How to use C++11 uniform initialization syntax?

by

The compile error for

// T t{u};
std::string a;
std::string b{a};

Is a combination of four things

  • The draft until not long ago said that if T has an initializer list constructor (std::string has one, taking char elements), that the initializer list is passed itself as an argument. So the argument to the constructor(s) is not a, but {a}.

  • The draft says that an initializer list initializing a reference is done not by direct binding, but by first constructing a temporary out of the element in the initializer list, and then binding the target reference to that temporary.

  • The draft says that when initializing a reference by an initializer list, when the initialization of the reference is not direct binding, that the conversion sequence is a user defined conversion sequence.

  • The draft says that when passing the initializer list itself when considering constructors of class X as candidates in an overload resolution scenario in a context like the above, then when considering a first constructor parameter of type “reference to cv X” (cv = const / volatile) – in other words highly likely a copy or move constructor, then no user defined conversions are allowed. Otherwise, if such a conversion would be allowed, you could always run in ambiguities, because with list initialization you are not limited to only one nested user defined conversion.

The combination of all the above is that no constructor can be used to take the {a}. The one using initializer_list<char> does not match, and the others using string&& and const string& are forbidden, because they would necessitate user defined conversions for binding their parameter to the {a}.

Note that more recent draft changed the first rule: They say that if no initializer list constructor can take the initializer list, that then the argument list consists of all the elements of the initializer list. With that updated rule, your example code would work fine.

More Related Contents:

  1. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  2. Why doesn’t emplace_back() use uniform initialization?
  3. Why can’t I initialize a reference in an initializer list with uniform initialization?
  4. Uniform initialization fails to copy when object has no data members
  5. Are there any valid use cases to use new and delete, raw pointers or c-style arrays with modern C++?
  6. Why can I use auto on a private type?
  7. How to remove from a map while iterating it?
  8. When can outer braces be omitted in an initializer list?
  9. When should you use constexpr capability in C++11?
  10. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  11. Differences between unique_ptr and shared_ptr [duplicate]
  12. Why no default move-assignment/move-constructor?
  13. Specifying one type for all arguments passed to variadic function or variadic template function w/out using array, vector, structs, etc?
  14. Why doesn’t C++ use std::nested_exception to allow throwing from destructor?
  15. Why doesn’t SFINAE (enable_if) work for member functions of a class template?
  16. Which Boost features overlap with C++11?
  17. Now that we have std::array what uses are left for C-style arrays?
  18. Does a C++11 range-based for loop condition get evaluated every cycle?
  19. Can we return objects having a deleted/private copy/move constructor by value from a function?
  20. Is there any compiler barrier which is equal to asm(“” ::: “memory”) in C++11?
  21. What are unevaluated contexts in C++?
  22. C++ Add months to chrono::system_clock::time_point
  23. The precision of std::to_string(double)
  24. Override member field in derived classes
  25. What is the purpose of max_digits10 and how is it different from digits10?
  26. C++11: the difference between memory_order_relaxed and memory_order_consume
  27. Should I use shared_ptr or unique_ptr
  28. Do c++11 lambdas capture variables they don’t use?
  29. Do I have to use atomic for “exit” bool variable?
  30. Passing a lambda into a function template

Leave a Comment