为了使成员函数的意义更加清楚，我们可在不改变对象的成员函数的函数原型中加上const说明：
 

  class Point
{
　public:
　　int GetX() const;
　　int GetY() const;
　　void SetPt (int, int);
　　void OffsetPt (int, int);
　private:
　　int xVal, yVal;
};
 

　　const成员函数应该在函数原型说明和函数定义中都增加const限定：
 

  int Point::GetY() const
{
　return yVal;
}
class Set {
public:
　Set (void){ card = 0; }
　bool Member(const int) const;
　void AddElem(const int);
　//...
};
bool Set::Member (const int elem) const
{
　//...
}

　　非常量成员函数不能被常量成员对象调用，因为它可能企图修改常量的数据成员：
　　const Set s;
　　s.AddElem(10); // 非法: AddElem不是常量成员函数
　　s.Member(10); // 正确
　　但构造函数和析构函数对这个规则例外，它们从不定义为常量成员，但可被常量对象调用（被自动调用）。它们也能给常量的数据成员赋值，除非数据成员本身是常量。

 
为什么需要const成员函数？
　　我们定义的类的成员函数中，常常有一些成员函数不改变类的数据成员，也就是说，这些函数是"只读"函数，而有一些函数要修改类数据成员的值。如果把不改变数据成员的函数都加上const关键字进行标识，显然，可提高程序的可读性。其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。

const成员函数和const对象
　　实际上，const成员函数还有另外一项作用，即常量对象相关。对于内置的数据类型，我们可以定义它们的常量，用户自定义的类也一样，可以定义它们的常量对象。例如，定义一个整型常量的方法为：
　　const int i=1 ；
同样，也可以定义常量对象，假定有一个类classA，定义该类的常量对象的方法为：
　　const classA a(2)；
　　这里，a是类classA的一个const对象，"2"传给它的构造函数参数。const对象的数据成员在对象寿命期内不能改变。但是，如何保证该类的数据成员不被改变呢？
　　为了确保const对象的数据成员不会被改变，在C++中，const对象只能调用const成员函数。如果一个成员函数实际上没有对数据成员作任何形式的修改，但是它没有被const关键字限定的，也不能被常量对象调用。下面通过一个例子来说明这个问题：
 

  class C
{
　int X;
public:
　int GetX()
　{
　　return X;
　}
　void SetX(int X)
　{
　　this->X = X;
　}
};
void main()
{
　const C constC;
　cout<<constC.GetX();
}

　　如果我们编译上面的程序代码，编译器会出现错误提示：constC是个常量对象，它只能调用const成员函数。虽然GetX( )函数实际上并没有改变数据成员X，由于没有const关键字限定，所以仍旧不能被constC对象调用。如果我们将上述加粗的代码：
　　int GetX()
改写成：
　　int GetX()const
再重新编译，就没有问题了。
const成员函数的使用
　　const成员函数表示该成员函数只能读类数据成员，而不能修改类成员数据。定义const成员函数时，把const关键字放在函数的参数表和函数体之间。有人可能会问：为什么不将const放在函数声明前呢？因为这样做意味着函数的返回值是常量，意义完全不同。下面是定义const成员函数的一个实例：
　　class X
　　{
　　　int i;
　　　public:
　　　int f() const;
　　};
　　关键字const必须用同样的方式重复出现在函数实现里，否则编译器会把它看成一个不同的函数：
　　int X::f() const
　　{
　　　return i;
　　}
　　如果f( )试图用任何方式改变i或调用另一个非const成员函数，编译器将给出错误信息。任何不修改成员数据的函数都应该声明为const函数，这样有助于提高程序的可读性和可靠性。

  对象.成员函数

     对象          成员函数       对/错
1、  const         const           对
2、  const         non-const       错
3、  non-const     const           对
4、  not-const     non-const       对

          成员函数调用成员函数

     成员函数      成员函数       对/错
5、  const         const           对
6、  const         non-const       错
7、  non-const     const           对
8、  non-const     non-const       对

作者：阿半

　　语言调用规范是指进行一次函数调用所采用的传递参数的方法，返回值的处理以及调用堆栈的清理。Microsoft C/C++ 语言中采用了五种调用规范，分别是__cdecl, __stdcall, __fastcall，thiscall和nake每一中调用规范都是利用eax作为返回值，如果函数返回值是64位的，则利用edx:eax对来返回值。Nake调用规范非常的灵活，足以独立的一篇文章描述，这里就不再描述nake调用规范。下表列出了前面四种规范调用的特点：
　 关键字 堆栈清理者 参数传递顺序
__cdecl 调用者 从右至左
__stdcall 被调用者 从右至左
__fastcall 被调用者 从右至左，前两个参数由寄存器ecx，edx传递
thiscall 被调用者或者调用者 从右至左

　　__cdecl 最大好处在于由于是调用者清理栈，它可以处理可变参数，缺点则在于它增加了程序的大小，因为在每个调用返回的时候，需要多执行一条清理栈的指令。
　　__stdcall 是在windows程序设计中出现的最多的调用规则，所有的不可变参数的API调用都使用这个规则。
　　__fastcall 在windows内核设计中被广泛的使用，由于两个参数由寄存器直接传递，采用这种规则的函数效率要比以上两种规则高。
　　thiscall是C++成员函数的默认调用规范，编译期间，这种调用会根据函数是否支持可变参数表来决定采用什么方式清理堆栈。如果成员函数不支持可变参数，那么它就是用参数入栈，ecx保存this指针的方式进行调用，如果成员函数支持可变参数，那么它的调用和__cdecl类似，唯一不同的是将this指针最后压入栈中进行传递。
　　调用者和被调用者必须采用同样的规则才能保证程序的正常执行，曾经看到很多程序员犯的错误就是由于调用规范的不一样，致使程序异常，比如：

DWORD ThreadFunc(LPVOID lpParam)
{
//…
}

CreateThread(..,(LPTHREAD_START_ROUTINE)ThreadFunc, …);　　如果在编译期间没有指定编译选项/Gz（指定未指明调用规范的函数采用__stdcall方式），那么编译器自动将ThreadFunc处理成__cdecl调用规范（/Gd），这样可能在线程开始的时候正常执行，然而退出的时候由于堆栈没有正常清理，造成访问违例或者非法指令错误。
　　以上说了很多清理栈的问题，那么为什么清理栈很重要呢。堆栈是线程相关的，也就是说每一个线程含有一个堆栈，这个堆栈上保存了局部变量，调用返回地址等很多线程相关的数据，这也是为什么独立运行的线程可以调用同样一个函数而互不干扰的原因。堆栈的特点恐怕大家已经非常熟悉了，那么根据上面的每一种调用，我给出一个简单的图示来说明清理堆栈的重要性，以及为什么上面的例子代码会出错。

图一　这是线程堆栈在运行的时候的样子

　　调用前和后esp的差值中间包含了函数参数表，返回地址这样的重要信息，举个简单的调用例子．假设有某个函数定义是这样的：

Int __cdecl func（void* p）；再假设esp调用函数前的数值为0x1234，那么在进入这个函数体内看到的堆栈是这样的：

122C 1230 1234
Next p 这里的next指调用函数后的下一条指令的位置。调用函数的汇编码：

Push p
Call func
Add esp，4 《--注意这里，由于是cdecl调用，需要调用者清栈。而一个__stdcall调用的汇编码：

Push p
Call func　　这里没有了add esp，4这个指令，因为在func函数返回的时候自己将esp已经复原了。再来看刚才举的错误的例子，由于强制转换的作用，线程开始函数被设置成了stdcall调用，而实际的线程函数被编译后，并没有执行堆栈的清理工作，线程函数返回的时候，由于堆栈的不正确，当然会发生错误。修改这个bug的方法只要在线程函数的定义前把__cdecl改成_stdcall即可。
　　有了上面的例子做基础来理解可变参数表就简单的多了，由于各种调用规范的限定，致使只有__cdecl调用规范可以采用可变参数表。先来看看可变参数表的定义（可以参考sdk目录下src\crt\varargs.h）：

typedef char *va_list;
#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
#define va_dcl va_list va_alist;
#define va_start(ap) ap = (va_list)&va_alist
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap) ap = (va_list)0　　va_list居然被定义成char* ？没错，这实际是用来定义了一个指针，指针的sizeof()就是操作系统可访问的地址空间的大小，也就是CPU相关的字长。_INTSIZEOF宏很简单，就是用来将数据以n的数据大小对齐。va_start宏有点模糊，可是如果你看懂了上面的堆栈数据结构，那么显然它就是获得最后一个固定参数的地址，也就是堆栈上的地址，va_arg先使得ap指向下一个参数，然后取得当前参数的值（注意，这个值正是堆栈上的值），va_end使得取参数过程结束。
　　这几个宏完成的动作很简单了，实际就是取得可变参数表在堆栈上的起始位置，然后根据参数类型，依次从堆栈上取出每一个参数。
　　本文简单的介绍了微软C/C++支持的调用类型，结合实例描述了规范的实际应用，最后根据CRT提供的源代码分析了可变参数表的实现。

本文来自CSDN博客，转载请标明出处：file:///E:/library/VC++%206_0%20中如何使用%20CRT%20调试功能来检测内存泄漏（转）%20-%20bairny的专栏%20-%20CSDN博客.mht

精确获取时间：

QueryPerformanceFrequency() - 基本介绍

类型：Win32API

原型：BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);

作用：返回硬件支持的高精度计数器的频率。

返回值：非零，硬件支持高精度计数器；零，硬件不支持，读取失败。

QueryPerformanceFrequency() - 技术特点

供WIN9X使用的高精度定时器：QueryPerformanceFrequency()和QueryPerformanceCounter()，要求计算机从硬件上支持高精度定时器。需包含windows.h头文件。

函数的原形是：

BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency);

BOOL QueryPerformanceCounter (LARGE_INTEGER *lpCount);

数据类型LARGEINTEGER既可以是一个作为8字节长的整数，也可以是作为两个4字节长的整数的联合结构，其具体用法根据编译器是否支持64位而定。该类型的定义如下：

typeef union _ LARGE_INTEGER

{

struct

{

DWORD LowPart;

LONG HighPart;

};

LONGLONG QuadPart;

} LARGE_INTEGER;

在定时前应该先调用QueryPerformanceFrequency()函数获得机器内部计时器的时钟频率。接着在需要严格计时的事件发生前和发生之后分别调用QueryPerformanceCounter()，利用两次获得的计数之差和时钟频率，就可以计算出事件经历的精确时间。

测试Sleep的精确时间：

#include <stdio.h>

#include <windows.h>

void main()

{

     LARGE_INTEGER nFreq;

     LARGE_INTEGER nBeginTime;

     LARGE_INTEGER nEndTime;

     double time;

     QueryPerformanceFrequency(&nFreq);

     QueryPerformanceCounter(&nBeginTime); 

     Sleep(1000);

     QueryPerformanceCounter(&nEndTime);

     time=(double)(nEndTime.QuadPart-nBeginTime.QuadPart)/(double)nFreq.QuadPart;

     printf("%f\n",time);

     Sleep(1000);

system("Pause");

}

结果为

0.999982

1.000088

1.000200

等，所以Sleep的精度还是比较低的。

1.线程的组成

           (1)线程内核对象：用于管理线程及存储线程的统计信息

           (2)线程栈：维护线程执行时需要的函数参数和局部变量。　线程栈所需的内存是从进程中分配而得的，其大小默认是1M.

           每个线程都有自已独立的线程栈。

           进程不执行任何代码，所有的代码都是由线程执行的。进程相当于一个装载线程的容器。

          线程共享进程的地址空间和数据，如内核对象句柄(内核对象句柄只能依附于某个进程而不是某个线程)

2.线程函数原型

            DWORD WINAPI ThreadFunc(PVOID pvParam)

            {

               DWORD dwResult = 0;

               ...

               return(dwResult);

            }

            The system allocates memory out of the process' address space for use by the thread's stack.

3.终止线程

              1.线程正常退出。系统会对线程函数内创建的所有对象调用析构函数。

              2.ExitThread(). 线程退出，　系统会清理线程栈。 但是系统不会对线程函数内创建的所有对象调用析构函数。

              3.TerminateThread().线程异步退出，系统不清理线程栈。只到拥有该线程的进程退出时才清理线程栈。

              　该函数是个异步函数，它只会告诉系统去杀掉某个线程，但是系统不会保证当该函数返回时线程立刻终止。

              　因此我们如果我们要确认线程已经终止了，则需要用WaitForSingleObject()来等待线程结束。             

              4.内核对象由进程所拥有，用户对象由线程拥有。线程可拥有两种用户对象：Windows和Hook.

              5.线程终止后，线程所拥有的用户对象会被系统释放。

             6.GetExitCodeThread() //检查线程是否已终止

4.线程内部细节

