08章 运算符重载.txt

C++大学教程txt版中文版 C++大学教程txt版中文版

 
C++大学教程(第8章 运算符重载-01)  
 

教学目标
    ●了解如何重新定义(重载)运算符以处理新类型
    ●了解如何将一个类的对象转换为另一个类的对象
    ●了解重载运算符的时机
    ●学习几个使用运算符重载的例子
    ●生成Array、String和Date类

8．1  简介
    第6章和第7章介绍了C++类的基本知识和抽象数据类型的表示方法。对类的对象(即抽象数据类型的实例)的操作是通过向对象发送消息完成的(即调用成员函数的形式)。对某些类(特别是数学类)来说，这种调用方式是繁琐的，而用C++中的丰富的内部运算符集来指定对对象的操作要更好。本章要介绍怎样把C++中的运算符和类的对象结合在一起使用，这个过程称为运算符重载。扩展C++使它具有这些新的功能是理所当然的。
    运算符<<在C++中有多种用途，既可以用作流插入运算符又可以用作左移位运算符，这是运算符重载的一个范例。同样，运算符>>也是C++中的一个重载运算符，它既可以用作流读取运算符，也可以用作右移位运算符。这两个运算符都是在C++类库中重载的。C++语言本身也重载了运算符+和-，这两个运算符在整数算术运算、浮点数算术运算和指针算术运算等上下文中执行的操作是不同的。
    为了使运算符在不同的上下文中具有不同的含义，C++允许程序员重载大多数运算符。编译器根据运算符的使用方式产生合适的代码。某些运算符(特别是赋值运算符以及+和-等等的各种算术运算符)经常要被重载。虽然重载运算符所能够实现的任务也能够用明确的函数调用完成，但是使用重载运算符能够使程序更易于阅读。
    本章要讨论使用运算符重载的时机以及怎样重载运算符，还要介绍使用重载运算符的许多完整程序。

8．2  运算符重载的基础
    C++程序设计是对类型敏感的，并且程序设计的重点也是放在类型上。程序员可使用内部的类型，也可以定义新的类型。内部的类型可以和C++中丰富的运算符集一起使用。运算符为程序虽提供了操作内部类型对象的简洁的表示方法。

    程序员也可以把运算符和用户自定义的类型一起使用。尽管C++不允许建立新的运算符，但是允许重载现有的运算符，使它在用于类的对象时具有新类型的含义，这是C++最强大的特点之一。

    软件工程视点8. 1
    运算符重载提供了C++的可扩展性，这也是C++最吸引人的属性之一。

    编程技巧8. 1
    在完成同样的操作的情况下，如果运算符重载能够比用明确的函数调用使程序更清晰，则应该使用运算
  符重载。

    编程技巧8．2
    不要过度地或不合理地使用运算特重载，因为这样会使程序语义不清且难以阅读。

    虽然运算符重载听起来好像是C++的外部能力，但是多数程序员都不知不觉地使用过重载的运算符。例如，加法运算符(+)对整数、单精度数和双精度数的操作是大不相同的。但是，因为C++语言本身已经重载了该运算符，所以它能够用于int、float、double和其他内部定义类型的变量。
    运算符重载是通过编写函数定义实现的。函数定义虽然也包括函数首部和函数体，但是函数名是由关键字operator和其后要重载的运算符符号组成的。例如，函数名operator+重载了运算符+。
    用于类的对象的运算符必须重载，但是有两种例外情况。赋值运算符(=)无需重载就可用于每一个类。在不提供重载的赋值运算符时，赋值运算符的默认行为是复制类的数据成员。不久就会看到，这种默认的复制行为对于带有指针成员的类是危险的，对这种类通常要显式重载赋值运算符。地址运算符&也无需重载就可以用于任何类的对象，它返回对象在内存中的地址。地址运算符也可以被重载。
    运算符重载最适合用于数学类。为了与在现实世界中操作这些数学类的方式一致，通常要重载一组运算符。例如，对于复数类，通常不仅仅要重载运算符+，因为其他算术运算符也经常用于复数。
    C++语言的运算符很丰富。因为程序员对每个运算符的含义和使用的具体语境是理解的，所以在重载用于新类的运算符时，程序员能够根据运算符的意义做出合理的选择。
    C++为其内部类型提供了丰富的运算符集，重载这些运算符的目的是为用户自定义的类型提供同样简洁的表达式。然而，运算符的重载不是自动完成的，程序员必须为所要执行的操作编写运算符重载函数。有时最好把这些函数用作成员函数，有时最好用作友元函数，在极少数情况下，他们可能既不是成员函数，也不是友元函数。
    可能会发生重载误用的情况，例如重载加法运算符(+)使它执行类似于减法的运算，或者重载除法运算符(／)以使它执行类似于乘法的运算。如此使用重载会使程序令人迷惑不解。

    编程技巧8．3
    在把重载运算符用于类的对象时，重载运算符的功能类似于该运算符作用于内部类型的对象时所完成的功能，避免没有目的地使用重载运算符。

    编程技巧8. 4
    在用重载运算符编写C++程序之前．查阅编译器的手册，了解特定运算符的各种限制和要求。

