14 C++ Notes

Inheritance

C++ Notes

What Is Inheritance

One class inherits data members and member functions from another class.
The concept is similar to Java, but C++ gives more control, you can choose the inheritance type: public, protected, or private.
Private members of the parent are never directly accessible in the child. They exist inside the object but are hidden, you must go through public getters, or protected ones if you're inside a child class.

C++

class Person {
public:
    std::string name;
    int age;
};

class Player : public Person { // public inheritance
public:
    int score;
};

Protected Members

Inaccessible from outside the class, same as private.
Accessible inside the class itself, and accessible inside child classes.
Not accessible from main() or any unrelated class.
Protected is the middle ground between public and private, designed specifically for inheritance.

Inheritance Types

Parent Member	public inheritance	protected inheritance	private inheritance
public member	Stays public	Becomes protected	Becomes private
protected member	Stays protected	Stays protected	Becomes private
private member	Inaccessible in child	Inaccessible in child	Inaccessible in child

Private members of the parent are never directly accessible in the child, regardless of inheritance type. They exist inside the object in memory, but the language blocks all direct access to them.

Resurrecting Members with using

When using private inheritance, everything from the parent becomes private in the child.
You can selectively bring specific members back to a higher access level using the using keyword inside the desired access block.
This does not change the parent class. It only changes access inside the derived class.
using also brings in all overloads of a method, not just one.

C++

class Child : private Person {
protected:
    using Person::age;     // resurrect age as protected
    using Person::getAge;  // resurrect method (all overloads)
};

Object Building Order with Inheritance

When a child object is created, the parent part of the object must be built before the child part. This order is fixed by the compiler and cannot be changed.

Construction Order

Parent constructor runs first
Child constructor runs after

Destruction Order (reversed)

Child destructor runs first
Parent destructor runs after

Destructors are always called automatically in reverse order of construction. You never manually call a base destructor, the compiler handles it.

Constructors with Inheritance

The child constructor calls the parent constructor in its own initializer list.
The parent constructor runs completely before the child constructor body even begins.
All arguments needed by the parent are passed through the child constructor.

C++

class Parent {
protected:
    std::string name;
    int age;
public:
    Parent(std::string name, int age)
    {
        this->name = name;
        this->age  = age;
    }
};

class Child : public Parent {
    double salary;
public:
    Child(std::string name, int age, double salary)
        : Parent(name, age) // call base constructor in initializer list
    {
        this->salary = salary;
    }
};

// in main:
Child child("Hassan", 21, 50000);

Default Copy Constructor

If you write Class obj2(obj1);, C++ automatically generates a copy constructor that performs a member-wise copy.
Safe only when there are no raw pointers, no dynamic memory management, and no external resources like file handles.

Java Behavior	C++ Behavior
Objects always live on the heap. Copying a reference copies the reference, not the object. Both variables end up pointing to the same object, a shallow copy by default.	Objects can live on the stack or the heap. The default copy copies actual data member by member. If the object has a stack array, the copy gets its own separate array, no shared memory.

The default copy constructor works for heap objects too. Copying depends on the class definition, not on where the object lives. Copying a heap object: Class* obj2{ new Class(*obj1) };, note the dereference, you pass the object itself, not the pointer.

Custom Copy Constructor

Must accept a const reference to the same class as its parameter. Passing by value would cause infinite recursion, since copying the parameter would trigger the copy constructor again.
Use the initializer list to copy members and to pass the base part to the parent's copy constructor.
When you pass other (a child object) to Parent(other), the compiler is smart enough to use only the parent portion of the object. This is called slicing.

C++

class Child : public Parent {
    int y;
public:
    Child(int x, int y) : Parent(x), y(y) {}

    // custom copy constructor
    Child(const Child& other)
        : Parent(other), // slices and copies the base part
          y(other.y)      // copies child-specific members
    {
        // deep copy logic for raw pointers goes here if needed
    }
};

Inheriting Base Constructors

A child can inherit all constructors of the parent using using Parent::Parent; inside the child class.
The copy constructor is not inherited this way.
Inherited constructors only initialize the base part of the object. They know nothing about child-specific members.
Child members must either have default values or be initialized separately.
Inherited constructors keep the same access level they had in the parent.

C++

class Parent {
public:
    Parent(int x) { std::cout << "Parent constructor\n"; }
};

class Child : public Parent {
public:
    using Parent::Parent; // inherit all parent constructors
};

// in main:
Child obj(10); // calls Parent(int x) through inheritance

Use inherited constructors carefully. They only know about parent members, if the child has its own data members without default values, those will be left uninitialized.

Inheriting with Destructors

You never manually call a base destructor. The compiler calls it automatically, in the reverse order of construction, exactly as described above.
This happens automatically for both stack and heap objects. For heap objects, calling delete on the child triggers the whole chain.
If the base class destructor is not marked virtual, and you delete a child object through a base pointer, only the base destructor runs. The child destructor is skipped entirely, causing a resource leak.
Always mark the base class destructor virtual if you plan to use polymorphism or delete through a base pointer.

