Effective C++ 条款46
本节条款：须要类型转换时请为模板定义非成员函数
这节知识是在条款24的基础上，讲述的有关非成员函数在模板类中（non-member function template）的作用。
我们先看一下条款24讲述的知识核心。条款24讲述了我们怎样能实现类的对象在特定条件下的隐式转换问题。
我们先看以下代码：
**
例一：
**
#include<iostream>
#include<assert.h>
using namespace std;
class Rational
{
private:
int numerator;
int denominator;
public:
Rational(int n = 0, int d = 1) : numerator(n), denominator(d)
{
assert(denominator != 0);
}
int GetNumerator() const
{
return numerator;
}
int GetDenominator() const
{
return denominator;
}
const Rational operator* (const Rational& r2);
};
const Rational Rational::operator* (const Rational& r2)
{
return Rational(this->GetNumerator()* r2.GetNumerator(), this->GetDenominator() * r2.GetDenominator());
}
int main()
{
Rational a(1,2);
Rational b = a * 2;
Rational c = 2 * a;//无法通过编译。
return 0;
}**
例二：
**
#include<iostream>
#include<assert.h>
using namespace std;
class Rational
{
private:
int numerator;
int denominator;
public:
Rational(int n = 0, int d = 1) : numerator(n), denominator(d)
{
assert(denominator != 0);
}
int GetNumerator() const
{
return numerator;
}
int GetDenominator() const
{
return denominator;
}
};
const Rational operator* (const Rational& r1,const Rational& r2)
{
return Rational(r1.GetNumerator()* r2.GetNumerator(), r1.GetDenominator() *r2.GetDenominator());
}
int main()
{
Rational a(1,2);
Rational b = a * 2;
Rational c = 2 * a;//通过编译。
return 0;
}
我们通过以上两段代码能够看出non-member成员函数能够实现混合运算。事实上该函数的实质是利用了编译期间类对象的隐式转换实现的。
对于Rational c = 2 * a;这句话，假设声明为类内的成员函数，那么编译器编译2 * a时。由于2不是一个类的对象。所以编译器不会使用类内的那个成员函数。它会搜寻有没有别的operator*的重载函数。假设没有，编译失败。对于例二。正好有一个operator*函数。
又由于Rational类的构造函数是non-explicit类型，支持隐式转换，所以2被隐式转换为Rational类的对象，编译成功。
然而，在template中，想要实现以上功能。还要考虑其它的问题。
我们看以下的代码：
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)
{……};
Rational<int> oneHalf(1,2);
Rational<int> result=oneHalf*2;//错误。无法通过编译大家思考一下为什么oneHalf*2这句话不能通过编译。事实上，operator*模板函数中參数有两个，所以它会分别对这两个參数进行匹配来确定函数模板类型，试想一下，函数模板在没有实例化之前是不存在的，不存在的函数怎么会实现參数的隐式转换？我们来判断一般模板函数的运行过程，首先。模板函数通过自身參数实例化，实例化之后才会被调用运行。然而。对于本例来说，两个參数的类型一个是Rational<int>，还有一个是2，在编译期间前者能够被判断出来类型是int的rational，后者却判断不出来。由于在template实參推导过程中从不将隐式类型转换考虑在内。
为了能让编译通过，我们能够进行例如以下改变
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());
}
};将operator*变成Rational类的友元函数。这样在定义一个Rational<int>对象的时候，operator*模板函数事实上已经被实例化了，这时候再调用oneHalf*2这句话的时候，就是直接调用已经实例化的operator*函数了，所以，此时，它支持隐式转换。将2转换为Rational<int>对象。
值得一提的是以上代码也可写成例如以下形式：
template<typename T>
class Rational
{
public:
……
friend const Rational<T> operator*(const Rational<T>& lhs,const Rational<T>& rhs);
{
return Rational<T>（lhs.numerator()*rhs.numerator(),lhs.denominator()*rhs.denominator());
}
};也就是说Rational<T>和Rational的形式是一个意思，为了简化，我们能够用Rational的形式。
由于这样将友元函数定义在Rational类中，也就默认是内联函数inline了，为了避免复杂的friend函数影响代码体积，我们利用另外的一种形式实现。
例如以下代码：
template<typename T> class Rational;//forward decelarion
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());
}
我们又又一次定义了一个非类成员函数non-member，将此函数的声明和定义都放在类的外部，这样就能避免代码膨胀问题。
总结
当编写一个class template时，它所提供之“与此template相关的”函数支持“全部參数之隐式类型转换”时。请将那些函数定义为class template内部的friend函数。
