• 本条款的内容衔接于条款24：https://blog.csdn.net/qq_41453285/article/details/104311944

一、非成员函数模板出错的例子

• 我们在条款24说过，对于Rational类来说，为了让所有的乘法操作都能通过操作，我们将operator*()函数定义为非成员函数版本（详情可以回过头再去看）。但是对于模板来说，这些规则可能不成立

• 例如下面我们把Rational和operator*()函数都定义为模板，代码如下：

//下面与条款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)
{	
}

• 现在我们书写下面的代码，不能编译通过。例如：

Rational<int> oneHalf(1, 2);

//在条款24中，Rational和operator*为非模板，此处代码可编译通过
//此处，Rational和operator*为模板，编译不通过
Rational<int> result = oneHalf * 2;

错误原因分析

• 错误的原因在于：上面的“oneHalf*2”没有找到匹配的operator*()函数，从而导致出错
• 原因：
  • oneHalf的类型为Rational<int>，因此其匹配到operator*()函数模板，并将operator*()函数模板的模板类型T实例化为int
  • 但是当运行到第二个参数的时候，2为int，operator*()函数模板无法根据int推断出T的类型
  • 因此最终编译器找不到合适的operator*()函数而导致出错
• 在非模板的operator*()中，operator*()可以将2隐式转换为Rational对象（Rational提供了隐式转换，详情再去看条款24）。但是在模板中，这种隐式转换不被允许
• template实参推导取到决定性的因素

二、将模板函数声明为friend

• 在“一”中，我们使用的模板类和模板函数出错了，一种解决办法是将operator()*声明为Rational模板类的友元（friend）
• 下面我们进过两次修改，最终实现错误的代码

第一次修改（编译通过，但是链接时出错）

• 我们先将operator()*声明为Rational的友元。代码如下：

template<typename T>
class Rational {
public:
    //友元，函数声明
    friend const Rational operator*(const Rational& lhs, const Rational& rhs);
};

//函数定义
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;
}

• 备注：上面friend生命中，我们没有在Rational后面添加<T>，这与Rational<T>是一样的，这两都可以
• 编译通过的原因：
  • 当对象oneHalf被定义时，程序会生成一份Rational<int>类的定义，于是class Rational<int>被实例化出来
  • class Rational<int>被实例化之后，friend operator*()函数也被自动声明出来（备注：只是声明而没有定义）
  • friend operator*()函数声明出来之后，该函数为一个函数了，而不是一个模板了，因此我们可以将2传递给该函数（并且参数2可以隐式类型转换，将2转换为Rational）
  • 于是上面的代码就可以编译通过了，但是链接时出错（下面介绍）
• 链接时出错的原因：
  • 因为在class Rational<int>被实例化出来的时候，friend只是将operator*()声明了，但是没有定义，因此程序报错

第二次修改（正确版本）

• 上面的代码编译通过，但是链接通过，因为找不到operator*()的定义
• 解决链接出错的方法是：在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()*lhs.denominator());
    }
};

• 此处friend的另一个好处：我们虽然将该函数声明为friend，但是却没有访问任何class的non-public成员，因此比较安全

三、令friend函数调用辅助函数（与inline相关）

• 我们曾在条款30中说过，如果函数定义在class中都会成为inline，因此上面我们定义在class中的friend operator()*也会称为inline
• 为了使inline带来的冲击最小化，我们可以：
  • 我们可以在operator()*中什么事情都不做，将所完成的事情移动到另一个辅助函数中
  • 这个辅助函数应该是一个template

• 代码如下：

  • ​​​​​​​为了使operator*()在类中的inline最优化，我们定义了一个辅助函数，在其中完成operator*()原本要完成的功能

  • doMultiply()不支持混合式操作（例如将Rational对象和一个int相乘），但是该函数只由operator*()调用，而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)
    {
        //在其中调用doMultiply()，可使inline最优化
        return doMultiply(lhs, rhs);
    }
};

//完成原本operator*()要完成的功能
template<typename T>
const Rational<T> doMultiply(const Rational<T>& lhs, const Rational<T>& rhs)
{
    return Rational<T>(lhs.numerator()*rhs.numerator(),
        lhs.denominator()*lhs.denominator());
}

​​​​​​四、总结

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