The key to implementing singleton pattern is to ensure that the class has only one instance and get it through a global access point. The specific steps are as follows: 1. Set the constructor to private to prevent external instance creation; 2. Provide static methods (such as getInstance()) to control access, where local static variables can be used to implement lazy initialization of C 11 thread-safe, or use std::once_flag and std::call_once to ensure initialization security under multi-threads; 3. Consider destruction and lifecycle management. If heap allocation is used, it is necessary to explicitly provide a destruction method and deal with repeated access issues. The local static variable method will be automatically destroyed when the program exits, simplifying management. The above solution selects applicable scenarios according to your needs.

Implementing a singleton pattern in C is a common design choice when you want to ensure that a class has only one instance and provide a global point of access to it. The key idea is to control the instance process so that no more than one object of the class can be created.

Here's how to do it properly in modern C .

Make the Constructor Private

The first step is to prevent external code from creating instances directly. This is done by making the constructor private or protected.

• If the constructor is public, anyone can create new instances — which defeats the purpose.
• By making it private, only the class itself can create an instance.

This is the foundation of the singleton pattern: restricting object creation.

Provide a Static Method to Access the Instance

Since direct instantiation is blocked, you need a way for other parts of the program to get access to the single instance. That's where a static method like getInstance() comes in.

 class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // private constructor

public:
    static Singleton* getInstance() {
        if (!instance) {
            instance = new Singleton();
        }
        return instance;
    }
};

• This version uses lazy initialization — the instance is created only when getInstance() is first called.
• It works fine in single-threaded environments, but in multi-threaded code, this could lead to race conditions.

If your application is multi-threaded, consider using std::call_once or C 11's magic statics (see next section).

Handle Thread Safety Correctly

If your app runs in a multi-threaded context, you need to make sure that instance creation is thread-safe.

There are two main approaches:

• Use a local static variable inside getInstance()
  Since C 11, this is thread-safe by default:

   static Singleton& getInstance() {
      static Singleton instance; // guaranteed to be initialized once
      return instance;
  }

  • This avoids memory leaks (no new used)
  • Also avoids race conditions due to static initialization rules

• Use std::once_flag and std::call_once
  For more complex cases or when you need dynamic allocation:

   static std::once_flag flag;
  static Singleton* getInstance() {
      std::call_once(flag, []{ instance = new Singleton(); });
      return instance;
  }

Thread safety matters even if your app isn't explicitly threaded — some libraries or frameworks might introduce concurrency behind the scenes.

Consider Destruction and Lifetime Management

Singletons often live for the entire runtime of the program, but sometimes you may want to clean them up manually.

• With heap-allocated singletons ( new ), you must delete the instance to avoid leaks.
• One solution is to add a destroyInstance() method:

 static void destroyInstance() {
    delete instance;
    instance = nullptr;
}

But this introduces extra complexity — what if someone tries to call getInstance() after destruction?

• You can guard against that with a flag, but then you're adding more state to manage.
• Alternatively, stick with the static local variable approach — it gets destroyed automatically at program exit.

So, depending on your use case, choose between simple static locals for thread-safe lazy initialization, or custom heap allocation with explicit destruction control.

Basically that's it.

The above is the detailed content of How to implement a singleton pattern in C ?. For more information, please follow other related articles on the PHP Chinese website!