读书笔记 effective c++ Item 46 如果想进行类型转换,在模板内部定义非成员函数

简介: 1. 问题的引入——将operator*模板化 Item 24中解释了为什么对于所有参数的隐式类型转换,只有非成员函数是合格的,并且使用了一个为Rational 类创建的operator*函数作为实例。

1. 问题的引入——将operator*模板化

Item 24中解释了为什么对于所有参数的隐式类型转换,只有非成员函数是合格的,并且使用了一个为Rational 类创建的operator*函数作为实例。在继续之前建议你先回顾一下这个例子,因为这个条款的讨论是对它的扩展,我们会对Item 24的实例做一些看上去无伤大雅的修改:对Rational和opeartor*同时进行模板化:

 1 template<typename T>
 2 class Rational {
 3 public:
 4 Rational(const T& numerator = 0, // see Item 20 for why params
 5 
 6 const T& denominator = 1);         // are now passed by reference
 7 
 8 const T numerator() const;          // see Item 28 for why return
 9 
10 
11 const T denominator() const; // values are still passed by value,
12 ... // Item 3 for why they’re const
13 };
14 template<typename T>
15 const Rational<T> operator*(const Rational<T>& lhs,
16 const Rational<T>& rhs)
17 { ... }

 

正如Item 24中讨论的,我们想支持混合模式的算术运算,所以我们想让下面的代码通过编译。这应该没有问题,因为我们在Item 24中使用了相同的代码。唯一的区别是Rational和operator*现在变成了模板:

1 Rational<int> oneHalf(1, 2);            // this example is from Item 24,
2 // except Rational is now a template
3 
4 Rational<int> result = oneHalf * 2; // error! won’t compile

 

2. 问题分析——模板参数演绎不能进行隐式转换


但事实上上面的代码不会通过编译,这就表明了模板化的Rational和非模板版本有些地方还是不一样的,确实是有区别的。在Item 24中,编译器知道我们尝试调用什么函数(带两个Rational参数的operator*),但是这里,编译器不知道我们想要调用哪个函数。相反,它们尝试确认从模板operator*中实例化出(也即是创建)什么样的函数。它们知道它们想实例化一些名字为operator*的函数,这些函数带有两个类型为Rational<T>的参数,但是为了进行实例化,它们必须确认T是什么。问题是他们不可能知道

为了演绎出T类型,它们看到了调用operator*时传递的参数类型。在上面的例子中,两个参数类型分别是Rational<int>(oneHalf的类型)和int(2的类型)。每个参数进行单独考虑。

使用oneHalf进行演绎(deduction)很容易,operator*的第一个参数所需要的类型为Rational<T>,实际上这里传递给operator*的第一个参数的类型是Rational<int>,所以T必须为int。不幸的是,对其他参数的演绎就没有这么简单了,operator*的第二个参数所需要的类型也为Rational<T>,但是传递给operator*的第二个参数是一个int值。在这种情况下编译器该如何确认T是什么呢?你可能期望它们使用Rational<int>的非显示构造函数来将2转换为一个Rational<int>,这样就允许它们将T演绎成int,但是它们没有这么做。因为在模板参数演绎期间永远不会考虑使用隐式类型转换函数。这样的转换是在函数调用期间被使用的,所以在你调用一个函数之前,你必须知道哪个函数是存在的。为了知道这些,你就必须为相关的函数模板演绎出参数类型(然后你才能实例化出合适的函数。)但是在模板参数演绎期间不会通过调用构造函数来进行隐式转换Item 24没有涉及到模板,所以模板参数的演绎不是问题。现在我们正在讨论C++的模板部分(Item 1),这变为了主要问题。

 

3. 问题解决——使用友元函数

3.1 在类模板中声明友元函数——编译通过

 

我们可以利用如下事实来缓和编译器接受的对模板参数演绎的挑战:模板类中的一个友元声明能够引用一个实例化函数。这就意味着类Ration<T>能够为Ration<T>声明一个友元函数的operator*。类模板不再依赖于模板参数演绎(这个过程只应用于函数模板),所以T总是在类Ration<T>被实例化的时候就能被确认。所以声明一个合适的友元operator*函数能简化整个问题:

 1 template<typename T>
 2 class Rational {
 3 public:
 4 ...
 5 
 6 friend // declare operator*
 7 const Rational operator*(const Rational& lhs, // function (see
 8 const Rational& rhs); // below for details)
 9 };
