From 602f35faba23e8c29a54261228a083dfa3ce0b2f Mon Sep 17 00:00:00 2001 From: sauron Date: Sat, 13 Sep 2025 10:47:04 +0900 Subject: [PATCH] commit 2025-09-13 10:46 is coding ZCFreeHeapSngl::ZtCBody in ZCppMain/ZtCSimList.H --- ZCppMain/ZMainHead.H | 54 +++- ZCppMain/ZtCObjList.H | 2 +- ZCppMain/ZtCSimList.H | 742 +++++++++++++++++++++++++++++++++++++++++++++++--- 3 files changed, 754 insertions(+), 44 deletions(-) diff --git a/ZCppMain/ZMainHead.H b/ZCppMain/ZMainHead.H index a226d00..9437410 100644 --- a/ZCppMain/ZMainHead.H +++ b/ZCppMain/ZMainHead.H @@ -748,6 +748,18 @@ namespace ZNsMain namespace ZNsIFace*/ + namespace ZNsIFaceEx + { + // ZNsIFace 에는 주로 interface 가 있다면, + // ZNsIFaceEx 에는 실제로 동작하는 코드가 온다. + // 따라서 여기에 오는 클래스는 주로 ZNsIFace 에 이미 있는 것이다. + // 다만, ZNsIFace 의 클래스는 주로 ZI 로 시작한다면 + // ZNsIFaceEx 의 클래스는 주로 ZC 로 시작한다. + // -- 2025-09-13 01:06 + }/* + namespace ZNsIFaceEx*/ + + namespace ZNsEnum { @@ -2631,6 +2643,18 @@ namespace ZNsMain }/* namespace ZNsCRTP*/ + namespace ZNsHelp + { + /*////////////////////////////////////////////////// + + ■ 주로 특정 클래스에 도움이 되는 클래스는 여기에 둔다. + + -- 2025-09-13 00:59:00 + + //////////////////////////////////////////////////*/ + }/* + namespace ZNsHelp*/ + namespace ZNsFunc { @@ -3775,7 +3799,7 @@ namespace ZNsMain public: - template class ZtCDblList + template class ZtCBody { public: typedef typename TDblList::ZCLink ZCLink ; @@ -3812,8 +3836,34 @@ namespace ZNsMain void DeleteHeap(){} + + TypeSize GetUseHeapSize() const + { + return 0; + }/* + TypeSize GetUseHeapSize() const*/ + + TypeSize GetAllHeapSize() const + { + return 0; + }/* + TypeSize GetAllHeapSize() const*/ + + + TypeSize size() const + { + return GetUseHeapSize(); + }/* + TypeSize GetHeapSize() const*/ + + TypeSize capacity() const + { + return GetAllHeapSize(); + }/* + TypeSize GetHeapSize() const*/ + };/* - template class ZtCDblList*/ + template class ZtCBody*/ public: diff --git a/ZCppMain/ZtCObjList.H b/ZCppMain/ZtCObjList.H index e9c70c3..66e16f8 100644 --- a/ZCppMain/ZtCObjList.H +++ b/ZCppMain/ZtCObjList.H @@ -58,7 +58,7 @@ namespace ZNsMain typedef const ZCIterator const_iterator; public: typedef typename TFeeeHeap:: - template ZtCDblList ZCFreeHeap; + template ZtCBody ZCFreeHeap; public: diff --git a/ZCppMain/ZtCSimList.H b/ZCppMain/ZtCSimList.H index ba7c4a3..69415b4 100644 --- a/ZCppMain/ZtCSimList.H +++ b/ZCppMain/ZtCSimList.H @@ -10,6 +10,666 @@ namespace ZNsMain { + namespace ZNsIFaceEx + { + + class ZCFreeHeapSngl + { + + template class ZtCBody + { + public: + typedef typename ZtCBody::TypeData TypeData; + typedef typename ZtCBody::TypeSize TypeSize; + typedef typename ZtCBody::TypeInit TypeInit; + typedef typename ZtCBody::ZCLink ZCLink ; + public: + + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallInit mo_Mutex ; + #endif //_REENTRANT_MUTEX + + private: + TypeSize ml_AllSize ; + TypeSize ml_UseSize ; + + ZCLink* mp_NoUseHead ; + ZCLink* mp_NoUseTail ; + private: + + ZCLink* SendFreeOut() + { + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + #ifdef _DEBUG + ZNsMain::ZCCheckAlloc::ZCAllowAlloc CAllowAllocObj; + #endif //_DEBUG + + if(ml_UseSize==0) + { + ZCLink* VP_TempLink = new ZCLink ; + + if(TypeInit::ZEUseInit>0) + TypeInit::OnInit(VP_TempLink->mo_Data, *this); + + return (++ml_AllSize, VP_TempLink); + }/* + if(ml_UseSize==0)*/ + + + ZCLink* VP_TempLink=mp_NoUseHead; + + if(VP_TempLink==mp_NoUseTail) + { + mp_NoUseHead=0; + mp_NoUseTail=0; + } + else + { + mp_NoUseHead = mp_NoUseHead->mp_NextLink; + } + //else + + --ml_UseSize; return VP_TempLink; + }/* + ZCLink* SendFreeOut()*/ + + + void SendFreeOut /*#####################################################*/ + ( + TypeSize AL_LinkSize, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink + ) + /*######################################################################*/ + { + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + #ifdef _DEBUG + ZNsMain::ZCCheckAlloc::ZCAllowAlloc CAllowAllocObj; + #endif //_DEBUG + + if(mp_NoUseHead==0) + { + MakeLink(AL_LinkSize, APR_HeadLink, APR_TailLink); + } + else if(AL_LinkSize==ml_UseSize) + { + ZCLink* VP_Temp = mp_NoUseHead; + + while(true) + { + if(TypeInit::ZEUseInit>0) + TypeInit::OnInit(VP_Temp->mo_Data, *this); + + if(VP_Temp==mp_NoUseTail) + { break; } + + VP_Temp = VP_Temp->mp_NextLink; + }/* + while(true)*/ + + APR_HeadLink = mp_NoUseHead ; + APR_TailLink = mp_NoUseTail ; + + mp_NoUseHead =0 ; + mp_NoUseTail =0 ; + ml_UseSize =0 ; + } + else if(AL_LinkSize0) + TypeInit::OnInit(mp_NoUseHead->mo_Data, *this); + + for(TypeSize VL_Count=2; VL_Count<=AL_LinkSize; ++VL_Count) + { + // VL_Count 가 2 부터 시작함으로 AL_LinkSize-1 번 순환한다. + // 그래야지 AL_LinkSize 개의 링크를 자를 수 있다. + + mp_NoUseHead = mp_NoUseHead->mp_NextLink; + + if(TypeInit::ZEUseInit>0) + TypeInit::OnInit(mp_NoUseHead->mo_Data, *this); + }/* + for(TypeSize VL_Count=2; VL_Count<=AL_LinkSize; ++VL_Count)*/ + + APR_TailLink = mp_NoUseHead ; + mp_NoUseHead= mp_NoUseHead->mp_NextLink; + ml_UseSize -= AL_LinkSize ; + } + else // AL_LinkSize > ml_UseSize + { + ZCLink* VP_Temp=mp_NoUseHead; + + while(true) + { + if(VP_Temp==mp_NoUseTail) + { break; } + + VP_Temp=VP_Temp->mp_NextLink ; + } + //while(true) + + APR_HeadLink = mp_NoUseHead; + + // MakeLink() 에서 TypeInit::OnInit() 가 호출됨. + MakeLink( AL_LinkSize - ml_UseSize , + mp_NoUseTail->mp_NextLink, + APR_TailLink + /*****/ ); + + mp_NoUseHead= 0 ; + mp_NoUseTail= 0 ; + ml_UseSize = 0 ; + } + //else // AL_LinkSize > ml_UseSize + }/* + void SendFreeOut + ( + TypeSize AL_LinkSize, ZCLink*& APR_HeadLink, ZCLink*& APR_TailLink + ) + ########################################################################*/ + + + void SendFreeOutCopy /*////////////////////////////*/ + ( + ZCLink* AP_LinkOrgin, TypeSize AL_FarNum , + ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy + ) + /*/////////////////////////////////////////////////*/ + { + // AL_FarNum > 0 + // AP_LinkOrgin 링크부터, + // AP_LinkOrgin 에서 AL_FarNum 만큼 떨어진 링크까지를 복사하여 + // 복사생성된 처음 링크 포인터를 APR_HeadCopy 에, + // 마지막 링크를 APR_TailCopy 에 대입한다. + // AP_LinkOrgin 링크에서 그 다음 링크로 접근하면서 링크를 복사할 것이다. + // 따라서 총 AL_FarNum + 1 개의 링크가 만들어진다. + // 이 함수는 각 링크를 새로 생성하는 MakeLinkCopy() 함수와는 달리 + // 기존에 있는 ml_UseSize 개의 링크를 먼저 사용한다. + + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + #ifdef _DEBUG + ZNsMain::ZCCheckAlloc::ZCAllowAlloc CAllowAllocObj; + #endif //_DEBUG + + if(mp_NoUseHead==0) + { + MakeLinkCopy(AP_LinkOrgin, AL_FarNum, APR_HeadCopy, APR_TailCopy); + } + else if( AL_FarNum < ml_UseSize) // ( (AL_FarNum<0 ? -AL_FarNum : AL_FarNum)+1 <= ml_UseSize) + { + ml_UseSize -= AL_FarNum+1 ; + + mp_NoUseHead->mo_Data = AP_LinkOrgin->mo_Data ; + APR_HeadCopy = mp_NoUseHead ; + + while(--AL_FarNum>=0) + { + mp_NoUseHead = mp_NoUseHead->mp_NextLink ; + AP_LinkOrgin = AP_LinkOrgin->mp_NextLink ; + + mp_NoUseHead->mo_Data = AP_LinkOrgin->mo_Data; + } + //while(--AL_FarNum>=0) + + APR_TailCopy=mp_NoUseHead; + + // 이 부분에서 mp_NoUseHead 는 잘려나가는 마지막 링크가 된다. + // 그러므로 다시 다음 링크로 초기화한다. + + mp_NoUseHead=mp_NoUseHead->mp_NextLink; + + if(mp_NoUseHead==0) + { + mp_NoUseTail=0; + + // mp_NoUseHead == 0 인데 mp_NoUseTail !=0 이라면 + // 나중에 자칫 무한루프에 빠질 수 있다. + // 따라서 위 코드를 두었다. + } + //if(mp_NoUseHead==0) + } + else // AL_FarNum > ml_UseSize + { + mp_NoUseHead->mo_Data = AP_LinkOrgin->mo_Data ; + APR_HeadCopy = mp_NoUseHead ; + + while(mp_NoUseHead!=mp_NoUseTail) + { + mp_NoUseHead= mp_NoUseHead->mp_NextLink; + AP_LinkOrgin= AP_LinkOrgin->mp_NextLink; + + mp_NoUseHead->mo_Data = AP_LinkOrgin->mo_Data; + } + //while(mp_NoUseHead!=mp_NoUseTail) + + MakeLinkCopy /*++++++++++++++++++++++++++++++++++++++++++++*/ + ( + AP_LinkOrgin->mp_NextLink, AL_FarNum-ml_UseSize , + mp_NoUseTail->mp_NextLink, APR_TailCopy + ); + /*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + + mp_NoUseHead = + mp_NoUseTail = 0; + ml_UseSize = 0; + } + //else // AL_FarNum > ml_UseSize + }/* + void SendFreeOutCopy //////////////////////////////// + ( + ZCLink* AP_LinkOrgin, TypeSize AL_FarNum , + ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy + ) + ///////////////////////////////////////////////////*/ + + + void MakeLink /////////////////////////////////////// + ( + TypeSize AL_MakeSize , + ZCLink*& APR_HeadLink, + ZCLink*& APR_TailLink + ) + ///////////////////////////////////////////////////*/ + { + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + #ifdef _DEBUG + ZNsMain::ZCCheckAlloc::ZCAllowAlloc CAllowAllocObj; + #endif //_DEBUG + + APR_HeadLink = new ZCLink; + + if(APR_HeadLink==0) + { + //add codes for memory over + + DeleteHeap(); return; + }/* + if(APR_HeadLink==0)*/ + + if(TypeInit::ZEUseInit>0) + TypeInit::OnInit(APR_HeadLink->mo_Data, *this); + + ml_AllSize += AL_MakeSize; + + ZCLink* VP_MakeLink = 0 ; + ZCLink* VP_TempLink = APR_HeadLink; + bool VB_IsHeapOver= false ; + + // bool VB_IsHeapOver 은 new 연산자가 NULL 포인터를 반환했을 때 + // true 를 대입받는다. 이 값을 조사함으로써 heap overflow 를 처리한다. + // bool VB_IsHeapOver 변수를 두지 않고 + // 아래 for 문에서 직접 메모리 처리를 하는 코드를 둘 수 있으나 + // for 문 안에 if 문 속에서 또 for 문을 써야 함으로 + // 가독성이 떨어질 수가 있다. + // 그래서 heap over 에 대한 예외처리 코드를 + // for 문 바깥으로 빼려는 것이다. + + while(--AL_MakeSize>0) // AL_MakeSize - 1 번 순환 + { + // AL_MakeSize - 1 번 순환 + + VP_MakeLink = new ZCLink; + + if(VP_MakeLink==0) + { + ml_AllSize -= AL_MakeSize+1 ; + VB_IsHeapOver = true ; + + break; + }/* + if(VP_MakeLink==0)*/ + + if(TypeInit::ZEUseInit>0) + TypeInit::OnInit(VP_MakeLink->mo_Data, *this); + + VP_TempLink->mp_NextLink=VP_MakeLink ; + VP_TempLink =VP_MakeLink ; + }/* + while(--AL_MakeSize>0)*/ + + APR_TailLink = VP_TempLink; + + // 메모리를 더 이상 할당할 수 없었다면 + // 이미 만들어진 VL_Count 개의 비원형 이중 링크를 지운다. + + if(VB_IsHeapOver==true) + { + VP_TempLink=APR_HeadLink; + + // 이 시점에서 최소한 APR_HeadLink 하나는 + // heap 에 생성되어 있다. + + do ////// + { + delete VP_TempLink; + + if(VP_TempLink==APR_TailLink) + { + DeleteHeap(); + + // Add extra codes for memory over + + return; + }/* + if(VP_TempLink==APR_TailLink)*/ + + APR_HeadLink=APR_HeadLink->mp_NextLink; + } + while(true); + }/* + if(VB_IsHeapOver==true)*/ + }/* + void MakeLink /////////////////////////////////////// + ( + TypeSize AL_MakeSize , + ZCLink*& APR_HeadLink, + ZCLink*& APR_TailLink + ) + ///////////////////////////////////////////////////*/ + + + void MakeLinkCopy /////////////////////////////////// + ( + ZCLink* AP_LinkOrgin, TypeSize AL_FarNum , + ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy + ) + ///////////////////////////////////////////////////*/ + { + // AP_LinkOrgin 링크부터, + // AP_LinkOrgin 에서 AL_FarNum 만큼 떨어진 링크까지를 복사하여 + // 복사생성된 처음 링크 포인터를 APR_HeadCopy 에, + // 마지막 링크를 APR_TailCopy 에 대입한다. + // AL_FarNum > 0 , 총 AL_FarNum + 1 개의 링크가 만들어진다. + + + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + #ifdef _DEBUG + ZNsMain::ZCCheckAlloc::ZCAllowAlloc CAllowAllocObj; + #endif //_DEBUG + + ZCLink* VP_MakeLink = 0 ; + ZCLink* VP_TempLink = 0 ; + bool VB_IsHeapOver= false; + + VP_TempLink = \ + VP_MakeLink = new ZCLink(AP_LinkOrgin->mo_Data); + + ml_AllSize += AL_FarNum+1 ; + + if(VP_MakeLink==0) + { + //add codes for memory over + + ml_AllSize -= AL_FarNum+1; DeleteHeap(); + + return; ///////////////////////////////// + }/* + if(VP_MakeLink==0)*/ + + APR_HeadCopy=VP_MakeLink; + + while(--AL_FarNum >= 0) + { + AP_LinkOrgin= AP_LinkOrgin->mp_NextLink ; + VP_MakeLink = new ZCLink(AP_LinkOrgin->mo_Data); + + if(VP_MakeLink==0) + { + ml_AllSize -= AL_FarNum+1 ; + APR_TailCopy = VP_TempLink ; + VB_IsHeapOver= true ; + + break; + }/* + if(VP_MakeLink==0)*/ + + VP_TempLink->mp_NextLink= VP_MakeLink; + VP_TempLink = VP_MakeLink; + }/* + while(--AL_FarNum >= 0)*/ + + APR_TailCopy=VP_TempLink; + + // 메모리를 더 이상 할당할 수 없었다면 + // 이미 만들어진 비원형 이중 링크를 지운다. + + if(VB_IsHeapOver==true) + { + do ////// + { + delete APR_HeadCopy; + + if(APR_HeadCopy==APR_TailCopy) + { + DeleteHeap(); return; + }/* + if(APR_HeadCopy==APR_TailCopy)*/ + + APR_HeadCopy = APR_HeadCopy->mp_NextLink; + } + while(true); + }/* + if(VB_IsHeapOver==true)*/ + }/* + void MakeLinkCopy /////////////////////////////////// + ( + ZCLink* AP_LinkOrgin, TypeSize AL_FarNum, + ZCLink*& APR_HeadCopy, ZCLink*& APR_TailCopy + ) + ///////////////////////////////////////////////////*/ + + + void RecvFreeIn(ZCLink* AP_Link) + { + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + AP_Link->mp_NextLink=0; + + if(++ml_UseSize==1) // ml_UseSize 이 0 일때 + { + mp_NoUseHead = + mp_NoUseTail = AP_Link ; + } + else + { + // 새로운 링크는 mp_NoUseTail 다음에 붙인다. + + mp_NoUseTail->mp_NextLink= AP_Link; + mp_NoUseTail = AP_Link; + } + //else + + if(TypeInit::ZEUseFini>0) + TypeInit::OnFini(AP_Link->mo_Data, *this); + }/* + void RecvFreeIn(ZCLink* AP_Link)*/ + + void RecvFreeIn(ZCLink* AP_HeadLink, ZCLink* AP_TailLink, TypeSize AL_Count) + { + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + if(TypeInit::ZEUseFini>0) + { + ZCLink* VP_NowLink = AP_HeadLink; + + __for1(TypeSize, i, AL_Count) + { + TypeInit::OnFini(VP_NowLink->mo_Data, *this) ; + + VP_NowLink = VP_NowLink->mp_NextLink; + }/* + __for1(TypeSize, i, AL_Count)*/ + }/* + if(TypeInit::ZEUseFini>0)*/ + + + if(ml_UseSize==0) + { + mp_NoUseHead = AP_HeadLink ; + mp_NoUseTail = AP_TailLink ; + } + else + { + // 새로운 링크는 mp_NoUseTail 다음에 붙인다. + + mp_NoUseTail->mp_NextLink = AP_HeadLink; + mp_NoUseTail = AP_TailLink; + } + //else + + mp_NoUseTail->mp_NextLink=0; + ml_UseSize += AL_Count ; + }/* + void RecvFreeIn(ZCLink* AP_HeadLink, ZCLink* AP_TailLink, TypeSize AL_Count)*/ + + + //private: + public : + + + ZtCBody() + { + ml_AllSize = + ml_UseSize = 0 ; + + mp_NoUseHead = + mp_NoUseTail = 0 ; + + ZNsMain::GetCHeapAllocList().AddFreeAllocBase(*this); + }/* + ZtCBody()*/ + + ~ZtCBody() + { + #ifndef _SIMLIST_FREE_STORE_CHECK_ + + #ifdef _SIMLIST_FREE_STORE_LOG_ + + if( ml_UseSize>0 ) + { + std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app); + fileout<0 )*/ + + #endif //_SIMLIST_FREE_STORE_LOG_ + + return ; + + #endif //!_SIMLIST_FREE_STORE_CHECK_ + + if(ml_UseSize==0) return ; + + ZCLink* VP_DelLink=mp_NoUseHead; + + do ////// + { + mp_NoUseHead = + mp_NoUseHead->mp_NextLink; + + delete VP_DelLink; + + VP_DelLink = mp_NoUseHead ; + } + while(VP_DelLink!=0); + + ml_AllSize -= ml_UseSize ; + ml_UseSize = 0 ; + mp_NoUseHead = + mp_NoUseTail = 0 ; + }/* + ~ZtCBody()*/ + + + void DeleteHeap() + { + #ifdef _REENTRANT_MUTEX + ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); + #endif //_REENTRANT_MUTEX + + if(ml_UseSize==0) return ; + + ZCLink* VP_DelLink = mp_NoUseHead; + + do ////// + { + mp_NoUseHead = + mp_NoUseHead->mp_NextLink ; + + delete VP_DelLink; + + VP_DelLink = mp_NoUseHead ; + } + while(VP_DelLink!=0); + + ml_AllSize -= ml_UseSize; + ml_UseSize = 0 ; + mp_NoUseHead = + mp_NoUseTail = 0 ; + }/* + void DeleteHeap()*/ + + + TypeSize GetUseHeapSize() const + { + return ml_UseSize; + }/* + TypeSize GetUseHeapSize() const*/ + + TypeSize GetAllHeapSize() const + { + return ml_AllSize; + }/* + TypeSize GetAllHeapSize() const*/ + + TypeSize size() const + { + return ml_UseSize; + }/* + TypeSize size() const*/ + + TypeSize capacity() const + { + return ml_AllSize; + }/* + TypeSize capacity() const*/ + + //public: + }; + //template class ZtCBody + + + };/* + class ZCFreeHeapSngl*/ + + + }/* + namespace ZNsIFaceEx*/ + + + + template class ZtCSortObjList; @@ -36,7 +696,7 @@ namespace ZNsMain public: - class ZCLinkHeap; + class ZCFreeHeap; class ZCLink : public TypeAlloc @@ -44,7 +704,7 @@ namespace ZNsMain public: template friend class ZtCSortObjList ; friend class ZtCSimList ; - /*##########################*/ friend class ZCLinkHeap ; + /*##########################*/ friend class ZCFreeHeap ; public: @@ -229,7 +889,7 @@ namespace ZNsMain ////////////////////////////////////////////////// - class ZCLinkHeap : public ZCFreeAllocBase + class ZCFreeHeap : public ZCFreeAllocBase { public: friend class ZtCSimList ; @@ -522,7 +1182,7 @@ namespace ZNsMain ZCLink* VP_MakeLink = 0 ; ZCLink* VP_TempLink = APR_HeadLink; bool VB_IsHeapOver= false ; - + // bool VB_IsHeapOver 은 new 연산자가 NULL 포인터를 반환했을 때 // true 를 대입받는다. 이 값을 조사함으로써 heap overflow 를 처리한다. // bool VB_IsHeapOver 변수를 두지 않고 @@ -718,7 +1378,7 @@ namespace ZNsMain } //void ReceiveLink(ZCLink* AP_Link) - void ReceiveLink(ZCLink* AP_HeadLink, ZCLink* AP_TailLink, TTypSize AL_Count) + void ReceiveLink(TTypSize AL_Count, ZCLink* AP_HeadLink, ZCLink* AP_TailLink) { #ifdef _REENTRANT_MUTEX ZNsMain::ZCMutexSmallLock VO_ZCMutexSmallLock(mo_Mutex); @@ -756,14 +1416,14 @@ namespace ZNsMain mp_NoUseTailLink->mp_NextLink=0; ml_UseSize += AL_Count ; } - //void ReceiveLink(ZCLink* AP_HeadLink, ZCLink* AP_TailLink, TTypSize AL_Count) + //void ReceiveLink(TTypSize AL_Count, ZCLink* AP_HeadLink, ZCLink* AP_TailLink) //private: public : - ZCLinkHeap() + ZCFreeHeap() { ml_AllSize = ml_UseSize = 0 ; @@ -773,9 +1433,9 @@ namespace ZNsMain ZNsMain::GetCHeapAllocList().AddFreeAllocBase(*this); } - //ZCLinkHeap() + //ZCFreeHeap() - ~ZCLinkHeap() + ~ZCFreeHeap() { #ifndef _SIMLIST_FREE_STORE_CHECK_ @@ -785,7 +1445,7 @@ namespace ZNsMain { std::fstream fileout("DEBUG.txt",std::ios::out | std::ios::app); fileout<0 ) @@ -816,7 +1476,7 @@ namespace ZNsMain mp_NoUseHeadLink = mp_NoUseTailLink = 0 ; } - //~ZCLinkHeap() + //~ZCFreeHeap() void DeleteAllInHeap() @@ -848,23 +1508,23 @@ namespace ZNsMain //void DeleteAllInHeap() - TTypSize GetUseLinkSize() const + TTypSize GetUseHeapSize() const { return ml_UseSize; } - //TTypSize GetUseLinkSize() const + //TTypSize GetUseHeapSize() const - TTypSize GetAllLinkSize() const + TTypSize GetAllHeapSize() const { return ml_AllSize; } - //TTypSize GetAllLinkSize() const + //TTypSize GetAllHeapSize() const - long GetHeapSize() const + long size() const { return ml_UseSize; } - //long GetHeapSize() const + //long size() const long GetMemSize() const { @@ -874,12 +1534,12 @@ namespace ZNsMain //public: }; - //class ZCLinkHeap + //class ZCFreeHeap //////////////////////////////////////////////// - /************ end class ZCLinkHeap ************/ + /************ end class ZCFreeHeap ************/ //////////////////////////////////////////////// @@ -909,7 +1569,7 @@ namespace ZNsMain ZCLink* VP_HeadLink=0; ZCLink* VP_TailLink=0; - GetCLinkHeap().GetManyLinkCopy + GetCFreeHeap().GetManyLinkCopy ( const_cast(AP_CopyLink), // g++ 에서는 반드시 AP_CopyLink 부분을 () 로 묶어 줄 것. AL_FarNum , @@ -1079,7 +1739,7 @@ namespace ZNsMain ZCLink* VP_HeadLink=0; ZCLink* VP_TailLink=0; - GetCLinkHeap().GetManyLink + GetCFreeHeap().GetManyLink (AL_DefaultSize, VP_HeadLink, VP_TailLink); ZCLink::MakeCircle( VP_HeadLink, VP_TailLink ); @@ -1211,7 +1871,7 @@ namespace ZNsMain void AddHead(TypeArg AR_Type) { - ZCLink* VP_AddLink = GetCLinkHeap().GetOneLink() ; + ZCLink* VP_AddLink = GetCFreeHeap().GetOneLink() ; #if(_CODE_NEW_) if(TypeMoveObj::ZEUseMoveObj>0) //////////////////// @@ -1238,7 +1898,7 @@ namespace ZNsMain ZCLink* AddHeadDefault() { - ZCLink* VP_AddLink=GetCLinkHeap().GetOneLink(); + ZCLink* VP_AddLink=GetCFreeHeap().GetOneLink(); if(++ml_Size==1) // ml_Size==0 { @@ -1257,7 +1917,7 @@ namespace ZNsMain void AddTail(TypeArg AR_Type) { - ZCLink* VP_AddLink = GetCLinkHeap().GetOneLink(); + ZCLink* VP_AddLink = GetCFreeHeap().GetOneLink(); #if(_CODE_NEW_) if(TypeMoveObj::ZEUseMoveObj>0) //////////////////// @@ -1284,7 +1944,7 @@ namespace ZNsMain ZCLink* AddTailDefault() { - ZCLink* VP_AddLink = GetCLinkHeap().GetOneLink(); + ZCLink* VP_AddLink = GetCFreeHeap().GetOneLink(); if(++ml_Size==1) // ml_Size==0 { @@ -1638,7 +2298,7 @@ namespace ZNsMain ZCLink* VP_DelLink= mp_HeadLink ; mp_HeadLink = mp_HeadLink->mp_NextLink; - GetCLinkHeap().ReceiveLink(VP_DelLink); + GetCFreeHeap().ReceiveLink(VP_DelLink); if(--ml_Size==0) { @@ -1690,7 +2350,7 @@ namespace ZNsMain mp_HeadLink->GetNextPtr(ml_Size-1); mp_TailLink->mp_NextLink=0 ; - GetCLinkHeap().ReceiveLink(VP_CutLink); + GetCFreeHeap().ReceiveLink(VP_CutLink); }/* void DeleteTail()*/ @@ -1703,8 +2363,8 @@ namespace ZNsMain if(AL_DelSize==ml_Size) { - GetCLinkHeap().ReceiveLink - (mp_HeadLink, mp_TailLink, ml_Size); + GetCFreeHeap().ReceiveLink + (ml_Size, mp_HeadLink, mp_TailLink); mp_HeadLink=0 ; mp_TailLink=0 ; ml_Size =0 ; @@ -1715,8 +2375,8 @@ namespace ZNsMain ZCLink* VP_NewTail= mp_HeadLink-> GetNextPtr( ml_Size-AL_DelSize-1 ); - GetCLinkHeap().ReceiveLink - (VP_NewTail->mp_NextLink, mp_TailLink, AL_DelSize); + GetCFreeHeap().ReceiveLink + (AL_DelSize, VP_NewTail->mp_NextLink, mp_TailLink); mp_TailLink = VP_NewTail ; mp_TailLink-> mp_NextLink=0 ; @@ -1740,7 +2400,7 @@ namespace ZNsMain } #endif //_DEBUG - GetCLinkHeap().ReceiveLink + GetCFreeHeap().ReceiveLink ( CutLink(AP_PrevLink, AP_CutLink) ); }/* void Delete(ZCLink* AP_PrevLink, ZCLink* AP_CutLink)*/ @@ -1762,7 +2422,7 @@ namespace ZNsMain } #endif //_DEBUG - GetCLinkHeap().ReceiveLink + GetCFreeHeap().ReceiveLink ( CutLink(AP_PrevLink, AP_CutLink, AL_CutPos) ); }/* void Delete(ZCLink* AP_PrevLink, ZCLink* AP_CutLink, TTypSize AL_CutPos)*/ @@ -1818,8 +2478,8 @@ namespace ZNsMain { if(ml_Size==0) {return;} - GetCLinkHeap().ReceiveLink - (mp_HeadLink, mp_TailLink, ml_Size); + GetCFreeHeap().ReceiveLink + (ml_Size, mp_HeadLink, mp_TailLink); mp_HeadLink = mp_TailLink =0; @@ -1828,11 +2488,11 @@ namespace ZNsMain void DeleteAll()*/ - static void DeleteAllInHeap() + static void DeleteHeap() { - GetCLinkHeap().DeleteAllInHeap(); + GetCFreeHeap().DeleteHeap(); }/* - static void DeleteAllInHeap()*/ + static void DeleteHeap()*/ TTypSize Find(const ZCLink* AP_pSearchLink, TTypSize AL_FirstFindIndex=1) const @@ -1954,11 +2614,11 @@ namespace ZNsMain const ZCLink* GetLinkPtr(TTypSize AL_Index) const*/ - static ZCLinkHeap& GetCLinkHeap() + static ZCFreeHeap& GetCFreeHeap() { - static ZCLinkHeap SO_CLinkHeap; return SO_CLinkHeap; + static ZCFreeHeap SO_CLinkHeap; return SO_CLinkHeap; }/* - static ZCLinkHeap& GetCLinkHeap()*/ + static ZCFreeHeap& GetCFreeHeap()*/ inline TTypSize GetSize() const