Effective C++ 条款46

最新推荐文章于 2022-09-16 22:48:11 发布

weixin_30328063

最新推荐文章于 2022-09-16 22:48:11 发布

阅读量111

点赞数

文章标签： c/c++

原文链接：http://www.cnblogs.com/gccbuaa/p/7399593.html

版权

本节条款：须要类型转换时请为模板定义非成员函数

这节知识是在条款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());
    }