typedef给你一种方式来克服“*只适合于变量而不适合于类型”的弊端。你可以如下使用typedef：

typedef char * PCHAR;
PCHAR p,q;

这里的p和q都被声明为指针。（如果不使用typedef，q将被声明为一个char变量，这跟我们的第一眼感觉不太一致！）下面有一些使用typedef的声明，并且给出了解释：

typedef char * a;  // a is a pointer to a char

typedef a b();     // b is a function that returns
                   // a pointer to a char

typedef b *c;      // c is a pointer to a function
                   // that returns a pointer to a char

typedef c d();     // d is a function returning
                   // a pointer to a function
                   // that returns a pointer to a char

typedef d *e;      // e is a pointer to a function
                   // returning  a pointer to a
                   // function that returns a
                   // pointer to a char

e var[10];         // var is an array of 10 pointers to
                   // functions returning pointers to
                   // functions returning pointers to chars.

typedef经常用在一个结构声明之前，如下。这样，当创建结构变量的时候，允许你不使用关键字struct（在C中，创建结构变量时要求使用struct关键字，如struct tagPOINT a；而在C++中，struct可以忽略，如tagPOINT b）。

typedef struct tagPOINT
{
    int x;
    int y;
}POINT;

POINT p; /* Valid C code */

函数指针

函数指针可能是最容易引起理解上的困惑的声明。函数指针在DOS时代写TSR程序时用得最多；在Win32和X-Windows时代，他们被用在需要回调函数的场合。当然，还有其它很多地方需要用到函数指针：虚函数表，STL中的一些模板，Win NT/2K/XP系统服务等。让我们来看一个函数指针的简单例子：

int (*p)(char);

这里p被声明为一个函数指针，这个函数带一个char类型的参数，并且有一个int类型的返回值。另外，带有两个float类型参数、返回值是char类型的指针的指针的函数指针可以声明如下：

char ** (*p)(float, float);

那么，带两个char类型的const指针参数、无返回值的函数指针又该如何声明呢？参考如下：

void * (*a[5])(char * const, char * const);

“右左法则”[重要！！！]

The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.

这是一个简单的法则，但能让你准确理解所有的声明。这个法则运用如下：从最内部的括号开始阅读声明，向右看，然后向左看。当你碰到一个括号时就调转阅读的方向。括号内的所有内容都分析完毕就跳出括号的范围。这样继续，直到整个声明都被分析完毕。

对上述“右左法则”做一个小小的修正：当你第一次开始阅读声明的时候，你必须从变量名开始，而不是从最内部的括号。

下面结合例子来演示一下“右左法则”的使用。

int * (* (*fp1) (int) ) [10];

阅读步骤：
1. 从变量名开始 -------------------------------------------- fp1
2. 往右看，什么也没有，碰到了)，因此往左看，碰到一个* ------ 一个指针
3. 跳出括号，碰到了(int) ----------------------------------- 一个带一个int参数的函数
4. 向左看，发现一个* --------------------------------------- （函数）返回一个指针
5. 跳出括号，向右看，碰到[10] ------------------------------ 一个10元素的数组
6. 向左看，发现一个* --------------------------------------- 指针
7. 向左看，发现int ----------------------------------------- int类型

总结：fp1被声明成为一个函数的指针的指针的数组，这个数组有10个元素，函数的原型为带一个int类型的参数，返回值为一个指针？

再来看一个例子：

int *( *( *arr[5])())();

阅读步骤：
1. 从变量名开始 -------------------------------------------- arr
2. 往右看，发现是一个数组 ---------------------------------- 一个5元素的数组
3. 向左看，发现一个* --------------------------------------- 指针
4. 跳出括号，向右看，发现() -------------------------------- 不带参数的函数
5. 向左看，碰到* ------------------------------------------- （函数）返回一个指针
6. 跳出括号，向右发现() ------------------------------------ 不带参数的函数
7. 向左，发现* --------------------------------------------- （函数）返回一个指针
8. 继续向左，发现int --------------------------------------- int类型

总结：？？

还有更多的例子：

float ( * ( *b()) [] )();              // b is a function that returns a
                                       // pointer to an array of pointers
                                       // to functions returning floats.

void * ( *c) ( char, int (*)());       // c is a pointer to a function that takes
                                       // two parameters:
                                       //     a char and a pointer to a
                                       //     function that takes no
                                       //     parameters and returns
                                       //     an int
                                       // and returns a pointer to void.

void ** (*d) (int &,
  char **(*)(char *, char **));        // d is a pointer to a function that takes
                                       // two parameters:
                                       //     a reference to an int and a pointer
                                       //     to a function that takes two parameters:
                                       //        a pointer to a char and a pointer
                                       //        to a pointer to a char
                                       //     and returns a pointer to a pointer
                                       //     to a char
                                       // and returns a pointer to a pointer to void

float ( * ( * e[10])
    (int &) ) [5];                    // e is an array of 10 pointers to
                                       // functions that take a single
                                       // reference to an int as an argument
                                       // and return pointers to
                                       // an array of 5 floats.

正文完

一、 判断题（对的写 T ，错的写 F 并说明原因，每小题 4 分，共 20 分）

1 、有数组定义 int a[2][2]={{1},{2,3}}; 则 a[0][1] 的值为 0 。（      ）

2 、 int (*ptr) (), 则 ptr 是一维数组的名字。（      ）

3 、指针在任何情况下都可进行 >,<,>=,<=,== 运算。（      ）

4 、 switch(c) 语句中 c 可以是 int ,long,char ,float ,unsigned int 类型。（    ）

5 、 #define print(x)  printf( ＂ the no, ＂ #x ＂ ,is ＂ )

二、填空题（共 30 分）

1 、在 windows 下，写出运行结果，每空 2 分，共 10 分。

char str[ ]= ＂ Hello ＂ ;

char *p=str;

int n=10;

sizeof(str)=(      )

sizeof(p)=(       )

sizeof(n)=(       )

void func(char str[100])

{    }

sizeof(str)=(     )

2 、 void setmemory(char **p, int num)

{ *p=(char *) malloc(num);}

void test(void)

{  char *str=NULL;

   getmemory(&str,100);

   strcpy(str, ＂ hello ＂ );

   printf(str);

}

运行 test 函数有什么结果？（                                 ） 10 分

3 、设 int arr[]={6,7,8,9,10};

     int *ptr=arr;

   *(ptr++)+=123;

 printf( ＂ %d,%d ＂ ,*ptr,*(++ptr));

(                                   ) 10 分

二、 编程题（第一小题 20 ，第二小题 30 分）

1 、   不使用库函数，编写函数 int strcmp(char  *source, char *dest)

  相等返回 0 ，不等返回 -1 ；

for (int i = 0; i < 10; ++i)  
{                             
   //codes here
}
if (i < 10).. //error in Vc8
for (i = 0; i < 5; ++i) //error in Vc8

解决方法：
在for语句之前声明变量（可保证代码在vc7.1和vc8下同时编译通过）

int i =0;                    
for (i = 0; i < 10; ++i)
for (i = 0; i < 5; ++i)

2. 指针和引用的声明
在Vc7.1中, 下面的代码可以编译, 但是vc8会报C4430 错误。（很难想象有些美国程序员竟然这样声明）

const & int a; //error in VC8
const * int b;  //error in VC8
int myfun (const & B); //error in VC8

解决方法：
把* 或&放到类型的后面.

const int& a; 
const int* b;
int myfun (const B&);

3. 默认int类型
在vc7.1中，如果定义一个变量但不声明类型，那么默认为int。VC8不支持。

static i = 0; // C4430 error in Vc8 
const i = 0; //C4430 error

解决方法：
加上int.

static int i = 0; 
const int i = 0;

4. 函数的默认返回值类型
同上，VC8不支持把 int 作为默认返回值类

Func()
{return 0;}; //error in VC8

解决方法：
明确声明函数返回值类型为 int.

int Func()
{return 0;};

5. 函数地址
Vc7中函数名就是地址。在vc8中，必须要使用&操作符同时写出这个方法的全名(fully qualified name).

class A
{
public:
     int Test(void);
};
void fun(int (A::*test) (void));
int main() 
{
     fun(A::Test);//C3867 error in VC
     return 0;
}

解决方法：
加上 &.

fun(&A::Test);

6. 隐式类型转换
VC8不允许B* 到const B*&的隐式转换.

class B{};
void fun ( const B* & );//if possible use const B* instead
int main() 
{
B *test = new B();
fun (test); //error in VC8
return 0;
}

解决方法：
强制转换或函数参数变成const B*。

void fun ( const B*  );

7. 友元方法(Friend function)
VC8不允许声明一个private或protected函数为友元.

class A
{
private:
 void c();  
};
class B
{
  friend void A::c(); //C2248 error, c() is invisible to class B.
};

解决方法 1:
声明友元类.

class A
{
private:
 void c();  
};
class B
{
  friend class A;
};

解决方法 2:
把函数声明为public

class A
{
public:
 void c();  
};
class B
{
  friend void A::c();
};

8. STL的stdext 命名空间
在vc8中，hash_map 和hash_set 被移进了stdext命名空间中.

#include <hash_map>
std::hash_map //error in VC8

解决方法：
使用stdext 命名空间.

#include <hash_map>
stdext::hash_map

9. 头文件
许多头文件如fstream.h 和iostream.h在VC8中已经不存在了.

#include <fstream.h> //error in VC8

解决方法：
使用STL.

#include <fstream>

10. Iterator
一些 STL 类, iterators 不再用指针实现

std::vector<DMDetailRow> m_data;
std::vector<DMDetailRow>::iterator iter = &m_data[rowNum];

解决方法：

std::vector<DMDetailRow>::iterator Iter = m_data.begin() + rowNum;

11. Enum
使用一个Enum的成员时，不要使用enum的名字

enum E
{
  a,b,c
};
E e1 = E::a; //warning in VC8

解决方法：
去掉Enum 的名字.

E e1 = a;

class Links
{
public:
    Links* back;
    Links* forword;

    virtual Add(){ ... };
    virtual Del(){ ... };
    virtual Ins(){ ... };
    virtual Print() =0;
    ....

};

于是对于特定的数据结构我们可以：
class mylinks : public Links
{
public:
    char* myname;
    char sex;
    int  age;
    ...
    virtual Print(){ .... }

};
对其操作时都可以使用你类的泛型算法。

在C中，该如何做呢？我们用C中的指针和强制类型转可以做到。

下面是我总结出来的一个小的程序，体现了用指针的弹性来实现这一继承的效果：
（我在Liniux下的GCC调试通过）

=======================================

 1#include <stdio.h>
 2
 3/**//* 双向链表 （类似于父类）*/
 4typedef struct hLinks{
 5   struct hLinks *bwLink;
 6   struct hLinks *fwLink;
 7} hLinks;
 8
 9
10/**//*
11 * 一个使用双向链表的结构
12 *     （类似于子类）
13 */
14typedef struct hEnt{
15   hLinks links;
16   int hData;
17   char key[10];
18} hEnt;
19
20
21/**//*
22 *  双向链插入泛型算法 （类似于父数中的成员函数）
23 */
24Insert( hLinks* elem, hLinks *dest )
25{
26   if ( !elem || !dest ) return;
27
28   elem->bwLink = dest->bwLink;
29   elem->fwLink = dest;
30   dest->bwLink->fwLink = elem;
31   dest->bwLink = elem;
32}
33
34
35/**//*
36 *  打印 （类似于子类重载父类的成员函数）
37 */
38PrintLink( hLinks *h )
39{
40    hEnt *p ;
41
42    for( p = ( hEnt* ) h->fwLink;     /**//*  <-----------把hLink再转回来  */
43         p != ( hEnt* ) h;
44         p = ( hEnt* )( (hLinks*)p )->fwLink )
45    {
46       printf("hData=[%d], key=[%s]\n", p->hData, p->key);
47    }
48}
49
50 
51
52main()
53{
54   hLinks head;
55   hEnt a[4];
56   int i;
57
58   head.bwLink = &head;
59   head.fwLink = &head;
60
61   for(i=0;i<4;i++)
62   {
63      a[i].hData = i*10;
64      sprintf(a[i].key,"id=%d", i);
65
66      /**//*  使用泛型算法构造双向链  */ 
67      Insert( (hLinks *) &a[i], (hLinks *) &head ); /**//*   <-----注意这个强制转换  */
68   }
69
70   PrintLink( (hLinks *) &head ); /**//*   <-------也注意这个强制转换  */
71}
72
73

