运算符重载

1. 运算符重载意义

运算符重载是对已有的运算符赋予多重含义，使同一个运算符作用于不同类型的数据时导致不同的行为。
针对自定义的类，可以对原有运算符进行重载。
举例说明：
① 使复数类的对象可以用“+”运算符实现加法；
② 使时钟类对象可以用“++”运算符实现时间增加1秒。

2. 运算符重载规定

① 不能重载的运算符：“.”、“.*”、“::”、“?:” 、sizeof
② 重载之后运算符的优先级和结合性都不会改变

3. 运算符重载形式

函数类型 operator 运算符（形参） 
{ 
	...... 
} 

参数个数=原操作数个数-1 （后置++、–除外）

4. 两种重载方式：

① 可以重载为类的非静态成员函数。
② 可以重载为非成员函数（必要时可以声明为友元）。

4.1 重载为成员函数（双目运算符）

举例说明：
复数类加减法运算重载为成员函数，
要求: 将+、-运算重载为复数类的成员函数。
规则: 实部和虚部分别相加减。
操作数: 两个操作数都是复数类的对象。

#include <iostream> 
using namespace std; 
class Complex 
{ 
public: 
	Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) 
	{ } 
	//运算符+重载成员函数 
	Complex operator + (const Complex &c2) const; 
	//运算符-重载成员函数 
	Complex operator - (const Complex &c2) const; 
	void display() const; //输出复数 
private: 
	double real; //复数实部 
	double imag; //复数虚部 
};
Complex Complex::operator+(const Complex &c2) const
{ 
	//创建一个临时无名对象作为返回值 
	return Complex(real+c2.real, imag+c2.imag); 
}
Complex Complex::operator-(const Complex &c2) const
{ 
	//创建一个临时无名对象作为返回值 
	return Complex(real-c2.real, imag-c2.imag); 
}
void Complex::display() const 
{ 
	cout<<"("<<real<<", "<<imag<<")"<<endl; 
}
int main() 
{ 
	Complex c1(5, 4), c2(2, 10), c3; 
	cout << "c1 = "; c1.display(); 
	cout << "c2 = "; c2.display(); 
	c3 = c1 - c2; //使用重载运算符完成复数减法 
	cout << "c3 = c1 - c2 = "; 
	c3.display(); 
	c3 = c1 + c2; //使用重载运算符完成复数加法 
	cout << "c3 = c1 + c2 = "; 
	c3.display(); 
	return 0; 
} 

运行结果：

补充说明：
在重载运算符函数中，创建一个临时无名对象作为返回值，比创建一个临时对象作为返回值效率要高，因为：
创建临时对象作为返回值，需要发生拷贝构造，即：将临时对象的值拷贝给函数的返回值，需要调用类的拷贝构造函数；而创建一个临时无名对象作为返回值，不需要拷贝构造。
双目运算符重载规则
① 如果要重载 B 为类成员函数，使之能够实现表达式 oprd1 B oprd2，其中 oprd1 为 A 类对象，则 B 应被重载为 A 类的成员函数，形参类型应该是 oprd2 所属的类型。
② 经重载后，表达式 oprd1 B oprd2 相当于 oprd1.operator B(oprd2)
拿上述复数类型举例说明：

表达式 c1+c2 相当于 c1.operator +(c2)

4.2 重载为成员函数（单目运算符）

思考：
单目运算符前置和后置++、–如何区分呢？

举例说明：重载前置++和后置++为时钟类成员函数
重载规则：
• 前置单目运算符，重载函数没有形参
• 后置单目运算符，重载函数需要有一个int形参
• 操作数是时钟类的对象。
• 实现时间增加1秒钟。

