Why does the standard differentiate between direct-list-initialization and copy-list-initialization?

by

Because they don’t do the exact same thing. As stated in 13.3.1.7 [over.match.list]:

In copy-list-initialization, if an explicit constructor is chosen, the initialization is ill-formed.

In short, you can only use implicit conversion in copy-list-initialization contexts.

This was explicitly added to make uniform initialization not, um, uniform. Yeah, I know how stupid that sounds, but bear with me.

In 2008, N2640 was published (PDF), taking a look at the current state of uniform initialization. It looked specifically at the difference between direct initialization (T{...}) and copy-initialization (T = {...}).

To summarize, the concern was that explicit constructors would effectively become pointless. If I have some type T that I want to be able to be constructed from an integer, but I don’t want implicit conversion, I label the constructor explicit.

Then somebody does this:

T func()
{
  return {1};
}

Without the current wording, this will call my explicit constructor. So what good is it to make the constructor explicit if it doesn’t change much?

With the current wording, you need to at least use the name directly:

T func()
{
  return T{1};
}

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Optimizing away a “while(1);” in C++0x
  3. What are the advantages of list initialization (using curly braces)?
  4. Is the size of std::array defined by standard
  5. Capturing a reference by reference in a C++11 lambda
  6. Is a moved-from vector always empty?
  7. c++ access static members using null pointer
  8. lifetime of a std::initializer_list return value
  9. Deleted default constructor. Objects can still be created… sometimes
  10. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  11. Why is modifying a string through a retrieved pointer to its data not allowed?
  12. Get pointer to object from pointer to some member
  13. Is it legal to declare a constexpr initializer_list object?
  14. Are notes and examples in the core language specification of the C++ Standard non-normative?
  15. Why do auto and template type deduction differ for braced initializers?
  16. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  17. Can C++ code be valid in both C++03 and C++11 but do different things?
  18. What is the value category of the operands of C++ operators when unspecified?
  19. Are int8_t and uint8_t intended to be char types?
  20. How can an incomplete type be used as a template parameter to vector here?
  21. Is left-shifting (
  22. What is the purpose of a declaration like int (x); or int (x) = 10;
  23. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  24. Does C++11 allow dollar signs in identifiers?
  25. reinterpret_cast between char* and std::uint8_t* – safe?
  26. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  27. What expressions create xvalues?
  28. C++11 cross compiler/standard library random distribution reproducibility
  29. Is it possible to invoke a user-defined conversion function via list-initialization?
  30. Can using a lambda in header files violate the ODR?

Leave a Comment