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

               

---

dKingyoArrayManager.h

解説を見る。

#ifndef DKINGYO_ARRAY_MANAGER__
#define DKINGYO_ARRAY_MANAGER__


#include "AllLoad.h"



namespace dkutil{//begin dkutil
namespace memory{//begin memory



template<class T>
inline int ReallocateByNew(T **before,DWORD oldcount,T **after,DWORD extend,DWORD *aftercount)
{
    DWORD total = oldcount + extend;//合計の新規確保分
    T *get = new T[total];//maxcountはここで更新
    if(get==NULL){
        return -1;//だめじゃん！！最悪〜〜
    }
    //メモリコピー
    for(DWORD i=0;i<oldcount;i++){
        get[i]=(*before)[i];
    }
    //memcpyはC++のオブジェクトも出来るかどうか分からないので＾＾；

    delete[] (*before);//元のは開放
    (*after) = get;//アドレスを入れる。
    (*aftercount) = total;//合計の確保した数を入れる
    return 0;
}


template <class T,DWORD EXNTEND_ARRAY=100>//EXTEND_ARRAYはメモリを再確保する時の数
class dKingyoArrayOneByOneDynamic :public IdKingyoArrayOneByOne<T,DWORD *>{
protected:
    T *m;// M emory
    DWORD maxcount;//配列の最大数
    DWORD nowmp;//now  m point
    bool mflag;//is OK?
    //T **mp[100];//Memory Point;(空いている領域のポインタを入れておくところ)
    std::deque<DWORD > mp;//キューにする！？
    //DWORD nowmpp;//now mp point;
    enum{//,DWORD EXTEND_ARRAY=100
        enuExtendArray=EXNTEND_ARRAY,
    };
public:

    dKingyoArrayOneByOneDynamic(){
        maxcount=NULL;
        nowmp=NULL;
        m=NULL;
        mflag=false;
    }

    dKingyoArrayOneByOneDynamic(dKingyoArrayOneByOneDynamic<T> &a){
    mflag=false;
        maxcount = a.maxcount;
      nowmp = a.nowmp;
      getflag = a.getflag;
      mp = a.mp;
      if(a.maxcount > 0){
        m = new T[a.maxcount];
                if(!m){//例外発生しました！！
                    char *estr="dKingyoArrayOneByOneDynamicコピーコンストラクタ内:アホ〜〜〜　メモリ確保くらいしてよね！";
                    DK_THROW(estr) -1;
                    return;
                }
        for(int i = 0; i < a.maxcount; i++){//メモリコピー
                     *(m + i) = *(a.m + i);
        }
                //memcpy(m, a.m, a.maxcount);これだとC++のオブジェクトも出来るかどうかは不明
      }
      else{
        m = NULL;
      }
            mflag=true;//初期化済みやねん！
    }//まぁ、こんなものでよいかのぉ？

    virtual ~dKingyoArrayOneByOneDynamic(){
        End();
    }
    inline T *Data(){return m;};//恐ろしい関数だなぁ。直接アクセスだよ＾＾；

    inline DWORD DataMax(){return maxcount;}//配列の最大数
    virtual bool isOK(){return mflag;}//コンストラクタが成功したか？とか？
    virtual int End(){
        if(m){
            delete[] m;
            m=NULL;
        }
        
        maxcount=NULL;
        nowmp=NULL;
        m=NULL;
        mp.clear();//キューもすべて削除
        mflag=false;//フラグを下ろす
        return 0;
    }
    virtual int Compaction(){return DKINGYO_NOT_MOUNTED;//使われませんよ〜〜＾＾；
    }

    virtual int Init(size_t memory_count,int flag=0,T *p=NULL)
    //virtual int Init(size_t memory_count)
    {
        if(mflag==true)return 1;//もう一回呼び出しはダメです。
        maxcount=memory_count;
        //Dyanamic memoryだったらnewしかないでしょ＾＾；
        m = new T[memory_count];
        if(!m) return -1;//だめじゃんNULLじゃ

        mflag=true;//フラグを立てる
        
        return 0;
    }
    virtual int Reallocate(){
        if(mflag==false){
            if(-1==Init(100))//百個くらい＾＾；
                MessageBox(NULL,"ちゃんとこのクラスを使う時Init()してますか？","!最悪のパターンが発生!\n",MB_OK);
        }
        return ReallocateByNew<T>(&m,maxcount,&m,enuExtendArray,&maxcount);
        /*
        DWORD old=maxcount;
        T *get = new T[(maxcount=(DWORD)maxcount*2)];//maxcountはここで更新
        if(get==NULL){
            return -1;//だめじゃん！！最悪〜〜
        }
        if(old>=maxcount){
            MB("WHAT!!");
        }
        //初期化。
        memset((void *)get,0,sizeof(T)*maxcount);
        //メモリコピー
        for(DWORD i=0;i<old;i++){
            get[i]=m[i];
        }
        delete[] m;//元のは開放
        m = get;//アドレスを入れる。
        return 0;*/
    }

