Can someone explain the benefits of polymorphism?

Question

So I understand pretty much how it works, but I just can\'t grasp what makes it useful. You still have to define all the separate functions, you still have to create an instanc

Answer 1

polymorphism is great if you have a list/array of object which share a common ancestor and you wich to do some common thing with them, or you have an overridden method. The example I learnt the concept from, use shapes as and overriding the draw method. They all do different things, but they're all a 'shape' and can all be drawn. Your example doesn't really do anything useful to warrant using polymorphism

Answer 2

A good example of useful polymorphism is the .NET Stream class. It has many implementations such as "FileStream", "MemoryStream", "GZipStream", etcetera. An algorithm that uses "Stream" instead of "FileStream" can be reused on any of the other stream types with little or no modification.

Answer 3

Both your examples do the same thing but in different ways.
The first example calls function() by using Static binding while the second calls it using Dynamic Binding.

In first case the compiler precisely knows which function to call at compilation time itself, while in second case the decision as to which function should be called is made at run-time depending on the type of object which is pointed by the Base class pointer.

What is the advantage?
The advantage is more generic and loosely coupled code.

Imagine a class hierarchy as follows:

The calling code which uses these classes, will be like:

Shape *basep[] = { &line_obj, &tri_obj,
                   &rect_obj, &cir_obj};
for (i = 0; i < NO_PICTURES; i++)
    basep[i] -> Draw ();

Where, line_obj, tri_obj etc are objects of the concrete Shape classes Line, Triangle and so on, and they are stored in a array of pointers of the type of more generalized base class Shape.

This gives the additional flexibility and loose coupling that if you need to add another concrete shape class say Rhombus, the calling code does not have to change much, because it refers to all concrete shapes with a pointer to Base class Shape. You only have to make the Base class pointer point to the new concrete class.

At the sametime the calling code can call appropriate methods of those classes because the Draw() method would be virtual in these classes and the method to call will be decided at run-time depending on what object the base class pointer points to.

The above is an good example of applying Open Closed Principle of the famous SOLID design principles.

Answer 4

There are countless examples of nice uses of polymorphism. Consider as an example a class that represents GUI widgets. The most base classs would have something like:

class BaseWidget
{
...
virtual void draw() = 0;
...
};

That is a pure virtual function. It means that ALL the class that inherit the Base will need to implement it. And ofcourse all widgets in a GUI need to draw themselves, right? So that's why you would need a base class with all of the functions that are common for all GUI widgets to be defined as pure virtuals because then in any child you will do like that:

class ChildWidget
{
 ...
  void draw()
  {
     //draw this widget using the knowledge provided by this child class
  }
};


class ChildWidget2
{
 ...
  void draw()
  {
     //draw this widget using the knowledge provided by this child class
  }
};

Then in your code you need not care about checking what kind of widget it is that you are drawing. The responsibility of knowing how to draw itself lies with the widget (the object) and not with you. So you can do something like that in your main loop:

for(int i = 0; i < numberOfWidgets; i++)
{
    widgetsArray[i].draw();
}

And the above would draw all the widgets no matter if they are of ChildWidget1, ChildWidget2, TextBox, Button type.

Hope that it helps to understand the benefits of polymorphism a bit.

Answer 5

The poly in polymorphic means more than one. In other words, polymorphism is not relevant unless there is more than one derived function.

In this example, I have two derived functions. One of them is selected based on the mode variable. Notice that the agnostic_function() doesn't know which one was selected. Nevertheless, it calls the correct version of function().

So the point of polymorphism is that most of your code doesn't need to know which derived class is being used. The specific selection of which class to instantiate can be localized to a single point in the code. This makes the code much cleaner and easier to develop and maintain.

#include <iostream>
using namespace std;

class Parent
{
public:
    virtual void function() const {};
};

class Derived1 : public Parent
{
    void function() const { cout << "derived1"; }
};

class Derived2 : public Parent
{
    void function() const { cout << "derived2"; }
};

void agnostic_function( Parent const & bar )
{
   bar.function();
}

int main()
{
   int mode = 1;
   agnostic_function
   (
      (mode==1)
      ? static_cast<Parent const &>(Derived1())
      : static_cast<Parent const &>(Derived2())
   );
}

Answer 6

Let's say that my School class has a educate() method. This method accepts only people who can learn. They have different styles of learning. Someone grasps, someone just mugs it up, etc.

Now lets say I have boys, girls, dogs, and cats around the School class. If School wants to educate them, I would have to write different methods for the different objects, under School.

Instead, the different people Objects (boys,girls , cats..) implement the Ilearnable interface. Then, the School class does not have to worry about what it has to educate.

School will just have to write a

public void Educate (ILearnable  anyone)

method.

I have written cats and dogs because they might want to visit different type of school. As long as it is certain type of school (PetSchool : School) and they can Learn, they can be educated.

1. So it saves multiple methods that have the same implementation but different input types
2. The implementation matches the real life scenes and so it's easy for design purposes
3. We can concentrate on part of the class and ignore everything else.
4. Extension of the class (e.g. After years of education you come to know, hey, all those people around the School must go through GoGreen program where everyone must plant a tree in the same way. Here if you had a base class of all those people as abstract LivingBeings, we can add a method to call PlantTree and write code in PlantTree. Nobody needs to write code in their Class body as they inherit from the LivingBeings class, and just typecasting them to PlantTree will make sure they can plant trees).