Polymorphism.

Overriding methods and name hiding.

class Person {
   protected:
      string name;
   public:
      Person() : name("unknown") {};
      Person(char *n) : name(n) {};
      void Print() const { cout<<name; };
};

class Student : public Person {
   private:
      float gpa;
   public:
      Student() : gpa(0) {};
      Student(char *name, float GPA) : Person(name), gpa(GPA) {};
      void Print() const { cout<<gpa; };
};

Person::Print(void)

Student::Print(void)

The next question is: if we use the following code:

Student student("John Smith", 3.88);
student.Print();

Person *person = new Student("John Smith", 3.88);
person->Print();

Since, as we mentioned above, the signatures of the two Print() methods are different, we did not remove the method Person::Print() from the Student class, we just hid it. In other words, we still can call it, but we need to specify the complete name of the method (including the class name). For example, to invoke method Print() of the class Person for an object of the Student class, we need to do this:

Student student("John Smith", 3.88);
student.Person::Print();   // print the name of the student
student.Print();           // print the GPA of the student

void Print() const { Person::Print();  cout<<": "<<gpa; };

In MS Visual C++ you can use the keyword __super (two underscore symbols) to refer to the parent (base) class. For example, the same modification can be done in MS C++ as

void Print() const { __super::Print();  cout<<": "<<gpa; };

If we use a pointer to a base class to store a pointer of a derived class, then we can still access the methods of the derived class explicitly, but in order to do so, we have to convert the pointer to the right type of pointer first:

Person *person = new Student("Bob Tester", 3.90);
person->Print();                        // invoking Person::Print()
static_cast<Student*>(person)->Print(); // invoking Student::Print()

Similarly, we can hide data members of the base class by defining data members with the same names in the derived class. To access members of the base class, we need to use their complete signatures. For example,

student.Person::public_data_member

Dynamic binding and virtual methods.

void Student::Print()
{
   Person::Print();
   cout<<": "<<gpa;
}

void Student::Print(string msg)
{
   cout<<msg;
   Print();
}

student.Print("\n");

If we use a code like

Person *p = new Student("John Tester", 3.90);
p->Print();

class Person {
   protected:
      string name;
   public:
      Person() : name("unknown") {};
      Person(char *n) : name(n) {};
      virtual void Print() const { cout<<name; };
};

Please modify the previous example to have method Print dynamically bounded and run the same code:

Person *p = new Student("John Tester", 3.90);
p->Print();

However, if we decide to modify class Student and add method PrintAll defined as:

void PrintAll() const { Person::Print(); cout<<": "<<gpa; };

Person *p = new Student("John Tester", 3.90);
p->PrintAll();

filename.cpp(line#) : error C2039: 'PrintAll' : is not a member of 'Person'

class Person {
   ...
   public:
      ...
      virtual void PrintAll() const {};
      ...
};

Virtual destructors.

Person *person = new Student("John Smith", 3.95);

delete person;

class Person {
   protected:
      string name;
   public:
      ...
      ~Person() { cout<<"Destroyng object Person\n"; };
};

class Student : public Person {
   private:
      float gpa;
   public:
      ...
      ~Student() {  cout<<"Destroying object Student\n";  };
};

Destroying object Person

      virtual ~Person() { cout<<"Destroyng object Person\n"; };

Destroying object Student
Destroying object Person

As you understand constructors cannot be virtual simply because when we create a new object we know exactly what kind of object we create.

Abstract classes.

 virtual return_type function_name(parameter_list) = 0;

For example, we can design an abstract class for geometric figures. In this class we gather all common characteristics of all figures as well as their common methods (interface):

class Figure {
   protected:
      int x, y;
      static Graphics *rg;
      static Pen *erasor;
   public:
      Figure() : x(0), y(0) {};
      Figure(int X, int Y) : x(X), y(Y) {};
      virtual ~Figure() {};
      void MoveTo(int X, int Y) { x=X; y=Y; };
      virtual void Draw(Pen *pen) const = 0;
      virtual void Hide() const = 0;
      virtual void DrawFilled(Brush *bsrush) const = 0;
      ...
};

class Circle : public Figure {
   private:
      int radius;
   public:
      Circle() : radius(10) {};
      Circle(int x, int y, int r) : Figure(x, y), radius(r) {};
      ~Circle() {};
      void Draw(Pen *pen) const
      {
         gr->DrawEllips(pen, x, y, radius, radius);
      };
      void Hide() const
      {
         gr->DrawEllips(erasor, x, y, radius, radius);
      };
      void DrawFilled(Brush *bsrush) const
      {
         gr->FillEllips(brush, x, y, radius, radius);
      };
};

Run-time typing information.

Figure *obj = new Circle(5, 5, 10);
if( typeid(*obj) == typeid(Square) ) cout<<"Yes";
else cout<<"No";

std::vector<Figure*> pieces;
// randomly initialize them
...
for(i=0;i<pieces.size();i++)
   cout<<typeid( *(pieces[i]) ).name()<<endl;

Another way to figure out if an object pointer points to an object of a specific type is to use the dynamic_cast operator. This operator takes the type you want to convert a variable into as a template argument (embraced by < and > signs) and the object to convert as a parenthesized argument. For example:

Figure *f = new Square(5, 5, 10);
Square *s = dynamic_cast<Square*>( f );

Rect *r = dynamic_cast<Rect*>( f );
if( r != NULL )
   cout<<"This is not a rectangle";

The static_cast operator is similar, but performs no run-time checks on the result. If the argument cannot be converted to the specified type, no indication will be given. Most of the time you won't even be able to compile the program due to an error message like:

Error E2031 cast.cpp 70: Cannot cast from 'C *' to 'B *' in function main()
*** 1 errors in Compile ***

At the end of the chapter we would like to note that only pointers and references are polymorphic in C++, the real objects are not. For example, if we have two object (not references) declared as

Student student("John Smith", 4.0);
Person  person;

person = student;

person.print();

Homework assignment

class Figure {
   ...
   public:
      void Display() { Show(); };
      virtual void Show() { ... };
};

class Square : public Figure {
   ...
   public:
      void Display() { Show(); };
      virtual void Show() { ... };
}:

Figure *fig = new Square();
fig->Display();
dynamic_cast<Square*>(fig)->Display();

• In line 2 which of the two Display() methods is invoked?
• Which of the two Show() methods will the invoked method calls?
• Same questions about line 3.
• Now, assume that virtual method Show() calls non-virtual method Display(), and answer similar questions about this line:

  fig->Show();