MFC的CString(VC6) 記憶體管理分析

來源:互聯網
上載者:User

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方法上.

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.