Re: Inheritance Model Implementation Internals
On Jul 14, 9:22 am, sujeet <sujeet....@gmail.com> wrote:
Hi Friends,
I was pondering over how might be the Inheritance Model be
implemented.
For example:
class _X
{
protected:int ff;
Public: fun();};
class _Y:public _X
{
protected:int ff;
public: sum();
}
int main()
{
_Y y;
return 0;
}
Now does y object internally contain slots with each slot containing
pointer to it's base sub object or all the data members of base class
copied under derived object ?, and if so what about member functions
of base class ..
the only time "slots" are involved is when virtual functions are
used. for data members, they are just copied into a flat buffer.
That's why when you do sizeof(Foo) it's the size of all the data
members added together (with a few minor exceptions which aren't
really important here). Make a base class with 5 integer members and
set them to 1, 2, 3, 4, 5, then make a derived class with 5 members 6,
7, 8, 9, 10. Then do this:
derived* d = new derived();
int* pi = reinterpret_cast<int*>(d);
and see what you get.
Regular, non-virtual functions do not factor into this at all. Their
offsets into your executable's code segment are determined at compile
time and as such are statically bound. So if you do struct Foo { void
f() {} };, the code for f is at a fixed location in memory and there
is no need to waste space storing any kind of reference to it inside
the class. Instead, whenever f is called, the compiler notices this
and simply hardcodes a jump to the previously determined static
offset. In order that each time the function is called it has access
to the information for the instance of the object it was invoked on, C+
+ functions receive an extra hidden parameter, which is a pointer to
the instance. You probably know this parameter as the 'this'
keyword. There's nothing magic about it, it's just an argument to
your function.
Virtual functions are more complicated, but the short version is that
every instance of a class with at least 1 virtual function has an
additional data member that is inaccessible to you (unless you cheat
really bad). This member is a pointer to a table of function
pointers. The compiler compiles base classes first, assigns a 0-based
index to each virtual function, and puts the address in the table at
the corresponding index. Then it goes to the next-most derived class
and generates a new table specific to that class. It copies the base
class's table but now only fills in the entries for virtual functions
that it has overridden. Now, when the compiler notices that you
invoke a virtual function, it actually generates assembly code that
first accesses the table, then gets the function pointer at the
specified index (the index is known at compile time by the compiler
since it's the one that built the table in the first place), and then
invokes the function at that address.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]