1.CreateThread 和 _beginthreadex 区别：

    CreateThread是系统API,_beginthreadex是CRT(C Run Time Library 运行时库)函数.     _beginthreadex内部会调用CreateThread函数。 

     _endthreadex会释放_beginthreadex为tiddata结构分配的内存。

    如果线程函数中调用了CRT函数(注：不是全部CRT函数　只是其中一部分函数),则该线程函数必须由_beginthreadex而不是CreateThread函数创建。否则会产生内存泄露。

    如果在除主线程之外的任何线程中进行一下操作，你就应该使用多线程版本的C runtime library,并使用_beginthreadex和_endthreadex：

              (1) 使用malloc()和free()，或是new和delete

              (2) 使用stdio.h或io.h里面声明的任何函数

              (3) 使用浮点变量或浮点运算函数

              (4) 调用任何一个使用了静态缓冲区的runtime函数，比如:asctime(),strtok()或rand()

2._beginthreadex和_beginthread区别

    _beginthreadex内部会自动调用 _endthreadex.

    _beginthread内部会自动调用_endthread.

    _endthread内部会自动调用CloseHandle关闭当前Thread内核对象的句柄,所以在用_beginthread 时我们不需要在主线程中调用CloseHandle来关闭子线程的句柄。 

   _endthreadex相比_endthread而言更安全。它不会自动关闭当前Thread内核对象的句柄。所以在用_beginthreadex时我们需要用CloseHandle来关闭子线程的句柄。

5.伪句柄和真实句柄

1.伪句柄(Pseudohandle):

                HANDLE GetCurrentProcess();

                HANDLE GetCurrentThread();                               

以上两个函数会返回指向线程或进程内核对象的伪句柄（其实以上两个函数返回的是一个常数如-1）。所以伪句柄的值永远是指向当前线程或进程的。 

如果把该值传给子进程，该值则代表当前子进程的伪句柄。所以把句柄传给子线程时一定要传真时的句柄不能传伪句柄。 

该句柄不会增加内核对象的引用计数，所以不需要调用CloseHandle()函数。

　　2.把伪句柄转换成真实句柄

DuplicateHandle会增加内核对象的引用计数，所以要用CloseHandle()来关闭复制所得的对象句柄。

6.Common API

                DWORD GetCurrentProcessId();

                DWORD GetCurrentThreadId();

                HANDLE GetCurrentProcess();

                HANDLE GetCurrentThread();

                     DuplicateHandle()

        microsoft的vc默认的是__cdecl方式，而windows API则是__stdcall，如果用vc开发dll给其他语言用，则应该指定__stdcall方式。堆栈由谁清除这个很重要，如果是要写汇编函数给C调用，一定要小心堆栈的清除工作，如果是__cdecl方式的函数，则函数本身（如果不用汇编写）则不需要关心保存参数的堆栈的清除，但是如果是__stdcall的规则，一定要在函数退出(ret)前恢复堆栈。
1.__cdecl
       所谓的C调用规则。按从右至左的顺序压参数入栈，由调用者把参数弹出栈。切记：对于传送参数的内存栈是由调用者来维护的。返回值在EAX中因此，对于象printf这样变参数的函数必须用这种规则。编译器在编译的时候对这种调用规则的函数生成修饰名的饿时候，仅在输出函数名前加上一个下划线前缀，格式为_functionname。
2.__stdcall
        按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。_stdcall是Pascal程序的缺省调用方式，通常用于Win32 Api中，切记：函数自己在退出时清空堆栈，返回值在EAX中。　　__stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个“@”符号和其参数的字节数，格式为_functionname@number。如函数int func(int a, double b)的修饰名是_func@12。
3.__fastcall
       __fastcall调用的主要特点就是快，因为它是通过寄存器来传送参数的（实际上，它用ECX和EDX传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈）。__fastcall调用约定在输出函数名前加上一个“@”符号，后面也是一个“@”符号和其参数的字节数，格式为@functionname@number。这个和__stdcall很象，唯一差别就是头两个参数通过寄存器传送。注意通过寄存器传送的两个参数是从左向右的，即第一个参数进ECX，第2个进EDX，其他参数是从右向左的入stack。返回仍然通过EAX.
4.__pascal
       这种规则从左向右传递参数，通过EAX返回，堆栈由被调用者清除

5.__thiscall

        仅仅应用于"C++"成员函数。this指针存放于CX寄存器，参数从右到左压。thiscall不是关键词，因此不能被程序员指定

       调用约定可以通过工程设置：Setting...\C/C++ \Code Generation项进行选择，缺省状态为__cdecl。

名字修饰约定：

1、修饰名(Decoration name)："C"或者"C++"函数在内部（编译和链接）通过修饰名识别
2、C编译时函数名修饰约定规则：
__stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个"@"符号和其参数的字节数，格式为_functionname@number,例如 ：function(int a, int b)，其修饰名为：_function@8
__cdecl调用约定仅在输出函数名前加上一个下划线前缀，格式为_functionname。
__fastcall调用约定在输出函数名前加上一个"@"符号，后面也是一个"@"符号和其参数的字节数，格式为@functionname@number。

3、C++编译时函数名修饰约定规则：
__stdcall调用约定：
1)、以"?"标识函数名的开始，后跟函数名；
2)、函数名后面以"@@YG"标识参数表的开始，后跟参数表；
3)、参数表以代号表示：
X--void ，
D--char，
E--unsigned char，
F--short，
H--int，
I--unsigned int，
J--long，
K--unsigned long，
M--float，
N--double，
_N--bool，
PA--表示指针，后面的代号表明指针类型，如果相同类型的指针连续出现，以"0"代替，一个"0"代表一次重复；
4)、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前；
5)、参数表后以"@Z"标识整个名字的结束，如果该函数无参数，则以"Z"标识结束。
其格式为"?functionname@@YG*****@Z"或"?functionname@@YG*XZ"，例如
          int Test1(char *var1,unsigned long)-----“?Test1@@YGHPADK@Z”
          void Test2()                       -----“?Test2@@YGXXZ”

__cdecl调用约定：
规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YA"。
__fastcall调用约定：
规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YI"。
VC++对函数的省缺声明是"__cedcl",将只能被C/C++调用.

注意：
1、_beginthread需要__cdecl的线程函数地址，_beginthreadex和CreateThread需要__stdcall的线程函数地址。

2、一般WIN32的函数都是__stdcall。而且在Windef.h中有如下的定义：
#define CALLBACK __stdcall
#define WINAPI　 __stdcall

3、extern "C" _declspec(dllexport) int __cdecl Add(int a, int b);
   typedef int (__cdecl*FunPointer)(int a, int b);
   修饰符的书写顺序如上。

4、extern "C"的作用：如果Add(int a, int b)是在c语言编译器编译，而在c++文件使用，则需要在c++文件中声明：extern "C" Add(int a, int b)，因为c编译器和c++编译器对函数名的解释不一样（c++编译器解释函数名的时候要考虑函数参数，这样是了方便函数重载，而在c语言中不存在函数重载的问题），使用extern "C"，实质就是告诉c++编译器，该函数是c库里面的函数。如果不使用extern "C"则会出现链接错误。
一般象如下使用：
#ifdef _cplusplus
#define ETERN_C extern "C"
#else
#define EXTERN_C extern
#endif

#ifdef _cplusplus
extern "C"{
#endif
EXTERN_C int func(int a, int b);
#ifdef _cplusplus
}
#endif

5、MFC提供了一些宏，可以使用AFX_EXT_CLASS来代替__declspec(DLLexport)，并修饰类名，从而导出类，AFX_API_EXPORT来修饰函数，AFX_DATA_EXPORT来修饰变量
AFX_CLASS_IMPORT：__declspec(DLLexport)
AFX_API_IMPORT：__declspec(DLLexport)
AFX_DATA_IMPORT：__declspec(DLLexport)
AFX_CLASS_EXPORT：__declspec(DLLexport)
AFX_API_EXPORT：__declspec(DLLexport)
AFX_DATA_EXPORT：__declspec(DLLexport)
AFX_EXT_CLASS：#ifdef _AFXEXT
    AFX_CLASS_EXPORT
        #else
    AFX_CLASS_IMPORT

6、DLLMain负责初始化(Initialization)和结束(Termination)工作，每当一个新的进程或者该进程的新的线程访问DLL时，或者访问DLL的每一个进程或者线程不再使用DLL或者结束时，都会调用DLLMain。但是，使用TerminateProcess或TerminateThread结束进程或者线程，不会调用DLLMain。

7、一个DLL在内存中只有一个实例
DLL程序和调用其输出函数的程序的关系：
1)、DLL与进程、线程之间的关系
DLL模块被映射到调用它的进程的虚拟地址空间。
DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。
DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。
DLLDLL可以有自己的数据段，但没有自己的堆栈，使用调用进程的栈，与调用它的应用程序相同的堆栈模式。

2)、关于共享数据段
DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread Local Strorage)。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/jia_xiaoxin/archive/2008/09/02/2868216.aspx

c++内存分配优先使用内存池，而不是new，delete

转载

原文出处：http://www.devdiv.net/home/space.php?uid=125&do=blog&id=364

认识一下new和delete的开销：

new和delete首先会转调用到malloc和free，这个大家应该很熟识了。很多人认为malloc是一个很简单的操作，其实巨复杂，它会执行一个系统调用，从用户态转到内核态，该系统调用会锁住内存硬件，然后通过链表的方式查找空闲内存，如果找到大小合适的，就把用户的进程地址映射到内存硬件地址中，然后释放锁，返回用户态。delete是一个反过程。

相对的，如果不是使用堆分配，而是直接在栈上分配，比如类型int，那么开销就是把sp这个寄存器加上sizeof(int)。

内存池模式：

       内存池就是预先分配好，放到进程空间的内存块，用户申请与释放内存其实都是在进程内进行，SGI-STL的alloc遇到小对象时就是基于内存池的。只有当内存池空间不够时，才会再从系统找一块很大的内存。

       内存池模式是如此之重要，以至于让我想不明白为什么四人帮那本《设计模式》没有把内存池列为基本模式，目前其它的教材，包括学院教材，实践教材都没有列出这个模式(讲线程池模式的教材倒非常多)。可能他们认为这不属于设计，而属于具体实现吧。但我觉得这样的后果是间接把很多c++ fans带向低效的编码方式。

sun公司就挺喜欢搞一些算法，用c++实现与java实现一遍，结果显示c++的效率有时甚至比java低，很多c++高手看了之后都会觉得很难解，其实有玄机：java的new其实是基于内存池的，而c++的new是直接系统调用。

c++内存池模式的发展：

       c++98标准之前，基本上大多数程序员没用使用内存池，c++98 标准之后，内存池的使用也只是停留在STL内部的使用上，并没有得到推广。

       其实我认为，STL的内存分配模式是一场变革，它不但包含内存分配的革命，也包含了内存管理(这个话题先放一边)的革命，只是这场变革被很多人忽略了。也有一些人认为STL的内存分配方案有潜在问题，就是只管从系统分配，但却永远不会调用系统级的释放，如果使用不当，程序拿住的内存会越来越多。我自己工作过的项目没遇上过这样的问题，但之前营帐报表组的一个容灾项目倒是遇上了。不过STL的内存模式没有推广最大的原因还是因为alloc不是标准组件，以至于被人忽略了。

       STL之后，一些c++ fans们开始搞出了几套内部使用的内存池。为了项目需要，我自己也曾经做过一个。但这些都没有很正式的公开，而且也不完美。

       大概在200x年(-_-!)，主导c++标准的一群牛人发起了一个叫boost的项目，才正式的把内存池带到实用与标准化阶段。

插入一点题外话：关于boost，很多人(包括我自己也曾经)产生误解，认为它是准标准库，是下一代标准库。其实boost是套基础建设，用来证明哪些方案是可行，哪些是不可行的，它里面的一些组件有可能会出局，也有可能不是以库的方式存在，而是以语言核心的方式存在，下一代标准库名字叫TR1，再一下代叫TR2(我对使用TR这个名字很费解，为什么不统一叫STL呢)。

new,delete调用与内存池调用的效率对比：

讲了这么多费话，要到关键时候了，用事例来证明为什么要优先使用内存池。下面这段代码是我很久以前的一段测试案例，细节上可能有点懂难，但流程还是清晰的：

#include <time.h>

#include <boost/pool/object_pool.hpp>

struct CCC

{

    CCC() {}

    char data[10];

};

struct SSS

{

    SSS() {}

    short data[10];

};

struct DDD

{

    DDD() {}

    double data[10];

};

// 把new,delete封装为一个与boost::object_pool一样的接口，以便于测试

template <typename element_type, typename user_allocator = boost::default_user_allocator_malloc_free>

class new_delete_alloc

{

public:

    element_type* construct() { return new element_type; }

    void destroy(element_type* const chunk) { delete chunk; }

};

template

< 

    template<typename, typename>

    class allocator

> 

double test_allocator()