    T *GetArray(DWORD *ReleaseID){
        if(nowmp>=maxcount)
        {//ちょっとこのままじゃアクセスバイオレーションだ〜よ！
            if(mp.empty() )
            {//キューが空だったら？ 
                if(-1==Reallocate())//リアロックする。
                {
                    return NULL;//最悪〜〜失敗。
                }
                else//上手くできたようなので
                {
                    //PrintDebug("リアロックが成功！！再起呼び出し\n");
                    return GetArray(ReleaseID);//再起呼び出し
                }

            }
            else//キューの中身が空じゃなかったら
            {
                //DWORD l_num;//配列の添え字をゲットする
                *ReleaseID=(mp.front());//ってことでGET!
                mp.pop_front();//削除する
                PrintDebug("キューからげっど！　%d\n",*ReleaseID);
                
                return &m[(*ReleaseID)];
            }

        }else{
            //生の配列を返す
            *ReleaseID = nowmp;//しっかり入れとく
            PrintDebug("生配列ゲット %d \n",nowmp);
            return &m[nowmp++];
        }
        
        //実際、ありえないけど念のため書いておく^^;
        return NULL;
    }
    /*
    @param ReleaseID[in] GetArrayで得たハンドルを入れる
    @return 0は成功 0以外は失敗
    */
    virtual int ReleaseArray(DWORD *ReleaseID){
    #ifdef _DEBUG
        static int count=0;
        int itc=0;
        for(DWORD i=0;i<mp.size();i++){
            if(*ReleaseID==mp[i]){
                MessageBox(NULL,"ReleaseArray 重複だ！！！","重大なERROR",MB_OK);
            }
            itc++;
        }
        count++;
        
    #endif
        mp.push_back(*ReleaseID);//キューに空いている配列番号を記録(配列の添え字)
        PrintDebug("ReleaseArray呼び出し。ID=%d\n",*ReleaseID);
        return 0;
    }
    void PrintDebug(char *str,...){
    #ifdef _DEBUG
        char s[1024];
        SET_VA_LIST(s,1024,str);
        //OutputDebugString(s);
        //dAddLog("dKingyoArrayOnebyOneDynamicClassDebug.log",s);
    #endif
    }
    void DebugPrint(){
        std::deque<DWORD >::iterator it=mp.begin();

        PrintDebug("//__________________________\ndKingyoArraySupporter debug");
        char my[1024];
        //****日時を取得
        SYSTEMTIME lpSystemTime={0};
        GetSystemTime(
          &lpSystemTime   // address of system time structure
        );
        _snprintf(my,1024,
          "//BEGIN_dKingyoArraySupporter Class Test/year=%d month=%d day=%d hour=%d minute=%d second=%d\n",
          lpSystemTime.wYear,
          lpSystemTime.wMonth,
          lpSystemTime.wDay,
          lpSystemTime.wHour,
          lpSystemTime.wMinute,
          lpSystemTime.wSecond
          );

        PrintDebug(my);
        PrintDebug("maxcount=%d,nowmp=%d",maxcount,nowmp);
        for(UINT i=0;i<maxcount;i++){
            PrintDebug("Vector Memory NO=%d,Value=%d",i,m[i]);
        }
        for(;it!=mp.end();it++){
            PrintDebug("Free Memory ArrayNum=%d\n",(*it));
        }
        PrintDebug("//____________END__________DEBUG \n");
    }
};


template <class T>
class dKingyoArrayOneByOneStatic : public IdKingyoArrayOneByOne<T,DWORD *>{
private:
    //コピーコンストラクタ//コピーは出来ない
    dKingyoArrayOneByOneStatic(dKingyoArrayOneByOneStatic<T> &a){}
protected:
    T *m;// M emory
    DWORD maxcount;//配列の最大数
    DWORD nowmp;//now  m point
    bool mflag;//is OK?
    //T **mp[100];//Memory Point;(空いている領域のポインタを入れておくところ)
    std::deque<DWORD > mp;//キューにする！？
    //DWORD nowmpp;//now mp point;
public:

