Calling initializer_list constructor via make_unique/make_shared

by

std::make_unique is a function template which deduces the argument types which are passed to the object constructor. Unfortunately, braced lists are not deducible (with an exception for auto declarations), and so you cannot instantiate the function template when that missing parameter type.

You can either not use std::make_unique, but please don’t go that route – you should avoid naked news as much as you can, for the children’s sake. Or you can make the type deduction work by specifying the type:

  • std::make_unique<Foo>(std::initializer_list<std::string>({"Hello", "World"}))

  • std::make_unique<Foo, std::initializer_list<std::string>>({"Hello", "World"})

  • auto il = { "Hello"s, "World"s }; auto ptr = std::make_unique<Foo>(il);

The last option uses the special rule for auto declarations, which (as I hinted above) do in fact deduce an std::initializer_list.

More Related Contents:

  1. Differences between std::make_unique and std::unique_ptr with new
  2. Advantages of using std::make_unique over new operator [duplicate]
  3. How to implement make_unique function in C++11? [duplicate]
  4. How to make std::make_unique a friend of my class
  5. error::make_unique is not a member of ‘std’
  6. Why isn’t `std::initializer_list` defined as a literal type?
  7. Raw pointer lookup for sets of unique_ptrs
  8. Why is `make_unique` disallowed?
  9. why can’t I print the copied string individually? [closed]
  10. How to implement classic sorting algorithms in modern C++?
  11. How does `void_t` work
  12. make_unique and perfect forwarding
  13. std::unique_ptr with an incomplete type won’t compile
  14. Why use std::bind over lambdas in C++14?
  15. Differences between unique_ptr and shared_ptr [duplicate]
  16. Pointers in c++ after delete
  17. When to use the brace-enclosed initializer?
  18. C++11: Correct std::array initialization?
  19. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  20. Pass by value vs pass by rvalue reference
  21. How to construct std::array object with initializer list? [duplicate]
  22. Is #pragma once part of the C++11 standard?
  23. Initializer-list-constructing a vector of noncopyable (but movable) objects
  24. Exception safety and make_unique
  25. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  26. Can I Reference Previous Members of an Initializer List?
  27. details of std::make_index_sequence and std::index_sequence
  28. Should I use shared_ptr or unique_ptr
  29. Is there a way to write make_unique() in VS2012?
  30. Fallback variadic constructor – why does this work?

Leave a Comment