【C++】C++ 类中的 this 指针用法 ③ ( 全局函数 与 成员函数 相互转化 | 有参构造函数设置默认参数值 | 返回匿名对象与返回引用 )

一、全局函数 与 成员函数 相互转化

---

1、成员函数转为全局函数 - 多了一个参数

C++ 编译器 , 在编译阶段会将 C++ 类的 成员函数 转为 全局函数 , 转换时 , 会 增加一个参数到参数列表开始为止 , 这个增加的参数是 对象本身的指针 ;

在 Student 类中 , 定义了如下函数 :

	// 成员函数 转为 全局函数 , 多了一个参数 Student* pThis 作为第一个参数
	void print()
	{
		cout << "age = " << this->age << " , height = " << this->height << endl;
	}
1
2
3
4
5

将上述 Student 类 中的 print 成员函数 , 转为 全局函数 , 转换后的代码为 :

// 将成员函数 void print() 
// 转为 全局函数
void Student_print(Student* pThis)
{
	cout << "age = " << pThis->age << " , height = " << pThis->height << endl;
}
1
2
3
4
5
6

转换完毕后 , 参数列表中增加了一个参数 Student* pThis 在 列表的开始位置 ;

详细代码 , 参考最后的完整代码示例 ;

2、全局函数转为成员函数 - 通过 this 指针隐藏操作数

全局函数转为成员函数 , 需要隐藏一个参数 , 就是通过 this 指针隐藏左操作数 , 对象本身 就是 左操作数 , 在成员函数中 , 通过 this 指针访问对象本身的成员 ;

在全局函数中 , 实现两个 Student 类相加 , 接收两个 Student 引用类型的参数 , 引用相当于一级指针 ;

// 全局函数中 , 将两个 Student 对象相加
// 引用的 等同于 一级指针 , Student 引用用法与 Student 对象用法相同
// 全局函数 转为 成员函数 , 少了一个参数
Student StudentPlus(Student& s1, Student& s2)
{
	Student s;
	s.age = s1.age + s2.age;
	s.height = s1.height + s2.height;
	return s;
}
1
2
3
4
5
6
7
8
9
10

转为成员函数后 , 成员函数 比 全局函数 少了一个参数 , 少的那个参数 , 就是对象本身 ;

	// 成员函数中, 将两个 Student 对象相加
	// 全局函数 转为 成员函数 , 少了一个参数
	Student StudentPlus(Student& s2)
	{
		Student s;
		s.age = this->age + s2.age;
		s.height = this->age + s2.height;
		// 注意 : 返回的是一个匿名对象
		return s;
	}
1
2
3
4
5
6
7
8
9
10

详细代码 , 参考最后的完整代码示例 ;

二、有参构造函数设置默认参数值

---

为 Student 类定义了有参构造函数 , 则其默认的无参构造函数 , 就不会生成 ;

	// 带参构造函数
	Student(int age, int height)
	{
		this->age = age;
		this->height = height;
		cout << "执行 Student 的构造函数" << endl;
	}
1
2
3
4
5
6
7

此时 , 如果要创建 Student 对象 , 只能调用上述 有参构造函数 , 如果使用 Student s2 的方式调用 默认构造函数 创建 Student 对象 , 就会报错 ;

如下带参数的构造函数 , 并且为其 有参构造函数 的参数 设置一个默认值 , 此时就可以使用 类名 对象名 的方式定义对象变量 ;

class Student
{
public:
	// 带参构造函数
	Student(int age = 0, int height = 0)
	{
		this->age = age;
		this->height = height;
		cout << "执行 Student 的构造函数" << endl;
	}

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

public:
	int age;		// 年龄
	int height;		// 身高
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

此时就可以使用默认构造函数 , 创建 Student 对象 ;

三、返回匿名对象与返回引用

---

在上面的章节中 , 将 两个 Student 对象相加 , 返回的是一个匿名对象 , 该匿名对象 是在 成员函数 中新创建的对象 ;

	// 成员函数中, 将两个 Student 对象相加
	// 全局函数 转为 成员函数 , 少了一个参数
	// 返回一个新 Student 对象
	Student StudentPlus(Student& s2)
	{
		Student s;
		s.age = this->age + s2.age;
		s.height = this->height + s2.height;
		// 注意 : 返回的是一个匿名对象
		return s;
	}
1
2
3
4
5
6
7
8
9
10
11

如果不返回新的对象 , 而是将 两个 对象相加 , 最终结果累加到 本对象中 , 则返回 Student 引用即可 ;

