从内存构造开始说起

我们定义一个CString变量，虽然我们工程用的是Unicode设置。但是”abc”是ANSI字符串。因为我们没有加_T限制啊。

CString str("abc");

由此宏

typedef ATL::CStringT< TCHAR, StrTraitMFC< TCHAR > > CString; CSTRING_EXPLICIT CStringT(_In_opt_z_ const YCHAR* pszSrc) : CThisSimpleString( StringTraits::GetDefaultManager() ) { if( !CheckImplicitLoad( pszSrc ) ) { *this = pszSrc; } }

StringTraits就是上面的的那个StrTraitMFC模板类。

static ATL::IAtlStringMgr* GetDefaultManager() throw() { return( AfxGetStringManager() ); } IAtlStringMgr* AFXAPI AfxGetStringManager() { return &afxStringManager; }

这个afxStringManager是一个全局变量。对，每个CString居然对应同一个字符串管理器。

CAfxStringMgr afxStringManager;

下面进入CSTringT的父类CSimpleStringT这个构造函数。

explicit CSimpleStringT(_Inout_ IAtlStringMgr* pStringMgr) { ATLENSURE( pStringMgr != NULL ); CStringData* pData = pStringMgr->GetNilString(); Attach( pData ); }

这个pStringMgr指向刚才那个全局的afxStringManager。

CStringData* CAfxStringMgr::GetNilString() throw() { m_nil.AddRef(); return &m_nil; }

m_nil是一个全局变量afxStringManager的成员变量，那么它也是全局的喽。

在这里面m_nil的成员变量+1，表示有多少个CSTring变量用到了此CStringData，即m_nil。

void AddRef() throw() { ATLASSERT(nRefs > 0); AtlInterlockedIncrement(&nRefs); }

再把此CStringData关联到我们的CSimpleStringT。

void Attach(_Inout_ CStringData* pData) throw() { m_pszData = static_cast< PXSTR >( pData->data() ); }

CSimpleStringT类中定义了成员变量：PXSTR m_pszData;在Unicode环境下，但我们传的是ANSI字符，所以PXSTR应该是char*类型。

看看的CStringData的data函数，返回的是一个sizeof( CStringData )大小后面的内存。那一块内存放着我们的字符串。那岂不是现在有N个CString变量共享这块内存？是的，后面继续看。

void* data() throw() { return (this+1); }

返回到StringT的构造函数，来看这一句,*this = pszSrc;然后进入赋值构造函数：

