Effective Modern C++[实践]-＞理解模板类别的推导

已于 2022-06-27 15:48:28 修改
阅读量255 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-06-27 12:09:42 首次发布
本文原创作者：-西门吹雪 MMTS_yang
本文链接：https://blog.csdn.net/mmts_yang/article/details/125480367
版权
本文详细探讨了C++模板类型推导的过程，通过四个不同情形展示了如何根据函数参数类型推导T和ParamType。情形1中，ParamType为非万能引用的引用或指针，情形2添加了const限定，情形3和4涉及指针。通过删除函数模板和编译器输出，分析了不同类型参数如何影响模板实例化。
摘要由CSDN通过智能技术生成

理解模板类别的推导

绪

函数模板伪代码如下：

template<typename T>
void f(ParamType param);

一次调用的形如f(expr);,编译器用 expr 来推导两个类型： T 和 ParamType。 这些类型经常是不一样的，因为 ParamType 一般带有限定符，如 const 或引用。
T 的类型推导不仅仅依赖于expr的类型， 还依赖于 ParamType的格式。具体需要从三个方面讨论：
如何查看模板类型参数导出的类型的方法
方式1：
见如下连接
How can I see the type deduced for a template type parameter?
在这里插入图片描述方式2：
点击网址打开Compiler查看生成的代码，如下
在这里插入图片描述

ParamType 是个指针或引用，但不是万能引用

类型推导步骤为：

  1. 若expr具有引用类型，先将引用部分忽略
  2. 之后，对expr的类别和ParamType的类别进行匹配来决定T的类别。

情形1 f(T& a)

方式1

使用删除的模板函数

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;
//情形1
template<typename T>
void f(T& a)=delete ;
int main() {
    int x = 22;
    const int lx = x;
    const int &rx = x;
    int&& rx1 = 27;
    const int*px = &x;
    int*px1 = &x;

    f(x); 		
    f(lx);	
    f(rx);		
    f(rx1);       
    f(px);    
    f(px1);   
    f(*px);     
    f(*px1);    
}

编译输出如下：

<source>: In function 'int main()':
<source>:17:6: error: use of deleted function 'void f(T&) [with T = int]'
   17 |     f(x);
      |     ~^~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:18:6: error: use of deleted function 'void f(T&) [with T = const int]'
   18 |     f(lx);
      |     ~^~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:19:6: error: use of deleted function 'void f(T&) [with T = const int]'
   19 |     f(rx);
      |     ~^~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:20:6: error: use of deleted function 'void f(T&) [with T = int]'
   20 |     f(rx1);
      |     ~^~~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:21:6: error: use of deleted function 'void f(T&) [with T = const int*]'
   21 |     f(px);
      |     ~^~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:22:6: error: use of deleted function 'void f(T&) [with T = int*]'
   22 |     f(px1);
      |     ~^~~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:23:6: error: use of deleted function 'void f(T&) [with T = const int]'
   23 |     f(*px);
      |     ~^~~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^
<source>:24:6: error: use of deleted function 'void f(T&) [with T = int]'
   24 |     f(*px1);
      |     ~^~~~~~
<source>:8:6: note: declared here
    8 | void f(T& a)=delete ;
      |      ^

从输出的结果可看出推导的类型

方式2

// Compile with /W4

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f(T& a){
    cout<<__func__<<"    "<<a<<endl;
} ;
int main() {
    int x = 22;
    const int lx = x;
    const int &rx = x;
    int&& rx1 = 27;
    const int*px = &x;
    int*px1 = &x;

    //void f<int>(int&)
    f(x); 		//T  int；		ParamType  int&
    //void f<int const>(int const&)
    f(lx);		//T const int； ParamType  const int&
    //void f<int const>(int const&)
    f(rx);		//T const int； ParamType  const int&
    // void f<int>(int&)
    f(rx1);             //T  int；		ParamType  int&
    //void f<int const*>(int const*&)
    f(px);      //T  const int*；	ParamType const int *&
    //void f<int*>(int*&)
    f(px1);     //T   int*；		ParamType  int*&
    //void f<int const>(int const&)
    f(*px);     //T const int；     ParamType  const int&
    //void f<int>(int&)
    f(*px1);    //T  int；		    ParamType  int&
}

生成的汇编代码如下：

