开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> C++知识库 -> Modern C++核心内容（一）—— 函数模板和auto关键字的类型推导 -> 正文阅读

[C++知识库]Modern C++核心内容（一）—— 函数模板和auto关键字的类型推导

说到C++的类型推导，绝大部分的C++ programmer都不陌生，多多少少在编码的过程中都会用到，尤其是进入C++ 11之后，就算不用函数模板也免不了会用auto，绝大部时候，即便不了解内部的推导规则，往往也能得到预期的结果，但如果不了解内部机制有可能会犯一些非预期的错误，而且了解内部机制也有利于我们写出更优的代码，Modern C++（c++ 11之后版本的统称）包含了三种类型推导：原有的函数模板推导，以及新增的auto推导和decltype推导，在C++14之后进而增加了auto和decltype结合的使用方式，其中模板函数推导和auto推导很类似，这篇文章就来聊一聊这两种最常见的类型推导，decltype以后再讨论。本篇的内容主要是结合看过的Effective Modern C++、网上关于类型推导的内容以及自己的一些理解和思考，例子主要来自Effective Modern C++，这本书写得很不错，而且很实用，强烈推荐，中英文版我都看过，中文版翻译得还可以，但有些地方有笔误，感觉还是英文版看起来更顺。

一、函数模板中的类型推导

在C++ 11之前，只有在函数模板这个场景下才会有类型推导，这也是最经典的一种类型推导，可以让我们写一个模板同时支持各种类型，而且不需要手动指定类型，本质上实在编译过程中根据实际的调用情况生成所需要的函数，也就是所谓的实例化。以下是一个典型的函数模板的定义和使用：

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

//调用
f(expr);

函数模板的类型推导里，涉及到以下三个部分：

T：模板参数，这个大家应该都不陌生，对于某些不使用推导的函数模板需要在尖括号里指定才能实例化。
ParamType：实例化后的函数形参类型。
expr：用来调用的表达式。

在编译过程实例化的时候，进行类型推导的依据就是expr，而推导的目标有两部分，一是T，二是ParamType，ParamType决定了生成的函数的实际形参类型，而T则是用来在函数内部进行相应类型的声明，同时在嵌套调用其他模板的时候也很有用，比如Modern C++中很重要的一个特性完美转发就需要用到T中隐含的信息。

对于函数模板中的类型推导，可以总结为以下三类：

ParamType是引用或者指针，但不是万能引用（Universal Reference）
ParamType是万能引用（Universal Reference）
ParamType既不是指针，也不是引用

1.1 ParamType是引用或者指针，但不是万能引用（Universal Reference）

这种类型也是我们最常见的一种类型，其中核心的推导规则如下：

忽略expr的引用属性。
把expr和ParamType进行模式匹配，进而确定T。

其中第一条规则很好理解，调用表达式是不是引用不影响推导结果，这和我们调用普通函数也一样，参数进入函数是传值还是传引用完全却决于函数形参而不是实参。而第二条所说的进行模式匹配则稍微灵活一些，本质上是综合考虑ParamType的额外限制和expr的额外限制，以下是一个ParamType为引用的典型例子

template<typename T>
void f(T& param);    // param is a reference and we have these variable declarations,

int x = 27;             // x is an int
const int cx = x;       // cx is a const int
const int& rx = x;      // rx is a reference to x as a const int

f(x);                   // T is int, param's type is int&
f(cx);                  // T is const int, param's type is const int&
f(rx);                  // T is const int, param's type is const int&

这里的ParamType是T&，也就是需要形参为引用，三个expr的类型分别是int，const int和const int&，也就是考虑以下三个模式匹配：

int 和 T&，expr就是一个没有啥额外要求的int，ParamType的附加条件是引用，所以推出来的ParamType是 int&，要int& == T&，T自然是int。
const int 和 T&，expr的附加条件是const，ParamType的附加条件是引用，所以推出来的ParamType是const int&，要const int& == T&，T自然是const int。
因为不考虑expr的引用属性，所以推导结果和2完全一样。

我们再来看一个ParamType是const T&的例子，和上面那个例子的区别就是ParamType多了个const：

template<typename T>
void f(const T& param);  // param is now a ref-to-const

int x = 27;              // as before
const int cx = x;        // as before
const int& rx = x;       // as before

f(x);                    // T is int, param's type is const int&
f(cx);                   // T is int, param's type is const int&
f(rx);                   // T is int, param's type is const int&

ParamType是const T&，也就是形参需要为const引用，三个expr的类型分别是int，const int和const int&，也就是以下三个模式匹配：

int 和 const T&，expr是一个没有啥额外要求的int，ParamType的附加条件是const引用，所以推出来的ParamType是 const int&，要const int& == const T&，T自然是int。
const int 和 const T&，expr的附加条件是const，ParamType的附加条件是const引用，合起来推出来的ParamType自然是const int&，const int& == const T&，T仍然是int。
因为不用考虑expr的引用属性，推导情况同2。

template<typename T>
void f(T* param);        // param is now a pointer

int x = 27;              // as before
const int *px = &x;      // px is a ptr to x as a const int

f(&x);                   // T is int, param's type is int*
f(px);                   // T is const int, param's type is const int*

指针本质上和引用是一样的，所以推导也类似，这里ParamType是T*，也就是需要形参为指针，两个expr的类型分别是int*，和const int *，也就是以下两个模式匹配：

int和 T，expr是一个int*，而ParamType也是T*，都是要指针没其他附加条件，所以推出来的ParamType是 int*，要 int* == const T*，T自然是int。
const int* 和 T*，expr除了指针外的附加条件是const，ParamType只是T*，所以推出来的ParamType是const int*，要const int* == T*，T自然是const int。

一切都是那么的自然。