#include <iostream> 
using namespace std; 
class Clock //时钟类定义
{ 
public: 
	Clock(int hour = 0, int minute = 0, int second = 0); 
	void showTime() const; 
	Clock& operator ++ (); //前置单目运算符重载，注：此处返回值为引用
	Clock operator ++ (int); //后置单目运算符重载 
private: 
	int hour, minute, second; 
};
Clock::Clock(int hour, int minute, int second) 
{ 
	if (0 <= hour && hour < 24 && 0 <= minute && minute < 60 && 0 <= second && second < 60) 
	{ 
		this->hour = hour; 
		this->minute = minute; 
		this->second = second; 
	} 
	else 
		cout << "Time error!" << endl; 
} 
void Clock::showTime() const 
{
	cout << hour << ":" << minute << ":" << second << endl; 
}
Clock & Clock::operator ++ () //返回值类型为引用
{ 
	second++; 
	if (second >= 60) 
	{ 
		second -= 60;  
		minute++; 
		if (minute >= 60) 
		{ 
			minute -= 60; 
			hour = (hour + 1) % 24; 
		} 
	} 
	return *this; 
}
Clock Clock::operator ++ (int) //注意形参表中的整型参数 
{ 
	Clock old = *this; 
	++(*this); //调用前置“++”运算符 
	return old; 
}
int main() 
{ 
	Clock myClock(23, 59, 59); 
	cout << "First time output: "; 
	myClock.showTime(); 
	cout << "Show myClock++:    "; 
	(myClock++).showTime(); 
	cout << "Show ++myClock:    "; 
	(++myClock).showTime(); 
	return 0; 
} 

程序运行结果：

总结：
前置单目运算符重载规则
① 如果要重载 U 为类成员函数，使之能够实现表达式 U oprd，其中 oprd 为A类对 象，则 U 应被重载为 A 类的成员函数，无形参。
② 经重载后， 表达式 U oprd 相当于 oprd.operator U()
后置单目运算符 ++和–重载规则
① 如果要重载 ++或–为类成员函数，使之能够实现表达式 oprd++ 或 oprd-- ， 其中 oprd 为A类对象，则 ++或-- 应被重载为 A 类的成员函数，且具有一个 int 类型形参。
② 经重载后，表达式 oprd++ 相当于 oprd.operator ++(0)

4.3 重载为非成员函数

有些运算符不能重载为成员函数，例如二元运算符的左操作数不是对象，或者是不能由我们重载运算符的对象
举例说明：
重载Complex的加减法为类的成员函数，但执行加法时，不是复数+复数，而是整数+复数这种形式，此时由于左操作数不是复数，无法调用类的成员函数，也就无法实现加法。
代码举例：
重载Complex的加减法和“<<”运算符为非成员函数
① 将+、-（双目）重载为非成员函数，并将其声明为复数类的友元，两个操作数都是复数类的常引用。
② 将<<（双目）重载为非成员函数，并将其声明为复数类的友元，它的左操作数是std::ostream引用，右操作数为复数类的常引用，返回std::ostream引用， 用以支持下面形式的输出：
cout << a << b;
该输出调用的是：
operator << (operator << (cout, a), b);

#include <iostream> 
using namespace std;
class Complex 
{ 
public: 
	Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) 
	{ } 
	friend Complex operator+(const Complex &c1, const Complex &c2); 
	//函数重载，根据参数类型调用加法函数
	friend Complex operator+(const int &real, const Complex &c2); 
	friend Complex operator-(const Complex &c1, const Complex &c2); 
	//重载输出，实现复数的输出形式
	friend ostream & operator<<(ostream &out, const Complex &c); 
private: 
	double real;  //复数实部 
	double imag;  //复数虚部 
};
Complex operator+(const Complex &c1, const Complex &c2)
{ 
	return Complex(c1.real+c2.real, c1.imag+c2.imag); 
} 
Complex operator+(const int &real, const Complex &c2); 
{
	return Complex(real+c2.real, c2.imag);
}
Complex operator-(const Complex &c1, const Complex &c2)
{ 
	return Complex(c1.real-c2.real, c1.imag-c2.imag); 
}
ostream & operator<<(ostream &out, const Complex &c)
{ 
	out << "(" << c.real << ", " << c.imag << ")"; 
	return out; 
}
int main() 
{ 
	Complex c1(5, 4), c2(2, 10), c3; 
	cout << "c1 = " << c1 << endl; 
	cout << "c2 = " << c2 << endl; 
	c3 = c1 - c2; //使用重载运算符完成复数减法 
	cout << "c3 = c1 - c2 = " << c3 << endl; 
	c3 = c1 + c2; //使用重载运算符完成复数加法 
	cout << "c3 = c1 + c2 = " << c3 << endl; 
	return 0; 
}

运算符重载为非成员函数的规则
① 函数的形参代表依自左至右次序排列的各操作数。
② 重载为非成员函数时
▫ 参数个数=原操作数个数（后置++、–除外）
▫ 至少应该有一个自定义类型的参数。
③ 后置单目运算符 ++和 – 的重载函数，形参列表中要增加一个int，但不必写 形参名。
④ 如果在运算符的重载函数中需要操作某类对象的私有成员，可以将此函数声 明为该类的友元。