Function Polymorphism: following the type of variable

Defining same functions in Parent and Child classes
- First: never-ever define variables in a child-class that have the same name as some variables in the parent class.
  The scoping rule will overshadow the variables in the parent class and you can't access them; so they become useless.
- On the other hand, it is a common practice to define functions in a child-class that have the same name and parameters as some functions in the parent class.
- When a child class defines a function that has the same name and parameters as some functions in the parent class, then there will be two different functions in the child-class; and which function will be called, depends on the TYPE of the function
Type of functions classes
- Ordinary functions (the ones you have seen so far)
- Virtual functions (the ones you will learn...)

Function Polymorphism

"Function polymorphism" is the ability to invoke a different function under different circumstances.

The best way to illustrate the concept of polymorphism (different function at different times), is through an example:

Consider the following 2 classes where myNewClass defines the same function func1(int) that is also found in its parent class:

class myOldClass { public: int i1; void func1(int i) { i1 = i1 + i; } };

class myNewClass : public myOldClass { public: int i2; void func1(int i) { i2 = i2 + 1000*i; } };

Let us consider a program with one variable and one pointer of each type:

myOldClass A; myOldClass *ptr1; myNewClass B; myNewClass *ptr2; A.func1(4); // Invokes myOldClass::func1() B.func1(4); // Invokes myNewClass::func1() ptr1 = &A; ptr1->func1(4); ptr1 = &B; ptr1->func1(4);

Example Program: (Normal behavior (non-polymorph)) click here
The expression ptr1->func1(4); invokes the function myOldClass::func1() in BOTH cases above
This outcome is what we should expect, afterall, we are evaluating the same expression !!!

In case you wondering if you have learned anything new, the answer is no.
I am only illustrating what you have learned so far to make the difference in the next example more evident.

Function Polymorphism (CONTINUED)

Now consider the following 2 classes where myNewClass defines the same function func1(int) that is also found in its parent class, with the difference where the function func1(int) is defined as a virtual function:

class myOldClass { public: int i1; virtual void func1(int i) { i1 = i1 + i; } };

class myNewClass : public myOldClass { public: int i2; virtual void func1(int i) { i2 = i2 + 1000*i; } };

Let us consider the same program with one variable and one pointer of each type:

Example Program: (Demo polymorphism) --- click here
The expression (ptr1 = &A;) ptr1->func1(4); now invokes the function myOldClass::func1() while expression (ptr1 = &B;) ptr1->func1(4); now invokes the function myNewClass::func1()
This outcome is what we do NOT expect.... a different function was invoked depending on the circumstance (more precisely, depending on which type of variable ptr1 was pointing to....

This phenomenon is called function polymorphism