C++ Design Patterns — Static Init Fiasco & Pitfalls

Every large C++ codebase — game engines, trading systems, operating systems — is held together not just by algorithms but by structure. That structure comes from design patterns. When a new engineer joins the Unreal Engine team, they don't need to reverse-engineer why the rendering subsystem is built the way it is. The patterns make the intent obvious. That's the superpower patterns give you: code that communicates its own design decisions.

The problem patterns solve is accidental complexity — the kind that grows when you solve the same structural problem a dozen different ways across the same codebase. Without patterns, you end up with object creation scattered everywhere, tight coupling between subsystems that should never talk directly, and notification chains that are impossible to trace. Patterns give you a vocabulary and a discipline: a shared contract between you and every developer who reads your code in the future.

By the end of this article, you'll be able to implement the Gang of Four's most important patterns in modern C++ (C++17/20), understand the performance tradeoffs each one carries, recognise when a pattern is being abused, and walk into a senior engineering interview and explain not just how a pattern works but why it exists and when you'd reject it.

Why C++ Design Patterns Are a Minefield Without Static Initialization Order Awareness

Design patterns in C++ are reusable solutions to common software design problems, but they collide hard with the language's static initialization order fiasco. The core mechanic: when a pattern (e.g., Singleton, Factory) relies on a static or global object, its constructor runs before main() — and the order across translation units is undefined. This means one pattern's static dependency may access another's uninitialized memory, producing silent corruption or crashes.

In practice, this breaks patterns that assume deterministic startup. A Meyers Singleton (local static) is safe because the standard guarantees initialization on first use (C++11+). But a classic Singleton with a file-scope static pointer? That's a race with the linker. The key property: any pattern using non-local static objects across translation units is vulnerable. The fix is to defer initialization or use construct-on-first-use idioms.

Use this knowledge whenever your system has global state — logging, config registries, plugin loaders. In production, a factory pattern that registers types at static init time can fail silently if another translation unit's static map is still zero-initialized. The rule: never let a design pattern's static object depend on another static object's constructor having run. If you do, your 'pattern' is a time bomb.

Creational Patterns: The Factory Method

In large-scale C++ applications, hardcoding object creation using the new keyword creates tight coupling. If you decide to change the underlying class implementation, you have to hunt down every instance of new across your project. The Factory Method pattern provides an interface for creating objects in a superclass but allows subclasses to alter the type of objects that will be created.

In modern C++, we often pair this with std::unique_ptr to ensure exception safety and automatic memory management, adhering to RAII principles.

But here's the thing: a factory switch-based on an enum is a code smell in itself. It violates the Open/Closed principle because every time you add a new product, you must modify the factory switch. Better alternatives include a registry of factory functions keyed by string (or type index) that can be extended without modifying the factory class. In HFT systems, that table is often populated at startup via static initialisation of plugin modules.

#include <iostream>
#include <memory>
#include <string>

namespace io::thecodeforge::patterns {

// Abstract Product
class Logger {
public:
    virtual ~Logger() = default;
    virtual void log(const std::string& message) = 0;
};

// Concrete Product A
class ConsoleLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "[Console]: " << message << "\n";
    }
};

// Concrete Product B
class FileLogger : public Logger {
public:
    void log(const std::string& message) override {
        std::cout << "[File Simulation]: Writing to disk: " << message << "\n";
    }
};

// Factory Creator
class LoggerFactory {
public:
    enum class Type { Console, File };

    static std::unique_ptr<Logger> createLogger(Type type) {
        switch (type) {
            case Type::Console: return std::make_unique<ConsoleLogger>();
            case Type::File:    return std::make_unique<FileLogger>();
            default:            return nullptr;
        }
    }
};

}

int main() {
    using namespace io::thecodeforge::patterns;
    
    auto logger = LoggerFactory::createLogger(LoggerFactory::Type::Console);
    if (logger) {
        logger->log("The forge is lit! 🔥");
    }
    
    return 0;
}

Structural Patterns: The Strategy Pattern & Modern CRTP

While traditional Strategy patterns rely on virtual function calls (runtime polymorphism), C++ allows for 'Static Polymorphism' via the Curiously Recurring Template Pattern (CRTP). This avoids the overhead of a VTable lookup, making it a favorite in high-frequency trading (HFT) and game physics engines.

