Singleton pattern

As explained in Object-Oriented Software Design in C++

The Singleton design pattern is a creational design pattern that restricts a class to one instance and provides a controlled access point to it.

The Singleton pattern models a class for which an application may have at most one object. It also provides a controlled access point to that object. A printer spooler or a single stadium executive pass illustrates the requirement: every request reaches the same object. section 14.0 section 14.1

A sound singleton design must:

• Provide an access operation that always returns the same object. section 14.1.1
• Create the object automatically when first requested, rather than requiring the application to create it. section 14.1.1
• Avoid creating the object when it is never requested. section 14.1.1
• Prevent copying so assignment and the copy constructor cannot produce additional instances. section 14.1.3

Refactoring ExecutivePass

A global ExecutivePass seems simple, but callers can copy it, producing independent passes with different keys. Global state also permits unexpected changes, creates order-of-initialization problems, and keeps the pass alive even when unused. Refactor it by making the constructor private, deleting the copy constructor and copy assignment operator, and storing the sole pointer in a private static member. A public static obtain(holder) function creates the object when the pointer is nullptr, updates its holder, and returns it. Deleting the object resets the pointer, allowing later creation. Ron and Sal therefore receive the same key; after deletion, Bob and Flo share a newly created key. section 14.1.2 section 14.1.3

The generic structure replaces ExecutivePass with Singleton, single_instance with singleton, obtain() with get_singleton(), and application-specific data and operations with generic members. The pattern controls construction and copying, but its check-then-create operation needs extra care in multithreaded programs: simultaneous callers can create multiple objects. section 14.1.4 section 14.4

Figure 14.2 A well-designed singleton object. The constructor is private. The copy constructor and the copy assignment operator are both disabled. The static private member variable single_instance points to the singleton object, and the static public member function obtain() returns the value of the pointer.

Use the class diagram to see how the private constructor, disabled copy operations, static instance pointer, and public access function enforce the design. section 14.1.3

How Object-Oriented Software Design in C++ covers it

How deep it goes

Explains construction, copying, lazy creation, deletion, and multithreading risks, but defers race-condition solutions.

Examples

Demonstrates printer spooling, a stadium executive pass, global copies, and repeated obtain-delete-obtain calls.

What it assumes

Assumes basic classes, constructors, pointers, static members, and C++ copy operations; teaches singleton structure through refactoring.

What you can do after

Build a C++ singleton with private construction, disabled copying, lazy creation, static access, and deletion-aware reuse.

How it connects

Connects singleton objects with global variables, lazy construction, copy constructors, copy assignment, multithreading, and race conditions.

liveBookmanning.com

Read Object-Oriented Software Design in C++ on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  ASP.NET Core in Action, 3eA singleton pattern is a creational design pattern that ensures a service or object has one shared instance for the relevant application lifetime.
• 

  liveBookmanning.com
  Infrastructure as Code, Patterns and Practices: With examples in Python and TerraformA singleton pattern is a design pattern in which a resource or set of resources has one authoritative instance within a system.
• 

  liveBookmanning.com
  Machine Learning Platform EngineeringThe singleton pattern restricts a component to one shared instance and provides a common access point to it.
• 

  liveBookmanning.com
  Software Design for Python ProgrammersThe Singleton Design Pattern is a creational design pattern that restricts a class to at most one object instance and provides access to that instance.
• 

  liveBookmanning.com
  AI-Powered Developer: Build software with ChatGPT and CopilotThe Singleton Pattern is a software design pattern that restricts a class to one instance and provides a global access point to it.

Compare how 6 books explain Singleton pattern →

Related concepts

• design patternkind of · A design pattern is a reusable, general solution structure for a recurring software design problem in a particular context.
• static fielduses · A named variable whose storage is associated with a class or has static duration, rather than being allocated separately for each object instance or function call.
• lazy initializationuses · Lazy initialization is a technique that postpones creating, retrieving, computing, or loading a value or resource until it is needed.
• AddSingletonconfigured by · AddSingleton is an ASP.NET Core dependency-injection registration method that reuses one service instance for the application's lifetime.
• global variablecontrasts with · A global variable is a variable whose binding is accessible from broad program or module scope according to the language’s name-resolution rules.
• object declarationproduced by · An object declaration is a Kotlin declaration that defines a singleton object and creates its sole instance as part of the declaration.

This explainer was generated by Manning's knowledge graph from the text of Object-Oriented Software Design in C++. The section links point to the parts of the book it draws on.