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

C++11 中的 std::initializer_list

虽然列表初始化很方便，但在容器初始化时，如果不想写多个重载构造函数，std::initializer_list 提供了更好的方案。

• 作用：允许容器接受任意数量的值进行初始化，如 vector v1 = {1, 2, 3};。
• 原理：底层维护一个数组，内部有两个指针分别指向开始和结束位置（结束位置是最后一个元素的下一个）。
• 支持迭代器遍历。

STL 容器通过增加 initializer_list 的构造函数来支持这种语法。

// STL 容器示例
vector(initializer_list<value_type> il);
map(initializer_list<value_type> il);

// 手动模拟 vector 的 initializer_list 构造
template<class T>
class vector {
public:
    typedef T* iterator;
    vector(initializer_list<T> l) {
        for (auto& e : l) push_back(e);
    }
private:
    iterator _start = nullptr;
    iterator _finish = nullptr;
    iterator _endofstorage = nullptr;
};

// 赋值也支持
vector& operator= (initializer_list<value_type> il);

结合代码场景理解：

#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 返回的是指针地址
    int i = 0;
    cout << mylist.begin() << endl;
    cout << &i << endl;

    // 两种写法语义差别：v1 直接构造，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 结合
    map<string, string> dict = { {"sort", "排序"}, {"string", "字符串"} };

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

总结：

1. 任意类型（内置、自定义）都支持列表初始化，自定义类型依赖构造函数。
2. initializer_list 主要是为 STL 容器准备的，让容器支持任意多个值的初始化。
3. 本质是将列表值传给容器的 initializer_list 构造函数，经编译器优化后往往变为直接构造。

右值引用和移动语义

C++98 只有左值引用，C++11 新增了右值引用。两者都是给对象取别名，但行为不同。

左值和右值

• 左值 (lvalue)：表示数据的表达式，有持久状态，存储在内存中，可以获取地址。能出现在赋值符号左边或右边。
• 右值 (rvalue)：字面值常量或表达式求值产生的临时对象。只能出现在赋值符号右边，不能取地址。
• 核心区别：能否取地址。

#include<iostream>
using namespace std;

int main() {
    // 左值：可以取地址
    int* p = new int(0);
    int b = 1;
    const int c = b;
    *p = 10;
    string s("111111");
    s[0] = 'x';
    cout << &c << endl;
    cout << (void*)&s[0] << endl;

    // 右值：不能取地址
    double x = 1.1, y = 2.2;
    10;           // 字面量
    x + y;        // 临时对象
    fmin(x, y);   // 临时对象
    string("11111"); // 临时对象
    
    // cout << &10 << endl; // 错误
    return 0;
}

左值引用和右值引用

• 左值引用 (Type&)：给左值取别名。
• 右值引用 (Type&&)：给右值取别名。
• 规则：
  • 左值引用不能直接引用右值，但 const 左值引用可以。
  • 右值引用不能直接引用左值，但可以通过 std::move 将左值强转为右值。
• 注意：变量表达式本身属性是左值。即使绑定了右值引用，该变量名作为表达式使用时仍是左值。

#include<iostream>
using namespace std;

template <class _Ty>
remove_reference_t<_Ty>&& move(_Ty&& _Arg) {
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

int main() {
    int b = 1;
    
    // 左值引用
    int& r1 = b;
    
    // 右值引用
    int&& rr1 = 10;
    double&& rr2 = 1.1 + 2.2;
    
    // const 左值引用绑定右值
    const int& rx1 = 10;
    
    // move 左值变右值
    int&& rrx1 = move(b);
    
    // 右值引用变量本身是左值
    int&& x = 1;
    // f(x); // 调用左值引用重载
    // f(move(x)); // 调用右值引用重载
    
    return 0;
}

引用延长生命周期

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

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

int main() {
    std::string s1 = "Test";
    
    // const 左值引用延长生存期
    const std::string& r2 = s1 + s1;
    // r2 += "Test"; // 错误：const 不可修改
    
    // 右值引用延长生存期且可修改
    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&&)
    return 0;
}

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

左值引用传参回顾

左值引用传参可减少拷贝，提高效率。但对于局部对象返回，左值引用无法解决对象销毁问题。

移动构造和移动赋值

移动构造函数类似拷贝构造，但参数是右值引用。它不复制资源，而是'窃取'资源，效率更高。

#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;
            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) {
            size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
            reserve(newcapacity);
        }
        _str[_size] = ch;
        ++_size;
        _str[_size] = '\0';
    }
    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"); // 移动构造
    lrq::string s4 = std::move(s1);   // 显式移动
    return 0;
}

解决传值返回问题

对于深拷贝类，返回局部对象时，移动语义可以避免不必要的拷贝。

namespace lrq {
string addStrings(string num1, string num2) {
    string str;
    // ... 计算逻辑 ...
    return str; // 返回局部对象
}
}

int main() {
    lrq::string ret = lrq::addStrings("11111", "2222"); // 场景 1：构造 + 移动/拷贝
    lrq::string ret2;
    ret2 = lrq::addStrings("11111", "2222");            // 场景 2：赋值 + 移动/拷贝
    return 0;
}

编译器优化说明：

• 只有拷贝构造：编译器可能优化掉部分拷贝，但无法完全消除。
• 有移动构造：编译器会优先调用移动构造，性能显著提升。
• RVO/NRVO：现代编译器（Release 模式）通常会直接构造返回值对象，避免临时对象生成。

关闭优化编译（Linux: g++ test.cpp -fno-elideconstructors）可以看到未优化的拷贝过程。