条款24：若所有的函数参数可能都需要发生类型转换才能使用，请采用non-member函数

假设有一个有理数类Rational，有一个计算有理数乘法的成员函数operator*，示例如下：

#include <iostream>

class Rational
{
public:
    Rational(int numerator = 0, int denominator = 1)
    {
        n = numerator;              // 分子
        d = denominator;            // 分母
    }
    int numerator() const
    {
        return n;
    }
    int denominator() const
    {
        return d;
    }
    const Rational operator*(const Rational& rhs) const
    {
        return Rational(this->n * rhs.n, this->d * rhs.d);
    }

private:
    int n;
    int d;
};

int main()
{
    Rational oneEight(1, 8);
    Rational oneHalf(1, 2);
    Rational result1 = oneEight * oneHalf;  // 同类型运算
34     Rational result2 = oneHalf * 3;         // 混合运算1
35     Rational result3 = 3 * oneHalf;         // 混合运算2　　

    std::cout << result1.numerator() << "/" << result1.denominator() << std::endl;
    std::cout << result2.numerator() << "/" << result2.denominator() << std::endl;
    std::cout << result3.numerator() << "/" << result3.denominator() << std::endl;

    return 0;
}

如上可见，该乘法运算对于执行同类型运算没有任何问题，为什么对于执行混合运算却有时可以，有时又不可以呢？其实，我们知道执行oneHalf * 3时，编译器调用oneHalf的成员函数，然后对于3执行隐式类型转换(调用Rational的构造函数完成的)，转换为Rational后执行乘法运算，因此没出现错误；但是对于3 * oneHalf而言就不同了，因为3并没有相应的成员函数，因此，编译器将试图寻找non-member operator*：result = operator*(2, oneHalf)，但是很遗憾，你没有提供这样的函数，因此发出错误。因此结论是：像这种需要发生类型转换才能继续工作的函数，你必须提供一个non-member函数来完成工作，示例如下：

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

这样的话上述的两种混合调用方式都可以通过了。因此请记住如下结论：

当你设计的某个函数的所有参数（包含this指针所指的那个隐含参数）都可能需要发生类型转换时，那么这个函数必须是non-member函数。