C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员 函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

关于虚函数的使用方法，我在这里不做过多的阐述。大家可以看看相关的C++的书籍。在这篇文章中，我只想从虚函数的实现机制上面为大家 一个清晰的剖析。

当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的代码，没有图片，没有详细的说明，没有比较，没有举一反三。不利于学习和阅读，所以这是我想写下这篇文章的原因。也希望大家多给我提意见。

言归正传，让我们一起进入虚函数的世界。

虚函数表

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。 这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。 没关系，下面就是实际的例子，相信聪明的你一看就明白了。

假设我们有这样的一个类：

class Base {
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }
};

按照上面的说法，我们可以通过Base的实例来得到虚函数表。 下面是实际例程：

typedef void(*Fun)(void);
Base b;
Fun pFun = NULL;
cout << "虚函数表地址：" << (int*)(&b) << endl;
cout << "虚函数表 — 第一个函数地址：" << (int*)*(int*)(&b) << endl;

// Invoke the first virtual function
pFun = (Fun)*((int*)*(int*)(&b));
pFun();

实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)

虚函数表地址：0012FED4
虚函数表 — 第一个函数地址：0044F148
Base::f

通过这个示例，我们可以看到，我们可以通过强行把&b转成int *，取得虚函数表的地址，然后，再次取址就可以得到第一个虚函数的地址了，也就是Base::f()，这在上面的程序中得到了验证（把int* 强制转成了函数指针）。通过这个示例，我们就可以知道如果要调用Base::g()和Base::h()，其代码如下：

(Fun)*((int*)*(int*)(&b)+0); // Base::f()

(Fun)*((int*)*(int*)(&b)+1); // Base::g()

(Fun)*((int*)*(int*)(&b)+2); // Base::h()

这个时候你应该懂了吧。什么？还是有点晕。也是，这样的代码看着太乱了。没问题，让我画个图解释一下。如下所示：

注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\0”一样，其标志了虚函数表的 结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。没有覆盖父类的虚函数是毫无意义的。我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。在比较之下，我们可以更加清楚地知道其内部的具体实现。

一般继承（无虚函数覆盖）

下面，再让我们来看看继承时的虚函数表是什么样的。假设有如下所示的一个继承关系：

请注意，在这个继承关系中，子类没有重载任何父类的函数。那么，在派生类的实例中，其虚函数表如下所示：

对于实例：Derive d; 的虚函数表如下：

我们可以看到下面几点：

1. 虚函数按照其声明顺序放于表中。
2. 父类的虚函数在子类的虚函数前面。

我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。

一般继承（有虚函数覆盖）

覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。下面，我们来看一下，如果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承关系。

为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。那么，对于派生类的实例，其虚函数表会是下面的一个样子：

我们从表中可以看到下面几点，

1. 覆盖的f()函数被放到了虚表中原来父类虚函数的位置。
2. 没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序，

Base *b = new Derive();
b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

多重继承（无虚函数覆盖）

下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。注意：子类并没有覆盖父类的函数。

对于子类实例中的虚函数表，是下面这个样子：

我们可以看到：

1. 每个父类都有自己的虚表。
2. 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

多重继承（有虚函数覆盖）

下面我们再来看看，如果发生虚函数覆盖的情况。

下图中，我们在子类中覆盖了父类的f()函数。

下面是对于子类实例中的虚函数表的图：

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

Derive d;

Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;

b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()

b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()

安全性

每次写C++的文章，总免不了要批判一下C++。这篇文章也不例外。通过上面的讲述，相信我们对虚函数表有一个比较细致的了解了。水可载舟，亦可覆舟。下面，让我们来看看我们可以用虚函数表来干点什么坏事吧。

通过父类型的指针访问子类自己的虚函数

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载的。虽然在上面的图中我们可以看到Base1的虚表中有Derive的虚函数，但我们根本不可能使用下面的语句来调用子类的自有虚函数：

Base1 *b1 = new Derive();
b1->f1(); //编译出错

