C++笔记——继承中的构造和析构调用规则

直接上代码

#include <iostream>
using namespace std;

class Parent
{
private:
	int a;
public:
	Parent(int a)
	{
		this->a = a;
		cout << "Parent构造函数，a=" << a << endl;
	}
	~Parent()
	{
		cout << "Parent析构函数" << endl;
	}
};

class Child :public Parent
{
public:
	Child(int a, int b, int c) :Parent(a)
	{
		this->b = b;
		this->c = c;
		cout << "Child构造函数" << endl;
	}
	~Child()
	{
		cout << "Child析构函数" << endl;
	}
private:
	int b;
	int c;
};
void play()
{
	Child c1(1,2,3);
}
int main(void)
{
	play();
	return 0;
}

编译运行结果如下：

从运行结果可以看出，继承中的构造和析构的调用规则是：

先调用父类构造函数，再调用子类构造函数，析构的顺序和构造的顺序相反。

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

2>父类的构造函数执行完毕后，执行子类的构造函数；
3>当父类的构造函数有参数时，需要在子类的初始化列表中显式调用；

4>析构函数的调用顺序和构造函数调用顺序相反；

下来再看一下类中组合类时的构造和析构的调用规则：

#include <iostream>
using namespace std;

class Obj
{
public:
	Obj(int a, int b)
	{
		this->a = a;
		this->b = b;
		cout << "Obj构造函数  a="<<a<<",b="<<b<< endl;
	}
	~Obj()
	{
		cout << "Obj析构函数" << endl;
	}
private:
	int a;
	int b;
};

class Parent:public Obj
{
private:
	char *p;
public:
	Parent(char *p) :Obj(1,2)
	{
		this->p = p;
		cout << "Parent构造函数，a=" << p << endl;
	}
	~Parent()
	{
		cout << "Parent析构函数" << endl;
	}
};

class Child :public Parent
{
public:
	Child(char *p) :Parent(p), obj1(3, 4), obj2(5,6)
	{
		this->myp = p;
		cout << "Child构造函数+++" <<myp<< endl;
	}
	~Child()
	{
		cout << "Child析构函数" << endl;
	}
private:
	char *myp;
	Obj obj1;
	Obj obj2;
};

void play()
{
	Child c1("继承测试");
}
int main(void)
{
	play();
	return 0;
}

编译运行结果如下：

按照运行结果，分析得出创建子类对象时会先调用祖先类的构造函数，再调用父类的构造函数，如果类内部组合了类的话，按照类定义顺序调用它的构造函数，最后在调用子类的构造函数，析构函数和构造函数的调用顺序相反。

其中Child(char *p) :Parent(p), obj1(3, 4), obj2(5,6)中的obj1和obj2的构造函数的调用顺序是按照obj1和obj2定义的顺序，而不是按照初始化列表的先后来调用构造函数。