Example of Singleton Pattern in C++

This article introduces the Singleton Pattern in C++, including its implementation and application in object management. The Singleton Pattern ensures that a class has only one instance and provides a global access point to it.

The Singleton Pattern is one of the most popular design patterns in object-oriented programming. This pattern ensures that a class has only one instance and provides a method to access that object. This article will present how to implement the Singleton Pattern in C++ with a specific example.

C++ code

#include <iostream>
#include <mutex>

class Singleton {
private:
    static Singleton* instance; // Pointer to the unique instance
    static std::mutex mtx; // Mutex for thread safety

    // Private constructor
    Singleton() {
        std::cout << "Constructor called" << std::endl;
    }

public:
    // Method to access the unique instance
    static Singleton* getInstance() {
        if (instance == nullptr) {
            std::lock_guard<std::mutex> lock(mtx); // Ensure thread safety
            if (instance == nullptr) {
                instance = new Singleton();
            }
        }
        return instance;
    }

    // Sample method
    void someBusinessLogic() {
        std::cout << "Processing business logic" << std::endl;
    }
};

// Initialize the pointer
Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mtx;

int main() {
    // Get the instance of Singleton and perform some logic
    Singleton* singleton = Singleton::getInstance();
    singleton->someBusinessLogic();

    return 0;
}

Detailed explanation

• static Singleton* instance: A static pointer that holds the unique instance of the Singleton class.
• static std::mutex mtx: A mutex to ensure that multiple threads do not access the getInstance() method simultaneously.
• Singleton(): A private constructor to prevent object creation outside of the class.
• static Singleton* getInstance(): A static method to access the unique instance. It checks if the instance is created and creates it if necessary.
• std::lock_guard<std::mutex> lock(mtx): Ensures thread safety when checking and creating the instance in a multithreaded environment.
• someBusinessLogic(): An example method within the Singleton class.

System Requirements:

• C++11 or later (to use std::mutex and std::lock_guard)

How to install the libraries needed to run the C++ code above:

The above code does not require any external libraries. You only need to compile it with a compiler that supports C++11.

Tips:

• The Singleton Pattern is useful when you need a single instance, such as a database connection manager or a global configuration.
• Be careful when using Singleton in a multithreaded environment to avoid data safety issues.

---