任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。（关于这方面的尝试，通过阅读后面附录的代码，相信你可以做到这一点）

访问non-public的虚函数

另外，如果父类的虚函数是private或是protected的，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这是很容易做到的。

如：

class Base {
private:
virtual void f() { cout << "Base::f" << endl; }
};

class Derive : public Base{
};

typedef void(*Fun)(void);

void main() {
Derive d;
Fun pFun = (Fun)*((int*)*(int*)(&d)+0);
pFun();
}

结束语

C++这门语言是一门Magic的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我们在干了什么。需要熟悉这门语言，我们就必需要了解C++里面的那些东西，需要去了解C++中那些危险的东西。不然，这是一种搬起石头砸自己脚的编程语言。

在文章束之前还是介绍一下自己吧。我从事软件研发有十个年头了，目前是软件开发技术主管，技术方面，主攻Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax等一切和互联网相关的东西。管理方面比较擅长于团队建设，技术趋势分析，项目管理。欢迎大家和我 交流，我的MSN和Email是：haoel@hotmail.com

附录一：VC中查看虚函数表

我们可以在VC的IDE环境中的Debug状态下展开类的实例就可以看到虚函数表了（并不是很完整的）

附录 二：例程

下面是一个关于多重继承的虚函数表访问的例程：

#include <iostream>

using namespace std;

class Base1 {
public:
virtual void f() { cout << "Base1::f" << endl; }
virtual void g() { cout << "Base1::g" << endl; }
virtual void h() { cout << "Base1::h" << endl; }
};

class Base2 {
public:
virtual void f() { cout << "Base2::f" << endl; }
virtual void g() { cout << "Base2::g" << endl; }
virtual void h() { cout << "Base2::h" << endl; }
};

class Base3 {
public:
virtual void f() { cout << "Base3::f" << endl; }
virtual void g() { cout << "Base3::g" << endl; }
virtual void h() { cout << "Base3::h" << endl; }
};

class Derive : public Base1, public Base2, public Base3 {
public:
virtual void f() { cout << "Derive::f" << endl; }
virtual void g1() { cout << "Derive::g1" << endl; }
};

typedef void(*Fun)(void);

int main()
{
Fun pFun = NULL;
Derive d;

int** pVtab = (int**)&d;

//Base1's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
pFun = (Fun)pVtab[0][0];
pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
pFun = (Fun)pVtab[0][1];
pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
pFun = (Fun)pVtab[0][2];
pFun();

//Derive's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
pFun = (Fun)pVtab[0][3];
pFun();

//The tail of the vtable
pFun = (Fun)pVtab[0][4];
cout<<pFun<<endl;

//Base2's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
pFun = (Fun)pVtab[1][0];
pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
pFun = (Fun)pVtab[1][1];
pFun();

pFun = (Fun)pVtab[1][2];
pFun();

//The tail of the vtable
pFun = (Fun)pVtab[1][3];
cout<<pFun<<endl;

//Base3's vtable
//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
pFun = (Fun)pVtab[2][0];
pFun();

//pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
pFun = (Fun)pVtab[2][1];
pFun();

pFun = (Fun)pVtab[2][2];
pFun();

//The tail of the vtable
pFun = (Fun)pVtab[2][3];
cout<<pFun<<endl;

return 0;
}

来源：陈皓 http://blog.csdn.net/haoel

一般而言，constructor和destructor的安插都如下：

//C++伪码
{
    Point point;
    // point.Point::Point()   //一般会被安插在这里
    ...
    // point.Point::~Point()   //一般会被安插在这里
}

如果一个作用域或函数中有一个以上的离开点，情况会稍微混乱一些。Destructor必须被放在每一个离开点之前，例如：

{
    Point point;
    // constructor 在这里
    switch( int (point.x()) ) {
        case -1:
            //...
            // destructor在这里
            return;
        case 0:
            //...
            //destructor在这里
            return;
        case 1:
            //...
            //destructor在这里
            return;
        default:
            //...
            //destructor在这里
            return;
    }
    //destructor在这里
}

