1、C++11的发展历史
C++11是C++的第二个主要版本，并且是从C++98起的最重要更新。它引入了大量更改，标准化了既有实践，并改进了对C++程序员可用的抽象。在它最终由ISO在2011年8月12日采纳前，人们曾使用名称“C++0×”，因为它曾被期待在2010年之前发布。C++03与C++11期间花了8年时间，故而这是迄今为止最长的版本间隔。从那时起，C++有规律地每3年更新一次。
2、列表初始化
1）C++98传统的{}
C++98中一般结构体和数组可以使用{}来初始化。
代码示例：
struct Point
{
int _x;
int _y;
};
int main()
{
int array1[] = { 1, 2, 3, 4, 5 };
int array2[5] = { 0 };
Point p = { 1, 2 };
return 0;
}2）C++11的{}
C++11以后想统一初始化方式，试图实现一切对象皆可用初始化，初始化也叫做列表初始化。
内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化了以后变成直接构造。
初始化的过程中，可以省略掉=。
C++11列表初始化的本意是想实现一个大统一的初始化方式，其次他在有些场景下带来的不少便利，如容器push/inset多参数构造的对象时，{}初始化会很方便。
代码示例：
class Date
{
public:
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{
cout << "Date(int year, int month, int day)" << endl;
}
Date(const Date& d)
:_year(d._year)
, _month(d._month)
, _day(d._day)
{
cout << "Date(const Date& d)" << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
//C++11支持
int a = 1;
int b = { 2 };
int c{ 3 };
//自定义类型支持
Date d1(2023, 4, 9);
Date d2 = { 2024,5,6 };//多参数隐式类型转换//构造一个临时对象，然后拷贝构造给d2,C++11优化成直接构造//构造+拷贝构造-》优化成直接构造
Date d3 = 2024;//单参数隐式类型转换
Date d4{ 2023,9,9 };//支持
//Date d5 2024;//不支持
vector<Date> v;
v.push_back(2024);
v.push_back({ 2021,3,5 });
const Date& d6 = { 2025,7,8 };//这里d6引用的是{2025，7，8}构造的临时对象
return 0;
}3）C++11的std::initializer_list
std::initializer_list一般在容器中常见。
代码示例：
//语法逻辑不一样
Date d1{ 2013,4,5 };//1~3个参数来初始化
vector<int> v{1, 2, 3, 4, 5};//任意个参数来初始化std::initializer_list支持多个参数来初始化的原因？它本质是一个类，这个类在底层开了个数组，将数据拷贝到数组里面，并且它的内部有两个指针分别指向数组的开始或者结束。
代码示例：
auto il = { 1,2,3 };
initializer_list<int> i2 = { 4,5,6,7 };
const vector<int>& v1 = { 1,3,54,5 };//引用的对象具有常性
cout << typeid(i2).name() << endl;//可以打印出i2的类型名
1、触发点：
当使用
{}进行初始化容器时，编译器会自动创建initializer_list对象。
触发initializer_list时，编译器的行为：1)临时数组创建：编译器将花括号内的元素转换为一个临时数组。
2)initializer_list构造：通过临时数组的首地址和长度构造initializer_list对象。
3)生命周期管理：临时数组的生命周期与initializer_list对象相同，通常持续到包含它的完整表达式结束。
2、特性：
不可变特性：initializer_list中的元素是只读的，无法修改。
浅拷贝：拷贝initializer_list对象时，仅复制指针和长度，不复制元素本身。
临时数组：初始化列表的元素存储在临时内存区域（通常是栈上)，其生命周期与initializer_list对象绑定。
3、它和容器之间的行为
假设和vector的行为：
1、编译器创建临时initializer_list<int>对象,指向临时数组{1,2,3}。
2、调用vector的initializer_list构造函数，将元素从临时数组复制到vector内部。
3、右值引用和移动语义
C++98的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，C++11之后我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。
1）右值和左值
左值是一个表示数据的表达式(如变量名或解引用的指针），一般是有持久状态，存储在内存中，我们可以获取它的地址，左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。
右值也是一个表示数据的表达式，要么是字面值常量、要么是表达式求值过程中创建的临时对象等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
值得一提的是，左值的英文简写为lvalue，右值的英文简写为rvalue。传统认为它们分别是leftvalue、right value的缩写。现代C++中,lvalue被解释为loactor value的缩写,可意为存储在内存中、有明确存储地址可以取地址的对象，而rvalue被解释为read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字面量常量，存储于寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址。
代码示例：
// 左值：可以取地址
// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("111111");
s[0] = 'x';
// 右值：不能取地址
double x = 1.1, y = 2.2;
// 以下⼏个10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
10;
x + y;
fmin(x, y);
string("11111");2）左值引用和右值引用
Type& rl = x；Type&& rr1 = y；第一个语句就是左值引用，左值引用就是给左值取别名，第二个就是右值引用，同样的道理，右值引用就是给右值取别名。
左值引用不能直接引用右值，但是const左值引用可以引用右值。
右值引用不能直接引用左值，但是右值引用可以引用move(左值）。
move是库里面的一个函数模板，本质内部是进行强制类型转换，当然他还涉及一些引用折叠的知识，这个我们后面会细讲。
需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量变量表达式的属性是左值。
语法层面看，左值引用和右值引用都是取别名，不开空间。从汇编底层的角度看下面代码中r1和rr1汇编层实现，底层都是用指针实现的，没什么区别。底层汇编等实现和上层语法表达的意义有时是背离的，所以不要然到一起去理解，互相佐证，这样反而是陷入迷途。
代码示例：
// 以下的p、b、c、*p、s、s[0]就是常⻅的左值
int* p = new int(0);
int b = 1;
const int c = b;
*p = 10;
string s("111111");
s[0] = 'x';
double x = 1.1, y = 2.2;
// 左值引⽤给左值取别名
int& r1 = b;
int*& r2 = p;
int& r3 = *p;
string& r4 = s;
char& r5 = s[0];
// 右值引⽤给右值取别名
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);
string&& rr4 = string("11111");
// 左值引⽤不能直接引⽤右值，但是const左值引⽤可以引⽤右值也可以引用左值
const int& rx1 = 10;
const double& rx2 = x + y;
const double& rx3 = fmin(x, y);
const string& rx4 = string("11111");
const int& i2 = b;
// 右值引⽤不能直接引⽤左值，但是右值引⽤可以引⽤move(左值)
int&& rrx1 = move(b);
int*&& rrx2 = move(p);
int&& rrx3 = move(*p);
string&& rrx4 = move(s);
string&& rrx5 = (string&&)s;
// 这⾥要注意的是，rr1的属性是左值，所以不能再被右值引⽤绑定，除⾮move⼀下
int& r6 = r1;
// int&& rrx6 = rr1;
int&& rrx6 = move(rr1);注意：move是一个类型转换函数。底层跟强转差不多。
3）引用延长生命周期
右值引用可用于为临时对象延长生命周期，const的左值引用也能延长临时对象生存期，但这些对象无法被修改。
代码示例：
std::string s1 = "Test";
// std::string&& r1 = s1; // 错误：不能绑定到左值
const std::string& r2 = s1 + s1; // OK：到 const 的左值引⽤延⻓⽣存期
// r2 += "Test"; // 错误：不能通过到 const 的引⽤修改
std::string&& r3 = s1 + s1; // OK：右值引⽤延⻓⽣存期
r3 += "Test"; // OK：能通过到⾮ const 的引⽤修改
std::cout << r3 << '\n';4）左值和右值的参数匹配
C++98中，我们实现一个const左值引用作为参数的函数，那么实参传递左值和右值都可以匹配。
C++11以后，分别重载左值引用、const左值引用、右值引用作为形参的f函数，那么实参是左值会匹配f(左值引用)，实参是const左值会匹配f(const左值引用)，实参是右值会匹配f(右值引用)。
右值引用变量在用于表达式时属性是左值。这是为下面的移动语义准备的，要不然怎么交换右值的资源。
void f(int& x)
{
std::cout << "左值引⽤重载 f(" << x << ")\n";
}
void f(const int& x)
{
std::cout << "到 const 的左值引⽤重载 f(" << x << ")\n";
}
void f(int&& x)
{
std::cout << "右值引⽤重载 f(" << x << ")\n";
}
int main()
{
int i = 1;
const int ci = 2;
f(i); // 调⽤ f(int&)
f(ci); // 调⽤ f(const int&)
f(3); // 调⽤ f(int&&)，如果没有 f(int&&) 重载则会调⽤ f(const int&)
f(std::move(i)); // 调⽤ f(int&&)
// 右值引⽤变量在⽤于表达式时是左值
int&& x = 1;
f(x); // 调⽤ f(int& x)
f(std::move(x)); // 调⽤ f(int&& x)
return 0;
}
注意：函数调用的原则是有更匹配的调用更匹配的，有左值调用用左值调用没有就调用const 左值调用。
5）左值引用主要使用场景回顾
左值引用主要使用场景是在函数中左值引用传参和左值引用传返回值时减少拷贝，同时还可以修改实参和修改返回对象的价值。左值引用已经解决大多数场景的拷贝效率问题，但是有些场景不能使用传左值引用返回，如addStrings和generate函数，C++98中的解决方案只能是被迫使用输出型参数解决。那么C++11以后这里可以使用右值引用做返回值解决吗？显然是不可能的，因为这里的本质是返回对象是一个局部对象，函数结束这个对象就析构销毁了，右值引用返回也无法概念对象已经析构销毁的事实。
代码示例：
class Solution {
public:
// 传值返回需要拷⻉
string addStrings(string num1, string num2) {
string str;
int end1 = num1.size() - 1, end2 = num2.size() - 1;
// 进位
int next = 0;
while (end1 >= 0 || end2 >= 0)
{
int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
int ret = val1 + val2 + next;
next = ret / 10;
ret = ret % 10;
str += ('0' + ret);
}
if (next == 1)
str += '1';
reverse(str.begin(), str.end());
return str;
}
};
class Solution {
public:
// 这⾥的传值返回拷⻉代价就太⼤了
vector<vector<int>> generate(int numRows) {
vector<vector<int>> vv(numRows);
for (int i = 0; i < numRows; ++i)
{
vv[i].resize(i + 1, 1);
}
for (int i = 2; i < numRows; ++i)
{
for (int j = 1; j < i; ++j)
{
vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
}
}
return vv;
}
};
//优化代码
class Solution {
public:
// 这⾥的传值返回拷⻉代价就太⼤了
vector<vector<int>> generate(int numRows,vector<vector<int>>& vv) {
//vector<vector<int>> vv(numRows);
vv.resize(numRows);
for (int i = 0; i < numRows; ++i)
{
vv[i].resize(i + 1, 1);
}
for (int i = 2; i < numRows; ++i)
{
for (int j = 1; j < i; ++j)
{
vv[i][j] = vv[i - 1][j] + vv[i - 1][j - 1];
}
}
return vv;
}
};分析：addStrings函数，如果没有移动构造而且不考虑优化的情况下：返回值会先进行拷贝构造给临时对象再把临时对象拷贝给接受临时对象的值；反之，返回值移动构造给临时对象再把临时对象移动构造接收返回值的值，大大提高了效率。
6）移动构造和移动赋值
移动构造函数是一种构造函数，类似拷贝构造函数，移动构造函数要求第一个参数是该类类型的引用，但是不同的是要求这个参数是右值引用，如果还有其他参数，额外的参数必须有缺省值。
移动赋值是一个赋值运算符的重载，他跟拷贝赋值构成函数重载，类似拷贝赋值函数，移动赋值函数要求第一个参数是该类类型的引用，但是不同的是要求这个参数是右值引用。
对于像string/vector这样的深拷贝的类或者包含深拷贝的成员变量的类，移动构造和移动赋值才有意义，因为移动构造和移动赋值的第一个参数都是右值引用的类型，他的本质是要“窃取”引用的右值对象的资源，而不是像拷贝构造和拷贝赋值那样去拷贝资源，从提高效率。下面的la::string样例实现了移动构造和移动赋值，我们需要结合场景理解。
注意：移动语义主要针对右值引用，移动语义本质就是对资源进行交换，因为右值一般是临时对象；建议不要交换左值的资源，一旦交换，左值的资源会丢失，例如：move(左值)。
代码示例：
namespace la
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
cout << "string(char* str)-构造" << endl;
_str = new char[_capacity + 1];
strcpy(_str, str);
}
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
string(const string& s)
:_str(nullptr)
{
cout << "string(const string& s) -- 拷⻉构造" << endl;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
// 移动构造
string(string&& s)
{
cout << "string(string&& s) -- 移动构造" << endl;
swap(s);
}
string& operator=(const string& s)
{
cout << "string& operator=(const string& s) -- 拷⻉赋值" <<
endl;
if (this != &s)
{
_str[0] = '\0';
_size = 0;
reserve(s._capacity);
for (auto ch : s)
{
push_back(ch);
}
}
return *this;
}
// 移动赋值
string& operator=(string&& s)
{
cout << "string& operator=(string&& s) -- 移动赋值" << endl;
swap(s);
return *this;
}
~string()
{
cout << "~string() -- 析构" << endl;
delete[] _str;
_str = nullptr;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
if (_str)
{
strcpy(tmp, _str);
delete[] _str;
}
_str = tmp;
_capacity = n;
}
}
void push_back(char ch)
{
if (_size >= _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity *
2;
reserve(newcapacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
const char* c_str() const
{
return _str;
}
size_t size() const
{
return _size;
}
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
};
}
int main()
{
la::string s1("xxxxx");
// 拷⻉构造
la::string s2 = s1;
// 构造+移动构造，优化后直接构造
la::string s3 = la::string("yyyyy");//构造一个临时对象，临时对象具有常性，用临时对象移动构造s3，但是编译器直接优化成直接构造
// 移动构造
la::string s4 = move(s1);
la::string s5;//调用默认构造
la::string s5 = la::string("hhhh");//构造+移动赋值，优化成直接赋值。构造一个临时对象，把临时对象的资源交换给s5。
return 0;
}图片解析：
以下都是无优化情况下。
由于C++11的特性较多，分篇进行讲解！