Re: same overhead in calling virtual and non virtual member function...?
ypjofficial@indiatimes.com wrote:
Hello All,
So far I have been reading that in case of a polymorphic class ( having
at least one virtual function in it), the virtual function call get
resolved at run time and during that the vtable pointer is made use
of..
eg.
class one
{
virtual void fun1(){ cout<<"one::fun1";} //This is a virtual
function.
void fun2(){ cout<<"one ::fun2";}//Not a virtual function.
};
so when the virtual function gets called through the base class poitner
the call actually gets expanded to the code like this
o->vfptr[0]();
Yes, at least for C++ compilers that use vtables to implement virtual
functions. But the general point is that one function call to a virtual
method in the source code can - at runtime - execute any of several
distinct methods (based on the runtime type of the object) each and
every time. So calling a virtual method requires run-time
decision-making which is not needed when calling non-virtual methods or
global functions.
My confusion is how the call to the non virtual function (here fun2
)gets resolved in polymorphic class?
When does the compiler decide to look into the vtable and when not to
look?
The compiler generates "lookup-code" when the method being called has
been declared virtual, otherwise it generates a direct call to the
method as determined by the object's static type.
As in this scenario I strongly feel that, every time the compiler has
to look into the vtable irrespective of the virtuality or non
virtuality of the function.If it finds the function entry in the vtable
then it calls the function from there otherwise if it doesn't find any
entry into the vtable it looks for the non virtual function and then
execute the fuction code?
The program at runtime does not need to determine whether a method is
virtual or not. The compiler has that information at compile time - so
only calls to virtual methods will have the overhead of a virtual
method call.
So in other words whenever your class is polymorphic , we have to deal
with this overhead always whether the class user calls the virtual or
non virtual function...
No, that is not the case at all.
Greg
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]