一、继承中的对象模型分析

---

1、继承代码示例

下面有 3 个类 , 分别是 A 类 , B 类 , C 类 ;

• A 类是 基类 ;
• B 类 公有继承 A 类 , 并定义了新的 成员变量 y ;
• C 类 公有继承 B 类 , 并定义了新的 成员变量 z ;

class A {
public:
	int x;
};

class B : public A {
public:
	int y;
};

class C : public B {
public:
	int z;
};

分别定义上述 3 个类的对象 ,

	A objA;
	B objB;
	C objC;

2、基类与派生类内存模型

上述 3 个对象的内存模型如下 :

• A 类对象 objA 中有一个成员 int x , 在内存中只有一个 int 类型的空间 ;
• B 类对象 objB 中 , 除了继承自 A 类的 int x 成员 , 还有一个自己的 int y 成员 , 在内存中是 2 个 int 类型的空间 ;
• C 类对象 objC 中 , 除了继承自 B 类的 int x 和 int y 成员 , 还有一个自己的 int z 成员 , 在内存中是 3 个 int 类型的空间 ;

3、问题引入 - 派生类对象构造函数和析构函数调用

上述 继承 的过程中 , 每一层继承 , 都继承了上一级 父类的 成员变量 , 同时自己也定义了新的成员变量 ;

• 在 派生类对象 构造时 , 构造函数如何进行调用 ;
• 在 派生类对象 析构时 , 析构函数如何进行调用 ;

本篇博客开始讨论上述问题 ;

4、完整代码示例 - 派生类对象内存模型

#include "iostream"
using namespace std;

class A {
public:
	int x;
};

class B : public A {
public:
	int y;
};

class C : public B {
public:
	int z;
};

int main() {

	A objA;
	B objB;
	C objC;
	

	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}

二、继承中的构造函数和析构函数

---

1、子类构造函数与析构函数调用顺序

继承中的构造函数和析构函数 :

• 子类构造 : 子类对象 进行 构造 时 , 需要调用 父类 的 构造函数 对 继承自父类的 成员变量 进行 初始化 操作 ; 构造函数 调用顺序如下 :
  • 构造时 , 先调用 父类 的构造函数 , 构造继承自父类的成员 ;
  • 然后 , 再调用 子类 的 构造函数 , 构造 子类 自己定义的成员 ;
• 子类析构 : 子类对象 进行 析构 时 , 需要调用 父类 的 析构函数 对 继承自父类的 成员变量 进行 析构 操作 ; 析构函数调 用顺序如下 :
  • 析构时 , 先 调用 子类 的 析构函数 , 析构 子类 自己的成员 ;
  • 然后 , 再调用 父类 的 析构函数 , 析构 继承自父类的成员 ;

2、子类构造函数参数列表

如果 父类 的 构造函数 有 参数 , 则 需要再 子类 的 初始化列表中 显示调用 该有参构造函数 ;

如果 A 类有构造函数 :

class A {
public:
	A(int a)
	{
		this->x = a;
		cout << "A 构造函数调用" << endl;
	}
}

B 类 如果继承 A 类 ,

• 如果 A 类有默认的构造函数 , B 类的构造函数可以这么写 , 不显式调用 A 类的构造函数 , 默认调用 A 类的 无参 默认构造函数 ;

class B : public A {
public:
	B(int b)
	{
		this->y = b;
		cout << "B 构造函数调用" << endl;
	}
}

• 如果 A 类 没有 默认的构造函数 , B 类的构造函数 必须 显式调用 A 类的构造函数 , 并传入 A 类的构造函数参数 ;

class B : public A {
public:
	B(int a, int b) : A(a)
	{
		this->y = b;
		cout << "B 构造函数调用" << endl;
	}
}

3、代码示例 - 继承中的构造函数和析构函数

代码示例 :

#include "iostream"
using namespace std;

class A {
public:
	A(int a)
	{
		this->x = a;
		cout << "A 构造函数调用" << endl;
	}
	~A()
	{
		cout << "A 析构函数调用" << endl;
	}
public:
	int x;
};

class B : public A {
public:
	B(int a, int b) : A(a)
	{
		this->y = b;
		cout << "B 构造函数调用" << endl;
	}
	~B()
	{
		cout << "B 析构函数调用" << endl;
	}
public:
	int y;
};

class C : public B {
public:
	C(int a, int b, int c) : B(a, b)
	{
		this->z = c;
		cout << "C 构造函数调用" << endl;
	}
	~C()
	{
		cout << "C 析构函数调用" << endl;
	}
public:
	int z;
};

int main() {

	C obj(1, 2, 3);

	cout << "obj.x = " << obj.x << 
		 " , obj.y = " << obj.y << 
		 " , obj.z = " << obj.z << endl;
	

	// 控制台暂停 , 按任意键继续向后执行
	system("pause");

	return 0;
}

执行结果 :

A 构造函数调用
B 构造函数调用
C 构造函数调用
obj.x = 1 , obj.y = 2 , obj.z = 3
请按任意键继续. . .
C 析构函数调用
B 析构函数调用
A 析构函数调用