运算符重载

整理自《面向对象程序设计》

3.1什么是运算符重载

为了实现两个Time类对象的加法运算，可以写出如下语句：

Time t1,t2;//定义时间类对象t1、t2
t1=Tadd(t1,t2);//调用函数Tadd()计算两个时间的和
//显然这种调用方式不直观，太繁琐
t1=t1+t2//使用运算符重载可以直接用加好来实现时间的加法运算

所谓重载，就是重新赋予新的含义。运算符重载是将系统中已有的运算符赋予不同的意义。使用运算符重载可以使C++的代码更直观、更易懂、更灵活，使得用户自定义的数据类型以一种更方便、更简洁的方式工作。

由于运算符也是函数，所以在用户自定义的类可以去重载这些函数。运算符重载的方法就是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。

运算符通常是对类中的私有成员进行操作，故重载运算符应能访问类中的私有成员，所以重载运算符一般采用成员函数或友元函数的形式。

3.2重载运算符的规则

• 重载运算符可以对运算符做出新的解释，但原有的基本语义不变。
• 不改变运算符的优先级和结合性。
• 不改变运算符所需要的操作数，即单目运算符只能重载为单目运算符，不能将单目运算符重载为双目运算符。
• 不能创建新的运算符，只有系统预定义的运算符才能被重载，除作用域操作符 :: 条件操作符 ? 点操作符 . 指向成员操作的指针操作符 ->*，.*预处理符号：＃外 ，其他系统预定义的运算符都可以被重载。
• 重载运算符的函数不能有默认的参数，否则就改变了运算符参数的个数。
• 重载的运算符必须和用户自定义类型的对象一起使用，其参数至少应该有一个是类对象或类对象的引用。
• 用于类对象的运算符一般必须重载，但有两个例外，运算符 = 和 &，用户不必重载这两个运算符。
• 运算符重载函数可以是类的成员函数，也可以是类的友元函数。对于=、()、[] 和 ->，运算符只能用成员函数的方式进行重载，对于 << 和 >> 运算符必须用友元函数的方式进行重载。

3.3运算符重载函数作为类的成员函数

可以将运算符重载函数作为类的成员函数，方法是在类中定义一个同名的运算符函数来重载该运算符。

定义运算符重载函数的格式如下：

函数类型 operator 运算符名称（形参表）｛
   函数体;   
｝
//例如
Time operator+(time t)

其中operator+ 为函数名，形参表中是运算符要求的操作数。在定义重载运算符的函数后，可以说函数operator+重载了运算符+。

【对自定义时间类Time 实现加法操作】

//Time.h
class Time {
private:
    int hour;
    int minute;
    int sec;
public:
    Time():hour(0), minute(0), sec(0) {};
    Time(int x, int y , int z ) :hour(x), minute(y), sec(z) {};
    Time operator+(Time &t);
    void show();
};
//Time.cpp
#include<iostream>
using namespace std;
#include"Time.h"

Time Time::operator+(Time &t) {
    Time mt;
    int jinwei = 0;
    mt.sec = sec + t.sec;
    if (mt.sec >= 60) {
        mt.sec -= 60;
        jinwei = 1;
    }
    mt.minute = minute + t.minute+jinwei;
    jinwei = 0;
    if (mt.minute >= 60) {
        mt.minute -= 60;
        jinwei = 1;
    }
    mt.hour = hour + t.hour + jinwei;
    return mt;
}
void Time::show() {
    cout << hour << ":" << minute << ":" << sec;
}
//main.cpp
#include"Time.h"
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int main() {
    Time t1(10, 10, 10), t2(20, 55, 55), t3;
    t3 = t1 + t2;
    t1.show();
    cout << "+";
    t2.show();
    cout << "+";
    cout << "=";
    t3.show();
    cout << endl;
    getchar();
}
/*
10:10:10+20:55:55+=31:6:5
*/

