【C++ 语言】面向对象 ( 函数重载 | 运算符重载 | 运算符重载两种定义方式 | 拷贝构造方法 | RVO 优化 | NRVO 优化 )

文章目录

• • • • 函数重载
      • 运算符重载 ( 类内部定义云算符重载 )
      • 运算符重载 ( 类外部定义运算符重载 )
      • 可重载的运算符
      • 拷贝构造方法
      • 编译器优化 ( RVO 优化 | NRVO 优化 )
      • 完整代码示例

函数重载

---

C 中如果出现两个同名的函数 , 就会出现冲突 , 编译时会报错 ;

C 中是允许出现两个同名的函数 , 这里函数的参数个数 , 顺序 , 类型 , 返回值类型 至少有一种是不同的 ; 如下面两个函数就是参数个数不同 , 前者有 0 个参数 , 后者有 1 个参数 ;

代码语言：javascript复制

void OOTest() {

	//在方法中直接声明 Student 对象, student 对象处于栈内存中 , 
	//其作用域仅限于 OOTest 函数 , 方法执行完就会清理掉
	Student student(18, 1);
}

void OOTest(int i) {

	//在方法中直接声明 Student 对象, student 对象处于栈内存中 , 
	//其作用域仅限于 OOTest 函数 , 方法执行完就会清理掉
	Student student(18, 1);
}

运算符重载 ( 类内部定义云算符重载 )

---

C 中允许重新定义运算符的行为 , 如常用的加减成熟运算符 , 都可以进行重载操作 ; 可以自定义运算符的操作 ;

类内部定义云算符重载 , 格式为 “返回值类型 ( 类名称 ) operator运算符符号 ( const 参数类型名称& 参数变量名称 ) { 方法内容 }” , 参数的类型是引用类型 ;

加法运算符重载 , 对 “ ” 号运算符进行重载 , 其作用是让两个 Operator 的 number 成员变量相加 , 然后返回一个新的 Operator 对象 , 其 number 成员变量值是两个 Operator 的 number 成员变量值之和 ;

代码语言：javascript复制

//运算符重载 , " " 号运算符进行重载 , 
//其作用是让两个 Operator 的 number 成员变量相加
//运算符重载的本质是按照一定格式定义一个方法
//这个定义的方法中包含运算符 , 除运算符之外的其它符号可以省略简写
public:
	Operator operator (const Operator& o1) {
		//  运算符的作用是 两个 Operator 对象, 进行操作得到第三个 Operator 对象
		//第三个 Operator 对象的 number 变量 , 是前两个 Operator 对象之和
		Operator o2;
		o2.number = this->number   o1.number;
		return o2;
	}

运算符重载本质 , 其本质是定义一个方法 , 该方法有固定的格式去定义 , 调用该方法的时候 , 可以使用函数形式调用 , 也可以使用运算符进行运算 , 其 本质还是类的函数调用 ;

重载运算符完整调用 , 即调用上面定义的整个 operator 方法 , 这是采用正式的的函数调用方式 ;

代码语言：javascript复制

	//这是运算符重载的完整写法 , 
	//其中的 .operator 和之后的 () 可以省略变成下面的简化写法
	Operator o3 = o1.operator (o2);
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载完整写法结果 : " << o3.number << endl;

运算符重载简化调用 ( 推荐 ) , 这种调用就是运算符运算 , 写法就是 “对象1 运算符 对象2” 结果得到的是 对象3 ; 这种调用方法与上面的区别是省略了调用时的 .operator 和参数外面的括号 () ;

代码语言：javascript复制

	//  是在 Operator 类中自定义的运算符重载 
	//其作用是返回一个对象 , 其number成员变量值是 o1 和 o2 中number成员变量之和
	Operator o4 = o1   o2;
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载简化写法结果 : " << o4.number << endl;

运算符重载调用完整代码 :

代码语言：javascript复制

	//运算符重载
	//注意这里的 Operator 对象 o1 和 o2 都在栈内存中
	Operator o1;
	o1.number = 80;

	Operator o2;
	o2.number = 10;

	//运算符重载完整写法

	//这是运算符重载的完整写法 , 
	//其中的 .operator 和之后的 () 可以省略变成下面的简化写法
	Operator o3 = o1.operator (o2);
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载完整写法结果 : " << o3.number << endl;

	//运算符重载简化写法

	//  是在 Operator 类中自定义的运算符重载 
	//其作用是返回一个对象 , 其number成员变量值是 o1 和 o2 中number成员变量之和
	Operator o4 = o1   o2;
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载简化写法结果 : " << o4.number << endl;

