Brace-enclosed initializer list constructor

by

It can only be done for aggregates (arrays and certain classes. Contrary to popular belief, this works for many nonpods too). Writing a constructor that takes them is not possible.

Since you tagged it as “C++0x”, then this is possible though. The magic words is “initializer-list constructor”. This goes like

Phenotype(std::initializer_list<uint8> c) {
  assert(c.size() <= std::size(m_array));
  std::copy(c.begin(), c.end(), m_array);
}

// used like
Phenotype p1{1, 2, 3};
Phenotype p2({1, 3, 2}); // works too
Phenotype p3(1, 2, 3); // doesn't work

However, such initialization will default construct the array and then use the assignment operator. If you aim for speed and safety (you get compile time errors for too many initializers!), you can also use an ordinary constructor with a variadic template.

This can be more generic than needed though (often an initializer_list completely suffices, especially for plain integers). It benefits from perfect forwarding, so that an rvalue argument can be move constructed into an array element

template<typename ...T>
Phenotype(T&&...t):m_array{ std::forward<T>(t)... } {

}

// used like
Phenotype p1{1, 2, 3}; 
Phenotype p2(1, 2, 3); // works too
Phenotype p3({1, 2, 3}); // doesn't work

It’s a hard choice!

Edit Correction, the last one works too, as we didn’t make the constructor explicit, so it can use the copy constructor of Phenotype, constructing a temporary Phenotype object and copy it over to p3. But that’s not what we really would want the calls to be 🙂

More Related Contents:

  1. Can I list-initialize a vector of move-only type?
  2. initializer_list and move semantics
  3. Initializer lists and RHS of operators
  4. initializer_list and template type deduction
  5. Initializing a member array in constructor initializer
  6. lifetime of a std::initializer_list return value
  7. When to use the brace-enclosed initializer?
  8. Why does auto x{3} deduce an initializer_list?
  9. How do I initialize a member array with an initializer_list?
  10. Order of evaluation of elements in list-initialization
  11. Are multiple mutations within initializer lists undefined behavior?
  12. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  13. Why doesn’t my template accept an initializer list
  14. How to construct std::array object with initializer list? [duplicate]
  15. Initializer-list-constructing a vector of noncopyable (but movable) objects
  16. Is it legal to declare a constexpr initializer_list object?
  17. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  18. C++11 initializer list fails – but only on lists of length 2
  19. Double delete in initializer_list vs 2013
  20. Why can’t I initialize a reference in an initializer list with uniform initialization?
  21. Range-based for with brace-initializer over non-const values?
  22. What would a std::map extended initializer list look like?
  23. Initialization difference with or without curly braces in C++
  24. Which greedy initializer-list examples are lurking in the Standard Library?
  25. What is std::move(), and when should it be used?
  26. Move-only version of std::function
  27. std::unique_ptr for C functions that need free
  28. How to get the precision of high_resolution_clock?
  29. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  30. Proper way to receive a lambda as parameter by reference

Leave a Comment