语句t3 = t1 + t2;在编译时变成什么样子呢？由于已经将+运算符重载为Time类的成员函数，这一语句首先编译成通过对象来调用类的成员函数的形式：t3 = t1.operatro+(t2);，在每一个成员函数中都包含一个this指针。这样在执行,C++把它处理为t3=t1.operator+(&t1,t2);即给operator+()函数新增一个参数&t1。对于Time::operator+()函数，C++把它处理为如下形式：

Time Time::operator+(Time *this, Time &t){
    Time mt;
    int jinwei = 0;
    mt.sec = this->sec + t.sec;
    if (mt.sec >= 60) {
        mt.sec -= 60;
        jinwei = 1;
    }
    mt.minute = this->minute + t.minute + jinwei;
    jinwei = 0;
    if (mt.minute >= 60) {
        mt.minute -= 60;
        jinwei = 1;
    }
    mt.hour = this->hour + t.hour + jinwei;
    return mt;
}

【对自定义的时间类Time重载运算符“！”作为其成员函数，用于判断时间对象是否为0】

//Time.h
class Time {
private:
    int hour;
    int minute;
    int sec;
public:
    Time():hour(0), minute(0), sec(0) {};
    Time(int x, int y , int z ) :hour(x), minute(y), sec(z) {};
    Time operator+(Time &t);
    int operator!();//声明重载的“！”运算符
    void show();
};
//Time.cpp
#include<iostream>
using namespace std;
#include"Time.h"

int Time::operator!() {
    if ((hour == 0) && (minute == 0) && (sec == 0)) return 1;
    else return 0;
}
Time Time::operator+(Time &t) {
    Time mt;
    int jinwei = 0;
    mt.sec = sec + t.sec;
    if (mt.sec >= 60) {
        mt.sec -= 60;
        jinwei = 1;
    }
    mt.minute = minute + t.minute+jinwei;
    jinwei = 0;
    if (mt.minute >= 60) {
        mt.minute -= 60;
        jinwei = 1;
    }
    mt.hour = hour + t.hour + jinwei;
    return mt;
}
void Time::show() {
    cout << hour << ":" << minute << ":" << sec;
}
//main.cpp
#include"Time.h"
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int main() {
    Time t1(10, 10, 10), t2;
    if (!t1) cout << "t1 is 0" << endl;
    else cout << "t1 is not 0" << endl;
    if (!t2) cout << "t2 is 0" << endl;
    else cout << "t2 is not 0" << endl;
    getchar();
}
/*
t1 is not 0
t2 is 0
*/

3.4运算符重载函数作为类的友元函数

【为了便于理解，重载函数operator+()不作为Time类的成员函数，而是把重载函数放在类外，作为Time类的友元函数】

//Time.h
class Time {
private:
    int hour;
    int minute;
    int sec;
public:
    Time():hour(0), minute(0), sec(0) {};
    Time(int x, int y , int z ) :hour(x), minute(y), sec(z) {};
    friend Time operator+(Time &t1, Time &t2);//重载“+”运算符函数作为友元函数
    void show();
};
//Time.cpp
#include<iostream>
using namespace std;
#include"Time.h"
void Time::show() {
    cout << hour << ":" << minute << ":" << sec;
}
//main.cpp
#include"Time.h"
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
Time operator+(Time &t1, Time &t2) {
    Time mt;
    int jinwei = 0;
    mt.sec = t1.sec + t2.sec;
    if (mt.sec >= 60) {
        mt.sec -= 60;
        jinwei = 1;
    }
    mt.minute = t1.minute + t2.minute + jinwei;
    jinwei = 0;
    if (mt.minute >= 60) {
        mt.minute -= 60;
        jinwei = 1;
    }
    mt.hour = t1.hour + t2.hour + jinwei;
    return mt;
}
int main() {
    Time t1(10, 10, 10), t2(20,55,55),t3;
    t3 = t1 + t2;
    t1.show();
    cout << "+";
    t2.show();
    cout << "=";
    t3.show();
    cout << endl;
    getchar();
}
/*
10:10:10+20:55:55=31:6:5
*/