代码执行结果 :

代码语言：javascript复制

内部定义的运算符重载完整写法结果 : 90
内部定义的运算符重载简化写法结果 : 90

运算符重载 ( 类外部定义运算符重载 )

---

类外部定义运算符重载 , 运算符重载也可以定义在类的外部 , 可以是任意包含类头文件的代码中 , 其定义方式与定义在类的内部对比 , 只有参数是有区别的 , 在类外部定义 , 其中需要两个参数 , 分别代表运算符运算的两个参数 ;

乘法运算符重载 , 对 “*” 号运算符进行重载 , 其作用是让两个 Operator 的 number 成员变量相乘 , 然后返回一个新的 Operator 对象 , 其 number 成员变量值是两个 Operator 的 number 成员变量值之积 ;

代码语言：javascript复制

//类外部定义云算符重载
//	使用该重载云算符时 , 将两个对象相乘 , 获得的第三个对象 , 
//	该对象的 number 成员变量值 , 是 前两个对象的 number 对象的乘积 
Operator operator*(const Operator& o1, const Operator& o2) {
	//  运算符的作用是 两个 Operator 对象, 进行操作得到第三个 Operator 对象
	//第三个 Operator 对象的 number 变量 , 是前两个 Operator 对象之和
	Operator o3;
	o3.number = o1.number * o2.number;
	return o3;
}

已重载的运算符调用 , 可以直接调用运算符重载的 operator*() 方法 , 也可以直接使用运算符 , o1 * o2 ;

代码语言：javascript复制

	//运算符重载
	//注意这里的 Operator 对象 o1 和 o2 都在栈内存中
	Operator o1;
	o1.number = 80;

	Operator o2;
	o2.number = 10;

	//这是运算符重载的完整写法 , 
	//其中的 .operator 和之后的 () 可以省略变成下面的简化写法
	Operator o5 = operator*(o1, o2);
	//打印 o5 中的 number 变量值
	cout << "外部定义的运算符重载完整写法结果 : " << o5.number << endl;

	//运算符重载简化写法

	//  是在 Operator 类中自定义的运算符重载 
	//其作用是返回一个对象 , 其number成员变量值是 o1 和 o2 中number成员变量之积
	Operator o6 = o1 * o2;
	//打印 o6 中的 number 变量值
	cout << "外部定义的运算符重载简化写法结果 : " << o6.number << endl;

代码执行结果

代码语言：javascript复制

外部定义的运算符重载完整写法结果 : 800
外部定义的运算符重载简化写法结果 : 800

可重载的运算符

---

这里列举一下可重载的运算符

运算符的类型	列举该类型下的所有可重载的运算符
比较运算符 ( 双目运算符 )	== (等于) , != (不等于) , < (小于) , > (大于 ) , <= ( 小于等于 ) , >= ( 大于等于 )
逻辑运算符 ( 双目运算符 )	&& ( 与 ) , || ( 或 ) , ! ( 非 )
数值计算运算符 ( 双目运算符 )	( 加 ) , - ( 减 ) , * ( 乘 ) , / ( 除 )
位运算符 ( 双目运算符 )	| ( 按位或运算 ) , & ( 按位与运算 ) , ~ ( 按位取反运算 ) , ^ ( 按位异或运算 ) , << ( 左移运算 ) , >> ( 右移运算 )
赋值运算符 ( 双目运算符 )	= ( 等于 ) , = ( 加等于 ) , -= ( 减等于 ) , *= ( 乘等于 ) , /= ( 除等于 ) , % = ( 模等于 ) , &= ( 按位与等于 ) , |= ( 按位或等于 ) , ^= ( 按位异或等于 ) , <<= ( 左移等于 ) , >>= ( 右移等于 )
单目运算符	( 正数符号 ) , - ( 负数符号 ) , * ( 指针类型 ) , & ( 取地址符 ) , ( 自增运算符 ) , – ( 自减运算符 )
内存申请释放运算符	new ( 新建对象 ) , new[] ( 新建数组对象 ) , delete ( 释放对象 ) , delete[] ( 释放数组对象 )
函数调用运算符	()
成员访问运算符	->
下标运算符	[]
逗号运算符	,