在这个例子中，point的destructor必须在switch指令四个出口的return操作前被生成出来。另外也很有可能在这个作用域的结束符号之前被生成出来。因此，一般而言，我们会把object尽可能放置在使用它的那个程序区段附近，这样做可以节省不必须的对象产生操作和摧毁操作。

全局对象

C++程序中所有的global objects都被放置在程序的data segment中。如果明确指定给它一个值，object将以该值为初值，否则object所配置到的内容为0（这和C略有不同，C并不自动设定初值）。对于全局的class object，其在编译时期可以被放置于data segment中并且内容为0，但constructor一直要到程序运行时才会执行。
对于每个全局对象，编译器会为其产生一个相应的初始化函数和内存释放函数，这些函数在编译时期就通过一定的方法链接起来，并插在main函数的开始处和结束处。

局部静态对象

对于局部静态对象，可以通过创建一个临时性的标记对象，用来判断在函数调用的时候局部静态对象是否已经被初始化，而不用在程序启动的时候将所有局部静态对象都构造出来。

二、对象数组

对于像下面的数组定义：

Point knots[10];

Point有一个default constructor，因此这个constructor必须轮流施行于knots每一个元素之上。在cfront中，使用一个命名为vec_new()的函数，产生出以class objects构造而成的数组。比较晚近的编译器，包括Borland、Microsoft和Sun，则是提供了两个函数，一个用来处理“没有virtual base class”的class，另一个用来处理“内带virtual base class”的class。后一个函数通常称为vec_vnew()。函数类型通常如下（当然在各平台上可能会有些许差异存在）：

void* vec_new(
    void *array,                                      //数组起始地址
    size_t elem_size,                                //每一个class object的大小
    int elem_count,                                  //数组中的元素数目
    void (*constructor)( void* ),
    void (*destructor)( void*, char)
}

其中constructor和destructor参数是这个class的default constructor和default destructor的函数指针，虽然constructor和destructor在程序代码是没法获取到的，但是在这里有编译器的支持，因此完全可以获取到constructor和destructor的函数指针。下面是编译器可能针对上面定义的10个Point元素所做的vec_new()调用操作：

Point knots[10];
vec_new( &knots, sizeof( Point ), 10, &Point::Point, 0);

如果Point也定义了一个destructor，当knots的生命结束时，该destructor也必须施行于这10个Point元素身上，这是经由一个类似于vec_delete()的runtime library函数完成的，其函数原型如下：

void* vec_delete(
    void *array,                                      //数组起始地址
    size_t elem_size,                                //每一个class object的大小
    int elem_count,                                  //数组中的元素数目
    void (*destructor)( void*, char)
}

如果在程序员代码中提供了一个或多个明显初始给一个由class objects组成的数组，像下面这样：

Point knots[10] = {
    Point(),
    Point(1.0, 1,0, 0.5),
    -1.0
};

那么，对于那些明显获得初值的元素，vec_new()不再有必要。对于那些尚未被初始化的元素，vec_new()的施行方式就可能被转换为：

Point knots[0];
//明确地初始化前3个元素
Point::Point( &knots[0] );
Point::Point( &knots[1], 1.0, 1.0, 0.5 );
Point::Point( &knots[2], -1.0, 0.0, 0.0 );
//以vec_new初始化后7个元素
vec_new( &knots+3, sizeof( Point ), 7, &Point::Point, 0);

1. 记录在member initialization list中的data members初始化操作会被放进constructor的函数本身，并以members的声明顺序为顺序。
2. 如果有一个member并没有出现在member initialization之中，但它有一个default constructor，那么该default constructor必须被调用。
3. 在2之前，如果class object有virtual table pointer(s)，它（们）被设定初值，指向适当的virtual table(s)。
4. 在3之前，所有上一层的base class constructors必须被调用，以base class的声明顺序为顺序：
   • 如果base class被列于member initialization list中，那么任何明确指定的参数都应该传递过去。
   • 如果base class没有被列于member initialization list中，而它有default constructor，那么就调用之。
   • 如果base class是多重继承下的第二或后继的base class，那么this指针必须有所调整。
