【IT168 专稿】
下面是示例程序使用及未使用这个未公开MFC类的对比情况截图，是不是有点心动了呢，接着往下看。
简介
如果你经常浏览MFC的源代码，说不定就会有意想不到的惊喜发现，这不，很快就发现了一个，它是一个小工具类的集合，允许为特定类的对象定义怎样为其动态分配内存，这个类就是CFixecAlloc，通常它在大家熟悉的CString类的内部，用来分配字符串缓冲区。而我们今天要说的，就是如何在现有代码中，应用CFixecAlloc类，只花最少的修改成本来获取可观的性能提升，本文中探讨CRT动态分配的开销、针对CRT不足之处的备选方法、对CFixecAlloc类的剖析、及如何在程序中使用CFixecAlloc，最后，将在一个示例程序中证明这一切。
为什么不用malloc/free、new/delete呢？
众所周知，动态内存分配开销非常大，它会导致程序执行时间上的性能损耗，而且占用空间也更大，如果还不相信，可以亲自查看一下CRT源代码中提供的malloc.c文件，怎么说呢，malloc()函数有点复杂，执行起来可能要花点时间；至于空间上的开销，说起来就稍有点繁琐了，基本上编译程序时不同版本的VC++、程序运行时不同版本的Windows，都会用到不同版本的堆，但这已超出了本文的范围。如果真的对CRT如何选择堆的版本很感兴趣，可以看一下heapinit.c文件中的__heap_select()函数。在CRT的winheap.h头文件中，定义了三种不同版本堆：
__SYSTEM_HEAP
__V5_HEAP
__V6_HEAP
V5及V6版本映射的堆实现，对CRT库来说是私有的，而系统堆（system heap）直接映射到Win32堆服务（如HeapCreate()、HeapAlloc()等等）。对于V5及V6版本，查看CRT源代码之后就可完全知道其空间开销，例如，对V6堆而言，就可找到下面这行语句：
//添加8个字节的开销并求整到下一个参数大小BYTES_PER_PARA等同于16字节，这是一个非常大的开销，如果我们只需要12字节呢，而CRT将会为此保留32字节，这已经比所需的两倍还多了。但V5及V6堆现今已很少使用了，且也没有源代码，所以还不能确切了解HeapAlloc()的开销是多少，然而，存在一定程度上的开销总是不争的事实，微软对此在HeapCreate()文档中的声明是：
sizeEntry = (intSize + 2 * (int)sizeof(int) +
(BYTES_PER_PARA - 1)) & ~(BYTES_PER_PARA - 1);
系统使用私有堆中的内存，用于存储支撑堆的结构，因此，并不是所有规定的堆大小对进程来说都是可用的。例如，如果HeapAlloc()函数从一个最大64K的堆中请求64k（千字节）内存，那么会因为存在系统开销而调用失败。
其他方法的局限性
当然，也有其他人编写了内存池类用于解决CRT堆开销过多的问题，然而，大多数这类方法需要大量修改现有程序的代码，以便让所有对new、delete的调用，都转向对缓冲池类成员的调用；另外，这类方法还有一个潜在的局限性，它们缺乏线程安全，而CFixedAlloc就是为了解决这些情况而来的。
CFixedAlloc的类声明：
class CFixedAlloc可以看到，这是一个非常简单的类，而且，你也许也留意到了，这个类由临界区提供了线程安全。m_AllocSize中包含了类的对象大小，m_blockSize指定了每个固定内存块能包含的对象数，这两个成员都在构造函数中设置。唯一剩下的就是CPlex指针了，在这不打算详细讲解这个类，只需了解它才是真正进行CRT动态内存分配的类就行了，它包含了一个指针，指向另一个CPlex对象以创建一个CPlex链表，所以它的大小只能为4字节，当进行内存分配时，就需要m_allocSize*m_blockSize+sizeof(CPlex)。
{
//构造函数
public:
CFixedAlloc(UINT nAllocSize, UINT nBlockSize = 64);
//属性
UINT GetAllocSize() { return m_nAllocSize; }
//具体操作
public:
void* Alloc(); //返回一块nAllocSize大小的内存
void Free(void* p); //释放由Alloc分配的一块内存
void FreeAll(); //释放所有此类分配的内存
//实现
public:
~CFixedAlloc();
protected:
struct CNode
{
CNode* pNext;
};
UINT m_nAllocSize; //Alloc中每个块的大小
UINT m_nBlockSize; //每次获取的块数
CPlex* m_pBlocks; //块链表（nBlocks*nAllocSize）
CNode* m_pNodeFree; //第一个要释放的节点，如果没有则为NULL
CRITICAL_SECTION m_protect;
};
现在，我们可以对比CRT与CFixedAlloc之间的差异了：使用CRT，对于每个对象都会存在CRT开销；而使用CFixedAlloc，内存开销则为CRT开销加上CPlex大小（4字节），再除以已分配对象数，当分配数目非常大时，此开销接近于零。下面，再来仔细看一下两个更重要的CFixedAlloc函数：
void* CFixedAlloc::Alloc()
{
EnterCriticalSection(&m_protect);
if (m_pNodeFree == NULL)
{
CPlex* pNewBlock = NULL;
TRY
{
//添加另一个块
pNewBlock = CPlex::Create(m_pBlocks, m_nBlockSize, m_nAllocSize);
}
CATCH_ALL(e)
{
LeaveCriticalSection(&m_protect);
THROW_LAST();
}
END_CATCH_ALL
//把它们放进要释放的列表中
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;
}
}
ASSERT(m_pNodeFree != NULL);
//移除释放列表中第一个节点
void* pNode = m_pNodeFree;
m_pNodeFree = m_pNodeFree->pNext;
LeaveCriticalSection(&m_protect);
return pNode;
}
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);
}
}
在Alloc()中，代码会检查要释放的内存池是否为空，如果为空，则创建一个新的内存块（CPlex），并设置要释放节点列表，在此，因为是直接放置到每个块中，所以就没有多余的空间来放置节点信息。当然了，要正常工作，m_nAllocSize必须要大过sizeof(CNode)，这也是为什么要在构造函数里进行检查的原因：ASSERT(nAllocSize >= sizeof(CNode))。
如果大家看过CRT代码，可能有点搞不清楚CFixedAlloc的代码为什么会很少，从算法的观点来看，主要是因为内存块的大小是固定的，比方说，在可进行变量分配的堆中，经过多次分配与释放之后，堆中会有碎片，过不多久就必须扫描一次堆，把邻近的小的剩余空间合并为大的空间，以提高内存使用的效率。
下面是使CFixedAlloc更便于使用的宏：
// DECLARE_FIXED_ALLOC -- used in class definitionDECLARED_FIXED_ALLOC()宏担当了new与delete操作，这样，无需修改现有代码就可以应用CFixedAlloc；而IMPLEMENT_FIXED_ALLOC()则负责指定块大小。
#define DECLARE_FIXED_ALLOC(class_name) \
public: \
void* operator new(size_t size) \
{ \
ASSERT(size == s_alloc.GetAllocSize()); \
UNUSED(size); \
return s_alloc.Alloc(); \
} \
void* operator new(size_t, void* p) \
{ return p; } \
void operator delete(void* p) { s_alloc.Free(p); } \
void* operator new(size_t size, LPCSTR, int) \
{ \
ASSERT(size == s_alloc.GetAllocSize()); \
UNUSED(size); \
return s_alloc.Alloc(); \
} \
protected: \
static CFixedAlloc s_alloc \
// IMPLEMENT_FIXED_ALLOC -- used in class implementation file
#define IMPLEMENT_FIXED_ALLOC(class_name, block_size) \
CFixedAlloc class_name::s_alloc(sizeof(class_name), block_size) \
如何使用CFixedAlloc
1、把“fixalloc.h”包含在需要修改且含有类定义的头文件中。
2、在类声明中添加DECLARE_FIXED_ALLOC()宏。
3、在含有类定义的CPP文件中添加IMPLEMENT_FIXED_ALLOC()宏。
4、重新编译。
5、微调块的大小，以获得非常好的效果。
因为CFixedAlloc是一个私有类，所以还要在编译器选项中添加一个额外的include目录，其必须指向MFC源代码目录。（因此，在安装Visual Studio时就要选择安装MFC源代码了，还好这通常情况下都是默认安装的。）
大功告成，现在在自己的类中就可以使用MFC CFixedAlloc了，提醒一句：如果编译时代码中有#define _DEBUG，CFixedAlloc宏将不会展开，最终结果还是会和以前一样，就好像什么也没动过。
对上面的第五步，还要补充一下，块的大小非常重要，如果太大，就会浪费内存；如果太小，则不会得到应有的性能提升，然而，即便这个值非常小，仍会减少对CRT分配函数的调用次数。块大小的理想值应恰好等于要分配的对象数，当然了，通常这是不可能的。
关于Visual C++ 2005的警告信息
另外，不得不提一点，如果用Visual C++ 2005编译使用了CFixedAlloc的程序时，可能会遇到如下警告信息：
.\CFixedAllocDemoDlg.cpp(237) : warning C4995:
'CFixedAlloc': name was marked as #pragma deprecated
.\CFixedAllocDemoDlg.cpp(240) : warning C4995:
'CFixedAlloc': name was marked as #pragma deprecated
这表明从Visual C++ 2005开始，微软已不赞成使用CFixedAlloc类，可我们一时也找不出什么可以代替它的方法，如果你觉得使用CFixedAlloc会让程序大有改观，大可以忽略这些信息，如果怕微软以后从MFC中移除CFixedAlloc类，带来程序上的兼容性问题，那建议你复制一份CFixedAlloc文件加以保存。
这也表明，微软开始慢慢疏远CFixedAlloc了，回过头来看MFC6，CFixedAlloc却用在了每个临时句柄映射对象类中，如CWnd和CGdiObject，有以下为证：
class CTempGdiObject : public CGdiObject但这些类从MFC7.1（VC++2003）中就已被移除，也许微软MFC开发小组有其自己的理由吧。
{
DECLARE_DYNCREATE(CTempGdiObject)
DECLARE_FIXED_ALLOC(CTempGdiObject);
};
内存释放
当某个对象被删除，且“释放列表”在同一分配的CPlex中时，CFixedAlloc会返回一个节点到一个“释放列表”中，因为CPlex对象是单向链接的，所以在整个程序生命期都会保持已分配状态（或直到它们的表头被删除）。事实上，CFixedAlloc不仅仅是进行内存分配，它是一个再循环器：按需进行分配但并不释放，为后续的分配请求作保留。
通常，这在频繁地使用new/delete/new/delete情况下，会带来更好的速度提升，但对于短时间内需要大量内存的这种情况，可能会有些问题，这时，程序会一直占有这部分内存，直到CPlex表头被删除，除非用户在使用完内存后，显式地调用CFixedAlloc::FreeAll()来释放这部分内存。也就是说，如果之前已删除所有分配的对象，就可在任意时候调用CFixedAlloc::FreeAll()来自己释放内存，否则，内存会直到CFixedAlloc对象销毁时才会被释放。提示一下：全局对象是在进入WinMain()之前的启动代码中创建的，而在程序退出WinMain()后、自身卸载前才会被销毁。
CFixedAlloc与继承
在与派生类一起使用CFixedAlloc时，还必须多一点了解，比如说以下情况：
class Base如果后面代码中用了Child *p = new Child，将会调用Child::operator new()而不是CFixedAlloc，这时该怎么办呢，请看下面：
{
DECLARE_FIXED_ALLOC(Base);
};
class Child : public Base
{
};
class Base当然了，如果类是抽象类，而我们又把Base类声明为FIXED_ALLOC，这怎么也说不过去，因此，关于在类继承中使用CFixedAlloc，必须知道delete操作符为static但不为virtual，再看以下代码：
{
DECLARE_FIXED_ALLOC(Base);
};
class Child : public Base
{
DECLARE_FIXED_ALLOC(Child);
};
Base *p = new Child;在这种情况中，将会调用Base::operator delete()，这可就麻烦大了。以下是可行的解决方案：
delete p;
class Base
{
public:
virtual void Destroy() {delete this;}
DECLARE_FIXED_ALLOC(Base);
};
class Child : public Base
{
public:
virtual void Destroy() {delete this;}
DECLARE_FIXED_ALLOC(Child);
};
Base *p = new Child;
p->Destroy();
示例程序
示例程序非常简单，仅是声明两个几乎一样的类：一个使用了CFixedAlloc而另一个没用。接下来，创建了大量的对象，创建过程是计时的，完成之后，会显示结果。要计算未用CFixedAlloc的类大小开销，在此使用了__V6_HEAP，这种情况非常少见，因此计算值可能不完全准确，但一般来看，应该是比较正确了。
#define ITER_NUM 1000*1024
class A
{
public:
A( A *next ) : m_next(next) {}
A *m_next;
int dummy1;
int dummy2;
};
class B
{
public:
B( B *next ) : m_next(next) {}
B *m_next;
int dummy1;
int dummy2;
DECLARE_FIXED_ALLOC(B);
};
IMPLEMENT_FIXED_ALLOC(B,ITER_NUM);
void CCFixedAllocDemoDlg::OnTestTimebutton()
{
//可在此添加控件通知处理代码
A *curAObj, *firstAObj = NULL;
B *curBObj, *firstBObj = NULL;
DWORD startA, endA, startB, endB;
register int i;
{
CWaitCursor wait;
startA = GetTickCount();
for( i = 0; i < ITER_NUM; i++ )
{
firstAObj = new A(firstAObj);
}
while( firstAObj )
{
curAObj = firstAObj->m_next;
delete firstAObj;
firstAObj = curAObj;
}
startB = endA = GetTickCount();
for( i = 0; i < ITER_NUM; i++ )
{
firstBObj = new B(firstBObj);
}
while( firstBObj )
{
curBObj = firstBObj->m_next;
delete firstBObj;
firstBObj = curBObj;
}
endB = GetTickCount();
}
displayResult( endA-startA,endB-startB );
}
#define BYTES_PER_PARA 16
void CCFixedAllocDemoDlg::displayResult( DWORD timeA, DWORD timeB )
{
TCHAR buf[1024];
/*
* 每个A对象占用32字节。
*/
int overheadA = (32-sizeof(A))*ITER_NUM;
/*
*首先计算已分配大小，再减去所请求大小。
*/
int overheadB =
(8+sizeof(B)*ITER_NUM + sizeof(CPlex) + (BYTES_PER_PARA-1))
& ~(BYTES_PER_PARA - 1);
overheadB -= sizeof(B)*ITER_NUM;
wsprintf( buf, __TEXT("Creating and destroying %d objects\n")
__TEXT("without CFixedAlloc\t: M ms\n")
__TEXT("with CFixedAlloc\t: M ms\n")
__TEXT("You saved %d bytes with CFixedAlloc"),
ITER_NUM, timeA, timeB,
overheadA - overheadB );
MessageBox(buf,__TEXT("Results"));
}
建议
如果移除临界区，把CFixedAlloc作为单线程版本，还可进一步提高性能，这点微软也想到了，从MFC7（VC++.NET 2002）开始，就添加了对单线程的支持，最新的Visual C++ 2008当然也不例外。如果想使用单线程版本的CFixedAlloc，就可使用以下宏：
// DECLARE_FIXED_ALLOC -- used in class definition不过在IMPLEMENT_FIXED_ALLOC_NOSYNC()宏中有一个小错误，宏参数class_nbame应该为class_name（注：这个错误在Visual C++ 2008中依然存在）。看起来在MFC中并没有使用这些宏，要不然早就发现这个语法错误了，同时，这也意味着这个非同步版本可能未被MFC开发小组所测试。不管怎样，这个错误很小，而且在修正之后丝毫不影响使用，也正是因为MFC中没有使用这个宏，所以修正之后也无需再重新编译MFC。
#define DECLARE_FIXED_ALLOC_NOSYNC(class_name) \
public: \
void* operator new(size_t size) \
{ \
ASSERT(size == s_alloc.GetAllocSize()); \
UNUSED(size); \
return s_alloc.Alloc(); \
} \
void* operator new(size_t, void* p) \
{ return p; } \
void operator delete(void* p) { s_alloc.Free(p); } \
void* operator new(size_t size, LPCSTR, int) \
{ \
ASSERT(size == s_alloc.GetAllocSize()); \
UNUSED(size); \
return s_alloc.Alloc(); \
} \
protected: \
static CFixedAllocNoSync s_alloc \
// IMPLEMENT_FIXED_ALLOC_NOSYNC -- used in class
// implementation file
#define IMPLEMENT_FIXED_ALLOC_NOSYNC(class_nbame, block_size) \
CFixedAllocNoSync class_name::s_alloc(sizeof(class_name),
block_size) \
/*
*取消第一行define语句前的注释符号就可以使用单线程版本的CFixedAlloc
*在重新编译之前，必须修正fixalloc.h中的语法错误
* IMPLEMENT_FIXED_ALLOC_NOSYNC()宏参数中的class_nbame应为class_name
*
*注意：单线程版本只可用在VC++.NET及以上版本中
//#define _USE_SINGLE_THREAD测试程序表明非同步版本相对于原CFixedAlloc版本，带来了40%的速度提升，可别犯迷糊，非同步版本可不能用在多线程程序中喔。
#ifndef _USE_SINGLE_THREAD
class B
{
public:
B( B *next ) : m_next(next) {}
B *m_next;
int dummy1;
int dummy2;
DECLARE_FIXED_ALLOC(B);
};
IMPLEMENT_FIXED_ALLOC(B,ITER_NUM);
#else
class B
{
public:
B( B *next ) : m_next(next) {}
B *m_next;
int dummy1;
int dummy2;
DECLARE_FIXED_ALLOC_NOSYNC(B);
};
IMPLEMENT_FIXED_ALLOC_NOSYNC(B,ITER_NUM);
#endif
