Question

In the code below I am not able to understand the way in which the virtual methods of the derived class is being called.
Also, can anyone suggest a source where the concepts of virtual function is explained diagrammatically with very basic approach.

class Base1
{
  virtual void fun1() { cout << "Base1::fun1()" << endl; }
  virtual void func1() { cout << "Base1::func1()" << endl; }
};


class Base2 
{
  virtual void fun1() { cout << "Base2::fun1()" << endl; }
  virtual void func1() { cout << "Base2::func1()" << endl; }
};


class Base3 
{
    virtual void fun1() { cout << "Base3::fun1()" << endl; }
    virtual void func1() { cout << "Base3::func1()" << endl; }
};

class Derive : public Base1, public Base2, public Base3
{

public:

  virtual void Fn()
  {
    cout << "Derive::Fn" << endl;
  }

  virtual void Fnc()
  {
    cout << "Derive::Fnc" << endl;
  }
};


typedef void(*Fun)(void);

int main()
{
  Derive obj;
  Fun pFun = NULL;

  // calling 1st virtual function of Base1
  pFun = (Fun)*((int*)*(int*)((int*)&obj+0)+0);
  pFun();

  // calling 2nd virtual function of Base1
  pFun = (Fun)*((int*)*(int*)((int*)&obj+0)+1);
  pFun();

  // calling 1st virtual function of Base2
  pFun = (Fun)*((int*)*(int*)((int*)&obj+1)+0);

  pFun();

  // calling 2nd virtual function of Base2

  pFun = (Fun)*((int*)*(int*)((int*)&obj+1)+1);
  pFun();

  // calling 1st virtual function of Base3
  pFun = (Fun)*((int*)*(int*)((int*)&obj+2)+0);
  pFun();

  // calling 2nd virtual function of Base3
  pFun = (Fun)*((int*)*(int*)((int*)&obj+2)+1);

  pFun();

  // calling 1st virtual function of Drive
  pFun = (Fun)*((int*)*(int*)((int*)&obj+0)+2);
  pFun();

  // calling 2nd virtual function of Drive
  pFun = (Fun)*((int*)*(int*)((int*)&obj+0)+3);
  pFun();

  return 0;
}

Answer 1

The inheritance diagram looks like this:

Base1  Base2  Base3

  \      |      /
   \     |     /
    \    |    /
     \   |   /

      Derived

There is no unambiguous function Derived::func1(). Morover, the virtual keyword is a red herring, because Derived isn’t actually overriding anything. So the only question is how to call the various base functions. Here’s how:

Derived x;

// x.func1(); // Error: no unambiguous base function

x.Base1::func1();
x.Base2::func1();
x.Base3::func1();

The story would be entirely different if you were to actually override func1() in Derived.