Re: same overhead in calling virtual and non virtual member function...?
<ypjofficial@indiatimes.com> schrieb im Newsbeitrag
news:1157752413.959892.167510@i42g2000cwa.googlegroups.com...
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.
};
int main()
{
one * o = new one;
o->fun1();
o->fun2();
delete o;
o= NULL;
return 0;
}
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]();
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?
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?
There is one error in your Concept of a compiler. Compilers don't call the
functions they compile. They generate code to call them, and this code
depends on, among other things, a functions firtuaity or non- virtually.
When the compiler detects a call to a virtual function, it may indeed emit
some code to fetch the function's address from a "vtable". But if a
non-virtual function should be called, the compiler can insert the address
directly into the code.
Also, the compiler does not use a "vtable" to decide whether a function is
virtual or not. Usually compilers have much more complicated tables, which
also contain a function's name, its return type, number and type of its
parameters, and perhaps many other data. And the compiler has to look-up
each identifier in this table. No matter what that identifier is used for.
Actually, the compiler has to look-up the identifier to determine what the
identifier is used for.
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...
At compile-time, that might be correct but even worse -- even if a class is
not polymorphic, it still takes about the same time to compile a function
call. But there might be a difference at run-time.
HTH
Heinz
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]