Trouble with different kinds of polymorphism

Question

From what I learned so far, there are two kinds of polymorphism, compile-time, and runtime. In compile-time, the polymorphed function or operator is resolved by compiler, while in runtime, its resolved at runtime. Examples of compiile time polymorphism include function and operator overloading, and runtime polymorphism includes function overriding and virtual functions. Additonally there are cases like Early binding and Late binding which I'm coming to later. Consider the following code:

class base {
public:
    void Print() {
        std::cout << "This is parent class\n";
    }
};

class derived : public base {
public:
    void Print() {
        std::cout << "This is derived class\n";
    }
};

If I do this:

base b1;
b1.Print();
derived d1;
d1.Print();

the result is pretty obvious:

This is parent class
This is derived class

The real problem begins when I use a pointer to base class to operate on these functions.

base b1;
derived d1;
base* pb = &b1;
base* pb2 = &d1;
pb->Print();
pb2->Print();

The output would be:

This is parent class
This is parent class

This is due to Early binding, the compiler checks the type of object that is calling the function, not the type of object its processing. And pretty much obviously it is done in compile time. Now if I use the virtual keyword in the base class function definition, then I can do the above easily without any hassle, which is due to Late binding, which saves the function definition for runtime based on the type of object its processing. This is an example of runtime polymorphism.

Sorry for taking too long, my question is, is this the only way we can achieve runtime polymorphism? Also, if function overriding is runtime polymorphism, then the previous example (i.e, the one with Early binding) should also be runtime polymorphism since it is also doing function overriding.

Please tag with a programming language - different languages handle polymorphism very differently. — BJ Myers, Mar 24 '18 at 15:55

score 0 · Answer 1 · answered Mar 24 '18 at 20:55

Nothing forces you to use virtual functions in order to achieve run time polymorphism. In performance critical code often time see things like this to avoid the cost of a virtual function call:

void foo(Base * _b)
{
   if(_b->typeID == TID_BASE)
   {
       b->bar();
   }
   else if(_b->typeID == TID_DERIVED)
   {
       static_cast<Derived*>(_b)->bar();
   }
}

Where type id is either some form of enum or pointer that uniquely identifies a type. That said, I'd never recommend doing this unless you actually measured that it makes a performance difference in your case.

Regarding your last question. No, that is in no way late binding because your are not overriding any functions at all. In your example there is one Print function in the Base class and one in the Derived class. By casting your object to Base, you explicitly request the Base class Print function.

Trouble with different kinds of polymorphism

1 Answers1