当前位置：网站首页 > 技术分析 > 正文

c++ 疑难杂症(10) std::initializer_list

liebian365 2024-11-18 14:21 4 浏览 0 评论

std::initializer_list 是 C++11 引入的一个新特性，主要用于支持统一初始化语法（也称为大括号初始化）。引入 std::initializer_list 的原因主要有以下几点：

初始化方式的统一：在 C++11 之前，初始化对象的方式有很多种，包括等号初始化、括号初始化、构造函数初始化等。这种多样性可能会导致混乱和错误。引入 std::initializer_list 和大括号初始化语法后，C++ 提供了一种更统一、更简洁的初始化方式。
支持任意数量的初始化参数：std::initializer_list 可以接受任意数量的同类型参数，这使得它非常适合用于初始化数组、向量等容器。在之前的 C++ 版本中，要实现这种功能通常需要借助变长参数模板或其他复杂技术。
类型安全：std::initializer_list 是类型安全的，这意味着它只接受指定类型的元素。这有助于在编译时捕获类型错误，从而提高代码的安全性。
性能优化：由于 std::initializer_list 在编译时确定其元素数量和类型，因此编译器可以进行一些优化，例如将列表中的元素直接存储在静态存储区中，从而提高性能。
与现有代码的兼容性：引入 std::initializer_list 和大括号初始化语法后，C++ 仍然保留了之前的初始化方式，以确保与现有代码的兼容性。这意味着开发者可以根据需要选择使用新的初始化方式或继续使用旧的方式。

1. std::initializer_list

std::initializer_list<T> 类型对象是一个访问 const T 类型对象数组的轻量代理对象。

std::initializer_list 对象在这些时候自动构造：

用花括号初始化列表?? 列表初始化一个对象，其中对应构造函数接受一个 std::initializer_list 参数
以花括号初始化列表?? 为赋值的右运算数，或函数调用参数，而对应的赋值运算符/函数接受 std::initializer_list 参数
绑定花括号初始化列表?? 到 auto，包括在范围 for 循环中

std::initializer_list 可由一对指针或指针与其长度实现。复制一个 std::initializer_list 不会复制它对应的初始化列表的基底数组。

如果声明了 std::initializer_list 的显式（全）或偏特化，那么程序非良构。

实现比较简单，直接把源码贴出来.

namespace std
{
  /// initializer_list
  template<class _E>
    class initializer_list
    {
    public:
      typedef _E        value_type;
      typedef const _E&     reference;
      typedef const _E&     const_reference;
      typedef size_t        size_type;
      typedef const _E*     iterator;
      typedef const _E*     const_iterator;

    private:
      iterator          _M_array;
      size_type         _M_len;

      // The compiler can call a private constructor.
      constexpr initializer_list(const_iterator __a, size_type __l)
      : _M_array(__a), _M_len(__l) { }
      //这里很关键， 供编译器调用， 实际使用  

    public:
      constexpr initializer_list() noexcept
      : _M_array(0), _M_len(0) { }
      //创建空的初始化器列表  

      // Number of elements.
      constexpr size_type
      size() const noexcept { return _M_len; }
      //返回初始化器列表中的元素数目

      // First element.
      constexpr const_iterator
      begin() const noexcept { return _M_array; }
      //返回指向首元素的指针  

      // One past the last element.
      constexpr const_iterator
      end() const noexcept { return begin() + size(); }
      //返回指向末元素后一位置的指针  
    };

  /**
   *  @brief  Return an iterator pointing to the first element of
   *          the initilizer_list.
   *  @param  __ils  Initializer list.
   */
  template<class _Tp>
    constexpr const _Tp*
    begin(initializer_list<_Tp> __ils) noexcept
    { return __ils.begin(); }
    //特化 std::begin()

  /**
   *  @brief  Return an iterator pointing to one past the last element
   *          of the initilizer_list.
   *  @param  __ils  Initializer list.
   */
  template<class _Tp>
    constexpr const _Tp*
    end(initializer_list<_Tp> __ils) noexcept
    { return __ils.end(); }
    //特化 std::end()
}

2. 示例

用花括号初始化列表?? 列表初始化一个对象，其中对应构造函数接受一个 std::initializer_list 参数

#include <string>
#include <list>
#include <vector>
#include <map>

