- [Voiceover] Hi, welcome to the second video
of this section, polymorphism.
In the previous video, we learned about inheritance.
In this video, we'll go through the concept of polymorphism,
and take a look at an example.
Polymorphism allows us to write code
that is less dependent on the types
we are trying to manipulate.
This can make our code clearer and more efficient.
It means different forms.
If the objects that we code
can be more than one type of thing,
that we can take advantage of this.
Boiled down to its simplest definition,
polymorphism is this:
Any sub-class can be used
as part of the code that uses the super-class.
This means we can write code
that is simpler and easier to understand,
and also easier to modify or change.
Also, we can write code for the super-class,
and rely on the fact that no matter how many times
it is sub-classed, within certain parameters,
the code will still work.
Let's discuss an example.
Suppose we want to use polymorphism
to help write a zoo management game,
where we have to feed and tend to the needs of animals.
We will probably want to have a function such as "feed."
We will also probably want to pass an instance
of the animal to be fed into the feed function.
A zoo of course has many types of animals.
Lion, elephant and three-toed sloth.
With our new knowledge of C++ inheritance,
it will make sense to code an animal class
and have all the different types of animal inherit from it.
If we want to write a function, "feed,"
that we can pass lion, elephant, and three-toed sloth
into as a parameter,
it might seem like we need to write a feed function
for each and every type of animal.
However, we can write polymorphic functions,
with polymorphic return types and arguments.
Take a look at this definition
of the hypothetical feed function:
This function has the animal reference as a parameter.
Meaning that, any object that is built from a class
that extends animal can be passed into it.
So you can even write code today,
and make another sub-class in a week, month, or year.
And the very same functions and data structures
will still work.
Also, we can enforce upon our sub-classes,
a set of rules for what they can and cannot do,
as well as how they do it.
So, good design in one stage
can influence it at other stages.
But will we really ever want to
instantiate an actual animal?
We'll find out.
In this video, we've looked at polymorphism.
Great.
Next, as I just said, we'll see abstract classes,
virtual and pure virtual functions.