《C++ Primer》之重载操作符与转换（中）

• 赋值操作符

类赋值操作符接受类类型形参，通常，该形参是对类类型的 const 引用，但也可以是类类型或对类类型的非 const 引用。如果没有定义这个操作符，则编译器将合成它。类赋值操作符必须是类的成员，以便编译器可以知道是否需要合成一个。可以为一个类定义许多附加的赋值操作符，这些赋值操作符会因右操作符类型不同而不同。例如，标准库的类 string 定义了 3 个赋值操作符：除了接受 const string& 作为右操作数的类赋值操作符之外，类还定义了接受 C 风格字符串或 char 作为右操作数的赋值操作符，这些操作符可以这样使用：

string car ("Volks");
     car = "Studebaker"; // string = const char*
     string model;
     model = 'T'; // string = char

为了支持这些操作符，string 类包含如下成员：

// illustration of assignment operators for class string
     class string {
     public:
         string& operator=(const string &);      // s1 = s2;
         string& operator=(const char *);        // s1 = "str";
         string& operator=(char);                // s1 = 'c';
         // ....
      };

赋值操作符可以重载。无论形参为何种类型，赋值操作符必须定义为成员函数，这一点与复合赋值操作符有所不同。

• 赋值必须返回对*this的引用

string 赋值操作符返回 string 引用，这与内置类型的赋值一致。而且，因为赋值返回一个引用，就不需要创建和撤销结果的临时副本。返回值通常是左操作数的引用，例如，这是 Sales_item 复合赋值操作符的定义：

// assumes that both objects refer to the same isbn
     Sales_item& Sales_item::operator+=(const Sales_item& rhs)
     {
        units_sold += rhs.units_sold;
        revenue += rhs.revenue;
        return *this;
     }

一般而言，赋值操作符与复合赋值操作符应返回操作符的引用。

• 下标操作符

可以从容器中检索单个元素的容器类一般会定义下标操作符，即 operator[]。标准库的类 string 和 vector 均是定义了下标操作符的类的例子。下标操作符必须定义为类成员函数。

提供读写访问。定义下标操作符比较复杂的地方在于，它在用作赋值的左右操作符数时都应该能表现正常。下标操作符出现在左边，必须生成左值，可以指定引用作为返回类型而得到左值。只要下标操作符返回引用，就可用作赋值的任意一方。可以对 const 和非 const 对象使用下标也是个好主意。应用于 const 对象时，返回值应为 const 引用，因此不能用作赋值的目标。类定义下标操作符时，一般需要定义两个版本：一个为非 const 成员并返回引用，另一个为 const 成员并返回 const 引用。

• 原型下标操作符

下面的类定义了下标操作符。为简单起见，假定 Foo 所保存的数据存储在一个 vector<int>: 中：

class Foo {
     public:
         int &operator[] (const size_t);
         const int &operator[] (const size_t) const;
         // other interface members
     private:
         vector<int> data;
         // other member data and private utility functions
      };

下标操作符本身可能看起来像这样：

int& Foo::operator[] (const size_t index)
     {
         return data[index];  // no range checking on index
     }
     const int& Foo::operator[] (const size_t index) const
     {
         return data[index];  // no range checking on index
     }

• 成员访问操作符

为了支持指针型类，例如迭代器，C++ 语言允许重载解引用操作符（*）和箭头操作符（->)）。箭头操作符必须定义为类成员函数。解引用操作不要求定义为成员，但将它作为成员一般也是正确的。

构建更安全的指针：解引用操作符和箭头操作符常用在实现智能指针的类中。作为例子，假定想要定义一个类类型表示指向Screen 类型对象的指针，将该类命名为 ScreenPtr。