    dKingyoArrayOneByOneStatic(){
        maxcount=NULL;
        nowmp=NULL;
        m=NULL;
        mflag=false;
    }
    

    virtual ~dKingyoArrayOneByOneStatic(){
        End();
    }
    inline T *Data(){return m;};//恐ろしい関数だなぁ。直接アクセスだよ＾＾；
    inline DWORD DataMax(){return maxcount;}//配列の最大数
    virtual bool isOK(){return mflag;}
    virtual int End(){
        maxcount=NULL;
        nowmp=NULL;
        m=NULL;
        mp.clear();//キューもすべて削除
        mflag=false;//フラグを下ろす
        return 0;
    }
    virtual int Compaction(){return -100;//使われませんよ〜〜＾＾；
    }
    virtual int Init(size_t memory_count,int flag=0,T *p=NULL)
    {
        if(mflag==true)return 1;//もう一回呼び出しはダメです。
        maxcount=memory_count;
        m = p;//STATIC　メモリだからポインタよこして〜な！
        if(!m) return -1;//だめじゃんNULLじゃ

        mflag=true;//フラグを立てる
        
        return 0;
    }
    virtual int Reallocate(){
        return -100;//使われないものを呼ばないでね！！
    }
    T *GetArray(DWORD *ReleaseID){
        if(nowmp>=maxcount)
        {//ちょっとこのままじゃアクセスバイオレーションだ〜よ！
            if(mp.empty() )
            {//キューが空らしい
                    return NULL;//空だから最悪〜〜失敗
            }
            else//キューの中身が空じゃなかったら
            {
                //DWORD l_num;//配列の添え字をゲットする
                *ReleaseID=(mp.front());//ってことでGET!
                mp.pop_front();//削除する
                PrintDebug("キューからげっど！　%d\n",*ReleaseID);
                
                return &m[(*ReleaseID)];
            }

        }else{
            //生の配列を返す
            *ReleaseID = nowmp;//しっかり入れとく
            PrintDebug("生配列ゲット %d \n",nowmp);
            return &m[nowmp++];
        }
        
        //実際、ありえないけど念のため書いておく^^;
        return NULL;
    }
    virtual int ReleaseArray(DWORD *ReleaseID){
    #ifdef _DEBUG
        static int count=0;
        int itc=0;
        for(DWORD i=0;i<mp.size();i++){
            if(*ReleaseID==mp[i]){
                ;
                ;
                MessageBox(NULL,"ReleaseArray 重複だ！！！","重大なERROR",MB_OK);
            }
            itc++;
        }
        count++;
        
    #endif
        mp.push_back(*ReleaseID);//キューに空いている配列番号を記録(配列の添え字)
        PrintDebug("ReleaseArray呼び出し。ID=%d\n",*ReleaseID);
        return 0;
    }
    void PrintDebug(char *str,...){
    #ifdef _DEBUG
        char s[1024];
        SET_VA_LIST(s,1024,str);
        //OutputDebugString(s);
        //dAddLog("dKingyoArrayOnebyOneStaticClassDebug.log",s);
    #endif
    }
    void DebugPrint(){
        std::deque<DWORD >::iterator it=mp.begin();

        PrintDebug("//__________________________\ndKingyoArraySupporter debug");
        char my[1024];
        //****日時を取得
        SYSTEMTIME lpSystemTime={0};
        GetSystemTime(
          &lpSystemTime   // address of system time structure
        );
        _snprintf(my,1024,
          "//BEGIN_dKingyoArraySupporter Class Test/year=%d month=%d day=%d hour=%d minute=%d second=%d\n",
          lpSystemTime.wYear,
          lpSystemTime.wMonth,
          lpSystemTime.wDay,
          lpSystemTime.wHour,
          lpSystemTime.wMinute,
          lpSystemTime.wSecond
          );

        PrintDebug(my);
        PrintDebug("maxcount=%d,nowmp=%d",maxcount,nowmp);
        for(UINT i=0;i<maxcount;i++){
            PrintDebug("Vector Memory NO=%d,Value=%d",i,m[i]);
        }
        for(;it!=mp.end();it++){
            PrintDebug("Free Memory ArrayNum=%d\n",(*it));
        }
        PrintDebug("//____________END__________DEBUG \n");
    }
};

/*
template<class T,DWORD EXNTEND_ARRAY>
class dKingyoArray : public IdKingyoArray<T>{
protected:
    enum{
        enuExtendArray=EXTEND_ARRAY,
    };
    T *m_a;//array of member
    DWORD maxcount;//配列の最大数
    DWORD nowmp;//now  m point
    bool mflag;//is OK?
    std::deque<tugFreeDomainArray > mp;//すでに開放済み領域をキューにする
    std::deque<tugFreeDomainArray > m_re;//すでに確保済みの領域をキューにする
public:
    inline T *Data(){return m_a;};//恐ろしい関数だなぁ。直接アクセスだよ＾＾；
    inline DWORD DataMax(){return maxcount;}//配列の最大数
    dKingyoArray(){
        m_a=NULL;maxcount=0;nowmp=0;mflag=false;
        mp.clear();
    };
    
    virtual ~dKingyoArray(){
        AllFree();
    }
    virtual int ReallocateMemory(){
        return ReallocateByNew(m_a,maxcount,m_a,enuExtendArray,&maxcount);
    }
    virtual int Init(size_t count,int,void *){
        if(!count) return -1;//サイズが0ならエラーで返す
        if(mflag) return 1;//初期化済みなら返す

        m = new T[count];
        if(!m) return -1;//メモリ確保できない

        maxcount = count;//マックスカウントこれ以上アクセスするな！

        return 0;
    }
    virtual T *GetArray(size_t num,FREEDOMAINARRAY *ReleaseID){
        if(!mflag){//初期化できてないやん！
            if(0 != Init(enuExtendArray,NULL,NULL))
                return NULL;
        }

        if(nowmp>=maxcount)
        {//ちょっとこのままじゃアクセスバイオレーションだ〜よ！
            if(mp.empty() )
            {//キューが空らしい
                if(0 != ReallocateMemory()){//リアロックする
                    return NULL;//最悪〜〜
                }else{//上手く出来たようなので再起呼び出し
                    return GetArray(num,ReleaseID);
                }
            }
            else//キューの中身が空じゃなかったら
            {
                //DWORD l_num;//配列の添え字をゲットする
                FREEDOMAINARRAY atemp;
                
                atemp=(mp.front());//ってことでGET!
                mp.pop_front();//削除する
                PrintDebug("キューからげっど！No : %d\n",atemp.point);
                *ReleaseID = atemp.point;
                return &m[atemp.point];
            }

        }else{
            //生の配列を返す
            *ReleaseID = nowmp;//しっかり入れとく
            PrintDebug("生配列ゲット %d \n",nowmp);
            return &m[nowmp++];
        }
        
        //実際、ありえないけど念のため書いておく^^;
        return NULL;
    }

    virtual int ReleaseArray(DWORD *ReleaseID,T *Original){
        if(!mflag) return -1;//初期化くらいしろよ！
#   ifdef _DEBUG
        for(DWORD i=0;i<mp.size();i++){
            if(*ReleaseID== mp[i].point){
                MessageBox(NULL,"ReleaseArray 重複だ！！！","重大なERROR",MB_OK);
            }
        }
#endif
        mp.push_back(*ReleaseID);//キューに空いている配列番号を記録(配列の添え字)
        PrintDebug("ReleaseArray呼び出し。ID=%d\n",*ReleaseID);
    virtual int Compaction() = 0;
    virtual int AllFree() = 0;
    virtual void PRINT_DEBUG(char *str,...) = 0;
    virtual void DEBUG_PRINT() = 0;
    virtual bool isOK(){return mflag;}
};





//**********************************************************
//**********************************************************

template<class T,DWORD = EXTEND_ARRAY = 100>
class dKingyoObjectPool{
public:
    //enum{
    //  enuExtendArray=EXTEND_ARRAY,
    //};
    inline void *operator new(size_t size){
    }
    inline void *operator new[](size_t size){
    }
    inline void operator delete[](void* obj){
    }
    inline void operator delete(void* obj){
    }
*/









#ifdef USE_DKINGYO_OBJECT_TEST

extern void MemoryTest3__new_vs_dKingyoArrayOneByOneDynamic();
extern void MemoryTest2__();
extern void MemoryTest__();
extern void MemoryTest4__malloc_vs_OneByOne();

#endif //end of USE_DKINGYO_OBJECT_TEST

}//end of memory
}//end of dkutil

#endif  // DKINGYO_ARRAY_MANAGER__  end of once include

---