下面的代码并不复杂，先定义了一个基类函数对象Action，Button类带有一个Action的指针，作为其回调函数，在setAction中设置回调。由于Action是一个基类，所有继承了Action的继承类如PlayMusic都可以被Button调用，而且不需要改变接口，这个比起函数指针作回调来说，简单了很多，也清晰很多。

下面是代码：

#include <iostream>
#include <string>
#include <stdlib.h>

using namespace std;

class Action
{
public:
    virtual ~Action() = 0;
    virtual void operator()() = 0;
    virtual Action *clone() const = 0;
};

Action::~Action()
{ cout << "::~Action()" << endl; }

void Action::operator()()
{
    cout << "1111111111" << endl;
}

class Button
{
public:
    Button( const string &label )
        : m_label( label ), m_action( 0 ) {}
    ~Button()
    {
        if( m_action )
        {
            delete m_action;
            m_action = NULL;
        }   
    }
    void setAction( const Action *newAction )
    {
        Action *tmp = newAction->clone();
        delete m_action;
        m_action = tmp;
    }
    void onClick() const
    {
        if( m_action )
            ( *m_action )();
    }

private:
    string m_label;
    Action *m_action;
};

class PlayMusic : public Action
{
public:
    PlayMusic( const string &songFile )
        :m_song( songFile ) {}
    virtual ~PlayMusic() { cout << "~PlayMusic()" << endl; }
       
    void operator()()
    {
        cout << "PlayMusic " << m_song << endl;
    }
    virtual Action *clone() const
    {
        return (Action *)this;
    }
private:
    string m_song;
};

int main(int argc, char *argv[])
{
    Button *b = new Button( "Anoko no namaewa" );
    PlayMusic *song = new PlayMusic( "AnokoNonamaewa.mp3" );
    b->setAction( song );
    b->onClick();
   
    delete b;
   
  system("PAUSE"); 
  return 0;
}

数据指针	T *
成员数据指针	T::*
函数指针	R (*)(...)
成员函数指针	R (T::*)(...)

　　尽管C++中仍然有万能指针void*，但它却属于被批斗的对象，而且再也不能“万能”了。它不能转换成成员指针。

　　这样一来，C++的指针就变得很尴尬：我们需要一种指针能够指向同一类型的数据，不管这个数据是普通数据，还是成员数据；我们更需要一种指针能够指向同一类型的函数，不管这个函数是静态函数，还是成员函数。但是没有，至少从现在的C++标准中，还没有看到。
　
沐枫网志 C++指针探讨(三)成员函数指针

　　自从有了类，我们开始按照　数据＋操作　的方式来组织数据结构；自从有了模板，我们又开始把 数据 和 算法 分离，以便重用，实在够折腾人的。但不管怎么折腾，现在大多数函数都不再单身，都嫁给了类，进了围城。可是我们仍然需要能够自由调用这些成员函数。
　　考虑一下windows下的定时调用。SetTimer函数的原型是这样的：

UINT_PTR SetTimer(
    HWND hWnd,
    UINT_PTR nIDEvent,
    UINT uElapse,
    TIMERPROC lpTimerFunc
);

uintptr_t _beginthread( 
   void( *start_address )( void * ),
   unsigned stack_size,
   void *arglist 
);

class mythread
{
  public:
    static void doit(void* pThis)
    {
　　　　((mythread*)pThis)->doit();
    }
    void doit(){}
};

main()
{
  
  mythread* pmt = new mythread;
  _beginthread(&mythread::doit, 0, (void*)pmt);
  
}

　　但是显然，C++程序员肯定不会因此而满足。这里头有许多被C++批判的不安定因素。它使用了C++中被认为不安全的类型转换，不安全的 void*指针，等等等等。但这是系统为C语言留下的调用接口，这也就认了。那么假如，我们就在C++程序中如何来调用成员函数指针呢？
　　如下例，我们打算对vector中的所有类调用其指定的成员函数：

#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
using namespace std;

class A
{
    int value;
public:
    A(int v){value = v;}
    void doit(){ cout << value << endl;};
    static void call_doit(A& rThis)
    {
        rThis.doit();
    }
};


int main()
{
    vector<A> va;
    va.push_back(A(1));
    va.push_back(A(2));
    va.push_back(A(3));
    va.push_back(A(4));
    //方法1:
    //for_each(va.begin(), va.end(), &A::doit); //error
    //方法2:
    for_each(va.begin(), va.end(), &A::call_doit);
    //方法3:
    for_each(va.begin(), va.end(), mem_fun_ref<void, A>(&A::doit));

    system("Pause");

    return 0;
}

　　方法1，编译不能通过。for_each只允许具有一个参数的函数指针或函数对象，哪怕A::doit默认有一个this指针参数也不行。不是for_each没考虑到这一点，而是根本做不到！
　　方法2，显然是受到了beginthread的启发，使用一个静态函数来转调用，哈哈成功了。但是不爽！这不是C++。
　　方法3，呼，好不容易啊，终于用mem_fun_ref包装成功了成员函数指针。
　 　似乎方法3不错，又是类型安全的，又可以通用－－慢着，首先，它很丑，哪有调用普通C函数指针那么漂亮啊（见方法2），用了一大串包装，又是尖括号又是 圆括号，还少不了&号！其次，它只能包装不超过一个参数的函数！尽管它在for_each中够用了，但是你要是想用在超过一个参数的场合，那只有 一句话：不可能的任务。

\ 在c++中可以作为衔接符（忘了规范的术语是不是这么叫了， 汗自己一个~），例如：

  //this is memo\

this is memo too

上面两行在c++中，编译器会认为是一行。

不过\一般只在宏定义中使用，因为如果是字符串，那么别写分号就行，如：
char *s = "How "
    "are "
    "you?";
如果是一般的语句，那么就直接换，比如：
int sum = i +
    j;

2）##

## 叫做指令粘贴符，它的英文术语叫做token-pasting operator，主要在宏定义中使用。使用例子如下：

#define paster( n ) printf( "token" #n " = %d", token##n )

int token9 = 9;

用如下方式调用宏,

paster( 9 ); //输出: taken9 = 9

上面的宏此时等价于

printf( "token" "9" " = %d", token9 );

结果就是：

printf( "token9 = %d", token9 );

3) C++函数参数入栈顺序--从右到左

下面的例子用来验证C++函数参数入栈顺序：

   void test（int i1, int i2, int i3）

{

    printf(“i1=%d, i2=%d, i3=%d\n“,i1,i2,i3);

}

int i=0;

test(++i,++i,++i);

则输出结果为：i1=3, i2=2, i3=1

4)一个有趣的小问题--表达式与算符结合顺序

在VC论坛里看到有人对下面的表达式计算结果有点迷惑，

int i = 1;

int k = (++i) + (++i)+ (++i);

int i2 = 1;

int k2 = (++i2) + (++i2);

我也测试了一下，很多人一开始会以为 k = 2 + 3 + 4  =9;

但是事实上在VC, DevC++4.9(GCC)里面编译， 执行结果k=10;

综合其他人的一些看法和我自己的测试，得出结论:

k= (++i)+(++i)+(++i);//等价于++i，++i，k = i+i + （++i）；也就是 k = 3 + 3 + 4 = 10。

因此，k2的结果为6。

4)下面先看问题：

////bowex ()///////////////////////////////////////////////////////

char uu[3][2];
CString s;
for(int i=0;i<3;i++)
{
  s="我";
  strcpy(uu[i],s);
}

运行完以上程序后为何数组uu中的内容是

uu[0] --- > 我我我
uu[1] --- > 我我
uu[2] --- > 我

而不是
uu[0] --- > 我
uu[1] --- > 我
uu[2] --- > 我         为何？ 奇怪! 多谢

////////////////////////////////////////////////////////////////////

网友“QunKangLi(维护成本与程序员的创造力的平方成正比)”给出解释：

“char uu[3][3];//这样就行了，字符串结束符占一个字符宽度。”

这个解释是很对，不过我还是要强调一下这种情况可能产生的严重后果：

像这种情况让我想起了strcpy函数可能引起非法内存访问，也就是说，如果

strcpy拷贝的目的地址分配的空间不够，那么strcpy会把空间后面的地址也占用，

这样就可能使某些数据被意外修改，从而导致程序崩溃或者数据异常。之所以有

这种感受，是因为以前碰到有个程序，就发生这样的错误，就是因为strcpy拷贝的内容

过长从而把数据结构中紧接其后的成员的数据变为0了，结果程序当然出现意外。

假设把上面的for循环用下面的语句代替 那么结果就更加荒唐， 因为会出现乱码。

char uu[3][2];
CString s;

s="我";
strcpy(uu[2],s);
 strcpy(uu[1],s);
strcpy(uu[0],s);

 大家可以编译一下上面的代码，运行程序 你可以看到uu数组中有乱码。

如果输出的话，应该是这样的，

uu[0] --- > 我
uu[1] --- > （空串）
uu[2] --- > （空串）

2. 链表的好用法
   struct a {
     static a *mLinkedList; // 申明为一个静态变量
 
     a *mNext;
     bool mCanRemoteCreate;

    a(bool canRemoteCreate)
    {
       mNext = mLinkedList;
       mLinkedList = this;
       mCanRemoteCreate = canRemoteCreate;
    }
    static int *create(const char *name);
  };
 
  a *a::mLinkedList = NULL; // 初始化
 