ScreenPtr 类将类似于我们的第二个 HasPtr 类。ScreenPtr 的用户将会传递一个指针，该指针指向动态分配的 Screen，ScreenPtr 类将拥有该指针，并安排在指向基础对象的最后一个 ScreenPtr 消失时删除基础对象。另外，不用为 ScreenPtr 类定义默认构造函数。因此，我们知道一个 ScreenPtr 对象将总是指向一个 Screen 对象，不会有未绑定的 ScreenPtr，这一点与内置指针不同。应用程序可以使用 ScreenPtr 对象而无须首先测试它是否指向一个 Screen 对象。

像 HasPtr 类一样，ScreenPtr 类将对其指针进行使用计数。我们将定义一个伙伴类保存指针及其相关使用计数：

// private class for use by ScreenPtr only
     class ScrPtr {//智能指针
         friend class ScreenPtr;
         Screen *sp;
         size_t use;
         ScrPtr(Screen *p): sp(p), use() { }
         ~ScrPtr() { delete sp; }
     };

这个类看来很像 U_Ptr 类并且作用同样。ScrPtr 保存指针及其相关使用计数。将 ScreenPtr 设为友元，以便 ScreenPtr 可以访问使用计数。ScreenPtr 类将管理使用计数：

/*
      * smart pointer: Users pass to a pointer to a dynamically allocated Screen, which
      *                   is automatically destroyed when the last ScreenPtr goes away
      */
     class ScreenPtr {
     public:
         //  no default constructor: ScreenPtrs must be bound to an object
         ScreenPtr(Screen *p): ptr(new ScrPtr(p)) { }
         //  copy members and increment the use count
         ScreenPtr(const ScreenPtr &orig):
            ptr(orig.ptr) { ++ptr->use; }
         ScreenPtr& operator=(const ScreenPtr&);
         //  if use count goes to zero, delete the ScrPtr object
         ~ScreenPtr() { if (--ptr->use == ) delete ptr; }
     private:
         ScrPtr *ptr;    // points to use-counted ScrPtr class
     };

因为没有默认构造函数，所以 ScreenPtr 类型的每个对象必须提供一个初始化函数，初始化函数必须是另一个 ScreenPtr 对象或指向动态分配的 Screen 的指针。构造函数分配一个新的 ScrPtr 对象以保存那个指针及相关的使用计数。试图定义一个不带初始化式的 ScreenPtr 对象是错误的：

ScreenPtr p1; // error: ScreenPtr has no default constructor
     ScreenPtr ps(new Screen(,));     // ok: ps points to a copy of myScreen

• 支持指针操作

指针支持的基本操作有解引用操作和箭头操作。我们的类可以这样定义这些操作：

class ScreenPtr {
     public:
         // constructor and copy control members as before
         Screen &operator*() { return *ptr->sp; }
         Screen *operator->() { return ptr->sp; }
         const Screen &operator*() const { return *ptr->sp; }
         const Screen *operator->() const { return ptr->sp; }
     private:
         ScrPtr *ptr; // points to use-counted ScrPtr class
     };

解引用操作符是个一元操作符。在这个类中，解引用操作符定义为成员，因此没有显式形参，该操作符返回对 ScreenPtr 所指向的 Screen 的引用。像下标操作符一样，我们需要解引用操作符的 const 和非 const 版本。它们的区别在于返回类型：const 成员返回 const 引用以防止用户改变基础对象。

箭头操作符与众不同。它可能表现得像二元操作符一样：接受一个对象和一个成员名。对对象解引用以获取成员。不管外表如何，箭头操作符不接受显式形参。这里没有第二个形参，因为 -> 的右操作数不是表达式，相反，是对应着类成员的一个标识符。没有明显可行的途径将一个标识符作为形参传递给函数，相反，由编译器处理获取成员的工作。

当这样编写时：

point->action();

由于优先级规则，它实际等价于编写：

(point->action)();

换句话说，我们想要调用的是对 point->action 求值的结果。编译器这样对该代码进行求值：如果 point 是一个指针，指向具有名为 action 的成员的类对象，则编译器将代码编译为调用该对象的 action 成员；否则，如果 action 是定义了 operator-> 操作符的类的一个对象，则 point->action 与 point.operator->()->action 相同。即，执行 point 的 operator->()，然后使用该结果重复这三步；否则，代码出错。

