C++ constructors: why is this virtual function call not safe?

Question

This is from the C++11 standard sec 12.7.4. This is rather confusing.

1. What does the last sentence in the text mean exactly?
2. Why is the last method cal

Answer 1

The last sentence of the normative text that you cite reads as follows:

If the virtual function call uses an explicit class member access and the object expression refers to the complete object of x or one of that object’s base class subobjects but not x or one of its base class subobjects, the behavior is undefined.

This is, admittedly, rather convoluted. This sentence exists to restrict what functions may be called during construction in the presence of multiple inheritance.

The example contains multiple inheritance: D derives from A and B (we'll ignore V, because it is not required to demonstrate why the behavior is undefined). During construction of a D object, both the A and B constructors will be called to construct the base class subobjects of the D object.

When the B constructor is called, the type of the complete object of x is D. In that constructor, a is a pointer to the A base class subobject of x. So, we can say the following about a->f():

• The object under construction is the B base class subobject of a D object (because this base class subobject is the object currently under construction, it is what the text refers to as x).

• It uses explicit class member access (via the -> operator, in this case)

• The type of the complete object of x is D, because that is the most-derived type that is being constructed

• The object expression (a) refers to a base class subobject of the complete object of x (it refers to the A base class subobject of the D object being constructed)

• The base class subobject to which the object expression refers is not x and is not a base class subobject of x: A is not B and A is not a base class of B.

Therefore, the behavior of the call is undefined, per the rule we started from at the beginning.

Why is the last method call in B::B undefined? Shouldn't it just call a.A::f?

The rule you cite states that when a constructor is called during construction, "the function called is the final overrider in the constructor’s class and not one overriding it in a more-derived class."

In this case, the constructor's class is B. Because B does not derive from A, there is no final overrider for the virtual function. Therefore the attempt to make the virtual call exhibits undefined behavior.