CString 類是我們經常用到的類,所以有必要對它的記憶體管理員模式分析一下.
CString 記憶體管理的演變過程如下:
VC5 單純的使用new delete方法。
因為字串操作需要頻繁調整記憶體大小.而採用C++操作符 new 與 delete
是沒有與realloc相應功能的。結果就是每一次的改變記憶體大小都需要額外
增加一次拷貝操作。
而 new 與delete 在實現中在進程堆中分配。頻繁地在堆上進行小記憶體配置與釋放
必然在堆上產生大量片段。堆片段過多直接影響了程式效率。
於是MFC在VC6版本對此進行了改進。
VC6 對於大於512位元組的記憶體和DEBUG模式下,CString仍然使用 new 和 delete來操縱。
在Release模式下不大於512位元組的記憶體配置操作採用了記憶體池管理。
並將之細分為 <=64, <=128, <=256, <=512 位元組4個記憶體池管理。
這樣在不大於512位元組的情況下CString有了很好的效率。
但是傳說中有解決一個BUG就會產生另外一個BUG的定律。
CString 顯然也無法避免它。
於是在VC7中又改了。
VC7 恢複使用C 的記憶體管理調用方式。即採用 alloc, free, realloc. CString存在的問題
就是由於new與delete沒有realloc重新調整記憶體大小的功能。之前產生的問題導致最終
還是採用了C的管理方法。在VC6中為瞭解決CString小記憶體操縱的效能問題 MFC在Release版本下對於不大於512位元組的記憶體配置
採用的記憶體池管理來進行最佳化。其他情況下仍舊使用new 與delete.Release版本下CString在處理不大於512Byte字串的記憶體時調用如下
VC6 中CString 分配記憶體與釋放記憶體調用次序如下CString::AllocBuffer
CFixedAlloc::Alloc
CPlex::CreateCString::FreeData
CFixedAlloc::Free
=========================================================================================
相關代碼引用如下:
FILE:MFCSRCSTRCORE.CPP
void CString::AllocBuffer(int nLen) //用來分配記憶體
{
...
#ifndef _DEBUG // 在Release 版本並且是不大於512位元組
if (nLen <= 64)
{
pData = (CStringData*)_afxAlloc64.Alloc();
pData- >nAllocLength = 64;
}
else 分別為 <= 1128, <=256 , <=512
{
...
}
else
#endif // DEBUG 和Release下大於512的
{
pData = (CStringData*)
new BYTE[sizeof(CStringData) + (nLen+1)*sizeof(TCHAR)];
pData- >nAllocLength = nLen;
}
...
}void FASTCALL CString::FreeData(CStringData* pData) // 釋放記憶體
{
#ifndef _DEBUG 在Release 版本並且是不大於512位元組
int nLen = pData- >nAllocLength;
if (nLen == 64) // 根據記憶體大小分別調用管理器
_afxAlloc64.Free(pData);
else if (nLen == 128)
_afxAlloc128.Free(pData);
else if (nLen == 256)
_afxAlloc256.Free(pData);
else if (nLen == 512)
_afxAlloc512.Free(pData);
else
{
ASSERT(nLen > 512);
delete[] (BYTE*)pData;
}
#else // DEBUG 和Release下大於512的
delete[] (BYTE*)pData;
#endif
}_afxAlloc[64,128,256,512] 是CFixedAlloc類的全域對象。我們分析一下CFixedAlloc是整樣進行記憶體池管理的它在使用中又產生了什麼問題?
class CFixedAlloc //定義在 MFCSRCFIXALLOC.H檔案中
{
public:
CFixedAlloc(UINT nAllocSize, UINT nBlockSize = 64);
UINT GetAllocSize() { return m_nAllocSize; }
public:
void* Alloc(); //分配 由CString調用
void Free(void* p); //釋放 由CString調用
void FreeAll(); //釋放所有 被解構函式調用
public:
~CFixedAlloc();
protected:
struct CNode{//這個是用來實現一個單向鏈表
CNode* pNext;
};
UINT m_nAllocSize; // 需要指派至的大小僅由建構函式傳入
UINT m_nBlockSize; // 預分配的數目即池的大小,由建構函式賦予,可知預設為64
CPlex* m_pBlocks; // 池的鏈表指標。CPlex對象含有一個CPlex* pNext指標對象,
CNode* m_pNodeFree; // 被釋放塊鏈表的頭指標,實際是應看做可用記憶體塊鏈表
CRITICAL_SECTION m_protect;//臨界區對象
};/*
在Alloc的實現中我們可以看到,當池中沒有可用塊的時候
調用 CPlex::Create建立一塊 m_nAllocSize * m_nBlockSize的記憶體池
如果有的話則從m_pNodeFree中彈出一塊來使用
*/
void* CFixedAlloc::Alloc()
{
if (m_pNodeFree == NULL){ //如果沒有可用的記憶體塊就進行分配一個池
CPlex* pNewBlock = NULL;
TRY{ // 分配記憶體塊 預設是64個m_nAllocSize.
pNewBlock = CPlex::Create(m_pBlocks, m_nBlockSize, m_nAllocSize);
}CATCH_ALL(e){
...異常
}END_CATCH_ALL
// 下面的代碼是將記憶體塊壓入m_pNodeFree鏈表中待用。
CNode* pNode = (CNode*)pNewBlock- >data();
(BYTE* &)pNode += (m_nAllocSize * m_nBlockSize) - m_nAllocSize;
for (int i = m_nBlockSize-1; i >= 0; i--, (BYTE*&)pNode -= m_nAllocSize)
{
pNode- >pNext = m_pNodeFree;
m_pNodeFree = pNode;
}
}
// 這兩句是彈出一塊記憶體給調用者使用。
void* pNode = m_pNodeFree;
m_pNodeFree = m_pNodeFree- >pNext;
...
return pNode;
}
/*
當調用者調用Free時,只是將這塊記憶體重新壓入m_pNodeFree鏈表中
並非釋放,而是標誌為可用塊以待後用。
*/
void CFixedAlloc::Free(void* p)
{
if (p != NULL)
{
EnterCriticalSection( &m_protect);
CNode* pNode = (CNode*)p;
pNode- >pNext = m_pNodeFree;
m_pNodeFree = pNode;
LeaveCriticalSection( &m_protect);
}
}
void CFixedAlloc::FreeAll()
{
EnterCriticalSection( &m_protect);
m_pBlocks- >FreeDataChain();
m_pBlocks = NULL;
m_pNodeFree = NULL;
LeaveCriticalSection( &m_protect);
}
/*
在解構函式中 調用FreeAll進行釋放記憶體
*/
CFixedAlloc::~CFixedAlloc()
{
FreeAll();
DeleteCriticalSection( &m_protect);
}
/*
MFCINCLUDEAFXPLEX_.H
*/
struct CPlex // warning variable length structure
{
CPlex* pNext;
void* data() { return this+1; }
static CPlex* PASCAL Create(CPlex* & head, UINT nMax, UINT cbElement);
void FreeDataChain(); // free this one and links
};/*
MFCSRCPLEX.CPP
*/
CPlex* PASCAL CPlex::Create(CPlex*& pHead, UINT nMax, UINT cbElement)
{
CPlex* p = (CPlex*) new BYTE[sizeof(CPlex) + nMax * cbElement];
p- >pNext = pHead;
pHead = p; // 加入鏈表
return p;
}
void CPlex::FreeDataChain() // free this one and links
{
CPlex* p = this;
while (p != NULL){
BYTE* bytes = (BYTE*) p;
CPlex* pNext = p- >pNext;
delete[] bytes;
p = pNext;
}
}============================================================================
現在我們用一個執行個體來看一下在Release版本下的實際記憶體動作以分配10000個 含有"abcdefghijklmnopqrstuvwxyz"串的CString數組CString * strArray[10000];for( int =0;i < 10000; i++ )
strArray[i] = new CString( "abcdefghijklmnopqrstuvwxyz");因為字串小於64所以調用了_afxAlloc64::Alloc;----------------------------------------------------------------
_afxAlloc64在STRCORE.CPP中被定義如下:
AFX_STATIC CFixedAlloc _afxAlloc64(ROUND4(65*sizeof(TCHAR)+sizeof(CStringData)));在ANSI版本下 sizeof(TCHAR) = 1
sizeof( CStrginData ) = 12;
65*sizeof(TCHAR)+sizeof(CStringData) = 77;ROUND4定義用下,將之圓整為4的倍數,
#define ROUND(x,y) (((x)+(y-1))&~(y-1))
#define ROUND4(x) ROUND(x, 4)
所以
_afxAlloc64(ROUND4(65*sizeof(TCHAR)+sizeof(CStringData))) 實際上
宏展開最終為
extern CFixedAlloc _afxAlloc64( 80,64);
----------------------------------------------------------------在CPlex中分配池的大小
sizeof(CPlex) + nMax * cbElement = 4+80*64 = 5124 BYTE.因為10000不是64的整數倍 = 要分配157個池
實際分配記憶體 = 157*5124 = 804468 BYTE = 804KB.釋放CString對象
for( int =0;i < 10000; i++ )
delete strArray[i];此時CString 的調用_afxAlloc64.Free.由CFixedAlloc::Free的實現可知此時並沒有真正釋放記憶體,只是將這該塊重新加入m_pNodeFree鏈表中待用.因為CFixedAlloc釋放記憶體操作是在解構函式調用,而_afxAlloc64是被定義為全域對象.它的解構函式要到程式退出才能被調用.所以CFixedAlloc分配的記憶體在程式結束之前只會增加而不能回收.而如果我們重新分配10000個 字串 >64 <=128的的CString對象時
_afxAlloc64的記憶體佔用依舊,而_afxAlloc128則重新分配了 157*(4+144*64) = 157*9220=1447540= 1.44754MB
再釋放它,此時記憶體佔用則為 1.44754MB+804KB = 2.252008MB.與使用char*對象做比較:char* chArray[10000];
分配 "abcdefghijklmnopqrstuvwxyz" 實際記憶體是 27*10000 = 270KB
釋放後記憶體即被回收
再分配128字串 10000個 記憶體是 129*10000 = 1.29MB.
釋放後記憶體即被回收
結論:
VC6中的CString採用記憶體池技術在改進小記憶體new與delete的效能與堆片段問題後
又產生了一個不是記憶體泄露的記憶體泄露。其實VC5,VC6中CString產生的問題是因為教條地遵守C++應當採用new與delete來管理記憶體的規則造成的最終在VC7中 CString仍舊回到使用C方法上.