• 使用重载箭头

ScreenPtr p(&myScreen);     // copies the underlying Screen
p->display(cout);

因为 p 是一个 ScreenPtr 对象，p->display 的含义与对 (p.operator->())->display 求值相同//p是对象，不是指针，这里就需要对操作符“->”进行重载，先调用p.operator->()，返回一个p的指针，然后再调用displat()。对 p.operator->() 求值将调用 ScreenPtr 类的 operator->，它返回指向 Screen 对象的指针，该指针用于获取并运行 ScreenPtr 所指对象的 display 成员。

对重载箭头的返回值的约束：重载箭头操作符必须返回指向类类型的指针，或者返回定义了自己的箭头操作符的类类型对象。如果返回类型是指针，则内置箭头操作符可用于该指针，编译器对该指针解引用并从结果对象获取指定成员。如果被指向的类型没有定义那个成员，则编译器产生一个错误。如果返回类型是类类型的其他对象（或是这种对象的引用），则将递归应用该操作符。编译器检查返回对象所属类型是否具有成员箭头，如果有，就应用那个操作符；否则，编译器产生一个错误。这个过程继续下去，直到返回一个指向带有指定成员的的对象的指针，或者返回某些其他值，在后一种情况下，代码出错。

• 自增操作符和自减操作符

自增（++）和自减（--）操作符经常由诸如迭代器这样的类实现，这样的类提供类似于指针的行为来访问序列中的元素。例如，可以定义一个类，该类指向一个数组并为该数组中的元素提供访问检查。理想情况下，带访问检查的指针类可用于任意类型的数组，这一点的实现我们将在介绍类模板时学习。现在，我们的类将处理 int 数组：

/*
      * smart pointer: Checks access to elements throws an out_of_range
      *                exception if attempt to access a nonexistent element
      * users allocate and free the array
      */
     class CheckedPtr {
     public:
         // no default constructor; CheckedPtrs must be bound to an object
         CheckedPtr(int *b, int *e): beg(b), end(e), curr(b) { }
         // dereference and increment operations
     private:
         int* beg;   // pointer to beginning of the array
         int* end;   // one past the end of the array
         int* curr;  // current position within the array
     };

• 定义自增自减操作符

C++ 语言不要求自增操作符或自减操作符一定作为类的成员，但是，因为这些操作符改变操作对象的状态，所以更倾向于将它们作为成员。在为类定义重载的自增操作符和自减操作符之前，还必须考虑另一件事情。对内置类型而言，自增操作符和自减操作符有前缀和后缀两种形式。毫不奇怪，也可以为我们自己的类定义自增操作符和自减操作符的前缀和后缀实例。我们首先介绍前缀形式，然后实现后缀形式。

• 定义前自增前自减操作符

前缀式操作符的声明看起来像这样：

class CheckedPtr {
     public:
         CheckedPtr& operator++();        // prefix operators
         CheckedPtr& operator--();
         // other members as before
      };

为了与内置类型一致，前缀式操作符应返回被增量或减量对象的引用。

这个自增操作符根据 end 检查 curr，从而确保用户不能将 curr 增量到超过数组的末端。如果 curr 增量到超过 end，就抛出一个 out_of_range 异常；否则，将 curr 加 1 并返回对象引用：

// prefix: return reference to incremented/decremented object
     CheckedPtr& CheckedPtr::operator++()
     {
         if (curr == end)
             throw out_of_range
                   ("increment past the end of CheckedPtr");
         ++curr;                // advance current state
         return *this;
     }

除了将 curr 减 1 并检查是否会减到 beg，自减操作符的行为与自增操作符类似：

CheckedPtr& CheckedPtr::operator--()
     {
         if (curr == beg)
             throw out_of_range
               ("decrement past the beginning of CheckedPtr");
         --curr;              // move current state back one element
         return *this;
     }