By passing the derived class as a template parameter to the base class, the compiler can resolve function calls at compile-time, allowing for aggressive inlining.

But static polymorphism locks your strategy at compile time. If you need to swap strategies based on a runtime config file or user input, CRTP won't work — you'll need the classic Strategy pattern with virtual functions. The decision tree is simple: if the strategy is known when you write the code (e.g., different validators for different input types that never change), use CRTP. If the strategy is chosen during runtime (e.g., a compression algorithm selected from a UI dropdown), use virtual dispatch. Mix both in a hybrid: use a small virtual interface over a CRTP implementation to get inlining where possible and runtime selection where needed.

#include <iostream>

namespace io::thecodeforge::performance {

// CRTP Base
template <typename Derived>
class Validator {
public:
    void validate() {
        // Static polymorphism: resolved at compile-time
        static_cast<Derived*>(this)->checkLogic();
    }
};

class EmailValidator : public Validator<EmailValidator> {
public:
    void checkLogic() {
        std::cout << "Validating email string format...\n";
    }
};

class PasswordValidator : public Validator<PasswordValidator> {
public:
    void checkLogic() {
        std::cout << "Validating password strength requirements...\n";
    }
};

}

int main() {
    using namespace io::thecodeforge::performance;

    EmailValidator ev;
    ev.validate();

    PasswordValidator pv;
    pv.validate();

    return 0;
}

Creational Patterns: Thread-Safe Singleton (Meyers Singleton)

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. In C++, the most robust implementation is the 'Meyers Singleton' (named after Scott Meyers), which uses a function-local static variable. Since C++11, the initialization of function-local static variables is guaranteed to be thread-safe by the standard — no mutexes or double-checked locking needed.

But Singleton is often overused. It introduces global state, making code tightly coupled and hard to test. Before applying it, ask: does this truly need to be a single instance? Often a dependency injection framework or a factory that creates one instance (and passes it around) is cleaner. For truly unique resources (hardware driver, logging system, global configuration), Singleton is acceptable, but always pair it with a unit-testing seam: allow replacing the instance via a setter in testing builds.

Be aware of the static initialization order fiasco when two Singletons depend on each other (see production incident above). Meyers Singleton is lazy and thread-safe, but if one Singleton's constructor calls another Singleton, you can still get into trouble. Break cyclical dependencies by using explicit initialization steps in main().

#include <iostream>
#include <mutex>

namespace io::thecodeforge::patterns {

class ConfigurationManager {
public:
    // Meyers Singleton: thread-safe since C++11
    static ConfigurationManager& instance() noexcept {
        static ConfigurationManager instance;
        return instance;
    }

    std::string getDatabaseUrl() const { return "jdbc:postgresql://prod-db:5432/forge"; }

    // Prevent copying and assignment
    ConfigurationManager(const ConfigurationManager&) = delete;
    ConfigurationManager& operator=(const ConfigurationManager&) = delete;

private:
    ConfigurationManager() = default;
    ~ConfigurationManager() = default;
};

}

int main() {
    using namespace io::thecodeforge::patterns;
    auto& config = ConfigurationManager::instance();
    std::cout << config.getDatabaseUrl() << "\n";
    return 0;
}

Behavioral Patterns: The Observer Pattern (with Weak Pointers)

The Observer pattern defines a one-to-many dependency between objects: when one object changes state, all its dependents are notified automatically. In C++, implementing a thread-safe Observer requires careful resource management.

The classic pitfall: storing raw pointers to observers and not notifying them after they're destroyed — causes dangling pointer crashes. The fix: store std::weak_ptr and lock before calling. Also protect the subscription list with a std::mutex because notification can happen from any thread.

Another consideration: the order of notification is undefined — never rely on it. And the notifier should not hold locks while calling observers (to avoid deadlocks). A common pattern is to copy the observer list under a lock, then iterate the copy outside the lock.

#include <iostream>
#include <memory>
#include <vector>
#include <mutex>
#include <algorithm>

namespace io::thecodeforge::patterns {

class Observer {
public:
    virtual ~Observer() = default;
    virtual void update(const std::string& message) = 0;
};

class Subject {
public:
    void subscribe(std::shared_ptr<Observer> obs) {
        std::lock_guard<std::mutex> lock(mtx_);
        observers_.push_back(obs);
    }

