那些你不知道的默认构造函数~~

首先，本篇文章只讲 “默认构造函数”，即如你所知，默认构造函数是不带参数的构造函数。

编译器会在 适当的时候 为class合成一个默认构造函数 ~~

先问以下两个问题：

1    编译器会为任何没有声明构造函数的class，合成默认构造函数？？ 错！！！

2    合成的默认构造函数会显示设定class内的每一个data member的默认值？？ 错！！！

class Base
{
public:
    int x;
    int getX() const {return x;};
};
int main()
{
    Base b;
    cout << b.getX() << endl;
    return 0;
}

结果不如人意，getX的输出值完全是随机的。

编译器的动作，是仅限于自己的责任，类的设计者如果需要为类的所有成员进行初始化，那么自己动手吧！！

编译器的动作是隐式的，因此，了解什么时候算是 “适当的时候”？？

以下的4个方面是编译器的所谓的适当的时候。。。

1  带有“默认构造函数”的类成员对象。 

就是说，如果类A的一个对象a作为类B的成员变量，并且类B没有定义构造函数，但是类A有自己的默认构造函数，那么，在定义类B的对象时，编译器会为类B合成一个默认构造函数。因为在创建类B的对象时，期间必须调用类A的默认构造函数初始化a。

例如：

class Base
{
public:
    Base()
    {
        cout << "call Base default constructor..." << endl;
    }
    virtual ~Base(){}
};

class Base2
{
public:
    Base2(){cout << "call Base2 default constructor..." << endl;}
};

class Derived
{
private:
    Base2 b2;
    Base b;
    int x;
public:
    //Derived(int _x){  x = _x; }
    ~Derived(){}
};
int main()
{
    Derived d;
    return 0;
}

执行结果为：

可以看到，成员变量b2和b的默认构造函数被调用，并且是按照其声明次序。

2  带有默认构造函数的基类

就是说。如果类Derived继承自类Base，但是Base类定义默认构造函数的话，分两种情况：

1    如果这个Derived类没有定义构造函数，那么编译器必定会为其合成一个，因为此时的默认构造函数将不是trivial的，因此必须将它合成，用于初始化基类。

2     如果Derived类定义了自己版本的构造函数，这其中并没有默认构造函数，那么在这些定义的构造函数调用之前，还是会调用基类的默认构造函数。（意味着先调用基类的默认构造函数，再调用自身的构造函数）。

如下：

class Base
{
public:
    Base()
    {
        cout << "call Base default constructor..." << endl;
    }
    virtual ~Base(){}
};

class Base2
{
public:
    Base2(){cout << "call Base2 default constructor..." << endl;}
    virtual ~Base2(){}
};

class Member
{
public:
    Member(){cout << "call Member default constructor..." << endl;}
};

class Derived : public Base, public Base2
{
private:
    int x;
    Member m;
    string str;
public:
    Derived(int _x):x(_x){}
    Derived(string _str):str(_str){}
    ~Derived(){}
};
int main()
{
    Derived d(0);
    return 0;
}

执行结果为：

可以看到，在Derived类中并没有默认构造函数，但是当我们使用 "以int作为参数的构造函数"时，其基类的默认构造函数被调用（按声明次序），调用完成之后，如果还有成员对象，再调用该类的默认构造函数（如此处的Member）.

3 带有 ”虚函数“的类

也就是说，如果一个class继承一个虚函数，或者是一个类的继承体系中含有 virtual继承。如果用户没有定义构造函数，那么编译器会合成。

如下：

class Base
{
private:
    int x;
public:
    Base(){cout << "call Base default ctor..." << endl;}
    virtual void vCall(){cout << "virtual call in Base..." << endl;}
    virtual ~Base(){}
};
class Derived:public Base
{
private:
    int x ;
public:
    void vCall(){x=1;cout << "virtual call in Derived..." << endl;}

};
void vCall(Base &b)
{
    b.vCall();
}


int main()
{
    Derived d;
    vCall(d);
    return 0;
}

执行结果为：

可以看到，基类的默认构造函数被调用。由于存在虚函数，存在多态性，代码中的d的实际类型只有在执行时才知道，因此编译器会为该类继承层次中的每一个对象生成一个virtual table，其中存放虚函数的地址。因此有一个”vptr“指针指向这个虚函数表，编译器会生成这个指针并且付给每个对象，这是由“默认构造函数”来完成的。

4带有 “虚基类”的类

就是说，编译器会为带有”虚基类“的类合成默认构造函数。对于不同的编译器，虚基类的实现方式不一样，但是共同的作用都是需要确定在派生类的对象中虚基类的位置。

上述四种情况下，都是编译器的责任，编译器会在 这 4中合适的时候合成  "non-trivial default ctor"，这些构造函数是要干实事的。对于其他的情况。编译器生成的都是"trivial default ctor"，它们实际上根本不会被合成。

因此，默认构造函数真的不简单，”合适的时候“真的是一句很有哲学的话，把后面的责任推得干干净净~~

但是，值得一提的是，如果用户需要明确的指定成员变量的值，那么这就是程序员自己的责任了。