...
        mov     rdi, rax
        call    void f<int>(int&)
        lea     rax, [rbp-24]
        mov     rdi, rax
        call    void f<int const>(int const&)
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax
        call    void f<int const>(int const&)
        mov     rax, QWORD PTR [rbp-16]
        mov     rdi, rax
        call    void f<int>(int&)
        lea     rax, [rbp-40]
        mov     rdi, rax
        call    void f<int const*>(int const*&)
        lea     rax, [rbp-48]
        mov     rdi, rax
        call    void f<int*>(int*&)
        mov     rax, QWORD PTR [rbp-40]
        mov     rdi, rax
        call    void f<int const>(int const&)
        mov     rax, QWORD PTR [rbp-48]
        mov     rdi, rax
        call    void f<int>(int&)
        mov     eax, 0
        leave
        ret
 ...

输出结果为

f    22
f    22
f    22
f    27
f    0x7ffdfd4ae16c
f    0x7ffdfd4ae16c
f    22
f    22

结论如下：

expr f(expr)TParamTypeinstance
int xf(x)intint&void f<int>(int&)
const int lx f(lx)const intconst int&void f<int const>(int const&)
const int &rxf(rx)const intconst int&void f<int const>(int const&)
int&& rx1f(rx1)intint&void f<int>(int&)
const int*pxf(px)const int*const int* &void f<int const*>(int const*&)
int*px1f(px1)int *int* &void f<int*>(int*&)
const int*pxf(*px)const intconst int&void f<int const>(int const&)
int*px1f(*px1)intint&void f<int>(int&)

情形2 f(const T& a)

代码

// Compile with /W4

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f(const T& a){
    cout<<__func__<<"    "<<a<<endl;
} ;
int main() {
    int x = 22;
    const int lx = x;
    const int &rx = x;
    int&& rx1 = 27;
    const int*px = &x;
    int*px1 = &x;

    f(x); 		
    f(lx);	
    f(rx);	
    f(rx1);       
    f(px);   
    f(px1);   
    f(*px);    
    f(*px1);   
}

生成汇编代码如下：

...
        call    void f<int>(int const&)
...
        call    void f<int>(int const&)
...
        call    void f<int>(int const&)
...
        call    void f<int>(int const&)
...
        call    void f<int const*>(int const* const&)
...
        call    void f<int*>(int* const&)
...
        call    void f<int>(int const&)
..
        call    void f<int>(int const&)

结论

expr f(expr)TParamTypeinstance
int xf(x)intconst int&void f<int>(int const&)
const int lx f(lx)intconst int&void f<int>(int const&)
const int &rxf(rx)intconst int&void f<int>(int const&)
int&& rx1f(rx1)intconst int&void f<int>(int const &)
const int*pxf(px)const int*const int* &void f<int const*>(int const* const&)
int*px1f(px1)int *int* &void f<int*>(int* const &)
const int*pxf(*px)intconst int&void f<int>(int const&)
int*px1f(*px1)intconst int&void f<int>(int const&)

情形3 f(T* a)

代码

// Compile with /W4

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f(T* a){
    cout<<__func__<<"    "<<*a<<endl;
} ;

// template<typename T>
// void f(T*& a)=delete;

int main() {
    int x = 22;
    const int lx = x;
    const int &rx = x;
    int&& rx1 = 27;
    const int*px = &x;
    int*px1 = &x;

    f(&x); 		
    f(&lx);	
    f(&rx);	
    f(&rx1);       
    f(px);   
    f(px1);   
    // f(*px);  //  no matching function for call to 'f(const int&)'
    // f(*px1); //error: no matching function for call to 'f(int&)'  
}

生成的汇编代码如下：

   		 call    void f<int>(int*)
		 ...
        call    void f<int const>(int const*)
		...
        call    void f<int const>(int const*)
		...
        call    void f<int>(int*)
		...
        call    void f<int const>(int const*)
		...
        call    void f<int>(int*)
		...

结论

expr f(expr)TParamTypeinstance
int xf(x)intint&*void f<int>(int *)
const int lx f(lx)const intconst int*void f<int>(int const*)
const int &rxf(rx)int constconst int*void f<int>(int const*)
int&& rx1f(rx1)intint*void f<int>(int*)
const int*pxf(px)const intconst int*void f<int const>(int const*)
int*px1f(px1)int *int*void f<int*>(int*)

情形4 f(const T* a)

与情形2类似不做讨论

ParamType 是个万能引用

推导规则会区分左值和右值

  1. expr是左值，T和ParamType都会被推导为左值
  2. expr是右值，则应用《 ParamType 是个指针或引用，但不是万能引用》规则。
// Compile with /W4

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f4(T&& a)=delete ;

