Re: same overhead in calling virtual and non virtual member function...?

From:

"Aman JIANG" <AmanJIANG@gmail.com>

Newsgroups:

comp.lang.c++.moderated,comp.lang.c++

Date:

9 Sep 2006 14:48:40 -0400

Message-ID:

<1157780457.537679.7190@i42g2000cwa.googlegroups.com>

{ Quoted sig & clc++m banner removed. -mod }

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..?

My english is bad, by-your-leave.
If you write a class like this:

    class One
    {
    public:
        virtual void fun1() { cout<<"one::fun1"; }
        void fun2() { cout<<"one::fun2"; }
    };

And make the call like this:

    One *p = new One;
    p->fun1();
    p->fun2();
    delete p;

In fact, for the compiler, it's might looks like this:

    p = _new(sizeof(One));

    (*p->vtbl[0])(p);

    fun2(p);

    if (p != 0)
    {
        _delete (p);
    }

Actually, if a function is non-virtual in a (polymorphic) class,
it will be resolved a static-call at compiler-time.

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]