The Cost of Virtual Functions

Most of us reach for virtual functions the moment we need polymorphism. It's the standard approach: define a base class, mark a few methods as virtual, and let the vtable handle the dispatch at runtime. But in high-performance systems—think game engines, high-frequency trading, or embedded drivers—that tiny overhead of a pointer indirection and the loss of compiler inlining can actually add up to a measurable performance hit.

I've spent years optimizing tight loops where a virtual call inside a million-iteration cycle was the primary bottleneck. The solution isn't to abandon polymorphism, but to shift it from runtime to compile-time. This is where the Curiously Recurring Template Pattern (CRTP) becomes an essential tool in your kit.

What is CRTP?

CRTP is a design pattern where a class Derived inherits from a template class Base, using Derived itself as the template argument. It looks a bit strange at first glance, but it allows the base class to call methods in the derived class without using virtual functions.

template <typename Derived>
class Base {
public:
    void interface() {
        // Cast this to the derived type to access its implementation
        static_cast<Derived*>(this)->implementation();
    }

    // A default implementation if the derived class doesn't provide one
    void implementation() {
        // Default behavior
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() {
        // Specific behavior for Derived
    }
};

Real-World Scenario: A High-Performance Logger

Imagine you're building a logging framework. You want different backends (Console, File, Network) but you can't afford the overhead of a virtual function call every time a log() message is sent, especially when logging thousands of events per second.

By using CRTP, the compiler knows exactly which write() method to call at compile time, allowing it to inline the code entirely. Here is how I would implement this in a production environment:

#include <iostream>
#include <string_view>
#include <vector>

// The CRTP Base class
template <typename Implementation>
class LoggerBase {
public:
    void log(std::string_view message) {
        // Static polymorphism: resolved at compile time
        static_cast<Implementation*>(this)->write(message);
    }

protected:
    // Ensures only classes inheriting from LoggerBase can use this
    LoggerBase() = default;
};

// Console implementation
class ConsoleLogger : public LoggerBase<ConsoleLogger> {
public:
    void write(std::string_view message) {
        std::cout < "[Console] " < message < "\n";
    }
};

// File implementation (mock)
class FileLogger : public LoggerBase<FileLogger> {
public:
    void write(std::string_view message) {
        // Imagine actual file I/O here
        std::cout < "[File] Writing to disk: " < message < "\n";
    }
};

// A helper function to demonstrate usage
template <typename T>
void execute_log(LoggerBase<T>& logger, std::string_view msg) {
    logger.log(msg);
}

int main() {
    ConsoleLogger console;
    FileLogger file;

    execute_log(console, "System initialized");
    execute_log(file, "Database connection established");

    return 0;
}

Why This Matters

The magic here is that static_cast<Implementation*>(this) tells the compiler: "I know for a fact that this object is of type Implementation." Because this is resolved during compilation, the compiler can see through the call and potentially inline the write() method directly into the log() method.

Pro Tip: While CRTP is powerful, remember that it creates a different base class for every derived class (e.g., Base<DerivedA> and Base<DerivedB> are entirely unrelated types). You cannot store them in a std::vector<Base*> like you can with traditional inheritance.

Trade-offs and Considerations

  • Binary Size: Because you are using templates, the compiler generates a new version of the base class for every derived type. In most cases, the performance gain outweighs the slight increase in binary size.
  • Complexity: It's more visually complex than a simple virtual keyword. Use it where performance is a requirement, not just because it feels "clever."
  • Type Safety: If you accidentally inherit class Wrong : public Base<Right>, you'll get an undefined behavior crash during the static_cast. In C++20, you can mitigate this using concepts to enforce that the template argument inherits from the base.

When you stop thinking about polymorphism as a runtime feature and start treating it as a compile-time architectural choice, your C++ code becomes significantly more efficient. CRTP is one of the most reliable ways to achieve that shift.