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

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

对于容器初始化，如果不想写多个构造函数，std::initializer_list 提供了通用方案。

• 本质：底层是一个数组，内部有两个指针分别指向开始和结束位置。
• 作用：允许容器接受任意数量的值进行初始化，如 vector<int> v = {1, 2, 3};。

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

int main() {
    std::initializer_list<int> mylist = { 10, 20, 30 };
    cout << sizeof(mylist) << endl;
    
    // 两种写法语义略有不同，v1 是直接构造，v2 涉及临时对象
    vector<int> v1({ 1, 2, 3, 4, 5 });
    vector<int> v2 = { 1, 2, 3, 4, 5 };
    
    // map 的 initializer_list 构造结合 pair 隐式转换
    map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };
    
    // 赋值也支持
    v1 = { 10, 20, 30, 40, 50 };
    return 0;
}

三、右值引用和移动语义

C++11 新增右值引用，解决了深拷贝类对象的性能问题。

1. 左值和右值

• 左值 (Lvalue)：有持久状态，可取地址，如变量名。英文简写 lvalue (locator value)。
• 右值 (Rvalue)：字面量或临时对象，不可取地址。英文简写 rvalue (read value)。

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

int main() {
    int b = 1;
    // 左值：可以取地址
    int* p = &b;
    
    // 右值：不能取地址
    // cout << &10 << endl; // 错误
    double x = 1.1, y = 2.2;
    x + y; // 表达式结果存在临时对象里
    string("11111"); // 临时对象
    return 0;
}

2. 左值引用和右值引用

• 左值引用 (Type&)：绑定左值。
• 右值引用 (Type&&)：绑定右值。
• const 左值引用：可以绑定右值，用于延长临时对象生命周期。
• move 函数：将左值强制转为右值引用。

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

int main() {
    int b = 1;
    string s("test");
    
    // 左值引用给左值取别名
    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. 引用延长生命周期

右值引用可用于为临时对象延长生命周期；const 左值引用也能延长，但对象不可修改。

#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. 左值和右值的参数匹配

C++11 允许根据实参类型重载函数：

• 左值实参 -> 左值引用形参
• const 左值实参 -> const 左值引用形参
• 右值实参 -> 右值引用形参

#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;
    const int ci = 2;
    f(i);       // 调用 f(int&)
    f(ci);      // 调用 f(const int&)
    f(3);       // 调用 f(int&&)
    f(std::move(i)); // 调用 f(int&&)
    return 0;
}

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

（1）解决传值返回问题

C++98 中返回局部对象需要拷贝，代价大。C++11 通过移动语义减少开销。

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

移动构造函数要求第一个参数是右值引用，本质是'窃取'资源而非拷贝。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
#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*) :_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() {
    lrq::string s1("xxxxx");
    lrq::string s2 = s1;              // 拷贝构造
    lrq::string s3 = lrq::string("yyyyy"); // 构造 + 移动构造（优化后直接构造）
    cout << "******************************" << endl;
    return 0;
}

（3）右值对象构造与赋值的场景分析

• 只有拷贝构造，没有移动构造：编译器可能优化掉部分拷贝，但在关闭优化（如 -fno-elide-constructors）时会看到两次拷贝。
• 既有拷贝也有移动构造：优先调用移动构造，效率更高。
• 赋值操作同理：右值对象赋值时，若有移动赋值则调用移动赋值，否则回退到拷贝赋值。

理解这些机制的关键在于观察局部对象的生命周期和栈帧变化，以及编译器对 RVO（返回值优化）的处理。