C++ Inheritance: Base & Derived Classes Explained

Reusing a Class by Extending It

You've built classes with constructors and cleaned them up with destructors. Inheritance is the next step: instead of copying the members of one class into another, you declare that a new class is a specialized version of an existing one and let it inherit everything automatically.

The existing class is the base class (or parent); the new one is the derived class (or child). A derived class starts with all of the base's data and behavior, then adds or changes what makes it different. This is C++'s primary tool for the "is-a" relationship: a Dog is an Animal, a SavingsAccount is a BankAccount.

Basic Syntax: class Derived : public Base

You inherit by following the derived class name with a colon, an access specifier, and the base class name. The most common form is public inheritance.

#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
    string name;
    void eat() {
        cout << name << " is eating." << endl;
    }
};

// Dog is-a Animal: it gets name and eat() for free
class Dog : public Animal {
public:
    void bark() {
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog d;
    d.name = "Rex";   // inherited member
    d.eat();          // inherited method
    d.bark();         // Dog's own method
    return 0;
}

Dog never declares name or eat(), yet both work on a Dog object because they were inherited from Animal. The derived class is free to add members like bark() that the base knows nothing about.

protected: Members for Children Only

A private base member is not accessible inside the derived class - inheritance does not break encapsulation. When you want the base's internals hidden from the outside world but available to subclasses, use the protected access specifier.

#include <iostream>
using namespace std;

class BankAccount {
protected:
    double balance = 0;   // visible to derived classes, not to outsiders
public:
    void deposit(double amount) { balance += amount; }
    double getBalance() const { return balance; }
};

class SavingsAccount : public BankAccount {
public:
    void addInterest(double rate) {
        balance += balance * rate;   // OK: protected member is reachable here
    }
};

int main() {
    SavingsAccount s;
    s.deposit(1000);
    s.addInterest(0.05);
    cout << s.getBalance() << endl; // 1050
    // s.balance = 0;   // ERROR: protected, not accessible from main
    return 0;
}

Think of the three levels as concentric rings: private is "only this class," protected is "this class and its descendants," and public is "everyone." See access-specifiers for the full picture.

Constructor and Destructor Order

A derived object contains a base subobject, and that base part must be alive before the derived part is built. So construction runs base-first, destruction runs derived-first (the exact reverse). If the base needs constructor arguments, you pass them through the member-initializer list.

#include <iostream>
#include <string>
using namespace std;

class Animal {
    string name;
public:
    Animal(string n) : name(n) {
        cout << "Animal ctor: " << name << endl;
    }
    ~Animal() { cout << "Animal dtor: " << name << endl; }
};

class Dog : public Animal {
public:
    // forward the argument to the base constructor
    Dog(string n) : Animal(n) {
        cout << "Dog ctor" << endl;
    }
    ~Dog() { cout << "Dog dtor" << endl; }
};

int main() {
    Dog d("Rex");
    return 0;
}

The output makes the ordering concrete:

Animal ctor: Rex   // base built first
Dog ctor           // then the derived part
Dog dtor           // destroyed in reverse...
Animal dtor: Rex   // ...base last

If you forget the : Animal(n) and the base has no default constructor, the code won't compile - C++ has no idea how to build the base part. A base class you intend to inherit from should almost always declare a destructor (and, as the next page shows, often a virtual one).

Overriding: Redefining a Base Method

A derived class can replace an inherited method by declaring one with the same signature. You can still reach the original through Base::method().

#include <iostream>
using namespace std;

class Shape {
public:
    void describe() const { cout << "A generic shape" << endl; }
};

class Circle : public Shape {
public:
    void describe() const {
        Shape::describe();              // call the base version explicitly
        cout << "...specifically a circle" << endl;
    }
};

int main() {
    Circle c;
    c.describe();
    return 0;
}

This is plain name hiding, not polymorphism: which describe() runs is decided at compile time by the static type of the variable. That's a critical limitation - if you call through a Shape& or Shape* that actually points at a Circle, you'll still get Shape::describe(). Fixing that requires virtual, which is the topic of the next page.

Watch Out for Object Slicing

Because a base reference or pointer can refer to a derived object, it's tempting to copy a derived object into a base-typed variable. Don't - the derived part gets sliced off.

#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
    string name = "?";
};

class Dog : public Animal {
public:
    string breed = "Labrador";
};

int main() {
    Dog d;
    d.name = "Rex";

    Animal a = d;   // SLICING: only the Animal part is copied
    cout << a.name << endl;   // Rex
    // a.breed is gone - it was never part of an Animal
    return 0;
}

a is a genuine Animal, not a Dog wearing a base label, so breed simply doesn't exist on it. To work with derived objects polymorphically you must use a base reference (Animal&) or pointer (Animal*), never a base value. Slicing is silent - it compiles cleanly and just quietly drops data - which makes it one of the easier inheritance bugs to ship.

Common Mistakes to Avoid

• Expecting private base members to be reachable in the child. They aren't. Use protected for data the derived class legitimately needs, and keep truly internal state private.
• Forgetting to forward base constructor arguments. If the base has no default constructor, you must call it explicitly in the derived constructor's initializer list (: Base(args)).
• Slicing a derived object into a base value. Copying a Dog into an Animal drops everything Dog-specific. Pass and store base references or pointers instead.
• Overusing inheritance for code reuse. Inheritance models "is-a." If the relationship is really "has-a" (a Car has an Engine), prefer composition - a member object - over inheriting.

Next: Virtual Functions

The override you just saw was resolved at compile time, so calling through a base pointer ignored the derived version. The next page, virtual-functions, introduces the virtual keyword and override - the mechanism that makes the runtime type decide which method runs, unlocking true polymorphism and explaining why base classes need virtual destructors.