• 区别操作符前缀和后缀形式

同时定义前缀式操作符和后缀式操作符存在一个问题：它们的形参数目和类型相同，普通重载不能区别所定义的前缀式操作符还是后缀式操作符。为了解决这一问题，后缀式操作符函数接受一个额外的（即，无用的）int 型形参。使用后缀式操作符，编译器提供 0 作为这个形参的实参。//C++自身规定的，后缀操作符后边有一个默认的int类型的参数。尽管我们的前缀式操作符函数可以使用这个额外的形参，但通常不应该这样做。那个形参不是后缀式操作符的正常工作所需要的，它的唯一目的是使后缀函数与前缀函数区别开来。

• 定义后缀式操作符

class CheckedPtr {
     public:
         // increment and decrement
         CheckedPtr operator++(int);       // postfix operators
         CheckedPtr operator--(int);
         // other members as before
     };

为了与内置操作符一致，后缀式操作符应返回旧值（即，尚未自增或自减的值），并且，应作为值返回，而不是返回引用。后缀式操作符可以这样实现：

// postfix: increment/decrement object but return unchanged value
     CheckedPtr CheckedPtr::operator++(int)
     {

         // no check needed here, the call to prefix increment will do the check
         CheckedPtr ret(*this);        // save current value
         ++*this;                      // advance one element, checking the increment
         return ret;                   // return saved state
     }
     CheckedPtr CheckedPtr::operator--(int)
     {
         // no check needed here, the call to prefix decrement will do the check
         CheckedPtr ret(*this);  // save current value
         --*this;                // move backward one element and check
         return ret;             // return saved state
      }

操作符的后缀式比前缀式复杂一点，必须记住对象在加 1／减 1 之前的当前状态。这些操作符定义了一个局部 CheckedPtr 对象，将它初始化为 *this 的副本，即 ret 是这个对象当前状态的副本。保存了当前状态的副本后，操作符调用自己的前缀式操作符分别进行加 1 或减 1：

++*this

调用这个对象的 CheckedPtr 前缀自增操作符，该操作符检查自增是否安全并将 curr 加 1 或抛出一个异常。假定不抛出异常，前自增操作符函数以返回存储在 ret 的副本而结束。因此，返回之后，对象本身加了 1，但返回的是尚未自增的原值。因为通过调用前缀式版本实现这些操作符，不需要检查 curr 是否在范围之内，那个检查以及必要的 throw，在相应的前缀式操作符中完成。因为不使用 int 形参，所以没有对其命名。

• 显示调用前缀式操作符

可以显式调用重载操作符而不是将它作为操作符用在表达式中。如果想要使用函数调用来调用后缀式操作符，必须给出一个整型实参值：

CheckedPtr parr(ia, ia + size);        // iapoints to an array of ints
     parr.operator++();                    // call postfix operator++
     parr.operator++();                     // call prefix operator++

所传递的值通常被忽略，但该值是必要的，用于通知编译器需要的是后缀式版本。一般而言，最好前缀式和后缀式都定义。只定义前缀式或只定义后缀式的类，将会让习惯于使用两种形式的用户感到奇怪。

• 调用操作符和函数对象

可以为类类型的对象重载函数调用操作符。一般为表示操作的类重载调用操作符。例如，可以定义名为 absInt 的结构，该结构封装将 int 类型的值转换为绝对值的操作：

struct absInt {
         int operator() (int val) {
             return val <  ? -val : val;
         }
     };

这个类很简单，它定义了一个操作：函数调用操作符，该操作符有一个形参并返回形参的绝对值。通过为类类型的对象提供一个实参表而使用调用操作符，所用的方式看起来像一个函数调用：

int i = -;
     absInt absObj;  // object that defines function call operator
     unsigned int ui = absObj(i);     // calls absInt::operator(int)

