继承与组合混搭情况下，构造和析构调用原则

1、子类对象在创建时会首先调用父类的构造函数

2、父类构造函数执行结束后，执行子类的构造函数

3、当父类的构造函数有参数时，需要在子类的初始化列表中显示调用

4、析构函数调用的先后顺序与构造函数相反

 

总之，在继承与组合混搭的情况下，

构造函数调用顺序：先调用父类构造函数（一直调用到最祖先的父类，类似递归的思想），再调用组合对象的构造函数，最后调用本身的构造函数。

析构函数调用顺序：先调用本身的析构函数，再次调用组合对象的析构函数，最后调用父类的构造函数 （构造与析构的调用顺序刚好相反）。

 

代码如下：

#include <iostream>
using namespace std;

class Object
{
public:
	Object(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "object构造函数 执行 " << "a" << a << " b " << b << endl;
	}
	~Object()
	{
		cout << "object析构函数 \n";
	}
protected:
	int a;
	int b;
};


class Parent : public Object
{
public:
	Parent(char* p) : Object(1, 2)
	{
		this->p = p;
		cout << "父类构造函数..." << p << endl;
	}
	~Parent()
	{
		cout << "析构函数..." << p << endl;
	}

	void printP(int a, int b)
	{
		cout << "我是爹..." << endl;
	}

protected:
	char* p;
};


class child : public Parent
{
public:
	child(char* p) :  obj1(3, 4), obj2(5, 6), Parent(p)
	{
		this->myp = p;
		cout << "子类的构造函数" << myp << endl;
	}
	~child()
	{
		cout << "子类的析构" << myp << endl;
	}
	void printC()
	{
		cout << "我是儿子" << endl;
	}
protected:
	char* myp;
	Object obj1;
	Object obj2;
};


void objplay()
{
	char p[] = "继承测试";
	child c1(p);

	/**
	输出：
	object构造函数 执行 a1 b 2
	父类构造函数...继承测试
	object构造函数 执行 a3 b 4
	object构造函数 执行 a5 b 6
	子类的构造函数继承测试
	子类的析构继承测试
	object析构函数
	object析构函数
	析构函数...继承测试
	object析构函数
	hello...
	*/
}
void main()
{
	objplay();
	cout << "hello..." << endl;
	system("pause");
	return;
}