5. 在4之前，所有virtual base class constructors必须被调用，从左到右，从最深到最浅：
   • 如果class被列于member initialization list中，那么如果有任何明确指定的参数，都应该传递过去。若没有列于list之中，而class中一个default constructor，也应该调用之。
   • 此外，class中的每一个virtual base class subobject的偏移量(offset)必须在执行期可被存取。
   • 如果class object是最底层的(most-derived)的class，其constructors可能被调用；某些用以支持这个行为的机制必须被放进来。

对于虚拟继承，可以在derived class的constructor函数中加入条件式的测试参数，用来决定调用还是不调用相关的virtual base class constructors。

对象定义的析构函数的执行顺序和构造的顺序相反：

1. destructor的函数本身首先被执行。
2. 如果class拥有member class object，而后者拥有destructors，那么它们会以其声明顺序的相反顺序被调用。
3. 如果object内带一个vptr，则现在被重新设定，指向适当之base class的virtual table。
4. 如果有任何直接的（上一层）nonvirtual base classes拥有destructor，它们会以其声明顺序的相反顺序被调用。
5. 如果有任何virtual base class拥有destructor，而当前讨论的这个class是最尾端(most -derived)的class，那么它们会以原来的构造顺序的相反顺序被调用。

1.Nonstatic member functions

C++的设计准则之一就是：nonstatic member function 至少必须和一般的nonmember function有相同的效率。而实际上，编译器内部会将“member函数实体”转换为对等的“nonmember函数实体”。其转化步骤大致如下：

• 改写函数的signature（函数名称+参数数目+参数类型）以安插一个额外的参数到member function中，用以提供一个存取管道，使class object得以调用该函数。该额外参数被称为this指针。
• 将每一个“对nonstatic data member”的存取操作“改为经由this指针来存取”。
• 对member function重新写成一个外部函数。对函数名称进行“mangling”处理，使它在程序中成为独一无二的语汇（比如将参数 类型和返回值类型也编码进来）。

2.Virtual member functions

如果normalize()是一个virtual member function，那么以下调用：

ptr->normalize();

将会被内部转化为：

( * ptr->vptr[ 1 ])( ptr );

其中：

• vptr表示由编译器产生的指针，指向virtual table。它被安插在每一个“声明有（或继承自）一个或多个virtual functions”的class object中。事实上其名称也会被“mangled”，因为在一个复杂的class派生体系中，可能存在多个vptrs。
• 1是virtual table slot的索引值，关联到normalize()函数。
• 第二个ptr表示this指针。

“经由一个class object调用一个virtual function”，这种操作应该总是被编译器像对待一般的nonstatic member function一样加以决议。如果在normalize()函数中再调用一个ptr的virtual member function，则这个function是以“class object调用”的方式进行决议的，即压制了由于虚拟机制而产生的不必要的重复调用操作。

3.Static member functions

静态成员函数有几个明显的特性是：

• 没有this指针。
• 不能够直接存取其class中的nonstatic members。
• 不能够被声明为 const、volatile或virtual。
• 不需要经由 class object 才被调用 ——虽然大部分时候它是这样被调用的。

一个static member function，理所当然会被提出class声明之外，并给予一个经过“mangled”的适当名称。由于static member function没有this指针，所以其地址的类型并不是一个“指向class member function的指针”，而是一个“nonmember 函数指针”。也就是说：

对于

unsigned int Point3d::object_count()
{
//....
}
&Point3d::object_count();

会得到一个数值，类型是：

unsigned int (*) ();

而不是：

unsigned int ( Point3d::*) ();

由于static member function缺乏this指针，因此差不多等同于nonmember function。

二、关于Virtual member functions

