ladder-like C++ virtual inheritance : <p>If I have a class inheritance relation like the following</p>

<pre><code>               a
              /  \
             b    c
              \   |
               |  d
                \/ \
                e   f
                 \ /
                  g
</code></pre>

<p>Is the following the correct definition?</p>

<pre><code>    class A {};
    class B: public virtual A {};
    class C: public virtual A {};
    class D: public C {};
    class E: public B, public virtual D  {};
    class F: public virtual D {};
    class G: public E, public F {};
</code></pre>

<p>I made both A and D virtually inherited because I assume each joint class need to be virtual.</p>

<p>Also I am not sure how C++ defines the constructor order of the above case. The link
<a href="https://isocpp.org/wiki/faq/multiple-inheritance#mi-vi-ctor-order" rel="noreferrer">https://isocpp.org/wiki/faq/multiple-inheritance#mi-vi-ctor-order</a> says</p>

<blockquote>
  <p>The very first constructors to be executed are the virtual base
  classes anywhere in the hierarchy. They are executed in the order they
  appear in a depth-first left-to-right traversal of the graph of base
  classes, where left to right refer to the order of appearance of base
  class names.</p>
  
  <p>After all virtual base class constructors are finished, the
  construction order is generally from base class to derived class. The
  details are easiest to understand if you imagine that the very first
  thing the compiler does in the derived class’s ctor is to make a
  hidden call to the ctors of its non-virtual base classes (hint: that’s
  the way many compilers actually do it). So if class D inherits
  multiply from B1 and B2, the constructor for B1 executes first, then
  the constructor for B2, then the constructor for D. This rule is
  applied recursively; for example, if B1 inherits from B1a and B1b, and
  B2 inherits from B2a and B2b, then the final order is B1a, B1b, B1,
  B2a, B2b, B2, D.</p>
  
  <p>Note that the order B1 and then B2 (or B1a then B1b) is determined by
  the order that the base classes appear in the declaration of the
  class, not in the order that the initializer appears in the derived
  class’s initialization list.</p>
</blockquote>

<p>If so, is the order like?</p>

<pre><code>  A, D, B, C, D, F, G
</code></pre>

<p>I do not expect D is constructed before C. What is the correct constructor order?</p>
