Re: same overhead in calling virtual and non virtual member function...?
ypjofficial@indiatimes.com schrieb:
Hello All,
[... about vptr lookup ...]
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]();
You seem to have read the FAQ already, but I'll post it nonetheless for
the sake of reference:
http://www.parashift.com/c++-faq-lite/virtual-functions.html
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?
At compile-time. The compiler knows what functions are virtual, and
what functions are non-virtual; note that if a specific function is
marked as virtual somewhere in the class hierarchy, then it is
automatically virtual for all classes *deriving* from this class.
"Good coding style(tm)" proposes to use the virtual keyword in any class
for this method, as it shows a conscious decision.
I think, you are worried of this:
// --- in our all known header file
struct I_blub {
virtual void v_method() = 0;
void method() {}; // note: non-virtual
};
// --- in a third party component anywhere, only binary linked.
struct CThirdParty : I_blub {
virtual void v_method() { }
virtual void method() { } // note: *virtual*!
};
This probably won't work as expected. If you now do
CThirdParty obj;
obj.method();
then it is clear, that the CThirdParty::method() will be called. But if
you think you can do:
I_blub *my_obj= &obj;
my_obj->method();
you will be surprised. Indeed I_blub::method() will be called. This is
becase for I_blub the compiler knows that method() is *non-virtual*, and
will therefore not do a look-up. Never.
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?
Why do you feel so? Every function is known to be virtual or
non-virtual at compile-time, for a specific class. If you derive from a
class, and add some virtual to a known method, you did not change the
base class. If somebody accesses your class via base, the virtual in
your derived class has no effect.
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..?
I hope I could help a bit.
As a final remark I want to add, that with current compiler optimization
there may already be some tricks to decrease the cost of virtual
function calls, I'm thinking of profile guided optimization here. I
don't know exactly what is done there, but I think it has to do with
speculative execution of some virtual function call or so. I hope one
of the other readers may point to some resource.
best regards,
-- Markus
Thanks and Regards,
Yogesh Joshi
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]