运算符重载

概念:运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
目的：增加代码的可读性
函数名字：关键字operator后面接需要重载的运算符符号
函数原型:返回值类型+operator操作符号+(参数列表)----(例如:==运算符重载为bool operator ==(参数列表)
下面我们用一个简单的Time类进行各种演示:

class Time{
public:
	Time(int hour=12,int minute=13,int second=12){
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

1.Time对象之间大小的比较

	//<运算符重载
	bool operator<(const Time& d){
		return (_hour < d._hour) || (_hour == d._hour&&_minute < d._minute) || (_hour == d._hour&&_minute == d._minute&&_second < d._second);
	}
	//==运算符重载
	bool operator==(const Time& d){
		return _hour == d._hour&&_minute == d._minute&&_second == d._second;
	}
	//>运算符重载
	bool operator>(const Time& d){
		return !(*this < d || *this == d);
	}
	//<=运算符重载
	bool operator<=(const Time& d){
		return (*this < d || *this == d);
	}
	//>=运算符重载
	bool operator>=(const Time& d){
		return (*this>d || *this == d);
	}
	//!=运算符重载
	bool operator!=(const Time& d){
		return !(*this == d);
	}

这里我们只需要实现两个比较运算符(例如>和==)就可以利用这两个去简单的实现其他的比较运算符
2.Time对象之间的加减换算

	Time operator+(Time& d){
		Time tmp(*this);
		tmp._hour = _hour + d._hour;
		tmp._minute = _minute + d._minute;
		tmp._second = _second + d._second;
		if (tmp._second > 60){
			tmp._second = tmp._second - 60;
			tmp._minute = tmp._minute + 1;
			if (tmp._minute > 60){
				tmp._minute = tmp._minute - 60;
				tmp._hour = tmp._hour + 1;
				if (tmp._hour > 24){
					cout << "hour不能大于24" << endl;
				}
			}
		}
		return tmp;
	}
	Time operator-(Time& d){
		Time tmp(*this);
		tmp._hour = _hour - d._hour;
		tmp._minute = _minute - d._minute;
		tmp._second = _second - d._second;
		if (tmp._minute < 0){
			tmp._hour = tmp._hour - 1;
			tmp._minute = tmp._minute + 60;
		}
		if (tmp._second < 0){
			tmp._minute = tmp._minute - 1;
			tmp._second = tmp._second + 60;
		}
		return tmp;
	}

这里我考虑到时间相加，也会有"进位"或者"借位"，所以也运用了判断语句，读者也可以全方位考虑，更加精确的时间的相加减。
3.时间±秒数

	//时间+=秒
	Time& operator+=(int second){
		_second = _second + second;
		return *this;
	}
	//
	Time& operator-=(int second){
		_second = _second - second;
		return *this;
	}
	Time operator+(int second){
		Time tmp(*this);
		tmp._second += second;
		if (tmp._second > 60){
			tmp._second = tmp._second - 60;
			tmp._minute = tmp._minute + 1;
			if (tmp._minute > 60){
				tmp._minute = tmp._minute - 60;
				tmp._hour = tmp._hour + 1;
				if (tmp._hour > 24){
					cout << "hour不能大于24" << endl;
				}
			}
		}
		return tmp;
	}
	Time operator-(int second){
		Time tmp(*this);
		tmp._second -= second;
		if (tmp._minute < 0){
			tmp._hour = tmp._hour - 1;
			tmp._minute = tmp._minute + 60;
		}
		if (tmp._second < 0){
			tmp._minute = tmp._minute - 1;
			tmp._second = tmp._second + 60;
		}
		return tmp;
	}

对于对象的加减，无论是加整数，还是加一个相同类型的对象，都需要考虑，自身是否发生了改变，如果发生改变，则违反了+或者-运算符的意思，所以我们在实现运算符重载函数的同时，考虑运算符的含义不能被改变。
4.对象的自增自减

	//前置++
	Time& operator++(){
		*this = *this + 1;
		return *this;
	}
	//后置++
	Time operator++(int){
		Time tmp(*this);
		*this = *this + 1;
		return tmp;
	}
	//前置--
	Time& operator--(){
		*this = *this - 1;
		return *this;
	}
	//后置--
	Time operator--(int){
		Time tmp(*this);
		*this = *this - 1;
		return tmp;
	}

关于前置和后置的区别，我们需要主义，后置是先赋值，在自增或者自减少，所以需要我们创建一个临时对象，去保存当前值，然后返回，而对于前置与后置运算符的区别就在于是否有int。
5.两个时间之间相差的秒数

	//时间-时间=秒数
	int operator-(const Time& d){
		int i = 0;
		Time a(*this);
		Time b(d);
		if (*this > d){
			while (a != b){
				i++;
				b++;
			}
		}
		else{
			while (a != b){
				i++;
				a++;
			}
		}
		return i;
	}

关于，时间之间相减，我们在前面已经实现，也考虑了借位，所以这里我们只需要利用计数器，去统计相差的秒数。
关于运算符重载的相关运算符实现就谈到这里！！