运算符重载&const修饰符

运算符重载

运算符重载一般作为类的成员函数实现，用于实现自定义类的运算操作。

[返回值] operator[运算符](参数...){...};

参数

• 参数个数必须与运算符原意需要的参数相同，比如重载+，就需要两个参数（左参数和右参数）
• 对于单目运算符，不需要传入参数，以为已经默认将成员this指针指向的对象作为参数传入
• 对于双目运算符，只需要传入一个参数做为右参数，左参数已经默认为this指针指向的对象

返回值

返回值的类型取决于重载的运算符的作用

应用

设计一个时间类，重载+号使得两个时间相加显示正确的时间

class Time
{
	int _hour;
	int _min;
	int _sec;
public:
	Time(int hour = 0, int min = 0, int sec = 0)
	{
		_hour = hour;
		_min = min;
		_sec = sec;
	}
	void Print()
	{
		cout << _hour << ":" << _min << ":" << _sec << endl;
		
	}
	Time operator+(int min)//加分钟
	{
		 Time t(*this);//因为是+号，规定不能改变左右参数的值，所以使用t来取和用以返回。
		 t._min += min;
		 if (t._min > 59)//检查时间正确性
		 {
			 t._hour += (t._min / 60);
			 if (t._hour > 23)
				 t._hour /= 24;
			 t._min %= 60;
		 }
		 return t;
	}
};
int main()
{
	Time a(10, 30, 30);
	(a + 140).Print();
    return 0;
}

流提取>>与流插入<<

因为流运算符是双目运算符，所以this指针指向的类应该放在运算符左边，流对象应该放在运算符右边，但这与我们实际使用的场景刚好相反。
我们需要让左参数指向流，右参数指向类，因此重载就不能做为类的成员函数出现了。此时，需要用到友元函数friend，友元函数本身是一个普通函数，但作为类的友元，能够调用类的成员，包括private。并且参数不用被类限制为第一个必须是this指向的指针。

#include"head.h"
class Time
{
	friend ostream& operator<<(ostream& out, Time& t);//友元函数，声明
	friend istream& operator>>(istream& in, Time& t);
	int _hour;
	int _min;
	int _sec;
public:
	Time(int hour = 0, int min = 0, int sec = 0)
	{
		_hour = hour;
		_min = min;
		_sec = sec;
	}
	
};
ostream& operator<<(ostream& out, Time& t)//流插入
{
	out << t._hour << ":" << t._min << ":" << t._sec << endl;
	return out;
}
istream& operator>>(istream& in, Time& t)//流提取
{
	in >> t._hour >> t._min >> t._sec;
	return in;
}
int main()
{
	Time a;
	cin >> a;
	cout << a;
	return 0;
}

const修饰符

const能够修饰的对象为：内置类型变量、自定义类型变量、指针变量、成员函数、函数参数、函数返回值。着重分析修饰内置类型变量、指针遍历变量和成员函数的情况。

const修饰内置类型变量

意味着该变量被编译器识别为常量，值不可再更改。例如下面将报错：

const int a = 3;
a = 4; //将报错，常量值不可更改

const修饰指针变量

左定值：当const出现在*左边，意味着指针变量指向的内容不可改变
右定向：当const出现在*右边，意味着指针变量指向的地址不可改变
当同时出现，则都不可改变

const int *p = 2; //左定值
int* const p = 2; //右定向
const int* const p = 2; //左定值右定向

const修饰成员函数

const修饰成员函数，意味着该成员函数不能修改类里的任何成员变量。const必须出现在函数名右边，出现在左边则是修饰的函数返回值。

class A{
	private:
		int a,b,c;
	public:
		int getA() const{
			return 1;
		}
};

总结

const就像给要修饰的内容加上了一道只读的锁，任何东西被修饰后都只能访问，不可改变了。