关于nontrivial default constructor(一)

C++ Standard 说：

对于class A来说， 如果没有任何 user-defined constructor， 那么会有一个 default constructor被隐式声明出来， 一个被隐式声明出来的 default constructor将是一个trivial constructor。

以下四种情况为nontrivial default constructor：

1. 如果一个class 没有constructor，但它内涵一个member object(类对象)，而后者有一个default constructor， 那么其implicit default constructor 就是nontrivial 的。

合成的默认构造函数，拷贝构造函数，析构函数，拷贝赋值运算符都以inline形式完成。一个inline函数有静态链接，不会被文件以外者看到。

被合成出来的默认构造函数将调用内含对象的默认构造函数来初始化其内含对象。

class A
{
public:
A();
A(int);
...
};

class B
{
private:
A a;
char *str;
...//没有任何构造函数
};

此时，B的默认构造函数被编译器合成，而且是nontrivial，但此构造函数并不会执行其成员str的初始化，因为这是程序员的责任。
被合成的构造函数类似于：

inline B::B()
{
a.A::A();//只此操作，并没有初始化str
}

再一次强调，被合成的default constructor是只满足编译器的需要，而不满足程序员的需要。

但是有个问题：若程序员提供默认构造函数来初始化str，例如：

B::B()
{
str = nullptr;
}

此时编译器不会在为我们合成default constructor，因为我们已经定义了一个。此时编译器会怎么办呢？答案如下：
如果class A内含一个或以上的member class objects，那么class A的每一个constructor必须调用每一个member class 的default constructor。
类似于这样：

B::B()
{
a.A::A();   //附加的compiler code
str = nullptr;   //explicit user code

}

看下面一段代码：

class Dopey
{
public:
Dopey()
{
cout << "Dopey constructor ..." << endl;
}
};

class Sneezy
{
public:
Sneezy(int a)
{
x = a;
cout << "argment Sneezy constructor ..." << endl;
}
Sneezy()
{
cout << "Sneezy constructor ..." << endl;
}
private:
int x;
};

class Bashful
{
public:
Bashful()
{
cout << "Bashful constructor ..." << endl;
}
};

class Snow_white
{
public:

//Snow_white();
Dopey dopey;
Sneezy sneezy;
Bashful bashful;
private:
int mumble;
};

//Snow_white::Snow_white() : sneezy(1024)
//{
//	mumble = 2048;
//}
int main(void)
{
Snow_white snow_white;
return 0;
}

Snow_white没有定义自己的默认构造函数，就会有一个nontrivial constructor被合成出来，一次调用Dopey，Sneezy， Bashful的default constructor。
运行结果：



但是如果Snow_white定义了自己的默认构造函数呢？取消上面代码的注释部分，会发生什么呢？
自定义的构造函数会被扩张：

Snow_white::Snow_white() : sneezy(1024)
{
//扩充的代码
dopey.Dopey::Dopey();
sneezy.Sneezy::Sneezy(1024);
bashful.Bashful::Bashful();

//explicit user code
mumble = 2048;
}

运行结果：


以上为第一种情况。
未完待续..............................