尽管 absObj 是一个对象而不是函数，我们仍然可以“调用”该对象，效果是运行由 absObj 对象定义的重载调用操作符，该操作符接受一个 int 并值并返回它的绝对值。函数调用操作符必须声明为成员函数。一个类可以定义函数调用操作符的多个版本，由形参的数目或类型加以区别。定义了调用操作符的类，其对象常称为函数对象，即它们是行为类似函数的对象。

• 将函数对象用于标准库算法

函数对象经常用作通用算法的实参。程序分析一组故事中的单词，计算有多少个单词长度在 6 字符以上。该解决方案的一个部分包括定义一个函数以确定给定 string 的长度是否大于 6 字符：

// determine whether a length of a given word is 6 or more
     bool GT6(const string &s)
     {
         return s.size() >= 6;
     }

使用 GT6 作为传给 count_if 算法的实参，以计算使 GT6 返回 true 的单词的数目：

vector<string>::size_type wc =
                     count_if(words.begin(), words.end(), GT6);//判断words这个vector中的单词中，长度大于6的个数

函数对象可以比函数更灵活。我们的实现有个严重问题：它将 6 这个数字固化在 GT6 函数的定义中。count_if 算法运行只用一个形参且返回 bool 的函数。理想情况下，应传递 string 和我们想要的长度进行测试。通过该方式，可以使用同一代码对不同长度的字符串进行计数。通过将 GT6 定义为带函数调用成员类，可以获得所需的灵活性。将这个类命名为 GT_cls 以区别于函数：

// determine whether a length of a given word is longer than a stored bound
     class GT_cls {
     public:
         GT_cls(size_t val = 0): bound(val) { }
         bool operator()(const string &s)//利用对“（）”的重载，类对象可以当做一个函数一样去使用
                            { return s.size() >= bound; }
     private:
         std::string::size_type bound;
     };

这个类有一个构造函数，该构造函数接受一个整型值并用名为 bound 的成员记住那个值。如果没有提供值，构造函数将 bound 置 0。该类也定义了调用操作符，接受一个 string 参数并返回一个 bool。调用操作符将 string 实参的长度与数据成员 bound 中存储的值相比较。

可以像前面一样进行计数，但这一次使用 GT_cls 类型的对象而不是 GT6 函数：

cout << count_if(words.begin(), words.end(), GT_cls(6))
          << " words 6 characters or longer" << endl;

这个 count_if 调用传递一个 GT_cls 类型的临时对象而不再是名为 GT6 的函数。用整型值 6 来初始化那个临时对象，构造函数将这个值存储在 bound 成员中。现在，count_if 每次调用它的函数形参时，它都使用 GT_cls 的调用操作符，该调用操作符根据 bound 的值测试其 string 实参的长度。使用函数对象，容易修改程序以根据其他值进行测试，只需为传给 count_if 的对象改变构造函数实参即可。例如，这样修改程序，就可以计算长度在 5 个字符以上的单词数：

cout << count_if(words.begin(), words.end(), GT_cls(5))
          << " words 5 characters or longer" << endl;

更为有用的是，还可以计算长度在 1 到 10 个字符的单词数：

for (size_t i = 0; i != 11; ++i)
         cout << count_if(words.begin(), words.end(), GT(i))
              << " words " << i
              << " characters or longer" << endl;

如果使用函数代替函数对象来编写这个程序，可能需要编写 10 个不同的函数，每个函数测试一个不同的值。

• 标准库定义的函数对象

标准库定义了一组算术、关系与逻辑函数对象类，标准库还定义了一组函数适配器，使我们能够特化或者扩展标准库所定义的以及自定义的函数对象类。这些标准库函数对象类型是在 functional 头文件中定义的。

aaarticlea/png;base64,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" alt="" width="306" height="207" />aaarticlea/png;base64,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" alt="" width="300" height="202" />aaarticlea/png;base64,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" alt="" width="328" height="116" />

• 每个类表示一个给定操作符

