6.12C++：继承基类的构造函数、单继承的构造函数、多继承的构造函数、派生类复制构造函数、派生类的析构函数

1 继承基类的构造函数

class A{
public:
	A(){};  // A的构造函数
};
class B : public A{
public:
	using A:A；
}

2 单继承的构造函数

class A{
public:
	A(int i){};
};
class B : public A{
public:
	B(int i, int j): A(i), bb(j); /i传递给A的构造函数，j初始化bb
private:
	int bb;
};

3 多继承的构造函数

派生类的构造函数需要给所有基类构造函数传递参数。
多继承时先按声明顺序执行每个基类的构造函数，同时传递参数至对应构造函数。
之后按声明顺序，初始化派生类成员

#include <iostream>
using namespace std;
class Base1 {
public:
	Base1() {
		cout << "基类1的构造函数" << endl;
	};
	Base1(int i) : base1(i) {
		cout << "基类1的构造函数" << endl;
	};
private:
	int base1;
};
class Base2 {
public:
	Base2() {
		cout << "基类2的构造函数" << endl;
	};
	Base2(int i) : base2(i) {
		cout << "基类2的构造函数" << endl;
	};
private:
	int base2;
};
class Base3 {
public:
	Base3() {
		cout << "基类3的构造函数" << endl;
	};
};
class Derived : public Base3, public Base2, public Base1 {
public:
	Derived() {  /先按3-2-1的顺序调用基类构造函数，
				再按1-2-3的顺序创建成员对象，调用Base1-2-3的构造函数
		cout << "继承类的构造函数" << endl;
	};
	Derived(int i, int j, int p, int q) : a(i), b(j), Base1(p), Base2(q){
		cout << "继承类的构造函数" << endl;
	};
private:
	Base1 a;
	Base2 b;
	Base3 c;
};
int main() {
	Derived dd;/ 调用无参数的构造函数
	cout << endl;
	Derived d(1, 2, 3, 4);
	return 0;
}
输出结果：
基类3的构造函数
基类2的构造函数
基类1的构造函数
基类1的构造函数
基类2的构造函数
基类3的构造函数
继承类的构造函数

基类3的构造函数
基类2的构造函数
基类1的构造函数
基类1的构造函数
基类2的构造函数
基类3的构造函数
继承类的构造函数

4 派生类复制构造函数

派生类未定义复制构造函数的情况

1. 编译器会在需要时生成一个隐含的复制构造函数
2. 先调用基类的复制构造函数，再为派生类新增的成员执行复制

派生类定义了复制构造函数的情况
基类复制构造函数的形参类型是==基类对象的引用

Base(const Base &a) : ...{};

而派生类对象也可以是基类的对象，所以派生类对象的引用可以作为实参

5 派生类的析构函数

构造函数执行顺序： 基类（按声明顺序）-成员对象所属类（按声明顺序）-派生类
析构函数执行顺序：派生类-成员对象所属类（相反）-基类（相反）
和入栈、出栈类似，先构后析，后构先析
可以理解为：如果先析构基类或成员对象所属类，派生类的总体内容就减少了，派生类就无法正常工作了；所以先析构最后创建内存空间的派生类。

#include <iostream>
using namespace std;
class Base {
public:
	Base() {
		cout << "构造基类" << endl;
	}
	~Base() {
		cout << "析构基类" << endl;
	}
};
class C {
public:
	C() {
		cout << "构造C" << endl;
	}
	~C() {
		cout << "析构C" << endl;
	}
};
class Derived : public Base {
public:
	Derived() {
		cout << "构造继承类" << endl;
	}
	~Derived() {
		cout << "析构继承类" << endl;
	}
private:
	C c;
};
int main()
{
	Derived d;
	return 0;
}
运行结果：
构造基类   / Derived继承了Base的成员
构造C 	/ Derived的成员对象c 调用C的构造函数
构造继承类	/ Derived的构造函数执行完毕
析构继承类	/ 先析构派生类自己
析构C	/ 析构成员对象所属类
析构基类 /最后析构基类