CStringT& operator=(_In_opt_z_ PCYSTR pszSrc) { // nDestLength is in XCHARs int nDestLength = (pszSrc != NULL) ? StringTraits::GetBaseTypeLength( pszSrc ) : 0; if( nDestLength > 0 ) { PXSTR pszBuffer = GetBuffer( nDestLength ); StringTraits::ConvertToBaseType( pszBuffer, nDestLength, pszSrc); ReleaseBufferSetLength( nDestLength ); } else { Empty(); } return( *this ); }

nDestLength ，就是多字节字符串转换为宽字符字符串后的字符数，比如多字节的”abc”转为宽字节后，nDestLength 的值为3。

static int __cdecl GetBaseTypeLength(_In_z_ LPCSTR pszSrc) throw() { // Returns required buffer size in wchar_ts return ::MultiByteToWideChar( _AtlGetConversionACP(), 0, pszSrc, -1, NULL, 0 )-1; }

然后看看CSimpleStringT的重量级成员函数吧：

_Ret_cap_(nMinBufferLength + 1) PXSTR GetBuffer(_In_ int nMinBufferLength) { return( PrepareWrite( nMinBufferLength ) ); } PXSTR PrepareWrite(_In_ int nLength) { if (nLength < 0) AtlThrow(E_INVALIDARG); CStringData* pOldData = GetData(); int nShared = 1-pOldData->nRefs; // nShared < 0 means true, >= 0 means false int nTooShort = pOldData->nAllocLength-nLength; // nTooShort < 0 means true, >= 0 means false if( (nShared|nTooShort) < 0 ) // If either sign bit is set (i.e. either is less than zero), we need to copy data { PrepareWrite2( nLength ); } return( m_pszData ); }

nRefs变量至少被现在我们的str变量AddRef了一次，所以至少为1，若是大于一，说明和其它一个变量share，但是share的话，只能共读，不能共写（共写的话岂不是一份内存要保存两份字符串，矛盾了）。而我们这个函数叫PrepareWrite，要Write了。只有nRefs==1，或<1(有<1这种情况吗？)并且nAllocLength>nLength（已分配内存大于要分配内存）的情况才不会进入PrepareWrite2。

ATL_NOINLINE void PrepareWrite2(_In_ int nLength) { CStringData* pOldData = GetData(); if( pOldData->nDataLength > nLength ) { nLength = pOldData->nDataLength; } if( pOldData->IsShared() ) { Fork( nLength ); } else if( pOldData->nAllocLength < nLength ) { // Grow exponentially, until we hit 1G, then by 1M thereafter. int nNewLength = pOldData->nAllocLength; if( nNewLength > 1024 * 1024 * 1024 ) { nNewLength += 1024 * 1024; } else { // Exponential growth factor is 1.5. nNewLength = nNewLength + nNewLength / 2; } if( nNewLength < nLength ) { nNewLength = nLength; } Reallocate( nNewLength ); } }

我们这边会进入Fork( nLength )这个分支。

ATL_NOINLINE void Fork(_In_ int nLength) { CStringData* pOldData = GetData(); int nOldLength = pOldData->nDataLength; CStringData* pNewData = pOldData->pStringMgr->Clone()->Allocate( nLength, sizeof( XCHAR ) ); if( pNewData == NULL ) { ThrowMemoryException(); } int nCharsToCopy = ((nOldLength < nLength) ? nOldLength : nLength)+1; // Copy '\0' CopyChars( PXSTR( pNewData->data() ), nCharsToCopy,PCXSTR( pOldData->data() ), nCharsToCopy ); pNewData->nDataLength = nOldLength; pOldData->Release(); Attach( pNewData ); } IAtlStringMgr* CAfxStringMgr::Clone() throw() { return this; }

从这个Clone()就可以看出IAtlStringMgr还是之前全局的那个。

CStringData* CAfxStringMgr::Allocate( int nChars, int nCharSize ) throw() { size_t nTotalSize; CStringData* pData; size_t nDataBytes; ASSERT(nCharSize > 0); if(nChars < 0) { ASSERT(FALSE); return NULL; } nDataBytes = (nChars+1)*nCharSize; nTotalSize = sizeof( CStringData )+nDataBytes; pData = (CStringData*)malloc( nTotalSize ); if (pData == NULL) return NULL; pData->pStringMgr = this; pData->nRefs = 1; pData->nAllocLength = nChars; pData->nDataLength = 0; return pData; }

我们这边的”abc”是多字节，但是我们的工程是Unicode的，所以最终我们的字符以Unicode格式存储于内存。nCharSize 此处则为2。多分配了sizeof( CStringData )，以存放CStringData 信息，这里存放的不是一个CStringData 指针哟，而是sizeof( CStringData )大的内存，以存放一整个CStringData信息。不过要注意的一点是，nAllocLength 为字符数，而不是字节数。回到Fork函数：

为什么这个Copy '\0'要像代码中这么搞呢？不太理解，想想可能是因为现在的StringT与之前的StringT共享一块内存，现在要自立内存了，也要把之前的数据拷过来吧。

CStringData的Release()也比较简单，就是引用计数<=0就把内存释放掉。

void Release() throw() { ATLASSERT( nRefs != 0 ); if( _AtlInterlockedDecrement( &nRefs ) <= 0 ) { pStringMgr->Free( this ); } } void CAfxStringMgr::Free( CStringData* pData ) throw() { free(pData); }

现在回到CStringT的operator= 函数：

在Fork函数的Attach调用中已经将m_pszData指向了用于存放字符串的内存。GetBuffer函数返回的是m_pszData。

static void __cdecl ConvertToBaseType( _Out_cap_(nDestLength) LPWSTR pszDest, _In_ int nDestLength, _In_ LPCSTR pszSrc, _In_ int nSrcLength = -1) throw() { // nLen is in wchar_ts ::MultiByteToWideChar( _AtlGetConversionACP(), 0, pszSrc, nSrcLength, pszDest, nDestLength ); }

现在再把多字节的”abc”转换为宽字节的字符串并存到m_pszData中。再看看ReleaseBufferSetLength:

void ReleaseBufferSetLength(_In_ int nNewLength) { ATLASSERT( nNewLength >= 0 ); SetLength( nNewLength ); } void SetLength(_In_ int nLength) { ATLASSERT( nLength >= 0 ); ATLASSERT( nLength <= GetData()->nAllocLength ); if( nLength < 0 || nLength > GetData()->nAllocLength) AtlThrow(E_INVALIDARG); GetData()->nDataLength = nLength; m_pszData[nLength] = 0; }

这个作用也比较明显，就是设置nDataLength ，并且把字符串结尾置0。

其他构造函数

一些关键函数

void ReleaseBuffer(_In_ int nNewLength = -1) { if( nNewLength == -1 ) { int nAlloc = GetData()->nAllocLength; nNewLength = StringLengthN( m_pszData, nAlloc); } SetLength( nNewLength ); }

如果ReleaseBuffer不传参数，那么nNewLength 就是m_pszData字符数与nAlloc之间的小者。否则nNewLength 由你自己设置。StringLengthN函数的功能就是取。SetLength( nNewLength )把nNewLength 位置的字符置为0，并把CStringData的nDataLength字段设置为nNewLength 。所以说ReleaseBuffer并不是用来释放内存的，函数名甚是迷惑人。