C++ 对象模型 默认构造函数

“default constructor ... 在需要的时候被编译器产生出来。“  ------ 《深度探索C++对象模型》，P39（华中科技大学出版）

-------------------------------------------------------------------------------------------------------------------------------------------------------

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

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

如你所见，没有一个是真的.

--------------------------------------------------------------------------------------------------------------------------------------------------------

在 以下 4 种情况下，编译器会 合成 构造函数

• case 1 当一个class 中 “带有 default constructor”的 member class object;
• case 2 当一个class 派生自 ”带有 default constructor“的 base class;
• case 3 当一个class 声明（或 继承）一个 virtual function;
• case 4 当一个class 派生自一个 继承串链，其中有一个 或 多个 virtual base class.

        以上 4 种情况，会导致 “编译器 必须 为 未声明 constructor 的 classes 合成 一个 default constructor”.  C++ Standard [ISO-C++95](不知现在 C++ standard 对此处的 描述 是否 有所变化) 把 那些合成物 称为 implicit nontrivial default constructor. 被合成出来的 constructor 只能满足编译器（而非程序）的需求. 它之所以能完成任务，是借着“调用 member object 或 base class 的 default constructor” 或是 “为每一个object 初始化 其 virtual function 机制 或 virtual base class 机制” 而完成的. 对于不存在 这 4 种情况 而又没有声明 任何 constructor 的 classes，我们说 它们拥有的是 implicit trivial default constructor，它们实际上并不会被合成出来.

        在合成的 default constructor 中，只有 base class subobjects 和 member class objects 会被初始化，所有其他的 nonstatic data member，如整数，指针，整型数组等等都不会被初始化. 如果程序需要一个“把某指针设为 0 ”的 default constructor，那么提供它的应该是程序员.

测试环境： CentOS 6.5， g++ 4.4.7

下面通过 查看 反汇编代码（使用 objdump -d xxx.o 查看） 来确定 是否 有 default constructor 被合成

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

1.  不是 上述 四种情况，也无用户定义的 constructor

#include <iostream>

class TEST_A                 // 不是 上述 四种情况，也无用户定义的 constructor
{
    public:
        int a;
};

int main()
{
    TEST_A test_a;
    return 0;
}

反汇编： 可以看到 下面 汇编代码 中 并没有 call，即没有 函数调用，也就表明 在 定义 一个 TEST_A 对象时，没有 调用 constructor，说明 编译器 并没有为它合成 default constructor.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 ec 10                 sub    $0x10,%esp
   6:    b8 00 00 00 00           mov    $0x0,%eax
   b:    c9                       leave  
   c:    c3                       ret 

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include <iostream>

class TEST_A                 // 不是 上述 四种情况，也无用户定义的 constructor
{
    public:
        int a;
};
class TEST_B:public TEST_A   // 不是 上述 四种情况，也无用户定义的 constructor，TEST_B 继承自 TEST_A
{
    public:
        int a;
};

int main()
{
    TEST_B test_b;
    return 0;
}

反汇编：TEST_B  虽然继承于 TEST_A（不是 虚拟继承），但是 TEST_A 并没有 default constructor，也不符合 上述 4 种情况，TEST_B 自身又无 member

object，也没有 virtual function，故 编译器 不会为它 合成 default constructor. 下面的 汇编代码中没有 函数调用，也证明了这点.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 ec 10                 sub    $0x10,%esp
   6:    b8 00 00 00 00           mov    $0x0,%eax
   b:    c9                       leave  
   c:    c3                       ret

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

2. 不是上述 4种情况，有用户自定义 default constructor，或许 还有 自定义 destructor

#include <iostream>

class TEST_A                 // 不是 上述 四种情况，有用户定义的 default constructor
{
    public:
        TEST_A(){}
        int a;
};

int main()
{
    TEST_A test_a;
    return 0;
}

反汇编：有用户自定义的 default constructor，定义一个类对象时，自然 会 调用 default constructor.  没有调用 destructor：用户未定义，也不符合 编译器 合成

destructor 的 条件，故 没有 destructor 供其调用（也没有必要）

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    83 ec 20                 sub    $0x20,%esp
   9:    8d 44 24 1c              lea    0x1c(%esp),%eax
   d:    89 04 24                 mov    %eax,(%esp)
  10:    e8 fc ff ff ff           call   11 <main+0x11>   //调用 用户自定义 default constructor
  15:    b8 00 00 00 00           mov    $0x0,%eax
  1a:    c9                       leave  
  1b:    c3                       ret

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include <iostream>

class TEST_A                 // 不是 上述 四种情况，有用户定义的 constructor，destructor
{
    public:
        TEST_A(){}
        ~TEST_A(){}
        int a;
};

int main()
{
    TEST_A test_a;
    return 0;
}

反汇编：由于 TEST_A 还定义了 destructor， 故 main 函数 结束时，还 对 TEST_A 的对象 进行了 析构

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    53                       push   %ebx
   7:    83 ec 2c                 sub    $0x2c,%esp
   a:    8d 44 24 1c              lea    0x1c(%esp),%eax
   e:    89 04 24                 mov    %eax,(%esp)
  11:    e8 fc ff ff ff           call   12 <main+0x12>  // 调用 用户自定义 default constructor
  16:    bb 00 00 00 00           mov    $0x0,%ebx
  1b:    8d 44 24 1c              lea    0x1c(%esp),%eax
  1f:    89 04 24                 mov    %eax,(%esp)
  22:    e8 fc ff ff ff           call   23 <main+0x23>  // 调用 用户自定义 destructor
  27:    89 d8                    mov    %ebx,%eax
  29:    83 c4 2c                 add    $0x2c,%esp
  2c:    5b                       pop    %ebx
  2d:    89 ec                    mov    %ebp,%esp
  2f:    5d                       pop    %ebp
  30:    c3                       ret

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include <iostream>

class TEST_A                // 用户 自定义 default constructor， 未 定义 destructor            
{
    public:
        TEST_A(){}
        //~TEST_A(){}
        int a;
};
class TEST_B:public TEST_A  // 普通 继承               
{
    public:
        int a;
};

int main()
{
    TEST_B test_b;
    return 0;
}

反汇编：属于 case 2，TEST_B 继承自带有 default constructor 的 base class：TEST_A. 故 编译器 会 为其 合成 一个 default constructor，以保证 可以调用 

TEST_A 的 default constructor 生成 derived class：TEST_B 中的 TEST_A subobject. 此例 同样 没有 destructor 被 合成.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    83 ec 20                 sub    $0x20,%esp
   9:    8d 44 24 18              lea    0x18(%esp),%eax
   d:    89 04 24                 mov    %eax,(%esp)
  10:    e8 fc ff ff ff           call   11 <main+0x11>   // 调用 合成 的 default constructor
  15:    b8 00 00 00 00           mov    $0x0,%eax
  1a:    c9                       leave  
  1b:    c3                       ret

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

#include <iostream>

class TEST_A                
    public:
        TEST_A(){}
        ~TEST_A(){}
        int a;
};
class TEST_B:public TEST_A               
{
    public:
        int a;
};

int main()
{
    TEST_B test_b;
    return 0;
}

反汇编：由于 base class 中 定义了 destructor，故 要 析构 derived class 中的 base class subobject，就需要调用base class 的 destructor，编译器通过 为 derived class 合成 一个 destructor，并在该 合成的 destructor 中 调用 base class 的 destructor 来达到目的.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    53                       push   %ebx
   7:    83 ec 2c                 sub    $0x2c,%esp
   a:    8d 44 24 18              lea    0x18(%esp),%eax
   e:    89 04 24                 mov    %eax,(%esp)
  11:    e8 fc ff ff ff           call   12 <main+0x12>    // 调用 合成 的 default constructor
  16:    bb 00 00 00 00           mov    $0x0,%ebx
  1b:    8d 44 24 18              lea    0x18(%esp),%eax
  1f:    89 04 24                 mov    %eax,(%esp)
  22:    e8 fc ff ff ff           call   23 <main+0x23>    // 调用 合成 的 destructor
  27:    89 d8                    mov    %ebx,%eax
  29:    83 c4 2c                 add    $0x2c,%esp
  2c:    5b                       pop    %ebx
  2d:    89 ec                    mov    %ebp,%esp
  2f:    5d                       pop    %ebp
  30:    c3                       ret 

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

3. case 1, 含有 “带有 default constructor 的 member class object”

#include <iostream>
#include <string>

class TEST_A               
{
    public:
        std::string s;  // s 是带有 default constructor 的 member class object（string 类 具有 default constructor）
        int a;
};

int main()
{
    TEST_A test_a;
    return 0;
}

反汇编：由于 string 类 不仅 有 default constructor ， 还有 destructor，s 作为 string 类 的对象，又是TEST_A 的成员，故 编译器 为 TEST_A 合成 了 default

constructor，也 合成了 destructor.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    53                       push   %ebx
   7:    83 ec 2c                 sub    $0x2c,%esp
   a:    8d 44 24 18              lea    0x18(%esp),%eax
   e:    89 04 24                 mov    %eax,(%esp)
  11:    e8 fc ff ff ff           call   12 <main+0x12>   // 调用 编译器 合成的 default constructor
  16:    bb 00 00 00 00           mov    $0x0,%ebx
  1b:    8d 44 24 18              lea    0x18(%esp),%eax
  1f:    89 04 24                 mov    %eax,(%esp)
  22:    e8 fc ff ff ff           call   23 <main+0x23>   // 调用 编译器 合成的 destructor
  27:    89 d8                    mov    %ebx,%eax
  29:    83 c4 2c                 add    $0x2c,%esp
  2c:    5b                       pop    %ebx
  2d:    89 ec                    mov    %ebp,%esp
  2f:    5d                       pop    %ebp
  30:    c3                       ret

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

4. case 2，当一个class 派生自 ”带有 default constructor“的 base class

#include <iostream>
#include <string>

class TEST_A           
{
    public:
        std::string s;
        int a;
};
class TEST_B:public TEST_A
{
    public:
        int a;
};

int main()
{
    TEST_B test_b;
    return 0;
}

反汇编：因为 TEST_A 内含 member class object（此处为 string s），故 编译器 会为它 合成 default constructor 和 destructor；而 TEST_B 又 普通 继承 于

TEST_A , 故编译器 也会为 TEST_B 合成 default constructor 和 destructor

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    53                       push   %ebx
   7:    83 ec 2c                 sub    $0x2c,%esp
   a:    8d 44 24 14              lea    0x14(%esp),%eax
   e:    89 04 24                 mov    %eax,(%esp)
  11:    e8 fc ff ff ff           call   12 <main+0x12>   // 调用 编译器 合成的 default constructor
  16:    bb 00 00 00 00           mov    $0x0,%ebx
  1b:    8d 44 24 14              lea    0x14(%esp),%eax
  1f:    89 04 24                 mov    %eax,(%esp)
  22:    e8 fc ff ff ff           call   23 <main+0x23>   // 调用 编译器 合成的 destructor
  27:    89 d8                    mov    %ebx,%eax
  29:    83 c4 2c                 add    $0x2c,%esp
  2c:    5b                       pop    %ebx
  2d:    89 ec                    mov    %ebp,%esp
  2f:    5d                       pop    %ebp
  30:    c3                       ret

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

5. case 3 当一个class 声明（或 继承）一个 virtual function

#include <iostream>

class TEST_A           
{
    public:
        virtual void func(){}    
        int a;
};

int main()
{
    TEST_A test_a;
    return 0;
}

当一个 class 中声明了 virtual function 时

1. 编译器会产生 一个 virtual function table，内放 class 的 virtual functions 地址;
2. 在每一个 class object 中，编译器 会 合成 一个 pointer member（即 vptr），用来指向 class 的 vtbl （virtual function table）.

        对于那些未声明任何 constructor 的 class， 编译器 会为 它们 合成 一个 default constructor， 以便正确的初始化 每一个 class object 的 vptr.

反汇编：TEST_A 未定义任何的 constructor，但又 含有 virtual function，为了使其 对象 能够 找到 类 的virtual functions 的地址，编译器会修改 类的定义，添加

一个 指针成员 （vptr），此时 编译器 还会 合成一个default constructor，用来 初始化 这个 vptr，使其指向 virtual function table.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    83 ec 20                 sub    $0x20,%esp
   9:    8d 44 24 18              lea    0x18(%esp),%eax
   d:    89 04 24                 mov    %eax,(%esp)
  10:    e8 fc ff ff ff           call   11 <main+0x11>    // 调用 编译器 合成 的 default constructor
  15:    b8 00 00 00 00           mov    $0x0,%eax
  1a:    c9                       leave  
  1b:    c3                       ret

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

6. case 4 当一个class 派生自一个 继承串链，其中有一个 或 多个 virtual base class

#include <iostream>

class TEST_A           
{
    public:
        int a;
};
class TEST_B:public virtual TEST_A
{
    public:
        int a;
};

int main()
{
    TEST_B test_b;
    return 0;
}

反汇编： 这个例子中 TEST_A, TEST_B，都没有 定义 default constructor，而且 TEST_A 也不会 被 编译器 合成 default construtor，但是 TEST_B 虚拟继承于TEST_A，从 汇编代码中 看到 在定义一个 TEST_B 对象时，调用了 构造函数，这个 构造函数 就是 编译器 为它 合成的 default constructor.

00000000 <main>:
   0:    55                       push   %ebp
   1:    89 e5                    mov    %esp,%ebp
   3:    83 e4 f0                 and    $0xfffffff0,%esp
   6:    83 ec 20                 sub    $0x20,%esp
   9:    8d 44 24 14              lea    0x14(%esp),%eax
   d:    89 04 24                 mov    %eax,(%esp)
  10:    e8 fc ff ff ff           call   11 <main+0x11>    // 调用 编译器 合成的 default constructor
  15:    b8 00 00 00 00           mov    $0x0,%eax
  1a:    c9                       leave  
  1b:    c3                       ret

再 看例子 来说明 虚拟继承 时 为什么 要 合成 构造函数： （引用自 《深度探索C++对象模型》 P46）

　　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, public B  { public: int k; };

　　// 无法 在 编译期间 解析出 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 可以延迟

到执行期 才决定下来. 所有 ”经由 reference 或 pointer 存取一个 virtual base classes “ 的操作都可以通过 相关指针 完成. 改写 foo()

　　// 可能的 编译器 转变 操作

　　void foo( const A * pa ) { pa -> __vbcX -> i = 1024; }

　　其中 __vbcX 表示 编译器所产生的指针，指向 virtual base class X.

　　__vbcX 是在 class object 构建 期间被完成的.  对于class 所定义的 每一个 constructor，编译器会 安插 那些 “允许 每一个 virtual base class 到 执行期存取操作”

的代码，如果 class 没有 声明 任何 constructors，编译器 必须 为它合成 一个 default constructor.

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