若所有参数皆需类型转换，请为此采用non-member函数

首先，看一个member函数实现两个有理数相乘的例子，

点击(此处)折叠或打开

1. class Rational {
   
2. public:
   
3.     Rational(int numerator = 0, int denominator = 1);//非explicit，可隐式类型的转换
   
4.     int numerator() const;
   
5.     int denominator() const;
   
6. 
   
7.     const Rational operator* (const Rational& rhs) const;
   
8. private:
   
9.     int numerator;
   
10.     int denominator;
    
11. };
    
12. 
    
13. Rational oneHalf(1, 2);
    
14. Rational result = oneHalf * 2;  //通过， 这里的2隐式转换为Rational类型对象
    
15. result = 2 * oneHalf;           //不通过， operator* 操作对象必须为Rational类型，而这里只是int类型的2，所以编译不通过！！！

为什么第一条可以通过编译，而第二条却不能？

只有当参数被列于参数列表内，这个参数才是隐式类型转换的合格参与者！

当第二条result = 2 * oneHalf；编译失败后。编译器尝试寻找以下这般调用的non-member operator *（命名空间内或在global作用域内）。

result = operator* (2, oneHalf); //错误！因为本例中不存在这样一个接受int和Rational作为参数的non-member operator*。

现在，让operator* 成为一个non-member函数，允许编译器在每一个实参身上执行隐式类型转换：

点击(此处)折叠或打开

1. class Rational {
   
2. public:
   
3.     Rational(int numerator = 0, int denominator = 1);
   
4.     int numerator() const;
   
5.     int denominator() const;
   
6. 
   
7. private:
   
8.     int numerator;
   
9.     int denominator;
   
10. };
    
11. 
    
12. const Rational operator*(const Rational& lhs,
    
13.                             const Rational& rhs)
    
14. {
    
15.     return Rational(lhs.numerator() * rhs.numerator(),
    
16. 
    
17.                     lhs.denominator() * rhs.denominator());
    
18. }
    
19. Rational oneFourth(1, 4);
    
20. Rational result;
    
21. 
    
22. result = oneFourth * 2;  //ok
    
23. result = 2 * oneFourth;  //ok

此时的参数2均在参数列表之内，编译器对其隐式类型转换成Rational对象，编译成功！

**如果需要为某个函数的所有参数（包括this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member。