由于已经将+运算符重载为Time类的友元函数，因此语句t3+t1+t2;编译称为调用普通函数的形式：t3=operator+(t1,t2);。

二者区别?（精髓）

运算符重载函数可以是类的成员函数，也可以是类的友元函数，那么二者有何区别，在参数个数和调用方式有什么不同？

把Time类的定义及主函数修改如下：

class Time{
    private:
    int hour,minute,sec;
    public:
    Time(){hour=0;minute=0;sec=0;}
    Time(int x,int y,int z){hour=x,minute=y;sec=z;}
    Time(int z){hour=0;minute=0;sec=z;}
    friend Time operator+(Time &t1,Time &t2);
};
int main(){
    Time t1(10,10,10),t2;
    t1=t1+45;
    t2=45+t1;
    return 0;
}

编译系统怎样处理语句t2=t1+45;呢？在编译时，系统发现运算符左侧的t1是Time类对象，右侧45是一个整数。那么编译系统首先寻找有没有对+运算符的重载，发现有operator+()函数，它是类的友元函数，要求两个Time类的形参，而现在45是一个整数，不符合要求。然后编译系统就去找有没有转换构造函数，发现有Time(int z)这个转换构造函数，于是去调用Time(int z)这个转换构造函数，将45转换为Time类常量后，才去调用operator+()函数。该过程相当于执行语句t2=t1+Time(45);同理，语句t2=45+t1;相当于执行语句t2=Time(45)+t1;

如果主函数不变，修改Time类的定义如下：

class Time{
    private:
    int hour,minute,sec;
    public:
    Time(){hour=0;minute=0;sec=0;}
    Time(int x,int y,int z){hour=x,minute=y;sec=z;}
    Time(int z){hour=0;minute=0;sec=z;}
    Time operator+(Time &t);
};

编译系统怎样处理语句t2=t1+45;呢？在编译时，编译系统首先寻找有没有对+运算符的重载，发现有operator+()函数，它是类的成员函数，要求一个Time类的形参，而现在45是一个整数，不符合要求。然后编译系统就去找有没有转换构造函数，发现有Time(int z)这个转换构造函数，于是去调用Time(int z)这个转换构造函数，将45转换为Time类常量后，才去调用t1.operator+()函数。相当于执行语句t2=t1.operator+(Time(45));而语句t2=45+t1;会编译成t2=45.operator+(t1),由于45不是Time类对象不能调用Time类的成员函数，所以编译出错。

 成员函数重载的+运算符不支持交换律，从这个例子中可以看出在第一个参数需要隐式转换的情形下，使用友元函数重载运算符是正确的选择。

什么时候应该用成员函数，什么时候应该用友元函数重载？

由于友元的使用会破坏类的封装，因此从原则上说，要尽量将运算符函数作为类的成员函数。但考虑到各方面的因素，一般将单目运算符重载为成员函数，将双目运算符重载为友元函数。另外，C++规定，有的运算符（=、（）、[ ]、->）必须定义为类的成员函数，（流插入运算符<<和流提取运算符>>、类型转换运算符）则使用友元函数重载。若一个运算符的操作需要修改类对象的状态时（如=、*= 和 ++），应该用成员函数重载，如果运算符的左右操作数类型不同，左操作数可以是常数或其他类型的数时，希望有隐式转换，则必须用友元函数。

3.5重载++和--运算符

++和--运算符属于单目运算符，但是它们有两种使用方式，即前置方式++x 和后置方式 x++，其意义也不相同。前置方式是先自加，返回的是修改后的对象本身，而后置方式返回的是自加前的对象，然后对象自加。C++对此做了约定：在自增（自减）运算符重载中，增加（减少）一个int型形参，就是后置自增（自减）运算符函数，否则就是前置方式。

int在这里只是一个占位符，用来区分函数是前置还是后置，并没有实际意义。

【对Time类进行自增运算，每次走一秒，假设当前秒数小于59】

