C++11 深度剖析：列表初始化与右值引用

前言

随着现代软件开发的快速发展，编程语言也在不断进化。C++11 是 C++ 语言的一个重要版本，于 2011 年正式发布，引入了许多全新的特性，极大地提升了代码的效率、可读性以及程序的执行性能。从增强的类型推断到智能指针，从并发编程的支持到对 Lambda 表达式的引入，C++11 使得开发者在编写高效且可维护的代码时拥有了更多的选择。

1. C++11 的发展历史

C++11 是 C++ 的第二个主要版本，并且是从 C++98 起的最重要更新。它引入了大量更改，标准化了既有实践，并改进了对 C++ 程序员可用的抽象。在它最终由 ISO 在 2011 年 8 月 12 日采纳前，人们曾使用名称'C++0x'，因为它曾被期待在 2010 年之前发布。C++03 与 C++11 期间花了 8 年时间，故而这是迄今为止最长的版本间隔。从那时起，C++ 有规律地每 3 年更新一次。

2. 列表初始化

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.2 C++11 中的{}

C++11 以后想统一初始化方式，试图实现一切对象皆可用{}初始化，{}初始化也叫做列表初始化。

• 内置类型支持，自定义类型也支持，自定义类型本质是类型转换，中间会产生临时对象，最后优化后变成直接构造。
• {}初始化的过程中，可以省略掉=。
• C++11 列表初始化的本意是想实现一个大统一的初始化方式，其次在有些场景下带来的不少便利，如容器 push/inset 多参数构造的对象时，{}初始化会很方便。

#include<iostream>
#include<vector>
using namespace std;

struct P{ int a; int b; };

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1) :_year(year), _month(month), _day(day) {
        cout << "Date(int year = 1, int month = 1, int day = 1)" << 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++98 支持
    int a[] = { 1, 2, 3, 4, 5 };
    int a2[5] = { 0 };
    P p = { 1, 2 };

    // C++11 支持的
    // 内置类型支持
    int x1 = { 2 };

    // 自定义类型支持
    // 这里本质是用{ 2025, 1, 1}构造一个 Date 临时对象
    // 临时对象再去拷贝构造 d1，编译器优化后合二为一变成{ 2025, 1, 1}直接构造初始化
    Date d1 = { 2025, 1, 1 };

    // 这里 d2 引用的是{ 2024, 7, 25}构造的临时对象
    const Date& d2 = { 2024, 7, 25 };

    // 需要注意的是 C++98 支持单参数时类型转换，也可以不用{}
    Date d3 = { 2025 };
    Date d4 = 2025;

    // 可以省略掉=
    P p1{ 1, 2 };
    int x2{ 2 };
    Date d6{ 2024, 7, 25 };
    const Date& d7{ 2024, 7, 25 };

    // 不支持，只有{}初始化，才能省略=
    vector<Date> v;
    v.push_back(d1);
    v.push_back(Date(2025, 1, 1));
    // 比起有名对象和匿名对象传参，这里{}更有性价比
    v.push_back({ 2025, 1, 1 });
    return 0;
}

2.3 C++11 中的 std::initializer_list

上面的初始化已经很方便，但是对象容器初始化还是不太方便，比如一个 vector 对象，我想用 N 个值去构造初始化，那么我们得实现很多个构造函数才能支持。 vector v1 ={1,2,3}; vector v2 = {1,2,3,4,5};

• C++11 库中提出了一个 std::initializer_list 的类，auto il = { 10, 20, 30 }; // the type of il is an initializer_list，这个类的本质是底层开一个数组，将数据拷贝过来，std::initializer_list 内部有两个指针分别指向数组的开始和结束。
• 容器支持一个 std::initializer_list 的构造函数，也就支持任意多个值构成的 {x1,x2,x3...} 进行初始化。STL 中的容器支持任意多个值构成的 {x1,x2,x3...} 进行初始化，就是通过 std::initializer_list 的构造函数支持的。

#include<iostream>
#include<vector>
#include<string>
#include<map>
using namespace std;

int main() {
    std::initializer_list<int> mylist;
    mylist = { 10, 20, 30 };
    cout << sizeof(mylist) << endl;
    // 这里 begin 和 end 返回的值 initializer_list 对象中存的两个指针
    // 这两个指针的值跟 i 的地址跟接近，说明数组存在栈上
    int i = 0;
    cout << mylist.begin() << endl;
    cout << mylist.end() << endl;
    cout << &i << endl;

    // {}列表中可以有任意多个值
    // 这两个写法语义上还是有差别的，第一个 v1 是直接构造，
    // 第二个 v2 是构造临时对象 + 临时对象拷贝 v2+优化为直接构造
    vector<int> v1({ 1,2,3,4,5 });
    vector<int> v2 = { 1,2,3,4,5 };
    const vector<int>& v3 = { 1,2,3,4,5 };

    // 这里是 pair 对象的{}初始化和 map 的 initializer_list 构造结合到一起用了
    map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };

    // initializer_list 版本的赋值支持
    v1 = { 10,20,30,40,50 };
    return 0;
}

3. 右值引用

3.1 左值和右值

