这一周主要是介绍类运算符重载，下面回顾下。

课程地址：

coursera：C++程序设计

https://www.coursera.org/learn/cpp-chengxu-sheji

中国大学MOOC：程序设计与算法（三）C++面向对象程序设计

程序设计与算法（三）C++面向对象程序设计

运算符重载

运算符重载的含义

  • 运算符重载，就是对已有的运算符(C++中预定义的运算符)赋予多 重的含义，使同一运算符作用于不同类型的数据时导致不同类型的 行为。
  • 运算符重载的目的是：扩展C++中提供的运算符的适用范围，使之能作用于对象。
  • 同一个运算符，对不同类型的操作数，所发生的行为不同。
    • complex_a + complex_b 生成新的复数对象
    • 5 + 4 = 9

运算符重载的形式

  • 运算符重载的实质是函数重载
  • 可以重载为普通函数，也可以重载为成员函数
  • 把含运算符的表达式转换成对运算符函数的调用。
  • 把运算符的操作数转换成运算符函数的参数。
  • 运算符被多次重载时，根据实参的类型决定调用哪个运算符函数。

形式如下：

返回值类型 operator 运算符（形参表）
{
	……
}

来看一个具体的例子：

class Complex
{
    public:
        double real,imag;
        Complex( double r = 0.0, double i= 0.0 ):real(r),imag(i) { }
        Complex operator-(const Complex & c);
};
Complex operator+( const Complex & a, const Complex & b)
{
	return Complex( a.real+b.real,a.imag+b.imag); //返回一个临时对象
}
Complex Complex::operator-(const Complex & c)
{
	return Complex(real - c.real, imag - c.imag); //返回一个临时对象
}

注意：

重载为成员函数时， 参数个数为运算符目数减一。

重载为普通函数时， 参数个数为运算符目数。

赋值运算符的重载

有时候希望赋值运算符两边的类型可以不匹配， 比如，把一个int类型变量赋值给一个Complex对象， 或把一个 char * 类型的字符串赋值给一个字符串对 象,此时就需要重载赋值运算符“=”。

注意，赋值运算符“=”只能重载为成员函数。

class String {
    private:
    	char * str;
    public:
        String ():str(new char[1]) { str[0] = 0;}
        const char * c_str() { return str; };
        String & operator = (const char * s);
        String::~String( ) { delete [] str; }
};
String & String::operator = (const char * s)
{ //重载“=”以使得 obj = “hello”能够成立
    delete [] str;
    str = new char[strlen(s)+1];
    strcpy( str, s);
    return * this;
}

int main()
{
    String s;
    s = "Good Luck," ; //等价于 s.operator=("Good Luck,");
    cout << s.c_str() << endl;
    // String s2 = "hello!"; //这条语句要是不注释掉就会出错
    s = "Shenzhou 8!"; //等价于 s.operator=("Shenzhou 8!");
    cout << s.c_str() << endl;
    return 0;
}

//输出：
//Good Luck,
//Shenzhou 8!
对 operator = 返回值类型的讨论

对运算符进行重载的时候，好的风格是应该尽量保留运算符原本的特性，所以上述例子中返回引用，再考虑如下例子：

a = b = c; 和 (a=b)=c; //会修改a的值

分别等价于： 

a.operator=(b.operator=(c)); 

(a.operator=(b)).operator=(c);

运算符重载为友元函数

  • 一般情况下，将运算符重载为类的成员函数，是较好的选择。
  • 但有时，重载为成员函数不能满足使用要求，重载为普通函数，又不能访问类的私有成员，所以需要将运算符重载为友元。

来看以下例子：

class Complex
{
    double real,imag;
    public:
    Complex( double r, double i):real(r),imag(i){ };
    Complex operator+( double r );
};
Complex Complex::operator+( double r )
{ //能解释 c+5
	return Complex(real + r,imag);
}

  • 经过上述重载后：

    Complex c ; c = c + 5; //有定义，相当于 c = c.operator +(5);

    但是：c = 5 + c; //编译出错

  • 所以，为了使得上述的表达式能成立，需要将 + 重载为普通函数。 

    Complex operator+ (double r,const Complex & c) 
{ //能解释 5+c 
    return Complex( c.real + r, c.imag); 
}

  • 但是普通函数又不能访问私有成员，所以，需要将运算符 + 重载为友元。 

    class Complex
{
    	double real,imag;
    public:
        Complex( double r, double i):real(r),imag(i){ };
        Complex operator+( double r );
        friend Complex operator + (double r,const Complex & c);
};

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

