1、左值、右值
左值、右值是表达式的属性，单独一个变量也是表达式，称为变量表达式，它是最简单的表达式，没有运算符，只有一个运算对象。
左值表达式即为返回左值的表达式，他们有：变量表达式、前++(前--)运算、*解引用运算、[]下标运算、返回左值引用类型的函数表达式。
右值表达式即为返回右值的表达式，如：字面常量、非左值运算的运算表达式(如100 * i、i + n等表达式)、返回非左值引用类型的函数表达式。
从以上可知左值持久，右值短暂，左值表达式表示的是一个对象的身份，而右值表达式表示的是对象的值，只有左值才能被赋值，如：*p = 1，++i = 0，ary[0] = 100。
2、左值引用
我们原来学过使用&来定义引用类型，其实使用&定义的是左值引用，因为绑定的都是左值表达式，如：
int o = 5;
int& h = o; //o是变量(变量表达式)
int& e = ++o; //前++运算
int* p = &o;
int& f = *p; //*解引用运算
int ary[10] = { 0 };
int& s = ary[0]; //[]下标运算
int& func(){...}
int&q = func(); //func()是返回引用类型的函数表达式
&定义的引用类型不能用右值表达式来初始化，即左值引用不能绑定右值表达式，如：
int& m = 100; //错误，将左值引用绑定到字面常量上
int j = 100;
int& n = j + 50; //错误，将左值引用绑定到右值表达式上
int func() { ... }
int& x = func(); //错误，将左值引用绑定到返回非左值引用类型的函数表达式
左值引用&只能使用左值表达式来初始化即只能绑定左值表达式，那右值表达式使用哪种类型呢？答案就是C++11中增加的右值引用。
3、右值引用
右值引用只能绑定到临时对象，该临时对象将要被销毁且该对象没有其他用户，右值引用使用&&来定义，如：
int&&r = 100; //将右值引用绑定到字面常量上，即使用字面常量来初始化右值引用
int k = 5;
int&& n = k + 10; //将右值引用绑定到右值表达式上
int func() { ... }
int&& x = func(); //将右值引用绑定到返回非左值引用类型的函数表达式
我们可以通过std::move()函数来将一个右值引用绑定到左值上，为了避免冲突，对于move()函数我们应该在调用的时候总是加上命名空间std::，如下所示。
int i = 100;
int&& r = std::move(i);
因为右值引用只能绑定到临时对象上，所以对左值调用std::move()后，除非对原左值赋新值或销毁它外，我们将不再使用它，比如下面的代码，unique_ptr有一个构造函数支持右值引用，当我们执行这个构造函数后u1不再拥有原始指针，因为在这个构造函数中会将u2保存u1中的原始指针后将u1中的指针设为nullptr，这就保证了通过u1不再会使用原来的值，我们通过reset()对u1赋新值后可以再使用它。
std::unique_ptr<int> u1(new int); std::unique_ptr<int> u2(std::move(u1)); cout << "u1: " << (u1 ? "not null" : "null") << endl; //输出为 "u1: null" u1.reset(new int);
我们知道左值引用的一个重要作用就是声明函数的参数，避免值传递和拷贝参数对象，右值引用同样是提供这个功能，我们称右值引用可以移动对象而非拷贝对象，而且它针对的是传入的参数是右值的情况，如：
void func(int&& i) {}
void test(std::string&& str) {}
func(100); //避免值传递拷贝参数
int k = 100;
func(k + 5); //避免值传递拷贝参数
test(std::string("abc")); //避免值传递拷贝参数
4、拷贝和移动对象
右值引用参数在类的构造函数和成员函数中用的比较多，比如C++11中很多类的构造函数、成员函数除了拷贝版本外还增加了一个移动版本，如string::string(string&& r)、vector<value_type>::push_back(value_type&& var)，区分移动和拷贝的重载函数即通过函数的参数：拷贝版本通常是const T&，而移动版本是一个T&&（因为我们要从实参"窃取"数据，所以不是const T&&）。
我们可以让自己的类也支持移动操作，通过为其定义移动构造函数和移动赋值运算符。为了完成资源移动必须确保移动后源对象的销毁是无害的，移动完成后源对象的资源所有权已经归属新创建的对象。
由于移动操作是“窃取”资源，它通常不非配任何资源，所以我们通常都应该使用noexcept来声明移动函数不会抛出异常，而且对于标准容器来说，如果不为移动构造函数标记为noexcept的话，容器会使用拷贝构造函数而非移动构造函数。
下面为类中添加移动构造函数和移动赋值运算符的一个例子：
class CFoo
{
public:
CFoo(const CFoo& lf)
{
if (lf.m_pData)
{
m_pData = new char(iDataSize);
memcpy(m_pData, lf.m_pData, iDataSize);
}
else
{
if (m_pData)
{
delete[] m_pData;
m_pData = nullptr;
}
}
}
CFoo(CFoo&& rf)noexcept
{
m_pData = rf.m_pData; //从源对象“窃取”资源
rf.m_pData = nullptr; //防止源对象析构后资源失效，源对象可安全销毁
}
CFoo& operator=(const CFoo& rhs)
{
if (&rhs == this)
return *this;
if (m_pData)
delete[] m_pData;
if (rhs.m_pData)
{
m_pData = new char[iDataSize];
memcpy(m_pData, rhs.m_pData, iDataSize);
}
else
{
if (m_pData)
{
delete[] m_pData;
m_pData = nullptr;
}
}
return *this;
}
CFoo& operator=(CFoo&& rhs)noexcept
{
if (&rhs == this)
return *this;
m_pData = rhs.m_pData; //从源对象“窃取”资源
rhs.m_pData = nullptr; //防止源对象析构后资源失效，源对象可安全销毁
return *this;
}
virtual ~CFoo()
{
if (m_pData)
{
delete[] m_pData;
m_pData = nullptr;
}
}
private:
char* m_pData = nullptr;
int iDataSize = 0;
};
5、引用限定符&和&&
&用来限定函数只能被左值对象来调用，&&用来限定函数只能被又值对象来调用，需要注意的是&和&&只能用于非static的成员函数，且必须同时出现在函数的声明和定义中，在const限定符之后，如：
class CFoo
{
public:
void fun()&{}
};
CFoo().fun(); //错误，fun()只能被左值对象来调用
CFoo f;
f.func(); //正确
//======================================
class CShow
{
public:
CShow& operator=(const CShow& rhs)&&
{
return *this;
}
};
CShow s;
s = CShow(); //错误，operator=只能被右值对象调用
CShow() = s; //正确
6、C++11中新增的使用{}初始化
原来在C++中，对于普通数组、结构体、没有构造析构和虚函数的类可以使用 {} 进行初始化，也就是我们所说的初始化列表，而对于类对象或容器的初始化不支持{}，只能使用()或拷贝构造函数，C++11中则没有了这个限制，使用初始化列表还可以防止类型收窄：
int i = { 100 }; int num{ 100 }; int n{ 100.0 }; //从double转换为int为类型收缩，编译出错 std::vector<int> v = { 0, 1, 2 }; std::map<int, std::string> m = { { 0, "c++" },{ 1, "java" },{ 2, "c#" } }; int* p = new int[3]{ 0, 1, 2 }; class CFoo { public: CFoo(int a, int b) { ; } }; class CBar { private: CFoo f{ 0, 0 }; }; CFoo f = { 8, 9 }; CFoo func(CFoo f) { return{ 8, 9 }; } func({ 10, 11 });