【C++】继承 ⑧ ( 继承 + 组合模式的类对象构造函数和析构函数调用规则 )

曾经终败给现在 2024-02-21 10:55 11阅读 0赞

#### 文章目录 ####

*  一、继承 + 组合 模式的类对象 构造函数和析构函数调用规则
 *   *  1、场景说明
     *  2、调用规则
 *  二、完整代码示例分析
 *   *  1、代码分析
     *  2、代码示例

## 一、继承 + 组合 模式的类对象 构造函数和析构函数调用规则 ##

--------------------

### 1、场景说明 ###

如果一个类

*  既 继承了 基类 ,
 *  又 在类中 维护了一个 其它类型 的 成员变量 ,

那么 该类 的 构造 与 析构 , 就需要涉及到

*  **类 本身** 的 构造函数 和 析构函数 ,
 *  **父类** 的 构造函数 和 析构函数 ,
 *  **类 成员变量** 的 构造函数 和 析构函数 ;

### 2、调用规则 ###

**在 继承 + 组合 的情况下 , 构造函数 与 析构函数 调用规则如下 :**

*  **构造函数 : 父类 -> 成员 -> 自身 ;**
    
     *  首先 , 调用 父类 构造函数 ;
     *  然后 , 调用 成员 构造函数 ; 也就是 成员变量 类型的 构造函数 ;
     *  最后 , 调用 自己 构造函数 ; 自身定义的 构造函数 ;
 *  **析构函数 : 自身 -> 成员 -> 父类 ;**
    
     *  首先 , 调用 自己 析构函数 ; 自身定义的 析构函数 ;
     *  然后 , 调用 成员 析构函数 ; 也就是 成员变量 类型的 析构函数 ;
     *  最后 , 调用 父类 析构函数 ;

## 二、完整代码示例分析 ##

--------------------

### 1、代码分析 ###

在下面的代码中 ,

**继承关系 :** C 类 继承了 B 类 `class C : public B` , B 类 继承了 A 类 `class B : public A` ;

**组合关系 :** D 类 是一个普通类 , 在 C 类中维护了一个 D 类成员变量 ;

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

可根据下面的调用规则 , 分析出 C 类对象中 , 涉及到的 父类构造/析构函数 , 自身构造/析构函数 , 成员变量 构造/析构函数 的调用顺序 ;

*  构造函数调用顺序 : 父类 -> 成员 -> 自身 ;
 *  析构函数调用顺序 : 自身 -> 成员 -> 父类 ;

### 2、代码示例 ###

**代码示例 :**

#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 D
    {
        
    public:
    	D()
    	{
        
    		cout << "D 构造函数调用" << endl;
    	}
    	~D()
    	{
        
    		cout << "D 析构函数调用" << endl;
    	}
    };
    
    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;
    	D d;
    };
    
    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 的构造函数 , 是 父类构造函数 ;
 *  D 构造函数 , 是 成员构造函数 ;
 *  C 构造函数 , 是 自身构造函数 ;

**构造函数的调用顺序为 : 父类 -> 成员 -> 自身 , 符合上述的调用原则 ;**

然后分析 析构函数 调用顺序 ;

*  C 析构函数 , 是 自身构造函数 ;
 *  D 析构函数 , 是 成员构造函数 ;
 *  A 和 B 的析构函数 , 是 父类构造函数 ;

**析构函数的调用顺序为 : 自身 -> 成员 -> 父类 , 符合上述的调用原则 ;**

A 构造函数调用
    B 构造函数调用
    D 构造函数调用
    C 构造函数调用
    obj.x = 1 , obj.y = 2 , obj.z = 3
    Press any key to continue . . .
    C 析构函数调用
    D 析构函数调用
    B 析构函数调用
    A 析构函数调用

![在这里插入图片描述][cc7bc21a9d694b058f59d4848323244e.png]

[cc7bc21a9d694b058f59d4848323244e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/e1b02f71401c4eecb4c8cc84af421bbf.png