拷贝构造方法

---

分析下面方法中的栈内存 ;

代码语言：javascript复制

//运算符重载 , " " 号运算符进行重载 , 
//	其作用是让两个 Operator 的 number 成员变量相加
//	运算符重载的本质是按照一定格式定义一个方法
//	这个定义的方法中包含运算符 , 除运算符之外的其它符号可以省略简写
public:
	Operator operator (const Operator& o1) {
		//  运算符的作用是 两个 Operator 对象, 进行操作得到第三个 Operator 对象
		//第三个 Operator 对象的 number 变量 , 是前两个 Operator 对象之和
		Operator o2;
		o2.number = this->number   o1.number;

		//o2 对象是存在栈内存中 , 返回 o2 操作出现了拷贝操作
		//o2 会调用拷贝构造方法 , 拷贝到一个临时对象中 
		//如果返回值有接收的对象 , 那么又调用拷贝构造方法 , 
		//	将这个临时对象又会被拷贝给接收对象
		return o2;
	}

};

分析上述方法中的栈内存对象 , 在运算符重载的方法中 , 涉及到了栈内存对象的生命周期问题 , Operator o2; 语句在方法的栈内存中创建了一个 Operator 对象 o2 , 该对象的生命周期只限于整个方法体 , 方法执行完毕后 , 栈内存中的该对象就要被释放掉 ;

但是 该对象需要被返回 , 并且在方法调用完成之后 , 还要 赋值给另外一个对象 , 现在讨论一下其中的运行机制 ;

从 return o2; 开始分析 , 返回 o2 对象 , 系统会将栈内存中的 o2 对象 拷贝到一个临时对象中 , 这里调用了一次拷贝构造方法 ; 然后将临时对象又赋值给了返回值接收的对象 , 此处又调用了一次拷贝构造方法 ; 整个操作在理论上调用了两次拷贝构造方法 ;

拷贝构造方法实现 , 拷贝构造方法与构造方法的区别是 , 其需要传入一个引用类型 ( 类名& 变量名 ) 的参数 , 如下示例中实现了默认的构造方法 , 同时实现了拷贝构造方法 , 在发生该对象的拷贝操作时 , 会调用该方法 , 打印相应的数据 , 这样我们就能测试追踪对象的拷贝操作了 ;

代码语言：javascript复制

	//默认的构造方法
	Operator() {}

	//拷贝构造方法, 每次拷贝都会调用该构造方法
	//	以此来验证栈内存中 返回 栈内存中的对象 , 
	//	将栈内存对象拷贝到临时对象中
	//	在方法调用处 , 又将临时对象拷贝给了接收返回值的对象
	Operator(Operator& o) {
		this->number = o.number;
		cout << "Operator 对象执行拷贝操作" << endl;
	}

下面运行如下重载云算符调用的方法 , 分析其构造方法调用次数 , 下面是要运行的代码 :

代码语言：javascript复制

	//  是在 Operator 类中自定义的运算符重载 
	//其作用是返回一个对象 , 其number成员变量值是 o1 和 o2 中number成员变量之和
	Operator o4 = o1   o2;
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载简化写法结果 : " << o4.number << endl;

运行结果如下 , 此处发现拷贝构造方法只调用了一次 , 理论上其应该调用两次 , 这就涉及到了编译器的 RVO 优化 ;

代码语言：javascript复制

Operator 对象执行拷贝操作
内部定义的运算符重载完整写法结果 : 90

编译器优化 ( RVO 优化 | NRVO 优化 )

---

理论上拷贝构造方法是要执行两次的 , 在 operator 方法中 , 第一次将 o2 对象拷贝给临时对象 , 第二次将 临时对象拷贝给接收 operator 方法返回值的对象 ;

但是在 Visual Studio 中编译后执行结果 只拷贝了一次, 拷贝构造函数只调用了一次, 这是由于编译器优化的原因 ;