8．3  运算符重载的限制
    C++中的大部分运算符都可以被重载。图8．1列出了可以被重载的运算符，图8．2列出了不能被重载的运算符。  

    常见编程错误8．1
    想重载不能重载的运算符是个语法错误。

    可以重载的运算符     
    +         -         *         /         %         ^         &        |
    ~        !         =         <        >        +=        -=        *=
    /=        %=        ^=        &=        |=        <<        >>        >>=
    <<=       ==        !=        <=        >=        &&        ||        ++
    --        ->*        ，        ->       []        ()        new       delete
    new[]     delete[]
 

                                图 8.1 可以被重载的运算符

    不可以重载的运算符 
    .        .*        ::        ?:        sizeof 


                     图 8.2 不能被重载的运算符

    重载不能改变运算符的优先级。虽然重载具有固定优先级的运算符可能会不便于使用，但是在表达式中使用圆括号可以强制改变重载运算符的计算顺序。
    重载不能改变运算符的结合律。
    重载不能改变运算符操作数的个数。重载的一元运算符仍然是一元运算符，重载的二元运算符仍然是二元运算符，C++中的惟一的三元运算符(?：)也不能被重载。运算符&、*、+和-既可以用作一元运算符，也可以用作二元运算符，可以分别把他们重载为一元运算符和二元运算符。
    不能创建新的运算符，只有现有的运算符才能被重载。因此，程序员不能使用一些流行的表示方法，如BASIC中表示指数的运算符**。

    常见编程错误8．2
    试图创建新的运算符是个语法错误。

    运算符重载不能改变该运算符用于内部类型对象时的含义。例如，程序员不能改变运算符+用于两个整数时的含义。运算符重载只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。

    常见编程错误8. 3
    试图改变运算符对内部类型的对象的作用方式是个浯法错误。

    软件工程视点8．2
    运算符函数的参数至少有一个必须是类的对象或者是对类的对象的引用。这种规定防止了程序员改变运算符对内部类型的对象的作用方式。

    重载了赋值运算符=和加法运算符+以后，虽然下列语句是允许的：
       object2 = object2 + object1；
    但并不意味运算符+=也被自动重载了。因此，下面的语句是不允许的：
       object2 += object1；
    然而，显式地重载运算符+=可使上述语句成立。

    常见编程错误8．4
    认为重载了某个运算符(如“+”)可以自动地重载相关的运算符(如“+=”)，或重载了“==”就自动重载了“!=”，运算符只能被显式重载(不存在隐式重载)。

    常见编程错误8．5
    想通过运算符重栽改变运算符的”数量”是个语法错误。

    编程技巧8．5
    要保证相关运算符的一致性，可以用一个运算符实现另一个运算符(即用重载的运算符“+”实现重载的运算符“+=”)。