int main() {

    std::list<int> lst({ 1, 2, 3, 4, 5, 6 });
    std::vector<double> vec = { 0.1, 0.2, 0.3 };
    std::map<int, std::string> map({ { 1, "1" }, {2, "2"} });
    std::map<int, std::string> map2{ { 1, "1" }, {2, "2"} };
    
    return 0;
}

以花括号初始化列表?? 为赋值的右运算数，或函数调用参数，而对应的赋值运算符/函数接受 std::initializer_list 参数

#include <iostream>
#include <string>
#include <map>
#include <list>
#include <vector>

void func(std::initializer_list<int>& il) {
    std::cout << "func : ";
    for (auto x : il) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

int main() {

    std::list<int> lst;
    std::vector<double> vec;
    std::map<int, std::string> map;

    //operator= 
    lst = { 1, 2, 3, 4, 5, 6 };
    vec = { {0.1, 0.2, 0.3} };
    map = { {1, "3"}, {2, "6"} };

    //函数(insert(const_iterator _Where, initializer_list<_Ty> _Ilist))
    lst.insert(lst.end(), { 9, 10 });

    //函数/lambda调用
    std::initializer_list<int> xx{ 1, 2, 3, 4, 5 };
  //auto xx = { 1, 2, 3, 4, 5 }; //ok, 可自动推导
    func(xx);

    auto show = [](std::initializer_list<int>& il) {
        std::cout << "lambda : ";
        for (auto x : il) {
            std::cout << x << " ";
        }
        std::cout << std::endl;
    };
    show(xx);
    
    return 0;
}
/*打印输出:
func : 1 2 3 4 5
lambda : 1 2 3 4 5
*/

绑定花括号初始化列表?? 到 auto，包括在范围 for 循环中

#include <iostream>
#include <initializer_list>

int main() {

    //构建了 std::initializer_list<int>
    for (int x : {3, 6, 1, 2}) {
  //for (int& x : { 3, 6, 1, 2 }) { //错误, 常量不能改变
  //for (const int& x : {3, 6, 1, 2}) { //ok
        std::cout << x << " ";
    }
    std::cout << std::endl;

    //推导为 std::initializer_list<double>
    auto al = {0.1, .2, 0.3, .5};
    std::cout<<"size="<<al.size()<<std::endl;
    for (const double& x : al) {
  //for (const auto& x : al) { //ok
        std::cout << x << " ";
    }
    std::cout << std::endl;

    //注意是 const double*
    for (const double* iter = al.begin(); iter != al.end(); ++iter) {
  //for (auto iter = al.begin(); iter != al.end(); ++iter) {
        std::cout << *iter << " ";
    }
    std::cout << std::endl;
    return 0;
}
/*打印输出:
3 6 1 2
size=4
0.1 0.2 0.3 0.5
0.1 0.2 0.3 0.5
*/

自定义

#include <iostream>
#include <string>
#include <initializer_list>

int main() {

    class A {
    public:
        A(std::initializer_list<int> il) {
            std::cout << "int : ";
            for (const auto& x : il) {
                std::cout << x << " ";
            }
            std::cout << std::endl;
        }

        A(std::initializer_list<double> il) {
            std::cout << "double : ";
            for (const auto& x : il) {
                std::cout << x << " ";
            }
            std::cout << std::endl;
        }

        A(std::initializer_list<std::string> il) {
            std::cout << "string : ";
            for (const auto& x : il) {
                std::cout << x << " ";
            }
            std::cout << std::endl;
        }

        void DoSomething(std::initializer_list<int> il) {
            std::cout << "DoSomething : ";
            for (const auto& x : il) {
                std::cout << x << " ";
            }
            std::cout << std::endl;
        }
    };

    A a1{1, 2, 3, 4};
    A a2{ 0.1, .2, .3, .4 };
    A a3{ "a", "b", "c", "d"};

    a3.DoSomething({9, 99, 999});
    return 0;
}
/*打印输出:
int : 1 2 3 4
double : 0.1 0.2 0.3 0.4
string : a b c d
DoSomething : 9 99 999
*/

c++ 疑难杂症(9) std::array

c++ 疑难杂症(8) std::multimap

c++ 疑难杂症(7) std::tuple

c++ 疑难杂症(6) std::map

c++ 疑难杂症(5) std::pair

c++ 疑难杂症(4) std:vector

c++ 疑难杂症(3) 模板特化

c++ 疑难杂症(2) std::move

c++ 疑难杂症(1) std::thread

std::map 初始化