Abstract Base Classes and Pure Virtual Functions

1. From Optional Overrides to a Mandatory Contract

Recall that a regular virtual function provides an implementation that derived classes can, but are not required to, override.

class Entity {
public:
    // A derived class CAN override this, but doesn't HAVE to.
    virtual std::string GetName() { return "Entity"; } 
};

But what if this default behavior is meaningless? What is the "name" of a generic Entity? It makes more sense to force specialized classes like Player or Enemy to provide their own names.

To do this, we declare the function as a pure virtual function. The syntax is to replace the function body with = 0;.

class Entity {
public:
    // This function MUST be implemented by a concrete derived class.
    virtual std::string GetName() = 0; 
};

Two crucial things happen when you add a pure virtual function to a class:

1. The function has no implementation in the base class.
2. The class itself becomes an abstract base class.

The most important consequence of a class being abstract is that you cannot create an instance of it. The compiler will stop you. An abstract class is an incomplete blueprint, intended only to be a base for other, more concrete classes.

Let's see this in action.

2. Interfaces in C++

Since you have experience with Java and TypeScript, you're likely familiar with the interface keyword. It's used to define a pure contract—a set of method signatures that a class promises to implement.

C++ does not have an interface keyword. Instead, the concept of an interface is a design pattern achieved using an abstract base class that (typically) contains only pure virtual functions and no data members.

The key idea is that we use an abstract class to define a "can-do" relationship. An object that inherits from a Drawable interface "can be drawn." An object inheriting from a Serializable interface "can be serialized." This is a powerful tool for designing flexible systems.

For another perspective, let's look at an example that might resonate with your interests in engineering and game development.

3. Fulfilling the Contract: Concrete Classes

If a class inherits from an abstract base class, it must provide implementations for all of the pure virtual functions it inherits. Once it does, it becomes a concrete class, and you can create instances of it.

What happens if the derived class fails to implement one of the pure virtual functions? The "abstract" property is inherited, and the derived class is also considered abstract.

This shows how the compiler enforces the contract. To be "concrete," you must fulfill all the promises made by your base classes.

Let's see this demonstrated.

4. A Powerful Use Case: Writing Generic, Decoupled Code

The real power of interfaces comes from writing code that operates on the abstract base type. This decouples the code that uses an object from the concrete implementation of that object.

A classic anti-pattern in programming is a long if-else-if chain that checks the type of an object and behaves differently for each type. This is fragile; when you add a new type, you have to find and update all these checks.

Abstract classes and pure virtual functions solve this elegantly.

By defining a fooBar() function in the Vehicle interface, the myCode function no longer needs to know about Cars or Trucks. It just needs to know that it has a list of Vehicles, and every Vehicle knows how to fooBar() itself. When you add a Motorcycle class later, the myCode function doesn't need to change at all.

This powerful idea allows you to build systems where components interact through well-defined contracts (interfaces), without needing to know about each other's internal details.

Conclusion

Today we've bridged the gap between optional polymorphism and enforced contracts. You've learned how to create abstract base classes that define what a derived class must do, a cornerstone of object-oriented design.

Key Takeaways:

• A pure virtual function is declared with = 0; and has no implementation in the base class.
• A class with one or more pure virtual functions becomes an abstract base class and cannot be instantiated directly.
• In C++, an interface is a design pattern, typically an abstract class consisting only of pure virtual functions.
• A derived class must override all inherited pure virtual functions to become a concrete class that can be instantiated.
• This mechanism allows you to define contracts and write generic code that is decoupled from concrete implementations, avoiding fragile type-checking.

Next Up

We've now built a solid foundation for creating and using polymorphic class hierarchies. Our generic code can work with a Vehicle* without knowing if it's a Car or a Truck. But what if, in a specific situation, we have a Vehicle* and we need to know if it's a Car so we can call a car-specific function (like retractRoof())? How can we safely check the object's true type?

In the next lesson, we will cover how to use dynamic_cast for safe downcasting in a polymorphic class hierarchy, giving you a tool to inspect the dynamic type of an object when necessary.