Design Pattern

One instance per process, global access point — widely considered an anti-pattern; covers Meyers singleton, thread safety, testability problems, and modern alternatives (DI, `std::call_once`, `inline` variable).

Defer instantiation to subclasses or callbacks — base defines the algorithm, derived (or a function) decides which concrete product to create; covers classic virtual form, modern `std::function`/template alternatives, and the distinction from a "static factory function".

Create families of related objects without naming concrete classes — one factory object per family variant; covers classic GoF form, modern template/policy alternatives, and the trade-off vs Factory Method.

Construct a complex object step by step, separating *what to build* from *how to assemble* — covers fluent interface with `std::move`, classic GoF director form, named-parameter idiom, and comparison with Abstract Factory.

Create new objects by cloning an existing instance — virtual `clone()` for polymorphic copy; covers deep vs shallow copy, prototype registries, copy-and-swap, and how `std::variant` + value semantics can replace it.

Wrap an incompatible interface so client code can talk to it through the interface it already expects — object-adapter via composition or class-adapter via multiple inheritance.

Decouple an abstraction hierarchy from its implementation hierarchy so the two can vary independently — composition instead of a combinatorial inheritance tree.

Treat individual objects and compositions of objects uniformly through a shared interface — recursive tree structure where leaves and containers respond to the same operations.

Attach responsibilities to an object dynamically by wrapping it in an object with the same interface — composition-based alternative to subclassing for behavior extension.

Provide a single, simplified interface to a complicated subsystem of classes — clients depend on the facade, not the subsystem's internals.

Share fine-grained immutable state across many objects to cut memory use — split intrinsic (shared) from extrinsic (per-instance) state and intern the intrinsic part.

Surrogate object exposing the same interface as a real subject to control access — used for lazy initialization, remote calls, permission checks, smart references, and caching.

Pass a request along a chain of handlers — each decides to handle or forward, decoupling sender from receiver and avoiding monolithic if/else dispatch.

Encapsulate a request as an object — enables parameterizing callers, queueing/logging requests, and supporting undo/redo.

Sequential access to elements of an aggregate without exposing its internal representation — in C++ the canonical iterator pattern is baked into the language via `begin`/`end`, range-based `for`, and C++20 ranges.

Centralize complex many-to-many interactions among components into a single mediator object, so components only talk to the mediator, not to each other.

Capture an object's internal state into an opaque token so it can be restored later, without exposing internals to outside code.

Define a one-to-many dependency so when a subject changes state, all dependents (observers) are notified automatically — the foundation of event-driven and reactive programming.

Object alters behavior when its internal state changes — looks like it changed class; encapsulates state-dependent code as separate objects with transitions wired between them.

Define a family of interchangeable algorithms, encapsulate each, and let the client pick or swap one at runtime via composition — algorithm varies independently of the code that uses it.

Define the skeleton of an algorithm in a base class, defer specific steps to subclasses — invert control so the base orchestrates and the subclass fills in the variable steps.

Separate an algorithm from the object structure it operates on by double dispatch — each element accepts a visitor and calls back the visit method matching its concrete type; lets you add operations without modifying the elements.

Define a grammar as a class hierarchy where each rule maps to a node, then walk the resulting AST to evaluate sentences in the language — useful for tiny DSLs; for anything non-trivial, use a parser generator instead.

A class derives from a template instantiated with itself (`class D : public Base<D>`), giving the base static access to the derived type — enables zero-overhead static polymorphism, mixins, and the Barton–Nackman trick.

Compose class behavior by passing orthogonal **policies** as template parameters that the host class inherits from — compile-time Strategy with zero runtime cost; popularized by Alexandrescu's *Modern C++ Design*.