【c++】类和对象6—运算符重载

---

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

加号（+）运算符重载

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

#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;
	}*/

	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 test()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p1 + p2;
	//1、成员函数重载本质调用：
	//Person p3 = p1.operator+(p2);
	
	//2、全局函数重载本质调用： 
	//Person p3 = operator+(p1, p2);

	Person p4 = p1 + 100;//Person+int

	cout << "p3.m_A=" << p3.m_A << endl;
	cout << "p3.m_B=" << p3.m_B << endl;

	cout << "p4.m_A=" << p4.m_A << endl;
	cout << "p4.m_B=" << p4.m_B << endl;
}

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

输出：
p3.m_A=20
p3.m_B=20
p4.m_A=110
p4.m_B=110

总结：
1、对于内置的数据类型的表达式的运算符是不可能改变的；
2、不要滥用运算符重载。

左移（<<）运算符重载

作用：可以输出自定义数据类型。

#include<iostream>
using namespace std;

class Person
{
	friend ostream& operator<<(ostream& out, Person& p);

public:
	Person(int a,int b)
	{
		m_A = a;
		m_B = b;
	}

	//利用成员函数重载左移运算符
	//p.operator<<(cout)简化版本p<<cout
	//不会利用成员函数重载<<，因为无法实现cout在左侧
	/*void operator<<(cout)
	{

	}*/
private:
	int m_A;
	int m_B;
};

//只能利用全局函数重载左移运算符
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p)
{
	out << "m_A=" << p.m_A << "m_B=" << p.m_B;
	return out;//链式编程思想
}


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

	cout << p << endl;
}

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

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

递增（++）运算符重载

作用：通过重载递增运算符，实现自己的整型数据

#include<iostream>
using namespace std;

class MyInterger
{
	friend ostream& operator<<(ostream& out, MyInterger myint);

public:
	MyInterger()
	{
		m_num = 0;
	}
	//前置++
	//返回引用为了一种对一个数据进行递增操作
	MyInterger& operator++() {
		//先++
		m_num++;
		//再返回
		return *this;
	}

	//后置++
	//void operator++(int) int代表占位参数，可以用于区分前置和后置递增
	MyInterger operator++(int) {
		//先返回
		MyInterger temp = *this;//记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++
		//再++
		m_num++;
		return temp;
	}
private:
	int m_num;
};

ostream& operator<<(ostream& out, MyInterger myint)
{
	out << myint.m_num;
	return out;
}

//前置++，先++ 再返回
void test01()
{
	MyInterger myInt;
	cout << ++myInt << endl;
	cout << myInt << endl;
}

//后置++，先返回 再++
void test02()
{
	MyInterger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

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

赋值（=）运算符重载

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

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

#include<iostream>
using namespace std;

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 test()
{
	Person p1(18);

	Person p2(20);

	Person p3(22);

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

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


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

关系运算符重载

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

#include<iostream>
using namespace std;

class Person
{

public:
	Person(string name,int age)
	{
		this->m_name = name;
		this->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;
		}
	}
	//重载关系运算符!=
	bool operator!=(Person& p)
	{
		if (this->m_name == p.m_name && this->m_age == p.m_age)
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	string m_name;
	int m_age;
};

void test()
{
	Person a("张三", 18);
	Person b("张三", 18);
	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

	if (a != b)
	{
		cout << "a和b不相等" << endl;
	}
	else
	{
		cout << "a和b相等" << endl;
	}
}


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

函数调用运算符重载

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

#include<iostream>
using namespace std;

class MyPrint
{
public:
	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};

void MyPrint02(string test)
{

	cout << test << endl;
}

void test01()
{
	MyPrint myprint;
	myprint("helloworld");//由于使用起来非常类似于函数调用，因此称为仿函数
	MyPrint02("helloworld");
}

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

void test02()
{
	MyAdd myadd;//非匿名函数对象，名字是myadd
	int ret = myadd(100, 100);
	cout << "ret=" << ret << endl;

	//匿名函数对象
	cout << MyAdd()(100, 100) << endl;
}

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

---