10 
11 template<typename T>                                                              // define operator*
12 
13 const Rational<T> operator*(const Rational<T>& lhs, // functions  
14 
15 
16 const Rational<T>& rhs)
17 { ... }

 

现在我们对operator*的混合模式的调用就能通过编译了,因为当对象oneHalf被声明为类型Rational<int>的时候,Ratinonal<T>被实例化称Rational<int>,作为这个过程的一部分,参数为Rational<int>的友元函数operator*被自动声明。作为一个被声明的函数(不是函数模板),编译器在调用它时就能够使用隐式类型转换函数(像Rational的非显示构造函数),这就是如何使混合模式调用成功的

3.2 关于模板和模板参数的速写符号

虽然代码能够通过编译,但是却不能链接成功。我们稍后处理,但是对于上面的语法我首先要讨论的是在Rational中声明operator*。

在一个类模板中,模板的名字能够被用来当作模板和模板参数的速写符号,所以在Rational<T>中,我们可以写成Rational来代替Rational<T>。在这个例子中只为我们的输入减少了几个字符,但是如果有多个参数或者更长的参数名字的时候,它既能减少输入也能使代码看起来更清晰。我提出这些是因为在上面的例子中operator*的声明用Rational作为参数和返回值,而不是Rational<T>。下面的声明效果是一样的:

1 template<typename T>
2 class Rational {
3 public:
4 ...
5 friend
6 const Rational<T> operator*(const Rational<T>& lhs,
7 const Rational<T>& rhs);
8 ...
9 };

 

然而,使用速写形式更加容易(更加大众化)。

3.3 把友元函数的定义合并到声明中——链接通过

现在让我们回到链接问题。混合模式的代码能够通过编译,因为编译器知道我们想调用一个实例化函数(带两个Rational<int>参数的operator*函数),但是这个函数只在Rational内部进行声明,而不是被定义。我们的意图是让类外部的operator*模板提供定义,但是编译器不会以这种方式进行工作。如果我们自己声明一个函数(这是我们在Rational模板内部所做的),我们同样有责任去定义这个函数。在上面的例子中,我们并没有提供一个定义,这就是为什么连接器不能知道函数定义的原因。

最简单的可能工作的解决方案是将operator*函数体合并到声明中:

 1 template<typename T>
 2 class Rational {
 3 public:
 4 ...
 5 friend const Rational operator*(const Rational& lhs, const Rational& rhs)
 6 {
 7 return Rational(lhs.numerator() * rhs.numerator(), // same impl
 8 lhs.denominator() * rhs.denominator()); // as in
 9 } // Item 24
10 };
11 
12  

 

确实这能够工作:对operator*的混合模式调用,编译,链接,运行都没有问题。

3.4 如此使用友元函数很意思

这种技术的有意思的地方是友元函数并没有被用来访问类的非public部分。为了使所有参数间的类型转换成为可能,我们需要一个非成员函数(Item 24在这里仍然适用);并且为了让合适的函数被自动实例化出来,我们需要在类内部声明一个函数。在类内部声明一个非成员函数的唯一方法是将其声明为友元函数。这就是我们所做的,不符合惯例?是的。有效么?毋庸置疑。

4. 关于模板友元函数inline的讨论

正如在Item 30中解释的,在类内部定义的函数被隐式的声明为inline函数,这同样包含像operator*这样的友元函数。你可以最小化这种inline声明的影响:通过让operator*只调用一个定义在类体外的helper函数。在这个条款的例子中没有必要这么做,因为operator*已经被实现成了只有一行的函数,对于更加复杂的函数体,helper才可能是你想要的。“让友元函数调用helper”的方法值得一看。

Rationl是模板的事实意味着helper函数通常情况下也会是一个模板,所以在头文件中定义Rational的代码会像下面这个样子:

 1 template<typename T> class Rational; // declare
 2 // Rational
 3 // template
 4 
 5 template<typename T> // declare
 6 const Rational<T> doMultiply( const Rational<T>& lhs, // helper
 7 
 8 const Rational<T>& rhs);                                         // template
 9 
10 template<typename T>
11 class Rational {
12 public:
13 ...
14 friend
15 const Rational<T> operator*(const Rational<T>& lhs,
16 const Rational<T>& rhs)                                          // Have friend
17 
18  
19 
20 { return doMultiply(lhs, rhs); }                // call helper
21 
22 ...                                                            
23 
24 };           

                                                 