8．4  用作类成员与友元函数的运算符函数
    运算符函数既可以是成员函数，也可以是非成员函数。非成员函数通常是友元函数。成员函数是用this指针隐式地访问类对象的某个参数，非成员函数的调用必须明确地列出该参数。
    在重载运算符()、[]、->，或者任何赋值运算符时，运算符重载函数必须声明为类的一个成员。对于其他的运算符，运算符重载函数可以是非成员函数。
    不管运算符函数是成员函数还是非成员函数，运算符在表达式中的使用方式是相同的。哪种实现方式更好呢?
    当运算符函数是一个成员函数时，最左边的操作数(或者只有最左边的操作数)必须是运算符类的一个类对象(或者是对该类对象的引用)。如果左边的操作数必须是一个不同类的对象，或者是一个内部类型的对象，该运算符函数必须作为一个非成员函数来实现(正如8．5节中分别重载运算符<<和>>作为流插入运算符和流读取运算符一样)。运算符函数作为非成员函数直接访问该类的private或者protected成员时，该函数必须是一个友元。
    重载的<<运算符必须有一个类型为ostream&的左操作数(例如表达式cout<<classObject中的cout)，因此它必须是一个非成员函数。类似地，重载>>运算符必须有一个类型为istream&的左操作数(如表达式cin >> classObject中的cin)，所以它也必须是一个非成员函数。此外，这两个重载的运算符函数都需要访问输出或输入的类对象的private数据成员，因此出于性能考虑，这些重载的运算符函数通常都是类的友元函数。

    性能提示8．1
    可以把一个运算符作为一个非成员、非友元函数重载。但是，这样的运算符函数访问类的private和protected数据时必须使用类的public接口中提供的“set”或者“get'’函数(即设置数据和读取数据的函数)、调用这些函数的开销会降低性能，因此必须内联这些函数以提高性能。
    只有当二元运算符的最左边的操作数是该类的一个对象时，或者当一元运算符的操作数是该类的一个对象时．才需调用特定类的运算符成员函数。
    选择非成员函数重载运算符的另外一个原因是使运算符具有可交换性。例如：假定有longint类型的一个对象number和类HugeInteger的一个对象bigInteger1(本章的练习中开发了类HugeInteger，该类中的整数可以是任意大小，不受机器字长的限制)。如果要求加法运算符(+)生成一个临时的HugeInteger对象，它是HugeInteger和longint类型对象的和(如表达式bigInteger1+number)，或者是longint和HugeInteger类型对象的和(如表达式number+bigIntegerl)，那么上述的加法运算符就要具有可交换性(正如通常的加法一样)。问题在于，如果把运算符作为成员函数重载，类的对象必须出现在运算符的左边，所以要将运算符函数作为一个非成员的友元重载，这样才能允许HugeInteger对象出现在加法运算符的右边。处理HugeInteger对象在左边的operator+函数依然可以是一个成员函数。记住，非成员函数不一定要是友元，只要类的public接口中有相应set和get函数，有内联的set和get函数则更好。

8．5  重载流插入与流读取运算符
    C++的流读取运算>>和流插入运算符<<可用来输入输出标准类型的数据。这两个运算符是C++编译器在类库中提供的，可以处理包括类C语言中的char*字符串和指针在内的每一种内部数据类型。也可以重载运两个运算符以输入输出用户自定义类型的数据。图8．3中的程序演示了重载的流读取运算符和流插入运算符，它们用来处理用户自定义的电话号码类PhoneNumber的数据。程序假定输入的电话号码是正确的，错误检测留给读者在练习中完成。

1 // Fig. 8.3: fig0S03.cpp
2 // Overloading the stream-insertion and
3 // stream-extraction operators.
4 #include <iostream.h>
5 #include <iomanip.h>
6
7 class PhoneNumber {
8   friend ostream &operator<<( ostream&, const PhoneNumber & );
9   friend istream &operator>>( istream&, PhoneNumber & );
10
11 private:
12   char areaCode[ 4 ];  // 3-digit area code and null
13   char exchang[ 4 ];  // 3-digit exchange and null
14   char line[ 5 ];     // 4-digit line and null
15 };
16
17 // Overloaded stream-insertion operator (cannot be
18 // a member function if we would like to invoke-ti with
19 // cout << somePhoneNumber;).
20 ostream &operator<<( ostream &output, const PhoneNumber &num)
21 {
22   output << "(" << num.areaCode << ")"
23          << num.exchange <<  "-"  << num.line;
24   return output;    // enables cout << a << b << c;
25 }
26
27 istream &operator>>( istream &input, PhoneNumber &num )
28 {
29   input.ignore();                    // skip (
30   input >> setw( 4 ) >> num,areaCode; // input area code
31                                      // skip ) and space
32   input >> setw( 4 ) >> num.exchange; // input exchange
33   input.ignore();
34   input >> setw( 5 ) >> num.line;    // input line
35   return input;     // enables cin >> a >> b >> c;
36 }
37
38 int main()
39 {
40   PhoneNumber phone;  //  create object phone
41
42   cout << "Enter phone number in the form (123)  456-7890:\n";
43
44   // cin >> phone invokes operator>> function by
45   // issuing the call operator>>( ein, phone ).
46    cin >> phone;
47
48   // cout << phone invokes operator<< function by
49   // issuing the call operator<<( eout, phone ).
50   cout << "The phone number entered was: "<< phone << endl;
51   return 0;
52 }

