Unit 3: Inheritance and overloading

Inheritance is the mechanism by which a derived (child) class acquires the data and functions of a base (parent) class. Syntax: class Derived : mode Base { … };

cppclass Student {                       // base
protected:
    int roll;
public:
    void getRoll(int r) { roll = r; }
};
class Exam : public Student {         // multilevel: level 2
protected:
    int m1, m2;
public:
    void getMarks(int a, int b) { m1 = a; m2 = b; }
};
class Result : public Exam {          // level 3
public:
    void show() { cout << roll << " total = " << m1 + m2; }
};

Ambiguity in multiple and hybrid inheritance: if two base classes inherit from the same grandparent, the derived class gets two copies (the diamond problem). It is solved with a virtual base class: class B : virtual public A.

• protected members are accessible in the class and its derived classes but not outside — the middle ground between private and public.

• Nested class: a class declared inside another class — used to hide helper classes; containership (composition): a class contains objects of other classes ("has-a" relationship), as opposed to inheritance ("is-a").

cppclass Car {
    class Engine { public: int hp = 120; };   // nested class
    Engine e;                                 // containership
public:
    int power() { return e.hp; }
};

Function overloading means several functions with the same name but different parameter lists (number or type of arguments). The compiler chooses the right one.

cppdouble area(double r)            { return 3.14159 * r * r; }   // circle
double area(double l, double b)  { return l * b; }             // rectangle
double area(double a, double b, double c) {                    // triangle (Heron)
    double s = (a + b + c) / 2;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

Operator overloading gives an operator a special meaning for user-defined types using an operator function: ReturnType operator+(Arg);

• Unary operators (++, −−, −) as member functions take no argument.
• Binary operators (+, −, ×) as member functions take one argument (the right operand).

cppclass Complex {
    float re, im;
public:
    Complex(float r = 0, float i = 0) { re = r; im = i; }
    Complex operator+(Complex c) { return Complex(re + c.re, im + c.im); }
};
Complex c3 = c1 + c2;   // calls c1.operator+(c2)

Rules: only existing operators can be overloaded; at least one operand must be a user-defined type; precedence and number of operands cannot change; the operators ., ::, ?:, sizeof and .* cannot be overloaded.

cppclass Counter {
    int c = 0;
public:
    Counter& operator++() { ++c; return *this; }           // unary prefix ++
    Counter operator+(const Counter &o) const {             // binary +
        Counter t; t.c = c + o.c; return t;
    }
};