#virtual functions

The C++ Virtual Keyword: Nothing Dynamic or RunTime about it

Continuing my post on INHERITANCE to INHERITANCE AND POLYMORPHISM Hope u guys hav read dat if not den plz read dat before reding dis....!! Inheritance is powerful but still u vil think dat v can do without it. Obviously yes .... v can, v have been doing without it coz v still use C language. But introucing d concept of POLYMORPHISM with inheritance takes d power to the next level. So remember INHERITANCE + POLYMORPHISM = VERY POWERFUL We introduce d concept of polymorphism by introducing VIRTUAL FUNCTIONS. So u should first understand d concept of Virtual functions. For eg: We create an ENEMY class and we have 20 different types of ENEMIES class enemy { public: void Attack(); } So dis becomes our base class for all enemies now if we have like 20 diff. enemies in our game and all of dem have different attacks. So without using Virtual functions we make 20 classes for diff enemies and all of dem inherit from base class enemy. den enemy obj = new badEnemy(); enemy obj1 = new BadAssEnemy(); enemy obj2 = new RealBadAssEnemy(); but when we call attack() of all three objects it will call d attack() of base class.....:( so bad na same kind of attack for every enemy makes ur game a dull game, UNTIL we make dat attack() function "VIRTUAL". Now each enemy class vil have different implementation for their attack() which vil actually make dem different. like badenemy attack() simply fires a pistol at you while BadAssEnemy's attack() fires a machine gun at you and RealBadAssEnemy's attack() fires rocket launcher at u..!! Hope ur following d point..it gives us d power to implement d function differently for every class.

WORKING OF VIRTUAL FUNCTIONS The address of all the functions are known at compile time with the exception of virtual functions. There address is not known at until run time, this is an example of late binding. One of d factors deciding the size of an executable (.exe) depends on this binding if a lot of early binding is done d size tends to increase and with late binding the size tends to decrease. In the world of VIRTUAL functions there are "VTABLES" and "VPTRS" VTABLES: They are an array of function pointers which holds the addresses of all the virtual functions. Only 1 VTABLE is generated for a single class VPTRS: It is a pointer which points at a location inside the VTABLE.Each object will have a VPTR which points to the correct location in a VTABLE. SO what happens when we call a virtual function 1.VPTR of that object is fetched 2.Offset in the VTABLE is calculated 3. At that offset is d function pointer which is pointing to the virtual function which is then fetched 4. finally the function call is made. Though the actual memory footprint of a virtual function is very complex but dis is d crux of what happens behind and should give u a basic understanding. NOTE: Compilers are smart enough to optimize VIRTUAL function calls. For eg: class A { virtual void func(); } class B : public A { virtual void func(); } int main() { A* obj = new B(): B* obj1 = new B(): obj.func(); \\Virtual function overhead, VTABLE lookup occurs here obj1.func(); \\No overhead here simple member function call passing a "this" pointer. return 0; }

Well, that's about it for my COM concepts summary, so far. I still have more to learn about COM, so as I go along, I'll make up more summaries to add to this one.