Is accessing a member of a struct in its own initializer undefined behaviour

Question

Consider:

struct A { void do_something() {} };

struct B {
  A& a;
  B(A& a) : a{a} { a.do_something(); }
};

struct C {
  A a; B b;
  C(A& a) : b{a} {}
};

int main() {
  C c{ c.a };
}

It seems possible that this could be made to work, because:

• even before c is initialized, we know its memory layout and the address of c.a
• we don't actually use c.a until it is initialized.

Additionally, I didn't get a warning under a few different compilers.

However, I experienced some extremely odd behaviour (a bit later on) that could only be down to doing something undefined, and which only went away when I reorganised my program to avoid this pattern.

Thanks.

Answer 1

Your program has undefined behavior, because you are accessing an object's member outside the object and before the lifetime of the object commences.

$12.7: 1: For an object with a non-trivial constructor, referring to any non-static member or base class of the object before the constructor begins execution results in undefined behavior...

As to why it compiles fine: A name can be used after its point of declaration ... And Quoting the C++ Standard draft... (emphasis mine):

$3.3.2 : 1: The point of declaration for a name is immediately after its complete declarator (Clause [dcl.decl]) and before its initializer (if any)...

And initalizer is defined to have the syntax (reproduced here partially):

initializer...

initializer:
    brace-or-equal-initializer
    ( expression-list )

brace-or-equal-initializer:
    = initializer-clause
    braced-init-list

initializer-clause:
    assignment-expression
    braced-init-list
. . .

The above is the same reason why this will compile:

int k(k);
int m{m};
int b = b;

Answer 2

In addition to my previous answer,

---

Your code is a crafty one... Because, despite the supposed UB with using an object before its initialized, the behaviour of your code is apparently well defined..

How? In the construction of c, the following sequence of events will happen:

1. You call C's constructor, C(A& a) : b{a} {} which takes a reference to an object of type A. (A reference is just like an address, and as you rightly mentioned, the address of c.a is known at compile time). Your call is: C c{ c.a }; and the compiler is fine with that since c.a is an accessible name

2. Due to the order of declaration of C's members...

   struct C {
     A a; B b;
     C(A& a) : b{a} {}
   };
   

   the object a is initialized before b.

3. Thus, a becomes alive before its use in the member initializer... b{a}

---

But again, you can be smoked by optimizers...

Answer 3

C++ has a pretty well-defined order of construction. First (non-virtual) base classes are initialized. Members are initialized next, in order of their declaration in the class (and ignoring the order of the initializer list), and only after the last member has been initialized will the body of the constructor be entered.

In this case, it means that the ctors are called in the order A::A, B::B, C::C.

You would have an issue if C was declared as

struct C {
  B b; A a; 
  C(A& a) : b{a} {}
};