许多编译器从根本上强制你将所有的模板定义放在头文件中,所以你可能同样需要在你的头文件中定义doMultiply。(正如Item30解释的,这样的模板不需要inline)。这会像下面这个样子:

template<typename T> // define
const Rational<T> doMultiply(const Rational<T>& lhs, // helper
const Rational<T>& rhs) // template in
{ // header file,
return Rational<T>(lhs.numerator() * rhs.numerator(), // if necessary
lhs.denominator() * rhs.denominator());
}

当然,作为一个模板,doMultiply不支持混合模式的乘法,但是也不需要支持。它只被operator*调用,operator*支持混合模式操作就够了!从根本上来说,函数operator*支持必要的类型转换,以确保两个Rational对象被相乘,然后它将这两个对象传递到doMultiply模板的合适实例中进行实际的乘法操作。协同行动,不是么?

5. 总结

当实现一个提供函数的类模版时,如果这些函数的所有参数支持和模板相关的隐式类型转换,将这些函数定义为类模板内部的友元函数。


作者: HarlanC

博客地址: http://www.cnblogs.com/harlanc/
个人博客: http://www.harlancn.me/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出, 原文链接

如果觉的博主写的可以,收到您的赞会是很大的动力,如果您觉的不好,您可以投反对票,但麻烦您留言写下问题在哪里,这样才能共同进步。谢谢!

目录
相关文章
|
14天前
|
存储 C++
【C++】string类的使用③(非成员函数重载Non-member function overloads)
这篇文章探讨了C++中`std::string`的`replace`和`swap`函数以及非成员函数重载。`replace`提供了多种方式替换字符串中的部分内容,包括使用字符串、子串、字符、字符数组和填充字符。`swap`函数用于交换两个`string`对象的内容,成员函数版本效率更高。非成员函数重载包括`operator+`实现字符串连接,关系运算符(如`==`, `&lt;`等)用于比较字符串,以及`swap`非成员函数。此外,还介绍了`getline`函数,用于按指定分隔符从输入流中读取字符串。文章强调了非成员函数在特定情况下的作用,并给出了多个示例代码。
|
14天前
|
C++
【C++】string类的使用④(常量成员Member constants)
C++ `std::string` 的 `find_first_of`, `find_last_of`, `find_first_not_of`, `find_last_not_of` 函数分别用于从不同方向查找目标字符或子串。它们都返回匹配位置,未找到则返回 `npos`。`substr` 用于提取子字符串,`compare` 则提供更灵活的字符串比较。`npos` 是一个表示最大值的常量,用于标记未找到匹配的情况。示例代码展示了这些函数的实际应用,如替换元音、分割路径、查找非字母字符等。
|
14天前
|
编译器 C++
【C++】类和对象⑤(static成员 | 友元 | 内部类 | 匿名对象)
📚 C++ 知识点概览:探索类的`static`成员、友元及应用🔍。
|
14天前
|
算法 C++ 容器
|
14天前
|
存储 编译器 程序员
|
6天前
|
设计模式 安全 编译器
【C++11】特殊类设计
【C++11】特殊类设计
25 10
|
11天前
|
C++
C++友元函数和友元类的使用
C++中的友元(friend)是一种机制,允许类或函数访问其他类的私有成员,以实现数据共享或特殊功能。友元分为两类:类友元和函数友元。类友元允许一个类访问另一个类的私有数据,而函数友元是非成员函数,可以直接访问类的私有成员。虽然提供了便利,但友元破坏了封装性,应谨慎使用。
41 9
|
6天前
|
存储 编译器 C语言
【C++基础 】类和对象(上)
【C++基础 】类和对象(上)
|
14天前
|
编译器 C++
【C++】string类的使用④(字符串操作String operations )
这篇博客探讨了C++ STL中`std::string`的几个关键操作,如`c_str()`和`data()`,它们分别返回指向字符串的const char*指针,前者保证以&#39;\0&#39;结尾,后者不保证。`get_allocator()`返回内存分配器,通常不直接使用。`copy()`函数用于将字符串部分复制到字符数组,不添加&#39;\0&#39;。`find()`和`rfind()`用于向前和向后搜索子串或字符。`npos`是string类中的一个常量,表示找不到匹配项时的返回值。博客通过实例展示了这些函数的用法。