{

    // 使用了一些不规则的分配与释放，增加内存管理的负担

    // 但总体流程还是很规则的，基本上不产生内存碎片，要不然反差效果会更大。

    allocator<CCC> c_allc;

    allocator<SSS> s_allc;

    allocator<DDD> d_allc;

    double re = 0; // 随便作一些运算，仿止编译器优化掉内存分配的代码

    for (unsigned int i = 0; i < 10000; ++i)

    {

        for (unsigned int j = 0; j < 10000; ++j)

        {

            CCC* pc = c_allc.construct();

            SSS* ps = s_allc.construct();

            re += pc->data[2];

            c_allc.destroy(pc);

            DDD* pd = d_allc.construct();

            re += ps->data[2];

            re += pd->data[2];

            s_allc.destroy(ps);

            d_allc.destroy(pd);

        }

    }

    return re;

}

int main(int argc, char* argv[])

{

    double re1 = 0;

    double re2 = 0;

    // 运行内存池测试时，基本上对我机器其它进程没什么影响

    time_t begin = time(0);

    re1 = test_allocator<boost::object_pool>(); // 使用内存池boost::object_pool

    time_t seporator = time(0);

    // 运行到系统调用测试时，感觉机器明显变慢，

    // 如果再加上内存碎片的考虑，对其它进程的影响会更大。

    std::cout << long(seporator - begin) << std::endl;

    re2 = test_allocator<new_delete_alloc>();           // 直接系统调用

    std::cout << long(time(0) - seporator) << std::endl;

    std::cout << re1 << re2 << std::endl;

}

总结：

在一个100000000次的循环中，使用内存池是3秒，使用系统调用是93秒。

可能会有人觉得100000000这个数很大，93秒没什么，但想一下，一个表有几千万行是很正常的，如果每行有十多列，每列有数据类型，数据长度，数据内容。如果在这样的一个循环错误的使用了new和delete。

而且以上测试还没有考虑到碎片的影响，以及运行该程序时对其它程序的影响。而且还有一点，就是机器的内存硬件容量越大，内存分配时，需要搜索的时间就可能越长，如果内存是多条共同工作的，影响就再进一步。

什么算是错误的使用呢，比如返回一个std::string给用户，有人觉得new出来返回指针给用户会更好，你可能会想到如果new的话，只产生一次string的构造，如果直接返回对象可能需要多次构造，所以new效率更高。但事实不是这样，虽然在构造里会有字符串的分配，但其实这个分配是在内存池中进行的，而你直接的那个new就肯定是系统调用。

当然，有些情况是不可说用什么就用什么的，但如果可选的话，优先使用栈上的对象，其次考虑内存池，然后再考虑系统调用。

一般来说，动态链接库在内存中只会加载一次

每个进程需要调用到次动态链接库的时候，都会从这一个内存地址中加载

但，如果进程需要改动动态链接库中的信息，哪怕是全局变量，系统也会从内存中重新分配出一小块区域，来进行这些变量的存储

那么与之对应的，每一个进程，所修改的动态链接库，只能是自己的一份，不能在所有进程中共享的

如果想在所有进程中共享一份动态链接库数据，则需要在DLL中设置一个共享的 “段”。
 

以下代码是定义一个节并给节命名为MySec，HWND g_hWnd=NULL;为将放在节中的数据

#pragma data_seg("MySec")
HWND g_hWnd=NULL;
#pragma data_seg()

 注意：但是放在 MySec 段中的变量必须要被初始化。飞走而编译器就会将该变量放到 MySec 段以外
的其他段中。

仅定义一个数据段还不能达到共享数据的目的，还要告诉编译器该段的属性，有两种方法可以实现该目的（其效果是相同的），一种方法是在.DEF文件中加入如下语句：

SETCTIONS

　　MySec READ WRITE SHARED

另一种方法是在项目设置链接选项中加入如下语句：

　　/SECTION:shareddata,rws

RWS：r为读，w为写，s为共享


或者 使用一种更方便的方法，直接将连接器开关嵌入到 dll 的源代码中。

#pragma comment(linker,"/section:MySec,RWS")

VC2005运行库是VC2005编译出来的程序运行所依赖的库（不包括.NET支持），采用manifest方式来指定dll文件。如果将程序.exe文件直接拷贝到没有安装过VC2005的计算机上运行运行，往往会出现找不到msvcr80.dll、mfc80.dll文件等错误。

解决方案：
解决方式一、在目标系统上安装2005版vcredist_x86.exe（全称Microsoft Visual C++ 2005 Redistributable Package (x86)）。微软官方下载地址：http://download.microsoft.com/download/d/3/4/d342efa6-3266-4157-a2ec-5174867be706/vcredist_x86.exe

解决方案二、直接拷贝VS8目录下的VC \ redist \ x86 \ 目录下的 Microsoft.VC80.MFC、Microsoft.VC80.CRT、Microsoft.VC80.MFCLOC几个文件夹，到exe所在的目录下，目录结构如下：
.\myapp.exe
.\myapp.dll
.\Microsoft.VC80.CRT\
.\Microsoft.VC80.MFC\
.\Microsoft.VC80.MFC\Microsoft.VC80.MFCLOC\
然后修改Microsoft.VC80.MFCLOC目录下的Microsoft.VC80.MFCLOC.manifest文件，将其中的version=”8.0.50727.42″，修改为version=”8.0.50608.0″。
为了避免保证VS8的完整性，建议先将Microsoft.VC80.MFCLOC的文件拷出来后再修改。

C++是一门广泛用于工业软件研发的大型语言。它自身的复杂性和解决现实问题的能力，使其极具学术研究价值和工业价值。和C语言一样，C++已经在许多重要的领域大获成功。

然而，一个不可否认的现实是，在低阶程序设计领域，C++挤压着C同时也在承受着C的强烈反弹，而在高阶程序设计领域，Java和C#正在不断蚕食着C++的地盘。也许C++与C合为一体永远都是一个梦想，也许Java和C#的狂潮终将迫使C++回归本位 — 回到它有着根本性优势的开发领域：低级系统程序设计、高级大规模高性能应用设计、嵌入式程序设计以及数值科学计算等。果真如此，我认为这未尝不是一件好事。

C++吸引如此之多的智力投入，以至于这个领域的优秀作品，包括重量级的软件产品、程序库以及书籍等，数不胜数。文题“C++程序设计之四书五经”一个不太严格的含义是：C++程序设计之四书 ⅹ 五经。是的，在本文（及其下篇）中，我将分门别类推荐20多本C++好书，你可以根据自己的需要选读。

TCPL和D&E

TCPL和D&E分别是《The C++ Programming Language》和《The Design and Evolution of C++》的简称，均出自Bjarne Stroustrup之手。我将它们单列出来，首先是因为Bjarne是C++语言的创建者，然后是因为比“首先”那个原因更重要的原因：这两本书是C++领域毋庸置疑的杰作。说它们是C++语言圣经，并不为过。

Bjarne Stroustrup, The C++ Programming Language (Special 3rd Edition)

《C++程序设计语言（特别版）》，机械工业出版社

《C++程序设计语言（特别版）（英文影印版）》，高等教育出版社

迄今为止，TCPL是除了C++标准文献之外最权威的C++参考手册。和大多数人的看法不大一样，我认为Bjarne的文字语言并不逊色于他所创建的程序语言，至少我喜欢这种学院气息浓厚的作品。本书对C++语言的描述轮廓鲜明、直截了当。它从C++语言创建者的角度来观察C++，这是任何别的作者和书籍做不到的 — 没有任何人比Bjarne自己更清楚该怎么来使用C++。

这是一本严肃的著作，以中、高级C++开发人员为目标读者。如果你是一名有经验的C++程序员，需要了解更加本质的C++知识，本书正是为你而写。它不是那种让你看了会不断窃喜的小书，需要用心体会，反复咀嚼。在阅读过程中，请特别留心Bjarne先生强调了什么，又对什么一语带过。我个人比较喜欢这本书的第四部分“使用C++做设计”，这样的内容在类似的程序设计语言书籍中很难看到 — 我甚至认为Bjarne应该将这部分独立出来单独写一本书。

Bjarne Stroustrup, The Design and Evolution of C++

《C++语言的设计和演化》，机械工业出版社

《C++语言的设计和演化（英文版）》，机械工业出版社

D&E是一本关于C++语言设计原理、设计决策和设计哲学的专著。它清晰地回答了C++为什么会成为今天这个样子而没有变成另外一种语言。作为C++语言的创建者，Bjarne淋漓尽致地展示了他独到而深刻的见解。除了广受赞誉的语言特性外，Bjarne没有回避那些引起争议的甚至被拒绝的C++特性，他一一给出了逻辑严密、令人信服的解释。内容涵盖C++的史前时代、带类的C、C++的设计规则、标准化、库、内存管理、多重继承、模板等，对包括异常机制、运行时类型信息和名字空间在内的重要的新特性都分别进行了深入探讨。每一名C++程序员都应该可以从Bjarne的阐释中加深对手中这门语言的认识。

需要再次提醒的是，这两本书知识浓缩，信息量极大，请不要错过Bjarne每一句看似漫不经意的话。

入门教程

学习任何一门语言都需要一个从入门到精通、从新手到高手循序渐进的过程。不过，对于一个所谓的新手而言，究竟是一个完完全全的新手，还是一个熟悉某种别的语言的“新手”，甚至是在某种语言程序设计领域已经颇有建树的高手，很难一概而论？不同的C++新手需要不同的入门书籍。

Andrew Koenig, Barbara E. Moo, Accelerated C++: Practical Programming by Example

《Accelerated C++中文版》，中国电力出版社

和市面上大多数C++教程不同，本书不是从“C++中的C”开始讲解，而是始于地道的C++特性。从一开始就使用标准库来写程序，随着讲述的逐渐深入，又一一解释这些标准库组件所依赖的基础概念。另外，和其他C++教材不同的是，这本书以实例拉动语言和标准库的讲解，对后两者的讲解是为了给实例程序提供支持，而不是像绝大多数C++教材那样，例子只是用作演示语言特性和标准库用法的辅助工具。

作者在C++领域的编程实践、教育培训以及技术写作方面都是世界一流水准。我喜欢这种大量使用标准库和C++语言原生特性的清新的写作风格。在这本教材面前，几乎迄今为止的所有C++教材都黯然失色或显得过时。尽管这本教材也许对于国内的高校教育来说有些前卫，不过我仍然极力向我的同行们推荐。顺带一提，在Bjarne和我最近的一封通信里，他这样评价本书：对于有经验的程序员学习C++而言，这本书可能是世界上最好的一本。

Stanley B.Lippman, Josee Lajoie, C++ Primer (3rd Edition)

《C++ Primer (3RD)中文版》，中国电力出版社

这本书的名字多少有点让人误解。尽管作者声称这本书是为C++新手而写，但无论是它的厚度还是讲解的深度都暴露了似乎并非如此。也许说它是一本“从入门到精通”的C++教程会更合适一些。我个人认为它并不适合完全不懂C++的初学者 — 在阅读这本书之前，你至少应该先有那么一点C或C++的背景知识，或者至少要具有一些其他语言的编程经验。

尽管这本书省略了一些高级C++特性的讨论，但仍然可以称得上是迄今为止最全面的C++学习教程。事实上，如果一名C++初学者能够扎扎实实地读完本书并对照《C++ Primer Answer Book》完成全部习题的话，他的水平肯定可以进入职业C++程序员的行列。我个人认为，即使你已经拥有了TCPL，这本书依然有拥有的价值，因为在许多方面它比TCPL来得更详细、更易懂。

Stanley B. Lippman, Essential C++

《Essential C++中文版》，华中科技大学出版社

《Essential C++（影印版）》，中国电力出版社

可以不太严格地认为这本书是《C++ Primer》的精简版。本书一一讲述了C++中最具代表性的主题，包括过程式编程、泛型编程、基于对象编程、面向对象编程、模板编程以及异常处理等。Stanley将门槛调低到“具有其他语言程序设计经验”的C++新手所能接受的最基本的层次，使他们能够迅速开始使用C++编程而又免于阅读《C++ Primer》那样的大部头。它以实例引导学习，力图使读者在最短的时间内把握C++的精粹。

也许换一个人来概述C++编程范型（paradigm）的方方面面需要好几百页才能说清楚，但这本小书不可思议地做到了这一点。我个人非常喜欢这种满是技术、简明扼要并且“有话好好说”的书。这本书同样具有一个明显的风格：所有程序例子全部采用标准库组件，让人耳目一新。

以上三本书都不是为了完完全全的编程新手而写。完全的C++编程新手可以阅读Francis Glassborow的新书（尚未出版）：《A Beginners Introduction to Computer Programming : You Can Do It!》。这也是Bjarne的推荐。Francis Glassborow是ACCU主席，多年来他对几乎每一本C++经典名著评头论足，他自己的这一本自然会引起C++社群的极大兴趣。

高效、健壮编程

两年前我在负责一个省级电力调度系统项目时编写了一个网关程序，它从SCADA系统获取电力实时信息。通讯接口采用了不常用的数据库直连方式（这个网关程序一端连接SQL Server 6.5，另一端连接Oralce 8.1.6）。由于实时测点近万，每次将全部取样更新或插入一遍显然是低效的。我在网关程序里建了一个内存库，获取到的数据首先在其中进行比较，然后决定是否更新物理数据库（同时还做了别的更复杂的事情……），从而在效率和资源占用两方面达到了预期效果。

