C++编译器默认构造函数合成机制分析

我们通常会说当生命一个 class 时，如果我们不为该 class 指定一个 constructor，那么编译器会替我们实现一个 connstructor，那么这种说法一定对吗？

事实上，这是不对的。这个不是我说的，是深入理解C++对象模型说的，原话是：

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

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

首先解释第一点，只有四种情况才会导致 ”编译器必须为未声明 constructor 之 classes 合成一个 default constructor“。被合成出来的 constructor 只能满足编译器（而非程序）的需要。它们之所以能够完成任务，是借着 “调用 member object 或base class 的 default constructor” 或是 “为每一个 object 初始化其virtual function 机制或 virtual base class 机制”而完成。至于没有存在那四种情况，而又没有声明任何 constructor 的 classes，我们说它拥有的是 implicit trivial(浅薄而无能，没啥用的），它们实际上并不会被合成出来。

下面分别讨论上述四种合成 constructor 的情况：

情况一：一个 class 内含一个 member object，且其 member object 拥有 default constructor

class Foo { public: Foo(), Foo( int ) ... };
class Bar { public: Foo foo; char* str; };  //不是继承，是包含

void foo_bar(){
    Bar bar;   //Bar::foo 必须在此处初始化
               //译注：Bar::foo是一个member object，而其 class Foo 拥有default constructor，符合本小节主题
    if( str ) {  }  ...
}

此时 class Bar 内含一个 member object Foo，并且 Foo 有 default constructor Foo()，那么编译器就会为 Bar 合成一个 default constructor，看起来像这样：

//Bar 的 default constructor 可能会这样合成
//被 member foo 调用 class Foo 的 default constructor
inline
Bar::Bar(){
    //C++伪码
    foo.Foo::Foo();
}

再一次请你注意，被合成的 default constructor 只满足编译器的需要，而不是程序的需要，为了让这个程序片段能够正确执行，字符指针 str 也需要初始化，那么程序员可能会这么做：

Bar::Bar() { str = 0; }  //程序员定义的 default constructor

此时编译器还需要初始化 member object foo，但是由于 default constructor 已经被程序员明确定义出来了，编译器没办法合成第二个。编译器采取的行动是：“如果 class A 内含一个或一个以上的 member class object，那么 class A 的每一个 constructor 必须调用每一个 member classes 的 default constructor”，编译器会向用户程序员的 constructors 前面插入必要的 default constructor。插入后可能像这样：

//插入后的 default constructor 
//C++伪码
Bar::Bar(){
    foo.Foo::Foo();   //插入的 compiler code
    str = 0；            //explicit user code
}

如果有多个 class member objects 都要求初始化操作，将如何做呢？C++会按照 “member objects 在 class 中的声明次序“ 来调用各个 consructors。这一点由编译器完成。并且如果某个 member object 的 default constructor 被程序员定义过了，它照样会被按顺序调用。如：

//程序员对 Snow_White 类所写的 default constructor，显示初始化一个 member object
Snow_White::Snow_White() : sneezy( 1024){
    mumble = 2048
}

它会被扩张为：

Snow_White::Snow_White() : sneezy( 1024) {
    //插入 member class onject
    //调用其 constructor
    dopey.Dopey::Dopey();
    sneezy.Sneezy::Sneezy(1024);
    bashfun.Bashfun::Bashful();

    //explicit user code
    mumble = 2048;
}

情况二：带有 “default constructor” 的 base class 

类似的道理，如果一个没有任何 constructors 的 class 派生自一个 ”带有 default constructor“ 的 base class，那么这个 derived class 的 default constructor 会被是为 nontrivial，并且因此需要被合成出来，它将调用上一层 base classes 的 default constructor（根据它们的声明次序）。对一个后继派生的 class 而言，这个合成的 constructor 和一个 ”被明确提供的 default constructor” 其实没什么区别。

如果设计者提供多个 constructors（比如带 int 参数的 constructor），但其中都没有 default constructor 呢? 编译器会扩张现有的每一个 constructors，在前面插入 base class 的 default constructor。如果有成员 member object，同样按顺序调用。

情况三：带有一个 “virtual Function” 的 class

如果一个 class 声明或继承一个 virtual function，并且缺乏由用户声明的 constructors，编译器会详细记录合成一个 default constructor 的必要信息。如：

class Widget{
    public:
        virtual void filp() = 0;
        ...
}

void filp( const Widget& widget ) { widget.filp(); }

//假设 Bell 和 Whistle 都派生自 Widget
void foo(){
    Bell b;
    Whistle w;

    filp( b );
    filp( w );
}

下面两个扩张步骤在编译期间发生：

1. 一个 virtual function table （在 cfront 中被称为 vtbl）会被编译器产生出来，内放 class 的 virtual functions 地址。
2. 在每一个 class onject 中，一个额外的 pointer member（也就是 vptr）会被编译器合成出来，内含相关的 class vtbl 的地址。

此外，widget.filp() 的虚拟引发操作（virtual invocation）会被重新改写（实际上就是虚函数调用传入的 this 会变化），以使用 widget 的 vptr 和 vtbl 中的 filp() 条目：

//widget.filp() 的虚拟引发操作（virtual invocation）的转变
// (* widget.vptr[ 1 ] )( &widget )

其中：

• 1 表示 filp() 在 virtual table 中的固定索引
• &widget 代表要交给 “被调用的某个 filp() 函数实体” 的 this 指针

为了让这个机制发挥功效，编译器必须为每一个 Widget（或其派生类之）object 的 vptr 设定初始值，放置适当的 virtual table 地址，对于 class 所定义的每一个 constructor，编译器会插入类似前文所说的伪码来做这样的事情。对于那些什么都没有声明的 classes，编译器则就像本文主题，为它们合成一个 default constructor，以便正确的初始化每一个 class object 的 vptr。（你可以理解，vptr 必须赋初值，就像我们平时用的指针，不用是赋NULL一样）。

情况四：带有一个 ”virtual base class“ 的 class

virtual base class 的实现法在不同的编译器之间有极大差异。然后每一种实现法的共通点在于必须是 virtual base class 在其每一个 derived class object 中的位置，能够与执行期准备妥当。例如下面的代码中：

class X { public: int i; };
class A : public virtual X { public: int j; };
class B : public virtual X { public: double d; };
class C : public A, pulic B { public: int k; };

//无法在编译使其决定（resolve）出pa->X::i 的位置
void foo( const A* pa) { pa->i = 1024; }

main()
{
    foo( new A );
    foo( new C );
    // ... 
}

编译器无法固定住 foo() 函数之中"经由 pa 而存取的 X::i“ 的实际偏移位置，因为 pa 的真正类型可以改边，编译器必须改变 ”执行存取操作“ 的那些码，使 X::i 可以延迟至执行期才决定下来。

做法通常是在 “derived class object 的每一个 virtual base classes 中安插一个指针”（相当于一个中间件）。所有“经由 reference 或 pointer 来存取一个 virtual base class” 的操作可以通过相关指针完成。在我的例子中，foo() 可以被改写如下，以符合这样的实现策略：

//可能的编译器转变操做，中间加了一层
void foo( const A* pa ) { pa->__vbcX->i = 1024; }   

其中，__vbcX表示编译器产生的指针，指向 virtual base class X。__vbcX是在 class 构造期间完成的。对于 class 所定义的每一个 constructor，编译器会安插哪些 ”允许每一个 virtual base class 的执行期存取操作“ 的码。如果 class 没有声明任何 constructors，编译器必须为它合成一个 default constructor。（最后这点我的理解是，像这种多态指针不能固定下来，我们需要给它指一个方向，不能让它乱指，所以编译器会合成default constructor）。

好了，前面解释了唯有的四种编译器会为未声明 constructor 的 classes 合成一个 default constructor 的情况。现在解释一下这句：

• 编译器合成出来的 default constructor 会明确设定 "class 内每一个 data member 的默认值                  

在合成的 default constructor 中，只有 base class subobject 和 member objects 会被初始化。所有其他的 nonstatic data member，如整数、整数指针、整数数组等等都不会被初始化，这些初始化操作对程序而言或许又需要，但对编译器则并非必要。如果一个程序需要 "把某指针设为 0” 的 default constructor，那么提供它的人应该是程序员。