条款24：如果所有的参数都需要类型转换，那么请为此采用non-member函数

首先还是下面这个class;

class Rational{
public:
    Rational(int numirator = 0, 
             int denominator = 1);
    int numurator() const;
    int denominator() const; //    getter;
};

想要支持operator*的时候我们首先可能想到的是两种选择，一种是member operator*()，还有一种就是friend operator*().

 

首先，member function版本的operator*带来的问题是， rational * 2可以正常使用但是 2 * rational 却不能。

所以首先这里要说的就是，所有的参数都需要进行隐式转换的情况下，采用non-member形式会更加的契合。

 

再者，如果不选去member function形式的operator*,那么是采取friend方式的operator*比较好还是说采取non friend形式的operator*方式比较好呢

 

下面首先以非friend的方式实现了这个问题：

const Rational operator*(const Rational & lhs, const Rational & rhs)
{
    return Rational(lhs.numerator() * rhs.numerator(), lhs.denominator() * rhs.denominator());
    //通过了两个getter来处理这件事
}

上面这种方式不仅可以使tmpRational * 2 以及2 * tmpRational正常通过编译，而且相对于friend函数来说，其对类的内部情况了解的更少，那么实际上他比下面的friend版本函数更加降低了耦合：

const Rational operator*(const Rational & lhs, const Rational & rhs)
{
    return Rational(lhs.numerator * rhs.numerator, lhs.denominator * rhs.denominator);
    //这里就没有使用getter来处理这件事
}

有太多的假设认为，一个与某个class相关的方法如果不是一个member function那么就应该是一个friend，实际上并不是这样，上面两种的其实上面那种确实耦合性更小。

小结：

    如果要为某个函数的所有参数进行类型转换，那么这个函数必须是个non-member，而如果能取得non-friend non-member效果其实更佳。