What changes to C++ made copy initialization work for class with explicit constructor?

by

Because the behavior of copy elision changes from C++17; for this case copy elision is mandatory.

Mandatory elision of copy/move operations

Under the following circumstances, the compilers are required to omit the copy and move construction of class objects, even if the copy/move constructor and the destructor have observable side-effects. The objects are constructed directly into the storage where they would otherwise be copied/moved to. The copy/move constructors need not be present or accessible:

  • In the initialization of an object, when the initializer expression is
    a prvalue of the same class type (ignoring cv-qualification) as the
    variable type:

    T f() {
    return T();
}

T x = T(T(f())); // only one call to default constructor of T, to initialize x

Note: the rule above does not specify an optimization: C++17 core language specification of prvalues and temporaries is fundamentally different from that of the earlier C++ revisions: there is no longer a temporary to copy/move from. Another way to describe C++17 mechanics is “unmaterialized value passing”: prvalues are returned and used without ever materializing a temporary.

And for copy initialization:

The effects of copy initialization are:

  • First, if T is a class type and the initializer is a prvalue
    expression whose cv-unqualified type is the same class as T, the
    initializer expression itself, rather that a temporary materialized
    from it, is used to initialize the destination object: see copy
    elision     (since C++17)

  • If T is a class type and the cv-unqualified version of the type of
    other is T or a class derived from T, the non-explicit constructors of
    T are examined and the best match is selected by overload resolution.
    The constructor is then called to initialize the object.

That means for X a = X(), a will be default constructed directly, the copy/move constructors and their side effects will be omiited completely. The selection of non-explicit constructors for overload resolution won’t take place, which is required in C++14 (and before). For these guaranteed cases, the copy/move constructors don’t participate in, then it won’t matter whether they’re explicit or not.

More Related Contents:

  1. Is a pointer with the right address and type still always a valid pointer since C++17?
  2. Self-initialization of a static constexpr variable, is it well-formed?
  3. Directly write into char* buffer of std::string
  4. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  5. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  6. reinterpret_cast creating a trivially default-constructible object
  7. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  8. Strongly typed using and typedef
  9. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  10. Is stateful metaprogramming ill-formed (yet)?
  11. What made i = i++ + 1; legal in C++17?
  12. Deleted default constructor. Objects can still be created… sometimes
  13. How is P0522R0 breaking code?
  14. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  15. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  16. Deducing first template argument with other template parameters defaulted
  17. Understanding the example on lvalue-to-rvalue conversion
  18. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  19. Are notes and examples in the core language specification of the C++ Standard non-normative?
  20. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  21. Static member access in constant expressions
  22. Compile-time or runtime detection within a constexpr function
  23. Pointer interconvertibility vs having the same address
  24. Why doesn’t an if constexpr make this core constant expression error disappear?
  25. Why was the space character not chosen for C++14 digit separators?
  26. Why isn’t `std::initializer_list` defined as a literal type?
  27. Classes with both template and non-template conversion operators in the condition of switch statement
  28. Why is `make_unique` disallowed?
  29. Injected class name compiler discrepancy
  30. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?

Leave a Comment