C++11 核心特性详解：列表初始化、右值引用与移动语义

3. C++11 中的 std::initializer_list

虽然 {} 很方便，但面对需要动态数量的元素时（如 vector<int> v = {1,2,3}），我们需要 std::initializer_list。

原理：

• std::initializer_list 内部维护一个指向数组的指针对（begin/end）。
• STL 容器通过重载接受 initializer_list 的构造函数，从而支持任意数量元素的初始化。

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

int main() {
    // initializer_list 本质是一个轻量级数组包装
    std::initializer_list<int> mylist = { 10, 20, 30 };
    cout << sizeof(mylist) << endl; // 通常是两个指针的大小
    
    // 容器初始化
    vector<int> v1({ 1,2,3,4,5 });      // 显式调用构造函数
    vector<int> v2 = { 1,2,3,4,5 };    // 隐式调用
    
    // map 的 key-value 对初始化
    map<string, string> dict = { 
        {"sort", "排序"}, 
        {"string", "字符串"} 
    };
    
    // 赋值也支持
    v1 = { 10,20,30,40,50 };
    return 0;
}

总结：

1. 任意类型（内置、自定义）都支持列表初始化。
2. 自定义类型的列表初始化依赖于构造函数。
3. initializer_list 主要是为 STL 容器准备的，让容器支持变长参数初始化。

三、右值引用和移动语义

C++11 新增的右值引用（Rvalue Reference）彻底改变了资源管理方式，配合移动语义解决了深拷贝带来的性能瓶颈。

1. 左值和右值

• 左值 (lvalue)：表示具有持久状态的表达式，可取地址（如变量名）。
• 右值 (rvalue)：表示临时数据或字面量，不可取地址（如 10, x + y）。

现代 C++ 定义中，左值强调'有地址'，右值强调'提供值但无地址'。

#include<iostream>
using namespace std;

int main() {
    // 左值：可取地址
    int b = 1;
    int* p = new int(0);
    cout << &b << endl;
    cout << &p << endl;
    
    // 右值：不可取地址
    double x = 1.1;
    // cout << &(x + y) << endl; // 编译错误
    string("temp"); 
    return 0;
}

2. 左值引用和右值引用

• Type& r1 = x;：左值引用，绑定左值。
• Type&& rr1 = y;：右值引用，绑定右值。
• 关键点：const 左值引用可以绑定右值；右值引用可以通过 std::move 绑定左值。
• 注意：右值引用变量本身在表达式中仍被视为左值（因为它有名字），除非再次 move。

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

int main() {
    int b = 1;
    
    // 左值引用
    int& r1 = b;
    
    // 右值引用
    int&& rr1 = 10;
    
    // const 左值引用绑定右值
    const int& rx1 = 10;
    
    // move 将左值转为右值
    int&& rrx1 = move(b);
    
    // 右值引用变量本身是左值属性
    int&& x = 1;
    // f(x); // 会匹配左值引用重载
    // f(move(x)); // 匹配右值引用重载
    return 0;
}

3. 引用延长生命周期

右值引用可用于延长临时对象的生命周期，允许修改该对象。

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

int main() {
    std::string s1 = "Test";
    
    // const 左值引用延长生命周期，但不可修改
    const std::string& r2 = s1 + s1;
    
    // 右值引用延长生命周期，且可修改
    std::string&& r3 = s1 + s1;
    r3 += " Test";
    cout << r3 << '\n';
    return 0;
}

4. 左值和右值的参数匹配

函数重载时，编译器会根据实参类型选择最匹配的形参：

• 左值 -> T&
• const 左值 -> const T&
• 右值 -> T&&

#include<iostream>
using namespace std;

void f(int& x) { cout << "左值引用" << endl; }
void f(const int& x) { cout << "const 左值引用" << endl; }
void f(int&& x) { cout << "右值引用" << endl; }

int main() {
    int i = 1;
    f(i);       // 调用 f(int&)
    f(3);       // 调用 f(int&&)
    f(std::move(i)); // 调用 f(int&&)
    return 0;
}

5. 右值引用和移动语义的使用场景

（1）解决传值返回问题

C++98 中返回局部对象会导致拷贝开销。C++11 引入移动语义后，若定义了移动构造函数，返回值时可自动触发移动而非拷贝。

（2）移动构造和移动赋值

移动操作的核心是'窃取'资源，而非复制数据。这对包含堆内存的类（如 string, vector）至关重要。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;

namespace lrq {
class string {
public:
    typedef char* iterator;
    iterator begin() { return _str; }
    iterator end() { return _str + _size; }
    
    string(const char* str) :_size(strlen(str)), _capacity(_size) {
        cout << "string(char*)-构造" << 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&) -- 拷贝构造" << endl;
        reserve(s._capacity);
        for (auto ch : s) push_back(ch);
    }
    
    // 移动构造
    string(string&& s) {
        cout << "string(string&&) -- 移动构造" << endl;
        swap(s); // 窃取资源
    }
    
    string& operator=(const string& s) {
        cout << "operator=(const string&) -- 拷贝赋值" << endl;
        if (this != &s) {
            delete[] _str;
            _str = nullptr;
            reserve(s._capacity);
            for (auto ch : s) push_back(ch);
        }
        return *this;
    }
    
    // 移动赋值
    string& operator=(string&& s) {
        cout << "operator=(string&&) -- 移动赋值" << endl;
        swap(s);
        return *this;
    }
    
    ~string() {
        cout << "~string() -- 析构" << endl;
        delete[] _str;
        _str = nullptr;
    }
    
    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';
    }
    
    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;
        }
    }
    
    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() {
    lrq::string s1("xxxxx");
    lrq::string s2 = s1;              // 拷贝构造
    lrq::string s3 = lrq::string("yyyyy"); // 移动构造
    return 0;
}

（3）编译器优化策略

在不同编译环境下（Debug/Release），编译器会对返回值优化（RVO/NRVO）做不同程度的处理。关闭优化选项（如 -fno-elide-constructors）可以更清晰地观察到拷贝与移动的调用过程。

本文重点梳理了 C++11 中列表初始化的便利性与右值引用的底层机制。理解这些特性有助于编写更高效、更安全的现代 C++ 代码。