Runtime polymorphism

[arunvnk]

It is not quite clear why the compiler uses rntime polymorphism when
the virtual keyword is specified.
Since the virtual Keyword is specified,why can't the
compiler decide at the runtime itself,which function is to be
called,even if the function is called by the base class pointer??

[Phlip]

arunvnk wrote:

It is not quite clear why the compiler uses rntime polymorphism when
the virtual keyword is specified.
Since the virtual Keyword is specified,why can't the
compiler decide at the runtime itself,which function is to be
called,even if the function is called by the base class pointer??

In a fully dynamic language like Ruby, every method is virtual. This implies
every method costs extra to call (more time and more memory).

C++ competes with assembler, so you don't pay for what you don't use. If C++
made every method virtual, then many projects could not use C++. Either
their programs would take too long to run, or a C++ compiler would take too
long to compile everything and analyze what methods should be virtual and
which could bind early.

So, you just omit 'virtual' on every method that you know won't need it.
This is no burden, because 'virtual' in C++ acts as a comment meaning
"override me if you want to re-use this class with different behavior."

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

[al pacino]

ar*****@gmail.com wrote:

It is not quite clear why the compiler uses rntime polymorphism when
the virtual keyword is specified.
Since the virtual Keyword is specified,why can't the
compiler decide at the runtime itself,which function is to be
called,even if the function is called by the base class pointer??

ar*****@gmail.com wrote: It is not quite clear why the compiler uses rntime polymorphism when
the virtual keyword is specified.
Since the virtual Keyword is specified,why can't the
compiler decide at the runtime itself,which function is to be
called,even if the function is called by the base class pointer??

hi,
actually (in polymorphism) you can use the base class pointer to invoke
the functions of
derived class object during run time...

NOW , which object's function to invoke is determined at run time,
(there is a vtable
mechanism involved) compiler makes no assumptions about it during
compilation since the
base class pointer might point to some other object at some other time
and invoke that
object's function.

this whole process takes place during run time.

consider this:

class BASE{
.........};
class derived1:public BASE{.............};
class derived2:public BASE{.............};

BASE *bptr= new derived1;//object is created during run time
bptr->anyfun(); //anyfun of derived1 is called
//now bptr can also point to an object of derived2 ,and future
resolutions
// are determined at run time

[Peter_Julian]

<ar*****@gmail.com> wrote in message
news:11********************@i40g2000cwc.googlegrou ps.com...
| It is not quite clear why the compiler uses rntime polymorphism when
| the virtual keyword is specified.
| Since the virtual Keyword is specified,why can't the
| compiler decide at the runtime itself,which function is to be
| called,even if the function is called by the base class pointer??
|

Pointers don't call functions, its the object at the pointer that is
doing the calling. A base pointer simply defines that *if* it is
pointing to an object, that object can be either a specific type or a
derivation thereof. The compiler enforces the type checks, nothing more.
ie:
If the ptr is a shape*, then the triangle satisfies the condition (a
triangle "is_a" shape). The triangle knows how to calculate its own area
and volume. The pointer and the compiler haven't got a clue how to do
that.

A pointer doesn't even know if its actually pointing to anything at all.
Thats why using pointers is dangerous and needs to be strictly confined.
This is not so with a reference. A reference knows its object and its
type. But thats another topic.

Incidentally, the virtual keyword essentially says: generate a vtable
for each of these related family of objects. Vtables are usually
themselves dumb pointers too.

At runtime, the compiler needs not know whether a particular object is
this or that derivation since its the eventual object, and therefore the
inheritance branch, that handles the calls and invocations. The compiler
simply governs and polices the type-transcations the safest way it can.

Thats a powerful concept since you are now free to create a system based
on abstract or base element-types that can be expanded to include new
derivatives that you'll bring into the design a decade from now. Without
modifying a single line of the original code except for the new
features. Thats because the compiler is decoupled from the underlying
system.

[Tomás]

ar*****@gmail.com posted:

Since the virtual Keyword is specified,why can't the
compiler decide at the runtime itself,which function is to be
called,even if the function is called by the base class pointer??

That's exactly the aim: If you declare the function as "virtual", then the
compiler will make sure that the correct function is invoked, regardless of
the type of the expression.

By having the "virtual" keyword in C++, we are simply given the choice as to
whether we desire this behaviour.

Choice is good.

For instance, if we are writing a carwash program, then we can decide that
we'll wash a certain vehicle the way in which a car should be washed... or
we can just give it the generic vehicle wash:

void PerformCarwash( Vehicle& vehicle )
{
int money = AcceptMoney();

if ( 5 <= money ) WashVehicle( vehicle.GetWashingInfo() );
}

If the member function "GetWashingInfo" is virtual, then, if this vehicle is
a car, then it will be washed in a manner fitting a car. If however
"GetWashingInfo" is non-virtual, then it will just be given the generic
vehicle wash.
-Tomás
-Tomás