int main() {
    int x = 22;
    const int lx = x;
    const int &rx = x;
    const int && yy = 27;

    f4(x); // 左值 ：T   int&；	         ParamType int &
    f4(lx);// 左值 ：T   const int&；	 ParamType const int&
    f4(rx);// 左值 ：T   const int&；	 ParamType const int*
    f4(26);// 右值 ：T   int；	 	     ParamType int &&
    f4(yy);// 左值 ：T   const int&；	 ParamType const int&
}

编译结果如下

<source>: In function 'int main()':
<source>:18:7: error: use of deleted function 'void f4(T&&) [with T = int&]'
...
<source>:19:7: error: use of deleted function 'void f4(T&&) [with T = const int&]'
...
<source>:20:7: error: use of deleted function 'void f4(T&&) [with T = const int&]'
...
<source>:21:7: error: use of deleted function 'void f4(T&&) [with T = int]'
...
<source>:22:7: error: use of deleted function 'void f4(T&&) [with T = const int&]'
...

详见右值引用的相关博客

ParamType 既非指针也非引用

template<typename T>
void f(T a)=delete ;

这种情况就是按值进行传递，无论下述代码中，传入什么，a都会是它的一个副本，也就是说是一个全新的对象。

推到规则如下：

  1. 若expr是引用类别，那么忽略掉
  2. 忽略掉expr的引用特性后，若expr是const对象也忽略，若expr是个volatile对象同样忽略。
// Compile with /W4

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f(T a)=delete ;


int main() {
    int x = 22;
    const int lx = x;
    const int &rx = x;
    const int && yy = 27;
    const char*const ptr = "xi_men_chui_xue";

    f(x);
    f(lx);
    f(rx);
    f(26);
    f(yy);
    f(ptr); //T 为const char * 
}

<source>:20:6: error: use of deleted function 'void f(T) [with T = int]'
...
<source>:21:6: error: use of deleted function 'void f(T) [with T = int]'
...
<source>:22:6: error: use of deleted function 'void f(T) [with T = int]'
...
<source>:23:6: error: use of deleted function 'void f(T) [with T = int]'
...
<source>:24:6: error: use of deleted function 'void f(T) [with T = int]'
...
<source>:25:6: error: use of deleted function 'void f(T) [with T = const char*]'
...

注： 在推导过程中，ptr所指内容的常量性会得到保留，但是其自身的常量性被忽略

数组实参

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f(T a){} ;

template<typename T>
void f1(T& a){} ;

template<typename T,std::size_t N>
constexpr std::size_t arraySize(T (&)[N])noexcept{
    return N;
}

int main() {
    const char name[]= "xi men chui da xue";

    f(name);
    f1(name);
    arraySize(name);
}

生成的汇编代码如下：

...
        call    void f<char const*>(char const*)
...
        call    void f1<char const [19]>(char const (&) [19])
...
        call    unsigned long arraySize<char const, 19ul>(char const (&) [19ul])
...

结论：

  1. ParamType非指针非引用 即按值传递，按值传递给函数模板的数组类别会被推导程指针类别。
  2. 按引用传递给函数模板的会被推导程数组类别，这个类别会包含数组的尺寸

函数实参

同数组实参类似。

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

using namespace std;

template<typename T>
void f(T a){} ;

template<typename T>
void f1(T& a){} ;

void function(){
}

int main() {
    const char name[]= "xi men chui da xue";
    f(function);//退化为指针
    f1(function);//推导为函数引用

}

汇编代码如下：

        mov     QWORD PTR [rbp-32], rax
        mov     QWORD PTR [rbp-24], rdx
        mov     DWORD PTR [rbp-17], 6649208
        mov     edi, OFFSET FLAT:function()
        call    void f<void (*)()>(void (*)())
        mov     edi, OFFSET FLAT:function()
        call    void f1<void ()>(void (&)())
        mov     eax, 0
