运算符重载介绍

在类中重新定义运算符，赋予运算符新的功能以适应类的运算，就称为运算符重载。
运算符重载是一种形式的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;
}

---

本篇完！