Coursera Cpp程序设计 week 3

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

课程地址:

coursera:C++程序设计

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

中国大学MOOC:程序设计与算法(三)C++面向对象程序设计

程序设计与算法(三)C++面向对象程序设计

运算符重载

运算符重载的含义

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

运算符重载的形式

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

形式如下:

1
2
3
4
返回值类型 operator 运算符(形参表)
{
……
}

来看一个具体的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 * 类型的字符串赋值给一个字符串对 象,此时就需要重载赋值运算符“=”。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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 = 返回值类型的讨论

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

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

分别等价于:

1
2
3
a.operator=(b.operator=(c)); 

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

运算符重载为友元函数

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

来看以下例子:

1
2
3
4
5
6
7
8
9
10
11
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; //编译出错

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

    1
    2
    3
    4
    Complex operator+ (double r,const Complex & c) 
    { //能解释 5+c
    return Complex( c.real + r, c.imag);
    }
  • 但是普通函数又不能访问私有成员,所以,需要将运算符 + 重载为友元。

    1
    2
    3
    4
    5
    6
    7
    8
    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);
    };

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

看一个具体例子:

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

类型转换运算符的重载

类型转换很常用,例如我们常用如下语句:

1
double a = (double) 3;

来看一个具体例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#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++规定:

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

    1
    2
    3
    4
    5
    6
    重载为成员函数: 
    T & operator++();
    T & operator--();
    重载为全局函数:
    T1 & operator++(T2);
    T1 & operator--(T2);
  • 后置运算符作为二元运算符重载,多写一个没用的参数:

    1
    2
    3
    4
    5
    6
    重载为成员函数:
    T operator++(int);
    T operator--(int);
    重载为全局函数:
    T1 operator++(T2,int);
    T1 operator--(T2,int);

来看一个具体例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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++语言支持如下写法:

1
++a = 1;

但是不支持

1
a++ = 1;

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

注意事项
  1. C++不允许定义新的运算符 ;

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

    1
    2
    3
    complex_a + complex_b;
    word_a > word_b;
    date_b = date_a + n;
  3. 运算符重载不改变运算符的优先级;

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

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