I have some questions about the object size with virtual.
1) virtual function
class A {
public:
int a;
virtual void v();
}
The size of class A is 8bytes….one integer(4 bytes) plus one virtual pointer(4 bytes)
It’s clear!
class B: public A{
public:
int b;
virtual void w();
}
What’s the size of class B? I tested using sizeof B, it prints
12
Does it mean that only one vptr is there even both of class B and class A have virtual function? Why there is only one vptr?
class A {
public:
int a;
virtual void v();
};
class B {
public:
int b;
virtual void w();
};
class C : public A, public B {
public:
int c;
virtual void x();
};
The sizeof C is 20……..
It seems that in this case, two vptrs are in the layout…..How does this happen? I think the two vptrs one is for class A and another is for class B….so there is no vptr for the virtual function of class C?
My question is, what’s the rule about the number of vptrs in inheritance?
2) virtual inheritance
class A {
public:
int a;
virtual void v();
};
class B: virtual public A{ //virtual inheritance
public:
int b;
virtual void w();
};
class C : public A { //non-virtual inheritance
public:
int c;
virtual void x();
};
class D: public B, public C {
public:
int d;
virtual void y();
};
The sizeof A is 8 bytes ————– 4(int a) + 4 (vptr) = 8
The sizeof B is 16 bytes ————– Without virtual it should be 4 + 4 + 4 = 12. why there is another 4 bytes here? What’s the layout of class B ?
The sizeof C is 12 bytes. ————– 4 + 4 + 4 = 12. It’s clear!
The sizeof D is 32 bytes ————– it should be 16(class B) + 12(class C) + 4(int d) = 32. Is that right?
class A {
public:
int a;
virtual void v();
};
class B: virtual public A{ //virtual inheritance here
public:
int b;
virtual void w();
};
class C : virtual public A { //virtual inheritance here
public:
int c;
virtual void x();
};
class D: public B, public C {
public:
int d;
virtual void y();
};
sizeof A is 8
sizeof B is 16
sizeof C is 16
sizeof D is 28 Does it mean 28 = 16(class B) + 16(class C) – 8(class A) + 4 ( what’s this? )
My question is , why there is an extra space when virtual inheritance is applied?
What’s the underneath rule for the object size in this case?
What’s the difference when virtual is applied on all the base classes and on part of the base classes?
This is all implementation defined. I’m using VC10 Beta2. The key to help understanding this stuff (the implementation of virtual functions), you need to know about a secret switch in the Visual Studio compiler, /d1reportSingleClassLayoutXXX. I’ll get to that in a second.
The basic rule is the vtable needs to be located at offset 0 for any pointer to an object. This implies multiple vtables for multiple inheritance.
Couple questions here, I’ll start at the top:
This is how virtual functions work, you want the base class and derived class to share the same vtable pointer (pointing to the implementation in the derived class.
This is the layout of class C, as reported by /d1reportSingleClassLayoutC:
You are correct, there are two vtables, one for each base class. This is how it works in multiple inheritance; if the C* is casted to a B*, the pointer value gets adjusted by 8 bytes. A vtable still needs to be at offset 0 for virtual function calls to work.
The vtable in the above layout for class A is treated as class C’s vtable (when called through a C*).
This is the layout of class B in this example:
As you can see, there is an extra pointer to handle virtual inheritance. Virtual inheritance is complicated.
No, 36 bytes. Same deal with the virtual inheritance. Layout of D in this example:
Virtual base class pointer, it’s complicated. Base classes are “combined” in virtual inheritance. Instead of having a base class embedded into a class, the class will have a pointer to the base class object in the layout. If you have two base classes using virtual inheritance (the “diamond” class hierarchy), they will both point to the same virtual base class in the object, instead of having a separate copy of that base class.
Important point; there are no rules: the compiler can do whatever it needs to do.
And a final detail; to make all these class layout diagrams I am compiling with:
Where XXX is a substring match of the structs/classes you want to see the layout of. Using this you can explore the affects of various inheritance schemes yourself, as well as why/where padding is added, etc.