当前位置:天才代写 > tutorial > C语言/C++ 教程 > C++箴言:范例转换时界说非成员函数

C++箴言:范例转换时界说非成员函数

2017-11-06 08:00 星期一 所属: C语言/C++ 教程 浏览:462

副标题#e#

《C++箴言:声明为非成员函数的机缘》叙述了为什么只有 non-member functions(非成员函数)适合于应用到所有 arguments(实参)的 implicit type conversions(隐式范例转换),并且它还作为一个示例利用了一个 Rational class 的 operator* function。我发起你在阅读本文之前先熟悉谁人示例,因为本文举办了针对《C++箴言:声明为非成员函数的机缘》中的示例做了一个无感冒雅(模板化 Rational 和 operator*)的扩展接头:

template<typename T>
class Rational {
public:
Rational(const T& numerator = 0, // see《C++箴言:用传引用给const代替传值》for why params
const T& denominator = 1); // are now passed by reference
const T numerator() const; // see《C++箴言:制止返回工具内部构件的句柄》for why return
const T denominator() const; // values are still passed by value,
... // Item 3 for why they're const
};
template<typename T>
const Rational<T> operator*(const Rational<T>& lhs,
const Rational<T>& rhs)
{ ... }

就像在《C++箴言:声明为非成员函数的机缘》中,我想要支持 mixed-mode arithmetic(殽杂模式运算),所以我们要让下面这些代码可以或许编译。我们指望它能,因为我们利用了和 Item 24 中可以事情的代码沟通的代码。仅有的区别是 Rational 和 operator* 此刻是 templates(模板):

Rational<int> oneHalf(1, 2); // this example is from 《C++箴言:声明为非成员函数的机缘》,
// except Rational is now a template
Rational<int> result = oneHalf * 2; // error! won't compile

编译失败的事实体现对付模板化 Rational 来说,有某些对象和 non-template(非模板)版本差异,并且确实存在。在《C++箴言:声明为非成员函数的机缘》中,编译器知道我们想要挪用什么函数(取得两个 Rationals 的 operator*),可是在这里,编译器不知道我们想要挪用哪个函数。作为替代,它们试图断定要从名为 operator* 的 template(模板)中实例化出(也就是建设)什么函数。它们知道它们假定实例化出的某个名为 operator* 的函数取得两个 Rational<T> 范例的参数,可是为了做这个实例化,它们必需断定 T 是什么。问题在于,它们做不到。


#p#副标题#e#

在推演 T 的实验中,它们会察看被传入 operator* 的挪用的 arguments(实参)的范例。在当前环境下,范例为 Rational<int>(oneHalf 的范例)和 int(2 的范例)。每一个参数被别离考查。

利用 oneHalf 的推演很简朴。operator* 的第一个 parameter(形参)被声明为 Rational<T> 范例,而传入 operator* 的第一个 argument(实参)(oneHalf) 是 Rational<int> 范例,所以 T 必然是 int。不幸的是,对其它参数的推演没那么简朴。operator* 的第二个 parameter(形参)被声明为 Rational<T> 范例,可是传入 operator* 的第二个 argument(实参)(2) 的 int 范例。在这种环境下,让编译器如何断定 T 是什么呢?你大概期望它们会利用 Rational<int> 的 non-explicit constructor(非显式结构函数)将 2 转换成一个 Rational<int>,这样就使它们推表演 T 是 int,可是它们不这样做。它们不这样做是因为在 template argument deduction(模板实参推演)进程中从不思量 implicit type conversion functions(隐式范例转换函数)。从不。这样的转换可用于函数挪用进程,这没错,可是在你可以挪用一个函数之前,你必需知道哪个函数存在。为了知道这些,你必需为相关的 function templates(函数模板)推表演 parameter types(参数范例)(以便你可以实例化出符合的函数)。可是在 template argument deduction(模板实参推演)进程中不思量经过 constructor(结构函数)挪用的 implicit type conversion(隐式范例转换)。《C++箴言:声明为非成员函数的机缘》不包罗 templates(模板),所以 template argument deduction(模板实参推演)不是一个问题,此刻我们在 C++ 的 template 部门,这是主要问题。

#p#副标题#e#

