Inheritance and modelling is-a relationships

Understanding Inheritance and modelling is-a relationships

A derived class does not copy the base class, it embeds it. When you write class Manager : public Employee, every Manager object physically contains a complete Employee subobject, and that subobject must be fully built before any Manager-specific member exists. That is why base initialization belongs in the member initializer list and runs before the derived constructor body, and why destruction runs the other way: the derived part is torn down first, while the base it depends on is still valid.

Public inheritance also declares a conversion. The compiler binds a Manager reference to a const Employee& parameter, and a Manager* to an Employee*, with no cast, because the Employee it needs is sitting inside the object. The consequence is that every function ever written against Employee now silently accepts Managers, so the question to ask before writing : public Employee is not whether the two classes share fields, but whether every statement a caller may legally write against an Employee stays correct when the object is really a Manager.

Reuse alone is not a reason to inherit. If a class merely needs another class's services, a GameLoop that times frames or a Stack that stores its elements in a vector, make it a member and expose only the operations you are willing to support, because public inheritance permanently publishes the base's entire public interface as part of yours. Say the sentence out loud as a test: "a Manager is an Employee" is a claim about how the object may be used, while "a Stack is a vector" is not, and the shortcut ends with you defending invariants against inherited functions like clear() and insert().

#include <iostream>
#include <string>
#include <utility>

class Employee {
public:
    Employee(std::string name, int id)
        : name_(std::move(name)), id_(id) {
        std::cout << "Employee(" << name_ << ") built\n";
    }
    ~Employee() { std::cout << "Employee(" << name_ << ") gone\n"; }

    const std::string& name() const { return name_; }
    void printBadge() const {
        std::cout << "badge #" << id_ << " " << name_ << "\n";
    }

private:
    std::string name_;
    int id_;
};

class Manager : public Employee {
public:
    Manager(std::string name, int id, int reports)
        : Employee(std::move(name), id), reports_(reports) {
        std::cout << "Manager(" << name() << ") built\n";
    }
    ~Manager() { std::cout << "Manager(" << name() << ") gone\n"; }

    int reports() const { return reports_; }

private:
    int reports_;
};

void checkIn(const Employee& e) {   // accepts any Employee, Manager included
    e.printBadge();
}

int main() {
    Manager m("Dana", 4102, 3);
    checkIn(m);
    std::cout << m.name() << " has " << m.reports() << " reports\n";
}

Worked examples

#include <iostream>

class Rectangle {
public:
    Rectangle(int w, int h) : w_(w), h_(h) {}
    void setWidth(int w) { w_ = w; }
    void setHeight(int h) { h_ = h; }
    int area() const { return w_ * h_; }
private:
    int w_;
    int h_;
};

class Square : public Rectangle {          // claims a Square is-a Rectangle
public:
    explicit Square(int side) : Rectangle(side, side), side_(side) {}
    int side() const { return side_; }
private:
    int side_;
};

void stretch(Rectangle& r) {               // legal for any Rectangle
    r.setWidth(10);
}

int main() {
    Square s(4);
    std::cout << "before: side=" << s.side() << " area=" << s.area() << "\n";
    stretch(s);
    std::cout << "after: side=" << s.side() << " area=" << s.area() << "\n";
}

#include <iostream>

class Account {
public:
    explicit Account(long cents) : cents_(cents) {}
    void deposit(long amount) { cents_ += amount; }
    long balance() const { return cents_; }
private:
    long cents_;
};

class SavingsAccount : public Account {
public:
    using Account::Account;                 // reuse the base constructor

    void addInterest(int basisPoints) {
        deposit(balance() * basisPoints / 10000);
    }
};

int main() {
    SavingsAccount s(200000);                // 2000.00 in cents
    s.addInterest(250);                      // 2.50%
    std::cout << "balance = " << s.balance() << "\n";
}

Important notes

Common mistakes

Try it yourself