Item 46 模板需要类型转换的时候

把Item 24的例子改成模板：

template<typename T>
class Rational {
public:
	Rational(const T& numerator = 0,
	         const T& denominator = 1);
	const T numerator() const;
	const T denominator() const;
	...
};
template<typename T>
const Rational<T> operator*(const Rational<T>& lhs,
							const Rational<T>& rhs)
{
	return Rational(lhs.numerator() * rhs.numerator(),
					lhs.denominator() * rhs.denominator()); 
}
void main() {
	Rational<int> oneHalf(1, 2);
	Rational<int> result = oneHalf * 2;		// 编译器找不到合适的operator*
}

定义operator*为非成员函数是为了支持混合运算。可是上面的代码却编译不过。为什么？
问题出在模板参数推导。
对于operator*来说，编译器只有推导出了T的类型，才能实例化该函数；然后编译器才能找到该函数；再然后调用该函数去处理两个操作数。
可是，编译器看着2这个数，迷惑了：如何从2推导出Rational<T>的T来呢？
编译器在着手推导T的时候，是不会去考虑使用隐式类型转换，把2变成Rational<int>，然后推导出int来的。
C++规定，隐式类型转换只发生在函数调用的时候。而在模板参数推导的时候，函数都还没有被建立出来！

C++是利用friend来解决这个问题的：

template<typename T>
class Rational {
public:
	...
	friend
	const Rational operator*(const Rational& lhs, const Rational& rhs)
	{
		return Rational(lhs.numerator() * rhs.numerator(),
						lhs.denominator() * rhs.denominator()); 
	}
};

1> 用friend关键字
2> 把operator*的实现放到模板类的声明里，变成内联函数
然后才能编译、链接。

有时，要内联的函数体会很大，超过编译器的限制。此时会另外加一层：

template<typename T> class Rational;    // 前视声明
template<typename T>                    // 再声明一个干具体工作的
const Rational<T> doMultiply(const Rational<T>& lhs, const Rational<T>& rhs);
template<typename T>
class Rational {
public:
	...
	friend
	const Rational operator*(const Rational& lhs, const Rational& rhs)
	{
		return doMultiply(lhs, rhs);   // 这样内联就没问题了
	}
};
template<typename T>                   // 干具体工作的，实现一般也放在头文件里
const Rational<T> doMultiply(const Rational<T>& lhs,
                             const Rational<T>& rhs)
{
	return Rational<T>(lhs.numerator() * rhs.numerator(),
                       lhs.denominator() * rhs.denominator());
}