为了支持virtual function机制，必须首先能够对于多态对象有某种形式的“执行期类型判断法”。也就是说，以下的调用操作将需要ptr在执行期的某些相关信息

ptr->z();

如此一来才能够找到并调用z()的适当实体。

在C++中， virtual functions（可经同其class object被调用）可以在编译时期获知，此外，这一组地址是固定不变的，执行期不可能新增或替换之。由于程序执行时，表格的大小和内容都不会改变，所以其建构和存取皆可以由编译器完全掌握，不需要执行期的任何介入。

一个class只会有一个virtual table。每一个table内含其对应的 class object中所有active virtual functions函数实体的地址。这些active virtual functions包括：

• 这个class所定义的函数实体，它会override一个可能存在的base class virtual function函数实体。
• 继承自base class的函数实体，这是在derived class不override base class virtual function时才会出现的情况。
• 一个pure_virtual_called()函数实体，它既可以扮演pure virtual function的空间保卫者角色，也可以当做执行期异常处理函数（有时候会用到）。

对于

ptr->z();

如何有足够的知道在编译时期设定virtual function的调用呢？

• 从指针是无法知道指针指向对象的类型的，但是可以通过ptr可以获取到对象的virtual table，从而可以通过virtual table的第一个slot（索引0）获得对象的类型信息。
• 即使不知道哪个z()函数实体会被调用，但是每一个z()函数地址都被放在slot4，这个是在编译时期就已经确定的了。

对于多重继承下的Virtual Functions，只需要注意其有n-1个vptr指针，n表示其上一层base classes的数目（因此，单一继承将不会有额外的virtual tables）。在基类和父类的函数调用上，有时候需要编译器介入进行必要的this指针调整，以指向到正确的base class的vptr上。

static data members，会被编译器提出于class之外，并被视为一个global变量（但只在class生命范围之内可见）。每一个member的存取许可（private, protected, public），以及与class的关联，并不会导致任何空间上或执行时间上的额外负担——不论是在个别的class objects或是在static data member本身。每一个static data member只有一个实体，存放在程序的data segment之中。

nonstatic data members直接存放在每一个class object之中。每一个nonstatic data member的偏移量（offset）在编译时期即可获知，甚至如果member属于一个base class subobject（派生自单一或多重继承串链）也是一样。因此，存取一个nonstatic data member，其效率和存取一个C struct member或一个nonderived class的member是一样的。

但是使用继承和指针还是会带一些差异的，如下代码：

// Point3d是一个derived class 其定义就忽略哈
Point3d origin, *pt = &origin;
origin.x = 0.0;
pt->x = 0.0

从上面代码中，“从origin存取”和“从pt存取”有什么重大的差异？答案是“当Point3d是一个derived class，而在其继承结构中有一个virtual base class，并且被存取的member（如上例中的x）是一个从该virtual base class继承而来的member时，就会有重大的差异“。这时候不能够说pt必然指向哪一种class type（因此也就不知道编译时期这个member真正的offset位置），所以这个存取操作必然延迟至执行期，经由一个额外的间接导引，才能够解决。但如果使用origin，就不会有这个问题，其类型无疑是Point3d Class，而即使它继承自virtual base class，members的offset位置也在编译时期就固定了。

二、”继承“与Data Member

在继承体系中，关于derived class members和base class(es) members的内存布局中的排列次序并未在C++ Standard中强制指定；理论上编译器可以自由安排之。在大部分编译器上头，base class members总是先出现，但属于virtual base class除外（一般而言，任何一条规则一旦遇上virtual base class基本就难成立的了）。

下面将分别讨论“单一继承且不含virtual function”、“单一继承并含virtual functions”、“多重继承”、“虚拟继承”等四种情况的继承模型。

1.单一继承且不含多态

单一继承而且没有多态时的数据布局

这里有一个易犯了的错误，把一个class分解为两层或更多层，有可能会为了“表现class体系之抽象化”而膨胀所需的空间。例子如下：

