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

课程地址:

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. 重载运算符()、 []、 ->或者赋值运算符=时,运算符重载函数必须声明为类的成员函数。