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函数。