SEO		[PR] 爆速!無料ブログ 無料ホームページ開設 無料ライブ放送

               

---

dkutilTL.h

解説を見る。

#include "AllLoad.h"
//#include "dKingyoMemoryManager.h"


#ifndef __dKingyoTemplateLibrary__
#define __dKingyoTemplateLibrary__

namespace dkutil{
    namespace DTL{


//************************
//必殺！テンプレート集
//**************************


template<class T,class OBJ>
void GeneralPurposeFree(T func,OBJ obj)
{
    if(obj){func(obj);obj=NULL;}
}

template<class Result,class T>
Result GeneralPurposeMessage(T function,char *str,...){
    Result r;
    int c;
    static char s[c=1024+512];
    memset(s,'\0',sizeof(s));
    va_list VaList ;
    va_start( VaList , str) ;
    _vsnprintf( s ,c, str , VaList ) ;
    va_end( VaList ) ;
    r=(Result)function(s);
    return r;
}


//**********************************************************
//シングルトン用テンプレートクラス
//**********************************************************
template <class T>
class dk_singleton {
public:
    dk_singleton() {}
    ~dk_singleton() { Release(); }
    T& operator*() { return *get(); }
    T* operator->() { return get(); }
    T* get() { CheckInstance(); return m_lpObj; }
    bool    isNull() const { return m_lpObj == NULL; }
    void Release();
    void CheckInstance();
    void InsertThreadLockUnlockFunction(VOIDFUNC lock,VOIDFUNC unlock){
        m_lockfunc=lock;m_unlockfunc=unlock;
    }
protected:
    static T*   m_lpObj;
    static VOIDFUNC m_lockfunc,m_unlockfunc;
};


//  static なオブジェクト
template <class T> T* dk_singleton<T>::m_lpObj = 0;
template<class T> VOIDFUNC dk_singleton<T>::m_lockfunc = 0;
template<class T> VOIDFUNC dk_singleton<T>::m_unlockfunc = 0;

template <class T> void dk_singleton<T>::CheckInstance() {
    if (m_lpObj==NULL) {
        if(m_lockfunc !=NULL && m_unlockfunc != NULL){m_lockfunc();}
        if(m_lpObj==NULL){
            m_lpObj = new T;
        }
        if(m_lockfunc !=NULL && m_unlockfunc != NULL){m_unlockfunc();}
    }
}

template <class T> void dk_singleton<T>::Release() {
    if (m_lpObj!=NULL) {
        if(m_lockfunc !=NULL && m_unlockfunc != NULL){m_lockfunc();}
        if(m_lpObj!=NULL){      
            delete m_lpObj;
            m_lpObj = NULL;
        }
        if(m_lockfunc !=NULL && m_unlockfunc != NULL){m_unlockfunc();}
    }
}



template<DWORD n>
struct GetKB{
    public:
        enum{value=1024*n,};
        //int GetValue(){return value;}
};



template<class T>
inline T *GetSingleton(){
    static dk_singleton<T> g;
    return g.get();
}




//**********************************************************
//allocator
//**********************************************************
//address - アドレスを返す。 
//allocate - 領域を確保する。 
//deallocate - 領域を解放する。 
//construct - 領域にオブジェクトをコピーする。 
//destroy - オブジェクトにデストラクタを呼出す。 

template <class T> 
class dkutil_allocator {
protected:
public:
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
  typedef T*        pointer;
  typedef const T*  const_pointer;
  typedef T&        reference;
  typedef const T&  const_reference;
  typedef T         value_type;
  
    pointer       address(reference x) const
    { return &x; }
  const_pointer address(const_reference x) const
    { return &x; }
  pointer       allocate(size_type n, const void* hint = 0) {
    //cout << "allocate " << n << " of " << typeid(T).name() << endl;
    return new value_type[n];//new(n * sizeof(value_type));
    }
  void      deallocate(pointer p, size_type n = 0) {
    //cout << "deallocate " << n << " of " << typeid(T).name() << endl;
    //if( (p == 0) == (n == 0) ) MB("WHAT!!! deallocate error");
        if(p==NULL) MB("WHAT!!! deallocate error");

    delete [] p;
  }
  size_type max_size() const
    { return (size_t)-1 / sizeof(T); }
  void      construct(pointer p, const T& val) {
    //cout << "construct " << typeid(T).name()<< '(' << val << ')' << endl;
    new ((void*)p) T(val);
  }
  void      destroy(pointer p) {
   // cout << "destroy " << typeid(T).name() << endl;
  }
  char* _Charalloc(size_type n) {
    return allocate(n);
  }
};

//なんか、d金魚があほなことはじめましたなぁ普通にstd::vector使えよ！！？
template<class T,class A=dkutil_allocator<T> >
class basic_vector{
protected:
    T *t;//メモリ
    A a;//あろけぇた
    DWORD count;//今入れることの出来る領域の添え字
    DWORD count_max;//今確保している最大値
    enum{
        enuEXTEND_ARRAY_NUM = 10,
    };
public:
    basic_vector(){
        t=NULL;
        t=a.allocate(count_max=100);//とりあえず100個ほど^^;
        count=0;
    }
    virtual ~basic_vector(){
        a.deallocate(t,count_max);
    }
    void set_allocator(A *get){a=get;}
    T *data(){return t;}
    bool resize(DWORD num){
        if(t==NULL){
            t=a.allocate(count_max=100);
            if(t==NULL) return  false;
        }

        if(count_max >= num || num==0)//馬鹿値を入れた奴は排除
            return false;
        
        T *temp=a.allocate(num);
        if(!temp)
            return false;
        
        //こっちの方が速い。
        //しかし、classの=オペレータは呼ばれないので却下
        //memcpy((void *)temp,(const void *)t,sizeof(T)*count);

        DWORD i;
        for(i=0;i<count;i++){
            temp[i]=t[i];
        }
        a.deallocate(t,count_max);
        t=temp;
        count_max=num;
        return true;
    }

    int push_back(T set){
        if(count >= count_max)//大きくなってきたら
        {
            if(false==resize(count + enuEXTEND_ARRAY_NUM))
                return -1;
        }
        t[count++]=set;//入れます。
        return count;
    }
    int pop_back(){count--;}
    bool empty(){return (count==0);}
    DWORD now_count(){return count;}
    DWORD max_count(){return count_max;}
    bool isOK(){return (t!=NULL);}
    void clear(){
        memset((void *)t,NULL,sizeof(T)*count_max);
        count=0;
    }
    virtual int sort(){
        return -100;//実装されてません。
    }
};

#ifdef USE_DKINGYO_OBJECT_TEST
extern void basic_vector_test();
#endif


}//end of DTL
}//end of dkutil

#endif // end of __dKingyoTemplateLibrary__ defined

---