4.5 运算符重载

拼命奔跑

已于 2023-06-13 15:28:20 修改

阅读量48

点赞数

分类专栏： C++核心编程文章标签： c++ 开发语言

于 2023-06-09 22:15:03 首次发布

本文链接：https://blog.csdn.net/qq_43593204/article/details/131135254

版权

C++核心编程专栏收录该内容

5 篇文章 0 订阅

订阅专栏

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

4.5.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算

#include<iostream>
using namespace std;
//加号运算符重载：
class Person112 {

public:
	//1.通过成员函数实现重载+号：
	//Person112 operator+(Person112& p) {
	//
	//
	//	Person112 temp;
	//	temp.m_A = this->m_A + p.m_A;
	//	temp.m_B = this->m_B + p.m_B;
	//	return temp;
	//}
	int m_A;
	int m_B;

};
//2.通过全局函数重载+号；
Person112 operator+(Person112 p1,Person112 p2) {
	Person112 temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;

}
//函数重载的版本：
Person112 operator+(Person112 p1,int i) {
	Person112 temp;
	temp.m_A = p1.m_A + i;
	temp.m_B = p1.m_B + i;
	return temp;

}
void test112() {

	Person112 p1;
	p1.m_A = 10;
	p1.m_B = 10;	
	Person112 p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//成员函数调用的本质：
	//Person112 p3 = p1.operator+(p2);
	//全局函数调用的本质：
	//Person112 p3 = operator+(p1, p2);
	Person112 p3 = p1 +p2;
	//运算符重载也可以发生函数重载； 
	Person112 p4 = p1 + 5;
	cout << "p4.m_A = " << p3.m_A << endl;
	cout << "p4.m_B = " << p3.m_B << endl;
}
int main() {
	test112();
	system("pause");
	return 0;
}

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的

总结2：不要滥用运算符重载

4.5.2 左移运算符重载

作用：可以输出自定义数据类型

#include<iostream>
using namespace std;
class Person113 {
	friend ostream& operator<<(ostream& cout, Person113& p);
	friend void test113();
private:
	//利用成员函数重载左移运算符：
	int m_A;
	int m_B;
	//利用成员函数重载 左移运算符  p.operator<<(cout)  简化版本  p<< cout
	//void operator<<(cout) {
	//	
	//
	//}

};
//只能利用全局函数重载左移运算符
ostream& operator<<(ostream& cout, Person113& p) {//本质  operator<<(cout,p)  简化：cout<<p

	cout << "m_A=" << p.m_A << "  m_B" << p.m_B;
	return cout;
}
void test113(){

	Person113 p;
	p.m_A = 10;
	p.m_B = 10;
	//cout << "p.m_A= " << p.m_A << endl;
	//cout << "p.m_B= " << p.m_B << endl;
	cout << p << endl;;
}

int main113() {
	test113();
	system("pause");
	return 0;
}

总结：重载左移运算符配合友元可以实现输出自定义数据类型

4.5.3 递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

#include<iostream>
using namespace std;
//重载递增运算符：
//自定义的整形：
class MyInteger {
	//让全局函数做友元：
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger() {
		this->m_Num = 0;
	}
	//重载前置++运算符：
	//这里MyInteger返回引用是为了一直对一个数据进行递增操作
	MyInteger& operator++() {
	
		//先进行++运算：
		m_Num++;
		//再将自身做返回：
		return *this;

	}
	//重载后置++运算符：(后置递增先输出表达式，再进行++操作)
	//MyInteger operator++(int)  int代表占位参数，可以用于区分前置和后置递增；
	MyInteger operator++(int) {
		//先记录当时的结果：
		MyInteger temp = *this;
		//后  递增
		m_Num++;
		//最后将记录结果作为返回：
		return temp;
	}
private:
	int m_Num;
};
//重载左移运算符：
ostream& operator<<(ostream& cout,MyInteger myint) {
	cout <<"m_Num= " << myint.m_Num << endl;
	return cout;
}
void test114() {
	MyInteger myint;
	cout << (myint++);
	cout << (myint);
}
int main114() {
	test114();
	system("pause");
	return 0;
}

总结：前置递增返回引用，后置递增返回值

4.5.4 赋值运算符重载

c++编译器至少给一个类添加4个函数

默认构造函数(无参，函数体为空)
默认析构函数(无参，函数体为空)
默认拷贝构造函数，对属性进行值拷贝
赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

#include<iostream>
using namespace std;
//赋值运算符重载：
class Person115 {

public:
	Person115(int age) {
	
		//将数据开辟到堆区
		m_Age = new int(age);
	
	}
	~Person115() {
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}
	
	}
	//重载赋值运算符
	Person115& operator=(Person115 &p) {
		//编译器提供的是浅拷贝
		//m_Age = p.m_Age
		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝；
		if (m_Age != NULL) {
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		//返回对象本身
		return *this;
	}
	int* m_Age;
};
void test115() {

	Person115 p1(18);
	Person115 p2(20);
	Person115 p3(22);
	p3 = p2 = p1;
	cout << "p1的m_Age =  " << *(p1.m_Age)<<endl;
	cout << "p2的m_Age =  " << *(p2.m_Age)<<endl;
	cout << "p3的m_Age =  " << *(p3.m_Age)<<endl;
}
int main115(){
	test115();
	system("pause");
	return 0;
}

4.5.5 关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

#include<iostream>
using namespace std;
//重载关系运算符：
class Person116 {
public:
	bool operator==(Person116 &p) {
		if(p.m_Age == this->m_Age && p.m_Name == this->m_Name) {
		
			return true;
		}
		else {
		
			return false;
		}
	
	}
	bool operator!=(Person116 &p) {
		if(p.m_Age != this->m_Age || p.m_Name != this->m_Name) {
		
			return true;
		}
		else {
		
			return false;
		}
	}
	Person116(string name, int age) {
	
		m_Name = name;
		m_Age = age;
	}
	string m_Name;
	int m_Age;
};
void test116() {
	Person116 p1("Tom", 20);
	Person116 p2("Tom", 20);
	if (p1 == p2) {
		cout << "p1与p2相等！\n";
	}
	else {
	
		cout << "p1与p2不相等！\n";
	}
	if (p1 != p2) {
	
	
		cout << "p1与p2不相等！\n";
	}
	else {
	
		cout << "p1与p2相等！\n";
	}
}
int main116() {
	test116();
	system("pause");
	return 0;

}

4.5.6 函数调用运算符重载

函数调用运算符 () 也可以重载
由于重载后使用的方式非常像函数的调用，因此称为仿函数
仿函数没有固定写法，非常灵活

#include<iostream>
using namespace std;
//函数调用运算符重载：
class MyPrint {
public:
	//重载函数调用运算符：
	void operator()(string str) {
		cout << str << endl;
	}

};
void test117() {

	MyPrint myPrint;
	myPrint("hello world");//由于使用起来非常类似于函数调用，因此成为仿函数；
}
//仿函数非常灵活，没有固定的写法
//加法类：
class MyAdd {

public:
	int operator() (int num1, int num2 ) {
	
		return num1 + num2;
	}

};
void test1171() {
	MyAdd myAdd;
	int ret = myAdd(100, 100);
	cout << ret << endl;
}
int main() {
	test1171();
	system("pause");
	return 0;
}