Is passing a C++ object into its own constructor legal?

by

This is not undefined behavior. Although foo is uninitialized, you are using it a way that is allowed by the standard. After space is allocated for an object but before it is fully initialized, you are allowed to use it limited ways. Both binding a reference to that variable and taking its address are allowed.

This is covered by defect report 363: Initialization of class from self which says:

And if so, what is the semantics of the self-initialization of UDT?
For example

 #include <stdio.h>

 struct A {
        A()           { printf("A::A() %p\n",            this);     }
        A(const A& a) { printf("A::A(const A&) %p %p\n", this, &a); }
        ~A()          { printf("A::~A() %p\n",           this);     }
 };

 int main()
 {
  A a=a;
 }

can be compiled and prints:

A::A(const A&) 0253FDD8 0253FDD8
A::~A() 0253FDD8

and the resolution was:

3.8 [basic.life] paragraph 6 indicates that the references here are valid. It’s permitted to take the address of a class object before it is fully initialized, and it’s permitted to pass it as an argument to a reference parameter as long as the reference can bind directly. Except for the failure to cast the pointers to void * for the %p in the printfs, these examples are standard-conforming.

The full quote of section 3.8 [basic.life] from the draft C++14 standard is as follows:

Similarly, before the lifetime of an object has started but after the
storage which the object will occupy has been allocated or, after the
lifetime of an object has ended and before the storage which the
object occupied is reused or released, any glvalue that refers to the
original object may be used but only in limited ways. For an object
under construction or destruction, see 12.7. Otherwise, such a glvalue
refers to allocated storage (3.7.4.2), and using the properties of the
glvalue that do not depend on its value is well-defined. The program
has undefined behavior if:

  • an lvalue-to-rvalue conversion (4.1) is applied to such a glvalue,

  • the glvalue is used to access a non-static data member or call a non-static member function of the
    object, or

  • the glvalue is bound to a reference to a virtual base class (8.5.3), or

  • the glvalue is used as the operand of a dynamic_cast (5.2.7) or as the operand of typeid.

We are not doing anything with foo that falls under undefined behavior as defined by the bullets above.

If we try this with Clang, we see an ominous warning (see it live):

warning: variable ‘foo’ is uninitialized when used within its own initialization [-Wuninitialized]

It is a valid warning since producing an indeterminate value from an uninitialized automatic variable is undefined behavior. However, in this case you are just binding a reference and taking the address of the variable within the constructor, which does not produce an indeterminate value and is valid. On the other hand, the following self-initialization example from the draft C++11 standard:

int x = x ;

does invoke undefined behavior.

Active issue 453: References may only bind to “valid” objects also seems relevant but is still open. The initial proposed language is consistent with Defect Report 363.

More Related Contents:

  1. Accessing inactive union member and undefined behavior?
  2. When does invoking a member function on a null instance result in undefined behavior?
  3. Optimizing away a “while(1);” in C++0x
  4. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  5. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  6. Does “Undefined Behavior” really permit *anything* to happen? [duplicate]
  7. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  8. no default constructor exists for class
  9. C++ virtual function from constructor [duplicate]
  10. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  11. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  12. Do I really need to implement user-provided constructor for const objects?
  13. How do you use the non-default constructor for a member?
  14. Can class template constructors have a redundant template parameter list in c++20
  15. Will an ’empty’ constructor or destructor do the same thing as the generated one?
  16. So why is i = ++i + 1 well-defined in C++11?
  17. Why is f(i = -1, i = -1) undefined behavior?
  18. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  19. How to add constructors/destructors to an unnamed class?
  20. Implementing a std::vector like container without undefined behavior
  21. Mixing class and struct
  22. Different ways of initializing an object in c++
  23. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  24. No matching function for call to Class Constructor
  25. Dangling references and undefined behavior
  26. Class inherited from class without default constructor
  27. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  28. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  29. C++ Member Initializer List
  30. Scope resolution operator being used twice

Leave a Comment