条款24：若所有参数都需类型转换，请为此采用non-member函数

本文主要是介绍条款24：若所有参数都需类型转换，请为此采用non-member函数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

1.前言

令classes支持隐式类型转换通常是个糟糕的想法，当然这条规则有其例外，最常见的例外是在建立数值类型时候，假如你设计一个class用来表现有理数，允许整数“隐式转换”为有理数似乎颇为合理。

2.实例分析

假设这样开始你的Rational class:

class Rational{public:Rational(int numerator=0,int denominator=1);//构造函数刻意不为explict,允许int-to-        Rational隐式转换int numerator() const;//分子访问函数int denominator() const;//分母的访问函数private:....
};

在这里，你想支持算数运算，比如加法，乘法等等。但你不确定是否该由member函数，non-member函数，或者由non-member friend函数来实现。

首先研究一下将operator*写成Rational成员函数的写法：

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

这个设计能够让你能够将两个有理数以最轻松自在的方式相乘：

Rational oneEighth(1,8);
Rational oneHalf(1,2);
Rational result=oneHalf*oneEighth;//很好
result=result*oneEighth;//很好

如果还想要更多的方式，希望能够支持混合式运算，也就是拿Rational和int相乘。然而当尝试混合式算术时，发现只有一半行的通：

result=oneHalf*2;//很好
result=2*oneHalf;//错误

这不是个好兆头，乘法应该满足交换律。

当你以对应的函数形式重写上述两个式子，问题便一目了然了：

result=oneHal;f.operator*(2);//很好
result=2.operator*(oneHalf);//错误

是的，oneHalf是一个内含operator*函数的class对象，所以编译器调用该函数。然而整数2并没有相应的class，也就没有operator*成员函数。编译器也会尝试寻找可以被以下这般调用的non-member operator*(即在命名空间内或者在global作用域内)：

result=operator*(2,oneHalf);//错误

但本例并不存在这样一个接受int和Rational作为参数的non-member operator*,因此查找失败。

再分析下先前成功的调用。注意其第二个参数是整数2，但Rational::operator*需要的实参却是个Rational对象，这里发生了什么是事情呢？

答案是这里发生了所谓的隐式转换。编译器知道你正在传递一个int，而函数需要的是Rationl；但它也知道只要调用Rational构造函数并赋予你所提供的int，就可以变出一个适当的Rational来，于是它就这样做了。换句话说此一调用动作在编译器眼里又点像这样：

const Rational temp(2);//根据2建立一个暂时性的Rational对象
result=oneHalf*temp;//等同于oneHalf.operator*(temp);

当然，只因为涉及non-explict构造函数，编译器才会这样做，如果Rational构造函数是explict，以下语句没有一个可以通过编译：

result=oneHalf*2;//错误，在explict构造函数下，无法将2转换为一个Rational
result=2*oneHalf;//同样的错误

这就很难让Rational class支持混合式算术运算了。

然而我的目标不仅在一致性，也要支持混合式算术运算，也就是希望能有个设计能让以上语句通过编译。我们再回到上述两个语句，为什么即使Rational构造函数不是explict，仍然只有一俄国可以通过编译，另一个确不可以：

result=oneHalf*2;//正确（在non-explict构造函数的情况下）
result=2*oneHalf;//错误

答案是：只有当参数列被列于参数列内，这个参数才是隐式类型转换的合格参与者，地位相当于“被调用之成员函数所隶属的那个对象”-即this对象的那个隐喻参数，绝不是隐式转换的合格参与者。这就是为什么上述第一次调用可以通过编译，第二次调用则不能，因为第一次调用伴随一个放在参数列内的参数，第二次调用则没有。

然而你一定也会想要支持混合式算术运算：让operator*成为一个non-member函数，允许编译器在每一个实参身上执行隐式类型转换：

class Rational{....
};
const Rational operator*(const Rational& lhs,const Rational& rhs)//现在做成一个non-           
{return Rational(lhs.numerator()*rhs.numerator(),lhs.denominator()*rhs.denominator());
}
//member函数
Ratioanl oneFourth(1,4);
Rational result;
result=oneFourth*2;//没问题
result=2*oneFourth;//编译通过

不过还有一点需要担心：即operator*是否应该成为Rational class的一个friend函数呢？

就本例而言答案是否定的，因为operator*可以完全由Rational的public接口完成任务，上面代码已经表明此种做法。这导出一个重要的观察：member函数的反面是non-member函数，不是friend函数。