    void unsubscribe(std::shared_ptr<Observer> obs) {
        std::lock_guard<std::mutex> lock(mtx_);
        auto it = std::remove_if(observers_.begin(), observers_.end(),
            [&obs](const std::weak_ptr<Observer>& wp) {
                return wp.lock() == obs;
            });
        observers_.erase(it, observers_.end());
    }

    void notify(const std::string& msg) {
        // Copy list under lock, then iterate outside lock
        std::vector<std::weak_ptr<Observer>> copy;
        {
            std::lock_guard<std::mutex> lock(mtx_);
            copy = observers_;
        }
        for (auto& wp : copy) {
            if (auto sp = wp.lock()) {
                sp->update(msg);
            }
        }
        // Optional: prune expired weak_ptrs
        pruneExpired();
    }

private:
    void pruneExpired() {
        std::lock_guard<std::mutex> lock(mtx_);
        auto it = std::remove_if(observers_.begin(), observers_.end(),
            [](const std::weak_ptr<Observer>& wp) { return wp.expired(); });
        observers_.erase(it, observers_.end());
    }

    std::mutex mtx_;
    std::vector<std::weak_ptr<Observer>> observers_;
};

class ConcreteObserver : public Observer, public std::enable_shared_from_this<ConcreteObserver> {
public:
    void update(const std::string& msg) override {
        std::cout << "Observer received: " << msg << "\n";
    }
};

}

int main() {
    using namespace io::thecodeforge::patterns;
    Subject subject;
    auto obs = std::make_shared<ConcreteObserver>();
    subject.subscribe(obs);
    subject.notify("Hello from the forge!");
    obs.reset(); // observer destroyed
    subject.notify("This should not crash");
    return 0;
}

Creational Patterns: The Builder (Fluent Interface)

When a class requires many optional or interdependent parameters, constructor overloading becomes unmanageable. The Builder pattern separates the construction of a complex object from its representation, allowing the same construction process to create different representations.

In C++, a fluent Builder returns *this from setter methods, enabling method chaining. This is especially useful for configuration objects, database connections, or HTTP request builders. C++20 introduced designated initializers which can partially replace Builder for simple cases, but for validation and interdependent parameters, Builder is still the right tool.

One production gotcha: Builders often perform validation in their build() method. If validation fails, they can return an std::optional or throw. Never leave the object in a partially constructed state. Another trap: Builders that own raw pointers instead of smart pointers — always store the final object in a std::unique_ptr or return by value if the object is movable.

#include <iostream>
#include <string>
#include <optional>

namespace io::thecodeforge::patterns {

class DatabaseConfig {
public:
    std::string host;
    int port;
    std::string username;
    std::string password;
    bool useSSL;
    int poolSize;

private:
    // Private constructor so only Builder can create
    DatabaseConfig() = default;

    friend class DatabaseConfigBuilder;
};

class DatabaseConfigBuilder {
public:
    DatabaseConfigBuilder() : config_(std::make_unique<DatabaseConfig>()) {}

    DatabaseConfigBuilder& setHost(const std::string& h) {
        config_->host = h;
        return *this;
    }
    DatabaseConfigBuilder& setPort(int p) {
        config_->port = p;
        return *this;
    }
    DatabaseConfigBuilder& setUsername(const std::string& u) {
        config_->username = u;
        return *this;
    }
    DatabaseConfigBuilder& setPassword(const std::string& pw) {
        config_->password = pw;
        return *this;
    }
    DatabaseConfigBuilder& setSSL(bool ssl) {
        config_->useSSL = ssl;
        return *this;
    }
    DatabaseConfigBuilder& setPoolSize(int size) {
        config_->poolSize = size;
        return *this;
    }

    // Build and validate
    std::optional<DatabaseConfig> build() {
        if (config_->host.empty()) {
            std::cerr << "Error: host is required\n";
            return std::nullopt;
        }
        if (config_->port <= 0) {
            config_->port = 5432; // default
        }
        if (config_->poolSize <= 0) {
            config_->poolSize = 10;
        }
        // Return by move, then we reset config
        auto result = std::move(*config_);
        config_ = std::make_unique<DatabaseConfig>();
        return result;
    }

private:
    std::unique_ptr<DatabaseConfig> config_;
};

}

