C++之std::initializer_list的使用小结

1.引言

在C++11标准中，std::initializer_list算是一个小而实用的特性。简单来说，它让你能用花括号 {} 里的值列表去初始化容器或数组，这几乎成了现代C++代码中的标准写法。无论是std::vector、std::list、std::set、std::map这些标准库容器，还是我们自定义的类，都可以借助它完成初始化。

更值得关注的是，它还解决了“处理可变数量参数”这一常见痛点。之前碰到这种需求时，要么得用C风格的可变参数，要么就得引入复杂的模板元编程。C++11给出了两个优雅的方案：如果所有实参类型相同，就用std::initializer_list；如果类型各异，则交给可变参数模板。这篇文章的重点，就是把这个使用频率最高的std::initializer_list拆开看透。

2.std::initializer_list的实现原理

先别急着看怎么用，我们直接把它的实现拎出来瞅一眼：

template 
class initializer_list {
public:
    using value_type      = _Elem;
    using reference       = const _Elem&;
    using const_reference = const _Elem&;
    using size_type       = size_t;

    using iterator       = const _Elem*;
    using const_iterator = const _Elem*;

    constexpr initializer_list() noexcept : _First(nullptr), _Last(nullptr) {}

    constexpr initializer_list(const _Elem* _First_arg, const _Elem* _Last_arg) noexcept
        : _First(_First_arg), _Last(_Last_arg) {}

    _NODISCARD constexpr const _Elem* begin() const noexcept {
        return _First;
    }

    _NODISCARD constexpr const _Elem* end() const noexcept {
        return _Last;
    }

    _NODISCARD constexpr size_t size() const noexcept {
        return static_cast(_Last - _First);
    }

private:
    const _Elem* _First;
    const _Elem* _Last;
};

// FUNCTION TEMPLATE begin
template 
_NODISCARD constexpr const _Elem* begin(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.begin();
}

// FUNCTION TEMPLATE end
template 
_NODISCARD constexpr const _Elem* end(initializer_list<_Elem> _Ilist) noexcept {
    return _Ilist.end();
}

从这段实现代码里，我们能提炼出几个关键信息：

第一，它提供的迭代器类型都是const _Elem*，这意味着里面的元素只能读不能写。所以，不要试图去修改initializer_list中的值，编译器是不会同意的。

第二，当你用花括号初始化时，编译器会在后台创建一个std::initializer_list对象。这个对象内部核心就是一个开始指针和一个结束指针——它本质上是个轻量级的视图，指向一块临时分配的连续存储区域。

第三，正因为只存了两个指针，所以std::initializer_list的大小是固定的（通常是两个指针的大小），跟它“代表”的元素数量没有任何关系。也就是说，不管你传100个元素还是3个元素，拷贝这个对象的开销都是一样的。

第四，它的生命周期跟所在的函数或表达式绑定。一旦离开了当前的上下文（比如函数调用结束），它就可能失效。所以，千万别想着把std::initializer_list当作一个长期持有的容器来用。

第五，它内部不持有数据，只是一个数据视图。除非你非常清楚自己在做什么，否则不建议把它当作类的成员变量来存储——它没办法保证数据一直有效。

第六，虽然它不管理内存，但它有迭代器，所以在很多算法和容器场景中都能无缝配合。

第七，标准库还为std::initializer_list特化了std::begin()和std::end()函数，这让它的适用范围又拓宽了一层。

第八，作为函数参数时很受欢迎，尤其是当你需要一个函数能接收数量不固定的同类型参数时，用它就能写出既简洁又灵活的接口。

3.容器的初始化

实战环节。几乎所有的STL容器都提供了接收std::initializer_list的构造函数，这也是我们日常开发中使用最频繁的场景。随便挑几个看看：

先看std::vector的构造函数：

_CONSTEXPR20_CONTAINER vector(initializer_list<_Ty> _Ilist, const _Alloc& _Al = _Alloc())
        : _Mypair(_One_then_variadic_args_t{}, _Al) {
        auto&& _Alproxy = _GET_PROXY_ALLOCATOR(_Alty, _Getal());
        _Container_proxy_ptr<_Alty> _Proxy(_Alproxy, _Mypair._Myval2);
        _Range_construct_or_tidy(_Ilist.begin(), _Ilist.end(), random_access_iterator_tag{});
        _Proxy._Release();
    }

再看std::list：