class Concrete {
public:
    //...
private:
    int val;
    char c1;
    char c2;
    char c3;
};

在一部32位机器中，每一个Concrete class object的大小都是8 bytes，细分为(1)val占用4 bytes；(2)c1,c2,c3各占用1 bytes；(3)alignment需要1 byte。如下图所示：

假如将上述的Concrete分裂为三层的继承结构表示的话：

class Concrete1 {
public:
    //...
private:
    int val;
    char c1;
};

class Concrete2 : public Concrete1 {
public:
    //...
private:
    char c2;
};

class Concrete3 : public Concrete2 {
public:
    //...
private:
    char c3;
};

经过这样分裂的设计后，Concrete3 object的大小不再是8 bytes了，而是16 bytes了。其继承结构的内存布局如下：

之所以出现这种情况是因为C++语言保证”出现在derived class中的base class subobject有其完整性原样性”,正是如此,继承后的Concrete3 object会因为继承串链中的父类alignment的空间而导致本身的空间膨胀.

2.加上多态

加上多态后，不可避免地在数据结构中多了一个vptr，C++ Standard没有规定vptr放在对象结构的位置。把vptr放在class object的尾端，可以保留base class C struct的对象布局，因而允许在C程序代码中也能使用。把vptr放在前端，对于“在多重继承之下，通过指向class members的指针调用virtual function”，会带来一些帮助，而代价就是丧失了C语言兼容性。

3.多重继承

相对于加入多态的单一继承，多重继承在把一个derived object转换为其base类型时，需要由编译器的介入，用以调整地址。具体来说，对于一个多重继承对象，将其地址指定给“最左端（也就是第一个）base class的指针”，情况将和单一继承时相同，因为二者都指向相同的起始地址。需付出的成本只有地址的指定操作而已。至于指定给第二个或后继的base class的地址指定操作，则需要将地址修改过：加上（或减去，如果downcast的话）介于中间的base class subobject(s)大小。

4.虚拟继承

多重继承的一个语意上的副作用就是，它必须支持某种形式的”shared subobject”继承。一个典型的例子是最早的iostream library:

class ios { ... };
class istream : public ios { ... };
class ostream : public ios { ... };
class iostream : public istream, public ostream { ... };

这样在iostream中得维护两份ios的subobject，而解决这个问题是使用虚拟继承：

class ios { ... };
class istream : public virtual ios { ... };
class ostream : public virtual ios { ... };
class iostream : public istream, public ostream { ... };

至于虚拟继承的一般实现方法如下所述。Class如果内含一个或多个virtual base class subobjects，像istream那样，将被分割成两部分：一个不变局部和一个共享局部。不变局部中的数据（实际上是在本类而非在base class中定义的data members），不管后继如何衍化，总是拥有固定的offset（从object的开头算起），所以这一部分数据可以被直接存取。至于共享局部，所表现的就是virtual base class subobject。这一部分的数据，其位置会因为每次的派生操作而会有所变化，所以它们只可以被间接存储（如在istream中的ios）。一般的布局策略是先安排好derived class的不变部分，然后再建立其共享部分。
有两个实现模型，第一个是在每个类中添加一个指针，用于指向共享局部的地址，即使共享局部在后继的继承中出现布局变化，但指针仍然会在编译阶段设定为正确的地址。另一个模型则是通过在virtual table上放置offset（相对于对象开头)来获取共享局部的地址。

C++新手一般有两个误解：

1. 任何class如果没有定义default constructor，就会被合成出一个来。
2. 编译器合成出来的default constructor会明确设定”class内每一个data member的默认值”。

有四种情况，会导致“编译器必须为未声明constructor之classes合成一个default constructor“。C++ Standard把那些合成物称为implicit nontrivial default constructors（隐式并有价值的默认构造函数）。至于没有存在那四种情况而又没有声明任何constructor的classess，则说它们拥有的是implicit trivial default constructors，它们实际上并不会被合成出来。那么这四种有价值的默认构造函数分别是：

