Inheritance: building on an existing class

Why inheritance?

Many things share common parts. Every bank account has a number, an owner and a balance, but a savings account also earns interest and a current account allows an overdraft. Instead of copying the common code into each class, you write it once in a base class and let each specific account inherit it. This is inheritance.

#include <iostream>
#include <string>

class Account {
public:
    Account(std::string owner, long long balance)
        : owner_(std::move(owner)), balance_(balance) {}
    void deposit(long long amount) { if (amount > 0) balance_ += amount; }
    long long balance() const { return balance_; }
    const std::string& owner() const { return owner_; }
protected:
    long long balance_;        // derived classes can use this
private:
    std::string owner_;
};

class SavingsAccount : public Account {
public:
    SavingsAccount(std::string owner, long long balance, double rate)
        : Account(std::move(owner), balance), rate_(rate) {}   // call the base constructor
    void addInterest() { balance_ += static_cast<long long>(balance_ * rate_); }
private:
    double rate_;
};

int main() {
    SavingsAccount s("Asha", 100000, 0.04);
    s.deposit(20000);          // inherited from Account
    s.addInterest();           // SavingsAccount's own
    std::cout << s.owner() << ": " << s.balance() << '\n';   // Asha: 124800
}

What the derived class can use

Always write public inheritance (class D : public B) unless you have a specific reason. With class D : B (no keyword), inheritance is private by default for classes, which hides the base's public interface and surprises most readers.

Order of construction and destruction

When a derived object is created, the base part is constructed first, then the derived members, then the derived constructor body runs. Destruction happens in exactly the reverse order: derived destructor first, base destructor last. This way the derived class can always rely on its base being ready.

Overriding versus hiding

If the derived class defines a function with the same name as one in the base, the derived version hides the base version when called on a derived object. To change behaviour through a base reference (polymorphism), the base function must be virtual; that is the next topic.

Is-a versus has-a

Use inheritance only for a real "is-a" relationship. A Car HAS an Engine; it is not an Engine. For has-a, put the other class inside as a member: this is composition. A common rule is "prefer composition over inheritance": inheritance ties classes tightly together, and deep hierarchies (five levels of base classes) become hard to change.

class Engine { public: void start() {} };

class Car {              // composition: Car HAS an Engine
public:
    void start() { engine_.start(); }
private:
    Engine engine_;
};