Forgetting virtual on the base destructor is one of the most common bugs in C++ inheritance. Given Person* p = new Player(...); followed by delete p;, without virtual ~Person() the Player destructor never runs. Any heap memory the Player allocated in its own constructor leaks permanently, with no error to warn you.

Reusing Names: Hiding vs Overriding

C++ allows a child class to define a member with the same name as a parent member.
Without virtual, this is called name hiding, not overriding. The child's version hides the parent's version entirely.
To call the parent version explicitly: from main(), use child.Parent::display();, from inside the child class, use Parent::display();.
If the function in the parent is marked virtual, then proper overriding happens instead, and polymorphism applies.

Code Example: main.cpp

C++

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

// ============================================================
// BASE CLASS
// ============================================================
class Person {
private:
    string ssn;          // private: NEVER directly accessible in child

protected:
    int age;             // protected: accessible in child class

public:
    string name;         // public: accessible everywhere

    Person(string name, int age, string ssn)
        : name(name), age(age), ssn(ssn)
    {
        cout << "Person constructor\n";
    }

    Person(const Person& other)
        : name(other.name), age(other.age), ssn(other.ssn)
    {
        cout << "Person copy constructor\n";
    }

    virtual ~Person() { cout << "Person destructor\n"; }

    int getAge() const { return age; }

    void display() const {
        cout << "Person: " << name << ", Age: " << age << endl;
    }
};

// ============================================================
// PUBLIC INHERITANCE
// ============================================================
class Player : public Person {
private:
    int score;

public:
    Player(string name, int age, string ssn, int score)
        : Person(name, age, ssn), score(score) // base constructor called first
    {
        cout << "Player constructor\n";
    }

    // custom copy constructor: base part copied via slicing
    Player(const Player& other)
        : Person(other), score(other.score)
    {
        cout << "Player copy constructor\n";
    }

    ~Player() { cout << "Player destructor\n"; }

    // name hiding (not virtual overriding)
    void display() const {
        cout << "Player: " << name
             << ", Age: "   << getAge()
             << ", Score: " << score << endl;
    }
};

// ============================================================
// PROTECTED INHERITANCE
// ============================================================
class ProtectedChild : protected Person {
public:
    ProtectedChild(string name, int age, string ssn)
        : Person(name, age, ssn) {}

    void show() {
        cout << "ProtectedChild name: " << name << endl; // name is now protected here
    }
};

// ============================================================
// PRIVATE INHERITANCE + USING (resurrecting members)
// ============================================================
class PrivateChild : private Person {
protected:
    using Person::age;    // resurrected as protected
    using Person::getAge; // resurrected method

public:
    PrivateChild(string name, int age, string ssn)
        : Person(name, age, ssn) {}

    void show() {
        cout << "PrivateChild age: " << getAge() << endl;
    }
};

// ============================================================
// INHERITING BASE CONSTRUCTORS VIA 'using'
// ============================================================
class SimpleBase {
public:
    SimpleBase(int x) {
        cout << "SimpleBase constructor with x = " << x << endl;
    }
};

class DerivedUsingCtor : public SimpleBase {
public:
    using SimpleBase::SimpleBase; // inherit all SimpleBase constructors
};

// ============================================================
// MAIN
// ============================================================
int main() {
    cout << "\n--- Object Construction Order ---\n";
    Player p1("Hassan", 21, "123-ABC", 100);
    // prints: Person constructor, then Player constructor

    cout << "\n--- Copy Constructor ---\n";
    Player p2 = p1; // calls Player copy constructor, which calls Person copy constructor

    cout << "\n--- Name Hiding ---\n";
    p1.display();           // calls Player::display() (child version)
    p1.Person::display();   // explicitly calls Person::display() (parent version)

    cout << "\n--- Protected Inheritance ---\n";
    ProtectedChild pc("Ali", 25, "456-DEF");
    pc.show();
    // pc.name;  ERROR: name became protected, not accessible from main

    cout << "\n--- Private Inheritance + using ---\n";
    PrivateChild pr("Sara", 30, "789-GHI");
    pr.show();
    // pr.name;  ERROR: private in this context

    cout << "\n--- Inheriting Constructors ---\n";
    DerivedUsingCtor obj(10); // calls SimpleBase(int) through inherited constructor

    cout << "\n--- Destruction Order (reversed, LIFO) ---\n";
    // obj, pr, pc, p2, p1 destroyed in reverse order as main ends
    // for each: child destructor first, then parent destructor

    return 0;
}

Closing

Access levels through inheritance, the fixed construction and destruction order, slicing in copy constructors, and the virtual destructor bug that catches almost everyone once. Last one left: polymorphism, where virtual stops being a footnote and becomes the whole point.