int main() {
    using namespace io::thecodeforge::patterns;
    auto maybeConfig = DatabaseConfigBuilder()
        .setHost("prod-db.example.com")
        .setPort(5432)
        .setUsername("admin")
        .setSSL(true)
        .setPoolSize(20)
        .build();

    if (maybeConfig) {
        auto& cfg = *maybeConfig;
        std::cout << "Connecting to " << cfg.host << ":" << cfg.port << "\n";
    }
    return 0;
}

Structural Patterns: The Adapter (And Why Wrapping Legacy DLLs Will Haunt You)

The Adapter pattern is how you make a square peg fit a round hole without rewriting the peg factory. You wrap an interface your code expects around an interface some legacy system actually exposes. Sounds clean. Until the legacy system is a C-style DLL with raw pointers, manual memory management, and zero exception safety.

Every call through the adapter becomes a potential crash site. The legacy code throws nothing. Your modern C++ code expects RAII and exceptions. So you wrap each call in try-catch blocks that translate error codes into exceptions, pray you don't leak when a callback fires mid-translation, and write integration tests that mock the DLL because you can't run it on your dev machine.

The real problem is not the adapter itself — it's assuming adapters are a one-line static_cast. They're not. Each adapter is a contract negotiation between two error handling philosophies. Document the failure modes. Assert preconditions at the boundary. And never, ever let a legacy pointer escape into modern code without an ownership wrapper.

// io.thecodeforge — c-cpp tutorial

#include <memory>
#include <stdexcept>

// Legacy C API — no exceptions, returns error codes
extern "C" int camera_open(const char* path, void** handle);
extern "C" int camera_capture(void* handle, unsigned char* buf, int* size);
extern "C" void camera_close(void* handle);

// Modern C++ interface
class Camera {
public:
    virtual ~Camera() = default;
    virtual std::vector<unsigned char> CaptureFrame() = 0;
};

class LegacyCameraAdapter final : public Camera {
    struct Deleter { void operator()(void* h) { camera_close(h); } };
    std::unique_ptr<void, Deleter> handle_;

public:
    explicit LegacyCameraAdapter(const char* path) {
        void* raw = nullptr;
        if (camera_open(path, &raw) != 0)
            throw std::runtime_error("camera_open failed");
        handle_.reset(raw);
    }

    std::vector<unsigned char> CaptureFrame() override {
        std::vector<unsigned char> buf(4096);
        int size = 0;
        int rc = camera_capture(handle_.get(), buf.data(), &size);
        if (rc != 0)
            throw std::runtime_error("camera_capture error: " + std::to_string(rc));
        buf.resize(size);
        return buf;
    }
};

Creational Patterns: Abstract Factory (The Mother Of All Constructors)

The Abstract Factory is what you reach for when your code needs to create families of related objects — think UI widgets that must match an OS theme, or game objects that need to be consistent within a level. One factory for Windows buttons and scrollbars, another for macOS. The caller never touches a concrete class.

In C++, the classic implementation is a virtual base factory with a virtual destructor, then concrete factories that new up objects. Works. But here's the C++ twist: if your factory returns std::unique_ptr or raw pointers, you've committed to heap allocation even when stack allocation would be faster. For embedded or latency-sensitive paths, that's a non-starter.

Modern C++ fix: make the factory a template policy parameter. The caller decides allocation strategy at compile time. The abstract factory becomes a concept, not a base class. You lose runtime polymorphism but gain zero-cost abstraction and the ability to allocate from a pool. For most server code? The virtual factory is fine. For a game engine? The virtual dispatch alone will cost you a cache miss per frame.

The real insight: ask yourself if you need runtime variation at all. If you compile per platform, an Abstract Factory is overkill. #ifdef the concrete types. If you need runtime switching (e.g. a config file changes the theme), use the factory. Know the cost of your abstraction before you abstract.

// io.thecodeforge — c-cpp tutorial

#include <memory>

// Abstract product interfaces
struct Weapon { virtual ~Weapon() = default; virtual int Damage() = 0; };
struct Armor  { virtual ~Armor() = default; virtual int Defense() = 0; };

