Base class pointers in C++

Introduction

Base class pointers let you use a pointer of a parent class to point to objects of child classes. This helps write flexible and reusable code.

When you want to store different child objects in the same pointer type.

When you want to call functions on objects without knowing their exact child type.

When you want to use polymorphism to decide which function runs at runtime.

When you want to write code that works with a family of related classes easily.

Syntax

C++

BaseClass *pointerName;
pointerName = &childObject;

The pointer is declared as the base class type.

It can point to any object of the base class or its derived classes.

Examples

A base class pointer points to a Dog object. It calls the base class version of speak because the function is not virtual.

C++

class Animal {
public:
    void speak() { std::cout << "Animal sound" << std::endl; }
};

class Dog : public Animal {
public:
    void speak() { std::cout << "Bark" << std::endl; }
};

int main() {
    Dog d;
    Animal *ptr = &d;
    ptr->speak();
    return 0;
}

Here, speak is virtual. The base class pointer calls Dog's speak because of polymorphism.

C++

class Animal {
public:
    virtual void speak() { std::cout << "Animal sound" << std::endl; }
};

class Dog : public Animal {
public:
    void speak() override { std::cout << "Bark" << std::endl; }
};

int main() {
    Dog d;
    Animal *ptr = &d;
    ptr->speak();
    return 0;
}

Sample Program

This program shows a base class pointer pointing to different child objects. It calls the correct speak function for each child thanks to virtual functions.

C++

#include <iostream>

class Animal {
public:
    virtual ~Animal() {}
    virtual void speak() {
        std::cout << "Animal sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Bark" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Dog dog;
    Cat cat;

    Animal *ptr;

    ptr = &dog;
    ptr->speak();  // Calls Dog's speak

    ptr = &cat;
    ptr->speak();  // Calls Cat's speak

    return 0;
}

Important Notes

Without virtual, the base class function is called even if the pointer points to a child object.

Base class pointers allow writing code that works with many child types easily.

Remember to use virtual destructors in base classes when using base class pointers to avoid memory issues.

Summary

Base class pointers can point to objects of derived classes.

They enable polymorphism when used with virtual functions.

This helps write flexible and reusable code that works with related classes.