3. 灵活的应用# ##
Token-Pasting Operator (##)

#define paster( n ) printf( "token" #n " = %d", token##n )
int token9 = 9;
If a macro is called with a numeric argument like
paster( 9 );the macro yields
printf( "token" "9" " = %d", token9 );which becomes
printf( "token9 = %d", token9 );

Stringizing Operator (#)
#define stringer( x ) printf( #x "\n" )
void main()
{
    stringer( In quotes in the printf function call\n );
    stringer( "In quotes when printed to the screen"\n );  
    stringer( "This: \"  prints an escaped double quote" );
}
Such invocations would be expanded during preprocessing, producing the following code:
void main()
{
   printf( "In quotes in the printf function call\n" "\n" );
   printf( "\"In quotes when printed to the screen\"\n" "\n" );
   printf( "\"This: \\\" prints an escaped double quote\"" "\n" );
}
When the program is run, screen output for each line is as follows:In quotes in the printf function call
"In quotes when printed to the screen"
"This: \" prints an escaped double quotation mark"
#define IMPLEMENT_NETCONNECTION(className, classGroup, canRemoteCreate) \
   NetClassRep* className::getClassRep() const { return &className::dynClassRep; } \
   NetClassRepInstance<className> className::dynClassRep(#className, 0, NetClassTypeNone, 0); \
   NetClassGroup className::getNetClassGroup() const { return classGroup; } \
   static NetConnectionRep g##className##Rep(&className::dynClassRep, canRemoteCreate)

4. 枚举:初始化为0值开始,后者比前者大1,除非显式指定.
   By default, the first enumerator has a value of 0, and each successive enumerator is one larger
   than the value of the previous one, unless you explicitly specify a value for a particular
   enumerator. Enumerators needn’t have unique values. The name of each enumerator is treated
   as a constant and must be unique within the scope where the enum is defined. An enumerator
   can be promoted to an integer value. However, converting an integer to an enumerator requires
   an explicit cast, and the results are not defined.

=========================
一些优秀的数学算法
5.1 /// Determines if number is a power of two.
 inline bool isPow2(const U32 number)
 {
    return (number & (number - 1)) == 0;
 }
5.2 浮点数的计算机中的储存方法

    单精度      1|   8   |   23    |
             符号  指数      尾数
    双精度      1|   11  |   52    |
             符号  指数      尾数  
            
    10110.100011 -> 1.0110100011* 2(4) 2的4之方
   
    符号位 0
    尾数   0110100011
    指数   4 以过剩127储存 +127= 131  -> 10000011
    所以  IEEE 754 : 0100000110110100011
   
    -0.0010011  -> -1.0011 * 2(-3) 2的-3之方
    符号位：-1
    尾数  : 0011
    指数为：-3  +127  的124 -〉01111100
    所以： 1 01111100 0011000000000000000000
   
    /// Determines the binary logarithm of the input value rounded down to the nearest power of 2.
 inline U32 getBinLog2(U32 value)
 {
    F32 floatValue = F32(value);
    return (*((U32 *) &floatValue) >> 23) - 127;
 }

  #define DEFS_OFFSET(s,m)       (DEFS_UI16)&(((s *)0)->m)
  #define DEFS_MEMBER_SIZE(s,m)  sizeof(((s *)0)->m)

  /* The following macros make it easier to specify binary numbers. For      */
  /* example, to specify a byte in binary:  DEFS_BINARY(01100001) or to   */
  /* specify a word in binary:  DEFS_BINARY_WORD(00111101,11001010)       */

  #define DEFS_BINARY_CONVERT(byte) (((byte & 0x10000000L) / 0x200000L) +  \
                                        ((byte & 0x01000000L) / 0x040000L) +  \
                                        ((byte & 0x00100000L) / 0x008000L) +  \
                                        ((byte & 0x00010000L) / 0x001000L) +  \
                                        ((byte & 0x00001000L) / 0x000200L) +  \
                                        ((byte & 0x00000100L) / 0x000040L) +  \
                                        ((byte & 0x00000010L) / 0x000008L) +  \
                                        ((byte & 0x00000001L) / 0x000001L))

  #define DEFS_BINARY(byte) DEFS_BINARY_CONVERT(0x##byte)

  #define DEFS_BINARY_WORD(high,low) (DEFS_BINARY_CONVERT(0x##high) * 256) + \

2006.1.7 字节交换顺序

/* This is a set of routines for demonstrating the effects of
 byte ordering between little endian and big endian machines

 Big Endian (B_ENDIAN == TRUE):

  MSB [ n | n+1 | n+2 | n+3 ] LSB

 Little Endian (B_ENDIAN == FALSE):

  MSB [ n+3 | n+2 | n+1 | n] LSB

 little/big-endian is bitness as well.  For example,

  struct {
   short b:5,   --- we _want_ signed for the example ---
   c:11;
  };

 is stored in little-endian (gint32el) ['+' denotes sign bit]:

 tf_Bitstream view -->
   0123456789A BCDEF
  |-----c----+|--b-+|

 Whereas bigendian (Motorola) stores it thus:

 tf_Bitstream view -->
   FEDCB A9876543210
  |+-b--|+----c-----|

 So, you have to invert bits as well to convert endianness.

 #define Gettf_Bit(Val,Idx) ( ( (Val) & (1<<(Idx)) ) )
 #define Settf_Bit(Val,Idx,tf_Bit) ( ( (Val) & (~(1<<Idx)) ) | ((tf_Bit)<<(Idx)) )
 for ( i = 0; i < sizeof(Val)*8; i++)
    NewVal = Settf_Bit(NewVal,sizeof(Val)*8-i-1, Gettf_Bit(Val,i));
*/        

DNP
DnpMasterStart
  --> taskSpawn ("tDnpMaster", priority, VX_FP_TASK, 0x8000,
        (FUNCPTR) DnpMasterTask,
        (int) ini_name, 0, 0, 0, 0, 0, 0, 0, 0, 0)
       
   dnpMasterTask ---> dnp_init()
                 ---> ca_task_initialize()
                 ---> ca_add_fd_registration()
                 ---> 从配置文件中得到dnp的配置信息
                 ---> pdpdvrs_initDNP()
                 ---> addr_init()
                 ---> dnp_loop()
       
  DnpMasterAddDevice
  DnpMasterAdd8550
  DnpMasterAddText
 
  DNP　PEER TO PEER
 
  一些debug信息
 
  物理层
  　．利用查表法来确定链路层的长度
  --->． pdpphys_initPhysRecMgr 物理层初始化，分配内存
  　  ． valid_address()
  　　． pdpphys_parseDNPframe()　
 
 
  DnpMasterTask
  

========================================================

  串口：从温旧梦

  　非重叠模式优点　．直接
  　　　　　　　　　．易移植
  　　　　　　缺点　．线程中读、写相互堵塞
  　　　　　　　　　．线程间相互堵塞（包括读之间，写之间，读写之间）
 
  　　　　　　单片机，嵌入式如vxworks，任务中相对简单的程序中常用
 
  　重叠模式　优点　．灵活，效率高（后台执行操作）
  　　　　　　　　　．多线程间，线程中，读写操作不会相互堵塞
  　　　　　　缺点　．不那么直接
  　　　　　　　　　．不易于移植
  　
  EV_RXCHAR：事件通知模式用在非重叠模是一个比较好的方式，因为程序不用轮询串口，以节省CPU的thread quantum
  　　　　　 方式如下：
  　　　　　DWORD dwCommEvent;
   DWORD dwRead;
   char  chRead;
   
   if (!SetCommMask(hComm, EV_RXCHAR))
      // Error setting communications event mask.
   
   for ( ; ; ) {
      if (WaitCommEvent(hComm, &dwCommEvent, NULL)) {
         if (ReadFile(hComm, &chRead, 1, &dwRead, NULL))
            // A byte has been read; process it.
         else
            // An error occurred in the ReadFile call.
            break;
      }
      else
         // Error in WaitCommEvent.
         break;
   }
   问题出现在：当多个字节连续的发送，第１个byte到，引起EV_RXCHAR 事件发生，
                          WaitCommEvent指示可读．第２个byte紧接着到，EV_RXCHAR只是在内部置位，
                          当第１个byte读完，调用WaitCommEvent时，系统再次指示EV_RXCHAR 事件发生，
                          可读第２个byte,问题出现在当第２个字符到达，而没有被读出时，第３个字符到
                          达了，此时系统也期望将对应于第３个字符的EV_RXCHAR置位，但是系统中的
                          EV_RXCHAR标志位已经被第２个已经置位了，于是就被忽略，当第２个自负读出
  　　　　　　后，只能在系统缓冲区，等待第４个字符到，而读出第３个字符，这样代码和系统
                          就失去同步。
   　　　　　　（我觉得这种情况在一般情况下不会出现,在单片机、
                               嵌入式应该是一个一个字符往外蹦，）
   
   　　　　　　而且WaitCommEvent会导致很多其它事件丢失，在高速情况下。
  　　　　　　　　
  　　解决办法是：利用ClearCommError判断缓冲中的字符个数，一次性读完所有到达字符

C++指针探讨 (二) 函数指针 - -

    在C/C++中，数据指针是最直接，也最常用的，因此，理解起来也比较容易。而函数指针，作为运行时动态调用（比如回调函数 CallBack Function）是一种常见的，而且是很好用的手段，不能不好好认识一番。

    接下来，我们就讨论一下函数指针。
   
    2 常规函数指针(难度: 3)
        void(*fp)();
        fp 是一个典型的函数指针，用于指向无参数，无返回值的函数。
        void(*fp2)(int);
        fp2 也是一个函数指针，用于指向有一个整型参数，无返回值的函数。
        当然，有经验人士一般都会建议使用typedef来定义函数指针的类型，如：
        typedef void(* FP)();
        FP fp3; // 和上面的fp一样的定义。
        函数指针之所以让初学者畏惧，最主要的原因是它的括号太多了；某些用途的函数指针，往往会让人陷在括号堆中出不来，这里就不举例了，因为不是本文讨论的范 围；typedef 方法可以有效的减少括号的数量，以及理清层次，所以受到推荐。本文暂时只考虑简单的函数指针，因此暂不用到typedef。
       
        假如有如下两个函数：
  void f1()
  {
      std::cout << "call f " << std::endl;
  }
  
  void f2(int a)
  {
      std::cout << "call f2( " << a << " )" << std::endl;
  }
  
  现在需要通过函数指针来调用，我们需要给指针指定函数：
  fp = &f1; // 也可以用：fp = f1;
  fp2= &f2; // 也可以用：fp2= f2;
  void (*fp3)() = &f1; // 也可以用：void (*fp3)() = f1;  
  调用时如下：
  fp(); // 或 (*fp)();
  fp2(1); // 或 (*fp2)(1);
  fp3();  // 或 (*fp3)();
  对于此两种调用方法，效果完全一样，我推荐用前一种。后一种不仅仅是多打了键盘，而且也损失了一些灵活性。这里暂且不说它。
  
  C ++强调类型安全。也就是说，不同类型的变量是不能直接赋值的，否则轻则警告，重则报错。这是一个很有用的特性，常常能帮我们找到问题。因此，有识之士认 为，C++中的任何一外警告都不能忽视。甚至有人提出，编译的时候不能出现任何警告信息，也就是说，警告应该当作错误一样处理。
  
  比如，我们把f1赋值给fp2，那么C++编译器(vc7.1)就会报错：
  fp2 = &f1; // error C2440: “=” : 无法从“void (__cdecl *)(void)”转换为“void (__cdecl *)(int)”
  fp1 = &f1; // OK
  
  这样，编译器可以帮我们找出编码上的错误，节省了我们的排错时间。C++编译器正致力于这一点。
  
  考虑一下C++标准模板库的sort函数：
  // 快速排序函数
  template
     void sort(
        RandomAccessIterator _First, // 需排序数据的第一个元素位置
        RandomAccessIterator _Last,  // 需排序数据的最后一个元素位置（不参与排序）
        BinaryPredicate _Comp     // 排序使用的比较算法(可以是函数指针、函数对象等)
     );

  比如，我们有一个整型数组：
  int n[5] = {3,2,1,8,9};
  要对它进行升序排序，我们需定义一个比较函数：
  bool less(int a, int b)
  {
      return a < b; // 感谢网友指出笔误之处。原为 return a-b 是错误的。
  }
  然后用：
  sort(n, n+5, less);
  
 
  这样，不需要改变sort函数的定义，就可以按任意方法进行排序，是不是很灵活？  
  这种用法以C++的标准模板库(STL)中非常流行。另外，操作系统中也经常使用回调(CallBack)函数，实际上，所谓回调函数，本质就是函数指针。

译者前言

一个C++程序员，想要进一步提升技术水平的话，应该多了解一些语言的语意细节。对于使用VC++的程序员来说，还应该了解一些VC++对于C++的诠释。Inside the C++ Object Model虽然是一本好书，然而，书的篇幅多一些，又和具体的VC++关系小一些。因此，从篇幅和内容来看，译者认为本文是深入理解C++对象模型比较好的一个出发点。
这篇文章以前看到时就觉得很好，旧文重读，感觉理解得更多一些了，于是产生了翻译出来，与大家共享的想法。虽然文章不长，但时间有限，又若干次在翻译时打盹睡着，拖拖拉拉用了小一个月。
一方面因本人水平所限，另一方面因翻译时经常打盹，错误之处恐怕不少，欢迎大家批评指正。

1 前言

了解你所使用的编程语言究竟是如何实现的，对于C++程序员可能特别有意义。首先，它可以去除我们对于所使用语言的神秘感，使我们不至于对于编译器干的活感到完全不可思议；尤其重要的是，它使我们在Debug和使用语言高级特性的时候，有更多的把握。当需要提高代码效率的时候，这些知识也能够很好地帮助我们。

本文着重回答这样一些问题：
 * 类如何布局？
 * 成员变量如何访问？
 * 成员函数如何访问？
 * 所谓的“调整块”（adjuster thunk）是怎么回事？
 * 使用如下机制时，开销如何：
 * 单继承、多重继承、虚继承
 * 虚函数调用
 * 强制转换到基类，或者强制转换到虚基类
 * 异常处理
首先，我们顺次考察C兼容的结构（struct）的布局，单继承，多重继承，以及虚继承；
接着，我们讲成员变量和成员函数的访问，当然，这里面包含虚函数的情况；
再接下来，我们考察构造函数，析构函数，以及特殊的赋值操作符成员函数是如何工作的，数组是如何动态构造和销毁的；
最后，简单地介绍对异常处理的支持。

对每个语言特性，我们将简要介绍该特性背后的动机，该特性自身的语意（当然，本文决不是“C++入门”，大家对此要有充分认识），以及该特性在微软的VC++中是如何实现的。这里要注意区分抽象的C++语言语意与其特定实现。微软之外的其他C++厂商可能提供一个完全不同的实现，我们偶尔也会将VC++的实现与其他实现进行比较。

2 类布局

本节讨论不同的继承方式造成的不同内存布局。

2.1 C结构（struct）

由于C++基于C，所以C++也“基本上”兼容C。特别地，C++规范在“结构”上使用了和C相同的，简单的内存布局原则：成员变量按其被声明的顺序排列，按具体实现所规定的对齐原则在内存地址上对齐。所有的C/C++厂商都保证他们的C/C++编译器对于有效的C结构采用完全相同的布局。这里，A是一个简单的C结构，其成员布局和对齐方式都一目了然。

struct A {
   char c;
   int i;
};

译者注：从上图可见，A在内存中占有8个字节，按照声明成员的顺序，前4个字节包含一个字符（实际占用1个字节，3个字节空着，补对齐），后4个字节包含一个整数。A的指针就指向字符开始字节处。

2.2 有C++特征的C结构

当然了，C++不是复杂的C，C++本质上是面向对象的语言：包含继承、封装，以及多态。原始的C结构经过改造，成了面向对象世界的基石——类。除了成员变量外，C++类还可以封装成员函数和其他东西。然而，有趣的是，除非为了实现虚函数和虚继承引入的隐藏成员变量外，C++类实例的大小完全取决于一个类及其基类的成员变量！成员函数基本上不影响类实例的大小。

这里提供的B是一个C结构，然而，该结构有一些C++特征：控制成员可见性的“public/protected/private”关键字、成员函数、静态成员，以及嵌套的类型声明。虽然看着琳琅满目，实际上只有成员变量才占用类实例的空间。要注意的是，C++标准委员会不限制由“public/protected/private”关键字分开的各段在实现时的先后顺序，因此，不同的编译器实现的内存布局可能并不相同。（在VC++中，成员变量总是按照声明时的顺序排列）。

struct B {
public:
   int bm1;
protected:
   int bm2;
private:
   int bm3;
   static int bsm;
   void bf();
   static void bsf();
   typedef void* bpv;
   struct N { };
};

译者注：B中，为何static int bsm不占用内存空间？因为它是静态成员，该数据存放在程序的数据段中，不在类实例中。

2.3 单继承

C++提供继承的目的是在不同的类型之间提取共性。比如，科学家对物种进行分类，从而有种、属、纲等说法。有了这种层次结构，我们才可能将某些具备特定性质的东西归入到最合适的分类层次上，如“怀孩子的是哺乳动物”。由于这些属性可以被子类继承，所以，我们只要知道“鲸鱼、人”是哺乳动物，就可以方便地指出“鲸鱼、人都可以怀孩子”。那些特例，如鸭嘴兽（生蛋的哺乳动物），则要求我们对缺省的属性或行为进行覆盖。
C++中的继承语法很简单，在子类后加上“:base”就可以了。下面的D继承自基类C。

struct C {
   int c1;
   void cf();
};

struct D : C {
   int d1;
   void df();
};

既然派生类要保留基类的所有属性和行为，自然地，每个派生类的实例都包含了一份完整的基类实例数据。在D中，并不是说基类C的数据一定要放在D的数据之前，只不过这样放的话，能够保证D中的C对象地址，恰好是D对象地址的第一个字节。这种安排之下，有了派生类D的指针，要获得基类C的指针，就不必要计算偏移量了。几乎所有知名的C++厂商都采用这种内存安排。在单继承类层次下，每一个新的派生类都简单地把自己的成员变量添加到基类的成员变量之后。看看上图，C对象指针和D对象指针指向同一地址。

2.4 多重继承

大多数情况下，其实单继承就足够了。但是，C++为了我们的方便，还提供了多重继承。

比如，我们有一个组织模型，其中有经理类（分任务），工人类（干活）。那么，对于一线经理类，即既要从上级经理那里领取任务干活，又要向下级工人分任务的角色来说，如何在类层次中表达呢？单继承在此就有点力不胜任。我们可以安排经理类先继承工人类，一线经理类再继承经理类，但这种层次结构错误地让经理类继承了工人类的属性和行为。反之亦然。当然，一线经理类也可以仅仅从一个类（经理类或工人类）继承，或者一个都不继承，重新声明一个或两个接口，但这样的实现弊处太多：多态不可能了；未能重用现有的接口；最严重的是，当接口变化时，必须多处维护。最合理的情况似乎是一线经理从两个地方继承属性和行为——经理类、工人类。

C++就允许用多重继承来解决这样的问题：

struct Manager ... { ... };
struct Worker ... { ... };
struct MiddleManager : Manager, Worker { ... };

这样的继承将造成怎样的类布局呢？下面我们还是用“字母类”来举例：

struct E {
   int e1;
   void ef();
};

struct F : C, E {
   int f1;
   void ff();
 
 
};
 
结构F从C和E多重继承得来。与单继承相同的是，F实例拷贝了每个基类的所有数据。与单继承不同的是，在多重继承下，内嵌的两个基类的对象指针不可能全都与派生类对象指针相同：
 
F f;
// (void*)&f == (void*)(C*)&f;
// (void*)&f <  (void*)(E*)&f;
译者注：上面那行说明C对象指针与F对象指针相同，下面那行说明E对象指针与F对象指针不同。

观察类布局，可以看到F中内嵌的E对象，其指针与F指针并不相同。正如后文讨论强制转化和成员函数时指出的，这个偏移量会造成少量的调用开销。

具体的编译器实现可以自由地选择内嵌基类和派生类的布局。VC++按照基类的声明顺序先排列基类实例数据，最后才排列派生类数据。当然，派生类数据本身也是按照声明顺序布局的（本规则并非一成不变，我们会看到，当一些基类有虚函数而另一些基类没有时，内存布局并非如此）。

2.5 虚继承

回到我们讨论的一线经理类例子。让我们考虑这种情况：如果经理类和工人类都继承自“雇员类”，将会发生什么？
 
struct Employee { ... };
struct Manager : Employee { ... };
struct Worker : Employee { ... };
struct MiddleManager : Manager, Worker { ... };
 
如果经理类和工人类都继承自雇员类，很自然地，它们每个类都会从雇员类获得一份数据拷贝。如果不作特殊处理，一线经理类的实例将含有两个雇员类实例，它们分别来自两个雇员基类。如果雇员类成员变量不多，问题不严重；如果成员变量众多，则那份多余的拷贝将造成实例生成时的严重开销。更糟的是，这两份不同的雇员实例可能分别被修改，造成数据的不一致。因此，我们需要让经理类和工人类进行特殊的声明，说明它们愿意共享一份雇员基类实例数据。

很不幸，在C++中，这种“共享继承”被称为“虚继承”，把问题搞得似乎很抽象。虚继承的语法很简单，在指定基类时加上virtual关键字即可。
 
struct Employee { ... };
struct Manager : virtual Employee { ... };
struct Worker : virtual Employee { ... };
struct MiddleManager : Manager, Worker { ... };
 
使用虚继承，比起单继承和多重继承有更大的实现开销、调用开销。回忆一下，在单继承和多重继承的情况下，内嵌的基类实例地址比起派生类实例地址来，要么地址相同（单继承，以及多重继承的最靠左基类），要么地址相差一个固定偏移量（多重继承的非最靠左基类）。然而，当虚继承时，一般说来，派生类地址和其虚基类地址之间的偏移量是不固定的，因为如果这个派生类又被进一步继承的话，最终派生类会把共享的虚基类实例数据放到一个与上一层派生类不同的偏移量处。请看下例：
 
struct G : virtual C {
   int g1;
   void gf();
};
 
译者注：GdGvbptrG（In G, the displacement of G’s virtual base pointer to G）意思是：在G中，G对象的指针与G的虚基类表指针之间的偏移量，在此可见为0，因为G对象内存布局第一项就是虚基类表指针； GdGvbptrC（In G, the displacement of G’s virtual base pointer to C）意思是：在G中，C对象的指针与G的虚基类表指针之间的偏移量，在此可见为4。

struct H : virtual C {
   int h1;
   void hf();
};
 
struct I : G, H {
   int i1;
   void _if();
};
 
暂时不追究vbptr成员变量从何而来。从上面这些图可以直观地看到，在G对象中，内嵌的C基类对象的数据紧跟在G的数据之后，在H对象中，内嵌的C基类对象的数据也紧跟在H的数据之后。但是，在I对象中，内存布局就并非如此了。VC++实现的内存布局中，G对象实例中G对象和C对象之间的偏移，不同于I对象实例中G对象和C对象之间的偏移。当使用指针访问虚基类成员变量时，由于指针可以是指向派生类实例的基类指针，所以，编译器不能根据声明的指针类型计算偏移，而必须找到另一种间接的方法，从派生类指针计算虚基类的位置。

在VC++中，对每个继承自虚基类的类实例，将增加一个隐藏的“虚基类表指针”（vbptr）成员变量，从而达到间接计算虚基类位置的目的。该变量指向一个全类共享的偏移量表，表中项目记录了对于该类而言，“虚基类表指针”与虚基类之间的偏移量。

其它的实现方式中，有一种是在派生类中使用指针成员变量。这些指针成员变量指向派生类的虚基类，每个虚基类一个指针。这种方式的优点是：获取虚基类地址时，所用代码比较少。然而，编译器优化代码时通常都可以采取措施避免重复计算虚基类地址。况且，这种实现方式还有一个大弊端：从多个虚基类派生时，类实例将占用更多的内存空间；获取虚基类的虚基类的地址时，需要多次使用指针，从而效率较低等等。

在VC++中，G拥有一个隐藏的“虚基类表指针”成员，指向一个虚基类表，该表的第二项是GdGvbptrC。（在G中，虚基类对象C的地址与G的“虚基类表指针”之间的偏移量（当对于所有的派生类来说偏移量不变时，省略“d”前的前缀））。比如，在32位平台上，GdGvptrC是8个字节。同样，在I实例中的G对象实例也有“虚基类表指针”，不过该指针指向一个适用于“G处于I之中”的虚基类表，表中一项为IdGvbptrC，值为20。

观察前面的G、H和I，我们可以得到如下关于VC++虚继承下内存布局的结论：
 首先排列非虚继承的基类实例；
 有虚基类时，为每个基类增加一个隐藏的vbptr，除非已经从非虚继承的类那里继承了一个vbptr；
 排列派生类的新数据成员；
 在实例最后，排列每个虚基类的一个实例。

该布局安排使得虚基类的位置随着派生类的不同而“浮动不定”，但是，非虚基类因此也就凑在一起，彼此的偏移量固定不变。

3 成员变量

介绍了类布局之后，我们接着考虑对不同的继承方式，访问成员变量的开销究竟如何。

没有继承。没有任何继承关系时，访问成员变量和C语言的情况完全一样：从指向对象的指针，考虑一定的偏移量即可。
 
C* pc;
pc->c1; // *(pc + dCc1);
译者注：pc是指向C的指针。
 访问C的成员变量c1，只需要在pc上加上固定的偏移量dCc1（在C中，C指针地址与其c1成员变量之间的偏移量值），再获取该指针的内容即可。

单继承。由于派生类实例与其基类实例之间的偏移量是常数0，所以，可以直接利用基类指针和基类成员之间的偏移量关系，如此计算得以简化。
 
D* pd;
pd->c1; // *(pd + dDC + dCc1); // *(pd + dDc1);
pd->d1; // *(pd + dDd1);
译者注：D从C单继承，pd为指向D的指针。
 当访问基类成员c1时，计算步骤本来应该为“pd+dDC+dCc1”，即为先计算D对象和C对象之间的偏移，再在此基础上加上C对象指针与成员变量c1之间的偏移量。然而，由于dDC恒定为0，所以直接计算C对象地址与c1之间的偏移就可以了。
 当访问派生类成员d1时，直接计算偏移量。

多重继承。虽然派生类与某个基类之间的偏移量可能不为0，然而，该偏移量总是一个常数。只要是个常数，访问成员变量，计算成员变量偏移时的计算就可以被简化。可见即使对于多重继承来说，访问成员变量开销仍然不大。
 
F* pf;
pf->c1; // *(pf + dFC + dCc1); // *(pf + dFc1);
pf->e1; // *(pf + dFE + dEe1); // *(pf + dFe1);
pf->f1; // *(pf + dFf1);
译者注：F继承自C和E，pf是指向F对象的指针。
 访问C类成员c1时，F对象与内嵌C对象的相对偏移为0，可以直接计算F和c1的偏移；
 访问E类成员e1时，F对象与内嵌E对象的相对偏移是一个常数，F和e1之间的偏移计算也可以被简化；
 访问F自己的成员f1时，直接计算偏移量。

虚继承。当类有虚基类时，访问非虚基类的成员仍然是计算固定偏移量的问题。然而，访问虚基类的成员变量，开销就增大了，因为必须经过如下步骤才能获得成员变量的地址：获取“虚基类表指针”；获取虚基类表中某一表项的内容；把内容中指出的偏移量加到“虚基类表指针”的地址上。然而，事情并非永远如此。正如下面访问I对象的c1成员那样，如果不是通过指针访问，而是直接通过对象实例，则派生类的布局可以在编译期间静态获得，偏移量也可以在编译时计算，因此也就不必要根据虚基类表的表项来间接计算了。

I* pi;
pi->c1; // *(pi + dIGvbptr + (*(pi+dIGvbptr))[1] + dCc1);
pi->g1; // *(pi + dIG + dGg1); // *(pi + dIg1);
pi->h1; // *(pi + dIH + dHh1); // *(pi + dIh1);
pi->i1; // *(pi + dIi1);
I i;
i.c1; // *(&i + IdIC + dCc1); // *(&i + IdIc1);
译者注：I继承自G和H，G和H的虚基类是C，pi是指向I对象的指针。
 访问虚基类C的成员c1时，dIGvbptr是“在I中，I对象指针与G的“虚基类表指针”之间的偏移”，*(pi + dIGvbptr)是虚基类表的开始地址，*(pi + dIGvbptr)[1]是虚基类表的第二项的内容（在I对象中，G对象的“虚基类表指针”与虚基类之间的偏移），dCc1是C对象指针与成员变量c1之间的偏移；
 访问非虚基类G的成员g1时，直接计算偏移量；
 访问非虚基类H的成员h1时，直接计算偏移量；
 访问自身成员i1时，直接使用偏移量；
 当声明了一个对象实例，用点“.”操作符访问虚基类成员c1时，由于编译时就完全知道对象的布局情况，所以可以直接计算偏移量。

当访问类继承层次中，多层虚基类的成员变量时，情况又如何呢？比如，访问虚基类的虚基类的成员变量时？一些实现方式为：保存一个指向直接虚基类的指针，然后就可以从直接虚基类找到它的虚基类，逐级上推。VC++优化了这个过程。VC++在虚基类表中增加了一些额外的项，这些项保存了从派生类到其各层虚基类的偏移量。

4 强制转化

如果没有虚基类的问题，将一个指针强制转化为另一个类型的指针代价并不高昂。如果在要求转化的两个指针之间有“基类-派生类”关系，编译器只需要简单地在两者之间加上或者减去一个偏移量即可（并且该量还往往为0）。

F* pf;
(C*)pf; // (C*)(pf ? pf + dFC : 0); // (C*)pf;
(E*)pf; // (E*)(pf ? pf + dFE : 0);

C和E是F的基类，将F的指针pf转化为C*或E*，只需要将pf加上一个相应的偏移量。转化为C类型指针C*时，不需要计算，因为F和C之间的偏移量为0。转化为E类型指针E*时，必须在指针上加一个非0的偏移常量dFE。C++规范要求NULL指针在强制转化后依然为NULL，因此在做强制转化需要的运算之前，VC++会检查指针是否为NULL。当然，这个检查只有当指针被显示或者隐式转化为相关类型指针时才进行；当在派生类对象中调用基类的方法，从而派生类指针被在后台转化为一个基类的Const “this” 指针时，这个检查就不需要进行了，因为在此时，该指针一定不为NULL。

正如你猜想的，当继承关系中存在虚基类时，强制转化的开销会比较大。具体说来，和访问虚基类成员变量的开销相当。

I* pi;
(G*)pi; // (G*)pi;
(H*)pi; // (H*)(pi ? pi + dIH : 0);
(C*)pi; // (C*)(pi ? (pi+dIGvbptr + (*(pi+dIGvbptr))[1]) : 0);
译者注：pi是指向I对象的指针，G,H是I的基类，C是G,H的虚基类。
 强制转化pi为G*时，由于G*和I*的地址相同，不需要计算；
 强制转化pi为H*时，只需要考虑一个常量偏移；
 强制转化pi为C*时，所作的计算和访问虚基类成员变量的开销相同，首先得到G的虚基类表指针，再从虚基类表的第二项中取出G到虚基类C的偏移量，最后根据pi、虚基类表偏移和虚基类C与虚基类表指针之间的偏移计算出C*。

一般说来，当从派生类中访问虚基类成员时，应该先强制转化派生类指针为虚基类指针，然后一直使用虚基类指针来访问虚基类成员变量。这样做，可以避免每次都要计算虚基类地址的开销。见下例。

/* before: */             ... pi->c1 ... pi->c1 ...
/* faster: */ C* pc = pi; ... pc->c1 ... pc->c1 ...
译者注：前者一直使用派生类指针pi，故每次访问c1都有计算虚基类地址的较大开销；后者先将pi转化为虚基类指针pc，故后续调用可以省去计算虚基类地址的开销。

5 成员函数

一个C++成员函数只是类范围内的又一个成员。X类每一个非静态的成员函数都会接受一个特殊的隐藏参数——this指针，类型为X* const。该指针在后台初始化为指向成员函数工作于其上的对象。同样，在成员函数体内，成员变量的访问是通过在后台计算与this指针的偏移来进行。
 
struct P {
   int p1;
   void pf(); // new
   virtual void pvf(); // new
 
 
};
 

P有一个非虚成员函数pf()，以及一个虚成员函数pvf()。很明显，虚成员函数造成对象实例占用更多内存空间，因为虚成员函数需要虚函数表指针。这一点以后还会谈到。这里要特别指出的是，声明非虚成员函数不会造成任何对象实例的内存开销。现在，考虑P::pf()的定义。
 
void P::pf() { // void P::pf([P *const this])
   ++p1;   // ++(this->p1);
}

这里P:pf()接受了一个隐藏的this指针参数，对于每个成员函数调用，编译器都会自动加上这个参数。同时，注意成员变量访问也许比看起来要代价高昂一些，因为成员变量访问通过this指针进行，在有的继承层次下，this指针需要调整，所以访问的开销可能会比较大。然而，从另一方面来说，编译器通常会把this指针缓存到寄存器中，所以，成员变量访问的代价不会比访问局部变量的效率更差。
译者注：访问局部变量，需要到SP寄存器中得到栈指针，再加上局部变量与栈顶的偏移。在没有虚基类的情况下，如果编译器把this指针缓存到了寄存器中，访问成员变量的过程将与访问局部变量的开销相似。

5.1 覆盖成员函数

和成员变量一样，成员函数也会被继承。与成员变量不同的是，通过在派生类中重新定义基类函数，一个派生类可以覆盖，或者说替换掉基类的函数定义。覆盖是静态（根据成员函数的静态类型在编译时决定）还是动态（通过对象指针在运行时动态决定），依赖于成员函数是否被声明为“虚函数”。

Q从P继承了成员变量和成员函数。Q声明了pf()，覆盖了P::pf()。Q还声明了pvf()，覆盖了P::pvf()虚函数。Q还声明了新的非虚成员函数qf()，以及新的虚成员函数qvf()。

struct Q : P {
   int q1;
   void pf();  // overrides P::pf
   void qf();  // new
   void pvf(); // overrides P::pvf
   virtual void qvf(); // new
};
 
对于非虚的成员函数来说，调用哪个成员函数是在编译时，根据“->”操作符左边指针表达式的类型静态决定的。特别地，即使ppq指向Q的实例，ppq->pf()仍然调用的是P::pf()，因为ppq被声明为“P*”。（注意，“->”操作符左边的指针类型决定隐藏的this参数的类型。）
 
P p; P* pp = &p; Q q; P* ppq = &q; Q* pq = &q;
pp->pf();  // pp->P::pf();  // P::pf(pp);
ppq->pf(); // ppq->P::pf(); // P::pf(ppq);
pq->pf();  // pq->Q::pf();  // Q::pf((P*)pq); （错误!）
pq->qf();  // pq->Q::qf();  // Q::qf(pq);
译者注：标记“错误”处，P*似应为Q*。因为pf非虚函数，而pq的类型为Q*，故应该调用到Q的pf函数上，从而该函数应该要求一个Q* const类型的this指针。

对于虚函数调用来说，调用哪个成员函数在运行时决定。不管“->”操作符左边的指针表达式的类型如何，调用的虚函数都是由指针实际指向的实例类型所决定。比如，尽管ppq的类型是P*，当ppq指向Q的实例时，调用的仍然是Q::pvf()。
 
pp->pvf();  // pp->P::pvf();  // P::pvf(pp);
ppq->pvf(); // ppq->Q::pvf(); // Q::pvf((Q*)ppq);
pq->pvf();  // pq->Q::pvf();  // Q::pvf((P*)pq); （错误！）
译者注：标记“错误”处，P*似应为Q*。因为pvf是虚函数，pq本来就是Q*，又指向Q的实例，从哪个方面来看都不应该是P*。

为了实现这种机制，引入了隐藏的vfptr成员变量。一个vfptr被加入到类中（如果类中没有的话），该vfptr指向类的虚函数表（vftable）。类中每个虚函数在该类的虚函数表中都占据一项。每项保存一个对于该类适用的虚函数的地址。因此，调用虚函数的过程如下：取得实例的vfptr；通过vfptr得到虚函数表的一项；通过虚函数表该项的函数地址间接调用虚函数。也就是说，在普通函数调用的参数传递、调用、返回指令开销外，虚函数调用还需要额外的开销。

回头再看看P和Q的内存布局，可以发现，VC++编译器把隐藏的vfptr成员变量放在P和Q实例的开始处。这就使虚函数的调用能够尽量快一些。实际上，VC++的实现方式是，保证任何有虚函数的类的第一项永远是vfptr。这就可能要求在实例布局时，在基类前插入新的vfptr，或者要求在多重继承时，虽然在右边，然而有vfptr的基类放到左边没有vfptr的基类的前面。

许多C++的实现会共享或者重用从基类继承来的vfptr。比如，Q并不会有一个额外的vfptr，指向一个专门存放新的虚函数qvf()的虚函数表。Qvf项只是简单地追加到P的虚函数表的末尾。如此一来，单继承的代价就不算高昂。一旦一个实例有vfptr了，它就不需要更多的vfptr。新的派生类可以引入更多的虚函数，这些新的虚函数只是简单地在已存在的，“每类一个”的虚函数表的末尾追加新项。

5.2 多重继承下的虚函数

如果从多个有虚函数的基类继承，一个实例就有可能包含多个vfptr。考虑如下的R和S类：
 
struct R {
   int r1;
   virtual void pvf(); // new
   virtual void rvf(); // new
};
 

struct S : P, R {
   int s1;
   void pvf(); // overrides P::pvf and R::pvf
   void rvf(); // overrides R::rvf
   void svf(); // new
};
 

这里R是另一个包含虚函数的类。因为S从P和R多重继承，S的实例内嵌P和R的实例，以及S自身的数据成员S::s1。注意，在多重继承下，靠右的基类R，其实例的地址和P与S不同。S::pvf覆盖了P::pvf()和R::pvf()，S::rvf()覆盖了R::rvf()。
 
S s; S* ps = &s;
((P*)ps)->pvf(); // (*(P*)ps)->P::vfptr[0])((S*)(P*)ps)
((R*)ps)->pvf(); // (*(R*)ps)->R::vfptr[0])((S*)(R*)ps)
ps->pvf();       // one of the above; calls S::pvf()
译者注：
 调用((P*)ps)->pvf()时，先到P的虚函数表中取出第一项，然后把ps转化为S*作为this指针传递进去；
 调用((R*)ps)->pvf()时，先到R的虚函数表中取出第一项，然后把ps转化为S*作为this指针传递进去；

因为S::pvf()覆盖了P::pvf()和R::pvf()，在S的虚函数表中，相应的项也应该被覆盖。然而，我们很快注意到，不光可以用P*，还可以用R*来调用pvf()。问题出现了：R的地址与P和S的地址不同。表达式(R*)ps与表达式(P*)ps指向类布局中不同的位置。因为函数S::pvf希望获得一个S*作为隐藏的this指针参数，虚函数必须把R*转化为S*。因此，在S对R虚函数表的拷贝中，pvf函数对应的项，指向的是一个“调整块”的地址，该调整块使用必要的计算，把R*转换为需要的S*。
译者注：这就是“thunk1: this-= sdPR; goto S::pvf”干的事。先根据P和R在S中的偏移，调整this为P*，也就是S*，然后跳转到相应的虚函数处执行。

在微软VC++实现中，对于有虚函数的多重继承，只有当派生类虚函数覆盖了多个基类的虚函数时，才使用调整块。

5.3 地址点与“逻辑this调整”

考虑下一个虚函数S::rvf()，该函数覆盖了R::rvf()。我们都知道S::rvf()必须有一个隐藏的S*类型的this参数。但是，因为也可以用R*来调用rvf()，也就是说，R的rvf虚函数槽可能以如下方式被用到：
 
((R*)ps)->rvf(); // (*((R*)ps)->R::vfptr[1])((R*)ps)
 
所以，大多数实现用另一个调整块将传递给rvf的R*转换为S*。还有一些实现在S的虚函数表末尾添加一个特别的虚函数项，该虚函数项提供方法，从而可以直接调用ps->rvf()，而不用先转换R*。MSC++的实现不是这样，MSC++有意将S::rvf编译为接受一个指向S中嵌套的R实例，而非指向S实例的指针（我们称这种行为是“给派生类的指针类型与该虚函数第一次被引入时接受的指针类型相同”）。所有这些在后台透明发生，对成员变量的存取，成员函数的this指针，都进行“逻辑this调整”。

当然，在debugger中，必须对这种this调整进行补偿。
 
ps->rvf(); // ((R*)ps)->rvf(); // S::rvf((R*)ps)
译者注：调用rvf虚函数时，直接给入R*作为this指针。

所以，当覆盖非最左边的基类的虚函数时，MSC++一般不创建调整块，也不增加额外的虚函数项。

5.4 调整块

正如已经描述的，有时需要调整块来调整this指针的值（this指针通常位于栈上返回地址之下，或者在寄存器中），在this指针上加或减去一个常量偏移，再调用虚函数。某些实现（尤其是基于cfront的）并不使用调整块机制。它们在每个虚函数表项中增加额外的偏移数据。每当虚函数被调用时，该偏移数据（通常为0）,被加到对象的地址上，然后对象的地址再作为this指针传入。

ps->rvf();
// struct { void (*pfn)(void*); size_t disp; };
// (*ps->vfptr[i].pfn)(ps + ps->vfptr[i].disp);
译者注：当调用rvf虚函数时，前一句表示虚函数表每一项是一个结构，结构中包含偏移量；后一句表示调用第i个虚函数时，this指针使用保存在虚函数表中第i项的偏移量来进行调整。

这种方法的缺点是虚函数表增大了，虚函数的调用也更加复杂。

现代基于PC的实现一般采用“调整—跳转”技术：
 
S::pvf-adjust: // MSC++
this -= SdPR;
goto S::pvf()
 
当然，下面的代码序列更好（然而，当前没有任何实现采用该方法）：
 
S::pvf-adjust:
this -= SdPR; // fall into S::pvf()
S::pvf() { ... }
译者注：IBM的C++编译器使用该方法。

5.5 虚继承下的虚函数

T虚继承P，覆盖P的虚成员函数，声明了新的虚函数。如果采用在基类虚函数表末尾添加新项的方式，则访问虚函数总要求访问虚基类。在VC++中，为了避免获取虚函数表时，转换到虚基类P的高昂代价，T中的新虚函数通过一个新的虚函数表获取，从而带来了一个新的虚函数表指针。该指针放在T实例的顶端。
 
struct T : virtual P {
   int t1;
   void pvf();         // overrides P::pvf
   virtual void tvf(); // new
};
 
void T::pvf() {
   ++p1; // ((P*)this)->p1++; // vbtable lookup!
   ++t1; // this->t1++;
}
 
如上所示，即使是在虚函数中，访问虚基类的成员变量也要通过获取虚基类表的偏移，实行计算来进行。这样做之所以必要，是因为虚函数可能被进一步继承的类所覆盖，而进一步继承的类的布局中，虚基类的位置变化了。下面就是这样的一个类：
 
struct U : T {
   int u1;
};
 

在此U增加了一个成员变量，从而改变了P的偏移。因为VC++实现中，T::pvf()接受的是嵌套在T中的P的指针，所以，需要提供一个调整块，把this指针调整到T::t1之后（该处即是P在T中的位置）。

5.6 特殊成员函数

本节讨论编译器合成到特殊成员函数中的隐藏代码。

5.6.1 构造函数和析构函数

正如我们所见，在构造和析构过程中，有时需要初始化一些隐藏的成员变量。最坏的情况下，一个构造函数要执行如下操作：

  * 如果是“最终派生类”，初始化vbptr成员变量，调用虚基类的构造函数；
  * 调用非虚基类的构造函数
  * 调用成员变量的构造函数
  * 初始化虚函数表成员变量
  * 执行构造函数体中，程序所定义的其他初始化代码

（注意：一个“最终派生类”的实例，一定不是嵌套在其他派生类实例中的基类实例）

所以，如果你有一个包含虚函数的很深的继承层次，即使该继承层次由单继承构成，对象的构造可能也需要很多针对虚函数表的初始化。
反之，析构函数必须按照与构造时严格相反的顺序来“肢解”一个对象。

 * 合成并初始化虚函数表成员变量
 * 执行析构函数体中，程序定义的其他析构代码
 * 调用成员变量的析构函数（按照相反的顺序）
 * 调用直接非虚基类的析构函数（按照相反的顺序）
 * 如果是“最终派生类”，调用虚基类的析构函数（按照相反顺序）

在VC++中，有虚基类的类的构造函数接受一个隐藏的“最终派生类标志”，标示虚基类是否需要初始化。对于析构函数，VC++采用“分层析构模型”，代码中加入一个隐藏的析构函数，该函数被用于析构包含虚基类的类（对于“最终派生类”实例而言）；代码中再加入另一个析构函数，析构不包含虚基类的类。前一个析构函数调用后一个。

5.6.2 虚析构函数与delete操作符

考虑结构V和W。
 
struct V {
   virtual ~V();
};
 
  struct W : V {
   operator delete();
};
 
析构函数可以为虚。一个类如果有虚析构函数的话，将会象有其他虚函数一样，拥有一个虚函数表指针，虚函数表中包含一项，其内容为指向对该类适用的虚析构函数的地址。这些机制和普通虚函数相同。虚析构函数的特别之处在于：当类实例被销毁时，虚析构函数被隐含地调用。调用地（delete发生的地方）虽然不知道销毁的动态类型，然而，要保证调用对该类型合适的delete操作符。例如，当pv指向W的实例时，当W::~W被调用之后，W实例将由W类的delete操作符来销毁。
 
V* pv = new V;
delete pv;   // pv->~V::V(); // use ::operator delete()
pv = new W;
delete pv;   // pv->~W::W(); // use W::operator delete()
pv = new W;
::delete pv; // pv->~W::W(); // use ::operator delete()
译者注：
 V没有定义delete操作符，delete时使用函数库的delete操作符；
 W定义了delete操作符，delete时使用自己的delete操作符；
 可以用全局范围标示符显示地调用函数库的delete操作符。

为了实现上述语意，VC++扩展了其“分层析构模型”，从而自动创建另一个隐藏的析构帮助函数——“deleting析构函数”，然后，用该函数的地址来替换虚函数表中“实际”虚析构函数的地址。析构帮助函数调用对该类合适的析构函数，然后为该类有选择性地调用合适的delete操作符。

6 数组

堆上分配空间的数组使虚析构函数进一步复杂化。问题变复杂的原因有两个：
1、 堆上分配空间的数组，由于数组可大可小，所以，数组大小值应该和数组一起保存。因此，堆上分配空间的数组会分配额外的空间来存储数组元素的个数；
2、 当数组被删除时，数组中每个元素都要被正确地释放，即使当数组大小不确定时也必须成功完成该操作。然而，派生类可能比基类占用更多的内存空间，从而使正确释放比较困难。
 
struct WW : W { int w1; };
pv = new W[m];
delete [] pv; // delete m W's  (sizeof(W)  == sizeof(V))
pv = new WW[n];
delete [] pv; // delete n WW's (sizeof(WW) >  sizeof(V))
译者注：WW从W继承，增加了一个成员变量，因此，WW占用的内存空间比W大。然而，不管指针pv指向W的数组还是WW的数组，delete[]都必须正确地释放WW或W对象占用的内存空间。

虽然从严格意义上来说，数组delete的多态行为C++标准并未定义，然而，微软有一些客户要求实现该行为。因此，在MSC++中，该行为是用另一个编译器生成的虚析构帮助函数来完成。该函数被称为“向量delete析构函数”（因其针对特定的类定制，比如WW，所以，它能够遍历数组的每个元素，调用对每个元素适用的析构函数）。

7 异常处理

简单说来，异常处理是C++标准委员会工作文件提供的一种机制，通过该机制，一个函数可以通知其调用者“异常”情况的发生，调用者则能据此选择合适的代码来处理异常。该机制在传统的“函数调用返回，检查错误状态代码”方法之外，给程序提供了另一种处理错误的手段。

因为C++是面向对象的语言，很自然地，C++中用对象来表达异常状态。并且，使用何种异常处理也是基于“抛出的”异常对象的静态或动态类型来决定的。不光如此，既然C++总是保证超出范围的对象能够被正确地销毁，异常实现也必须保证当控制从异常抛出点转换到异常“捕获”点时（栈展开），超出范围的对象能够被自动、正确地销毁。
考虑如下例子：
 
struct X { X(); }; // exception object class
struct Z { Z(); ~Z(); }; // class with a destructor
extern void recover(const X&);
void f(int), g(int);

int main() {
   try {
      f(0);
   } catch (const X& rx) {
      recover(rx);
   }
   return 0;
}

void f(int i) {
   Z z1;
   g(i);
   Z z2;
   g(i-1);
}

void g(int j) {
   if (j < 0)
      throw X();
}
译者注：X是异常类，Z是带析构函数的工作类，recover是错误处理函数，f和g一起产生异常条件，g实际抛出异常。

这段程序会抛出异常。在main中，加入了处理异常的try & catch框架，当调用f(0)时，f构造z1，调用g(0)后，再构造z2，再调用g(-1)，此时g发现参数为负，抛出X异常对象。我们希望在某个调用层次上，该异常能够得到处理。既然g和f都没有建立处理异常的框架，我们就只能希望main函数建立的异常处理框架能够处理X异常对象。实际上，确实如此。当控制被转移到main中异常捕获点时，从g中的异常抛出点到main中的异常捕获点之间，该范围内的对象都必须被销毁。在本例中，z2和z1应该被销毁。

谈到异常处理的具体实现方式，一般情况下，在抛出点和捕获点都使用“表”来表述能够捕获异常对象的类型；并且，实现要保证能够在特定的捕获点真正捕获特定的异常对象；一般地，还要运用抛出的对象来初始化捕获语句的“实参”。通过合理地选择编码方案，可以保证这些表格不会占用过多的内存空间。

异常处理的开销到底如何？让我们再考虑一下函数f。看起来f没有做异常处理。f确实没有包含try，catch，或者是throw关键字，因此，我们会猜异常处理应该对f没有什么影响。错！编译器必须保证一旦z1被构造，而后续调用的任何函数向f抛回了异常，异常又出了f的范围时，z1对象能被正确地销毁。同样，一旦z2被构造，编译器也必须保证后续抛出异常时，能够正确地销毁z2和z1。

要实现这些“展开”语意，编译器必须在后台提供一种机制，该机制在调用者函数中，针对调用的函数抛出的异常动态决定异常环境（处理点）。这可能包括在每个函数的准备工作和善后工作中增加额外的代码，在最糟糕的情况下，要针对每一套对象初始化的情况更新状态变量。例如，上述例子中，z1应被销毁的异常环境当然与z2和z1都应该被销毁的异常环境不同，因此，不管是在构造z1后，还是继而在构造z2后，VC++都要分别在状态变量中更新（存储）新的值。

所有这些表，函数调用的准备和善后工作，状态变量的更新，都会使异常处理功能造成可观的内存空间和运行速度开销。正如我们所见，即使在没有使用异常处理的函数中，该开销也会发生。

幸运的是，一些编译器可以提供编译选项，关闭异常处理机制。那些不需要异常处理机制的代码，就可以避免这些额外的开销了。

8 小结

好了，现在你可以写C++编译器了（开个玩笑）。
在本文中，我们讨论了许多重要的C++运行实现问题。我们发现，很多美妙的C++语言特性的开销很低，同时，其他一些美妙的特性（译者注：主要是和“虚”字相关的东西）将造成较大的开销。C++很多实现机制都是在后台默默地为你工作。一般说来，单独看一段代码时，很难衡量这段代码造成的运行时开销，必须把这段代码放到一个更大的环境中来考察，运行时开销问题才能得到比较明确的答案。

C++ 的 MetaProgramming

废话就不说了, 按照C的传统惯例,介绍programming的最好方式就是show代码, 第一个例子就是Hello,world, 这篇文章也不例外

在任何一个cpp文件中,输入

struct hello_world; //forward declaration
struct A : hello_world
{
};

然后编译..,注意我没有说"编译运行",而仅仅说的是"编译", 如果不意外的话,在你编译器的输出窗口会出现
base class hello_world undefined
或者
base class `hello_world' has incomplete type

等类似的语句, 至少在你的屏幕上打印出了 "hello_world" 字样,对吧? 对了,这就是这个例子的目的, 我不也打印出来的吗?

上面这个简陋的例子阐述了一个重要的现象, "编译时"而不是运行时, 这就是meta programming的世界, 一个处于编译期间, 而不是运行期间的世界.

运行时我们能作的事情很多在编译时我们不能作, 例如我们不能调用函数, 我们不能创建对象, 我们也不能设置断点, 一切都交给你的C++编译器.

接下来, 首先回顾一下一些C++的基本模板知识.
由于C++的编译器符合ISO 标准的程度不一, 我使用的是VC++ 6 和 gcc version 3.2.3 (mingw special 20030504-1)
下面的例子我在这两个编译器中都测试过.

C++模板的最经常的认识就是STL中的容器, 例如
vector<int> 就是一个可以装int的动态数组, vector<sharp*> 就是一个可以装sharp对象指针的数组.

然后我们还需要一点点模板特化的知识.
例如

template<class T> struct Foo {};

这是一个通用模板, 必配任何类型, 如果我们需要对int进行特别处理, 那么

template<> struct Foo<int>  {}; 

这样就实现了对 int 类型的完全特化 . VC6 只支持完全特化, 不支持偏特化, 或者部分特化.
不过还是稍微介绍一下:
什么是遍特化了? 还就上面这个例子而言, 如果我们想对所有的指针进行特化, 那么应该是
template<class T> struct Foo<T*> {}

那么什么又是部分特化了, 看看这个:
template<class T, class U> struct bar {};

template<class T> struct bar<T, int>  {};

后面这个就是对U模板参数的部分特化,使得 U为 int的时候 使用这个版本.

这篇文章由于针对VC6, 因此你不会遇到偏特化和部分特化的情况.

hello,world的例子以后, 我们准备干点有意思的事情. 例如求两数之和. 首先看看在运行时的函数我们应该如何实现:

定义:
int sum(int x, int y) { return x+y; }

调用:
int j =  sum(3, 4)

那么如何用meta programming的方式实现了?

meta programming 由于处于编译器, 因此给它的参数必须是编译时就可以确定的, 在当前C++中允许的为,integer 和 type.

就上面这个例子, 对于模板的调用应该是:
int j = sum_<3,4>::value;

3,4 都为整形常量, 编译时确定, 然后返回值如何取得? 记住在编译时是无法进行真正的函数调用的,因此我们只有通过定义在模板类中的一个常量
来获得返回结果. 最简单的方法就是在一个 struct定义一个匿名的enum .

sum的定义如下:
template<int x, int y>
struct sum_
{
  enum { value = x + y };
};

然后你可以编译后"运行"检查检查看看运行结果

#include <iostream>

using namespace std;

template<int x, int y>
struct sum_

{
   
    enum { value = x + y };

};

int main()

{
   
   cout << sum_<3, 4>::value << endl;
   
   return 0;

}

上面之所以使用struct sum_而不是class sum_是因为struct的默认作用范围上public, 可以省略几个键击.

这个例子通用展示了一个重要的观点, 对应通常可以在运行时调用的函数
int foo(int a, int b)
其对应的meta 实现为:
foo<a, b>::value
也就是我们的foo现在为一个struct name, 参数通过< > 中的模板投递, 结果通过 ::value 获得其中定义的一个匿名enum值.

那么如何计算 3,4,5的和?
你可能会想如下:
 sum_<3,4,5>::value

但是c++不支持一个模板类使用不同的参数参数存在, 换一个方式,
你如何在 int sum(int a, int b) 存在的情况下获得3个数的和?
我们可以这样：
sum( 3, sum(4, 5))
有lisp 背景的可能发现这很符合他们的思考方式, 至少以我浮浅的emacs lisp知识, 不使用中间变量. 同样,meta中你也可以这样使用:

sum_<   //开始参数
sum_< 3 //第一个参数为3
sum_< 3, sum_<   //第二个参数是另外一个表达式的结果
sum_< 3, sum_<4, //这个表达式的第一个参数为４
sum_< 3, sum_<4, 5> //这个表达式的第二个参数为５
sum_< 3, sum_<4, 5>::value //通过::value获得这个表达式的结果
sum_< 3, sum_<4, 5>::value >::value //然后获得整个表达式的结果

ok, 就这么多, 看出来没有, 再解释一次, 将上面我们的
  cout << sum_<3, 4>::value << endl;
   

中４的位置用一个sum_ 替换就得到了我们需要的三个数之和.

  cout << sum_<3, ?? >::value << endl;
   
 ===>
   ?? =  sum_<4, 5>::value

 ===> then
  cout << sum_<3, sum_<4, 5>::value >::value << endl;
   

如果我需要算 2, 3, 4, 5之和呢?
同样简单, 你将上面的3, 4 ,5 中的任何一个常量替换成对sum_ 进行一个调用就可以了.
例如:

out << sum_< ?? , sum_<4, 5>::value >::value << endl;
   

?? =  sum_< 2, 3 >::value

合并后为

cout << sum_< sum_<2, 3>::value , sum_<4, 5>::value >::value << endl;
运行的结果为 14.

这就是meta中最简单的一个例子, 顺序调用, 如果你看明白了同时觉得有点意思的话, 下来我们讲讲
循环语句, 通常我们写程序都避免递归, 因为容易造成堆栈和大脑溢出,但是在 meta 中必须使用递归的方式.

下面看看一个计算"阶乘"的例子, 其实这个才真正是meta 中的hello,world.

先看后面, 我们调用的方式:

cout << fac<5>::value ;  // 结果应该是 5 * 4 * 3 * 2 * 1 = 120;

通过前面的知识, 你知道fac是一个template struct的名字, 有一个模板参数int, value是其中的一个匿名枚举变量
于是你可以毫不犹豫的写下:

template<int i>
struct fac
{
  enum { value = ??? };
};

但是在value的地方你卡住了, 如果根据 i 得到 value?

让我们将大脑从"编译时世界"切换到"运行时的世界", 你如何写一个通常的递归函数来计算阶乘?

int fac(int n)
{
  if( n == 1)
    return 1;
  return n * fac(n-1);
}

注意 n == 1是一个递归退出条件,先不考虑n为1时的递归退出,
其他情况下是将n 乘以 fac (n - 1). 有了前面的sum_ 知识, 你应该可以推出 value = ???
中的??? 应该是
n *       //n*
fac       //调用下一个fac
fac<n-1>  //参数为n-1
fac<n-1>::value //获得结果

因此fac "函数"的模板实现就是

template<int i>
struct fac
{
  enum { value = i * fac<i - 1>::value };
};

然后我们再考虑递归退出条件, 为1时value应该为1, 拿起C++中的特化模板武器来
template<>
struct fac<1>      //参数为1时的特化
{
  enum { value = 1 };
};

这样就将参数为 1 时的返回值设置为1, 结束递归.

这样,当你输入
cout << fac<5>::value << endl;
时,编译器会实例化
template<>
struct fac<5>
{
  enum { value = 5 * fac<4>::value };
};

由于fac<5> 需要 fac<4> , 因此然后实例化 fac<4>, 同样的原因, fac<3> , fac<2>, fac<1>

到fac<1> , 编译器发现了一个特化版本fac<1> 匹配, 在fac<1>中的value已经是一个常量, 不依赖其他的fac实例, 递归退出, 最后
我们得到最终结果120 .

easy, 对不?

然后再介绍 if语句.
还是上面的这个fac例子, 负数的阶乘是没有意义的,先不考虑数学问题,假设我们希望在这个情况下返回-1,如何实现?

如果我们输入fac<-2>::value , 那么编译器会尝试实例化fac<-3>, fac<-4>, ......
你发现这是一个无限递归条件, 在运行时会造成你堆栈溢出, 由于我们在"编译时世界", 取决于你编译器, 最终总有结束的时候.

例如VC6 报错: fatal error C1202: recursive type or function dependency context too complex
G++报错     : template instantiation depth exceeds maximum of 500

因此我们需要一个if判断语句, 发现当模板参数 < 1的时候返回 -1.

按照测试先行的原则, 我们可以预计
fac<-1>::value == -1  是成立的.
现在的问题是如何实现? 下次再说吧! 也给个机会折磨折磨你的大脑. 记住, 模板不仅仅可以通过enum返回整数, 还可以通过嵌套 typedef返回一个类型.

上回说到一个fac的版本, 希望在负数的情况下返回-1, 而不是无限递归下去.
还是按照我们的思维, 先写个对应"运行时世界"的版本.

int safe_fac(int n)
{
  if( n < 1)
     return -1;
  return fac(n);
}

这个if逻辑很简单, 如果模板参数<1, 那么直接返回 -1, 否则 还是使用前面的fac那个版本.
好, 转换成我们的meta 版本.

你想,用个 ?: 运算符不就解决了吗?

template<int n>
struct safe_fac
{
  enum { value =  (n < 1 ? -1 : fac<n>::value ) };
};

可惜不对,  ?= 只有在"运行时世界"才能使用. 那么 value 后面的???写什么好呢?

先轻松轻松, 写一个if的meta 版本, 我敢保证你能看得懂.
template< bool b , class T, class U>
struct if_
{
  typedef T type;
};

注意了, 如果以前我们提到的例如sum_, fac等meta functions(其实就是c++中的模板类, 称之为meta function是因为它们就像是function)
是通过一个 在enum中的value 返回整形的话, 上面刚刚的if_这个例子就展示了 meta中的另外一个武器, 通过typedef 一个type 返回一个类型.

如果我们这样调用
if_<true, int, double>::type  的结果就是 int 类型, 注意是"类型", 不是对象.

我们想在b为false的时候返回第二个类型U, 即:
if_<false, int, double>::type 的返回结果是double

那么还是很简单, 部分特化 b 参数就可以了.即:
template<class T, class U>
struct if_<false, T, U>
{
  typedef U type;
};

我最前面说了, VC6不支持部分特化, 但是别忘了计算机时间的一条公理:
任何计算机问题都可以通过增加一层来解决. 大部分VC6中的模板的问题还是可以解决的. 如果你不使用VC6, 这部分就不用看了.

VC6是支持全部特化的, 因此我们可以将true, false特化出来

template<bool>
struct if_help
{
   ...
};

template<>
struct if_help<false>
{
   ...
};

这个在vc6中是支持的. 然后我们还需要两个额外的类型参数T,U, 这可以通过嵌套类来实现. 即

template<bool>
struct if_help
{
  template<class T, class U>
  struct In
  {
     typedef T type;
  };
};

template<>
struct if_help<false>
{
  template<class T, class U>
  struct In
  {
     typedef U type;
  };
};

然后我们真正的if_ "meta 函数"如下定义:

template<bool b, class T, class U>
struct if_
{
   typedef if_help<b>::In<T, U>::type type;
};

先根据b的内容实例化一个对应的if_help, : if_help<b>
然后给其中的In模板投递T,U参数, ::In<T, U>
然后通过type获得其中的返回类型 ::type
最后typedef type一下作为自己的返回类型, 这样外部就可以通过
if_<true, int, double>::type  获得返回的类型了.

上面if_ 的实现实际上要用几个C++关键字修饰一下:
typedef if_help<b>::In<T, U>::type type;
 ===>
typedef typename if_help<b>::template In<T, U>::type type;

为什么要加上typename 和 template, 这个解释起来到是很费劲. 有空再说.

好了, 从模板的语法世界中清醒过来, 现在你知道的是, 我们有了一个if_ 的meta函数, 接受3个参数bool b, class T, class U,
如果b为true, 那么它的返回值 (通过 if_::type 返回) 就是T,
如果b为false, 那么它的返回值 (通过 if_::type 返回) 就是U.

前面我提过了, 参数是通过<>来传递的, 因此一个例子就是

if_                          //函数名
if_<true,                    //第一个参数, bool 型
if_<true, int                //第二个参数, 类型
if_<true, int, double        //第3个参数,  类型
if_<true, int, doubble>      //右括号表示参数结束
if_<true, int, double>::type //通过::type获得返回结果, 不是value了, 当然这仅仅是一个命名惯例.

因此上面的那个 if_<true, int, double>::type 返回的就是 int,
在"运行时世界", 你可以如下使用:

for( if_<true, int, double>::type i = 0; i < 10; i++) {
  cout << "line " << i << "\n";
}

等同于
for( int i = 0; i < 10; i++) {
  cout << "line " << i << "\n";
}

当然对于这个例子这样使用是"有病". 我们等会会用到if_来实现前面的  safe_fac 实现了.

注意我说的返回值并不是前面sum_例子中的整形了, 这个时候返回一个类型. 类型不是实例对象, 这点我想你应该清楚.
编译时不可能返回对象, 因为要调用构造函数, 要确定对象地址, 我们还没有进入到" 运行时世界" , 对吧?
实际上meta programming 最重要的使用并不是前面我们提到过的sum_, fac这些, 因为毕竟拿个计算器算一下也花不了几个时间.
但是返回type就不同了.
那么type可以是什么呢? 可以是int, double这样的基本类型, 也可以我们前面的 sum_ 模板类等等.

然后再看safe_fac的实现:
先不考虑 <1 的情况, 那么value就应该是直接调用以前的 fac 函数

template<int n>
struct safe_fac
{
  enum { value = fac<n>::value };
};

然后再使得 >= 1时才使用fac函数, 那么利用我们前面的if_, 先忽略语法错误, 那么可以如下

enum
{
value = if_< n < 1,???,  fac<n> >::type::value
};

首先, n < 1 为真时返回一个类型???, 暂时我们还没有实现, 为false时返回
fac<n>类型, 然后通过::type获得返回的类型,或者为???, 或者为fac<n>,
然后通过::value得到这个类型的整数结果.

那么 ??? 应该是什么呢? 当然不能直接是-1, 否则 -1::value 就是语法错误.

因此我们可以定义一个简单的"函数", 返回-1:

struct return_neg1
{
   enum { value = -1 };
};

如果我们需要返回-2怎么办? 又定义一个return_neg2 "函数"? 干脆我们一劳永逸, 定义如下:

template<int n>
struct int_
{
   enum { value = n };
};

这样int_ 这个"函数"就是你给我什么, 我就返回什么. 不过int_是一个类型, 例如:
通过如下调用 int_<3>::value  返回它的结果3.

有了这个, 我们的代码就如下:

value = if_< n < 1, int_<-1>,  fac<n> >::type::value

原理清楚了, 最终的版本就是:

template<int n>
struct safe_fac
{
  enum { value = if_< n < 1, int_<-1>,  fac<n> >::type::value };
};

试试:
cout << safe_fac<-1>::value 输出 -1.

循环(递归表示), 条件判断, 顺序执行都有了, 剩下的就看你自己了.

--------------------------------------------------------------------------------
Boost中的mpl (meta programming library) 提供了一个专门用于metaprogramming的library, 同时前面提到的if_, int_等等就
是从mpl中拷贝来的, 当然我简化了很多.

Modern C++ Design 其中的Typelist将meta progamming的循环(就是递归)发挥得淋漓尽致, 在侯捷的网站上www.jjhou.com有免费的前4章可读. Typelist在第三章.
书中序言部分, Effective C++的作者Meyers说到, 如果第3章的typelists没有让你感到振奋, 那你一定是很沉闷.
就我亲身体验, 我觉得Meyers可能是说到委婉了些:
如果第3章的typelists没有让你感到振奋, 那1%的可能是你是很沉闷, 99%的可能是你没有看懂. I did.
GoF之一的 John Vlissides同样提到了typelists这一章就值得本书的价格. I believe.

另外, 我发现即使在这本让人抓狂的天才之作中, 作者仍然使用了n个TYPELIST_n 这样的预处理宏来处理多个type的情况, 但是在sourceforge
下的Loki库中我发现已经有了一个MakeTypelist"函数", 看来 meta programming 确实是, 啊...
是不是作者当时都没有预见到还能够以C++编译器内建的模板能力, 而不是依赖预处理宏来处理typelist.?

又, mpl中有专门装type的容器....

C++ Templates <The complete guide> 中的一个例子:

一个模板基类
template<class T>
class Base
{
public:
   int field;       // #1
};

派生类, 从上面的模板基类继承
注意, 在此, 基类并不能确定就是上面的Base<T>,
因为 下面#3 处可以看到, 程序对Base<int>进行了特化

template<class T>
class Derived : public Base<T>
{
public:
 void f()
 {
  field++;          //#2 哪个field? #1处还是#3处,
 }
};

#2处的field到底是char还是int类型? 即#1处还是#3处 ? 显然无法确定, 只有当
Derived被某个特定的T类型实例化的时候才知道.

template<>
class Base<int>
{
public:
 char field;           //#3
};

#2处的field是一个unqualified name, 而基类Base<T>是一个dependent name, 因此不去其中查找.

正确的编译器做法是: 在#1处报错.  VC7.1就是如此.

书中的例子实现手法使用多重/虚拟继承, 实现手法感觉比较诡秘. 但是至少告诉我是可以实现的.

于是干脆自己也练了练手,  博君一笑. 只在VC7.1下测试过, VC6也许可能可以迂回实现, 但是估计工作量太大.

1. 首先需要一个基本的 If 语句.

2. 然后使用一个 type_selector meta-function, N表示第几个默认参数(注意我的默认Policy参数DefaultPolicyArgs里面有一个meta data, 为0. 如果是用户定义的Policy, 那么形如Policy2_is的模板类里面有一个meta data为2. 这个数字主要是用于定位.

最后的DefaultType是当扫描一遍, 发现没有任何对应N位置的自定义Policy参数, 那么就取这个为默认值, 结束递归.(下面的4个void的特化版本就是干这个的)

注：以下全部假定是文本文件，二进制文件没有测试过。

  ifstream fIn("yourfile");
  if(fIn)
  {
   istream_iterator<string> strReader(fIn);// file begin
   istream_iterator<string> strEOF;  // file end

   string strToFind = "mythma";
   strReader=find(strReader, strEOF, strToFind);
   while(strReader != strEOF)
   { 
     ++strReader;  
    // do something 
    //*strReader; //dereference to get current string
    // find next 
    strReader=find(strReader, strEOF, strToFind);
   }
  }

从上面的代码可以看出, 此时fIn可以看作是一个存放const string的容器。

   istream_iterator<int> intReader(fIn);// file begin
   istream_iterator<int> intEOF;  // file end

   istream_iterator<CUser> intReader(fIn);// file begin
   istream_iterator<CUser> intEOF;  // file end

2、文件中是异构数据情况的处理

首先文件中所有的内容都可以用string来操作，这种处理方式无需讨论。
若用istream_iterator<int>读取包含非int数据的文件时会出现什么情况？
经测试，当istream_iterator<int>遇到第一个非int数据时，迭代终止。
---
测试代码：

  using namespace std;
  ifstream fIn("test.txt");
  if(fIn)
  {
   istream_iterator<int> intReader(fIn);
   istream_iterator<int> intEOF;

   copy(intReader, intEOF, ostream_iterator<int>(cout, " "));
  }

---
测试文件test.txt：
1 22 3.4 haha 44 hello
---
输出结果：
1 22 3

3、效率问题
istream_iterator除了使代码看起来比较简洁外，大家最关心的恐怕就是效率问题。我没有测试比较过。