C++11 新特性之列表初始化、initializer_list 与右值引用

C++11系列的全部目录
C++11 新特性详解（一）
├── 1. C++11简介
├── 2. 列表初始化
│   ├── C++98中的{}
│   ├── C++11统一初始化
│   └── initializer_list
└── 3. 右值引用基础
    ├── 左值和右值
    ├── 左值引用和右值引用
    ├── std::move
    └── 右值引用变量为什么又是左值
C++11 新特性详解（二）
├── 4. 移动语义
│   ├── 为什么需要移动构造
│   ├── 移动构造与移动赋值
│   ├── 深拷贝类中的资源转移
│   ├── 传值返回
│   └── STL中的移动
├── 5. 右值引用进阶
│   ├── 值类别
│   ├── 引用折叠
│   └── 万能引用
C++11 新特性详解（三）
├── 6. 完美转发
│   ├── 为什么需要forward
│   ├── T&&到底是什么
│   └── std::forward的原理
├── 7. 可变参数模板
│   ├── 参数包
│   ├── sizeof...
│   ├── 包扩展
│   └── 递归展开
└── 8. emplace系列
C++11 新特性详解（四）
├── 9. Lambda表达式
│   ├── Lambda是什么
│   ├── 为什么需要Lambda
│   ├── 仿函数与Lambda
│   ├── operator()
│   ├── auto为什么可以接Lambda
│   ├── 捕捉列表
│   ├── 值捕捉/引用捕捉
│   ├── 隐式捕捉
│   ├── mutable
│   └── Lambda底层原理
C++11 新特性详解（五）
├── 10. std::function
├── 11. bind
├── 12. function + Lambda + bind
├── 13. 逆波兰表达式案例
└── 14. C++11知识体系总结

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

//例如数组可以：
int a[] = {1, 2, 3};
//结构体可以：
Point p = {1, 2};

int x1 = { 2 };
Point p1 { 1, 2 };
Date d1 = { 2025, 1, 1 };
Date d2 { 2024, 7, 25 };

int x { 2 };
Point p { 1, 2 };
Date d { 2024, 7, 25 };

Point p {1, 2};

class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
        : _year(year)
        , _month(month)
        , _day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

​Date d1 = { 2025, 1, 1 };
可以从语义上理解为：
Date d1(2025, 1, 1);

cpp
template<class T>
class vector {
public:
    explicit vector(size_t count);                // 1个参数
    vector(size_t count, const T& value);         // 2个参数
    vector(const vector& other);                  // 1个参数（拷贝构造）
    // ... 等等
};

cpp
vector(int e1);                    // 支持 {1}
vector(int e1, int e2);            // 支持 {1,2}
vector(int e1, int e2, int e3);    // 支持 {1,2,3}
// ... 无穷无尽

vector<int> v;
v.push_back(1);
v.push_back(2);
v.push_back(3);
v.push_back(4);
v.push_back(5);

int arr[] = {1, 2, 3, 4, 5};
vector<int> v(arr, arr + 5);   // 利用迭代器区间构造函数

int arr[] = {1, 2, 3, 4, 5};   // 只有数组可以！

template<class T>
class initializer_list {
private:
    const T* _begin;   // 指向匿名数组的第一个元素
    const T* _end;     // 指向匿名数组的最后一个元素的下一个位置
public:
    // 构造函数（由编译器隐式调用，用户不能直接构造）
    constexpr initializer_list(const T* b, const T* e) noexcept
        : _begin(b), _end(e) {}
    // 获取元素个数
    constexpr size_t size() const noexcept { return _end - _begin; }
    // 迭代器支持（只读）
    const T* begin() const noexcept { return _begin; }
    const T* end()   const noexcept { return _end; }
};

#include <iostream>
#include <initializer_list>
int main() {
    std::initializer_list<int> mylist;
    mylist = {10, 20, 30};
    std::cout << sizeof(mylist) << std::endl;   // 通常输出 16（两个指针）
    int i = 0;
    std::cout << mylist.begin() << std::endl;   // 输出某个栈地址，例如 0x61fdf0
    std::cout << mylist.end()   << std::endl;   // 输出另一个栈地址，例如 0x61fdfc
    std::cout << &i            << std::endl;    // 输出另一个栈地址，例如 0x61fde0
    return 0;
}

template<class T>
class vector {
public:
    // 新增的 initializer_list 构造函数
    vector(std::initializer_list<T> il) {
        // 预分配足够的空间
        reserve(il.size());
        // 遍历 initializer_list，将元素拷贝到容器中
        for (const T& elem : il) {
            push_back(elem);
        }
    }
    // ... 其他构造函数
};

// 1. 直接构造（显式调用）
vector<int> v1({1, 2, 3, 4, 5});
// 2. 拷贝初始化（最常见的形式）
vector<int> v2 = {1, 2, 3, 4, 5};   // 编译器会优化为直接构造，避免临时对象的拷贝
// 3. 省略等号（最简洁）
vector<int> v3 {1, 2, 3, 4, 5};
// 4. const 引用绑定临时对象（生命周期延长）
const vector<int>& v4 = {1, 2, 3, 4, 5};
// 5. 赋值操作（operator= 也有 initializer_list 重载）
v1 = {10, 20, 30, 40, 50};

map<string, string> dict = {
    {"sort", "排序"},
    {"string", "字符串"}
};

栈内存：
    ┌─────────────────────┐
    │  __hidden_array:    │  地址：0x1000
    │  [10]               │  0x1000
    │  [20]               │  0x1004
    │  [30]               │  0x1008
    └─────────────────────┘
    ┌─────────────────────┐
    │  mylist (initializer_list): │
    │  _begin = 0x1000    │
    │  _end   = 0x100c    │  (0x1000 + 3*sizeof(int))
    └─────────────────────┘