运算符重载介绍
在类中重新定义运算符，赋予运算符新的功能以适应类的运算，就称为运算符重载。
运算符重载是一种形式的C++多态,它使得对象操作更直观,本质上也是属于函数重载。
实际上，我们已经在不知不觉之中使用了运算符重载。例如，加法运算符“+”可以对整数相加、也可以对string对象相加，如5+8; string s1=“abc”;string s2=“xyz”; s1+s2;这是因为C++已经对string类重载了“+”运算符。
又例如，C++对“<<”和“>>”进行了重载，用户在不同的场景下使用它们，作用是不同的。
对于位运算而言，“<<”运算符是左移运算符，“>>”运算符是右移运算符。
“<<”运算符在输出操作中与流对象cout配合使用，是流插入运算符；“>>”运算符在输入操作中与流对象cin配合使用，是流提取运算符。
对于自定义的新类型,需要对使用的运算符进行重新定义即运算符重载。如果某个运算符重载了,那么在使用该运算符时,系统会自动调用。
运算符重载格式如下:
返回值类型 operator 运算符(参数);//注意 operator关键字必须写
其中，operator 是 C++的关键字，专门用于定义运算符重载函数。
例如,operator +(),表示:重载+运算符,operator (),表示:重载运算符。
假设有一个Student类,并为它定义了一个operator +()成员函数,以重载+运算符,如果有Student的对象s1,s2,s3。便可以编写这样的代码。
s1 = s2+s3; //1 直接使用重载运算符
编译器发现,操作数是Student类对象,则使用相应的运算符函数替换上述代码。
s1 = s2.operator+(s3);//2 函数表示法,不如上面的简洁
当然,最重要的是可以使用简便的+运算符表示(如1),而不必使用笨拙的函数表示法(如2)。
计算时间
如果你今天上午编程花了2小时35分钟,下午又花了2小时40分钟,则总共花了多少时间呢?
现在采用一个Time类来处理。
class Time
{
private:
int hours;//小时
int minutes;//分钟
public:
Time(int h=0,int m=0):hours(h),minutes(m)//构造函数
{}
Time operator +(const Time& t)const;//重载+,注意返回值不是引用
void show() const;
};
Time Time::operator +(const Time& t) const//返回的是临时变量,不能写引用
{
return Time(hours + t.hours + (minutes + t.minutes) / 60, (minutes + t.minutes)% 60);
}
void Time::show() const
{
cout << hours << "小时," << minutes << "分钟" << endl;
}
int main()
{
Time t1 = { 2,35};
Time t2 = { 2,40 };
Time t3 = t1 + t2;
t3.show();
return 0;
}
重载的限制
1.重载后的运算符至少有一个操作数是用户定义的类型。这是防止你为内置类型重载运算符,你不能将减法(-)重载为两个整数的和。
2.不能改变运算符的操作数和优先级。例如不能将取余(%)重载成一元运算符。
3.不能创建新运算符。例如不能定义operator **()函数来表示指数。
4.不能重载下面的运算符(了解,不重要)。
sizeof : sizeof运算符 (可以是类型,不具备重载要求)
. : 成员运算符 (保证访问成员的功能不被改变)
.*: 成员指针运算符 (保证访问成员的功能不被改变)
:: : 作用域解析运算符 (类型,不具备重载要求)
? : : 条件运算符 (语义无法保证)
typeid : 获取类型信息运算符 (类型,不具备重载要求)
const_cast : 强制类转换运算符 (类型,不具备重载要求)
dynamic_cast : 强制类型转换运算符 (类型,不具备重载要求)
reinterpret_cast : 强制类型转换运算符 (类型,不具备重载要求)
static_cast : 强制类型转换运算符 (类型,不具备重载要求)
5.上表中的大多数运算符都可以通过成员或非成员函数进行重载,但下面的运算符只能通过成员函数进行重载(左边必须是类对象)。
= : 赋值运算符
():函数调用运算符
[]:下标运算符
->:通过指针访问类成员的运算符
假如运行 [ ]重载为非成员函数,那么可能出现下面的程序
Time& operator[](int n, Time& t)
{
//...一些操作
return c;
}
int main()
{
Time t(1, 10);
6[t]; //会出现这种奇怪的写法
return 0;
}
6.为了区分++,–的前置和后置。C++标准做了一个约定,在后置运算符的参数类别中增加一个int。例如
返回值 operator ++();//前置++
返回值 operator ++(int);//后置++,这个int没有实际意义,仅仅用来说明它是后置运算符
返回值 operator --();//前置--
返回值 operator --(int);//后置--,这个int没有实际意义,仅仅用来说明它是后置运算符
其它运算符重载
还有一些其它操作对于Time来说是有意义的。例如,将两个时间相减或时间乘以一个因子,这需要重载减法和乘法运算符。
class Time
{
private:
int hours;//小时
int minutes;//分钟
public:
Time(int h=0,int m=0):hours(h),minutes(m)//构造函数
{}
Time operator +(const Time& t)const;//重载 +,注意返回值不是引用
Time operator -(const Time& t)const;//重载 -
Time operator *(double n)const;//重载 *
void show() const;
};
Time Time::operator +(const Time& t) const//返回的是临时变量,不能使用引用
{
return Time(hours + t.hours + (minutes + t.minutes) / 60, (minutes + t.minutes) % 60);
}
Time Time::operator -(const Time& t)const
{
int minu1 = hours * 60 + minutes;//把this的时间转为分钟
int minu2 = t.hours * 60 + t.minutes;//把t的时间转为分钟
return Time((minu1 - minu2) / 60, (minu1 - minu2) % 60);
}
Time Time::operator *(double n)const
{
int minu = hours * 60 + minutes;//把this的时间转为分钟
minu = int( minu * n );//分钟取整
return Time(minu/60,minu%60);
}
void Time::show() const
{
cout << hours << "小时," << minutes << "分钟" << endl;
}
int main()
{
Time t1 = { 2,35 };
Time t2 = { 2,40 };
Time t3 = t1 + t2; //测试+
Time t4 = t2 - t1;//测试-
Time t5 = t1 * 1.5;//测试*
t3.show();
t4.show();
t5.show();
return 0;
}
注意:运算符重载应该反应操作的本质,如果使用运算符的重载反而让程序难以理解,就不要使用,直接定义函数更好。
运算符通过类成员函数进行重载,那么第一个操作数必须是类对象本身.
有时第一个操作数可能并不是类对象。例如 3*t1;
Time t6 = 3 * t1;//错误
t6.show();
非成员函数重载
为了解决这个问题,需要实现一个非成员函数的*运算符重载,函数声明如下:
Time operator *(double m, const Time& t);//这不是类成员函数,在类外声明(没有Time::)
这又带来另外一个问题,由于上面的函数不是类的成员函数,那么它是不能直接访问Time的私有成员数据的,有两个办法可以解决,1.在Time类中提供访问获取私有数据的接口方法(下面代码中的getHours和getMinutes);2.把上面的函数设为Time的友元函数。下面演示方法1
class Time
{
private:
int hours;//小时
int minutes;//分钟
public:
Time(int h=0,int m=0);
Time operator +(const Time& t)const;//重载+,注意返回值不是引用
Time operator -(const Time& t)const;
Time operator *(double n)const;
void show() const;
int getHours()const //获取小时值
{
return hours;
}
int getMinutes()const//获取分钟值
{
return minutes;
}
};
Time::Time(int h, int m)
{
hours = h;
minutes = m;
}
Time Time::operator +(const Time& t) const//返回的是临时变量,不能写引用
{
return Time(hours + t.hours + (minutes + t.minutes) / 60, (minutes + t.minutes) % 60);
}
Time Time::operator -(const Time& t)const
{
int minu1 = hours * 60 + minutes;//把this的时间转为分钟
int minu2 = t.hours * 60 + t.minutes;//把t的时间转为分钟
return Time((minu1 - minu2) / 60, (minu1 - minu2) % 60);
}
Time Time::operator *(double n)const
{
int minu = hours * 60 + minutes;//把this的时间转为分钟
minu = int( minu * n );//分钟取整
return Time(minu/60,minu%60);
}
void Time::show() const
{
cout << hours << "小时," << minutes << "分钟" << endl;
}
Time operator *(double m, const Time& t)
{
int minus = int(m*(t.getHours() * 60 + t.getMinutes()));
return Time(minus/60,minus%60);
}
int main()
{
Time t1 = {2,35};
Time t2 = { 2,40 };
Time t3 = t1 + t2;
Time t4 = t2 - t1;
Time t5 = t1 * 1.5;
t3.show();
t4.show();
t5.show();
Time t6 = 3 * t1;//数字写在前
t6.show();
return 0;
}
本篇完！
