Effective C++ 条款 46：需要类型转换时请为模板定义非成员函数

最新推荐文章于 2024-05-05 09:16:34 发布

It_Ds_N_cpp

最新推荐文章于 2024-05-05 09:16:34 发布

阅读量624

点赞数

分类专栏： Effective C++

本文链接：https://blog.csdn.net/u010470972/article/details/39505389

版权

Effective C++ 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

（一）

首先我们回顾条款24，它说过为什么惟有non-member函数才有能力“在所有实参身上实施隐式类型转换”。

现在我们将Rational和operator*模板化：

template<typename T>
class Rational {
public:
	Rational(const T& number = 0, const T& denominator = 1);
	const T number() const;
	const T denominator() const;
};

template<typename T>
const Rational<T> operator* (const Rational<T>& lhs, const Rational<T>& rhs) {
	...
}<span style="color: rgb(51, 51, 51); font-family: Verdana, Arial, Helvetica, sans-serif; font-size: 13px; line-height: 19px; text-align: justify;">许多编译器实质上会强迫你把所有template定义式放进头文件内，所以你或许需要在头文件内定义doMultiply（条款30，这样的templates不需非得是inline不可），看起来像这样：</span>

我们希望以上代码支持混合算术运算，所以我们希望以下代码能够顺利通过编译：

Rational<int> oneHalf(1,2); 
Rational<int> result = oneHalf * 2;//错误！无法通过编译

条款24内，编译器知道我们尝试调用什么函数（就是接受两个Rationals参数的那个operator*），但这里编译器不知道我们想要调用哪个函数。取而代之的是，他们试图想出什么函数被名为operator*的template具现化（产生）出来。它们知道应该可以具现化某个“名为operator*并接受两个Rational<T>参数”的函数，但完成这一具现化行动，必须先算出T是什么。问题是它们没这个能耐。

（二）

解决方法：template class内的friend声明式可以指涉某个特定函数。

class template并不依赖template实参推导（后者只施行于function template身上），所以编译器总是能在class Rational<T>具现化时得知T，所以令Rational<T> class 声明适当的operator*为其friend函数，可简化整个问题：

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

现在对operator*的混合式调用可以通过编译了。因为当对象oneHalf被声明为一个Rational<int>,class Rational<int>于是被具现化出来，而作为过程的一部分，friends函数operator*（接受Rational<int>参数）也就被自动声明出来。后者身为一个函数而非函数模板，因此编译器可在调用它的时候使用隐式转换函数（例如Rational的non-explicit构造函数）。

（三）

代码改过以后可以通过编译，因为编译器知道我们要调用哪个函数（就是接受一个Rational<int>以及又一个Rational<int>的那个operator*），但是却不能成功连接。

不能连接的原因：

那个函数只是被声明于Rational内，并没有被定义出来，我们意图令此class外部的operator* template提供定义式，但是行不通——如果我们自己声明了一个函数（那正是Rational template内的作为），就有责任定义那个函数，既然我们没有提供定义式，连接器当然找不到它。

所以要解决这个问题的方法就是：将operator*函数本体合并至其声明式内：

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());
	}
};

我们虽然使用friend，却与friend的传统用途“访问class的non-public成分”毫不相干。为了让类型转换可能发生在所有参数身上，我们需要一个non-member函数：为了令这个函数被自动具现化，我们需要将它声明在一个class内部：而在class内部声明non-member函数的唯一办法就是：令他成为一个friend。
以上代码就可以顺利通过编译，连接，运行了！

（四）

定义于class内的函数都暗自成为inline，包括operator*这样的friend函数。你可以将这样的inline声明所带来的冲击最小化，做法是令operator*不做任何事情，只调用一个定义于class外部的辅助函数。Rational是个template意味着这个辅助函数通常也是一个template。

许多编译器实质上会强迫你把所有template定义式放进头文件内，所以你或许需要在头文件内定义doMultiply（条款30，这样的templates不需非得是inline不可），Rational头文件代码看起来像这样：

template<typename T> class Rational;
template<typename T>
const Rational<T> doMultiply (const Rational<T>& lhs, const Rational<T>& rhs);
//声明helper template

template <typename T>
class Rational {
public:
	...
	friend const Rational<T> operator* (const Rational<T>& lhs, const Rational<T>& 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()); 
}

请记住：

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