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

C++11 中的 std::initializer_list

虽然列表初始化很方便，但在容器初始化场景下，如果希望用 N 个值构造，传统方式需要重载多个构造函数。C++11 引入了 std::initializer_list 类来解决这个问题。

std::initializer_list 本质上是一个轻量级的数组包装器，内部维护两个指针分别指向数据的开始和结束位置。STL 容器通过提供接受 initializer_list 的构造函数，从而支持任意数量的参数进行初始化。

#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", "字符串"} };

    // 赋值操作符也支持 initializer_list
    v1 = { 10, 20, 30, 40, 50 };
    return 0;
}

总结：

1. 任意类型（内置、自定义）都支持列表初始化，自定义类型依赖构造函数。
2. vector<int> v1({ 1,2,3,4,5 }); 这种写法避免了'虚函数'歧义（即空括号问题）。
3. initializer_list 主要是为 STL 容器准备的，让容器支持任意多个类型的参数初始化。

右值引用和移动语义

C++11 新增的右值引用语法，配合移动语义，解决了深拷贝带来的性能瓶颈。

左值和右值

• 左值 (lvalue)：表示具有持久状态的表达式，如变量名。可以取地址，可出现在赋值符号左边。现代定义中，lvalue 意为 "location value"，指存储在内存中有明确地址的对象。
• 右值 (rvalue)：表示临时数据，如字面量常量或表达式求值产生的临时对象。不能取地址，只能出现在赋值符号右边。rvalue 意为 "read value"，指提供数据值但不可寻址的对象。

#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, y = 2.2;
    // cout << &(x + y) << endl; // 编译错误
    fmin(x, y); 
    string("11111");
    return 0;
}

引用延长生命周期

右值引用可用于为临时对象延长生命周期。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;
}

左值和右值的参数匹配

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&&)
    
    int&& x = 1;
    f(x);          // 调用 f(int&)，因为 x 是左值
    f(std::move(x)); // 调用 f(int&&)
    return 0;
}

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

移动构造和移动赋值

移动构造函数和移动赋值运算符类似于拷贝版本，但要求第一个参数是右值引用。其核心目的是'窃取'资源而非复制资源，适用于包含动态内存分配的类（如 string, vector）。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
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) {
                delete[] _str;
                _str = nullptr;
                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;
        }

        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) reserve(_capacity == 0 ? 4 : _capacity * 2);
            _str[_size] = ch; ++_size; _str[_size] = '\0';
        }
        size_t size() const { return _size; }
        const char* c_str() const { return _str; }

    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;
}

解决传值返回问题

在 C++98 中，返回局部对象会导致拷贝开销。C++11 利用右值引用和移动语义，结合返回值优化（RVO/MVRO），可以避免不必要的拷贝。

namespace lrq {
    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;
    }
}

int main() {
    // 场景 1：直接初始化，可能触发移动构造
    lrq::string ret = lrq::addStrings("11111", "2222");
    
    // 场景 2：先声明再赋值，可能触发移动赋值
    lrq::string ret2;
    ret2 = lrq::addStrings("11111", "2222");
    return 0;
}

关于编译器优化的说明： 在现代编译器（如 VS2019 Release, GCC/Clang with O2/O3）中，上述代码通常会经历 RVO（Return Value Optimization）或 NRVO（Named Return Value Optimization），直接将局部对象构造在调用者的栈帧中，完全消除拷贝和移动操作。若需观察未优化的行为，可使用 -fno-elide-constructors 参数关闭优化。