• 左值是一个表示数据的表达式 (如变量名或解引用的指针)，一般是有持久状态，存储在内存中，我们可以获取它的地址。左值可以出现赋值符号的左边，也可以出现在赋值符号右边。定义时 const 修饰符后的左值，不能给他赋值，但是可以取它的地址。

int main() {
    int* p = new int(0);
    *p = 10;
    int c = 1;
    const int b = c;
    string s = "hello";
    string s1("world");
    /*cout << *p << endl;*/
    cout << &p << endl;
    cout << &b << endl;
    cout << &s << endl;
    cout << &s1 << endl;
    cout << (void*) &s1[0] << endl;
    return 0;
}

**右值也是一个表示数据的表达式，要么是字面值常量、要么是表达式求值过程中创建的临时对象等，**右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。

// 右值：不能取地址
double x = 1.1, y = 2.2;
// 以下⼏个 10、x + y、fmin(x, y)、string("11111")都是常⻅的右值
10;
x + y;
fmin(x, y);
string("11111");
cout << &10 << endl;
cout << &(x+y) << endl;
cout << &(fmin(x, y)) << endl;
cout << &string("11111") << endl;

值得一提的是，左值的英文简写为 lvalue，右值的英文简写为 rvalue。传统认为它们分别是 left value、right value 的缩写。现代 C++ 中，lvalue 被解释为 locator value 的缩写，可意为存储在内存中、有明确存储地址可以取地址的对象，而 rvalue 被解释为 read value，指的是那些可以提供数据值，但是不可以寻址，例如：临时变量，字面量常量，存储于寄存器中的变量等，也就是说左值和右值的核心区别就是能否取地址。

3.2 左值引用和右值引用

1. Type& r1 = x; Type&& rr1 = y; 第一个语句就是左值引用，左值引用就是给左值取别名，第二个就是右值引用，同样的道理，右值引用就是给右值取别名。

int main() {
    // 左值：可以取地址
    // 以下的 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];
    return 0;
}

右值引用给右值取别名

int && rr1 = 10;
int && rr2 = x + y;
double && rr3 = fmin(x, y);
string && rr4 = string("11111");

2. 左值引用不能直接引用右值，但是 const 左值引用可以引用右值

// const 左值引用可以引用右值
const int& rr5 = 10;
const int& rr6 = x + y;
const double& rr7 = fmin(x, y);
const string& rr8 = string("11111");

3. 右值引用不能直接引用左值，但是右值引用可以引用 move(左值)

// 右值引用 move 左值
int&&rrx1 = move(b);
int*&&rrx2 = move(p);
int&&rrx3 = move(*p);
string&&rrx4 = move(s);
char&&rrx5 = move(s[0]);

4. template <class T> typename remove_reference<T>::type&& move(T&& arg); move 是库里面的一个函数模板，本质内部是进行强制类型转换，当然他还涉及一些引总折叠的知识，这个后面会细讲。

5. 需要注意的是变量表达式都是左值属性，也就意味着一个右值被右值引用绑定后，右值引用变量变量表达式的属性是左值

// b、r1、rr1 都是变量表达式，都是左值
cout<<&b<<endl;
cout<<&r1<<endl;
cout << &rr1 << endl;
// 这里要注意的是，rr1 的属性是左值，所以不能再被右值引用绑定，除非 move 一下
int& r6 = r1;
//int&& rrx6 = rr1;--报错
int&& rrx6 = move(rr1);

3.3 引用延长生命周期

右值引用可用于为临时对象延长生命周期，const 的左值引用也能延长临时对象生存期，但这些对象无法被修改。

int main() {
    string s1="hello";
    //string&& s2 = s1;//不能右值引用绑定左值
    const string& s2 = s1 + s1;
    // OK：到 const 的左值引用延⻓⽣存期
    // r2 += "Test"; // 错误：不能通过到 const 的引⽤修改
    string&& r3 = s1 + s1;
    // OK：右值引⽤延⻓⽣存期
    r3 += "Test";
    // OK：能通过到⾮ const 的引⽤修改
    cout << r3 << '\n';
    return 0;
}

3.4 左值和右值的参数匹配

1. C++98 中，实现一个 const 左值引用作为参数的函数，那么实参传递左值和右值都可以匹配。
2. C++11 以后，分别重载左值引用、const 左值引用、右值引用作为形参的 f 函数，那么实参是左值会匹配 f(左值引用)，实参是 const 左值会匹配 f(const 左值引用)，实参是右值会匹配 f(右值引用)。注意右值引用变量在用于表达式时属性是左值，这个设计这里会感觉跟怪，下一博客讲右值引用的使用场景时，就能体会这样设计的价值了

void fun1(int& x) {
    cout << "左值引用重载 func1(int&x)" << endl;
}
void fun1(int&& x) {
    cout << "右值引用重载 func1(int&&x)" << endl;
}
void fun1(const int& x) {
    cout << "左值引用重载 func2(const int&x)" << endl;
}

int main() {
    int x = 10;
    const int y = x;
    fun1(x);
    fun1(10);
    // 如果没有 fun1(int&&) 重载则会调⽤ fun1(const int&)
    fun1(y);
    // 右值引⽤变量在⽤于表达式时是左值
    int&& r = 10;
    fun1(r);
    fun1(move(r));
    return 0;
}