// Abstract factory interface
class CharacterFactory {
public:
    virtual ~CharacterFactory() = default;
    virtual std::unique_ptr<Weapon> CreateSword() = 0;
    virtual std::unique_ptr<Armor>  CreateShield() = 0;
};

// Concrete factory for Orc faction
class OrcFactory : public CharacterFactory {
public:
    std::unique_ptr<Weapon> CreateSword() override {
        struct OrcSword : Weapon { int Damage() override { return 15; } };
        return std::make_unique<OrcSword>();
    }
    std::unique_ptr<Armor> CreateShield() override {
        struct OrcShield : Armor { int Defense() override { return 8; } };
        return std::make_unique<OrcShield>();
    }
};

// Client — no concrete classes mentioned
void EquipPlayer(CharacterFactory& factory) {
    auto sword = factory.CreateSword();
    auto shield = factory.CreateShield();
    // Use them...
}

Structural Patterns: The Bridge (Pimpl Is Not Just For Hiding Headers)

The Bridge pattern decouples an abstraction from its implementation so they can vary independently. In C++, that's exactly what the Pointer-to-Implementation (Pimpl) idiom does. But Pimpl is usually sold as a compilation firewall — hide the private members, reduce rebuild times. The Bridge is deeper: it lets you swap implementations at runtime without touching the abstraction's interface.

Real example: a cross-platform graphics API. Your Renderer abstraction holds a unique_ptr<RendererImpl>. On Windows, RendererImpl calls DirectX. On Linux, it calls Vulkan. The client code never includes a single platform header. Write the abstraction once. Swap the backend per platform or even per config.

The C++ trap: people make the Bridge too fat. Every method on the abstraction adds a virtual call through the impl pointer. For a renderer with DrawTriangle, SetTexture, ClearScreen — fine. For a renderer with 200 methods? You've created a slow fat interface that changes every week. Keep the bridge thin. Five to ten methods max. If your impl needs 200, your abstraction is wrong — break it into multiple bridges (e.g. TextureManager, ShaderCompiler).

Second trap: the Bridge tempts you to pass non-trivial state through the impl pointer every call. Cache state in the abstraction layer. The impl should be stateless or nearly stateless. Otherwise you're just doing slow delegation with extra steps.

// io.thecodeforge — c-cpp tutorial

#include <memory>

// Forward declare platform-specific renderer
class RendererImpl;

class Renderer {
    std::unique_ptr<RendererImpl> impl_;
public:
    Renderer();                          // picks backend at runtime
    ~Renderer();                         // destructor visible, impl in .cpp

    void DrawTriangle(float x1, float y1, float x2, float y2, float x3, float y3);
    void SetTexture(int id);
    void ClearScreen();
};

// In the .cpp file:
// #include "VulkanRenderer.h" or #include "DirectXRenderer.h"
// class RendererImpl {
// public:
//     virtual ~RendererImpl() = default;
//     virtual void Draw(float x1, float y1, float x2, float y2, float x3, float y3) = 0;
//     virtual void BindTexture(int id) = 0;
//     virtual void Clear() = 0;
// };
// class VulkanRenderer : public RendererImpl { /* ... */ };
// Renderer::Renderer() : impl_(std::make_unique<VulkanRenderer>()) {}

The Catalog of C++ Examples

A design pattern catalog transforms abstract theory into executable proof. For C++ developers, each example must expose the language-specific pitfalls that differentiate a working pattern from a silently broken one. Start with Creational patterns: the Factory Method reveals how virtual constructors interact with static storage duration; the Builder demonstrates why move semantics are non-negotiable for fluent interfaces; and the Abstract Factory exposes the constructor explosion when template parameters replace runtime dispatch. Structural patterns demand attention to memory layout: the Adapter wrapping a legacy DLL forces explicit lifetime management via RAII, while the Bridge (Pimpl) hides compilation dependencies but risks double indirection overhead. Behavioral patterns test ownership semantics: the Observer with weak pointers eliminates cyclic references, and the Strategy via CRTP avoids virtual table costs at the expense of compile-time coupling. Each example in the catalog should compile under C++17 or later, include a single main() demonstrating the pattern's invariant, and embed a static_assert or assertion to validate correctness. The goal is not exhaustive coverage but canonical implementations that survive code review and production hardening.

