Effective C++ Term 24 涉及隐式类型转换时，使用非成员函数

尽管隐式类型转换不是一个好东西，但是有时我们又不得不需要它，比如在做数学计算的时候，必须允许不同类型的数字进行混合运算，比如我们有一个小数类

class Rational {
public:
  // ctor is deliberately not explicit; allows implicit int-to-Rational 
  Rational(int numerator = 0, int denominator = 1);  
  // accessors for numerator and denominator
  int numerator() const;      
  int denominator() const;

private:
  int numerator;
  int denominator;
};

如果我们将乘法运算声明为 member function

class Rational {
public:
  // ...
  const Rational operator * (const Rational& rhs) const; };
};

那么只有当乘法左边的参数是Rational的实例化对象时，才会调用我们声明的这个const Rational operator *，看看下面这两个例子

Rational oneHalf(1, 2);
Rational result;
result = oneHalf * 2;  // 编译通过
result = 2 * oneHalf;  // 编译不通过

为什么这里很相似的两个乘法操作，一句编译通过，令一句编译不通过呢？很明显，由于oneHalf是一个Rational的实例化对象，因此在它右侧的*成功地调用了我们定义的operator *。由于我们定义的operator *左右两侧都规定是Rational类型，那为什么右侧2也可以通过编译呢？这是因为我们为Rational定义了一个 implicit 的构造函数，它可以接受一个整数进行初始化，所以可以看成编译器做了这样一件事情：oneHalf * Rational(2)

而另一句没有通过编译的语句，左侧的2是一个整数，它没有对应的右侧是Rational的实例化对象的operator *，因此编译器会发出抱怨

那么怎样声明适用于Rational的operator *才是合理的呢？答案是非成员函数（全局可见）

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

这样，只要乘号任意一侧出现了Rational，就会调用operator * (const Rational& lhs, Rational& rhs)这个函数，并且用得到的结果构造了一个新的Rational