C++学习类和对象（4）——C++运算符重载

---

C++相关笔记，学习视频：b站黑马程序员https://www.bilibili.com/video/BV1et411b73Z/?spm_id_from=333.999.0.0

前言

提示：这里可以添加本文要记录的大概内容：

4.1 加号运算符重载

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

对于内置的数据类型，编译器知道如何进行运算
1、对于内置的数据类型表达式的运算符不可能改变
2、不要滥用运算符重载

通过成员函数重载+号

通过全局函数重载+

class Person
{
public:
	//1、成员函数重载+号
	Peroson operator+(Person &p)
	{
		Person 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、全局函数重载+号
Person operator+(Person &p1,Person &p2)
{
	Person temp;
	temp.m_a=p1.m_a+p2.m_a;
	temp.m_b=p1.m_b+p2.m_b;
	return temp;
}

//函数重载的版本
Person operator+(Person &p1,int num)
{
	Person temp;
	temp.m_a=p1.m_a+num;
	temp.m_b=p1.m_b+num;
	return temp;
}

void test1()
{
	Person p1;
	p1.m_a=10;
	p1.m_b=10;
	Person p2;
	p2.m_a=10;
	p2.m_b=10;

	//成员函数重载本质调用
	//本质上是Person p3=p1.operator+(p2);
	Person p3=p1+p2;

		//全局函数重载本质调用
		//本质上是Person p3=operator+(p1,p2);
		Person p3=p1+p2;
		
		//运算符重载 也可以发生函数重载
		Person p4=p1+100;//person+int
}

---

4.2 左移运算符重载

只能利用全局函数重载<<运算符
cout标准的输出流对象ostream 全局只有一个
ostream &cout引用的本质是起一个别名，所以也可以用ostream &out等来替代

//左移运算符重载
class person
{
public:

//利用成员函数重载左移运算符，p.operator<<(cout) 简化版本p<<cout
//不会利用成员函数重载<<运算符，因为无法实现cout在左侧
//void operator<<(cout)
	int m_a;
	int m_b;
};
//只能利用全局函数重载<<运算符
//cout标准的输出流对象ostream 全局只有一个
//ostream &cout引用的本质是起一个别名，所以也可以用ostream &out等来替代
ostream & operator<<(ostream &cout,person &p)		//本质	operator<<(cout,p)  简化 cout<<p
{
	cout<<"m_a="<<p.m_a<<"m_b="<<p.m_b;
	return cout;
}

void test1()
{
	person p;
	p.m_a=10;
	p.m_b=10;
	cout<<p <<"hello world"<<endl;
//如果全局函数 用的是void返回 则只能有cout<<p，之后不可加其余内容
	
}
int main()
{
	test1();
	return 0;
}

//如果将m_a,m_b设置为私有的，则需要利用友元的知识进行
class person
{
	friend ostream & operator<<(ostream &cout,person &p);
public:
	person(int a,int b)
	{
			m_a=a;
			m_b=b;
	}		
private:
	int m_a;
	int m_b;
};
ostream & operator<<(ostream &cout,person &p)		//本质	operator<<(cout,p)  简化 cout<<p
{
	cout<<"m_a="<<p.m_a<<"m_b="<<p.m_b;
	return cout;
}

void test1()
{
	person p(10,10);
	cout<<p <<"hello world"<<endl;
}
int main()
{
	test1();
	return 0;
}

---

4.3 递增运算符重载（++）

作用：通过重载递增运算符，实现自己的整型数据
++a，先+1在输出a
a++，先输出再+1

区分前置递增和后置递增：
前置递增：返回引用。myinteger& opreator++()
后置递增：返回值，且使用int占位参数区分。myinteger operate++(int)

//重载递增运算符
//自定义整型
class myinteger
{
	friend ostream &  operator<<(ostream &cout,myinteger myint);
public:
	myinteger()
	{
		m_num=0;
	}
	//重载前置++运算符
	//此处返回的是引用&，而不是值，因为++操作始终对同一个对象进行的，
	myinteger& opreator++()
	{
		//先进行++运算
		m_num++;
		//再将自身作返回
		return *this;
	}
	//重载后置++运算符,后置返回的是值，不是引用
	//如果返回引用，相当于返回temp，而局部对象temp当前函数执行完后就被释放
	myinteger operate++(int)		//int代表占位参数，可以用于区分前置和后置递增，使用int代表后置递增、后置···
	{
		//先返回，再进行++运算，但先写return会报错
		//所以
		//先记录当时结果
		myinteger temp=*this;
		//后递增
		m_num++;
		//最后将记录结果做返回
		return temp;
	}
private:
	int m_num;
};

//重载<<运算符
ostream &  operator<<(ostream &cout,myinteger myint)
{
	cout<<myint.m_num;
	return cout;
}
void test1()
{
	myinteger myint;
	cout<<++myint<<endl;
}
void test2()
{
	myinteger myint;
	cout<<myint++<<endl;
	cout<<myint<<endl;
}
int main()
{
	test1();
	return 0;
}

---

4.4 赋值运算符重载

C++编译器至少给一个类添加4个函数
1、默认构造函数（无参，函数体为空）
2、默认析构函数（无参，函数体为空）
3、默认拷贝构造函数，对属性进行值拷贝
4、赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题
编译器提供的是浅拷贝，但如果数据在堆区就不行了，所以赋值运算符重载，可以深拷贝

class person
{
public:
	person(int age)
	{
		//将数据开辟到堆区
		//堆区特点：由程序员手动开辟，手动释放
		m_age=new int(age);
	}
	提供一个析构函数，将堆区数据释放
	~person()
	{
		if(m_age!=NULL)
		{
			delete m_age; 
			m_age=NULL;
		}
	}
//重载 赋值运算符
	person& operator=(peron &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 test1()
{
	person p1(18);
	person p2(20);
	p2=p1;//赋值操作，值拷贝，只是简单的拷贝了p1的内容，此时如果单纯用析构函数，会出现堆区重复释放导致程序崩溃
	//解决：利用深拷贝解决浅拷贝的问题
	cout<<"p1的年龄："<<*p1.m_age<<endl;
	cout<<"p2的年龄："<<*p2.m_age<<endl;
}

void test1()
{
	person p1(18);
	person p2(20);
	person p3(30);
	p3=p2=p1;    //❌，因为p2调用函数之后，返回值是void，改为person&
	cout<<"p1的年龄："<<*p1.m_age<<endl;
	cout<<"p2的年龄："<<*p2.m_age<<endl;
}

4.5 关系运算符重载

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

class person
{
public:
	person(string name,int age)//赋初值
	{
		m_name=name;
		m_age=age;
	}
	//重载关系运算符==
	 bool operator==(person &p)
	 {
		if(this->m_name==p.m_name && this->m_age==p.m_age)
		{
			return true;
		}
		return false;
	}
	string m_name;
	int m_age;
};
void test1()
{

	person p1("tom",18);
	person p2("tom",18);
	if(p1==p2)
	{
		cout<<"p1 和p2是相等的"<<endl;
	}
	else
	{
		cout<<"p1和p2是不相等的"<<endl;
	}
}

4.6 函数调用运算符重载

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

#include<iostream>
using namespace std;
#incude<string>
//函数调用运算符重载

class Myprint
{
public:
	//1、重载函数调用运算符
	void operator()(string test)	//重载
	{
		cout<<test<<endl;
	}
};
void Myprint01(string test)			//函数
{
	cout<<test<<endl;
}
void test1()
{
	Myprint myprint;
	myprint("hello world");			//相当于此处的hello world传给了string test，通过void operator()内的函数直接打印输出，，使用重载后的（）  2、类似函数的调用
	Myprint02("hello world");//调用构造的函数
}

//3、仿函数非常灵活，没有固定的写法,按照需求写对应的仿函数
class Myadd
{
public:
	int operator()(int num1,int num2)
	{
		return num1+num2;
	}
};
void test02()
{
	//创建对象
	Myadd myadd; 
	int ret=myadd(100,100);
	cout<<"ret="<<ret<<endl;
	
	//匿名函数对象 类型＋()，如Myadd()创建出一个匿名对象，执行完立即释放
	cout<<Myadd()(100,100)<<endl;
}
int main(){
	test1() 
	system("pause");
	return 0;
}