C++ 构造函数的初始化列表

（1）如果我们有一个类成员，它本身是一个类或者是一个结构，而且这个成员它只有一个带参数的构造函数，没有默认构造函数。这时要对这个类成员进行初始化，就必须调用这个类成员的带参数的构造函数，如果没有初始化列表，那么它将无法完成第一步，就会报错。

#include <iostream>

using namespace std;

class A {
    private:
        int m_a;

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

        ~A() {
            cout << "A被析构了" << endl;
        }

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

};

class B {
    private:
        int m_b;
        A m_a1;
        A m_a2;

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

        ~B() {
            cout << "B被析构了" << endl;
        }

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

int main(){
    A a1(10), a2(100);

    B b(a1, a2, 1);

    b.printB();
}

#include <iostream>

using namespace std;

class A {
public:
	//显示提供一个带参数的构造函数
	A(int a) {
		m_a = a;
		cout << "a = " << m_a << "调用了构造函数" << endl;

	}
	~A(){
		cout << "a = " << m_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 = " << m_b << " 调用了析构函数" << endl;
	}

private:
	int m_b;
	A m_a2;
	A m_a1;
};

int main(void) {

	B b2(30, 40, 50);
	b2.printB();

	return 0;
}

注：

1. 类内部的对象初始化的顺序，跟对象的定义顺序一样，跟初始化列表中的顺序无关
2. 析构的顺序就跟构造的顺序相反

（2）当类成员中含有一个const对象时，或者是一个引用时，他们也必须要通过成员初始化列表进行初始化，因为这两种对象要在声明后马上初始化，而在构造函数中，做的是对他们的赋值，这样是不被允许的。初始化列表中的初始化顺序,与声明顺序有关,与前后赋值顺序无关。

#include <iostream>

using namespace std;

class A{
	public:
		//显示提供一个带参数的构造函数
		A(int a){
			m_a = a;
			cout << "a = " << m_a << "调用了构造函数" << endl;

		}

		~A(){
			cout << "a = " << m_a << "被析构了" << endl;
		}

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

class B{
	public:
		B(int b) :a1(10), a2(100) { //在初始化B的时候通过初始化列表给内部对象a1 和a2 进行了初始化
		
			m_b = b;
			/*
			a1(10);
			a2(20);
			*/
			cout << "b = " << m_b << "调用了构造函数" << endl;
		}

		B(int aa1, int aa2, int b) : a1(aa1), a2(aa2), m_b(b) { //通过初始化列表不仅能够初始化成员对象， 还可以初始化成员变量

		}

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

		~B(){
			cout << "b = " << m_b << " 调用了析构函数" << endl;
		}

	private:
		int m_b;
		A a2;
		A a1;
};

//类内部的对象初始化的顺序，跟对象的定义顺序一样，跟初始化列表中的顺序无关
//析构的顺序就跟构造的顺序相反

class ABC{
	public:
		
		ABC(int a, int b, int c, int m) :m_m(m) {  // const常量只能在 初始化列表中 初始化
			cout << "ABC（int, int, int）" << endl;
			m_a = a;
			m_b = b;
			m_c = c;
			// const 常量不能在这里进行初始化操作
		}


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

		void printABC(){
			cout << m_a << "," << m_b << "," << m_c << "," << endl;
		}

	private:
		int m_a;
		int m_b;
		int m_c;
		const int m_m; // 常量
};


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;
		}

		ABCD(ABC&abc, int d) :m_abc(abc){
			m_d = d;
		}

	private:
		ABC m_abc;
		int m_d;
};

int main(void){

	B b(10, 20, 30);

	b.printB();

	ABC abc(10, 20, 30, 6);
	ABCD abcd(1, 2, 3, 4, 6);

	ABCD abcd1(abc, 40);

}

注：通过初始化列表不仅能够初始化成员对象， 还可以初始化成员变量。