C++中最容易被人忘记的构造函数初始化列表

需要用构造函数初始化列表

1、 初始化的数据成员是对象

2、类的成员变量被const修饰

3 、需要初始化引用成员数据

不需要初始化的有

1、 指针

2.、static 标记的，static const 也不需初始化列表中

static属于类并不属于具体的对象，所以 static成员是不允许在类内初始化的。

初始化的数据成员是对象相关案例

类中的对象的初始化顺序 跟初始化列表无关， 而跟对象的定义顺序有关

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

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

    private:
        int m_a;
    };

    class B
    {
    public:
    //构造函数初始化列表
        B(int b, int a1_value, int a2_value):a1(a1_value), a2(a2_value), m_b(b) {
        }

        void printB()
        {
            cout << "b = " << m_b << endl;
            a1.printA();
            a2.printA();
        }

        ~B() {
            cout << "~B()" << endl;
        }
    private:
        int m_b;
        A a2;
        A a1;
    };

类的成员变量被const修饰相关案例

class ABC
{
public:
    ABC()
    {
        m_a = 0;
        m_b = 0;
        m_c = 0;
    }

    ABC(int a, int b, int c) {
        m_a = a;
        m_b = b;
        m_c = c;
    }

    ABC(const ABC & another)
    {
        m_a = another.m_a;
        m_b = another.m_b;
        m_c = another.m_c;
    }
private:
    int m_a;
    int m_b;
    int m_c;
};

class ABCD
{
public:

    ABCD() :m_m(0)
    {
        m_d = 0;
    }

    ABCD(int d):m_m(0)
    {

    }

    ABCD(int a, int b, int c, int d) : abcObj(a, b, c), m_m(0){
        m_d = d;
    }

    ABCD(ABC &abc, int d) : abcObj(abc) ,m_m(0) {
        m_d = d;
    }
private:
    ABC abcObj;
    int m_d;
    const int m_m; 
};

需要初始化引用成员数据案例

class A
{
    public:
            A(int &n,int m = 12):b(n),a(m){}
            ~A(){}  
    private:
            const int a;
            int& b;
}