看一个具体例子：

friend ostream & operator<<( ostream & o,const CStudent & s){
    o << s.nAge ;
    return o;
}

类型转换运算符的重载

类型转换很常用，例如我们常用如下语句：

double a = (double) 3;

来看一个具体例子：

#include <iostream>
using namespace std;
class Complex
{
    double real,imag;
    public:
        Complex(double r=0,double i=0):real(r),imag(i) { };
        operator double () { return real; }
        //重载强制类型转换运算符 double
};
int main()
{
    Complex c(1.2,3.4);
    cout << (double)c << endl; //输出 1.2
    double n = 2 + c; //等价于 double n=2+c.operator double()
    cout << n; //输出 3.2
}

类型强制转换运算符被重载时不能写返回值类型，实际上其返回值类型就是该类型强制转换运算符代表的类型。

自增、自减运算符的重载

自增运算符++、自减运算符—有前置/后置之分，为了区分所重载的是前 置运算符还是后置运算符， C++规定：

  • 前置运算符作为一元运算符重载：

    重载为成员函数： 
T & operator++(); 
T & operator--(); 
重载为全局函数： 
T1 & operator++(T2); 
T1 & operator--(T2);

  • 后置运算符作为二元运算符重载，多写一个没用的参数： 

    重载为成员函数：
T operator++(int);
T operator--(int);
重载为全局函数：
T1 operator++(T2,int);
T1 operator--(T2,int);

来看一个具体例子：

class CDemo {
    private :
    	int n;
    public:
        CDemo(int i=0):n(i) { }
        CDemo & operator++(); //用于前置形式
        CDemo operator++( int ); //用于后置形式
        operator int ( ) { return n; }
        friend CDemo & operator--(CDemo & );
        friend CDemo operator--(CDemo & ,int);
};

CDemo & CDemo::operator++()
{ //前置 ++
    n ++;
    return * this;
} // ++s即为: s.operator++();

CDemo CDemo::operator++( int k )
{ //后置 ++
    CDemo tmp(*this); //记录修改前的对象
    n ++;
    return tmp; //返回修改前的对象
} // s++即为: s.operator++(0);

CDemo & operator--(CDemo & d)
{//前置--
    d.n--;
    return d;
} //--s即为: operator--(s);

CDemo operator--(CDemo & d,int)
{//后置--
    CDemo tmp(d);
    d.n --;
    return tmp;
} //s--即为: operator--(s, 0);

int main()
{
    CDemo d(5);
    cout << (d++ ) << ","; //等价于 d.operator++(0);
    cout << d << ",";
    cout << (++d) << ","; //等价于 d.operator++();
    cout << d << endl;
    cout << (d-- ) << ","; //等价于 operator--(d,0);
    cout << d << ",";
    cout << (--d) << ","; //等价于 operator--(d);
    cout << d << endl;
    return 0;
}

//输出结果：
//5,6,7,7
//7,6,5,5

注意自增自减运算符前置后置返回的类型不同，前置返回引用， 后置返回值，这是因为c++语言支持如下写法：

++a = 1;

但是不支持

a++ = 1;

所以前置运算符要返回引用，后置运算符返回值。

注意事项

  1. C++不允许定义新的运算符 ；

  2. 重载后运算符的含义应该符合日常习惯；

    complex_a + complex_b；
word_a > word_b；
date_b = date_a + n；

  3. 运算符重载不改变运算符的优先级；

  4. . 以下运算符不能被重载：“.” 、“.*” 、“::” 、“?:” 、 sizeof；

  5. 重载运算符()、 []、 ->或者赋值运算符=时，运算符重载函数必须声明为类的成员函数。