这个程序一直运行得很好，但在离开现场之后的某一天，系统管理员打来电话，说大概因为网络故障等原因，有时这个网关程序会崩溃掉 — 它自己崩掉也就罢了，问题是它还会把Windows 2000 Advanced Server搞成“蓝屏”！坦白地说，我还从来没看过哪个非蓄意的程序有这个“能耐”。由于当时正忙于另外一个大项目，无法去现场调试，最后只有凭经验对内存库代码小心翼翼地封装以异常处理代码（同时也做了一些别的修改……）。这样，虽然没有彻底解决问题，但程序终究不再死得那么难看了。

在这儿讲这么一段花絮有什么意思呢（当初为那个可怕的bug朝思暮想时我可不认为这是一个“花絮”）？我想说的是，对于任何软件而言，离开强健，效率也就无从谈起。而对于C++程序员来说，也许编写一个高效的程序并不难，但要编写一个需要7 ⅹ 24小时持续运行的服务端软件就不是那么容易了，需要考虑许多因素，有时这些因素甚至远远超出C++语言和开发工具的本身。作为一名开发实际项目软件的程序员，并非非得自己碰钉子才能积累经验，只要我们足够虚心，别人的经验往往都是我们很好的借鉴。鉴于此，我推荐以下几本书供你选读，它们可以让你从强健和效率两方面受益（当然了，它们涵盖的内容远不限于异常处理J）。

Scott Meyers, Effective C++: 50 Specific Ways to Improve Your Programs and Design (2nd Edition)

Scott Meyers, More Effective C++: 35 New Ways to Improve Your Programs and Designs

《Effective C++中文版》，华中科技大学出版社

《More Effective C++中文版》，中国电力出版社

《Effective C++（影印版）》，中国电力出版社

如果说《Effective C++》主要讨论C++中一些相对基础的概念和技巧的话，那么《More Effective C++》则着重探讨了包括异常处理在内的一系列高级技术。与前者相比，后者具有两大主要区别：其一，它包含很多时新的标准C++的内容；第二，它讨论的主题倾向于“战略化”而非“战术化”，并且讨论得更深入、更彻底。尤其是对虚析构函数、智能指针、引用计数以及代理类（proxy classe）等技术和模式论述的深入程度，让人很难想象是出现于这样的一本小书之中。

游刃有余的技术，高超的写作技巧，Scott无疑是世界上最优秀的C++技术作家之一。在简洁、清晰、易读等方面，这两本书都卓尔不群。总之，Scott提供的这85个可以改善编程技术和设计思维的方法，都是中、高级C++程序员必备的技能。我强烈推荐这两本书（实际上还有一本，稍后就会看到）。

Herb Sutter, Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions

Herb Sutter, More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions

《Exceptional C++中文版》，中国电力出版社

《More Exceptional C++中文版》，华中科技大学出版社

你自认为是一名C++语言专家吗？读一读ISO C++标准委员会秘书长的这两本书再回答。在这两本书中，Herb采用了“问答”的方式指导你学习C++语言特性。对于每一个专题，Herb首先合理地设想出你的疑问和困惑，接着又猜测出你十有八九是错误的解答，然后给你以指点并提出最佳解决方案，最后还归纳出解决类似问题的普适性原则。

这两本书是典型的深究C++语言细节的著作，很薄，但内容密集，远远超过Scott的那两本书，读起来很费脑筋 — 我个人认为它们要比Scott的书难懂得多。若要研习这薄薄的两本书所包含的知识，至少需要花费数月的时间！（在Scott的荐序中，他坦陈不止一次陷入GotW问题的陷阱，你应该知道这意味着什么）对于语言细节的深究有什么好处呢？尽管在大多数情况下，我们不必关心C++代码幕后的动作，然而当我们不得不关心时，这两本书可以为我们提供很好的线索，因为它们揭示了C++语言中微妙而又至关重要的东西。

Stephen C. Dewhurst, C++ Gotchas: Avoiding Common Problems in Coding and Design

《C++程序设计陷阱》，中国青年出版社

Stephen的理论素养和实践经验注定这是一本值得一读的好书。Stephen曾经是贝尔实验室中第一批C++使用者。他已经使用C++成功解决了包括编译器、证券交易、电子商务以及嵌入式系统等领域中的问题。本书汇集了作者来自开发一线的99条编程真知灼见，洞悉它们，你可以避免几乎所有常见的C++设计和编程问题。

我甚至认为，对于C++编程菜鸟而言，阅读这本书会比阅读Scott和Herb的书更能轻松而立竿见影地获得更大的提高。我个人很喜欢这本书的写作风格 — Stephen的许多观点看似极端却无可辩驳。当然了，这种自信（以及冷幽默）来自于作者深厚的技术素养，而非自大的偏执。

除了上面推荐的书籍外，Dov Bulka和 David Mayhew合著的《Efficient C++: Performance Programming Techniques》（《提高C++性能的编程技术》，清华大学出版社）也值得一看。这本超薄小书聚焦于高性能C++应用程序开发。两位作者都是IBM软件专家，都工作于对性能要求极高的系统构建领域，本书是他们的经验之谈。也有人不喜欢这本书，因为它花了不少的篇幅讲述和C++无关的东西，我却恰恰因为这一点而对这本书产生好感，正是这些东西让我开阔了眼界。

模板和泛型编程

模板和基于模板的泛型编程无疑是当今发展最活跃的C++程序设计技术。模板的第一个革命性的应用是STL，它将模板技术在泛型容器和算法领域的运用展现得淋漓尽致，而Boost、Loki等现代程序库则将模板技术的潜能不断发挥到极致。在模板和泛型编程领域，我推荐以下两本重量级著作：

David Vandevoorde, Nicolai M. Josuttis, C++ Templates: The Complete Guide

《C++ Templates全览（繁体版）》，台湾碁峰资讯股份有限公司

《C++ Templates全览（简体版）》，人民邮电出版社

有一种老套的赞美一本书的手法，大致是“没有看过这本书，你就怎么怎么地”，这里面往往夸张的成分居多。不过，倘若说“没有看过《C++ Templates: The Complete Guide》，你就不可能精通C++模板编程”，那么这个论断对于世界上绝大多数C++程序员来说是成立的。

这本书填补了C++模板书籍领域由来已久的空白。此前，上有《Modern C++ Design》这样的专注于模板高级编程技术和泛型模式的著作，下有《The C++ Standard Library》这样的针对特定模板框架和组件的使用指南。然而，假如对模板机制缺乏深入的理解，你就很难“上下”自如。鉴于此，我向每一位渴望透彻理解C++模板技术的朋友推荐这本书。

这本书在内地、台湾各有一个译本，但出自不同的译者之手。当你看到这篇文章时，两个译本应该都已经上市，对于读者来说当然也就多了一种选择。侯捷先生个人网站上开放了繁体译本大部分章节，不妨先睹为快。

Andrei Alexandrescu, Modern C++ Design: Generic Programming and Design Patterns Applied

《C++设计新思维：泛型编程与设计模式之应用》，华中科技大学出版社

《C++设计新思维（影印版）》，中国电力出版社

你自认为是C++模板编程高手吗？请看过这本书再回答J 这是一本出自天才之手令人敬畏的杰作。泛型模式，无限延伸你的视野，足以挑战任何一名C++程序员的思维极限。

这本书共分为两大部分，第一部分讨论了 Loki程序库采用的基础技术以及一些高级语言特性，包括基于策略的类设计、模板局部特化、编译期断言、Typelist以及小型对象分配技术等。第二部分则着重介绍了Loki中的重要组件和泛型模式技术，包括泛化仿函数（Generalization Functor）、单件（Singleton）、智能指针、对象工厂（Object Factory）、抽象工厂（Abstract Factory）、访问者（Visitor）以及多方法（Multimethods）等。每一种技术都让人大开眼界，叹为观止。

在C++的学习方面，过犹不及往往成了不求甚解的借口。然而，面向对象并非C++的全部，模板和泛型编程亦占半壁江山。对于“严肃”的C++程序员而言，及时跟进这项早经例证的成功技术，不失为明智之举。

结语

这些著作是如此大名鼎鼎，也许根本不缺我一个推荐。然而，纵然C++程序员队伍的发展壮大速度不像其他更时髦的语言那样迅速，新人进总是多于旧人出。除了热忱地欢迎新人，我个人认为到了对C++书籍进行“盘点”的时候了，并且希望这样的“盘点”有益于感兴趣的读者。请保持耐心和宽厚。在下篇中，我将继续介绍标准库、网络编程以及其他方面的C++好书。有好书相伴，这个冬天不会冷。

C++程序设计之四书五经（下篇）

我在上篇中“盘点”了TCPL和D&E以及入门教程、高效和健壮编程、模板和泛型编程等方面共十几本C++好书。冬去春来，让我们继续C++书籍精彩之旅J

标准库

当我还在研究院工作时，与同院另外两家研究所合作开发过一个大型水利枢纽调度集成项目。我们三家软件系统之间都要相互通信。在调试通讯模块时，细心的客户（一名好学的系统管理员）发现对于同一通信规约的解释代码，我的不超过30行，而对方的则超过了150行且很难看懂。这位系统管理员很纳闷，我说大家编程风格和习惯不一样，我使用了标准库，而他使用了传统C编程风格以及他所习惯的另外一些技术。

别误会！我绝无贬低这位合作伙伴的意思。事实上，我对那些真正有着深厚的C编程功力的程序员常常怀有钦佩之心。毕竟，C++能有今天的成功在很大程度上缘于它深深地植根于C。作为一名C++程序员，倘若不熟悉C++中的C，我往往会认为他的基本功是不扎实的，他的技术底气是不足的。

不过话又说回来，C++是一种多范型（paradigm）编程语言，具体采用哪种编程风格，专业程序员应该知道视具体情况而定。作为一名经常需要在现场做即兴开发的项目负责人，为了短平快地解决当务之急，我习惯尽量采用现有的库（和组件）。效率（以及强健性）久经验证的C++标准库已经摆在那儿了，何乐而不用呢？

Nicolai M. Josuttis, The C++ Standard Library: A Tutorial and Reference

《C++标准程序库：自修教程与参考手册》，华中科技大学出版社

这是一本百科全书式的C++标准库著作，是一本需要一再查阅的参考大全。它在完备性、细致性以及精确性方面都是无与伦比的。本书详细介绍了每一标准库组件的规格和用法，内容涵盖包括流和本地化在内的整个标准库而不仅仅是STL。正如本书副标题所示，它首先适合作为教程阅读，尔后又可用作参考手册。

浅显易懂的写作风格使得这本书非常易读。如果你希望学习标准库的用法并尽可能地发挥其潜能，那你必须拥有这本书。正如网络上所言，这本书不仅仅应该摆在你的书橱中，更应该放到你的电脑桌上。我向每一位职业C++程序员强烈推荐。

Angelika Langer, Klaus Kreft, Standard C++ IOStreams and Locales: Advanced Programmer's Guide and Reference

《标准C++输入输出流与本地化》，人民邮电出版社

C++标准库由STL、流和本地化三部分构成。关于STL的书市面上已经有不少，但罕见流和本地化方面的专著。本书是这两个领域中最优秀的一本，迄今为止没有任何一本书比这一本更全面详尽地讨论了流和本地化。如果你不满足于停留在“会用”流库的层面，千万不要错过它。

2001年夏天，我草草翻阅过这本书的中文版，从内容到包装都给我留下了比较深刻的印象 — 不过负面的居多一些。2003年秋天，无意中得知某网络书店正以超低价格甩卖这本书的中译本，情不自禁，一阵唏嘘。

Scott Meyers, Effective STL: 50 Specific Ways to Improve Your Use of the Standard Template Library

《Effective STL（影印版）》，中国电力出版社

读完Scott 的《Effective C++》和《More Effective C++》的中译本之后，我一直期待这本书的中文版。我从潘爱民先生的个人主页上了解到，他和他的合作伙伴似乎早已完成了这本书的翻译工作，可惜至今市面上仍不得见。幸运的是，我们可以看到它的原版。

本书是使用STL的程序员必读之作。在这本书中，Scott向我们讲述STL容器和算法的工作机制以及如何以最佳方式使用它们。和Scott的其他作品一样，这本书的写作风格清晰、精确，具有极佳的可读性。看过这本书以后，我想你也许会和我以及其他C++程序员一样产生这样的想法：Scott什么时候会写出一本“More Effective STL”？

关于STL，我还提醒你留心Matthew H. Austern的《Generic Programming and the STL: Using and Extending the C++ Standard Template Library》（《泛型编程与STL》，中国电力出版社）。这本书散发着浓厚的学院气息。Andrew Koenig和Barbara Moo在《Accelerated C++: Practical Programming by Example》一书末尾郑重推荐另外两本进阶好书（除了他们自己的《Ruminations on C++》外），其中一本是TCPL，另外一本就是本书！

