C++的变量限定指可以在变量类型的基础上加上特殊的限定条件，主要包括：是不是const，是不是volatile，是左值还是右值，是不是引用，是左值引用还是右值引用，等等。

1. 为什么要研究这个东西

主要是c++11以后，移动构造（左值右值的区分，std:move()接口），类型推断（模板，auto）等特性，都涉及到了这些东西，如果这些东西搞不明白，很难理解这些语法特性。

2. 如何理解这些限定

这是一个大课题，我们先用一句话概况一下：所有语法都是为了语义。这么说完你可能还是啥都没理解，首先到底语义是个啥，不要着急，后面我们会一直重复这句话，最后回头来看，你肯定会有更深的理解。

下面步入细节，先来看看编译器是如何保存这些限定的吧，编译器对每一个变量都对应一个条目，大概是这样：（只是为了举例，别较真儿）

item	变量名	内存地址	是否const	是否volatile	左值还是右值	引用类型
举例	a	0x100001	是/否	是/否	lvalue/rvalue	non/&/&&

注意：

1. 变量的值可以通过内存地址读到，没写到里面

2. 其实有条目的都是左值，右值只是赋值过程中一种临时形态，但为了方便，写到里面了

这样就有了下面这张图：（相信不用解释你也能懂）

通过排列组合，我们很容易得到到底有多少种限定情况：2x2x3 + 2x2x1 = 16。（引用只能是左值，所以不是全组合）

下面就写出这16种限定看看：

 50   int a = 1;
 51 
 52   int t1 = a;
 53   int &t2 = a;
 54   int &&t3 = std::move(a);
 55   2; //t4
 56   volatile int t5 = a;
 57   volatile int &t6 = a;
 58   volatile int &&t7 = std::move(a);
 59   std::move(t5); //t8
 60   const int t9 = a;
 61   const int &t10 = a;
 62   const int &&t11 = std::move(a);
 63   std::move(t9); //t12
 64   const volatile int t13 = a;
 65   const volatile int &t14 = a;
 66   const volatile int &&t15 = std::move(a);
 67   std::move(t13); //t16
 68   // 不考虑volatile
 69   int tt1 = a;
 70   int &tt2 = a;
 71   int &&tt3 = std::move(a);
 72   2; //tt4
 73   const int tt5= a;
 74   const int &tt6 = a;
 75   const int &&tt7 = std::move(a);
 76   std::move(tt5); //tt8
 77   //再不考虑const
 78   int ttt1 = a;
 79   int &ttt2 = a;
 80   int &&ttt3 = std::move(a);
 81   2; //ttt4

注意：

1. 上面也提到了，右值只是一个中间结果，所以没有右值这种类型，只有右值引用，而右值引用本身是个左值。

2. volatile是从C里面继承下来的，告诉编译器不要对其进行寄存器优化（注意，这句话就是语义），这个只有底层编程会用的，不在这里过多讨论，这样还剩下8种。

3. 如果进一步把const也忽略，那就只有4种了，它们是左值/右值，左值引用/右值引用/非引用的区别。

或许你对std::move()了解甚少，但在解释它之前，我们先来复习一下：传值与传引用

从宏观上看，程序运行的过程，就是不断复制数据的过程（=号两边，复制构造，实参传递给形参，函数返回，变量放入容器等等），类型限定也大都发生在复制的过程中，也就是你不能把某种限定的变量，复制给另一种特定类型的变量，最常见的const变量不能给non-const引用、左值引用不能绑定右值等。

好像扯远了，其实我想说的是，在数据复制过程中，首先要分清是传值还是传引用！

如果是传值，好了，你是大爷，有钱人，想出错都难。

因为新数据与源数据只是一次交易，后面就再也没关系了，源数据不会被改变，新数据的限定条件完全自己决定。

从代码上看，如果等式左边是int a = ,那右边可以是任何代表int的变量，或者可以隐式转成int的变量，所有限定条件都不影响，且只要代码编译过，基本不会出错。

 28   int a = 0;
 29   int b = a;
 30   int c = std::move(a);
 31 
 32   int a2 = 0;
 33   int &d = a2;
 34   int e = d;
 35   int f = std::move(d);
 36 
 37 
 38   const int a3 = 0;
 39   int g = a3;
 40   int h = std::move(a3);

std::move()只有在

references and cv-qualifiers，还有lvalue和rvalue的区别：

 11   int a = 2;
 12   const int b = a;
 13   volatile int c = a;
 14   int &d = a;
 15   const volatile int &e = a;
 16   int &&f = std::move(a);

程序运行过程，就是不断复制数据的过程，在代码中，最常见的操作就是把一个值复制给另一个值，虽然对应到内存上，都是二进制的拷贝，但在编译器中，由于各种各样的原因，还保留着这组二进制值的某些特性。那复制过程中，要不要保留这些特性呢？在没有类型推断之前，这个问题还比较简单，新的类型是要完全定义出来的，所以程序员必须要指定是否有某种限定（一般没有写，会有一个默认值，比如没有const那就是非const，没有引用，那就是值，没有写右值那就是左值等等）。但有了类型推导后，问题就复杂了，尤其是原值并不是默认值，而新值想用默认值的时候：

 19   int a = 1;
 20   auto &b = a; //增加引用特性，可以
 21   const auto &c = a; //增加const和引用，可以
 22 
 23   const int d = 2;
 24   auto e = 2; //e是否要保留const属性？不好决策，实际上是没有
 25   e++;
 26   auto &f = d; //f必须保留const属性
 27 //  f++;
 28 
 29   int g = 0;
 30   int &h = g;
 31   auto i = h;// i是否是g的引用，还是对应另一片内存？实际上对应另一片内存
 32   i++;
 33   cout << g << endl;
 35   auto j = std::move(g);
 36 //  int &&k = j; j是左值不是右值

从上面的例子可以看出，auto作为类型推导时，不会保留references and cv-qualifiers，还有lvalue和rvalue。

要想保留这些属性，必须要使用decltype(auto)作为类型推导标识符：

 19   int a = 1;
 20   auto &b = a; 
 21   const auto &c = a; 
 22 
 23   const int d = 2;
 24   auto e = d; 
 25   e++;
 26   decltype(auto) e2 = d;
 27 //  e2++; 编译失败，保留了const属性
 28   auto &f = d; 
 29 //  f++;
 30 
 31   int g = 0;
 32   int &h = g;
 33   auto i = h;
 34   i++;
 35   cout << g << endl; //0
 36   decltype(auto) i2 = h;
 37   i2++;
 38   cout << g << endl; //1 保留了引用属性
 39