2016/11/24 - C++ Overloading, Abstract Class and Polymorphism

Overloading

C++ allows you to specify more than one definition for a function name or an operator in the same scope, which is called function overloading or operator overloading respectively.

An overloaded declaration is a declaration that had been declared with the same name as a previously declared declaration in the same scope, except that both declarations have different arguments and obviously different definition (implementation).

When you call an overloaded function or operator, the compiler determines the most appropriate definition to use by comparing the argument types you used to call the function or operator with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.

Function overloading 1

You can have multiple definitions for the same function name in the same scope. The definition of the function must differ from each other by the types and/or the number of arguments in the argument list. You can not overload function declarations that differ only by return type.

Following is the example where same function print() is being used to print different data types:

#include <iostream>
using namespace std;

class printData {
   public:
     void print(int i) {
         cout << "Printing int: " << i << endl;
     }
     void print(double  f) {
         cout << "Printing float: " << f << endl;
     }
     void print(char* c) {
         cout << "Printing character: " << c << endl;
     }
};

int main(void) {
   printData pd;

   // Call print to print integer
   pd.print(5);

   // Call print to print float
   pd.print(500.263);

   // Call print to print character
   pd.print("Hello C++");

   return 0;
 }

And the result:

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Abstract Class 2

An interface describes the behavior or capabilities of a C++ class without committing to a particular implementation of that class.

The C++ interfaces are implemented using abstract classes and these abstract classes should not be confused with data abstraction which is a concept of keeping implementation details separate from associated data.

A class is made abstract by declaring at least one of its functions as pure virtual function. A pure virtual function is specified by placing “= 0” in its declaration as follows:

class Box {
    public:
        // pure virtual function
        virtual double getVolume() = 0;
        private:
            double length;      // Length of a box
            double breadth;     // Breadth of a box
            double height;      // Height of a box
};

The purpose of an abstract class (often referred to as an ABC) is to provide an appropriate base class from which other classes can inherit. Abstract classes cannot be used to instantiate objects and serves only as an interface. Attempting to instantiate an object of an abstract class causes a compilation error.

More details : See Reference [2]

Polymorphism 3

The word polymorphism means having many forms. Typically, polymorphism occurs when there is a hierarchy of classes and they are related by inheritance.

C++ polymorphism means that a call to a member function will cause a different function to be executed depending on the type of object that invokes the function.

Consider the following example where a base class has been derived by other two classes:

#include <iostream>
using namespace std;

class Shape {
   protected:
        int width, height;

   public:
        Shape( int a = 0, int b = 0) {
            width = a;
            height = b;
        }

        int area() {
            cout << "Parent class area :" <<endl;
            return 0;
        }
 };

 class Rectangle: public Shape {
     public:
         Rectangle( int a = 0, int b = 0):Shape(a, b) { }
         int area () {
             cout << "Rectangle class area :" <<endl;
             return (width * height);
         }
 };

 class Triangle: public Shape{
     public:
         Triangle( int a = 0, int b = 0):Shape(a, b) { }
         int area () {
             cout << "Triangle class area :" <<endl;
             return (width * height / 2);
         }
 };

 // Main function for the program
 int main( ) {
    Shape * shape;
    Rectangle rec(10,7);
    Triangle  tri(10,5);
    // store the address of Rectangle
    shape = &rec;
    // call rectangle area.
    shape->area();
    // store the address of Triangle
    shape = &tri;

    // call triangle area.
    shape->area();

    return 0;
 }

When the above code is compiled and executed, it produces the following result:

Parent class area
Parent class area

The reason for the incorrect output is that the call of the function area() is being set once by the compiler as the version defined in the base class. This is called static resolution of the function call, or static linkage - the function call is fixed before the program is executed. This is also sometimes called early binding because the area() function is set during the compilation of the program.

But now, let’s make a slight modification in our program and precede the declaration of area() in the Shape class with the keyword virtual so that it looks like this:

class Shape {
    protected:
        int width, height;
    public:
        Shape( int a = 0, int b = 0) {
            width = a;
            height = b;
        }

    virtual int area() {
        cout << "Parent class area :" <<endl;
        return 0;
    }
};

After this slight modification, when the previous example code is compiled and executed, it produces the following result:

Rectangle class area
Triangle class area

This time, the compiler looks at the contents of the pointer instead of it’s type. Hence, since addresses of objects of tri and rec classes are stored in *shape the respective area() function is called.

As you can see, each of the child classes has a separate implementation for the function area(). This is how polymorphism is generally used. You have different classes with a function of the same name, and even the same parameters, but with different implementations.

4 翻成白話文就是說： 一個訊息（message or event or stimulus）的意義是由接收者（接收到這個訊息的物件）來解釋，而不是由訊息發出者（sender）來解釋。所以，在runtime時只要接受者換成不同的物件或是instance，系統的行為就會改變。具有這樣的特性就稱之為polymorphism。

現實例子：Teddy（sender，等一下準備送出信息的物件）走在路上看到前方有兩位名人，分別是「林志玲」與「阿美姐」（等一下準備接收訊息的兩個物件），於是大喊一聲「美女請留步（訊息）」。理論上Teddy期待只有「林志玲」會「回頭」（訊息接收者的行為），沒想到「阿美姐」也回頭了…XD。所以說，一個訊息的解釋是由接收者來決定的，而不是送出者。如果一個系統具有這樣的特性，那麼我們就說這個系統具備多形(polymorphism)的行為。