每个标准库函数对象类表示一个操作符，即，每个类都定义了应用命名操作的调用操作符。例如，plus 是表示加法操作符的模板类型。plus 模板中的调用操作符对一对操作数应用 + 运算。不同的函数对象定义了执行不同操作的调用操作符。正如 plus 定义了执行 + 操作符的调用操作符，modulus 类定义了应用二元操作符 % 的调用操作符，equal_to 类应用 ==，等等。有两个一元函数对象类：一元减（negate<Type>)）和逻辑非（logical_not<Type>)）。其余的标准库函数对象都是表示二元操作符的二元函数对象类。为二元操作符定义的调用操作符需要两个给定类型的形参，而一元函数对象类型定义了接受一个实参的调用操作符。

• 表示操作数类型的模板类型

每个函数对象类都是一个类模板，我们需要为该模板提供一个类型。正如从诸如 vector 的顺序容器所了解的，类模板是可以用于不同类型的类。函数对象类的模板类型指定调用操作符的形参类型。例如，plus<string> 将 string 加法操作符应用于 string 对象，对于 plus<int>，操作数是 int 值，plus<Sales_item> 将 + 应用于 Sales_items; 对象，依次类推：

plus<int> intAdd;         // function object that can add two int values
     negate<int> intNegate;   //  function object that can negate an int value
     // uses intAdd::operator(int, int) to add 10 and 20
     int sum = intAdd(, );          // sum = 30
     // uses intNegate::operator(int) to generate -10 as second parameter
     // to intAdd::operator(int, int)
     sum = intAdd(, intNegate());    // sum = 0

函数对象常用于覆盖算法使用的默认操作符。例如，sort 默认使用 operator< 按升序对容器进行排序。为了按降序对容器进行排序，可以传递函数对象 greater。该类将产生一个调用操作符，调用基础对象的大于操作符。如果 svec 是一个 vector<string> 对象，以下代码

// passes temporary function object that applies > operator to two strings
     sort(svec.begin(), svec.end(), greater<string>());

将按降序对 vector 进行排序。像通常那样，传递一对迭代器以指明被排序序列。第三个实参用于传递比较元素的谓词函数。该实参 greater<string> 类型的临时对象，是一个将 > 操作符应用于两个 string 操作符的函数对象。

• 函数对象的函数适配器

标准库提供了一组函数适配器，用于特化和扩展一元和二元函数对象。函数适配器分为如下两类：绑定器，是一种函数适配器，它通过将一个操作数绑定到给定值而将二元函数对象转换为一元函数对象；求反器，是一种函数适配器，它将谓词函数对象的真值求反。

标准库定义了两个绑定器适配器：bind1st 和 bind2nd。每个绑定器接受一个函数对象和一个值。正如你可能想到的，bind1st 将给定值绑定到二元函数对象的第一个实参，bind2nd 将给定值绑定到二元函数对象的第二个实参。例如，为了计算一个容器中所有小于或等于 10 的元素的个数，可以这样给 count_if 传递值：

count_if(vec.begin(), vec.end(),
              bind2nd(less_equal<int>(), ));

传给 count_if 的第三个实参使用 bind2nd 函数适配器，该适配器返回一个函数对象，该对象用 10 作右操作数应用 <= 操作符。这个 count_if 调用计算输入范围中小于或等于 10 的元素的个数。

标准库还定义了两个求反器：not1 和 not2。你可能已经想到的，not1 将一元函数对象的真值求反，not2 将二元函数对象的真值求反。为了对 less_equal 函数对象的绑定求反，可以编写这样的代码：

count_if(vec.begin(), vec.end(),
             not1(bind2nd(less_equal<int>(), )));

这里，首先将 less_equal 对象的第二个操作数绑定到 10，实际上是将该二元操作转换为一元操作。再用 not1 对操作的返回值求反，效果是测试每个元素是否 <=。然后，对结果真值求反。这个 count_if 调用的效果是对不 <= 10 的那些元素进行计数。