网络编程

在网络编程时代，C++应该扮演着怎样的角色，让ACE（Adaptive Communications Environment）来告诉你。

Douglas C. Schmidt, Stephen D. Huston, C++ Network Programming, Volume 1: Mastering Complexity with ACE and Patterns

Douglas C. Schmidt, Stephen D. Huston, C++ Network Programming, Volume 2: Systematic Reuse with ACE and Frameworks

《C++网络编程，卷1：运用ACE和模式消除复杂性》，华中科技大学出版社

《C++网络编程，卷2：基于 ACE 和框架的系统化复用》，电子工业出版社

采用C++进行企业级网络编程，目前ACE（以及这两本书）是一个值得考虑的选择。ACE是一个面向对象、跨平台、开放源码的网络编程框架，目标在于构建高性能网络应用和中间件。Douglas是ACE的创始人，Stephen则已为ACE提供了数年的技术支持和顾问服务，两位都是ACE社群（是的，ACE的影响和实际应用的程度已经形成了一个社群）的专家。

ACE并不单单被大学和研究所追捧，它已经被成功地应用于世界上成千上万个商业应用中。在电信、宇航、医药和财经领域的网络系统中，ACE已经并继续发挥着重要的作用。如果你准备开发高性能通讯系统，你应该考虑考虑这一汇集世界顶尖专家智慧的成果。

除了使用C++面向对象设计技术和模板等高级语言特性外，ACE还运用了大量的模式。《C++网络编程》卷1和卷2并不仅仅教你关于ACE的方方面面，它还会教给你模式和通用框架设计等高级技术等。所以，作为一名中、高级C++程序员，即使你很少进行正儿八经的C++网络程序设计，阅读这两本书同样可以从中受益。

是的，并非所有网络应用都要使用Web服务器（以及其他应用服务器）和重量级组件模型，换个思路，它们或许也可以从轻量级的ACE组件中获益。

杂项

以下这几本书之所以被列入“杂项”单元，只是因为我没有考虑出更合适的归类方法，它们和上面的书籍一样，值得一读。

Bruce Eckel, Thinking in C++, Volume 1: Introduction to Standard C++ (2nd Edition)

Bruce Eckel, Thinking in C++, Volume 2: Practical Programming (Second Edition)

《C++编程思想（第2版）第1卷：标准C++导引》，机械工业出版社

《C++编程思想（英文版 第2版）》，机械工业出版社

《Thinking in C++》的第1版于1996年荣获“软件研发”杂志评选的图书震撼大奖。最新推出的第2版对内容进行了大幅改写和调整，以反映C++标准化带来的影响以及近几年面向对象领域最新研究和实践成果。“输入输入流”、“多重继承”、“异常处理”和“运行时类型识别”等高级主题连同C++标准化以后增加的一些内容则被放入第二卷中。Bruce是一名经验丰富的C++讲师和顾问，其培训和写作经验都是世界一流水准，他的作品比那些“玩票”的技术人员写的东西更能吸引读者。事实上，在同类图书中，对于大多数读者而言，这本书的可读性要超过TCPL和《C++ Primer》。顺带一提，访问作者的站点，你可以先睹第二卷的风采。

Andrew Koenig, Barbara E. Moo, Ruminations on C++: A Decade of Programming Insight and Experience

《C++沉思录》，人民邮电出版社

Andrew是世界上屈指可数的C++专家。这是一本关于C++编程思想和程序设计技术而非语言细节的著作。如果你已经具有一定的基础，这本书将教你在进行C++编程时应该怎样思考，应该如何表达解决方案。整本书技术表达透彻，文字通俗易懂。Bjarne这样评价这本书：本书遍布“C++是什么、C++能够做什么”的真知灼见。

Stanley B. Lippman, Inside The C++ Object Model

《深度探索C++对象模型》，华中科技大学出版社

《深度探索C++对象模型（影印版）》，中国电力出版社

从编译器的角度观察C++可以使你知其然并知其所以然。本书探讨了大量的C++面向对象程序设计的底层运作机制，包括构造函数、函数、临时对象、继承、虚拟、模板的实例化、异常处理、运行期类型识别等，另外还介绍了一些在实现C++对象模型过程中做出的权衡折衷。喜欢刨根问底的C++程序员不要错过这本书。

Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Design Patterns: Elements of Reusable Object-Oriented software

《设计模式：可复用面向对象软件的基础》，机械工业出版社

《设计模式：可复用面向对象软件的基础（英文版）》，机械工业出版社

设计可复用的面向对象的软件，你需要掌握设计模式。本书并非专为C++程序员而写，但它采用了C++（以及Smalltalk）作为主要示例语言，C++程序员尤其易于从中受益。四位作者都是国际公认的面向对象软件领域专家，他们将面向对象软件的设计经验作为设计模式详细记录下来。这本书影响是如此深远，以至于四位作者以及本书都被昵称为GoF（Gang of Four）。本书学院气息浓厚，行文风格严谨简洁，虽然它不如某些讲解模式的书籍易读，但真正要精准地理解设计模式，本书是终极权威。学习设计模式，这本书需要一而再、再而三的咀嚼。顺带一句：请将设计模式化作开拓思维的钥匙，切莫成为封闭思维的枷锁。

还有一些C++好书值得一读，恕此处无法一一列出。例如John Lakos的著作《Large-Scale C++ Software Design》（《大规模C++程序设计》，中国电力出版社）和侯捷先生的《STL 源码剖析》（华中科技大学出版社）等。

《STL 源码剖析》是一本很有特色的书，但我认为它还可以更好。我个人期待侯捷先生自第一版发行以来经过对模板技术的沉淀和再思考之后，再写一本剖析得更深入、更透彻并且更全面的“第二版”。遗憾的是，侯捷先生在完成《C++ Templates: The Complete Guide》一书的翻译后似乎决定暂时告别模板、泛型编程和STL领域。

2004年3月31日补充：我目前最常查阅的两本参考书是《C++标准程序库》和《STL源码剖析》。当然了，这与我年内的写作计划有很大的关系。

使用C++成功开发大规模软件系统，不仅需要很好地理解大多数C++书籍中讲述的逻辑设计问题，更需要掌握《大规模C++程序设计》中讲述的物理设计技术。当然，这本书的确有点过时了，不过，如果你的精力和金钱都比较宽绰，买一本看看并无坏处。

至此，我想有必要声明一下，有一些（好）书没有得到推荐，主要原因如下：

以上这些书已经足够多、足够好了。

我不会推荐通过正常渠道很难购买到的书籍 — 不管是中文版还是英文版。

作（译）者名气大小不影响我的推荐。我们是在看书，不是看人。

我不会推荐我从来没有看过的书。我至少要看过其中的某个版本（包括电子档）。这个“看”，一般指“认真阅读”，不过有一些也只能算是“浏览”。

结语

作为一名普通技术写译者，我深知技术创作和翻译的艰辛（和快乐），并多多少少了解一些有关技术书籍创作、翻译、制作、出版以及市场推介背后的细节。今天，我不会再对一本看上去差强人意的图书信口开河。罗列同一本书的各种版本的用意只在于为你多提供一些信息，让你多一种选择。

在本文成文的后期，我给Bjarne写了一封信，请教如果他来写这篇文章会怎么写。他给了我简明扼要的建议。在肯定以上列出的绝大部分图书都是世界顶尖水平的C++著作的同时，Bjarne提醒我别忘了向专家级程序员推荐《The C++ Standard : Incorporating Technical Corrigendum No. 1》。这本书是 C++标准规范的“图书版”，Bjarne亲自为之作序。

Bjarne还友好地提醒我，在我的推荐列表中没有哪一本有助于C++程序员进行Windows编程 — 这正是我的本意。在这篇文章中，我只推荐、点评平台中立的C++著作（网络编程除外） — 和操作系统无关，和集成开发环境无关，我甚至幻想它们和编译器也无关。你可以根据业务开发需要，选读自己喜爱的领域相关的C++书籍。

说到“系统无关、平台中立”，我不由得想起了“抽象层”的概念。开发实际应用的C++程序员通常工作于特定操作系统、特定开发环境和特定业务领域之中，而对标准C++和C++标准库扎实而深刻的把握，无疑是你得以在不同的操作系统、不同的开发环境以及不同的业务领域之间纵横驰骋的“抽象”本钱。

    　　多态性是面向对象程序设计的重要特征之一。它与前面讲过的封装性和继承性构成了面向对象程序设计的三大特征。这三大特征是相互关联的。封装性是基础，继承性是关键，多态性是补充，而多态又必须存在于继承的环境之中。

    　　所谓多态性是指发出同样的消息被不同类型的对象接收时导致完全不同的行为。这里所说的消息主要是指对类的成员函数的调用，而不同的行为是指不同的实现。利用多态性，用户只需发送一般形式的消息，而将所有的实现留给接收消息的对象。对象根据所接收到的消息而做出相应的动作(即操作)。

    　　函数重载和运算符重载是简单一类多态性。函数重载的概念及用法在《函数重载》一讲中已讨论过了，这里只作简单的补充，我们重点讨论的是运算符的重载。

    　　所谓函数重载简单地说就是赋给同一个函数名多个含义。具体地讲，C++中允许在相同的作用域内以相同的名字定义几个不同实现的函数，可以是成员函数，也可以是非成员函数。但是，定义这种重载函数时要求函数的参数或者至少有一个类型不同，或者个数不同。而对于返回值的类型没有要求，可以相同，也可以不同。那种参数个数和类型都相同，仅仅返回值不同的重载函数是非法的。因为编译程序在选择相同名字的重载函数时仅考虑函数表，这就是说要靠函数的参数表中，参数个数或参数类型的差异进行选择。 由此可以看出，重载函数的意义在于它可以用相同的名字访问一组相互关联的函数，由编译程序来进行选择，因而这将有助于解决程序复杂性问题。如：在定义类时，构造函数重载给初始化带来了多种方式，为用户提供更大的灵活性。

    　　下面我们重点讨论运算符重载。

    　　运算符重载就是赋予已有的运算符多重含义。C++中通过重新定义运算符，使它能够用于特定类的对象执行特定的功能，这便增强了C++语言的扩充能力。

    　　运算符重载的几个问题

    　　1. 运算符重载的作用是什么？

    　　它允许你为类的用户提供一个直觉的接口。

    　　运算符重载允许C/C++的运算符在用户定义类型(类)上拥有一个用户定义的意义。重载的运算符是函数调用的语法修饰：

    class Fred
    {
    public:
    // ...
    };

    #if 0
    // 没有算符重载：
    Fred add(Fred, Fred);
    Fred mul(Fred, Fred);

    Fred f(Fred a, Fred b, Fred c)
    {
    return add(add(mul(a,b), mul(b,c)), mul(c,a)); // 哈哈，多可笑...
    }
    #else
    // 有算符重载：
    Fred operator+ (Fred, Fred);
    Fred operator* (Fred, Fred);

    Fred f(Fred a, Fred b, Fred c)
    {
    return a*b + b*c + c*a;
    }
    #endif
    　　2. 算符重载的好处是什么？

    　　通过重载类上的标准算符，你可以发掘类的用户的直觉。使得用户程序所用的语言是面向问题的，而不是面向机器的。

    　　最终目标是降低学习曲线并减少错误率。

    　　3. 哪些运算符可以用作重载？

    　　几乎所有的运算符都可用作重载。具体包含：

    　　算术运算符：+,-,*,/,%,++,--;
    　　位操作运算符：&,,~,^,＜＜,＞＞
    　　逻辑运算符：!,&&,;
    　　比较运算符：＜,＞,＞=,＜=,==,!=;
    　　赋值运算符：=,+=,-=,*=,/=,%=,&=,=,^=,＜＜=,＞＞=;
    　　其他运算符：[],(),-＞,,(逗号运算符),new,delete,new[],delete[],-＞*。

    　　下列运算符不允许重载：

    　　.,.*,::,?:

    　　4. 运算符重载后，优先级和结合性怎么办？

    　　用户重载新定义运算符，不改变原运算符的优先级和结合性。这就是说，对运算符重载不改变运算符的优先级和结合性，并且运算符重载后，也不改变运算符的语法结构，即单目运算符只能重载为单目运算符，双目运算符只能重载双目运算符。

    　　5. 编译程序如何选用哪一个运算符函数？

    　　运算符重载实际是一个函数，所以运算符的重载实际上是函数的重载。编译程序对运算符重载的选择，遵循着函数重载的选择原则。当遇到不很明显的运算时，编译程序将去寻找参数相匹配的运算符函数。

    　　6. 重载运算符有哪些限制？

    　　(1) 不可臆造新的运算符。必须把重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中。

    　　(2) 重载运算符坚持4个“不能改变”。

    　　·不能改变运算符操作数的个数；
    　　·不能改变运算符原有的优先级；
    　　·不能改变运算符原有的结合性；
    　　·不能改变运算符原有的语法结构。

    　　7. 运算符重载时必须遵循哪些原则？

    　　运算符重载可以使程序更加简洁，使表达式更加直观，增加可读性。但是，运算符重载使用不宜过多，否则会带来一定的麻烦。

    　　使用重载运算符时应遵循如下原则：

    　　(1) 重载运算符含义必须清楚。

    　　(2) 重载运算符不能有二义性。


