Skip to content

Latest commit

 

History

History
247 lines (213 loc) · 9.64 KB

README.md

File metadata and controls

247 lines (213 loc) · 9.64 KB

Singleton Pattern Examples in C++

A collection of minimal, self-contained C++ examples demonstrating multiple ways to implement the Singleton design pattern. The repository includes modern, thread-safe techniques (Meyer's Singleton) and legacy approaches (Double-Checked Locking) for comparison.

🔍 Overview

Example Initialization Storage duration Cleanup Thread-safe Initialization Notes
singleton-classic-example Eager Static Automatic Yes Can suffer from SIOF and static destruction order issues.
singleton-meyers-example Lazy Static Automatic Yes (since C++11) Avoids classic SIOF because the object is created on first use.

May still suffer from static destruction order issues during program shutdown.
singleton-classic-dynamic-example Lazy Dynamic Manual No Races may occur if multiple threads call getInstance() or delInstance() concurrently.

Manual lifetime management is error-prone.
singleton-cherno-example Lazy Dynamic Manual No Similar problems to singleton-classic-dynamic-example: manual cleanup, unsafe lifetime management and no thread safety.
singleton-dclp-example Lazy Dynamic Manual No Classic Double-Checked Locking Pattern (DCLP).

Historically unsafe because of data races and reordering issues.

Obsolete in modern C++.
singleton-leaky-example Lazy Dynamic None Yes (since C++11) Intentionally leaks memory to avoid shutdown-order problems.

Useful when destruction order is more dangerous than not deleting the instance.

1️⃣ singleton-classic-example

🔳 Singleton with a static member instance.

  • 🧩 Variable: Static member variable
  • 💾 Storage: Static storage duration
  • ⚡ Initialization: Eager → Created before main() starts
  • 🧼 Cleanup: Automatic → Destroyed after main() exits
  • 🔒 Thread safety: Construction is effectively safe because initialization happens before main() in a single-threaded context
  • ⚠️ Static Initialization Order Fiasco (SIOF):
    • If a static object in another translation unit accesses the singleton during its own initialization, the singleton may not be constructed yet.
  • ⚠️ Static Destruction Order Fiasco:
    • If a static object in another translation unit accesses the singleton during its own destruction, the singleton may already have been destroyed.

2️⃣ singleton-meyers-example

🔳 Meyer's Singleton → The simplest and safest modern C++ singleton implementation.

  • 🧩 Variable: Static local variable
  • 💾 Storage: Static storage duration
  • ⏳ Initialization: Lazy → Created only on first call to getInstance()
  • 🧼 Cleanup: Automatic → Destroyed after main() exits
  • 🔒 Thread safety: Initialization is thread-safe since C++11
    • A function-local static variable is initialized exactly once, even in a multi-threaded environment.
  • ✅ Fixes SIOF: Avoids the classic static initialization order problem because the object is created on first use.
  • ⚠️ Still vulnerable to Static Destruction Order Fiasco

3️⃣ singleton-classic-dynamic-example

🔳 Singleton with a static member pointer → Dynamically allocated on first use.

  • 🧩 Variable: Static member pointer
  • 💾 Storage: Dynamic storage duration
  • ⏳ Initialization: Lazy → Created only on first call to getInstance()
  • 🧹 Cleanup: Manual → Requires manual destruction via delInstance()
  • ⚠️ Thread safety: Not guaranteed
    • Two threads could call delInstance() simultaneously, or one calls getInstance() while another calls delInstance(), leading to a race on the pointer.
  • ⚠️ Manual lifetime management is error-prone
    • Because the singleton is destroyed explicitly via delInstance(), the program must ensure no code still uses the old instance after deletion.

4️⃣ singleton-cherno-example

🔳 Cherno-style Singleton — inspired by Why I don't like Singletons - Cherno

  • 🧩 Variable: Static global pointer
  • 💾 Storage: Dynamic storage duration
  • ⏳ Initialization: Lazy → Created only on first call to getInstance()
  • 🧹 Cleanup: Manual → Requires manual destruction via delInstance()
  • ⚠️ Thread safety: Not guaranteed, same as singleton-classic-dynamic-example
  • ⚠️ Manual lifetime management is error-prone → Same as singleton-classic-dynamic-example

5️⃣ singleton-dclp-example

🔳 Singleton with Double-Checked Locking Pattern (DCLP) → Classic, but unsafe lazy-initialization pattern.

  • 🧩 Variable: Static member pointer
  • 💾 Storage: Dynamic storage duration
  • ⏳ Initialization: Lazy → Created only on first call to getInstance()
  • 🧹 Cleanup: Manual → Requires manual destruction via delInstance()
  • ⚠️ Thread safety: Not guaranteed, suffers from data races and reordering issues.
  • ❌ DCLP is unreliable → Multiple threads may observe a partially constructed object.
  • ⛔ Largely obsolete since C++11 → Thread-safe function-local static initialization is the simpler and preferred modern solution.
  • 📖 Reference: C++ and the Perils of Double-Checked Locking by Scott Meyers and Andrei Alexandrescu

6️⃣ singleton-leaky-example

🔳 "Leaky" Singleton → A heap-allocated singleton initialized through a function-local static pointer.

  • 🧩 Variable: Static local pointer
  • 💾 Storage: Dynamic storage duration
  • ⏳ Initialization: Lazy → Created only on first call to getInstance()
  • 🧹 Cleanup: No cleanup, the object is intentionally never deleted.
    • The memory is intentionally left allocated until process termination.
    • In practice, the operating system reclaims the memory when the process exits.
  • 🔒 Thread safety: Initialization is thread-safe since C++11
    • The local static pointer initialization is still protected by C++11's thread-safe static init guarantee, so the new only fires once, safely.
  • ✅ Avoids both construction and destruction order problems
    • Because the object is created on first use, it avoids SIOF
    • Because it is never destroyed, it avoids static destruction order issues
  • ⚠️ Trade-off: intentionally leaks memory by design

⚙️ Prerequisites

Before building, ensure you have the following installed:

  • CMake (v3.20 or newer required for Presets)
  • C++ compiler supporting C++20 (required for syncstream)

🖥️ Windows - Visual Studio MSVC

  • Visual Studio 2022
  • Workload Required: Desktop development with C++
  • Note: The preset uses the Visual Studio 17 2022 generator.

🖥️ Windows - MinGW

  • MinGW-w64 Toolchain
  • Generator: Ninja

🐧 Linux

  • C++ Compiler (GCC/Clang)
  • Generator: Ninja

🏗️ Build Instructions

The commands below are executed from the root of the repository.

1. Configure Workspace (run once)

  • 🖥️ Windows (MSVC) → cmake --preset windows-msvc
  • 🖥️ Windows (GCC, Ninja) → cmake --preset windows-gcc-debug
  • 🖥️ Windows (Clang, Ninja) → cmake --preset windows-clang-debug
  • 🐧 Linux (GCC) → cmake --preset linux-gcc-debug
  • 🐧 Linux (Clang) → cmake --preset linux-clang-debug

Build All (debug)

  • 🖥️ Windows (MSVC) → cmake --build --preset windows-msvc-debug
  • 🖥️ Windows (GCC, Ninja) → cmake --build --preset windows-gcc-debug
  • 🖥️ Windows (Clang, Ninja) → cmake --build --preset windows-clang-debug
  • 🐧 Linux (GCC) → cmake --build --preset linux-gcc-debug
  • 🐧 Linux (Clang) → cmake --build --preset linux-clang-debug

Build Specific Project

cmake --build --preset <preset> --target <target_name>

Example:

cmake --build --preset linux-gcc-debug --target 02-singleton-meyers-example

🏃 Running Examples

🖥️ Windows (MSVC)

build/windows-msvc/02-singleton-meyers-example/Debug/02-singleton-meyers-example.exe

🖥️ Windows (GCC, Ninja)

build/windows-gcc-debug/02-singleton-meyers-example/02-singleton-meyers-example.exe

🖥️ Windows (Clang, Ninja)

build/windows-clang-debug/02-singleton-meyers-example/02-singleton-meyers-example.exe

🐧 Linux (GCC)

./build/linux-gcc-debug/02-singleton-meyers-example/02-singleton-meyers-example

🐧 Linux (Clang)

./build/linux-clang-debug/02-singleton-meyers-example/02-singleton-meyers-example