《Effective C++》读书笔记 条款46：需要类型转换时请为模板定义非成员函数

对于例子

class Rational{
public:
    Rational(int numerator=0,int denominator=1);
    int  numerator()const;
    int denominator()const;
const Rational operator*(const Rational& rhs) const;
}

//混合算术
Rational onEighth(1,8);
Rational oneHalf(1,2);
Rational result = oneHalf*2;//合法
result = 2*oneHalf;//错误

 解决错误的方式就是将operator*写成non_member函数

但对于模板

template<typename T>
class Rational
{
public:
	Rational(const T& numberator = 0,const T& denominator = 1);
	const T numberator()const;
	const T denominator()const;
	
};
template<typename T>
const Rational<T> operator* (const Rational<T>& lhs, const Rational<T>& rhs)
{

}
int main()
{
	Rational<int> oneHalf(1, 2);
	Rational<int> result = oneHalf * 2;//错误，无法通过编译
	return 0;
}

模板化之后，第一种混合算术都不能通过编译了，这主要是因为在非模板时编译器直到我们要调用的函数时什么，而在这里编译器不知道，因为在调用operator*时，由第一个参数为Rational<int>,可以推导出T为int，但是第二个参数是int,编译器无法推出T是什么，虽然int通过调用non-explicit构造函数可以转换为Rational<int>，但是在推导T的过程中从不将隐式转换函数纳入考虑。要想解决这个问题，可以利用friend函数，将operator*声明为friend

template<typename T>
class Rational
{
public:
//在Rational中可以只写Rational,而不必写成Rational<T>
	Rational(const T& numberator = 0,const T& denominator = 1);
	const T numberator()const;
	const T denominator()const;
	friend const Rational operator*(const Rational& lhs, const Rational& rhs)
	{
		return Rational(lhs.numberator()*rhs.numberator(), lhs.denominator()*rhs.denominator());
	}
};

此时混合编译就可以通过编译了，因为第一个函数被声明为Ratiional<int>，则class Rational<int>就被具现化，而friend函数也就被自动声明出来，friend函数是一个函数而不是一个模板，编译器在调用他时使用隐式转换将2转换成一个Rational<int>。

请记住

当我们编写一个class template，而它所提供之“与此相关的”函数支持“所有参数之隐式类型转换”时，请将那些函数定义为“class template内部的friend函数”