条款十九: 分清成员函数，非成员函数和友元函数

成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。所以，如果有个函数必须进行动态绑定（见条款38），就要采用虚拟函数，而虚拟函数必定是某个类的成员函数。如果函数不必是虚拟的，情况就稍微复杂一点。

看下面表示有理数的一个类：

class rational {
public:
  rational(int numerator = 0, int denominator = 1);
  int numerator() const;
  int denominator() const;
  const rational operator*(const rational& rhs) const;

private:
  ...
};

现在可以很容易地对有理数进行乘法操作：

rational oneeighth(1, 8);
rational onehalf(1, 2);

rational result = onehalf * oneeighth;   // 运行良好

result = result * oneeighth;             // 运行良好

但不要满足，还要支持混合类型操作，比如，rational要能和int相乘。但当写下下面的代码时，只有一半工作：

result = onehalf * 2;      // 运行良好

result = 2 * onehalf;      // 出错!

如果用下面的等价函数形式重写上面的两个例子，问题的原因就很明显了：

result = onehalf.operator*(2);      // 运行良好

result = 2.operator*(onehalf);      // 出错!

对象onehalf是一个包含operator*函数的类的实例，所以编译器调用了那个函数。而整数2没有相应的类，所以没有operator*成员函数。

再看看那个成功的调用。它的第二参数是整数2，然而rational::operator*期望的参数却是rational对象。怎么回事？为什么2在一个地方可以工作而另一个地方不行？

秘密在于隐式类型转换。编译器知道传的值是int而函数需要的是rational，但它也同时知道调用rational的构造函数将int转换成一个合适的rational，所以才有上面成功的调用（见条款m19）。换句话说，编译器处理这个调用时的情形类似下面这样：

const rational temp(2);      // 从2产生一个临时
                             // rational对象

result = onehalf * temp;     // 同onehalf.operator*(temp);

当然，只有所涉及的构造函数没有声明为explicit的情况下才会这样，因为explicit构造函数不能用于隐式转换，这正是explicit的含义。如果rational象下面这样定义：

class rational {
public:
  explicit rational(int numerator = 0,     // 此构造函数为
                    int denominator = 1);  // explicit
  ...
  const rational operator*(const rational& rhs) const;
  ...
};

那么，下面的语句都不能通过编译：

result = onehalf * 2;             // 错误!
result = 2 * onehalf;             // 错误!

编译器只对函数参数表中列出的参数进行转换，决不会对成员函数所在的对象（即，成员函数中的*this指针所对应的对象）进行转换。

尽管如此，你可能还是想支持混合型的算术操作，而实现的方法现在应该清楚了：使operator*成为一个非成员函数，从而允许编译器对所有的参数执行隐式类型转换：

const rational operator*(const rational& lhs,
                         const rational& rhs)
{
  return rational(lhs.numerator() * rhs.numerator(),
                  lhs.denominator() * rhs.denominator());
}

rational onefourth(1, 4);
rational result;

result = onefourth * 2;           // 工作良好
result = 2 * onefourth;           // 万岁, 它也工作了!

关于友元：

如果想重载operator>>和operator<<来读写string对象，你会很快发现它们不能是成员函数。如果是成员函数的话，调用它们时就必须把string对象放在它们的左边：

// 一个不正确地将operator>>和
// operator<<作为成员函数的类
class string {
public:
  string(const char *value);

  ...

  istream& operator>>(istream& input);
  ostream& operator<<(ostream& output);

private:
  char *data;
};

string s;

s >> cin;                   // 合法, 但
                            // 有违常规

s << cout;                  // 同上

所以，如果来设计这些函数，就象这样：

istream& operator>>(istream& input, string& string)
{
  delete [] string.data;

  read from input into some memory, and make string.data
  point to it

  return input;
}

ostream& operator<<(ostream& output,
                    const string& string)
{
  return output << string.data;
}

上面两个函数都要访问string类的data成员，而这个成员是私有（private）的。但我们已经知道，这个函数一定要是非成员函数。这样，就别无选择了：需要访问非公有成员的非成员函数只能是类的友元函数。

结论：

假设f是想正确声明的函数，c是和它相关的类：

·虚函数必须是成员函数。如果f必须是虚函数，就让它成为c的成员函数。

·operator>>和operator<<决不能是成员函数。如果f是operator>>或operator<<，让f成为非成员函数。如果f还需要访问c的非公有成员，让f成为c的友元函数。

编译器只对函数参数表中列出的参数进行转换，决不会对成员函数所在的对象（即，成员函数中的*this指针所对应的对象）进行转换。

·其它情况下都声明为成员函数。如果以上情况都不是，让f成为c的成员函数。