【C++】构造函数初始化列表 ② ( 构造函数 为 初始化列表 传递参数 | 类嵌套情况下 的 构造函数 / 析构函数 执行顺序 )

一、构造函数 为 初始化列表 传递参数

---

1、构造函数参数传递

构造函数 初始化列表 还可以使用 构造函数 中的参数 ;

借助 构造函数 中的参数列表 , 可以为 初始化列表 传递参数 ;

在下面的代码中 , B 类的 有参构造函数 , 传入了 3 个参数 , 这三个参数都不在函数体中使用 , 而是在 参数列表中使用 ,

	// 构造函数中的参数可以作为
	B(int age, int ageOfA, int heightOfA) : m_age(age), m_a(ageOfA, heightOfA)
	{}
1
2
3

• m_age(age) 表示为 m_age 成员变量 赋值 构造函数参数中的 age 参数 ;
• m_a(ageOfA, heightOfA) 表示调用 A 的有参构造函数 , 传入的 2 个参数分别是 构造函数中的 int ageOfA, int heightOfA 两个参数 ;

代码示例 :

class B
{
public:
	B() : m_age(10), m_a(10, 150)
	{}

	// 构造函数中的参数可以作为
	B(int age, int ageOfA, int heightOfA) : m_age(age), m_a(ageOfA, heightOfA)
	{}
public:
	int m_age;		// 年龄
	A m_a;			// A 类型成员变量
};
1
2
3
4
5
6
7
8
9
10
11
12
13

调用上述 有参构造函数 , 传入参数即可 ;

	// 通过 B 的有参构造函数
	// 其中 构造函数中的参数 作为 参数列表 中的参数值
	B b(10, 10, 150);
1
2
3

2、代码示例 - 构造函数参数传递

下面的代码中 , 类 A 定义了 2 个参数的 有参构造函数 ;

类 B 定义了 无参构造函数 , 但是在该 无参构造函数 中 , 定义了函数列表 B() : m_age(10), m_a(10, 150) , 在该函数列表中 , 执行了 A 的构造函数 ;

类 B 中还定义了 有参构造函数 , 接收 3 个参数 , 分别作为 m_age 成员的值 , 和 A 类型成员对象的 有参构造函数 的 2 个参数 , 这是 使用了 构造函数 向 初始化列表 的 参数传递 机制 ;

代码示例 :

#include "iostream"
using namespace std;

class A
{
public:
	// 带参构造函数
	A(int age, int height)
	{
		m_age = age;
		m_height = height;
	}

public:
	int m_age;		// 年龄
	int m_height;	// 身高
};

class B
{
public:
	B() : m_age(10), m_a(10, 150)
	{}

	// 构造函数中的参数可以作为 参数列表 中的参数值
	B(int age, int ageOfA, int heightOfA) : m_age(age), m_a(ageOfA, heightOfA)
	{}
public:
	int m_age;		// 年龄
	A m_a;			// A 类型成员变量
};


int main()
{
	// 通过 B 的有参构造函数
	// 其中 构造函数中的参数 作为 参数列表 中的参数值
	B b(10, 10, 150);


	// 控制台暂停 , 按任意键继续向后执行
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

执行结果 :

二、类嵌套情况下 的 构造函数 / 析构函数 执行顺序

---

1、构造函数 / 析构函数 执行顺序

类 B 中 定义了 A 类型 的 成员变量 ;

A 类型对象 是 被组合对象 ;

构造函数执行顺序 :

在 初始化 B 类型 实例对象时 , 先执行 被组合对象 A 的构造函数 ,

如果 被组合对象 有多个 , 则 按照 成员变量 的定义顺序 进行初始化 ;

注意 : 此处 不是按照 初始化列表 的顺序 进行初始化 ;

析构函数执行顺序 :

析构函数 与 构造函数 的执行顺序 相反 ;

2、代码示例 - 构造函数执行顺序

下面的代码中 , 在 B 类中定义 A 类型 成员变量 ;

执行构造函数时 , 先调用 A 的构造函数 , 再调用 B 的构造函数 ;

执行析构函数时 , 与构造函数顺序相反 , 先执行 B 的析构函数 , 再执行 A 的析构函数 ;

代码示例 :

#include "iostream"
using namespace std;

class A
{
public:
	// 带参构造函数
	A(int age, int height)
	{
		m_age = age;
		m_height = height;
		cout << "执行 A 的构造函数" << endl;
	}

	~A()
	{
		cout << "执行 A 的析构函数" << endl;
	}

public:
	int m_age;		// 年龄
	int m_height;	// 身高
};

class B
{
public:
	B() : m_age(10), m_a(10, 150)
	{}

	// 构造函数中的参数可以作为 参数列表 中的参数值
	B(int age, int ageOfA, int heightOfA) : m_age(age), m_a(ageOfA, heightOfA)
	{
		cout << "执行 B 的构造函数" << endl;
	}

	~B()
	{
		cout << "执行 B 的析构函数" << endl;
	}
public:
	int m_age;		// 年龄
	A m_a;			// A 类型成员变量
};


int main()
{
	// 通过 B 的有参构造函数
	// 其中 构造函数中的参数 作为 参数列表 中的参数值
	B b(10, 10, 150);


	// 控制台暂停 , 按任意键继续向后执行
	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

执行结果 :

执行 A 的构造函数
执行 B 的构造函数
请按任意键继续. . .
执行 B 的析构函数
执行 A 的析构函数
1
2
3
4
5