[Effective C++ --024]若所有参数皆需类型转换，请为此采用non-member函数

引言

假设我们有这样的类：

 class A{
 public:
     A(int num = , int den = ) {};
     int num() const;
     int den() const;
     const A operator* (const A& rhs) const;
 };

在做乘法时，我们可以采用以下的操作：

     A a0(, );
     A a1(, );

     A match = a0 * a1;     // 同类型相乘
     match = match * a0;    // 同类型相乘

上述操作是完全木有问题的，那么如果我们想实现跨类型相乘应该怎么做呢？

于是我们开始尝试这样来操作

     match = a0 * ;       // OK        match = a0.operator * 2
     match =  * a0;       // Error     match = 2.operator * a0

是的，a0是一个包涵了operator*函数的class的对象，所以编译调用此函数。然而2却没有相应的class，也就没有相对应的operator*函数。

而上面成功的操作中，实际上调用了隐式转换函数，在编译器看来，实际执行的操作为：

 const A temp();     // 基于2建立一个临时对象
 match = a0 * temp;   // 等同于a0.operator * (temp);

这时如果我们将A的构造函数换成explicit函数，那么上述任何一种情况都不能进行隐式转换，也就没有任何一个语句可以编译通过。

让我们再深挖一些，为什么 match = 2 * a0;就不能通过隐式转换来完成呢？

答案是：只有当参数被列于参数列内，这个参数才是隐式转换的合格参与者。地位相当于”被调用的成员函数所属的那个对象“--即this对象的隐喻参数，不会是合格的参与者。这就是为什么第一次编译通过，而第二次编译不通过的原因:第一次调用伴随着一个放在参数列内的参数，而第二次调用则否。

一、使用non-member函数

如果我们一定要实现跨类型相乘，可以使用non-member来解决。

 class A{
 public:
     A(int num = , int den = ) {};
     int num() const;
     int den() const;
 };
 const A operator* (const A& lhs, const A& rhs) {
     return A(lhs.num() * rhs.num(),
              lhs.den() * rhs.den());
 }

在这种情况下,下面的任意一种情况都可以实现：

     A a0(, );
     A a1(, );

     A match = a0 * a1;
     match = match * a0;

     match = a0 * ;
     match =  * a0;

◆总结

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