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 call in `B::B` undefined? Shoudn't it just call `a.A::f`?

> 
> 4 Member functions, including virtual functions (10.3), can be called
>  during construction or destruction (12.6.2). When a virtual function
>  is called directly or indirectly from a constructor or from a
>  destructor, including during the construction or destruction of the
>  class’s non-static data members, and the object to which the call
>  applies is the object (call it x) under construction or destruction,
>  the function called is the final overrider in the constructor’s or
>  destructor’s class and not one overriding it in a more-derived class.
>  If the virtual function call uses an explicit class member access
>  (5.2.5) 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. [ Example:
> 
> 
> 
> ```
> struct V {
>  virtual void f();
>  virtual void g();
> };
> 
> struct A : virtual V {
>  virtual void f();
> };
> 
> struct B : virtual V {
>  virtual void g();
>  B(V*, A*);
> };
> 
> struct D : A, B {
>  virtual void f();
>  virtual void g();
>  D() : B((A*)this, this) { }
> };
> 
> B::B(V* v, A* a) {
>  f(); // calls V::f, not A::f
>  g(); // calls B::g, not D::g
>  v->g(); // v is base of B, the call is well-defined, calls B::g
>  a->f(); // undefined behavior, a’s type not a base of B
> }
> 
> ```
> 
> —end example ]
> 
> 
>