Enter phone number in the form [phone]:
[phone]
The phone number entered was: [phone]

                              图 8.3 用户自定义的流插入和流读取运算符

    流读取运算符函数operator>>(第27行)含有两个参数，一个是对istream的引用(即程序中的input)，另一个则是对用户自定义类型PhoneNumer的引用(即程序中的num)。函数返回一个对istream的引用。在图8. 3的程序中，运算符函数operator>>用来把下述格式的电话号码输入到类PhoneNumber的对象中:
    (800)  555 = 1212
当编译器遇到main()函数中的表达式：
    cin >> phone
编译器将生成函数调用：
    operator >> (cin，phone)；
当执行该调用时，引用参数input成为cin的一个别名，Num成为Phone的一个别名。运算符函数使用istream成员函数getline，将电话号码的三部分作为字符串分别读到被引用的PhoneNumber对象(运算符函数中的num和main函数中的phone)的areaCode、exchange和line成员中。流操纵算子sesetw保证将正确的字符数读入到字符数组中。回忆一下，我们曾经使用cin和setw限制读入的字符数比参数少1(例如setw(4)只允许读入3个字符，留出一个位置保存null终止符)。通过调用istream的成员函数ignore跳过括号、空格、破折号等等(ignore函数删除输入流中指定数目的字符，默认个数为1)。函数operator>>返回对isream对象的引用input(即cin)，因而能够在PhoneNumber对象的输入操作完成后，继续执行对PhoneNumber的其他对象或者其他数据类型对象的输入操作。例如，可以像下面那样输入两个PhoneNumber对象：

 cin >> phone1 >> phone2；
首先是表达式cin >> phone1产生如下调用：
    operator >> (cin，phone1)；
该调用返回cin并把它作为cin >> phone1的值，因此表达式的其余部分将被简单地解释为cin >> phone2，这将通过下列调用执行：
    operator >> (cin，phone2)；
    流插入运算符有两个参数，一个是对ostream的引用(即output)，另一个是对用户自定义类型PhoneNumber的引用(即 num)，函数返回一个对ostream的引用。函数operator<<显示了PhoneNumber的对象。当编译器遇到main函数中的表达式：
    cout << phone
编译器生成非成员函数调用：
    operator << (cout，phone)；
因为电话号码的各个部分是以字符串的格式存储的，所以函数operator<<以字符串形式显示它们。
    注意，函数operator<<和operator>>在类PhoneNumber中被声明为友元函数而不是成员函数。因为要把类PhoneNumber的对象作为运算符的右操作数，所以这些运算符函数必须是非成员函数。要把运算符重载为成员函数，类的操作数(类的对象)必须出现在运算符的左边，如果重载的输入和输出运算符必须直接访问类的非public成员，则必须把它们声明为友元。另外，还要注意operator<< 参数表中引用的PhoneNumber是const类型(因为只输出PhoneNumber)，而operator>>参数表中引用的PhoneNumber是非const类型(由于PhoneNumber对象要修改成在该对象中存放输入的电话号码)。

    软件工程视点8. 3
    无需修改类ostream 和 istream的声明和private数据成员就可以给用户自定义类型添加新的输入/输出能力。这种方式提高了C++语言的可扩展性，可扩展性是C++的最具吸引力的特点。

8．6  重载一元运算符
    类的一元运算符可重载为一个没有参数的非static成员函数或者带有一个参数的非成员函数，参数必须是用户自定义类型的对象或者对该对象的引用。实现重载运算符的成员函数应为非static，以便访问类的非static数据。记住，static成员函数只能访问类的static数据成员。
    本章稍后要用重载的一元运算符“!”测试一个字符串是否为空并返回一个布尔值。当把一元运算符(如“!”)重载为没有参数的非static成员函数时，如果s是String类的对象或是对String类对象的引用，那么编译器在遇到表达式!s时会生成函数调用s．operator!()。操作数s是类的对象，它调用了String类的成员函数operator!。类定义中的函数声明如下：
    class String{
    public：
    bool  operator!()  const；
    把一元运算符(如“!”)重载为带有一个参数的非成员函数时，参数有两种不同的情况。一种情况是该参数是某个对象(需要对象的副本，因此函数不作用于原对象)，另一种情况是该参数是对某个对象的引用(不复制原对象，因此函数会作用于原对象)。如果参数s是String类的一个对象或对String类对象的引用，则!s将被处理为operator!(s)，调用String类的非成员友元函数。String类声明如下：