1.2 ParamType是万能引用（Universal Reference）

这种情况是相对特殊的一种，首先是ParamType必须为T&&这种形式，看上去像是右值的定义，但是在包含类型推导的函数模板里有着特殊的含义，也就是所谓的万能引用，完美转发就是通过万能引用来实现的，后面详细聊一聊，总的来说核心规则如下：

如果expr是左值，T和ParamType都会被推导为左值引用。这也是整个函数模板类型推导里T唯一会被推导成引用的情况。
如果expr是右值，推导方式参照第一种类型。下面我们就来看一个例子：

template<typename T>
void f(T&& param);       // param is now a universal reference

int x = 27;              // as before
const int cx = x;        // as before
const int& rx = x;       // as before

f(x);                    // x is lvalue, so T is int&, param's type is also int&
f(cx);                   // cx is lvalue, so T is const int&, param's type is also const int&
f(rx);                   // rx is lvalue, so T is const int&, param's type is also const int&
f(27);                   // 27 is rvalue, so T is int, param's type is therefore int&&

这种类型的ParamType的格式很固定，就是T&&，所以我们只需要考虑expr，对于x，cx，rx，27，类型分别为左值的int，const int，const int&和右值的int。这里我们仍然可以推导出ParamType的实际类型。
对于x，cx，rx，因为是左值，结合上面的规则，ParamType必须为左值引用，x就是个int，对于cx和rx，因为expr有没有引用没区别，所以实际都是多了一个const的限制，所以ParamType分别为int&, const int&和const int&，从而分别为T&& == int&, T&& == const int&和T&& == const，然后问题来了，T的类型是什么？答案是引用折叠，对于模板里的完美转发，是有引用折叠的，有兴趣的可以先自行了解下的，简单来说就是在这个场景里有以下的转换规则：
在这里插入图片描述
具体到我们的例子就是& && == &，所以T 和ParamType的类型一样，分别也为int&, const int&和const int&，由于引用折叠在T是左值引用的时候T&&就等于T。

而对于27这个右值，T&&类型的ParamType扮演的就是一个右值引用，int类型的右值引用自然是int&&，所以T是int。

这里再多提一句，即便某个变量的类型是右值引用，包含这个变量名字的表达式也是左值，如果讲这种类型传入上面那个函数模板，仍然会当成左值来处理，如果想要被当成传入的是右值，通常会使用std::move。

1.3 ParamType既不是指针，也不是引用

这种情况也比较简单，ParamType既不是指针，也不是引用意味这是传值，所以核心就是expr的一系列const、引用啥的通通都可以不要，包括volatile也会被忽略。一个简单的例子如下：

template<typename T>
void f(T param);         // param is now passed by value

int x = 27;          // as before
const int cx = x;    // as before
const int& rx = x;   // as before

f(x);                // T's and param's types are both int
f(cx);               // T's and param's types are again both int
f(rx);               // T's and param's types are still both int

ParamType是T，所以就是个没什么附加条件的传值，x cx 和rx最终都产出了int的推导结果，指针是一种特殊的值，也能传入这种模板，如果传入的是个int*，那么自然推导结果也是int*。

如果ParamType改为const T，如下：

template<typename T>
void f(const T param);         // param is now passed by value

int x = 27;          // as before
const int cx = x;    // as before
const int& rx = x;   // as before

f(x);                // T is int, param's type is const int
f(cx);               // T is int, param's type is const int
f(rx);               // T is int, param's type is const int

显然ParamType都会是const int，那么T都是int。

二、auto类型推导

auto也算是c++ 11之后引入的一个关键特性了，特别常用，本质上他和函数模板的类型推导几乎一致，auto相当于T，整个变量名前的部分相当于ParamType。

auto x = 27;    //类似ParamType为T
const auto cx = x;    //类似ParamType为const T
const auto& rx = x;    //类似ParamType为const T&

因此也完全适用前面说到的三种函数模板的推导类型。这里就不一一展开了，详细的说明可以直接去看下Effective Modern C++的Item 2.

三、一些比较边角的情况

上面介绍了函数模板和auto的类型推导的最通用的机制，掌握了这些基本上就能完全掌握各种相关类型推导的场景了，但实际上还有一些比较特殊比较少用的细分规则，这里简单概括下，主要有以下几种：

数组作为实参和函数作为实参：简单概括就是因为数组和函数都可以退化成指针，对于ParamType为传值的函数模板，如果将数组和函数传进去，实际上推导出来的类型会是数组包含元素类型的指针和函数指针，如果ParamType为引用，则能获得数组和函数的实际类型。
函数模板推导的例子：

void someFunc(int, double);   // someFunc is a function，type is void(int, double)

template<typename T>
void f1(T param);    // in f1, param passed by value

template<typename T>
void f2(T& param);    // in f2, param passed by ref

f1(someFunc);    // param deduced as ptr-to-func，type is void (*)(int, double)
f2(someFunc);    // param deduced as ref-to-func，type is void (&)(int, double)

auto推导的例子：

const char name[] = "R. N. Briggs";    // name's type is const char[13]  
auto arr1 = name;    // arr1's type is const char*
auto& arr2 = name;    // arr2's type is const char (&)[13]

void someFunc(int, double);    // someFunc is a function, type is void(int, double)
auto func1 = someFunc;         // func1's type is void (*)(int, double)
auto& func2 = someFunc;        // func2's type is void (&)(int, double)

auto会认为用来调用的大括号括起来的元素是 std::initializer_list，而函数模板在推导的时候不会。如下：

auto x = { 11, 23, 9 };   // x's type is std::initializer_list<int>

template<typename T>      // template with parameter declaration equivalent to x's declaration
void f(T param);             

f({ 11, 23, 9 });         // error! can't deduce type for T