C++运算符重载

C++运算符重载

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

​ 运算符重载，也可以发生函数重载

1. 加号运算符(+)重载

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

代码实现

#include <iostream>
using namespace std;

class Person {
public:
	//1.成员函数重载+号，本质调用为Person p3 = p1.operator+(p2);
	Person operator+(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_A + p.m_B;
		return temp;
	}

	int m_A;
	int m_B;
};

//2.全局函数重载+号，本质调用为Person p3 = operator+(p1,p2);
//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 = 20;
	p2.m_B = 20;

	Person p3 = p1 + p2;
	cout << "p3.m_A= " << p3.m_A << endl;
	cout << "p3.m_B= " << p3.m_B << endl;
}

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

2.左移运算符(cout)重载

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

代码实现

#include <iostream>
using namespace std;

class Person {
public:
	//通常，我们不会利用成员函数重载左移运算符，因为无法将cout在左侧实现，调用时得写成p<<cout


	int m_A;
	int m_B;
};

//利用全局函数重载左移运算符
ostream& operator<<(ostream& cout, Person& p)
{
	cout << "p.m_A= " << p.m_A << endl;
	cout << "p.m_B= " << p.m_B << endl;
	return cout;
}

int main()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;

	cout << p << endl;
	return 0;
}

• 如果需要输出类中的私有内容，记得要将重载函数设置为友元

• 将重载函数cout输出类型设置为ostream，函数后可以继续追加其他输出值，如cout <<p<<"hello world"<<endl;

3.递增运算符(++)重载

作用：通过重载递增运算符，实现自己的整形数据递增。不过同样的道理，也可以写出递减运算符重载

代码实现

#include <iostream>
using namespace std;

class MyInteger
{
public:
	MyInteger()
	{
		m_Num = 10;
	}

	//重载前置++运算符(++i)
	MyInteger &operator++()
	{
		++m_Num;
		return *this;		//将类本身做返回
	}

	//重载后置++运算符(i++)
    //因为函数返回的是局部变量temp，当函数调用完后会释放局部变量，所以函数只能返回值，而不是引用&
	MyInteger operator++(int)	//int 代表占位参数，用于区分前置和后置递增
	{
		MyInteger temp = *this;
		m_Num++;
		return temp;		//将类本身做返回
	}

	int m_Num;
};

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

int main()
{
	MyInteger myint;
	cout << ++myint << endl;
	return 0;
}

递增运算符分前置递增(++i)和后置递增(i++)，两者写法分别为：

• 重载前置递增运算符：

  函数返回值 &operator++();

• 重载后置递增运算符：

  函数返回值 operator++(int);

注意：

(1).重载前置运算符不需要传入参数，而重载后置运算符需要传入一个占位参数int；

(2).重载前置运算符返回的是引用，后续可以对该值继续链式调用； 重载后置运算符直接返回局部变量的值，因为局部变量在函数调用完后就被释放，所以如果引用一个局部变量地址就会报错。

4.赋值运算符(=)重载

C++编译器至少给一个类添加了4个默认函数：

1. 默认构造函数(无参)
2. 默认析构函数(无参)
3. 默认拷贝构造函数，对属性进行浅拷贝
4. 赋值运算符operator=，对属性进行值拷贝

只要涉及到值的拷贝问题，就必须要搞清楚是深拷贝(拷贝对象和原对象指向不同存储空间)还是浅拷贝(拷贝对象和原对象指向同一片存储空间，可能引发释放问题)

代码实现

#include <iostream>
using namespace std;

class Person {
public:
	int *m_Age;

	Person(int age)	
	{
		m_Age = new int(age);
	}

	~Person()		//写出析构函数是为了方便看出浅拷贝和深拷贝的区别
	{
		if (m_Age) {
			delete m_Age;
			m_Age = NULL;
		}
	}

	Person &operator=(Person& p)
	{
		//先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(* p.m_Age);
		
		//编译器只提供如下浅拷贝：
		//m_Age = p.m_Age;

		return *this;
	}
};

void test()
{
	Person p1(10);
	Person p2(20);

	p2 = p1;		//赋值操作，调用重载函数

	cout << "p1.m_Age= " << *p1.m_Age << endl;
	cout << "p2.m_Age= " << *p2.m_Age << endl;
}

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

5.关系运算符(==)重载

在做对比操作时，如果需要对比的是两个类中的成员值，这就需要我们自己重载等值运算符，选取需要对比的成员。

代码实现

#include <iostream>
using namespace std;

class Person {
public:
	string m_Name;
	int m_Age;

	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;
		}
	}

};

int main()
{
	Person p1("张三",10);
	Person p2("李四", 20);
	if (p1 == p2) {
		cout << "p1 和 p2相等" << endl;
	}
	else {
		cout << "p1 和 p2不相等" << endl;
	}
	return 0;
}

同样的道理，也可以重载!=运算符、小于<运算符、大于>运算符等。

6.函数调用运算符()重载

​ 没错，这里重载的就是一对小括号()

• 由于重载后使用的方式比较像函数的调用，使用也称之为仿函数。仿函数没有固定写法，非常灵活

代码实现

#include <iostream>
using namespace std;

class MyPrint
{
public:
	void operator()(string str)
	{
		cout << str << endl;
	}
};

int main()
{
	MyPrint myprint;

	myprint("hello world!");		//这里的()使用了重载函数，其本身也像一个函数

	return 0;
}

上面代码中是将()重载为了输出函数，作为仿函数，它可以实现各种功能，前面几种重载类型几乎都可以用调用运算符重载实现(没去试验，我猜的)，注意后期使用不要混淆。