// io.thecodeforge — c-cpp tutorial
#include <memory>
#include <vector>
struct Observer {
    virtual void update(int) = 0;
    virtual ~Observer() = default;
};
struct Subject {
    void attach(std::weak_ptr<Observer> w) { obs.push_back(w); }
    void notify(int v) {
        for (auto& w : obs) {
            if (auto s = w.lock()) s->update(v);
        }
    }
    std::vector<std::weak_ptr<Observer>> obs;
};
struct Display : Observer {
    void update(int v) override { latest = v; }
    int latest = 0;
};
int main() {
    auto s = std::make_shared<Display>();
    Subject sub;
    sub.attach(s);
    sub.notify(42);
    return s->latest == 42 ? 0 : 1;
}

Conclusion

Design patterns in C++ are not abstract ideals — they are survival tools against the language's sharp edges. This series exposed the hidden costs: static initialization order in Factory Methods, virtual table bloat in classic Strategy, and reference cycles in Observer. The modern C++ answer is not to abandon patterns but to reforge them with RAII, templates, and the Standard Library. Move semantics transform Builder from a verb into a zero-cost abstraction; CRTP replaces runtime polymorphism in Strategy without heap allocation; and Meyers Singleton eliminates thread-safety worries via local static initialization. Yet patterns remain traps without rigorous ownership semantics — every shared_ptr in an Abstract Factory is a decision, every weak_ptr in an Observer is a promise broken safely. The final lesson: never cargo-cult a pattern from Java or Go. C++ demands that you trace the destructor path before writing the constructor. As you build your own catalog of patterns, write the failure case first: the dangling pointer, the static initialization bomb, the infinite callback recursion. Only then does the pattern earn its place in production code. The code below encapsulates this philosophy: a self-verifying observer that proves ownership correctness at compile time.

// io.thecodeforge — c-cpp tutorial
#include <memory>
#include <cassert>
struct SafePattern {
    virtual ~SafePattern() = default;
    virtual bool validate() const = 0;
};
struct FinalPattern final : SafePattern {
    bool validate() const override { return true; }
};
int main() {
    auto p = std::make_unique<FinalPattern>();
    assert(p->validate());
    return 0;
}

Strategy Pattern Context Object — Stop Mixing Algorithm Choice With Execution State

Most C++ Strategy Pattern tutorials glom the algorithm selector right into the context, so your context is both deciding which strategy to use AND holding data. That's a mess when you want unit tests, dynamic swapping, or serialization. The fix: a dedicated Context Object that stores state (input, output, config) independently from the Strategy selection logic. The context becomes a dumb holder — no if-else, no strategy instantiation. You pass a strategy reference into its methods, or inject via setter. Now you can reuse the same context across different strategies without reallocating. The strategy selection logic lives in a separate factory or in the caller, decoupling choice from execution. Your code survives changing requirements because state isn't tangled with decision making. Plus, you can mock strategies in tests without touching the context's internal guts. This pattern is especially brutal when your state includes resource handles — don't let strategy choice own cleanup.

// io.thecodeforge — c-cpp tutorial

#include <memory>

struct Strategy {
    virtual ~Strategy() = default;
    virtual int execute(int) = 0;
};

struct Context {
    int state{0};
    int apply(Strategy& s) { return s.execute(state); }
};

struct DoubleStrategy : Strategy {
    int execute(int v) override { return v * 2; }
};

struct TripleStrategy : Strategy {
    int execute(int v) override { return v * 3; }
};

// Usage: strategy selection outside context
// Context ctx{5}; ctx.apply(DoubleStrategy{}); // 10
// Context ctx{5}; ctx.apply(TripleStrategy{}); // 15

Modern Singleton: Meyers Singleton vs std::call_once

The Meyers Singleton, implemented via a local static variable, is the simplest and most efficient thread-safe singleton in C++11 and later. It relies on the guarantee that static local variables are initialized exactly once, even in multithreaded contexts. However, it has limitations: you cannot control the initialization order relative to other static objects, and the singleton's destructor runs at program exit, which may cause issues if other static objects depend on it. An alternative is using std::call_once with a std::once_flag to explicitly control initialization. This approach allows you to initialize the singleton on demand with more flexibility, such as passing arguments or handling errors. The trade-off is slightly more code and a potential performance cost due to the flag check. In practice, prefer the Meyers Singleton for most cases unless you need fine-grained control over initialization or destruction order. Note that both patterns avoid the static initialization order fiasco by deferring initialization to first use.