• 带有Default Constructor的Member Class Object。
• 带有Default Constructor的Base Class。
• 带有一个Virtual Function的Class。
• 带有一个Virtual Base Class的Class（Virtual Base Class是用来被虚拟继承的基类，防止在一个对象中重复出现几个基类）。

对于”带有Default Constructor的Member Class Object”，编译器会扩张已存在的construtors，没有则会合成只满足编译器需要的default constructor。然后在constructors中安插一些代码，使得user code在被执行之前，先调用必要的member class objects’ construtors，有多个member class objects则按照在class中声明的次序进行初始化。

对于”带有Default Constructor的Base Class”，含有多个时仍会按照声明的次序进行base class的初始化，如果同时存在着”带有Default Constructor的Member Class Object”，则member class objects的default constructor也会在base class constructor都被调用之后再调用。

对于”带有一个Virtual Function或Virtual Base Class的Class如何初始化vptr”以后再补充

在合成的default constructor中，只有base class subojects和member class objects会被初始化。所有其它的nonstatic data member，如整数、整数指针、整数数组等等都不会被初始化。

二、Copy Constructor

有三种情况，会以一个object的内容作为另一个class object的初值。

• 赋值的方式创建对象。如 X x; X xx = x;
• 值参数传递。如 X xx; foo( xx );
• 函数返回值。如 X foo() { X xx; …; return xx; }

如果class没有提供一个explicit copy constructor又当如何？当class object以“相同class的另一个object“作为初值时，其内部是以所谓的default memberwise initialization手法完成的，也就是把每一个内建或派生的data member的值，从某个object拷贝一份到另一个object身上。不过它并不会拷贝其中的member class object，而是以递归的方式施行memberwise initialization。

和以前一样，C++ Standard把copy constructor区分为trivial和nontrivial两种。只有nontrivial的实体才会被合成于程序之中，并执行default memeberwise initialization。决定一个copy constructor是否为trivial的标准在于class是否展现出所谓的”bitwise copy semantics”，顾名思义，若展现出bitwise copy semantics则不合成default copy constructor，不执行default memberwise initialization，而执行以bit的方式拷贝对象成员数据。

什么时候一个class不展现出”bitwise copy semantics”呢？其实这个与default constructor的4种情况基本是一样的：

• 当class内含一个member object而后者的class声明有一个copy constructor时（不论是被class设计者明确地声明的，或是被编译器合成的）。
• 当class继承自一个base class而后者存在有一个copy constructor时（再次强调，不论是被明确声明还是被合成而得的）。
• 当class声明了一个或多个virtual functions时。
• 当class派生自一个继承串链，其中有一个或多个virtual base classes时。

关于其中的Virtual Table指针的设定，在编译期间有两个程序扩张操作（只要有一个class声明了一个或多个virtual functions就会如此）：

• 增加一个virtual function table(vtbl)，内含每一个有作用的virtual function的地址。
• 将一个指向virtual function table的指针(vptr)，安插在每一个class object内。

当编译器导入一个vptr到class之中时，该class就不再展现bitwise semantics了。现在，编译器需要合成出一个copy constructor，以求将vptr适当地初始化，例子如下 ：

class ZooAnimal {
public:
    ZooAnimal();
    virtual ~ZooAnimal();

    virtual void animate();
    virtual void draw();
    //...
private:
    // ZooAnimal的animate()和draw()
    // 所需要的数据
};

class Bear : public ZooAnimal {
public:
    Bear();
    void animate();
    void draw();
    virtual void dance();
    //...
private:
    // Bear的animate()和draw()和dance()
    // 所需要的数据
};

上面的代码中Bear派生于ZooAnimal，并且带有virtual functions，也就不再展现bitwise semantics了。下面的初始化与其对应的类结构：

Bear yogi;
Bear winnie = yogi;

yogi和winnie的关系