-西门吹雪
关注
专栏目录
Effective Modern C++ 条款1：理解模板类型推导
cf18862344377的博客
04-27 942
更多C++学习笔记，关注 wx公众号：cpp读书笔记对于一个复杂系统的用户来说，很多时候他们最关心的是它做了什么而不是它怎么做的。在这一点上，C++中的模板类型推导表现得非常出色。数百万的程序员只需要向模板函数传递实参，就能通过编译器的类型推导获得令人满意的结果，尽管他们中的大多数在被逼无奈的情况下，对于传递给函数的那些实参是如何引导编译器进行类型推导的，也只能给出非常模糊的描述。如果那些人中包括你，我有一个好消息和一个坏消息。好消息是现在C++最重要最吸引人的特性auto是建立在模板类型推导的基础上的。
Modern-C++学习: auto和模板的推导规则
m0_64396392的博客
10-26 635
名词说明 通用引用: auto&&, T&&可以接受任意类型:其中:T&&声明在类型推导的时候才作为通用引用非类型推导考虑如下情况: 属性: const, &, &&, volatile, static… 类型: int, double, float…值类型说明 规则一 情况一:auto, typename T的默认情况 情况二:声明为指针或引用, 但非通用引用 情况三:通用引用 错误案例: 看到, 这里可能会疑惑,我的说法是不是错了, 通用引用为什么变成了左值引用? 对此, 你需要知道的是
Effective Modern C++
04-25
Effective Modern C++主要讲解了现代C++的一些特性（auto、智能指针、lambda表达式等)
Modern Effective C++前期知识(一)
最新发布
风间琉璃的博客
08-11 998
Modern Effective C++带你体验前所未有的C++学习之旅！
Effective Modern c++ 智能指针
https://gitcode.net/liuyuan185442111
12-19 447
std::unique_ptr占用空间大小 当使用默认删除器时，可以合理假设std::unique_ptr和原始指针大小相同。当自定义删除器时，情况可能不再如此。删除器是个函数指针，通常会使std::unique_ptr的大小grow from one word to two。如果删除器是函数对象，大小取决于函数对象中存储的状态多少，无状态函数对象（比如没有状态捕获的lambda表达式）对大小没有影响。因此当一个自定义的deleter可以实现为一个函数对象或无捕获状态的lambda表达式时，应优先选择后者。
《Effective Modern C++》翻译--条款1: 理解模板类型推导
一蓑烟雨任平生 也无风雨也无晴
01-10 8841
北京2016年1月9日13:47:17 开始第一章的翻译。 第一章名为 类型推断 分为四个条款： 1理解模板类型推导 2理解auto自动类型推导 3理解decltype操作符 4如何对待推导的类型第一章 类型推导C++98有一套单一的类型推导的规则用来推导函数模板。C++11轻微的修改了这些规则并且增加了两个推导规则，一个用于auto，一个用于decltype。接着C++14扩展了auto和decl
条款1:理解模板类型推导
L_H_L的博客
02-18 149
函数模板大致形式如下: template<typename T> void f(ParamType parem); 调用形式如下： f(expr); 在编译期，编译器会通过expr推导两个类型：一个是T的类型，另一个是ParamType的类型;其中T的类型推导结果不仅仅依赖expr的类型，还依赖ParamType的形式，而`ParamType分以下几种情况： ParamType是个指针或引用，但不是万能引用 template<typename T> void f(T&
Effective.Modern.C++-42.Specific.Ways.to.Improve.Your.Use.of.C++11.and.C++14
11-25
《Effective Modern C++：42 Specific Ways to Improve Your Use of C++11 and C++14》是Scott Meyers继其早期的经典《Effective C++》系列书籍之后，专门针对C++11和C++14标准所著的实践指南。本书不仅介绍了C++11...
Effective Modern C++ 纯人工翻译，持续更新，不为博你眼球，旨在自我提升
07-12 1770
纯手动翻译Effective Modern C++，志在学习，不为博你眼球！
Effective Modern C++11
12-19
Effective系列的C++11书籍，英文版的，好好学习吧，少年~
Effective.Modern.C++.zip
09-14
Coming to grips with C++11 and C++14 is more than a matter of familiarizing yourself with the features they introduce (e.g., auto type declarations, move semantics, lambda expressions, and concurrency support). The challenge is learning to use those features effectively—so that your software is correct, efficient, maintainable, and portable. That’s where this practical book comes in. It describes how to write truly great software using C++11 and C++14—i.e. using modern C++. Topics include: The pros and cons of braced initialization, noexcept specifications, perfect forwarding, and smart pointer make functions The relationships among std::move, std::forward, rvalue references, and universal references Techniques for writing clear, correct, effective lambda expressions How std::atomic differs from volatile, how each should be used, and how they relate to C++'s concurrency API How best practices in "old" C++ programming (i.e., C++98) require revision for software development in modern C++ Effective Modern C++ follows the proven guideline-based, example-driven format of Scott Meyers' earlier books, but covers entirely new material. "After I learned the C++ basics, I then learned how to use C++ in production code from Meyer's series of Effective C++ books. Effective Modern C++ is the most important how-to book for advice on key guidelines, styles, and idioms to use modern C++ effectively and well. Don't own it yet? Buy this one. Now". -- Herb Sutter, Chair of ISO C++ Standards Committee and C++ Software Architect at Microsoft
Item1——理解模板类型推导(Understand template type deduction)
感觉画质不如...原神的博客
12-11 184
Effective Modern C++
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-西门吹雪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值