• Windows 上 Visual Studio 的 C 编译器是 cl.exe
• MAC 上 Xcode 的 C 编译器是 GNU g

rvo 优化 , 在 VS 中, cl 编译器在 debug 模式下,会执行 rvo (return value) 优化 , 减少了1次拷贝和析构的操作 ;

nrvo 优化 , 在 release 模式下 , 会执行 nrvo 优化 , 会进行 0 次拷贝 , 减少了 2 次拷贝和析构的操作 , 其优化方式是改写方法 , 直接将接收对象放入参数 , 在方法中就将返回对象赋值给接收对象了 ;

完整代码示例

---

操作符重载类代码 :

代码语言：javascript复制

#pragma once

using namespace std;

class Operator {

public : 
	int number;
	//默认的构造方法
	Operator() {}

	//拷贝构造方法, 每次拷贝都会调用该构造方法
	//	以此来验证栈内存中 返回 栈内存中的对象 , 
	//	将栈内存对象拷贝到临时对象中
	//	在方法调用处 , 又将临时对象拷贝给了接收返回值的对象
	Operator(Operator& o) {
		this->number = o.number;
		cout << "Operator 对象执行拷贝操作" << endl;
	}

	//这里针对拷贝操作进行说明 : rvo 优化 , nrvo 优化
	//理论上 拷贝 构造方法 是要执行两次的 , 在 operator  方法中 , 
	//	第一次将 o2 对象拷贝给临时对象
	//	第二次将 临时对象拷贝给接收 operator  方法返回值的对象

	//但是在 Visual Studio 中编译后执行结果只拷贝了一次, 这是由于编译器优化的原因.
	//	Windows 上 Visual Studio 的 C   编译器是 cl.exe
	//	MAC 上 Xcode 的 C   编译器是 GNU g  
	
	//在 VS 中, cl 编译器在 debug 模式下,会执行 rvo (return value) 优化
	//	rvo 优化 , 减少了1次拷贝和析构的操作
	
	//在 release 模式下 , 会执行 nrvo 优化
	//	nrvo 优化 , 会进行 0 次拷贝 , 减少了 2 次拷贝和析构的操作
	//	其优化方式是改写方法 , 直接将接收对象放入参数 , 在方法中就将返回对象赋值给接收对象了

	//这两种优化都是编译器针对返回值进行的优化





//类内部定义云算符重载

//运算符重载 , " " 号运算符进行重载 , 
//	其作用是让两个 Operator 的 number 成员变量相加
//	运算符重载的本质是按照一定格式定义一个方法
//	这个定义的方法中包含运算符 , 除运算符之外的其它符号可以省略简写
public:
	Operator operator (const Operator& o1) {
		//  运算符的作用是 两个 Operator 对象, 进行操作得到第三个 Operator 对象
		//第三个 Operator 对象的 number 变量 , 是前两个 Operator 对象之和
		Operator o2;
		o2.number = this->number   o1.number;

		//o2 对象是存在栈内存中 , 返回 o2 操作出现了拷贝操作
		//o2 会调用拷贝构造方法 , 拷贝到一个临时对象中 
		//如果返回值有接收的对象 , 那么又调用拷贝构造方法 , 
		//	将这个临时对象又会被拷贝给接收对象
		return o2;
	}

};


//类外部定义云算符重载
//	使用该重载云算符时 , 将两个对象相乘 , 获得的第三个对象 , 
//	该对象的 number 成员变量值 , 是 前两个对象的 number 对象的乘积 
Operator operator*(const Operator& o1, const Operator& o2) {
	//  运算符的作用是 两个 Operator 对象, 进行操作得到第三个 Operator 对象
	//第三个 Operator 对象的 number 变量 , 是前两个 Operator 对象之和
	Operator o3;
	o3.number = o1.number * o2.number;

	//o2 对象是存在栈内存中 , 返回 o2 操作出现了拷贝操作
	//o2 会调用拷贝构造方法 , 拷贝到一个临时对象中 
	//如果返回值有接收的对象 , 那么又调用拷贝构造方法 , 
	//	将这个临时对象又会被拷贝给接收对象
	return o3;
}

main 函数代码 :

代码语言：javascript复制

// 003_Object_Oriented.cpp: 定义应用程序的入口点。
//

