MFC的 CString 学习笔记 -3

CString Class Research (3)

 

4. CStringData Allocate and dispose.

                In prior section, we know the CStringData has two Parts, One is Header, Include 3 member variables and 1 member function, totally 12 bytes, and the other part is actual data.

                Look the following code in MFC to Allocate and Dispose CStringData and its data buffer.

 

CStringData* pData; pData = (CStringData*)                                 new BYTE[sizeof(CStringData) + (nLen+1)*sizeof(TCHAR)]; pData->nAllocLength = nLen; pData->nRefs = 1; pData->data()[nLen] = '/0'; pData->nDataLength = nLen; m_pchData = pData->data();

                MFC allocate memory as BYTE array, include CStringData and data buffer, and convert it to CStringData pointer, nLen is the length of string, and one more byte, store a ‘/0’.

                In debug mode, when the nLen <= 64, system allocates 64 bytes, when the nLen <= 128, system allocates 128 bytes....

               

delete[] (BYTE*)pData;

                To dispose buffer, because there are CStringData part (header) and data buffer part, MFC convert the CStringData* to BYTE array, then delete it.

 

5. CString operator =.

                There are two methods to set one CString’s value. If the source string is not a CString object, then MFC will allocate a new buffer to destination CString object, and use memcpy function to copy the content of source string to destination CString.m_pchData.

AllocBeforeWrite(nSrcLen); memcpy(m_pchData, lpszSrcData, nSrcLen*sizeof(TCHAR)); GetData()->nDataLength = nSrcLen; m_pchData[nSrcLen] = '/0';

               

In addition, if the source string is CString Object, commonly, the destination CString.m_pchData point to source CString.m_pchData. That means, the destination CString.m_pchData and the source CSting.m_pchData will point to the same address, destination CString and the source CString has the same CStringData object.

                When 2 objects share one CStringData, the nRef member variable of CStringData will be set to 2.

If (m_pchData != stringSrc.m_pchData) {                 if ((GetData()->nRefs < 0 && GetData() != _afxDataNil) ||                                 stringSrc.GetData()->nRefs < 0)                 {                                 // actual copy necessary since one of the strings is locked                                 AssignCopy(stringSrc.GetData()->nDataLength, stringSrc.m_pchData);                 }                 else                 {                                 // can just copy references around                                 Release();                                 ASSERT(stringSrc.GetData() != _afxDataNil);                                 m_pchData = stringSrc.m_pchData;                                 InterlockedIncrement(&GetData()->nRefs);                 } }

                Two CString share one CStringData will save system memory resource, but there is a risk, that when data in CString object’s CStringData is changed, the other CString object will be changed at the same time, that may be is not we want.

                There is a function in MFC named CopyBeforeWrite to deal with this problem:

void CString::CopyBeforeWrite() {                 if (GetData()->nRefs > 1)                 {                                 CStringData* pData = GetData();                                 Release();                                 AllocBuffer(pData->nDataLength);                                 memcpy(m_pchData, pData->data(), (pData->nDataLength+1)*sizeof(TCHAR));                 }                 ASSERT(GetData()->nRefs <= 1); }

                When one CString’s value will be set, MFC will check if there is any other  CString share the same CStringData object with it. If the reference bigger than 1, that means at least 2 CString object reference this CStringData object. The current, will be changed CString must create a new CStringData object to store the new value.

                In the Release() function, if the reference bigger than 1, the buffer will not delete actually.

 

6. LockBuffer() and UnLockBuffer()

                LockBuffer will set nRef member to -1, and UnlockBuffer will set nRef member to 1.

                MSDN said: While in a locked state, the string is protected in two ways:

No other string can get a reference to the data in the locked string, even if that string is assigned to the locked string.   The locked string will never reference another string, even if that other string is copied to the locked string.

               

CString str1, str2;                 str2 = "abcde";                 str2.LockBuffer();                 str1 = str2;                   CString str3;                 str3 = "kk";                 str3.LockBuffer();                 str3 = str1;

                The str2’s buffer is locked, when set str1 equal to str2, a new buffer will created to store the str2’s value. str1 and str2 have different CStringData object.

               If the str3’s buffer is not locked, the str3 will share CStringData object with str1, but in this code, str3’s CStringData object is locked, MFC will copy the value of str1 to str3, the str3’s buffer address is not changed.

                Of course , when CString is initializion without init-value, MFC will set a system defined, empty CStringData object to it, the nRef is -1, so LockBuffer() and UnLockBuffer() is no use to system defined, empty CStringData object.