3.6 构造函数的初始化列表

#include<iostream>
using namespace std;

class A
{
public:
    A(int a)
    {
        cout << "A()...." << a << endl;
        m_a = a;
    }

    ~A() {
        cout << " ~A() " << endl;
    }

    void printA()
    {
        cout << " a = " << m_a <<endl;
    }

private:
    int m_a;
};

class B
{
public://构造函数的初始化列表
    B(A &a1,A &a2,int b):m_a1(a1),m_a2(a2)
    {
        cout << "B(A&,A&,int)...." << endl;
        m_b = b;

    }
    //构造对象对象的顺序跟初始化列表顺序无关
    //而是跟成员对象的定义顺序有关
    B(int a1,int a2,int b) :m_a1(a1),m_a2(a2)
    {//构造函数的初始化列表
        cout << "B(int ,int ,int)....." << endl;
        m_b = b;
    }

    void printB() 
    {
        cout << "b = " << m_b << endl;
        m_a1.printA();
        m_a2.printA();
    }
    ~B() {
        cout << "~B()..." << endl;
    }
private:
    int m_b;
    A m_a2;
    A m_a1;//构造对象对象的顺序跟成员对象的定义顺序有关
};

class ABC
{
public:
    ABC(int a,int b,int c,int m):m_m(m)
    {
        cout << "ABC(int ,int ,int)....." << endl;
        m_a = a;
        m_b = b;
        m_c = c;

    }

    ~ABC() {
        cout << "~ABC()..." << endl;
    }
private://类成员不能初始化赋值
    int m_a;
    int m_b;
    int m_c;
    const int m_m;//常量：一经初始化不可修改，且必须初始化
                //但这里此时还没有开辟空间，只有创建ABC对象时才开辟空间

};

class ABCD
{
public:
    ABCD(int a,int b,int c,int d,int m) :m_abc(a,b,c,m),m_d(d)
    {                                                 //m_d(d)相当于int m_d = d;  
                                                   //int这个类型的构造函数赋予初值
    }
    ABCD(ABC &abc,int d):m_abc(abc)
    {
        m_d = d;
    }
private:
    int m_d;
    ABC m_abc;

};

int main()
{
    A a1(10),a2(100);
    B b(a1,a2,1000);
    b.printB();

    B b1(10,20,300);
    b1.printB();

    ABC abc(10,20,30,666);
    ABCD abcd(1,2,3,4,666);
    ABCD abcd1(abc,40);

    return 0;
}

总结：

构造对象对象的顺序跟初始化列表顺序无关，而是跟成员对象的定义顺序有关。

m_d(d)相当于int m_d = d; int这个类型的构造函数赋予初值

常量：一经初始化不可修改，且必须初始化，但类中的常量成员此时还没有开辟空间可以不赋初值值，因为只有创建ABC对象时才开辟空间。