类型推导:函数模板与auto

1.从函数模板谈起

函数模板的类型推导机制是在c++98时代就有的,auto的类型推导机制与其基本一致,所以先理解函数模板类型推导。

函数模板可以用如下代码框架表示:

#template<typename T>
void f(PT param);

f(expr);

PT与T的不同之处在于PT相对于T可能有一些饰词(adornments),如const 和引用&。

对于模板类型T的推导是PT和expr共同作用的结果。下面分几种情况讨论类型推导的原则:

1)PT是一般的引用或指针

原则:

  • expr是一个引用(指针)类型,忽略其引用(指针)部分;
  • expr其他部分去匹配PT得到T的类型。 (匹配原则就是如果PT有const则expr的const忽略,PT无const,expr有,则添加)

代码示例如下:

//PT是指针或引用类型,expr的引用或指针被忽略 
//PT是T& 
#template<typename T>
void f(T& param);
int x = 11;
const int cx = x;
const int& rx = x;
f(x);  //PT是int&, T是int 
f(cx); //PT是const int&, T是const int 
f(rx); //PT是const int&, T是const int 


//PT是const T&,expr中的const被忽略 
#template<typename T>
void f(const T& param);
int x = 11;
const int cx = x;
const int& rx = x;
f(x);  //PT是int&, T是int 
f(cx); //PT是const int&, T是int 
f(rx); //PT是const int&, T是int 

//PT是T*, 
#template<typename T>
void f(T* param);
int x = 11;
const int* px = &x;
f(&x);  //PT是int*, T是int 
f(rx); //PT是const int*, T是const int

结果总结如下表格:

 

 

 

 

 

 

 

 

 

 

 

 

2) PT是万能引用(universal reference, ie &&)                              

注:万能引用既不是左值引用也不是右值引用,而是遇左则左,遇右则右。

原则:

  • 如果expr是左值引用,则PT和T均被推导为左值引用(这是所有情况中T被推导为引用的唯一情况);
  • 如果expr是右值引用,则与1)情况类似,即引用被忽略,其余部分去匹配PT。

代码示例如下:

//PT是T&&,左值推导为左值引用,右值引用忽略 
#template<typename T>
void f(T&& param);
int x = 11;
const int cx = x;
const int& rx = x;
f(x);  //x是左值, PT是int&, T是int& 
f(cx); //cx是左值, PT是const int&, T是const int& 
f(rx); //rx是左值, PT是const int&, T是const int&
f(11); //11是右值, PT是int&&, T是int 

结果总结如下表格:

 

3)PT既不是指针,也不是引用

当PT既不是指针,又不是引用(也就是只有T)时,用传值传参的方式考虑问题,可以想清楚推导原则。

所谓传值传参(pass by value)意味着拷贝一份新的独立的对象,但内容与原内容相同。

所以有如下原则和解释:

  • expr如果是引用,则忽略引用部分;
  • expr的const部分,volatile部分也被忽略。(传值传参拷贝一份新的,原来是const,不代表新拷贝的就是const);
  • expr存在指向常量的指针(ie const int*)应保留。 (指针拷贝了一份新的,但是他指向的内容仍然是原来的内容,应保证那块内容不可变);

代码示例如下:

//PT是T 
#template<typename T>
void f(T param);
int x = 11;
const int cx = x;
const int& rx = x;
const char* ptr1 = "C++11";
const char* ptr2 const = "c++14";
f(x);  //PT是int&, T是int 
f(cx); //PT是int, T是int 
f(rx); //PT是int, T是int 
f(ptr1);//PT是const char*, T是const char* 
f(ptr2);//PT是const char*,T是const char*,指向内容保留不可更改,指针本身const被移除。

结果总结如下表格:

补充1)关于数组参数的推导

数组参数在c++中可以退化为指针进行传参,所以补充对数组参数的类型推导。

 原则:

  • 当PT为传值类型(就是T)时,推导为退化的指针类型;
  • 当PT为引用类型(T&),推导为带有数组大小的明确的数组类型(如const char[13]);

代码示例如下:

//数组参数 
const char name[] = "C++11"; 
#template<typename T>
void f(T param);
f(name); //PT为 const char*,T被推导为const char*  

#template<typename T>
void f(T& param);
f(name); //PT为const char (&)[6], T被推导为const char[6]

 

补充2) 关于函数参数的推导

函数在c++中也可以退化为指针,所以函数参数的推导和数组基本一致。

直接看代码示例:

void someFunc(int, double); //类型void(int, double) 
#template<Typename T>
void f1(T param); 
f1(someFunc); //PT 为void(*) (int, double), T推导为 void(*) (int, double); 
#template<Typename T>
void f2(T& param);
f2(SomeFunc); //PT为void(&)(int, double), T推导为 void(int, double); 

总结如下表格:

至此,关于函数模板的推导过程总结完毕。

 

2. 函数模板到auto

auto的类型推导机制与函数模板类型推导机制几乎完全一样,除了一个小的注意点。

回顾函数模板类型推导的代码框架:

#template<typename T>
void f(PT param);

f(expr);

推导出T,需要PT与expr的共同作用。

在带有auto的表达式中,auto代表的就是T,也就是最后要推导出的结果;等号右边代表expr;而auto与其饰词一起,表示的是PT

注意此时最后更关心的是PT的类型,也就是式中待推导变量的类型。如 :

int x = 11const auto& rx = x;  //auto代表T, const auto&代表PT, x代表expr 

所以第一部分中讨论的函数模板类型推导原则完全适用于auto的类型推导。

给出代码示例如下:

auto x = 11; //类型3, auto推导为int
const auto cx = x; // 类型3, auto推导为int, cx类型为int 
const auto& rx = x; //类型1, auto推导为int, rx类型为int& 
auto&& uref1 = x; //左值,auto推导为int&, uref1类型为int& 
auto&& uref2 = cx; //左值,auto推导为const int&, uref2类型为const int& 
auto&& uref3 = 11; //右值,auto推导为int, uref3类型 int&& 
const char name[] = "C++11" ;
auto arr1 = name; // auto推导为const char*, arr1类型const char* 
auto& arr2 = name; //auto推导为const char[6], arr2类型为const char(&)[6] 
void someFunc(int, double);
auto func1 = someFunc(); //auto推导为void(*)(int, double), func1类型为void(*)(int, double)
auto& func2 = someFunc();//auto推导为void(int, double),func2类型为void(&)(int, double) 

注:

1). 上述原则都是与函数模板推导一致的原则。一点不同在于函数模板没有对于{}的推导,这是auto独有的。

使用{}初始化,会被推导为std:initializer_list的相关类型。如:

auto x3 = {27}; //推导为std::initializer_list<int>; 

 

2). 在函数返回类型和lambda表达式参数中使用auto,使用的是模板参数类型推导,而不是auto的类型推导;

也就是在此情况下,推导{}会报错。如:

auto createList() { //error,模板参数类型推导不能处理{} 
    return {1,2,3};
} 

至此,关于auto类型推导总结完毕。

 

参考文献:

1. Effective Modern C++, Scott Meyers, http://shop.oreilly.com/product/0636920033707.do

2. C++ 11/14最佳实践, 高博, http://boolan.com/camp/4

 

posted @ 2016-09-01 12:34  wangxiaobao1114  阅读(2980)  评论(0编辑  收藏  举报