#include <mutex>
#include <memory>

// Meyers Singleton (C++11 thread-safe)
class MeyersSingleton {
public:
    static MeyersSingleton& instance() {
        static MeyersSingleton inst;
        return inst;
    }
    void doSomething() { /* ... */ }
private:
    MeyersSingleton() = default;
    ~MeyersSingleton() = default;
    MeyersSingleton(const MeyersSingleton&) = delete;
    MeyersSingleton& operator=(const MeyersSingleton&) = delete;
};

// std::call_once Singleton
class CallOnceSingleton {
public:
    static CallOnceSingleton& instance() {
        std::call_once(initFlag, []() {
            instancePtr.reset(new CallOnceSingleton());
        });
        return *instancePtr;
    }
    void doSomething() { /* ... */ }
private:
    CallOnceSingleton() = default;
    ~CallOnceSingleton() = default;
    CallOnceSingleton(const CallOnceSingleton&) = delete;
    CallOnceSingleton& operator=(const CallOnceSingleton&) = delete;
    static std::unique_ptr<CallOnceSingleton> instancePtr;
    static std::once_flag initFlag;
};

std::unique_ptr<CallOnceSingleton> CallOnceSingleton::instancePtr;
std::once_flag CallOnceSingleton::initFlag;

Visitor Pattern with std::variant and std::visit

The classic Visitor pattern requires double dispatch and often leads to complex class hierarchies. In modern C++, std::variant combined with std::visit provides a simpler, more efficient alternative. Instead of defining a visitor interface and accept methods, you define a variant type that can hold any of the types you want to visit, and then use std::visit with a callable (e.g., a lambda or a struct with overloaded operator()). This eliminates the need for virtual functions and reduces boilerplate. The variant-based approach is type-safe, avoids inheritance, and often performs better due to static dispatch. However, it requires all types to be known at compile time and cannot be extended with new types without modifying the variant definition. Use this pattern when you have a fixed set of types and need to perform operations that vary per type. It's particularly useful in compilers, parsers, and state machines.

#include <variant>
#include <iostream>
#include <string>

// Types to visit
struct Circle { double radius; };
struct Rectangle { double width, height; };
struct Triangle { double base, height; };

// Variant type
using Shape = std::variant<Circle, Rectangle, Triangle>;

// Visitor via lambda with overloaded pattern
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

double area(const Shape& shape) {
    return std::visit(overloaded{
        [](const Circle& c) { return 3.14159 * c.radius * c.radius; },
        [](const Rectangle& r) { return r.width * r.height; },
        [](const Triangle& t) { return 0.5 * t.base * t.height; }
    }, shape);
}

int main() {
    Shape s = Circle{5.0};
    std::cout << "Area: " << area(s) << '\n';
    return 0;
}

Factory Pattern with unique_ptr and make_unique

The Factory pattern decouples object creation from its usage. In modern C++, using std::unique_ptr and std::make_unique is the recommended approach. The factory returns a std::unique_ptr to a base class, ensuring proper memory management and exception safety. std::make_unique (C++14) constructs the object and returns a unique pointer in one step, avoiding potential leaks if an exception is thrown. This pattern is especially useful when the concrete type is determined at runtime, such as in plugin architectures or when parsing configuration files. The factory can be a simple function or a class with a virtual method. For example, a ShapeFactory might create Circle, Rectangle, or Triangle objects based on a string parameter. The use of unique_ptr makes ownership clear and prevents resource leaks. If shared ownership is needed, use std::shared_ptr and std::make_shared instead.

#include <memory>
#include <string>
#include <iostream>

// Base class
class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};

// Concrete classes
class Circle : public Shape {
public:
    void draw() const override { std::cout << "Drawing Circle\n"; }
};

class Rectangle : public Shape {
public:
    void draw() const override { std::cout << "Drawing Rectangle\n"; }
};

// Factory function
std::unique_ptr<Shape> createShape(const std::string& type) {
    if (type == "circle") return std::make_unique<Circle>();
    if (type == "rectangle") return std::make_unique<Rectangle>();
    return nullptr;
}

int main() {
    auto shape = createShape("circle");
    if (shape) shape->draw();
    return 0;
}