list(initializer_list<_Ty> _Ilist) : _Mypair(_Zero_then_variadic_args_t{}) 
{
    _Construct_range_unchecked(_Ilist.begin(), _Ilist.end());  
}

std::map和std::set也不甘落后：

map(initializer_list _Ilist) : _Mybase(key_compare())
{
    insert(_Ilist);
}

set(initializer_list _Ilist) : _Mybase(key_compare()) 
{
    this->insert(_Ilist);
}

实际用起来，代码会非常简洁直观：

std::vector a = {13, 32, 43, 54, 56};
std::set b= {1, 2, 33, 4, 5, 2};
std::map c= {{13, a}, {24, b}, {3666, c}};

这种写法不仅可读性强，而且IDE和编译器的静态检查也能大幅减少手写循环可能带来的失误。

4.函数中使用std::initializer_list

函数参数的情景同样常见。假如我们要实现一个函数，它能接受任意数量的整数并打印出来，传统方法要么用可变参数宏，要么用数组加长度。现在一个initializer_list参数就搞定了：

void func(std::initializer_list values) {
    // 使用初始化列表中的值
    for (const auto& value : values) {
        // 处理每个值
    }
}

// 调用函数
func({13, 24, 35, 34, 52});

调用时只需要把用花括号包起来的列表传进去，一切水到渠成。

5.自定义类型中使用std::initializer_list

在自己的类中，也可以让构造函数接受std::initializer_list。这样一来，用户创建对象时就能享受和标准库容器一样的初始化体验：

class MyContainer {
public:
    MyContainer(std::initializer_list list) : data(list) {
        std::cout << "MyContainer initialized with " << data.size() << " elements." << std::endl;
    }

private:
    std::vector data;
};

MyContainer c = {1, 2, 3, 4};

从用户的角度看，这和初始化一个std::vector没什么两样。内部实现只负责把initializer_list的内容丢给真实存储数据的容器即可。

6.迭代std::initializer_list

既然它提供了迭代器，怎么遍历自然不言而喻。无论是基于范围的for循环，还是传统迭代器写法，都行得通：

std::initializer_list list = {1, 2, 3, 4};

for (int n : list) {
    std::cout << n << " ";
}
std::cout << std::endl;

for (auto it = list.begin(); it != list.end(); ++it) {
    std::cout << *it << " ";
}
std::cout << std::endl;

从代码质量的角度看，基于范围的for循环写法更简洁，也更能规避迭代器使用上的边界问题。

7. 在模板中使用std::initializer_list

模板碰上initializer_list，就能写出泛型的可变参数函数。例如下面这个printAll，不管传进来的是int还是string，都能完美打印出来：

template
void printAll(std::initializer_list list) {
    for (const auto& item : list) {
        std::cout << item << " ";
    }
    std::cout << std::endl;
}

printAll({1, 2, 3, 4});
printAll({"1241", "23525", "3252352"});

这里有一个天然的约束：因为initializer_list要求所有元素类型一致，所以你没办法在同一个列表中混入int和std::string。不过对于绝大多数通用场景来说，这种一致性反而让代码的语义更加明确。

8.std::initializer_list的限制

话说回来，没有哪种工具是万能的。std::initializer_list有以下两条核心限制：

其一，它只能存储相同类型的元素。想在同一个列表里塞int、float、string？对不起，这种想法只能走可变参数模板或其他方案。此外，如果存在隐式类型转换（比如从int到long），编译器可能会优先选择小范围的列表初始化，导致意想不到的重载选择，这是需要警惕的。

其二，元素不可修改。再强调一次：const。尝试修改initializer_list中的元素会导致编译错误：

std::initializer_list list = {1, 2, 3, 4};
// list[0] = 10; // 错误：不能修改initializer_list中的元素

这其实也合理——毕竟它是一个只读的“视图”，而非可读可写的容器。

9.总结

综合来看，std::initializer_list之所以被广泛使用，主要归功于两方面：

灵活性和扩展性事—任何需要可变数量参数的函数，都可以用它来简化接口。它同时还降低了调用代码的编写和维护成本，因为你只需要直观地列出一组值，剩下的交给编译器去处理。

比std::vector更轻量和高效——在值传递过程中，它只复制了两个指针，没有动态内存分配的负担。对于临时性的数据传递来说，这性价比很高。

参考：
std::initializer_list - cppreference.com