C++ Upcasting and Downcasting Simplified

Inheritance allows us to treat derived class objects as base class objects. This capability forms the foundation of runtime polymorphism in C++. While working with inheritance, you will often come across the terms Upcasting and Downcasting.

Introduction

In this article, we'll understand what they mean, when they are useful, and why one is generally considered safer than the other. Let's start with a simple inheritance hierarchy.

#include <iostream>

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

    virtual ~Animal() = default;
};

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

    void FetchBall() {
        std::cout << "Fetching Ball" << std::endl;
    }
};

Example of Inheritance

What is Upcasting?

Upcasting means converting a derived class pointer or reference into a base class pointer or reference.

Dog dog;

Animal* animalPtr = &dog;

Here, a Dog* is converted into an Animal*. This conversion is safe and happens automatically.

int main()
{
    Dog dog;
    Animal* animalPtr = &dog;
    animalPtr->Speak();
}

Output:

Bark Bark

Even though the pointer type is Animal*, the actual object is still a Dog. Therefore, runtime polymorphism works as expected. Refer this article to understand more about C++ object mode.

Why is Upcasting Useful?

Upcasting allows us to write generic code. For example, a veterinary clinic may work with different animals.

void MakeAnimalSpeak(Animal* animal) {
    animal->Speak();
}

Now we can pass any derived object.

Dog dog;

MakeAnimalSpeak(&dog);

This flexibility is one of the key benefits of object-oriented programming.

What is Downcasting?

Downcasting occurs when you convert a base class pointer or reference back into a derived class pointer or reference. Because a base class object is not necessarily a derived class object (e.g., an Animal isn't always a Dog), this action is potentially dangerous and requires an explicit cast

Animal* animalPtr = new Dog();

Dog* dogPtr = static_cast<Dog*>(animalPtr);

Now dogPtr can access members specific to Dog.

dogPtr->FetchBall();

Output:

Fetching Ball

At first glance, this may seem perfectly fine. However, downcasting introduces risk.

The Problem with Downcasting

Consider the following example.

Animal animal;

Animal* animalPtr = &animal;

Dog* dogPtr = static_cast<Dog*>(animalPtr);

The compiler accepts this code. However, the object is actually an Animal, not a Dog.

Accessing dogPtr results in undefined behavior. The program may crash, appear to work, or produce unexpected results. This is one reason why many experienced C++ developers avoid unnecessary downcasting.

Safer Downcasting with dynamic_cast

If the base class contains at least one virtual function, we can use dynamic_cast.

Animal* animalPtr = new Dog();

Dog* dogPtr = dynamic_cast<Dog*>(animalPtr);

if (dogPtr) {
    dogPtr->FetchBall();
}

Output:

Fetching Ball

Now consider:

Animal animal;

Animal* animalPtr = &animal;

Dog* dogPtr = dynamic_cast<Dog*>(animalPtr);

In this case:

dogPtr == nullptr

The cast fails safely instead of producing undefined behavior. User can safely add nullptr check before proceeding with further actions.

Up/Down Casting and Object Slicing

Object slicing happens in C++ when you assign a derived (child) class object to a base (parent) class object by value instead of using a pointer or a reference.

When this happens, the compiler allocates only enough memory for the base class. The entire derived portion of the object is literally "sliced off" and discarded.

Object slicing is not a problem per se, since it's a perfectly well-defined operation. It's just that it normally raises a 'WTF' moment, because it's seldom intended.

How it impact? Lets try to use previous Animal example to visualized this. A generic Animal only requires enough memory to store its weight. A Dog inherits that weight field but expands the footprint to add a breed field.

[ Animal Memory Box ]
+-------------------+

| weight: 15 kg     |  <- Total Size: 4 bytes
+-------------------+

[ Dog Memory Box ]
+-------------------+

| weight: 15 kg     |  <- Inherited Base Part (4 bytes)
+-------------------+

| breed: "Beagle"   |  <- Extra Derived Part (8 bytes)
+-------------------+

Side effects of Object Slicing

Why Does Object Slicing Happen?

1. Value Semantics: In C++, variables hold a fixed size of memory determined at compile time. An instance of Animal only has enough bytes to store an Animal . It physically cannot fit the extra variables introduced by Dog.

2. Copy Constructor: When you write Animal normalAnimal = dog;, the compiler calls the Animal copy constructor. It passes the dog object into it. The constructor only knows how to copy Animal fields, leaving the rest behind.

For more detailed understanding refer to this article.

Summary Upcasting vs Downcasting

Feature	Upcasting	Downcasting
Direction	Derived → Base	Base → Derived
Safety	Safe	Potentially Unsafe
Automatic	Yes	No
Typical Usage	Very Common	Less Common
Runtime Check Needed	No	Usually Yes

Conclusion

• Upcasting converts a derived object into a base class type.

• Upcasting is safe and happens automatically.

• Runtime polymorphism relies heavily on upcasting.

• Downcasting converts a base class type into a derived class type.

• Incorrect downcasting can lead to undefined behavior.

• Prefer dynamic_cast when downcasting is unavoidable.

• If you find yourself downcasting frequently, it may be worth revisiting the design of your class hierarchy.

In day-to-day C++ development, upcasting is common and encouraged, while downcasting should generally be used with caution.