目录

四则运算符重载

左移运算符重载

递增运算符重载

赋值运算符重载

关系运算符重载

函数调用运算符重载

---

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

四则运算符重载

        对自定义数据类型实现四则运算（加减乘除）操作，比如：自己写成员函数，实现两个对象相加属性后返回新的对象

        注意：四则运算符重载也可以进行函数重载。

        总结：

        1.对于内置的数据类型的表达式的的运算符是不可以改变的

        2.不要滥用运算符重载

#include <iostream>

using namespace std;

class Person
{
public:
	int m_a;
	int m_b;

	Person(int a, int b) :m_a(a), m_b(b)
	{

	}
	//成员函数重载
	Person operator+(const Person &p)
	{
		Person rp(0, 0);
		rp.m_a = this->m_a + p.m_a;
		rp.m_b = this->m_b + p.m_b;
		return rp;
	}
};
//全局函数重载
static Person operator-(const Person& p1, const Person& p2)
{
	Person rp(0, 0);
	rp.m_a = p1.m_a - p2.m_a;
	rp.m_b = p1.m_b - p2.m_b;
	return rp;
}
//函数重载
static Person operator-(const Person& p1, const int value)
{
	Person rp(0, 0);
	rp.m_a = p1.m_a - value;
	rp.m_b = p1.m_b - value;
	return rp;
}

int main(void)
{
	Person p1(10, 10);
	Person p2(10, 10);
	Person p3(5, 5);
	
	Person p4 = p1 + p2; //Person p4 = p1.operator+(p2);
	cout << "p4 m_a value:" << p4.m_a << endl;
	cout << "p4 m_b value:" << p4.m_b << endl;

	Person p5 = p4 - p3; //Person p5 = operator-(p4,p3)
	cout << "p5 m_a value:" << p5.m_a << endl;
	cout << "p5 m_b value:" << p5.m_b << endl;

	Person p6 = p5 - 5; //Person p6 = operator-(p5,5)
	cout << "p6 m_a value:" << p6.m_a << endl;
	cout << "p6 m_b value:" << p6.m_b << endl;
	system("pause");

	return 0;
}

左移运算符重载

        输出自定义的数据类型，比如：直接输出一个对象就可以输出其成员属性

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

#include <iostream>
#include <string>

using namespace std;

class Person
{
	friend static ostream& operator<<(ostream& cout, Person& p);
public:
	Person(int a, int b)
	{
		m_a = a;
		m_b = b;
	}
private:
	//通常不使用 成员函数重载 左移运算符 ,无法实现cout在左侧
	int m_a;
	int m_b;
};

static ostream& operator<<(ostream &cout, Person& p) // operator<<(cout, p)
{
	cout << "m_a=" << p.m_a << endl;
	cout << "m_b=" << p.m_b << endl;
	return cout;
}

static void test(void)
{
	Person p(10, 10);

	cout << p << endl;
}

int main(void)
{
	test();
	system("pause");
	return 0;
}

递增运算符重载

        区分前置和后置的差别！！

#include <iostream>
#include <string>

using namespace std;

class MyInteger
{
	friend static ostream& operator<<(ostream& cout, MyInteger p);
public:
	MyInteger(int b)
	{
		m_b = b;
	}
	//重载 后置,int 占位参数 int ，区分前置和后置
	MyInteger operator++(int)
	{
		MyInteger temp = *this;
		++*this;
		return temp;
	}
	//重载 前置
	MyInteger& operator++() //返回引用是为了一直对一个数据进行操作
	{
		++m_b;
		return *this;
	}
private:
	int m_b;
};

static ostream& operator<<(ostream& cout, MyInteger p) // operator<<(cout, p)
{
	cout << p.m_b;
	return cout;
}

static void test(void)
{
	MyInteger p(0);

	cout << ++p << endl;
	cout << p << endl;
}

static void test1(void)
{
	MyInteger p1(0);

	cout << p1++ << endl;
	cout << p1 << endl;
}

int main(void)
{
	test();
	test1();
	system("pause");
	return 0;
}

赋值运算符重载

         c++至少给一个类添加4个函数：前三个略

        4.赋值运算符operator=，对属性进行值拷贝（注意深浅拷贝问题）

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	Person(int b)
	{
		m_age = new int(b);
	}
	~Person()
	{
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
	}
	Person& operator=(const Person & p) //重载赋值运算符,使用深拷贝
	{
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
		m_age = new int(*p.m_age);
		return *this;
	}

	int *m_age;
};

static void test1(void)
{
	Person p1(12);
	Person p2(19);
	Person p3(14);
	p3 = p2 = p1;

	cout << "p1年龄为：" << *p1.m_age << endl;
	cout << "p2年龄为：" << *p2.m_age << endl;
	cout << "p3年龄为：" << *p3.m_age << endl;
}

int main(void)
{
	test1();
	system("pause");
	return 0;
}

关系运算符重载

        重载关系运算符，让两个自定义的数据类型进行对比操作

#include <iostream>
#include <string>

using namespace std;

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;
		}
		else 
		{
			return false;
		}
	}

	string m_name;
	int m_Age;
};

static void test1(void)
{
	Person p1("Tom", 19);
	Person p2("Mac", 19);

	if (p1 == p2)
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}

}

int main(void)
{
	test1();
	system("pause");
	return 0;
}

函数调用运算符重载

• 函数调用运算符() 也可以重载
• 由于重载后使用的方式非常像函数的调用，故称仿函数
• 仿函数没有固定写法，非常灵活（返回值、参数均不固定）

#include <iostream>
#include <string>

using namespace std;

class Myprint
{
public:
	void operator()(string test)
	{
		cout << test << endl;
	}
};

class MyAdd
{
public:
	int operator()(int a, int b)
	{
		return a + b;
	}
};

static void test1(void)
{
	Myprint myprint;

	myprint("Hello World!");//仿函数

	MyAdd myadd;
	int result = myadd(1, 1);
	cout << "result = " << result << endl;

	//匿名函数对象
	cout << "result = " << MyAdd()(11, 11) << endl;
}

int main(void)
{
	test1();
	system("pause");
	return 0;
}

推荐：[C++核心编程]（五）：类和对象——友元(friend)