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.
};
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?
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...
Can anyone please clarify it..?
When the *compiler* is able to determine the exact type of object,
then it is able to call the function statically.
If all it is given is a pointer (or reference) to a polymorphic
base class, then the compiler can make no assumptions about the
exact type of object.
So, for example;
class A
{
public:
virtual void f();
};
class B : public A
{
public:
virtual void f();
};
int main()
{
B b;
b.f(); // calls B::f() statically as b's type is known
A a;
A *pa = &a;
pa->f(); // uses virtual function dispatch and calls A::f()
pa = &b;
pa->f(); // uses virtual function dispatch and calls B::f()
}
Within the body of a constructor, the static type of an object is
the type corresponding to the constructor. So, if A's constructor
calls f(), A::f() will be called statically and, if B's constructor
calls f(), B::f() will be called statically.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]