Singleton

Intent

Ensures a class has only one instance and provides a global access point to it.

Problem

Several parts of the app need the same configuration or connection pool, and creating duplicates is wasteful or wrong.

Solution

Make the constructor private and expose a static method that creates the instance once and returns it afterwards.

Real-world analogy

Structure

Hover or tap a numbered role to highlight it in the diagram.

1. 1Singleton — Singleton keeps a private static instance and a private constructor, so nobody else can create it.
2. 2Singleton — getInstance() creates the instance on the first call and returns the same one afterwards.
3. 3ClientA — Clients call getInstance() and always receive the same object.

Try it

Code example

class Config {
public:
    static Config& instance() {
        static Config inst;   // initialised once, thread-safe since C++11
        return inst;
    }
    Config(const Config&) = delete;
    Config& operator=(const Config&) = delete;

    std::string get(const std::string& key) const { return values.at(key); }

private:
    Config() = default;
    std::unordered_map<std::string, std::string> values{{"env", "dev"}};
};

// Config::instance().get("env");

Applicability

How to implement

1. Add a private static field for the instance
2. Declare a public static creation method
3. Implement lazy initialisation, thread-safe if needed
4. Make the constructor private
5. Replace direct construction with calls to the static method

Pros and cons

Relations with other patterns

Check yourself