【无标题】

学习地址： 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 
 class A{
     //TODO:
 };

 int  main(){
     A C1;
     A 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 
void func(void){
   auto val = T::get();
   cout << val << endl;
}

int main1(void){
   func();
   func();

   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 <

5. 如果 exp 是函数调用，那么 decltype(exp) 的类型就和函数返回值的类型一致，注意:既然exp为表达式，那么肯定要给函数传递参数,exp 中调用函数时需要带上括号和参数，但这仅仅是形式，并不会真的去执行函数代码

int& func_int_r(int, char);  //返回值为 int&
int&& func_int_rr(void);  //返回值为 int&&
int func_int(double);  //返回值为 int

const 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 的类型为 int
   decltype(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 <

6. 如果 exp 是一个左值，或者被括号( )包围，那么 decltype(exp) 的类型就是 exp 的引用；假设 exp 的类型为 T，那么 decltype(exp) 的类型就是 T&。
7. m = n + m 表达式结果是左值。左值是指那些在表达式执行结束后依然存在的数据，也就是持久性的数据；右值是指那些在表达式执行结束后不再存在的数据，也就是临时性的数据

class Base{
public:
    int x;
};

int testDecltype3(){
    Base obj;

    //带有括号的表达式
    decltype(obj.x) a = 0;  //obj.x 为类的成员访问表达式，符合推导规则一，a 的类型为 int
    decltype((obj.x)) b = a;  //obj.x 带有括号，符合推导规则三，b 的类型为 int&。

    //加法表达式
    int n = 0, m = 0;
    decltype(n + m) c = 0;  //n+m 得到一个右值，符合推导规则一，所以推导结果为 int
    decltype(n = n + m) d = c;  //n=n+m 得到一个左值，符号推导规则三，所以推导结果为 int&

    return 0;
}

8. auto 的语法格式比 decltype 简单，所以在一般的类型推导中，使用 auto 比使用 decltype 更加方便，如下面代码，会报错T::iterator并不能包括所有的迭代器类型，当 T 是一个 const 容器时，应当使用 const_iterator。

template 
class Base1 {
public:
    void func(T& container) {
        m_it = container.begin();
    }

private:
    typename T::iterator m_it;  //注意这里报错
};

int testDecltype4()
{
    const vector v;
    Base1> obj;
    obj.func(v);

    return 0;
}
9. 类成员变量用decltype好于auto
*/
template 
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 v;
   Base1> obj;
   obj.func(v);

   return 0;
}