在一个 template class(模板类)中的一个 friend declaration(友元声明)可以指涉到一个特定的函数,我们可以操作这一事实为受到 template argument deduction(模板实参推演)挑战的编译器获救。这就意味着 class Rational<T> 可觉得 Rational<T> 声明作为一个 friend function(友元函数)的 operator*。class templates(类模板)不依靠 template argument deduction(模板实参推演)(这个进程仅合用于 function templates(函数模板)),所以 T 在 class Rational<T> 被实例化时老是已知的。通过将适当的 operator* 声明为 Rational<T> class 的一个 friend(友元)使其变得容易:

template<typename T>
class Rational {
public:
...
friend // declare operator*
const Rational operator*(const Rational& lhs, // function (see
const Rational& rhs); // below for details)
};
template<typename T> // define operator*
const Rational<T> operator*(const Rational<T>& lhs, // functions
const Rational<T>& rhs)
{ ... }

#p#分页标题#e#

此刻我们对 operator* 的殽杂模式挪用可以编译了,因为当 object oneHalf 被声明为 Rational<int> 范例时,class Rational<int> 被实例化,而作为这一进程的一部门,取得 Rational<int> parameters(形参)的 friend function(友元函数)operator* 被自动声明。作为已声明函数(并非一个 function template(函数模板)),在挪用它的时候编译器可以利用 implicit conversion functions(隐式转换函数)(譬如 Rational 的 non-explicit constructor(非显式结构函数)),而这就是它们如何使得殽杂模式挪用乐成的。

#p#副标题#e#

唉,在这里的上下文中,“乐成”是一个好笑的词,因为尽量代码可以编译,可是不能毗连。可是我们过一会儿再处理惩罚它,首先我想接头一下用于在 Rational 内声明 operator* 的语法。

在一个 class template(类模板)内部,template(模板)的名字可以被用做 template(模板)和它的 parameters(参数)的缩写,所以,在 Rational<T> 内部,我们可以只写 Rational 取代 Rational<T>。在本例中这只为我们节减了几个字符,可是当有多个参数或有更长的参数名时,这既能节减击键次数又能使最终的代码显得更清晰。我把这一点提前,是因为 operator* 被声明为取得并返回 Rationals,而不是 Rational<T>s。它就像如下这样声明 operator* 一样正当:

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

然而,利用缩写形式更简朴(并且更常用)。

此刻返回到毗连问题。殽杂模式代码编译,因为编译器知道我们想要挪用一个特定的函数(取得一个 Rational<int> 和一个 Rational<int> 的 operator*),可是谁人函数只是在 Rational 内部声明,而没有在此处界说。我们的意图是让 class 之外的 operator* template(模板)提供这个界说,可是这种要领不能事情。假如我们本身声明一个函数(这就是我们在 Rational template(模板)内部所做的事),我们就有责任界说这个函数。当前环境是,我们没有提供界说,这也就是毗连器为什么不能找到它。

让它能事情的最简朴的要领或者就是将 operator* 的本体归并到它的 declaration(界说)中:

#p#副标题#e# template<typename T>
class Rational {
public:
...
friend const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(), // same impl
lhs.denominator() * rhs.denominator()); // as in
} //《C++箴言:声明为非成员函数的机缘》
};

确实,这样就可以切合预期地事情:对 operator* 的殽杂模式挪用此刻可以编译,毗连,并运行。万岁!

关于此技能的一个有趣的调查结论是 friendship 的利用对付会见 class 的 non-public parts(非公有构件)的需求并没有起到什么浸染。为了让所有 arguments(实参)的 type conversions(范例转换)成为大概,我们需要一个 non-member function(非成员函数)(《C++箴言:声明为非成员函数的机缘》 依然合用);而为了能自动实例化出适当的函数,我们需要在 class 内部声明这个函数。在一个 class 内部声明一个 non-member function(非成员函数)的独一要领就是把它做成一个 friend(友元)。那么这就是我们做的。反传统吗?是的。有效吗?毫无疑问。

就像《C++箴言:领略inline化的参与和解除》叙述的,界说在一个 class 内部的函数被隐式地声明为 inline(内联),而这也包罗像 operator* 这样的 friend functions(友元函数)。你可以让 operator* 不做什么工作,只是挪用一个界说在这个 class 之外的 helper function(帮助函数),从而让这样的 inline declarations(内联声明)的影响最小化。在本文的这个示例中,没有出格指出这样做,因为 operator* 已经可以实现为一个 one-line function(单行函数),可是对付更巨大的函数体,这样做也许是符合的。"have the friend call a helper"(“让友元挪用帮助函数”)的要领照旧值得留意一下的。

 

    关键字:

天才代写-代写联系方式