std :: initializer_list和c array []的优点和缺点是什么？

Question

假设我有一些假设结构：

struct X {
  int i;
  double d;
}

我可以写

constexpr X x_c_array[]{{5, 6.3}};

要么

constexpr std::initializer_list<X> x_ilist{{5, 6.3}};

无法使用auto - 编译器必须知道内部类型 。

这两个版本都有任何缺点吗？

更新：

另外值得关注的是，您是否能够使用/将一种类型转换为另一种类型 - 例如。 在构建标准容器时？

Answer 1

简单明了： initializer_list不是容器。 这是外部分配元素的不可变视图。 它完全不适合容器在任何情况下有用 - 考虑不必要的间接（无可调整性），不可变性，其名称的惯用性。 最重要的是，它没有适当的界面。

两者看起来都足够的情况是序列的构造函数参数。 如果长度是固定的（或模板参数化），那么int const (&arr)[N]是可能的，尽管initializer_list更简单，更灵活。 毕竟，这就是它的设计和目的......

Answer 2

正如评论中所写，这是一个广泛的论点。

无论如何，我把注意力集中在一点上。

在第一种情况下

X x1[] {{5, 6.3}};

x1的元素数是x1类型的一部分。

所以你有

X x1[] {{5, 6.3}};
X x2[] {{5, 6.3}, {7, 8.1}};

static_assert( false == std::is_same<decltype(x1), decltype(x2)>::value );

使用初始化列表

std::initializer_list<X> x3 {{5, 6.3}};
std::initializer_list<X> x4 {{5, 6.3}, {7, 8.1}};

static_assert( true == std::is_same<decltype(x3), decltype(x4)>::value );

类型保持不变，改变元素的数量。

根据您的需要，这可能是第一或第二解决方案的优势。

元数量是C风格数组类型的一部分这一事实在元编程中可能有点优势。

假设您需要一个返回数组i值之和的函数，您可以编写C风格的数组

template <std::size_t N, std::size_t ... Is>
constexpr auto sum_i_helper (X const (&xArr)[N], std::index_sequence<Is...>)
 { return (... + xArr[Is].i); }

template <std::size_t N>
constexpr auto sum_i (X const (&xArr)[N])
 { return sum_i_helper(xArr, std::make_index_sequence<N>{}); }

当sum_i()的参数是not-constexpr值时，此函数也会编译。

如果你想写一些与std::initializer_list类似的东西稍微复杂一点，因为列表的size()不一定是编译时已知值，所以你把它作为模板参数传递（但函数没有使用运行时列表）或在函数内部使用size() ，但不能使用它来初始化std::index_sequence 。

无论如何，使用初始化列表，您可以使用旧的for()循环

constexpr auto sum_i (std::initializer_list<X> const lx)
 { 
   int ret { 0 };

   for ( auto const & x : lx )
      ret += x.i;

   return ret;
 }

当lx是constexpr值时，该函数可以计算编译时间。

另外值得关注的是，您是否能够使用/将一种类型转换为另一种类型 - 例如。 在构建标准容器时？

将数组转换为初始化列表，它很容易兼具编译时和运行时已知值

template <std::size_t N, std::size_t ... Is>
constexpr auto convertX_h (X const (&xArr)[N], std::index_sequence<Is...>)
 { return std::initializer_list<X>{ xArr[Is]... }; }

template <std::size_t N>
constexpr auto convertX (X const (&xArr)[N])
 { return convertX_h(xArr, std::make_index_sequence<N>{}); }

// ....

X x1[] {{5, 6.3}};

std::initializer_list<X> x5 = convertX(x1);

将初始化列表转换为C样式数组更加困难，因为数组的类型取决于元素的数量，因此您需要知道编译时初始化列表中元素的数量，因为您无法随机访问初始化列表，更糟糕的是，因为您无法编写返回C样式数组的函数。

我可以设想一个如下解决方案，将初始化列表转换为std::array （关于主题建议：尽可能使用std::array ，而不是C风格的数组）

template <std::size_t N>
constexpr auto convertX (std::initializer_list<X> const lx)
 { 
   std::array<X, N> ret;

   std::size_t i { 0u };

   for ( auto const & x : lx )
      ret[i++] = x;

   return ret;
 }

// ...

constexpr std::initializer_list<X> x4 {{5, 6.3}, {7, 8.1}};

auto x6 = convertX<x4.size()>(x4);

但是x6现在是std::array<X, 2> ，而不是X[2] ，而x4必须是constexpr值。

Answer 3

数组可以是非const的。 initializer_list只允许const访问元素。 在您的示例中，您使用constexpr，因此隐式为const，因此在这种情况下，这无关紧要。 但是如果你需要非const，则initializer_list不是一个选项。 这在initializer_list构造函数中特别烦人，你需要将元素从列表中移出，但不能因为对象是const。

C样式数组可以衰减到指向第一个元素的指针，初学者偶尔会发现这个元素令人困惑。 initializer_list没有。 您可以使用数组包装器而不会衰减，但您需要指定类型和大小，或使用大括号初始化列表中的类型来允许模板推导：

constexpr std::array x_std_array{X{5, 6.3}};

而且，正如max66的答案中深入探讨的那样， initializer_list可以是任何大小，而数组的大小取决于它的类型，这是一个优点或缺点。 类型的大小部分是模板元编程的一个优点，而“隐藏”大小是一个优势，因为您首先不需要模板。