std::initializer_list as template argument for constructor

Question

Consider a class which inherits from a std container with a template constructor which calls the underlying constructor of the container. This template constructor works for the simple copy and move constructor but not for the initializer_list ctor.

template<typename container_T>
class test : public container_T {
public:
  using container_type = container_T;

  test() {} 

  // templated constructor
  template<typename T>
  test(T t)
    : container_T(t) {}

   // without this it won't compile
  test(std::initializer_list<typename container_T::value_type> l)
    : container_T(l) {}
};

int main() {    
  test<std::deque<int>> vdi1;
  test<std::deque<int>> vdi2({1,2,3,4,5,6,7,8,9});

  std::cout << "vdi2 before:" << std::endl;
  for(auto it : vdi2)
    std::cout << it << std::endl;

  test<std::deque<int>> vdi3(std::move(vdi2));

  std::cout << "vdi2 before:" << std::endl;
  for(auto it : vdi2)
    std::cout << it << std::endl;

  std::cout << "vdi3 before:" << std::endl;
  for(auto it : vdi3)
    std::cout << it << std::endl;

  return 0;
}

If I remove the initializer_list constructor vdi2 won't compile. So my question: Why is the initializer_list not deduced by the template constructor? And is it possible to do so?

Actually, it is not a copy or move, they're declared implicitly, in addition to your ctor. And it doesn't work for `initializer_list`s as they cannot be/are not deduced. — dyp, Oct 20 '13 at 19:06
Why don't you use inheriting ctors? `using container_T::container_T;` [Live example](http://coliru.stacked-crooked.com/a/723b9da6b0f8766f) — dyp, Oct 20 '13 at 19:08
Edited comment (.. still a word missing: _Actually, it is not a copy or move _ctor__). What I meant was: a ctor template is never a copy or move ctor. — dyp, Oct 20 '13 at 19:11
@DyP actually... `using container_T::container_T;` is exactly what i was searching for. i've forgotten the possibility of inheriting constructors. thx — user1810087, Oct 20 '13 at 19:33
Looks like you wanna read http://stackoverflow.com/questions/5733828/initializing-from-an-initializer-list-but-without — Johannes Schaub - litb, Oct 20 '13 at 19:56

Cassio Neri · Accepted Answer · 2013-10-21T10:55:50.477

why is the initializer_list not deduced by the templated constructor?

The reason is that {1,2,3,4,5,6,7,8,9} is just a synctatic construct that doesn't have a type. Therefore, the compiler cannot deduce a type T for this synctatic construct and the first constructor fails.

However, by special Standard rules std::initializer_list<T> (among other things) can be construct from this synctatic construct and T can be deduced to int. Hence the second constructor works.

By constrast with function template argument type deduction, with

auto x = {1,2,3,4,5,6,7,8,9};

the compiler sets the type of x to be std::initializer_list<int>. There are also special Standard rules that says it must be so. Strictly speaking this is not type deduction because, as said above, {1,2,3,4,5,6,7,8,9} doesn't have a type to be deduced. (The only type deduction happening here is T = int in std::initializer_list<T>.) Here the compiler chooses (it doesn't deduce) the type of x to be std::initializer_list<int>. In any case, there's no harm to use the abuse of language of saying that the type of x is deduced to std::initializer_list<int>.

Finally, as DyP said in the comments, what you probably want is inheriting all constructors (not only those taking one argument) from the base container class. You can do this by removing all the constructors that you currently have and add just this line to test:

using container_type::container_type;

std::initializer_list as template argument for constructor

1 Answers1

Linked