运算符重载

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

加号运算符重载

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

#include<iostream>
using namespace std;
class Person
{
private:
	int m_A;
	int m_B;
public:
	Person(int A, int B)
	{
		m_A = A;
		m_B = B;
	}
	Person()
	{

	}
	//成员函数完成加号运算符重载
	/*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;
	}*/
	void print()
	{
		cout << m_A << m_B << endl;
	}
	int& getM_A()
	{
		return m_A;
	}
	int& getM_B()
	{
		return m_B;
	}
};
//全局函数完成加号运算符重载
Person operator+(Person& p1, Person& p2)
{
	Person temp;
	temp.getM_A() = p1.getM_A() + p2.getM_A();
	temp.getM_B() = p1.getM_B() + p2.getM_B();
	return temp;
}
int main()
{
	Person p1(1, 1);
	Person p2(2, 2);
	Person p3 = p1 + p2;
	p3.print();
	return 0;
}

左移运算符重载

无法使用成员函数重载左移运算符，因为cout无法在左边，故而只能用全局函数

#include<iostream>
#include<string>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& cout, Person& p);
private:
	string m_name;
	int m_age;
public:
	Person(string name, int age) :m_name(name), m_age(age)
	{

	}
};
//用全局函数重载左移运算法,并且声明为Person类的友元函数，这样才能访问Person类的私有成员
ostream& operator<<(ostream& cout, Person& p)
{
	cout << "姓名:" << p.m_name << "   " << "年龄:" << p.m_age << endl;
	return cout;
}
void test()
{
	Person p1("安比", 20);
	Person p2("艾莲", 19);
	cout << p1 << '\n' << p2 << endl;
}
int main()
{
	test();
	return 0;
}

递增运算符重载

• 前置递增运算符重载

#include<iostream>
using namespace std;
class  myInterger
{
	friend ostream& operator<<(ostream& cout, myInterger& m1);
private:
	int a;
public:
	myInterger()
	{
		a = 1;
	}
	myInterger& operator++()
	{
		++a;
		return *this;
	}

};
ostream& operator<<(ostream& cout, myInterger& m1)
{
	cout << m1.a << endl;
	return cout;
}
int main()
{
	myInterger m1;
	cout << ++m1 << endl;
	return 0;
}

• 后置递增运算符重载

#include<iostream>
using namespace std;
class myInterger
{
	friend ostream& operator<<(ostream& cout, myInterger m);  //访问私有成员需要声明友元
private:
	int a;
public:
	myInterger()
	{
		a = 1;
	}
	myInterger operator++(int)
	{
		myInterger temp;
		temp = *this;
		this->a++;
		return temp;
	}
};
ostream& operator<<(ostream& cout, myInterger m)  //注意此时无法取地址
{
	cout << m.a << endl;
	return cout;
}
void test()
{
	myInterger m1;
	cout << m1++ << endl;
	cout << m1 << endl;
}
int main()
{
	test();
	return 0;
}

赋值运算符重载

operator=做属性的值拷贝

#include<iostream>
using namespace std;
class Person
{
	friend ostream& operator<<(ostream& cout, Person& p);

private:
	int* age;
public:
	Person(int age)
	{
		this->age = new int(age);
	}
	~Person()
	{
		if (age != nullptr)
		{
			delete age;
			age = nullptr;
		}
	}
	Person& operator=(Person& p)
	{
		if (this->age != nullptr)
		{
			delete this->age;
			age = nullptr;
		}
		this->age = new int(*p.age);
		return *this;
	}

};
ostream& operator<<(ostream& cout, Person& p)  //此时这里不能用值传递，如果用值传递，那么必须深拷贝，否则局部变量回收的过程就会delete掉原来的数据?
{
	cout << *p.age << endl;
	return cout;
}
void test()
{
	Person p1(10);
	Person p2(20);
	p2 = p1;
	cout << p1 << p2 << endl;
}
int main()
{
	test();
	return 0;
}

关系运算符重载

//不想写了，返回值为bool返回真假就行
bool operator==(Person &p);

函数调用运算符重载，这是重点

仿函数的本质是让类做一些函数的工作，非常的灵活

#include<iostream>
#include<string>
using namespace std;
//写一个仿函数，用来进行字符串的打印
class myPrint
{
public:
	void operator()(string test)
	{
		cout << test << endl;
	}
};
int main()
{
	//使用匿名对象，myPrint()为匿名对象
	myPrint()("我要成为计算机高手!");
   //不使用匿名对象
    myPrint("我要成为原神高手!");
	return 0;
}