运算符重载函数的两种形式

    　　运算符重载的函数一般地采用如下两种形式：成员函数形式和友元函数形式。这两种形式都可访问类中的私有成员。

    　　1. 重载为类的成员函数

    　　这里先举一个关于给复数运算重载复数的四则运算符的例子。复数由实部和虚部构造，可以定义一个复数类，然后再在类中重载复数四则运算的运算符。先看以下源代码：

    #include ＜iostream.h＞

    class complex
    {
    public:
    complex() { real=imag=0; }
    complex(double r, double i)
    {
    real = r, imag = i;
    }
    complex operator +(const complex &c);
    complex operator -(const complex &c);
    complex operator *(const complex &c);
    complex operator /(const complex &c);
    friend void print(const complex &c);
    private:
    double real, imag;
    };

    inline complex complex::operator +(const complex &c)
    {
    return complex(real + c.real, imag + c.imag);
    }

    inline complex complex::operator -(const complex &c)
    {
    return complex(real - c.real, imag - c.imag);
    }

    inline complex complex::operator *(const complex &c)
    {
    return complex(real * c.real - imag * c.imag, real * c.imag + imag * c.real);
    }

    inline complex complex::operator /(const complex &c)
    {
    return complex((real * c.real + imag + c.imag) / (c.real * c.real + c.imag * c.imag),
    (imag * c.real - real * c.imag) / (c.real * c.real + c.imag * c.imag));
    }

    void print(const complex &c)
    {
    if(c.imag＜0)
    cout＜＜c.real＜＜c.imag＜＜'i';
    else
    cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i';
    }

    void main()
    {
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout＜＜"\nc1+c2=";
    print(c3);
    c3 = c1 - c2;
    cout＜＜"\nc1-c2=";
    print(c3);
    c3 = c1 * c2;
    cout＜＜"\nc1*c2=";
    print(c3);
    c3 = c1 / c2;
    cout＜＜"\nc1/c2=";
    print(c3);
    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout＜＜"\n(c1+c2)*(c1-c2)*c2/c1=";
    print(c3);
    cout＜＜endl;
    }
    　　该程序的运行结果为：

    c1+c2=6+1i
    c1-c2=-2+5i
    c1*c2=14+8i
    c1/c2=0.45+0.8i
    (c1+c2)*(c1-c2)*c2/c1=9.61538+25.2308i
    　　在程序中，类complex定义了4个成员函数作为运算符重载函数。将运算符重载函数说明为类的成员函数格式如下：

    　　＜类名＞ operator ＜运算符＞(＜参数表＞)

    　　其中，operator是定义运算符重载函数的关键字。

    　　程序中出现的表达式：

    　　c1+c2

    　　编译程序将给解释为：

    　　c1.operator+(c2)

    　　其中，c1和c2是complex类的对象。operator+()是运算+的重载函数。

    　　该运算符重载函数仅有一个参数c2。可见，当重载为成员函数时，双目运算符仅有一个参数。对单目运算符，重载为成员函数时，不能再显式说明参数。重载为成员函数时，总时隐含了一个参数，该参数是this指针。this指针是指向调用该成员函数对象的指针。

    　　2. 重载为友元函数

    　　运算符重载函数还可以为友元函数。当重载友元函数时，将没有隐含的参数this指针。这样，对双目运算符，友元函数有2个参数，对单目运算符，友元函数有一个参数。但是，有些运行符不能重载为友元函数，它们是：=,(),[]和-＞。

    　　重载为友元函数的运算符重载函数的定义格式如下：

    　　friend ＜类型说明符＞ operator ＜运算符＞(＜参数表＞)
    　　{……}

    　　下面用友元函数代码成员函数，重载编写上述的例子，程序如下：

    #include ＜iostream.h＞

    class complex
    {
    public:
    complex() { real=imag=0; }
    complex(double r, double i)
    {
    real = r, imag = i;
    }
    friend complex operator +(const complex &c1, const complex &c2);
    friend complex operator -(const complex &c1, const complex &c2);
    friend complex operator *(const complex &c1, const complex &c2);
    friend complex operator /(const complex &c1, const complex &c2);
    friend
    void print(const complex &c);
    private:
    double real, imag;
    };

    complex operator +(const complex &c1, const complex &c2)
    {
    return complex(c1.real + c2.real, c1.imag + c2.imag);
    }

    complex operator -(const complex &c1, const complex &c2)
    {
    return complex(c1.real - c2.real, c1.imag - c2.imag);
    }

    complex operator *(const complex &c1, const complex &c2)
    {
    return complex(c1.real * c2.real - c1.imag * c2.imag, c1.real * c2.imag + c1.imag * c2.real);
    }

    complex operator /(const complex &c1, const complex &c2)
    {
    return complex((c1.real * c2.real + c1.imag + c2.imag) / (c2.real * c2.real + c2.imag * c2.imag),
    (c1.imag * c2.real - c1.real * c2.imag) / (c2.real * c2.real + c2.imag * c2.imag));
    }

    void print(const complex &c)
    {
    if(c.imag＜0)
    cout＜＜c.real＜＜c.imag＜＜'i';
    else
    cout＜＜c.real＜＜'+'＜＜c.imag＜＜'i';
    }

    void main()
    {
    complex c1(2.0, 3.0), c2(4.0, -2.0), c3;
    c3 = c1 + c2;
    cout＜＜"\nc1+c2=";
    print(c3);
    c3 = c1 - c2;
    cout＜＜"\nc1-c2=";
    print(c3);
    c3 = c1 * c2;
    cout＜＜"\nc1*c2=";
    print(c3);
    c3 = c1 / c2;
    cout＜＜"\nc1/c2=";
    print(c3);
    c3 = (c1+c2) * (c1-c2) * c2/c1;
    cout＜＜"\n(c1+c2)*(c1-c2)*c2/c1=";
    print(c3);
    cout＜＜endl;
    }
    　　该程序的运行结果与上例相同。前面已讲过，对又目运算符，重载为成员函数时，仅一个参数，另一个被隐含；重载为友元函数时，有两个参数，没有隐含参数。因此，程序中出现的 c1+c2

    　　编译程序解释为：

    　　operator+(c1, c2)

    　　调用如下函数，进行求值，

    　　complex operator +(const coplex &c1, const complex &c2)

    3. 两种重载形式的比较

    　　一般说来，单目运算符最好被重载为成员；对双目运算符最好被重载为友元函数，双目运算符重载为友元函数比重载为成员函数更方便此，但是，有的双目运算符还是重载为成员函数为好，例如，赋值运算符。因为，它如果被重载为友元函数，将会出现与赋值语义不一致的地方。 其他运算符的重载举例

    　　1).下标运算符重载

    　　由于C语言的数组中并没有保存其大小，因此，不能对数组元素进行存取范围的检查，无法保证给数组动态赋值不会越界。利用C++的类可以定义一种更安全、功能强的数组类型。为此，为该类定义重载运算符[]。

    　　下面先看看一个例子：

    #include ＜iostream.h＞

    class CharArray
    {
    public:
    CharArray(int l)
    {
    Length = l;
    Buff = new char[Length];
    }
    ~CharArray() { delete Buff; }
    int GetLength() { return Length; }
    char & operator [](int i);
    private:
    int Length;
    char * Buff;
    };

    char & CharArray::operator [](int i)
    {
    static char ch = 0;
    if(i＜Length&&i＞=0)
    return Buff[i];
    else
    {
    cout＜＜"\nIndex out of range.";
    return ch;
    }
    }

    void main()
    {
    int cnt;
    CharArray string1(6);
    char * string2 = "string";
    for(cnt=0; cnt＜8; cnt++)
    string1[cnt] = string2[cnt];
    cout＜＜"\n";
    for(cnt=0; cnt＜8; cnt++)
    cout＜＜string1[cnt];
    cout＜＜"\n";
    cout＜＜string1.GetLength()＜＜endl;
    }
    　　该数组类的优点如下：

    　　(1) 其大小不心是一个常量。
    　　(2) 运行时动态指定大小可以不用运算符new和delete。
    　　(3) 当使用该类数组作函数参数时，不心分别传递数组变量本身及其大小，因为该对象中已经保存大小。

    　　在重载下标运算符函数时应该注意：

    　　(1) 该函数只能带一个参数，不可带多个参数。
    　　(2) 不得重载为友元函数，必须是非static类的成员函数。 2). 重载增1减1运算符

    　　增1减1运算符是单目运算符。它们又有前缀和后缀运算两种。为了区分这两种运算，将后缀运算视为又目运算符。表达式

    　　obj++或obj--

    　　被看作为：

    　　obj++0或obj--0

    　　下面举一例子说明重载增1减1运算符的应用。

    #include ＜iostream.h＞

    class counter
    {
    public:
    counter() { v=0; }
    counter operator ++();
    counter operator ++(int );
    void print() { cout＜＜v＜＜endl; }
    private:
    unsigned v;
    };

    counter counter::operator ++()
    {
    v++;
    return *this;
    }

    counter counter::operator ++(int)
    {
    counter t;
    t.v = v++;
    return t;
    }

    void main()
    {
    counter c;
    for(int i=0; i＜8; i++)
    c++;
    c.print();
    for(i=0; i＜8; i++)
    ++c;
    c.print();
    }
    　　4). 重载函数调用运算符

    　　可以将函数调用运算符()看成是下标运算[]的扩展。函数调用运算符可以带0个至多个参数。下面通过一个实例来熟悉函数调用运算符的重载。
    #include ＜iostream.h＞

    class F
    {
    public:
    double operator ()(double x, double y) const;
    };

    double F::operator ()(double x, double y) const
    {
    return (x+5)*y;
    }

    void main()
    {
    F f;
    cout＜＜f(1.5, 2.2)＜＜endl;
    }

级别： 初级

陈家朋 (japen@vip.sina.com), 系统架构师和技术顾问, 杭州迈可行通信技术有限公司

2003 年 3 月 01 日

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。同步调用是三者当中最简单的，而回调又常常是异步调用的基础，因此，下面我们着重讨论回调机制在不同软件架构中的实现。

1 什么是回调

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。同步调用是一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；回调是一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；异步调用是一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。回调和异步调用的关系非常紧密，通常我们使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。同步调用是三者当中最简单的，而回调又常常是异步调用的基础，因此，下面我们着重讨论回调机制在不同软件架构中的实现。

对于不同类型的语言（如结构化语言和对象语言）、平台（Win32、JDK）或构架（CORBA、DCOM、WebService），客户和服务的交互除了同步方式以外，都需要具备一定的异步通知机制，让服务方（或接口提供方）在某些情况下能够主动通知客户，而回调是实现异步的一个最简捷的途径。

对于一般的结构化语言，可以通过回调函数来实现回调。回调函数也是一个函数或过程，不过它是一个由调用方自己实现，供被调用方使用的特殊函数。

在面向对象的语言中，回调则是通过接口或抽象类来实现的，我们把实现这种接口的类成为回调类，回调类的对象成为回调对象。对于象C++或Object Pascal这些兼容了过程特性的对象语言，不仅提供了回调对象、回调方法等特性，也能兼容过程语言的回调函数机制。

Windows平台的消息机制也可以看作是回调的一种应用，我们通过系统提供的接口注册消息处理函数（即回调函数），从而实现接收、处理消息的目的。由于Windows平台的API是用C语言来构建的，我们可以认为它也是回调函数的一个特例。

对于分布式组件代理体系CORBA，异步处理有多种方式，如回调、事件服务、通知服务等。事件服务和通知服务是CORBA用来处理异步消息的标准服务，他们主要负责消息的处理、派发、维护等工作。对一些简单的异步处理过程，我们可以通过回调机制来实现。

下面我们集中比较具有代表性的语言（C、Object Pascal）和架构（CORBA）来分析回调的实现方式、具体作用等。

回页首

2 过程语言中的回调（C）

2.1 函数指针

回调在C语言中是通过函数指针来实现的,通过将回调函数的地址传给被调函数从而实现回调。因此，要实现回调，必须首先定义函数指针，请看下面的例子：

void Func(char *s)；// 函数原型
            void (*pFunc) (char *);//函数指针
            

可以看出，函数的定义和函数指针的定义非常类似。

一般的化，为了简化函数指针类型的变量定义，提高程序的可读性，我们需要把函数指针类型自定义一下。

typedef void(*pcb)(char *);
            

回调函数可以象普通函数一样被程序调用，但是只有它被当作参数传递给被调函数时才能称作回调函数。

被调函数的例子：

void GetCallBack(pcb callback)
            {
            /*do something*/
            }
            用户在调用上面的函数时，需要自己实现一个pcb类型的回调函数：
            void fCallback(char *s)
            {
            /* do something */
            }
            然后，就可以直接把fCallback当作一个变量传递给GetCallBack,
            GetCallBack（fCallback）;
            

