cpp class size with virutal pointer and inheritance

Question

class A{
    virtual void a();
};  
class B : A{
    virtual void a();
};
class C{
    virtual void a();
};
class E : A, C{
    virtual void a();
};

int main(){
    std::cout << (sizeof(B)) << "\n"; // 4
    std::cout << (sizeof(C)) << "\n"; // 4
    std::cout << (sizeof(E)) << "\n"; // 8
}

in 32 bits system linux

why sizeof(B) and sizeof(C) are both 4

for class C, it has a virtual function, so there is a virtual pointer hidden in class c which is 4 bytes

but why class B's size is also 4. I think it exists two pointers in class B, one is for B itself since class B has a virtual function, one is for A.

Then same problem for E?

any help is appreciated

You had a lot of typos in your code example which makes it impossible to compile it. We fixed that for you, but you should be a bit more accurate when you are posting here :-) — Klaus, Jan 04 '20 at 09:46

Klaus · Accepted Answer · 2020-01-04T09:40:37.927

No, there is only one vtable pointer in every object which uses virtual functions, independently if the virtual function was defined in the class itself or the class derives from another class which uses virtual functions.

What the compiler generates is a table of function pointers, so that every class ( not instance/object ) has its own. In your example you have a table for class A, one for class B and so on. And in every object/instance you have a vtable pointer. This pointer points only to the table. If you call a virtual function via class pointer, you have the indirection over the vtable pointer and than over the vtable itself.

As a result every instance of a class keeps only a single vtable pointer, pointing to the vtable for this class. As you can see, this results in the same size for every instance of every class you wrote.

In the case of multiple inheritance, you will get multiple vtable pointers. A more detailed answer is already given here: vtable and multiple inheritance

BTW: That you have a vtable and a vtable pointer is not guaranteed from the standards, every compiler can do what it want if the result is what we expect from the semantic. But the double indirection via vtable pointer to pointer in the table to the function is the typical implementation.

This is not correct. An instance of the class `E`, for example, will have two vtable pointers, which is why `sizeof(E)` is 8 up there… — Michael Kenzel, Jan 04 '20 at 09:37

score 0 · Answer 2 · answered Jan 04 '20 at 09:35

0

For single inheritance, derived class B just inserts one more entry to virtual table. For multiple inheritance, derived class E has 2 virtual table pointers.

Further: C++ virtual table layout of MI(multiple inheritance)

answered Jan 04 '20 at 09:35

Charlie

639
9
19

cpp class size with virutal pointer and inheritance

2 Answers2