学习地址： http://c.biancheng.net/view/3730.html
1. auto
1. 使用了 auto 关键字以后，编译器会在编译期间自动推导出变量的类型
2. 使用 auto 类型推导的变量必须马上初始化，这个很容易理解，因为 auto 在 C++11 中只是“占位符”，并非如 int 一样的真正的类型声明。
3. 当类型不为引用时，auto 的推导结果将不保留表达式的 const 属性
4. 当类型为引用时，auto 的推导结果将保留表达式的 const 属性
5. auto 不能在函数的参数中使用
6. auto 不能作用于类的非静态成员变量（也就是没有 static 关键字修饰的成员变量）中, 为什么？但是static可以，因为static成员变量如果初始化，那么初始化发生在任何代码执行之前，属于编译器初始化。
7. auto 关键字不能定义数组
char url[] = “http://c.biancheng.net/”;
auto str[] = url; //arr 为数组，所以不能使用 auto
8. auto 不能作用于【模板参数】，请看下面的例子：
template <typename T>class A{//TODO:};int main(){A<int> C1;A<auto> C2 = C1; //错误return 0;}
即auto不能推导出由模版生成的值的类型。
8. 用于泛型编程
class A{
public:static int get(void){return 100;}
};class B{
public:static const char* get(void){return "http://c.biancheng.net/cplus/";}
};template <typename T>
void func(void){auto val = T::get();cout << val << endl;
}int main1(void){func<A>();func<B>();return 0;
}
2. decltype
1. auto 和 decltype 关键字都可以自动推导出变量的类型，但它们的用法是有区别的：
auto varname = value;
decltype(exp) varname = value;
exp是一个表达式
auto 根据=右边的初始值 value 推导出变量的类型，而 decltype 根据 exp 表达式推导出变量的类型
2. auto 要求变量必须初始化，而 decltype 不要求，这很容易理解，auto 是根据变量的初始值来推导出变量类型的，如果不初始化，变量的类型也就无法推导了。decltype 可以写成下面的形式：
decltype(exp) varname;
3. 关于exp 注意事项exp 就是一个普通的表达式，它可以是任意复杂的形式，但是我们必须要保证 exp 的结果是有类型的，不能是 void
4. 如果 exp 是一个不被括号( )包围的表达式， 或者是一个类成员访问表达式， 或者是一个单独的变量， 那么 decltype(exp) 的类型就和 exp 一致， 这是最普遍最常见的情况。
class Student{
public:static int total;string name;int age;float scores;
};
int Student::total = 0;
void testDecltype1() {int n = 0;const int &r = n;Student stu;decltype(n) a = n; //n 为 int 类型，a 被推导为 int 类型decltype(r) b = n; //r 为 const int& 类型, b 被推导为const int& 类型decltype(Student::total) c = 0; //total 为类 Student的一个 int 类型的成员变量，c 被推导为 int 类型decltype(stu.name) url = "http://c.biancheng.net/cplus/"; //total 为类 Student 的一个 string 类型的成员变量， url 被推导为 string 类型cout << a << b << c << url <<endl;
}
- 如果 exp 是函数调用，那么 decltype(exp) 的类型就和函数返回值的类型一致，注意:既然exp为表达式，那么肯定要给函数传递参数,exp 中调用函数时需要带上括号和参数，但这仅仅是形式，并不会真的去执行函数代码
int& func_int_r(int, char); //返回值为 int&
int&& func_int_rr(void); //返回值为 int&&
int func_int(double); //返回值为 intconst int& fun_cint_r(int, int, int); //返回值为 const int&
const int&& func_cint_rr(void); //返回值为 const int&&void testDecltype2() {//decltype类型推导int n = 100;decltype(func_int_r(100, 'A')) a = n; //a 的类型为 int&decltype(func_int_rr()) b = 0; //b 的类型为 int&&decltype(func_int(10.5)) c = 0; //c 的类型为 intdecltype(fun_cint_r(1,2,3)) x = n; //x 的类型为 const int &decltype(func_cint_rr()) y = 0; // y 的类型为 const int&&cout << a << b << c << x << y <<endl;
}- 如果 exp 是一个左值，或者被括号( )包围，那么 decltype(exp) 的类型就是 exp 的引用；假设 exp 的类型为 T，那么 decltype(exp) 的类型就是 T&。
- m = n + m 表达式结果是左值。左值是指那些在表达式执行结束后依然存在的数据，也就是持久性的数据；右值是指那些在表达式执行结束后不再存在的数据，也就是临时性的数据
class Base{
public:int x;
};int testDecltype3(){Base obj;//带有括号的表达式decltype(obj.x) a = 0; //obj.x 为类的成员访问表达式，符合推导规则一，a 的类型为 intdecltype((obj.x)) b = a; //obj.x 带有括号，符合推导规则三，b 的类型为 int&。//加法表达式int n = 0, m = 0;decltype(n + m) c = 0; //n+m 得到一个右值，符合推导规则一，所以推导结果为 intdecltype(n = n + m) d = c; //n=n+m 得到一个左值，符号推导规则三，所以推导结果为 int&return 0;
}
- auto 的语法格式比 decltype 简单，所以在一般的类型推导中，使用 auto 比使用 decltype 更加方便，如下面代码，会报错T::iterator并不能包括所有的迭代器类型，当 T 是一个 const 容器时，应当使用 const_iterator。
template <typename T>
class Base1 {
public:void func(T& container) {m_it = container.begin();}private:typename T::iterator m_it; //注意这里报错
};int testDecltype4()
{const vector<int> v;Base1<const vector<int>> obj;obj.func(v);return 0;
}
9. 类成员变量用decltype好于auto
*/
template <typename T>
class Base1 {
public:void func(T& container) {m_it = container.begin();}decltype(T().begin()) m_it;
// static auto m_it1 = T().begin(); //不行
};int testDecltype4()
{const vector<int> v;Base1<const vector<int>> obj;obj.func(v);return 0;
}
