Memory implementation of member functions in C++

Question

I read an article on virtual table in Wikipedia.

class B1
{
public:
  void f0() {}
  virtual void f1() {}
  int int_in_b1;
};

class B2
{
public:
  virtual void f2() {}
  int int_in_b2;
};

used to derive the following class:

class D : public B1, public B2
{
public:
  void d() {}
  void f2() {}  // override B2::f2()
  int int_in_d;
};

After reading it I couldn't help but wonder how non virtual member functions are implemented in C++. Is there a separate table like the v-table in which all the function addresses are stored? If yes, what is this table called and what happens to it during inheritance?

If no then how does compiler understand these statements?

D * d1 = new D;
d1->f0();    // statement 1

How does compiler interpret that f0() is function of B1 and since D has publicly inherited D it can access f0(). According to the article the compiler changes statement 1 to

(*B1::f0)(d)

Answer 1

Aside from this, I can only say that a normal member function is just a memory address within a class (I even believe every object of that class use the same "function pointer" in memory, but with their own variables). A v-table is a form of runtime redirection, as the compiler can't know what object exactly it is dealing with (obviously due to polymorphism).

Answer 2

Non-virtual member functions are implemented like global functions that accept a hidden this parameter. The compiler knows at compile time which method to call based on the inheritance tree, so there's no need for a runtime table.

Answer 3

Is there a separate table like the v-table in which all the function addresses are stored?

They are stored in the place where they are called.

Taking your example: As long as the f0 method is non-virtual, the compiler knows what's the address of it because there is only one possibility. Let the address be 0xABCD. Then the code

d1->f0();    // statement 1

is compiled to instructions:

// push onto the stack 'this' pointer, as you pointed out the address must
// be earlier translated from D class to B1 which is not presented here
push d1

call 0xABCD // call method at known address (jump to this address)