如果赋了不同的值给该参数，那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

回页首

2.2 参数传递规则

到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值
            __stdcall int callee(int);
            // 调用函数以函数指针为参数
            void caller( __cdecl int(*ptr)(int));
            // 在p中企图存储被调用函数地址的非法操作
            __cdecl int(*p)(int) = callee; // 出错
            

指针p和callee()的类型不兼容，因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p，尽管两者有相同的返回值和参数列

2.3 应用举例

C语言的标准库函数中很多地方就采用了回调函数来让用户定制处理过程。如常用的快速排序函数、二分搜索函数等。

快速排序函数原型：

void qsort(void *base, size_t nelem, size_t width, int (_USERENTRY *fcmp)(const void *, const void *));
            二分搜索函数原型：
            void *bsearch(const void *key, const void *base, size_t nelem,
            size_t width, int (_USERENTRY *fcmp)(const void *, const void *));
            

其中fcmp就是一个回调函数的变量。

下面给出一个具体的例子：

#include <stdio.h>
            #include <stdlib.h>
            int sort_function( const void *a, const void *b);
            int list[5] = { 54, 21, 11, 67, 22 };
            int main(void)
            {
            int  x;
            qsort((void *)list, 5, sizeof(list[0]), sort_function);
            for (x = 0; x < 5; x++)
            printf("%i\n", list[x]);
            return 0;
            }
            int sort_function( const void *a, const void *b)
            {
            return *(int*)a-*(int*)b;
            }
            

2.4 面向对象语言中的回调（Delphi）

Dephi与C++一样，为了保持与过程语言Pascal的兼容性，它在引入面向对象机制的同时，保留了以前的结构化特性。因此，对回调的实现，也有两种截然不同的模式，一种是结构化的函数回调模式，一种是面向对象的接口模式。

2.4.1 回调函数

回调函数类型定义：

type
            TCalcFunc=function (a:integer;b:integer):integer;
            

按照回调函数的格式自定义函数的实现，如

function Add(a:integer;b:integer):integer
            begin
            result:=a+b;
            end;
            function Sub(a:integer;b:integer):integer
            begin
            result:=a-b;
            end;
            

回调的使用

function Calc(calc:TcalcFunc;a:integer;b:integer):integer
            

下面，我们就可以在我们的程序里按照需要调用这两个函数了

c:=calc(add,a,b);//c=a+b
            c:=calc(sub,a,b);//c=a-b
            

2.4.2 回调对象

什么叫回调对象呢，它具体用在哪些场合？首先，让我们把它与回调函数对比一下，回调函数是一个定义了函数的原型，函数体则交由第三方来实现的一种动态应用模式。要实现一个回调函数，我们必须明确知道几点：该函数需要那些参数，返回什么类型的值。同样，一个回调对象也是一个定义了对象接口，但是没有具体实现的抽象类（即接口）。要实现一个回调对象，我们必须知道：它需要实现哪些方法，每个方法中有哪些参数，该方法需要放回什么值。

因此，在回调对象这种应用模式中，我们会用到接口。接口可以理解成一个定义好了但是没有实现的类，它只能通过继承的方式被别的类实现。Delphi中的接口和COM接口类似，所有的接口都继承与IInterface（等同于IUnknow），并且要实现三个基本的方法QueryInterface, _AddRef, 和_Release。

• 定义一个接口
  

  type IShape=interface(IInterface) procedure Draw; end

  
  
• 实现回调类
  

  type TRect=class(TObject,IShape) protected function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; public procedure Draw; end; type TRound=class(TObject,IShape) protected function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall; function _AddRef: Integer; stdcall; function _Release: Integer; stdcall; public procedure Draw; end;

  
  
• 使用回调对象
  

  procedure MyDraw(shape:IShape); var shape:IShape; begin shape.Draw; end;

  
  

如果传入的对象为TRect，那么画矩形；如果为TRound，那么就为圆形。用户也可以按照自己的意图来实现IShape接口，画出自己的图形：

MyDraw(Trect.Create);
            MyDraw(Tround.Create);
            

2.4.3 回调方法

回调方法(Callback Method)可以看作是回调对象的一部分，Delphi对windows消息的封装就采用了回调方法这个概念。在有些场合，我们不需要按照给定的要求实现整个对象，而只要实现其中的一个方法就可以了，这是我们就会用到回调方法。

回调方法的定义如下：

TNotifyEvent = procedure(Sender: TObject) of object;
            TMyEvent=procedure(Sender:Tobject;EventId:Integer) of object;
            

TNotifyEvent 是Delphi中最常用的回调方法，窗体、控件的很多事件，如单击事件、关闭事件等都是采用了TnotifyEvent。回调方法的变量一般通过事件属性的方式来定义，如TCustomForm的创建事件的定义：

property OnCreate: TNotifyEvent read FOnCreate write FOnCreate stored IsForm;
            

我们通过给事件属性变量赋值就可以定制事件处理器。

用户定义对象（包含回调方法的对象）：

type TCallback=Class
            procedure ClickFunc(sender:TObject);
            end;
            procedure Tcallback.ClickFunc(sender:TObject);
            begin
            showmessage('the caller is clicked!');
            end;
            

窗体对象：

type TCustomFrm=class(TForm)
            public
            procedure RegisterClickFunc(cb:procedure(sender:Tobject) of object);
            end;
            procedure TcustomFrm..RegisterClickFunc(cb:TNotifyEvent);
            begin
            self.OnClick=cb;
            end;
            

使用方法：

var
            frm:TcustomFrm;
            begin
            frm:=TcustomFrm.Create(Application);
            frm.RegisterClickFunc(Tcallback.Create().ClickFunc);
            end;
            

回页首

3 回调在分布式计算中的应用（CORBA）

3.1 回调接口模型

CORBA的消息传递机制有很多种，比如回调接口、事件服务和通知服务等。回调接口的原理很简单，CORBA客户和服务器都具有双重角色，即充当服务器也是客户客户。

回调接口的反向调用与正向调用往往是同时进行的，如果服务端多次调用该回调接口，那么这个回调接口就变成异步接口了。因此，回调接口在CORBA中常常充当事件注册的用途，客户端调用该注册函数时，客户函数就是回调函数，在此后的调用中，由于不需要客户端的主动参与，该函数就是实现了一种异步机制。

从CORBA规范我们知道，一个CORBA接口在服务端和客户端有不同的表现形式，在客户端一般使用桩（Stub）文件，服务端则用到框架（Skeleton）文件，接口的规格采用IDL来定义。而回调函数的引入，使得服务端和客户端都需要实现一定的桩和框架。下面是回调接口的实现模型：

下面给出了一个使用回调的接口文件，服务端需要实现Server接口的框架，客户端需要实现CallBack的框架：

module cb
            {
            interface CallBack;
            interface Server;
            interface CallBack
            {
            void OnEvent(in long Source,in long msg);
            };
            interface Server
            {
            long RegisterCB(in CallBack cb);
            void UnRegisterCB(in long hCb);
            };
            };
            

客户端首先通过同步方式调用服务端的接口RegistCB，用来注册回调接口CallBack。服务端收到该请求以后，就会保留该接口引用，如果发生某种事件需要向客户端通知的时候就通过该引用调用客户方的OnEvent函数，以便对方及时处理。

本文源码 下载。

关于作者

		陈家朋，系统架构师和技术顾问，目前担任杭州迈可行通信技术有限公司MPS2000业务交换平台的首席设计人员。擅长架构设计、提供技术解决方案等工作，熟知计算机和通信领域的各种前沿技术。可以通过 japen@vip.sina.com跟他联系。

关于C++的RTTI

RTTI(Run-Time Type Identification)是面向对象程序设计中一种重要的技术。现行的C++标准对RTTI已经有了明确的支持。不过在某些情况下出于特殊的开发需要，我们需要自己编码来实现。本文介绍了一些关于RTTI的基础知识及其原理和实现。
RTTI需求：

　　和很多其他语言一样，C++是一种静态类型语言。其数据类型是在编译期就确定的，不能在运行时更改。然而由于面向对象程序设计中多态性的要求，C++中的指针或引用(Reference)本身的类型，可能与它实际代表(指向或引用)的类型并不一致。有时我们需要将一个多态指针转换为其实际指向对象的类型，就需要知道运行时的类型信息，这就产生了运行时类型识别的要求。

　　C++对RTTI的支持：

　　C++提供了两个关键字typeid和dynamic_cast和一个type_info类来支持RTTI：

　　dynamic_cast操作符：它允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构安全地转换类型。dynamic_cast提供了两种转换方式，把基类指针转换成派生类指针，或者把指向基类的左值转换成派生类的引用。见下例讲述：

void company::payroll(employee *pe) {
//对指针转换失败，dynamic_cast返回NULL
if(programmer *pm=dynamic_cast(pe)){
pm->bonus();
}
}
void company::payroll(employee &re) {
try{
//对引用转换失败的话，则会以抛出异常来报告错误
programmer &rm=dynamic_cast(re);
pm->bonus();
}
catch(std::bad_cast){

}
}

　　这里bonus是programmer的成员函数，基类employee不具备这个特性。所以我们必须使用安全的由基类到派生类类型转换，识别出programmer指针。

　　typeid操作符：它指出指针或引用指向的对象的实际派生类型。

　　例如：

employee* pe=new manager;
typeid(*pe)==typeid(manager) //true
　　typeid可以用于作用于各种类型名，对象和内置基本数据类型的实例、指针或者引用，当作用于指针和引用将返回它实际指向对象的类型信息。typeid的返回是type_info类型。

　　type_info类：这个类的确切定义是与编译器实现相关的，下面是《C++ Primer》中给出的定义(参考资料[2]中谈到编译器必须提供的最小信息量)：

class type_info {
private:
type_info(const type_info&);
type_info& operator=( const type_info& );
public:
virtual ~type_info();
int operator==( const type_info& ) const;
int operator!=( const type_info& ) const;
const char* name() const;
};

实现目标：

　　实现的方案

　　方案一：利用多态来取得指针或应用的实际类型信息

　　这是一个最简单的方法，也是作者目前所采用的办法。

　　实现：

enum ClassType{
UObjectClass,
URectViewClass,
UDialogClass,
……
};
class UObject{
virtual char* GetClassName() const {
return "UObject";
};
virtual ClassType TypeOfClass(){
return UObjectClass;
};
};
class UDialog{
virtual char* GetClassName() const {
return "UDialog";
};
virtual ClassType TypeOfClass(){
return UDialogClass;
};
};
　　示例：

UObject po=new UObject;
UObject pr=new URectView;
UObject pd=new UDialog;
cout << "po is a " << po->GetClassName() << endl;
cout << "pr is a " << pr->GetClassName() << endl;
cout << "pd is a " << pd->GetClassName() << endl;
cout<TypeOfClass()==UObjectClass< cout<TypeOfClass()==URectViewClass< cout<TypeOfClass()==UDialogClass< cout<TypeOfClass()==UObjectClass< cout<TypeOfClass()==UDialogClass<  
　　输出：

po is a UObjectClass
pr is a URectViewClass
pd is a UDialogClass
true
true
true
false
false
　　这种实现方法也就是在基类中提供一个多态的方法，这个方法返回一个类型信息。这样我们能够知道一个指针所指向对象的具体类型，可以满足一些简单的要求。

　　但是很显然，这样的方法只实现了typeid的部分功能，还存在很多缺点：

　　1、 用户每增加一个类必须覆盖GetClassName和TypeOfClass两个方法，如果忘了，会导致程序错误。

　　2、 这里的类名和类标识信息不足以实现dynamic_cast的功能，从这个意义上而言此方案根本不能称为RTTI。

　　3、 用户必须手工维护每个类的类名与标识，这限制了以库的方式提供给用户的可能。

　　4、 用户必须手工添加GetClassName和TypeOfClass两个方法，使用并不方便。

　　其中上面的部分问题我们可以采用C/C++中的宏技巧(Macro Magic)来解决，这个可以在我们的最终解决方案的代码中看到。下面采用方案二中将予以解决上述问题。
　方案二：以一个类型表来存储类型信息

　　这种方法考虑使用一个类结构，除了保留原有的整型类ID，类名字符串外，增加了一个指向基类TypeInfo成员的指针。

struct TypeInfo
{
char* className;
int type_id;
TypeInfo* pBaseClass;
operator== (const TypeInfo& info){
return this==&info;
}
operator!= (const TypeInfo& info){
return this!=&info;
}
};
　　从这里可以看到，以这种方式实现的RTTI不支持多重继承。所幸多重继承在程序设计中并非必须，而且也不推荐。下面的代码中，我将为DP9900软件项目组中类层次结构中的几个类添加RTTI功能。DP9900项目中，绝大部分的类都以单继承方式从UObject这个根类直接或间接继承而来。这样我们就可以从UObject开始，加入我们RTTI支持所需要的数据和方法。