#include "003_Object_Oriented.h"

//引用 Student 类声明的头文件
#include "Student.h"

#include "Instance.h"

#include "Operator.h"

using namespace std;

void OOTest() {

	//在方法中直接声明 Student 对象, student 对象处于栈内存中 , 
	//其作用域仅限于 OOTest 函数 , 方法执行完就会清理掉
	Student student(18, 1);
}

void OOTest(int i) {

	//在方法中直接声明 Student 对象, student 对象处于栈内存中 , 
	//其作用域仅限于 OOTest 函数 , 方法执行完就会清理掉
	Student student(18, 1);
}

//友元函数实现 , 在类的外部修改类中的私有成员变量 age
void changeAge(Student* student){
	student->age = 88;
}

int main()
{
	cout << "Hello Student" << endl;

	OOTest();
	//在上面的 OOTest() 方法中的栈内存中创建了 Student 对象
	//当 OOTest() 方法执行完毕后 , 就会释放掉 Student 对象

	//使用 new 创建对象 , 注意该对象在堆内存中创建的 
	//用完之后需要使用 delete 释放该对象
	Student* student = new Student(18, 1);

	//调用友元函数, 修改 student 对象类私有变量 age 的值
	changeAge(student);

	//调用 getAge() 常量函数获取 student 对象的 age 成员变量值
	//并将该值打印出来
	cout<< "age : " << student->getAge() <<endl;

	//释放使用 new 申请的堆内存中的内存
	delete student;

	//创建单例对象
	Instance* instance = Instance::getInstance();
	//打印单例对象中的变量值
	cout << "单例 instance->number : " << instance->number << endl;

	//释放单例类
	delete instance;


	//运算符重载
	//注意这里的 Operator 对象 o1 和 o2 都在栈内存中
	Operator o1;
	o1.number = 80;

	Operator o2;
	o2.number = 10;

	//运算符重载完整写法

	//这是运算符重载的完整写法 , 
	//其中的 .operator 和之后的 () 可以省略变成下面的简化写法
	Operator o3 = o1.operator (o2);
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载完整写法结果 : " << o3.number << endl;

	//运算符重载简化写法

	//  是在 Operator 类中自定义的运算符重载 
	//其作用是返回一个对象 , 其number成员变量值是 o1 和 o2 中number成员变量之和
	Operator o4 = o1   o2;
	//打印 o3 中的 number 变量值
	cout << "内部定义的运算符重载简化写法结果 : " << o4.number << endl;

	//这里对栈内存说明一下
	//在运算符重载实现的方法中 , 创建了 Operator 对象, 
	//这个对象在方法返回时先拷贝给了一个临时对象
	//这个临时对象是一个不可见的匿名对象 , 对外透明的
	//返回该临时对象后 , 发现有 Operator o3 变量接收该对象
	//再次将临时对象拷贝给 o3 对象 

	//测试类外部的运算符重载

	//运算符重载完整写法

	//这是运算符重载的完整写法 , 
	//其中的 .operator 和之后的 () 可以省略变成下面的简化写法
	Operator o5 = operator*(o1, o2);
	//打印 o5 中的 number 变量值
	cout << "外部定义的运算符重载完整写法结果 : " << o5.number << endl;

	//运算符重载简化写法

	//  是在 Operator 类中自定义的运算符重载 
	//其作用是返回一个对象 , 其number成员变量值是 o1 和 o2 中number成员变量之积
	Operator o6 = o1 * o2;
	//打印 o6 中的 number 变量值
	cout << "外部定义的运算符重载简化写法结果 : " << o6.number << endl;

	return 0;
}

运行结果 :

代码语言：javascript复制

Hello Student
Student() 构造方法
~Student() 析构方法
Student() 构造方法
age : 88
~Student() 析构方法
单例 instance->number : 888
Operator 对象执行拷贝操作
内部定义的运算符重载完整写法结果 : 90
Operator 对象执行拷贝操作
内部定义的运算符重载简化写法结果 : 90
Operator 对象执行拷贝操作
外部定义的运算符重载完整写法结果 : 800
Operator 对象执行拷贝操作
外部定义的运算符重载简化写法结果 : 800

编译器 对象 函数 内存 优化

0 人点赞