Robust Code of Singleton Design Pattern for Pre-C++11

Explore a thread-safe implementation of the Singleton design pattern in C++ versions before C++11. Learn how to address memory ordering and compiler optimization challenges, ensuring a single instance of a class throughout the application’s lifecycle. Dive into the code example showcasing careful synchronization techniques for reliable and efficient Singleton patterns.

For C++11 and above version, you must use the singleton design pattern that I have explained here.

This singleton implementation using the older C++ version and addressing memory ordering and compiler optimization issues by using atomic operations:

#include <iostream>
#include <mutex>

class Singleton {
public:
    static Singleton& getInstance() {
        if (!instance_.load(std::memory_order_acquire)) {
            std::lock_guard<std::mutex> lock(mutex_);
            if (!instance_.load(std::memory_order_relaxed)) {
                Singleton* temp = new Singleton;
                instance_.store(temp, std::memory_order_release);
            }
        }
        return *instance_.load(std::memory_order_relaxed);
    }

    void doSomething() {
        std::cout << "Singleton instance is doing something." << std::endl;
    }

    ~Singleton() {
        delete instance_.load();
    }

private:
    Singleton() {} // Private constructor to prevent external instantiation
    Singleton(const Singleton&) = delete; // Delete copy constructor
    Singleton& operator=(const Singleton&) = delete; // Delete assignment operator

    static std::atomic<Singleton*> instance_;
    static std::mutex mutex_;
};

std::atomic<Singleton*> Singleton::instance_{nullptr};
std::mutex Singleton::mutex_;

int main() {
    Singleton& instance1 = Singleton::getInstance();
    Singleton& instance2 = Singleton::getInstance();

    if (&instance1 == &instance2) {
        std::cout << "Both instances are the same. Singleton pattern works." << std::endl;
    } else {
        std::cout << "Instances are different. Singleton pattern failed." << std::endl;
    }

    return 0;
}

In this code, std::atomic is used to ensure proper memory ordering when accessing and updating the instance pointer. The std::memory_order_acquire and std::memory_order_release flags are used to control the memory ordering when loading and storing the instance pointer. This approach provides a safer way to ensure proper synchronization and memory visibility.

IMPORTANT NOTE

Keep in mind that even with this approach, handling all the intricacies of thread safety and memory visibility in older C++ versions can be complex. If possible, it’s recommended to use a more modern version of C++ where many of these issues are handled more effectively.