4.5 运算符重载

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

4.5.1 加号运算符重载

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

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


class Person
{
public:
	//1.成员函数重载
	Person 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;
	}
	Person operator+(int a)
	{
		Person temp;
		temp.m_A = this->m_A + a;
		temp.m_B = this->m_B + a;
		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;
//}
void test01()
{
	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 p4 = p1 + 100;
	cout <<"p3.m_A="<< p3.m_A << endl;
	cout << "p3.m_B="<<p3.m_B << endl;
	cout << "p4.m_A=" << p4.m_A << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

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

总结2：不能滥用函数重载

4.5.2 左移运算符重载

#include <iostream>
using namespace std;

// 左运算符重载
class Person
{
	friend ostream & operator<<(ostream &cout, Person &p);
public:
	Person(int a,int b):m_A(a),m_B(b)
	{

	}

private:
	//成员函数实现左运算符重载  p.operator<<(p)   p.operator <<(cout)
	//void operator<<(Person &p )
	//成员函数无法实现左移运算符重载
	int m_A;
	int m_B;

};
//只能利用全局函数重载
ostream & operator<<(ostream &cout,Person &p)
{
	cout << "m_A=" << p.m_A << "  m_B=" << p.m_B;
	return cout;
}
void test01()
{
	Person p(10,10);
	/*p.m_A = 10;
	p.m_B = 10;*/
	cout << p<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

4.5.3 递增运算符重载

#include <iostream>
using namespace std;
//递增运算符重载
class MyInteger
{
	friend ostream & operator<<(ostream &cout, MyInteger m1);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符  返回引用是为了一直对一个数值进行操作
	MyInteger &operator ++()
	{
		//先进行++运算
		m_Num++;
		//再将自身返回
		return *this;
	}
	//重载后置++递增
	//int代表占位参数，用于区分前置和后置递增
	MyInteger operator++(int)
	{
		//先记录一下当时的结果
		MyInteger temp = *this;


		//然后做一下递增
		m_Num++;

		//最后将记录结果返回
		return temp;
	}
private:
	int m_Num;
};
ostream & operator<<(ostream &cout,MyInteger m1)
{
	cout << m1.m_Num ;
	return cout;
}
//void test01()
//{
//	MyInteger myint;
//	cout << ++myint << endl;
//	
//}
void test02()
{
	MyInteger myint2;
	cout << myint2++ << endl;
	cout << myint2 << endl;
}
int main()
{

	test02();
	system("pause");
	return 0;
}

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

4.5.4 赋值运算符重载

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

1. 默认构造函数（无参，函数体为空）
2. 默认析构函数（无参，函数体为空）
3. 默认拷贝构造函数。对属性值进行值拷贝
4. 赋值运算符 operator=，对属性进行值拷贝

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

#include <iostream>
using namespace std;
//赋值运算符重载
class Person
{
public :
	Person(int age)
	{
		m_Age = new int(age);//年龄创建在堆区

	}
	
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	//重载 赋值运算符
	Person& operator =(Person &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 test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(19);
	p3= p2 = p1;//赋值操作
	cout << "p1的年龄为" <<* p1.m_Age << endl;
	cout << "p2的年龄为" << *p2.m_Age << endl;
	cout << "p3的年龄为" << *p3.m_Age << endl;
}
int main()
{

	test01();
	system("pause");
	return 0;
}

4.5.5 关系运算符重载

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

#include <iostream>
using namespace std;
//关系运算符重载

class Person
{
public:
	Person(string name, int age)
	{
		m_Age = age;
		m_Name = name;
	}
	bool operator==(Person &p)
	{
		if (this->m_Age == p.m_Age&&this->m_Name == p.m_Name)
			return true;
		else return false;
	}

	string m_Name;
	int m_Age;
};
void test01()
{
	Person p1("Tom", 11);
	Person p2("Tom", 11);
	if (p1 == p2)
	{
		cout << "p1和p2一致" << endl;
	}
	else cout << "p1和p2不一致" << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

4.5.6函数调用运算符重载（仿函数）

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

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

class MyPrint
{
public:
	void operator()(string test)
	{
		cout << test << endl;
	}
};
void test01()
{
	MyPrint myPrint;
	myPrint("hello world");//由于使用起来非常像函数调用，所以称为仿函数

}
//仿函数非常灵活 没有固定写法
class Myadd
{
public:
	int operator()(int num1,int num2)
	{
		return num1 + num2;
	}

};
void test02()
{
	Myadd myadd;
	int ref=myadd(100, 200);
	cout << ref << endl;
	//匿名函数对象
	cout << Myadd()(100, 100) << endl;
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}