class UObject
{
public:
bool IsKindOf(TypeInfo& cls); //判别某个对象是否属于某一个类
public:
virtual int GetTypeID(){return rttiTypeInfo.type_id;}
virtual char* GetTypeName(){return rttiTypeInfo.className;}
virtual TypeInfo& GetTypeInfo(){return rttiTypeInfo;}
static TypeInfo& GetTypeInfoClass(){return rttiTypeInfo;}
private:
static TypeInfo rttiTypeInfo;
};
//依次为className、type_id、pBaseClass赋值
TypeInfo UObject::rttiTypeInfo={"UObject",0,NULL};
　　考虑从UObject将这个TypeInfo类作为每一个新增类的静态成员，这样一个类的所有对象将共享TypeInfo的唯一实例。我们希望能够在程序运行之前就为type_id,className做好初始化，并让pBaseClass指向基类的这个TypeInfo。

　　每个类的TypeInfo成员约定使用rttiTypeInfo的命名，为了避免命名冲突，我们将其作为private成员。有了基类的支持并不够，当用户需要RTTI支持，还需要自己来做一些事情：

　　1、 派生类需要从UObject继承。

　　2、 添加rttiTypeInfo变量。

　　3、 在类外正确初始化rttiTypeInfo静态成员。

　　4、 覆盖GetTypeID、GetTypeName、GetTypeInfo、GetTypeInfoClass四个成员函数。

　　如下所示：

class UView:public UObject
{
public:
virtual int GetTypeID(){return rttiTypeInfo.type_id;}
virtual char* GetTypeName(){return rttiTypeInfo.className;}
virtual TypeInfo& GetTypeInfo(){return rttiTypeInfo;}
static TypeInfo& GetTypeInfoClass(){return rttiTypeInfo;}
private:
static TypeInfo rttiTypeInfo;
};
　　有了前三步，这样我们就可以得到一个不算太复杂的链表――这是一棵类型信息构成的"树"，与数据结构中的树的唯一差别就是其指针方向相反。

　　这样，从任何一个UObject的子类，顺着pBaseClass往上找，总能遍历它的所有父类，最终到达UObject。

　　在这个链表的基础上，要判别某个对象是否属于某一个类就很简单。下面给出UObject::IsKindOf()的实现。

bool UObject::IsKindOf(TypeInfo& cls)
{
TypeInfo* p=&(this->GetTypeInfo());
while(p!=NULL){
if(p->type_id==cls.type_id)
return true;
p=p->pBaseClass;
}
return false;
}

　　有了IsKindOf的支持，dynamic_cast的功能也就可以用一个简单的safe_cast来实现：

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}
　　至此，我们已经能够从功能上完成前面的目标了，不过用户要使用这个类库的RTTI功能还很麻烦，要敲入一大堆对他们毫无意义的函数代码，要在初始化rttiTypeInfo静态成员时手工设置类ID与类名。其实这些麻烦完全不必交给我们的用户，适当采用一些宏技巧(Macro Magic)，就可以让C++的预处理器来替我们写很多枯燥的代码。关于宏不是本文的重点，你可以从最终代码清单看到它们。下面再谈谈关于类ID的问题。

　　类ID

　　为了使不同类型的对象可区分，用一个给每个TypeInfo对象一个类ID来作为比较的依据是必要的。
其实对于我们这里的需求和实现方法而言，其实类ID并不是必须的。每一个支持RTTI的类都包含了一个静态TypeInfo对象，这个对象的地址就是在进程中全局唯一。但考虑到其他一些技术如：动态对象创建、对象序列化等，它们可能会要求RTTI给出一个静态不变的ID。在本文的实现中，对此作了有益的尝试。

　　首先声明一个用来产生递增类ID的全局变量。再声明如下一个结构，没有数据成员，只有一个构造函数用于初始化TypeInfo的类ID：

extern int TypeInfoOrder=0;
struct InitTypeInfo
{
InitTypeInfo(TypeInfo* info)
{
info->type_id=TypeInfoOrder++;
}
};
　　为UObject添加一个private的静态成员及其初始化：

class UObject
{
//……
private:
static InitTypeInfo initClassInfo;
};
InitTypeInfo UObject::initClassInfo(&(UObject::rttiTypeInfo));
　　并且对每一个从UObject派生的子类也进行同样的添加。这样您将看到，在C++主函数执行前，启动代码将替我们调用每一个类的initClassInfo成员的构造函数InitTypeInf:InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。

　　但实践与查阅资料让我们发现，由于C++中对静态成员初始化的顺序没有明确的规定，所以这样的方式产生出来的类ID并非完全静态，换一个编译器编译执行产生的结果可能完全不同。

　　还有一个可以考虑的方案是采用某种无冲突HASH算法，将类名转换成为一个唯一整数。使用标准CRC32算法从类型名计算出一个整数作为类ID也许是个不错的想法[3]。

　　程序清单

// URtti.h
#ifndef __URTTI_H__
#define __URTTI_H__

class UObject;

struct TypeInfo
{
char* className;
int type_id;
TypeInfo* pBaseClass;
operator== (const TypeInfo& info){
return this==&info;
}
operator!= (const TypeInfo& info){
return this!=&info;
}
};

inline std::ostream& operator<< (std::ostream& os,TypeInfo& info)
{
return (os<< "[" << &info << "]" << "\t"
<< info.type_id << ":"
<< info.className << ":"
<< info.pBaseClass << std::endl);
}

extern int TypeInfoOrder;

struct InitTypeInfo
{
InitTypeInfo(/*TypeInfo* base,*/TypeInfo* info)
{
info->type_id=TypeInfoOrder++;
}
};

#define TYPEINFO_OF_CLASS(class_name) (class_name::GetTypeInfoClass())
#define TYPEINFO_OF_OBJ(obj_name) (obj_name.GetTypeInfo())
#define TYPEINFO_OF_PTR(ptr_name) (ptr_name->GetTypeInfo())

#define DECLARE_TYPEINFO(class_name) public: virtual int GetTypeID(){return TYPEINFO_MEMBER(class_name).type_id;} virtual char* GetTypeName(){return TYPEINFO_MEMBER(class_name).className;} virtual TypeInfo& GetTypeInfo(){return TYPEINFO_MEMBER(class_name);} static TypeInfo& GetTypeInfoClass(){return TYPEINFO_MEMBER(class_name);} private: static TypeInfo TYPEINFO_MEMBER(class_name); static InitTypeInfo initClassInfo;
#define IMPLEMENT_TYPEINFO(class_name,base_name) TypeInfo class_name::TYPEINFO_MEMBER(class_name)= {#class_name,0,&(base_name::GetTypeInfoClass())}; InitTypeInfo class_name::initClassInfo(&(class_name::TYPEINFO_MEMBER(class_name)));

#define DYNAMIC_CAST(object_ptr,class_name) safe_cast(object_ptr,TYPEINFO_OF_CLASS(class_name))

#define TYPEINFO_MEMBER(class_name) rttiTypeInfo

class UObject
{
public:
bool IsKindOf(TypeInfo& cls);
public:
virtual int GetTypeID(){return TYPEINFO_MEMBER(UObject).type_id;}
virtual char* GetTypeName(){return TYPEINFO_MEMBER(UObject).className;}
virtual TypeInfo& GetTypeInfo(){return TYPEINFO_MEMBER(UObject);}
static TypeInfo& GetTypeInfoClass(){return TYPEINFO_MEMBER(UObject);}
private:
static TypeInfo TYPEINFO_MEMBER(UObject);
static InitTypeInfo initClassInfo;
};

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}
#endif
// URtti.cpp
＃i nclude "urtti.h"

extern int TypeInfoOrder=0;

TypeInfo UObject::TYPEINFO_MEMBER(UObject)={"UObject",0,NULL};
InitTypeInfo UObject::initClassInfo(&(UObject::TYPEINFO_MEMBER(UObject)));

bool UObject::IsKindOf(TypeInfo& cls)
{
TypeInfo* p=&(this->GetTypeInfo());
while(p!=NULL){
if(p->type_id==cls.type_id)
return true;
p=p->pBaseClass;
}
return false;
}
// mail.cpp
＃i nclude
＃i nclude "urtti.h"
using namespace std;

class UView:public UObject
{
DECLARE_TYPEINFO(UView)
};
IMPLEMENT_TYPEINFO(UView,UObject)

class UGraph:public UObject
{
DECLARE_TYPEINFO(UGraph)
};
IMPLEMENT_TYPEINFO(UGraph,UObject)

void main()
{
UObject* po=new UObject;
UView* pv=new UView;
UObject* pg=new UGraph;
if(DYNAMIC_CAST(po,UView))
cout << "po => UView succeed" << std::endl;
else
cout << "po => UView failed" << std::endl;
if(DYNAMIC_CAST(pv,UView))
cout << "pv => UView succeed" << std::endl;
else
cout << "pv => UView failed" << std::endl;
if(DYNAMIC_CAST(po,UGraph))
cout << "po => UGraph succeed" << std::endl;
else
cout << "po => UGraph failed" << std::endl;
if(DYNAMIC_CAST(pg,UGraph))
cout << "pg => UGraph succeed" << std::endl;
else
cout << "pg => UGraph failed" << std::endl;
}
　　实现结果

　　本文实现了如下几个宏来支持RTTI，它们的使用方法都可以在上面的代码中找到：
　　

宏函数 功能及参数说明
DECLARE_TYPEINFO(class_name)  为类添加RTTI功能放在类声明的起始位置
IMPLEMENT_TYPEINFO(class_name,base) 同上，放在类定义任何位置
TYPEINFO_OF_CLASS(class_name) 相当于typeid(类名)
TYPEINFO_OF_OBJ(obj_name) 相当于typeid(对象)
TYPEINFO_OF_PTR(ptr_name) 相当于typeid(指针)
DYNAMIC_CAST(object_ptr,class_name) 相当于dynamic_castobject_ptr
性能测试

　　测试代码：

　　这里使用相同次数的DYNAMIC_CAST和dynamic_cast进行对比测试，在VC6.0下编译运行，使用默认的Release编译配置选项。为了避免编译器优化导致的不公平测试结果，我在循环中加入了无意义的计数操作。

void main()
{
UObject* po=new UObject;
UView* pv=new UView;
UObject* pg=new UGraph;
int a,b,c,d;
a=b=c=d=0;
const int times=30000000;
cerr << "时间测试输出：" << endl;
cerr << "start my DYNAMIC_CAST at: " << time(NULL) << endl;
for(int i=0;i if(DYNAMIC_CAST(po,UView)) a++; else a--;
if(DYNAMIC_CAST(pv,UView)) b++; else b--;
if(DYNAMIC_CAST(po,UGraph)) c++; else c--;
if(DYNAMIC_CAST(pg,UGraph)) d++; else d--;
}
cerr << "end my DYNAMIC_CAST at: " << time(NULL) << endl;
cerr << "start c++ dynamic_cast at: " << time(NULL) << endl;
for(i=0;i if(dynamic_cast(po)) a++; else a--;
if(dynamic_cast(pv)) b++; else b--;
if(dynamic_cast(po)) c++; else c--;
if(dynamic_cast(pg)) d++; else d--;
}
cerr << "end c++ dynamic_cast at: " << time(NULL) << endl;
cerr << a << b << c << d << endl;
}
　　运行结果：

start my DYNAMIC_CAST at: 1021512140
end my DYNAMIC_CAST at: 1021512145
start c++ dynamic_cast at: 1021512145
end c++ dynamic_cast at: 1021512160
　　这是上述条件下的测试输出，我们可以看到，本文实现的这个精简RTTI方案运行DYNAMIC_CAST的时间开销只有dynamic_cast的1/3。为了得到更全面的数据，还进行了DEBUG编译配置选项下的测试。

　　输出：

start my DYNAMIC_CAST at: 1021512041
end my DYNAMIC_CAST at: 1021512044
start c++ dynamic_cast at: 1021512044
end c++ dynamic_cast at: 1021512059
　　这种情况下DYNAMIC_CAST运行速度要比dynamic_cast慢一倍左右。如果在Release编译配置选项下将UObject::IsKindOf方法改成如下inline函数，我们将得到更让人兴奋的结果（DYNAMIC_CAST运行时间只有dynamic_cast的1/5）。

inline bool UObject::IsKindOf(TypeInfo& cls)
{
for(TypeInfo* p=&(this->GetTypeInfo());p!=NULL;p=p->pBaseClass)
if(p==&cls) return true;
return false;
}
　　输出：

start my DYNAMIC_CAST at: 1021512041
end my DYNAMIC_CAST at: 1021512044
start c++ dynamic_cast at: 1021512044
end c++ dynamic_cast at: 1021512059
　　结论：

　　由本文的实践可以得出结论，自己动手编码实现RTTI是简单可行的。这样的实现可以在编译器优秀的代码优化中表现出比dynamic_cast更好的性能，而且没有带来过多的存储开销。本文的RTTI以性能为主要设计目标，在实现上一定程度上受到了MFC的影响。适于嵌入式环境。