当一个base class object以其derived class的object内容做初始化操作时，其vptr复制操作也必须保证安全：

Bear yogi;
ZooAnimal franny = yogi;     //注意，这里会发生切割行为
franny.draw();  //这里调用的是ZooAnimal的draw成员函数，如果是ZooAnimal &franny = yogi，则调用Bear::draw();

franny和yogi的关系

合成出来的ZooAnimal copy constructor会明确设定object的vptr指向ZooAnimal class的virtual table，而不是直接从右手边的class object中将其现值拷贝过来。
copy constructor的应用，迫使编译器多多少少对你的程序代码做部分转化。尤其是当一个函数以传值（by value）的方式传回一个class object，而该class object有一个copy constructor（不论是明确定义出来的，或是合成的）时。这将导致深奥的程序转化——不论在函数的定义或应用上。举个例子：

X bar()
{
    X xx;
    // ...处理 xx
    return xx;
}

编译器会把其中的xx以__result取代：

void bar( X &__result )
{
    // default constructor被调用
    // C++伪码
    __result.X::X();
    // ...处理xx
    return; //注意是直接return
}

这样的编译器优化操作，有时候被称为Named Return Value(NRV)优化，NRV优化如何被视为是标准C++编译器的一个义不容辞的优化操作。对于这样的NRV优化操作，需要一个explicit copy constructor定义来激活。但是并不是所有的代码都可以进行这样的优化，复杂的函数会使NRV优化难以实施。

三、Member Initialization List

对于没有使用initialization list的情况：

class Word {
    String _name;
    int _cnt;
public:
    Word() {
        _name = 0;
        _cnt = 0;
    }
};

上面的代码是没有错误的，但是实际上，Word Constructor会先产生一个暂时性的String object，然后将它初始化，再以一个assignment运算符将暂时性object指定给_name，然后再摧毁那个暂时性object，下面是编译器可能的内部扩张结果：

// C++伪码
Word::Word( /* this pointer goes here */ )
{
    // 调用String的default constructor
    _name.String::String()

    // 产生暂时性对象
    String temp = String(0);

    // "memberwise"地拷贝 _name
    _name.String::operator=( temp );

    // 摧毁暂时性对象
    temp.String::~String();

    _cnt = 0;
}

当然，更有效率的初始化方法是这样的：

Word::Word : _name(0)
{
    _cnt = 0;
}

这样使用initialization list初始化大致会被扩展成下面这样：

// C++伪码
Word::Word( /* this pionter goes here */ )
{
    // 调用String( int ) constructor
    _name.String::String( 0 );
    _cnt = 0;
}

对于initialization list的语法，其实际上并不是一组函数调用，而是对list对象的copy constructor的调用或者是直接赋值(如int)。编译器会一一操作initialization list，以适当次序在constructor之内安插初始化操作，并且在任何explicit user code之前，而list中的项目次序是由class中members声明次序所决定的，不是由initialization list中排列次序决定的。

1. 每一个class产生出一堆指向virtual functions的指针，放在表格之中。这个表格称为virtual table(vtbl)。
2. 每一个class object被添加了一个指针，指向相关的virtual table。通常这个指针被称为vptr。vptr的设定和重置都由每一个class的constructor、destructor和copy assignment运算符自动完成。每一个class所关联的type_info object（用以支持runtime type identification, RTTI）也经由virtual table被指出来，通常是被在这个表格的第一个slot处。

对于下面的代码：

    class Point
    {
    public:
     Point(float xval);
     virtual ~Point();

     float x() const;
     static int PointCount();

    protected:
     virtual ostream& print(ostream &os) const;

     float _x;
     static int _point_count;
    };

其C++的模型大概如下：

由上图可以看出，一个class object的需要内存要有：

1. 其nonstatic data members的总和大小。
2. 加上任何由于alignment的需求而填补上去的空间（可能存在于members之间，也可能存在于集合体边界）。
3. 加上为了支持virtual而由内部产生的任何额外负担。