Question

Consider this C++ code:

#include <iostream>
using namespace std;

struct B {
    virtual int f() { return 1; }
    int g() { return 2; }
};
struct D1 : public B { // (*)
    int g() { return 3; }
};
struct D2 : public B { // (*)
    virtual int f() { return 4; }
};
struct M : public D1, public D2 {
    int g() { return 5; }
};

int main() {
    M m;
    D1* d1 = &m;
    cout << d1->f()
         << static_cast<D2&>(m).g()
         << static_cast<B*>(d1)->g()
         << m.g();
}

It prints 1225. If we make virtual inheritance, i.e. add virtual before public in lines marked with (*), it prints 4225.

1. Can you explain why 1 changes to 4?
2. Can you explain meaning of static_cast<D2&>(m) and static_cast<B*>(d1)?
3. How you are you not getting lost in this kind of combinations? Are you drawing something?
4. Is it common to spot such complex settings in normal projects?

Answer 1

(1) Can you explain why 1 changes to 4?

Without virtual inheritance, there are 2 independent hierarchies of inheritance; B->D1->M and B->D2->M. So imagine 2 virtual function tables (though this is implementation defined).
When you invoke f() with D1*, it just knows about B::f() and that’s it. With virtual inheritance, base class B is delegated to M and thus D2::f() is considered as part of class M.

(2) Can you explain meaning of static_cast<D2&>(m) and static_cast<B*>(d1)?

static_cast<D2&>(m), is like considering object of class M as class D2
static_cast<B*>(d1), is like considering pointer of class D1 as class B1.
Both are valid casts.
Since g() is not virtual the function choice happens at compile-time. Had it been virtual then all these casting won’t matter.

(3) How you are you not getting lost in this kind of combinations? Are you drawing something?

Ofcourse it’s complex and at first glance if there are so many of such classes, one might get easily lost.

(4) Is it common to spot such complex settings in normal projects?

Not at all, it’s unusual and sometimes a code smell.