运算符重载器

概念：对已经存在的运算符进行一种全新的定义，赋予不同的数值操作

1. 加号运算符重载

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

分析问题

class Person{
public:
	int m_A;
	int m_B;
}

对于person类来说，我想进行一种全新的定义运算，不再说p1.m_A+p2.m_A=p3.m_A，而是p3=p1+p2，但是这么写编译器是无法读取的，只有人才可以看明白，因此我们要对传统的加法运算符进行一个改进，让编译器可以读取我们的指令要求，便有

class Person{
public:
	//必须添加无参构造函数
	Person() {};
	//初始化列表
	Person(int a,int b):m_A(a),m_B(b){};
	//加法运算符重载
	Person operator+(const Person& p){
		Person temp;
		temp.m_A=this->m_A+p.m_A;
		temp.m_B=this->m_B+p.m_B;
		return temp;//此时已经实现了p3=p1+p2的写法存在合理性
	}
	
public:
	int m_A;
	int m_B;
};

这时候编译器未报错，写个test函数去测试一下
void test(){
	Person p1(10,10);
	Person p2(1,3);
	Person p3=p1+p2;
	cout<<"p3.m_A="<<p3.m_A<<endl<<"p3.m_B="<<p3.m_B<<endl;
}

int main(){
	test();
	return 0;
}

运行结果为

由此可见加法运算符重载可以满足要求

2. 左移运算符重载

可以自定义输出类型

例如我们可以直接cout一个类对象p
但是这么写编译器无法识别，因为对象p有多个属性，编译器不知道输出哪一个属性，这时候便是左移运算符重载的运用可以巧妙化解

class Person{
public:
	//构造函数
	Person(){};
	//初始化列表
	Person(int a,int b):m_A(a),m_B(b){};
	
public:
	int m_A;
	int m_B;
};
//全局函数实现左移重载，
ostream& operator<<(ostream& out,Person p){
	cout<<"p.m_A="<<p.m_A<<endl<<"p.m_B="<<p.m_B<<endl;
	return out;
}
//测试函数
void test(){
	Person p(10,30);
	cout<<p<<endl;
}

运行结果如下
可见效果是成功的

3. 递增运算符重载

通过重载递增运算符，可以实现自己的整形数据

比如说我们要实现p.num++，但是想写成p++，这么写编译器不认识，那么我们只好进行递增运算符重载来实现我们的要求

class Person{
public:
	Person(){};
	Person(int num):m_Num(0){};
	
	//前置递增运算符重载
	Person& operator++(){
		m_Num++;
		return *this;
	}

	Person operator++(int){
		//保存当前的数值
		Person temp=*this;
		//当前数值自增
		m_Num++;
		//返回第一步保存的数值
		return temp;
	}
public:
	int m_Num;
};

于此同时，由于是cout<<p++<<endl这种写法，意味着我们也要使用左移运算符重载，写法同第二大点写法相同

ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}

进行数值测试环节
void test(){
	Person p;
	//前递增测试
	cout<<p<<endl;
	cout<<p++<<endl;
	cout<<p<<endl;
	//后递增测试环节
	Person q;
	cout<<q<<endl;
	cout<<++q<<endl;
	cout<<q<<endl;
}

测试结果如下

4. 赋值运算符重载

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person &p)
	{
        //先判断有无属性在堆区，如果有先释放再深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;
		
		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;
	}


	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int *m_Age;

};


void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);

	p3 = p2 = p1; //赋值操作

	cout << "p1的年龄为：" << *p1.m_Age << endl;

	cout << "p2的年龄为：" << *p2.m_Age << endl;

	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

int main() {

	test01();

	//int a = 10;
	//int b = 20;
	//int c = 30;

	//c = b = a;
	//cout << "a = " << a << endl;
	//cout << "b = " << b << endl;
	//cout << "c = " << c << endl;

	system("pause");

	return 0;
}

5. 关系运算符

class Person{
public:
	Person(string name){
		m_Name=name;
	}
	//布尔类型进行关系的正确判断
	bool operator==(Person p){
		if(this->m_Name==p.m_Name)
			return true;
		else
			return false;
	}

public:
	string m_Name;
};