Question

I’m slightly confused about runtime polymorphism. Correct me if I am wrong, but to my knowledge, runtime polymorphism means that function definitions will get resolved at runtime.

Take this example:

class a
{
a();
~a();
void baseclass();
}

class b: class a
{
b();
~b();
void derivedclass1();
}

class c: class a
{
c();
~c();
void derivedclass2();
}

Calling methodology:

b derived1;
a *baseptr = &derived1; //here base pointer knows that i'm pointing to derived class b. 
baseptr->derivedclass1();

In the above calling methodology, the base class knows that it’s pointing to derived class b.

So where does the ambiguity exist?

In what cases will the function definitions get resolved at runtime?

Answer 1

There is no ambiguity exists in the example provided.

If the base class has the same function name as the derived class, and if you call in the way you specified, it will call the base class’s function instead of the derived class one.

In such cases, you can use the virtual keyword, to ensure that the function gets called from the object that it is currently being pointed. It is resolved during the run time.

Here you can find more explanation..