Re: virtual and class size
Christopher <cpisz@austin.rr.com> wrote:
Is the following correct?
----
Question:
On a 32 bit machine, if you have a class A with one int (or DWORD) as
member data, along with a virtual destructor and one other virtual
method, what will the sizeof(A) return?
Answer:
The sizeof function returns the size of a type in bytes.
With no virtual methods, sizeof(type) returns the sum of the class'
data members. However, when you make one or more methods virtual, the
class now carries with it a pointer to the class' vtable.
The answer is therefore, 4 bytes for the int + 4 bytes for the pointer
to the vtable = 8 bytes.
The size is completely up to the implementation. The standard poses no
requirements on this. The size could well be 4 bytes (if the compiler could
somehow implement the requirements of the virtual destructor by means other
than with a vtable pointer in the object) or 400 bytes, for all the standard
cares.
In practice you are correct. However, if your goal is to write completely
portable code, you can't make the assumption.
What exactly does the vtable look like and how are methods "looked
up"?
The class just contains a pointer to the vtable? I thought each method
had a pointer into the vtable...
The exact implementation of virtual tables (which are btw not specified
in any way by the standard; in fact, you could implement dynamic binding
by a completely different method and it would be ok) is probably quite
dependent on the specific compiler.
The basic idea with virtual tables is that they contain function
pointers at specific offsets (which the compiler knows). Each virtual
table in an inheritance hierarchy contains the pointer for a specific
function always at the same offset. This way when a piece of code calls
a virtual function using an object, what happens is that the code takes
the vtable pointer, indexes it with the known literal offset, and calls
the function pointed by that element in the vtable.
So when you do a "myObject->virtualfunc(param)", what the compiler
produces is something akin to "(*myObject.vtable[12])(param)" (where
'vtable' refers to the vtable pointer inside the object, usually at
offset 0).