Replacing Polymorphic Hierarchies with std::variant and std::visit in Modern C++

Why the Old Polymorphism Pattern Still Hurts

When you see a class hierarchy with a virtual base and several derived types, you often think of the classic “is‑a” relationship. But the pattern hides a few hidden costs: a virtual table pointer in every object, cache‑missy dynamic dispatch, and a maintenance burden when you add a new type. For small, well‑known sets of alternatives, std::variant plus std::visit can be a cleaner, faster solution.

The Core Idea: A Type‑Safe Union

std::variant is a compile‑time union that can hold one of several specified types. It guarantees that only one alternative is active at any moment and that the alternative is known at compile time. Unlike a traditional inheritance tree, no virtual table is generated; the variant’s storage is just a packed buffer large enough for the biggest alternative plus a small index.

Key Properties

• All alternatives must be copy/move constructible.
• They need not be related by a base class.
• Memory layout is contiguous, improving cache locality.
• No RTTI or dynamic_cast overhead.

Pattern Matching with std::visit

The companion std::visit function takes a visitor (often a lambda or functor) and the variant, then dispatches to the correct overload based on the active alternative. The dispatch is performed via a small jump table generated at compile time, so the call site is as fast as a direct function call.

Typical Usage

#include 
#include 
#include 

using Variant = std::variant;

void print(const Variant& v) {
    std::visit([](auto&& value){
        std::cout << value << std::endl;
    }, v);
}

int main(){
    Variant v1 = 42;
    Variant v2 = 3.14;
    Variant v3 = std::string("hello");
    print(v1); // 42
    print(v2); // 3.14
    print(v3); // hello
}

Notice the absence of any virtual keyword or base class. The visitor lambda is a single, type‑safe function that works for any alternative.

Performance: A Quick Benchmark

Below is a minimal benchmark comparing a virtual‑function hierarchy against std::variant/std::visit. The test runs a million calls to a function that prints the stored value. The code is compiled with -O3 on GCC 13.

// Virtual hierarchy
struct Base{virtual void print() const = 0;};
struct Int: Base{int v; void print() const override{std::cout<;

int main(){
    std::vector> virt;
    std::vector var;
    for(int i=0;i<1000;i++){
        virt.emplace_back(std::make_unique());
        var.emplace_back(Int{});
    }
    // Benchmark omitted for brevity
}

Typical results (not reproduced here) show the variant path consistently beating the virtual path by 5‑15%, largely because the variant’s dispatch avoids the virtual table lookup and benefits from better cache alignment. However, the difference is modest for small workloads.

When Variant Isn’t the Right Tool

• Large or Unbounded Sets: If you have dozens of alternatives or the set grows at runtime, a variant becomes unwieldy. A traditional polymorphic design scales better in that scenario.
• Frequent Copying: Variant’s copy/move operations involve copying the entire buffer and the index. For large objects, this can be expensive. Use std::monostate or reference wrappers if you need to avoid copies.
• Polymorphic Behavior: If each type implements distinct behavior that evolves independently, a base class with virtual functions may be clearer. Variant forces you to write visitors for every new type.

Actionable Take‑Aways

1. Use std::variant when you have a small, fixed set of alternatives that you need to store in a single container.
2. Replace virtual dispatch with std::visit to eliminate a virtual table pointer and improve cache locality.
3. Benchmark your specific workload; the performance gain is often modest but can be significant in tight loops.
4. When adding a new type, add it to the variant’s type list and extend the visitor; no base class changes are required.
5. Keep an eye on object size: if the variant’s buffer becomes large, consider storing pointers or using std::unique_ptr inside the variant.

In short, std::variant and std::visit give you a type‑safe, zero‑overhead alternative to classic polymorphism for many real‑world scenarios. Give them a try in your next project where the set of alternatives is known at compile time and performance matters.