C++之运算符重载

一：运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其

返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

注意：

1.不能通过连接其他符号来创建新的操作符：比如operator@

2.重载操作符必须有一个类类型参数

3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐

藏的this

5.   .*  ::   sizeof   ?:   . 注意以上5个运算符不能重载。这个经常在笔试选择题中出

现。

//.* 用法：调用成员函数指针
class OB
{
public:
	void func()
	{
		cout << "void func()" << endl;
	}
};

typedef void(OB::* PtrFunc)();//成员函数指针类型

int main()
{
//对于普通函数函数名就可以表示函数地址
//成员函数的地址必须是用&
	PtrFunc fp = &OB::func;//定义成员函数指针fp指向成员函数

	OB tmp;
	(tmp.*fp)();//调用func函数
	return 0;
}

//全局的opreater==
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

//private:
	int _year;
	int _month;
	int _day;
};

bool operator==(const Date& d1, const Date& d2)
{
	return d1._day == d2._day
		&& d1._month == d2._month
		&& d1._year == d2._year;
}

int main()
{
	Date d1(2023, 4, 23);
	Date d2(2024, 4, 23);

	cout << (d1 == d2) << endl;//<<的优先级大于==

	return 0;
}

但是上面的写法就需要把成员变量变成共有的，这时候函数的封装性没办法的到保证。

两种解决方案:1.后面会讲解友元  2.将其重载成成员函数

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

    //左操作数是this,指向调用函数的对象
	bool operator==(const Date& d )
	{
		return _day == d._day
			&& _month == d._month
			&& _year == d._year;
	}

	private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 4, 23);
	Date d2(2024, 4, 23);

    //显示调用
    //d1.operator==(d2);
	cout << (d1 == d2) << endl;

	return 0;
}

---

二：赋值运算符重载

1. 赋值运算符重载格式

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

如果写一个返回值为void的赋值重载函数也可以完成赋值，既然这样为什么返回值为什么是引用类型呢？

对于上面连续赋值情况下，如果函数的返回值是void无法完成连续赋值

---

此时也许会有人问，为什么不直接返回Date，而是要返回引用呢？这就要说一下传值返回和传引用返回的区别：

看这个图，就可以看出如果传值返回和传引用返回都可以时， 传引用返回可以减少拷贝构造

原因：

对于引用返回：

1.返回对象是一个局部变量或者临时对象，出了当前作用域就析构销毁了，不能用引用返回

2.用引用返回是存在风险的，因为引用对象d在出函数栈帧时已经销毁了

3.虽然引用返回可以减少一次拷贝构造，但是出了函数作用域，返回对象还在才能用引用

结论：

1.返回对象生命周期出了函数到了，就用传值返回

2.返回对象生命周期没到，不会析构，传引用返回

上面传值引用的例子，可以改成：

---

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._year;
	}
	
	//赋值重载
	Date& operator==(const Date& d)
	{
		//避免写出d1 = d1,看两个变量地址是不是相同
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;

		}
		return (*this);//*this是d2，在mian函数的栈上，不会析构
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 4, 23);
	Date d2(2024, 5, 1);
	Date d3(2023, 4, 20);

	d1 = d2 = d3;

	return 0;
}

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 int _year;
 int _month;
 int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
 if (&left != &right)
 {
 left._year = right._year;
 left._month = right._month;
 left._day = right._day;
 }
 return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现

一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值

运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

class Time
{
public:
	Time()
	{
		 _hour = 1;
		 _minute = 1;
		 _second = 1;
	}

	Time& operator=(const Time& t)
	{
		if (this != &t)
		{
			_hour = t._hour;
			_minute = t._minute;
			_second = t._second;
		}

		return *this;
	}

private:
	int _hour = 1;
	int _minute = 1;
	int _second = 1;
};

class Date
{
private:
	//基本类型（内置类型）
	int _year;
	int _month;
	int _day;

	//自定义类型
	Time _t;
};

int main()
{
	Date d1;
	Date d2;
	d1 = d2;
	return 0;
}

既然 编译器生成的默认赋值运算符重载函数已经可以完成字节序的值拷贝了 ，还需要自己实

现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

原理和拷贝构造是一样的

//如果是栈，这里需要深拷贝解决
typedef int DataType;

class Stack
{
	Stack(int n = 4)
	{
		_a = (DataType*)malloc(sizeof(DataType) * n);

		if (_a == nullptr)
		{
			perror("malloc fail");
			return;
		}

		_size = 0;
		_capacity = n;
	}

	Stack& operator=(const Stack& st)
	{
		if (this != &st)
		{
			_a = (DataType*)malloc(sizeof(DataType) * st._capacity);
			if (_a == nullptr)
			{
				perror("malloc fail");
				return;
			}

			_size = st._size;
			_capacity = st._capacity;
		}
	}

	~Stack()
	{
		if (_a)
		{
			free(_a);
			_a = nullptr;
			_size = _capacity = 0;
		}
	}
private:
	DataType* _a;
	int _size;
	int _capacity;
};

三：前置++和后置++重载

对于自定义类型，能用前置++就用前置++

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//前置++
	Date& operator++()
	{
		_day += 1;
		return (*this);
	}

	//后置++
	//前置++和后置++都是一元运算符，为了让前置++和后置++形成正确的重载
	//c++规定：后置++重载时多加一个int类型，但是调用函数时不用传递，编译器自动传递
	//注意：后置++是先使用后+1，因此需要返回+1之后的旧值，所以需要先将this保存一份，在让this+1
	//而tmp是临时对象，只能是传值返回，不能用引用

	Date& operator++(int)
	{
		Date tmp = *this;
		_day += 1;

		return tmp;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d;
	Date d1(2022, 1, 13);

	d = d1++;
	d = ++d1;

	return 0;
}