方式一：作为成员函数

//Time.h
class Time {
private:
    int hour;
    int minute;
    int sec;
public:
    Time():hour(0), minute(0), sec(0) {};
    Time(int x, int y , int z ) :hour(x), minute(y), sec(z) {};
    Time operator++() { sec++; return *this; }
    Time operator++(int x) { Time t; t = *this; sec++; return t; }
    void show() { cout << hour << ":" << minute << ":" << sec<<endl; };
};
//main.cpp
#include"Time.h"
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int main() {
    Time t1(10, 10, 10), t2,t3;
    t1.show();
    t2 = ++t1;
    t1.show();
    t2.show();
    t3 = t1++;
    t1.show();
    t3.show();
    getchar();
}
/*
10:10:10
10:10:11
10:10:11
10:10:12
10:10:11
*/

方式二：作为友元函数

//Time.h
class Time {
private:
    int hour;
    int minute;
    int sec;
public:
    Time():hour(0), minute(0), sec(0) {};
    Time(int x, int y , int z ) :hour(x), minute(y), sec(z) {};
    friend Time operator++(Time &t) { t.sec++; return t; }
    friend Time operator++(Time &t,int x) { Time tt; tt = t; t.sec++; return tt; }
    void show() { cout << hour << ":" << minute << ":" << sec<<endl; };
};
//main.cpp
#include"Time.h"
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int main() {
    Time t1(10, 10, 10), t2,t3;
    t1.show();
    t2 = ++t1;
    t1.show();
    t2.show();
    t3 = t1++;
    t1.show();
    t3.show();
    getchar();
}
/*
10:10:10
10:10:11
10:10:11
10:10:12
10:10:11
*/

3.6重载流插入运算符和流提取运算符

在程序中，人们希望能用流插入运算符<<来输入用户自己声明的类的对象的信息，用流提取运算符>>来输入用户自己声明的类的对象的信息，这就需要重载流插入运算符<<和流提取运算符>>。

将<<和>>重载为友元函数的形式如下：

istream & operator>>(istream &,自定义类 &）；

ostream & operator<<(ostream &,自定义类& ) ；

cin是istream类的对象，cout是ostream类的对象。当执行cout<<3时，该语句被编译为cout.operator<<(3);然后去调用ostream类的operator<<()函数，而且调用后的返回值仍然是cout。

【在Time类上，重载流插入运算符<<和流提取运算符>>】

//Time.h
#include<iostream>
using namespace std;
class Time {
private:
    int hour;
    int minute;
    int sec;
public:
    friend ostream& operator<<(ostream &output,Time &t);
    friend istream& operator>>(istream &input,Time &t);
};
//Time.cpp
#include<iostream>
using namespace std;
#include"Time.h"
ostream& operator<<(ostream& output, Time &t) {
    output << t.hour << ":" << t.minute << ":" << t.sec;
    return output;
}
istream& operator>>(istream& input, Time &t) {
    cout << "input hour,minute and second of a time:";
    input >> t.hour >> t.minute >> t.sec;
    return input;
}
//main.cpp
#include"Time.h"
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int main() {
    Time t1, t2;
    cin >> t1 >> t2;
    cout << "t1=" << t1 << endl;
    cout << "t2=" << t2 << endl;
    getchar();
}
/*
input hour,minute and second of a time:10 20 30
input hour,minute and second of a time:4 5 6
t1=10:20:30
t2=4:5:6
*/

在operator>>()函数最后有语句return input;，就是说执行cin>>t1以后返回值是istream类的input，而input是cin对象的引用（别名），接下来再执行cin>>t2。

C++规定运算符>>(<<)重载函数的第一个参数和函数的类型都必须是istream（ostream）类型的引用，这就是为了返回cin(cout)的当前值，以便连续输入（输出）。

如果把函数定义为成员函数，那么语句cout<<t;就会被编译为cout.operator<<(t),系统认为要调用cout对象所属类ostream类的成员函数operator<<(),这样就出错了。