Singleton

Learn to write a single-instance class with the Singleton pattern.

What is the Singleton pattern?

Singleton is a design pattern that ensures a class has only one instance during the whole program. This single instance is accessible from everywhere. It is common for logging, configuration or connection pools.

The cleanest way in C++ is the Meyers singleton: a method that returns a static local variable. The compiler guarantees a single instance and thread safety since C++11.

Writing the Meyers singleton

In the Meyers singleton you declare a static local variable inside the instance() method. The variable is created on the first call and the same object is returned afterwards. The constructor is made private so a second instance cannot be created with new from outside.

Example: static Singleton& instance() { static Singleton s; return s; }. The line static Singleton s; runs only once. private: Singleton() = default; blocks external construction. Copying is also disabled with = delete.

Exercise Write the Singleton class

Define a Singleton class. Add a static Singleton& instance() method under public that defines static Singleton s; and returns it. Make the constructor private. In main call instance() twice and compare their addresses; if equal print "Single instance".

Show example solution

#include <iostream>

class Singleton {
public:
    static Singleton& instance() {
        static Singleton s;
        return s;
    }
private:
    Singleton() = default;
};

int main() {
    auto& a = Singleton::instance();
    auto& b = Singleton::instance();
    std::cout << (&a == &b ? "Single instance" : "Many");
    return 0;
}

Test yourself

What does the Singleton pattern guarantee?
- The class runs faster
- All methods become static
- A single instance across the program
- Private members become public
Show answer

A single instance across the program — Singleton ensures only one instance of a class is created.

Complete the instance method

static Singleton& ____() {
        static Singleton s;
        return s;
    }

Show answer

static Singleton& instance() {
        static Singleton s;
        return s;
    }

Match each piece to its role

static Singleton& instance()

Returns single instance
private Singleton()

Blocks external construction
static local variable

Thread safe
Meyers singleton

Cleanest C++ way

Next lesson: Factory

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies