深度搜索C++对象模型 - 构造函数



深度搜索C++对象模型: 构造函数

Default Constructor 构造函数:
C++ARM告诉我们: Default Constructor在需要的时候被编译器产生出来.
关键字: 在需要的时候 --> 被谁需要 需要来干什么?
例子:
class Foo
{
 public:
  int m_val;
  Foo *next;
};

void FooBar()
{
 Foo bar;
 if( bar.m_val || bar.next )
 {
  //do something
 }
}

这个程序本身的语义是:要求Foo有一个默认的构造函数, 可以将内部的两个data member初始化为0;
但是实际上结果是不符合语义的; 他可曾符合ARM所说? 答案是no;
其间最重要的一点是:  被程序需要 ?  被编译器需要 ?
很自然 把两个data member初始化为0, 这是程序的需要, 这是需要程序员保证的;
而对于编译器来说 他根本就没有被需要; ( 所以根本不会有默认构造函数, 后面会讲 )

//*********************************************************************************************//

对于编译器来说 "被编译器需要的 有用的默认构造函数" 有4种 分别介绍:

//-----------------------------------------------------------------------------------------------------------------------//

---> "含有 带有Default Constructor 的 Member Class Object 的 class":
如果一个Class内没有任何Constructor, 但是他内含一个Member Class Object, 而且这个Mmeber Class Object有Default Constructor,
那么这个Class的隐式默认构造函数就是有用的;
例子:
class Foo
{
 public:
  Foo();
};

class Bar
{
 public:
  Foo foo;
  char *str;
};

这种情况下, Bar里内含了一个成员类对象, 而且这个成员类对象含有默认构造函数, 那么编译器就会为class Bar合成一个默认构造函数;
当我们 Bar bar;的时候 Bar::foo 必须在此处被初始化, 被合成的Bar的默认构造函数内含必要的代码,能够调用class Foo的默认构造函数来初始化foo;
但是他并不产生任何代码来初始化str;  所以"将Bar::foo初始化是编译器的责任, 但是将Bar::str初始化是程序员的责任";
被合成的Bar的默认构造函数也许像这样:
inline
Bar::Bar()
{
 foo.Foo::Foo();
}

重申: "被合成的默认构造函数是编译器的需要 不是程序的需要";
至此 编译器的需要已经满足了, 所以我们要来满足程序的需要, 所以我们需要一个"显式默认构造函数"
Bar::Bar()
{
 str = nullptr;
}

此时, 程序的需要满足了 但是编译器还需要初始化member object foo ;
但是程序无法再次定义一个默认构造函数 因为我们已经显式的定义了一个,
此时 编译器行动如下: 如果class A内含一个或一个以上的member class object,
那么class A的"每一个构造函数"都会调用"每一个member calss object的默认构造函数";
编译器会扩张已存在的构造函数, 在其中安插一些代码, 使得我们user使用之前先执行默认构造,
如上 扩张后的默认构造函数可能如下:
Bar::Bar()
{
 foo.Foo::Foo();
 str = nullptr;
}

如果有多个member class object 则会按照声明的顺序来调用默认构造函数,
例如:
class A{ public: A(); };
class B{ public: B( int ); };
class C{ public: C(); };
class D{ public: A a; B b; C c; int num; };

如上: class D没有定义默认构造函数 则会有一个"有用的默认构造函数"被合成出来;
D::D() : b( 1024 )
{
 num = 2048;
}

那么他也许会被扩张为:
D::D : b( 1024 )
{
 a.A::A();
 b.B::B( 1024 );
 c.C::C();
 num = 2048;
}

//-----------------------------------------------------------------------------------------------------------------------//

---> "带有Default Constructor 的 Base Class":
如果一个没有任何constructor的class派生自一个"带有Default Constructor"的 base class,
那么这个 derived class 的默认构造函数为有用的;
例子:
class A{ public: int num_a; };
class B{ public: A a; int num_b; };
class C : public B

对于这个例子, class B是一个上文的 "含有 带有Default Constructor 的 Member Class Object 的 class";
那么 class C 派生自 class B; 那么 class C 的默认构造函数为有用的;
他将调用上一层( class B ) 的 "默认构造函数" 来 "构造其内含的 Member Class Object";
如果设计中提供多个构造函数,但是其中都"没有默认构造函数",
编译器会遍历所有构造函数, 内插上一层( class B )的构造函数 ( class B的构造函数又内插了Member Class Object的构造函数 );

//-----------------------------------------------------------------------------------------------------------------------//

---> "带有一个 Virtual Function 的 class":
对于一个 带有 virtual Function 的 class , 他的默认构造函数为有用的;

而一个 class 带有virtual Function 分为两种情况:
其一: 类申明( 或继承 ) 一个 virtual function;
其二: class 派生自一个继承串链, 其中有一个或多个 virtual base class ;

例子:
class Widget
{
 public:
  virtual void Func( const Wieget &idget ) = 0;
};

class Bell : public Widget
class Whistle : public Widget

Bell b;
Whistle w;
Func( b );
Func( w );

"两个扩张行动" 会在编译期间发生:
-> 一个 virtual function table ( vtbl )会被编译器产生出来, 其中存放着 class 的 virtual functions 地址;
-> 在每一个 class object 中, 一个额外的 pointer member ( vptr )会被编译器合成出来 内含有 virtual function table 的地址;
此外 weidget.Func() 的虚拟调用操作将被改写, 以使用 widget 的 vptr 和 vtbl 中的 Func() 条目;

为了让这个 "virtual function 机制" 发挥作用, 编译器必须"为每一个Widget Object 和 其派生类的Object 设置 vptr 的初值 放置适当的 vtbl地址";

对于 class 的每一个 Constructor ,编译器会安插一些代码来完成这个操作;

//-----------------------------------------------------------------------------------------------------------------------//

---> "带有一个 Virtual Base Class 的 Class":
class X
class A : public virtual X
class B : public virtual X
class C : public A, public B

带有 virtual Base Class 的 Class C, 他的构造函数是有用的;

//-----------------------------------------------------------------------------------------------------------------------//

总结: 以上4种情况, "编译器必须为未声明构造函数的类合成一个默认构造函数",
标准称这些合成出来的构造函数为"隐式有用的构造函数", 合成出来的构造函数能够满足编译器( 而非程序 )的需要,

至于"不属于以上4种情况的而且又没有声明构造函数" 标准称他们为"隐式无用的构造函数", 事实上他们"不会被合成出来";

在合成的"隐式有用的构造函数"中, 只有 base class subobjects ( 基类的子对象 ) 和 class member object ( 类成员对象 ) 会被初始化;
而其他的 data member, 等等都不会被初始化 ( 虽然他们也许对程序是有用的 );

---->"误解":
---> 任何class如果没有定义默认构造函数 就会被合成出来一个,
---> 编译器合成出来的默认构造函数会设定class内的每一个data member,
很明显 都是错误的,