Unit 4: Polymorphism and file handling

• Early (static) binding: the function call is linked to its definition at compile time.
• Late (dynamic) binding: the call is linked at run time, based on the actual object pointed to.

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.

A virtual function is declared with virtual in the base class; when called through a base-class pointer or reference, the derived class's version runs (late binding).

cppclass Shape { public: virtual void draw() { cout << "Shape"; } };
class Circle : public Shape { public: void draw() { cout << "Circle"; } };
Shape *s = new Circle;
s->draw();      // prints "Circle" because draw() is virtual

A pure virtual function has no body: virtual void draw() = 0;. A class with at least one pure virtual function is an abstract class; it cannot be instantiated and serves as an interface that derived classes must complete.

C++ uses stream classes from <fstream>: ofstream (write), ifstream (read) and fstream (both).