	// 成员函数中, 将两个 Student 对象相加
	// 全局函数 转为 成员函数 , 少了一个参数
	// 两个 对象相加 , 最终结果累加到 本对象中
	Student& StudentPlus2(Student& s2)
	{
		this->age = this->age + s2.age;
		this->height = this->height + s2.height;
		// 注意 : 返回的是一个引用 , 就是返回自身对象变量
		// this 是指针 , *this 是指针指向的 自身对象
		return *this;
	}
1
2
3
4
5
6
7
8
9
10
11

返回 引用 , 就是返回自身对象 ;

this 是指针 , *this 是指针指向的 自身对象 实际数据 ,

返回引用 , 就是返回 自身对象实际数据 *this ;

四、完整代码示例

---

代码示例 :

#include "iostream"
using namespace std;

class Student
{
public:
	// 带参构造函数
	Student(int age = 1, int height = 1)
	{
		this->age = age;
		this->height = height;
		cout << "执行 Student 的构造函数" << endl;
	}

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

	// 成员函数中, 将两个 Student 对象相加
	// 全局函数 转为 成员函数 , 少了一个参数
	// 返回一个新 Student 对象
	Student StudentPlus(Student& s2)
	{
		Student s;
		s.age = this->age + s2.age;
		s.height = this->height + s2.height;
		// 注意 : 返回的是一个匿名对象
		return s;
	}

	// 成员函数中, 将两个 Student 对象相加
	// 全局函数 转为 成员函数 , 少了一个参数
	// 两个 对象相加 , 最终结果累加到 本对象中
	// 注意此处 : 函数重载 不以 返回值为标准 , 函数名需要修改
	Student& StudentPlus2(Student& s2)
	{
		this->age = this->age + s2.age;
		this->height = this->height + s2.height;
		// 注意 : 返回的是一个引用 , 就是返回自身对象变量
		// this 是指针 , *this 是指针指向的 自身对象
		return *this;
	}

	// 成员函数 转为 全局函数 , 多了一个参数 Student* pThis 作为第一个参数
	void print()
	{
		cout << "age = " << this->age << " , height = " << this->height << endl;
	}

public:
	int age;		// 年龄
	int height;		// 身高
};

// 将成员函数 void print() 
// 转为 全局函数
void Student_print(Student* pThis)
{
	cout << "age = " << pThis->age << " , height = " << pThis->height << endl;
}


// 全局函数中 , 将两个 Student 对象相加
// 引用的 等同于 一级指针 , Student 引用用法与 Student 对象用法相同
// 全局函数 转为 成员函数 , 少了一个参数
Student StudentPlus(Student& s1, Student& s2)
{
	Student s;
	s.age = s1.age + s2.age;
	s.height = s1.height + s2.height;
	return s;
}


int main() {
	
	// 调用有参构造函数 创建 Student 实例对象
	Student s(18, 180);
	// 打印对象情况
	s.print();

	// 调用有参构造函数 , 有参构造函数参数使用默认值
	Student s2;
	s2.print();

	// 调用全局函数, 将两个 Student 对象相加
	// 函数返回的 匿名对象 用于 s3 初始化 
	// 直接将匿名对象转为普通对象
	Student s3 = StudentPlus(s, s2);
	s3.print();

	// 调用成员函数, 将两个 Student 对象相加
	Student s4;
	// 函数返回的 匿名对象 用于 s4 赋值
	// 此处匿名对象 为 s4 赋值 , 赋值完毕后 匿名对象销毁
	s4 = s.StudentPlus(s2);
	s3.print();
	

    // 控制台暂停 , 按任意键继续向后执行
    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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

执行结果 :

执行 Student 的构造函数
age = 18 , height = 180
执行 Student 的构造函数
age = 1 , height = 1
执行 Student 的构造函数
执行 Student 的析构函数
age = 19 , height = 181
执行 Student 的构造函数
执行 Student 的构造函数
执行 Student 的析构函数
执行 Student 的析构函数
age = 19 , height = 181
请按任意键继续. . .
1
2
3
4
5
6
7
8
9
10
11
12
13