对于构造函数，如何在可变模板与std：：initializer\u列表之间进行选择？

Question

在c 11的当前状态下（比如gcc 4.7.2），当我需要一个可以接受变量参数的构造函数时，我应该如何选择使用变量模板还是使用std：：initializer\u list？

Answer 1

我建议始终选择可变参数模板，并尽可能避免std::initializer_list。

这就是我用C 11实现std::向量的方式：

#include <iostream>
#include <vector>

struct exp_sequence {
  template <typename... T>
  exp_sequence(T&&...) {}
};

struct from_arglist_t {} from_arglist;

template <typename T>
class my_vector {
  std::vector<T> data;

public:
  my_vector(int n, T const& e) : data(n, e) {}

  template <typename... Args>
  my_vector(from_arglist_t, Args&&... args) {
    data.reserve(sizeof...(Args));
    exp_sequence{(data.push_back(std::forward<Args>(args)),1)...};
  }

  std::size_t size() { return data.size(); }
};

int main()
{
  std::vector<int> v1{13, 13}; std::cout << v1.size() << '\n'; // 2
  std::vector<int> v2(13, 13); std::cout << v2.size() << '\n'; // 13

  my_vector<int> v3{13, 13}; std::cout << v3.size() << '\n'; // 13
  my_vector<int> v4(13, 13); std::cout << v4.size() << '\n'; // 13
  my_vector<int> v5(from_arglist, 13, 13); std::cout << v5.size() << '\n'; // 2
  my_vector<int> v6{from_arglist, 13, 13}; std::cout << v6.size() << '\n'; // 2
}

原因如main所示，在泛型代码中使用initializer_list可能会导致不同的行为，具体取决于选择的括号类型。也可以通过添加这样的构造函数来默默更改代码。

另一个原因是仅移动类型：

//std::vector<move_only> m1{move_only{}}; // won't compile
my_vector<move_only> m2{from_arglist, move_only{}}; // works fine

Answer 2

使用可变参数模板，参数的数量在编译期间是已知的（并且可以通过sizeof...访问）。使用std::initializer_list，参数的数量只有在运行时才知道。因此，部分决策取决于您何时需要或想知道您有多少参数。

Answer 3

变量模板允许您提供不同类型的参数，而std：：initializer\u list则以参数的类型为模板。这意味着列表中所有元素的类型必须相同（或可转换为基础类型，但不允许缩小转换）。根据这是否适合您，您可以选择其中之一。

此外，如果需要完美转发，可变模板通常是默认选择，因为语法形式

struct A
{
    // Deduces T& for lvalue references, T for rvalue references, and binds to both
    template<typename... Ts>
    A(Ts&&...) { }

    // This is an rvalue reference to an initializer_list. The above type deduction
    // does not apply here
    template<typename T>
    A(initializer_list<T>&&) { }
};

另外请注意，当您使用统一初始化语法（即大括号）时，默认情况下将调用接受初始值设定项列表的构造函数，即使存在另一个可行的构造函数。这可能是您想要的，也可能不是您想要的：

struct A
{
    A(int i) { }
};

struct B
{
    B(int) { }
    B(std::initializer_list<A>) { }
};

int main()
{
    B b {1}; // Will invoke the constructor accepting initializer_list
}