第一章：类型推导
item1：理解模板类型推导
考虑下面的函数模板
template
void fun(ParamType param)
调用
fun(expr);//使用表达式调用f
编译器编译的时候要利用expr推导两个类型：T和ParamType。
T的推导取决于expr的类型和ParamType的类型。分三种情况
- ParamType为指针和非通用引用
- ParamType为通用引用
- ParamType不是指针也不是引用
case1:ParamType为指针和非通用引用
推导规则
1.expr是引用，忽略其引用属性
2.剩下部分与ParamType匹配决定T的类型
template
void f(T & param); //param是一个引用
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&
expr的const属性在下面这种情况中被忽略
template
void f(const T& param); // param is now a ref-to-const
指针的情况和引用基本一样
template
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*
case2:ParamType为通用引用
template
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&&
case3:ParamType不是指针也不是引用
template
void f(T param); // param is now passed by value
1.如果是引用，忽略引用属性
2.剩下的，忽略const属性，忽略volatile
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
下面这种情况，忽略指针自身的const属性，其指向内容的const属性保留，最后param的类型是const char*。
const char* const ptr = // ptr is const pointer to const object
f(ptr); // pass arg of type const char * const
数组参数
数组在下面的情况会弱化为指向const的指针
template
void f(T param); // template with by-value parameter
而下面的情况会保留数组属性
template
void f(T& param); // template with by-reference parameter
应用
// return size of an array as a compile-time constant. (The
// array parameter has no name, because we care only about
// the number of elements it contains.)
template // see info
constexpr std::size_t arraySize(T (&)[N]) noexcept // below on
{ // constexpr
return N;
}
int keyVals[] = { 1, 3, 7, 9, 11, 22, 35 }; // keyVals has
// 7 elements
int mappedVals[arraySize(keyVals)]; // so does mappedVals
函数参数
void someFunc(int, double); // someFunc is a function;
// type is void(int, double)
template
void f1(T param); // in f1, param passed by value
template
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)
Things to Remember
• During template type deduction, arguments that are references are treated as
non-references, i.e., their reference-ness is ignored.
• When deducing types for universal reference parameters, lvalue arguments get
special treatment.
• When deducing types for by-value parameters, const and/or volatile arguments
are treated as non-const and non-volatile.
• During template type deduction, arguments that are array or function names
decay to pointers, unless they’re used to initialize references.
item2:理解auto的类型推导
auto的类型推导和模板的类型推导基本一样，其转换关系是
1.auto相当于模板推导里面的T
2.对auto的修饰相当于ParamType
auto x = 27;
const auto cx = x;
const auto& rx = x;
template // conceptual template for
void func_for_x(T param); // deducing x's type
func_for_x(27); // conceptual call: param's
// deduced type is x's type
template // conceptual template for
void func_for_cx(const T param); // deducing cx's type
func_for_cx(x); // conceptual call: param's
// deduced type is cx's type
template // conceptual template for
void func_for_rx(const T& param); // deducing rx's type
func_for_rx(x); // conceptual call: param's
// deduced type is rx's type
相对应的case1
相对应的case2
auto&& uref1 = x; // x is int and lvalue,
// so uref1's type is int&
auto&& uref2 = cx; // cx is const int and lvalue,
// so uref2's type is const int&
auto&& uref3 = 27; // 27 is int and rvalue,
// so uref3's type is int&&
相对应的case3
相对应的数组和函数
const char name[] = // name's type is const char[13]
"R. N. Briggs";
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)
有一个例外,看定义一个变量并初始化，有以下选择，结果都是一样的
//C++98
int x1 = 27;
int x2(27);
//C++11
int x3 = { 27 };
int x4{ 27 };
用auto时，第三四条语句定义的是包含一个元素的std::initializer_list
auto x1 = 27; // type is int, value is 27
auto x2(27); // ditto
auto x3 = { 27 }; // type is std::initializer_list,
// value is { 27 }
auto x4{ 27 }; // ditto
大括可以直接推导auto，但不能推导模板参数
auto x = { 11, 23, 9 }; // x's type is
// std::initializer_list
template // template with parameter
void f(T param); // declaration equivalent to
// x's declaration
f({ 11, 23, 9 }); // error! can't deduce type for T
指定了std::initializer_list
template
void f(std::initializer_list initList);
f({ 11, 23, 9 }); // T deduced as int, and initList's
// type is std::initializer_list
C++14用auto推导返回值，使用的是模板类型推导规则，下面的是非法的
auto createInitList()
{
return { 1, 2, 3 }; // error: can't deduce type
} // for { 1, 2, 3 }
lambda用auto做参数推导也是如此
std::vector v;
…
auto resetV =
[&v](const auto& newValue) { v = newValue; }; // C++14
…
resetV({ 1, 2, 3 }); // error! can't deduce type
// for { 1, 2, 3 }
item3：理解decltype
decltype 简单的返回传入值的类型
const int i = 0; // decltype(i) is const int
bool f(const Widget& w); // decltype(w) is const Widget&
// decltype(f) is bool(const Widget&)
struct Point {
int x, y; // decltype(Point::x) is int
}; // decltype(Point::y) is int
Widget w; // decltype(w) is Widget
if (f(w)) … // decltype(f(w)) is bool
template // simplified version of std::vector
class vector {
public:
…
T& operator[](std::size_t index);
…
};
vector v; // decltype(v) is vector
…
if (v[0] == 0) … // decltype(v[0]) is int&
decltype应用在模板返回值推导上
template // works, but
auto authAndAccess(Container& c, Index i) // requires
-> decltype(c[i]) // refinement
{
authenticateUser();
return c[i];
}
decltype(auto) ：auto表示返回值需要推导，decltype表示推导是使用decltype的规则
template // C++14; works,
decltype(auto) // but still
authAndAccess(Container& c, Index i) // requires
{ // refinement
authenticateUser();
return c[i];
}
decltype(auto)和auto对比
Widget w;
const Widget& cw = w;
auto myWidget1 = cw; // auto type deduction: myWidget1's type is Widget
decltype(auto) myWidget2 = cw; // decltype type deduction:myWidget2's type is const Widget&
上面的例子都有瑕疵，问题出在Container不能传入右值，右值是一个临时对象，在离开函数后会被销毁，这样会返回一个悬置的引用。但是传入右值不是没有意义的，例如当用户只想简单的返回一个元素的拷贝时，如下面代码所示。
std::deque makeStringDeque(); // factory function
// make copy of 5th element of deque returned
// from makeStringDeque
auto s = authAndAccess(makeStringDeque(), 5);
C++14的最终版本
template // final
decltype(auto) // C++14
authAndAccess(Container&& c, Index i) // version
{
authenticateUser();
return std::forward(c)[i];
}
C++11最终版本
template // final
auto // C++11
authAndAccess(Container&& c, Index i) // version
-> decltype(std::forward(c)[i])
{
authenticateUser();
return std::forward(c)[i];
}
特殊情况