實現單例模式的關鍵在于確保類僅有一個實例并通過全局訪問點獲取它。具體步驟如下：1. 將構造函數設為私有以阻止外部創(chuàng)建實例；2. 提供靜態(tài)方法（如getInstance()）以控制訪問，其中可采用局部靜態(tài)變量實現C 11線程安全的懶漢式初始化，或使用std::once_flag和std::call_once確保多線程下初始化安全；3. 考慮析構與生命周期管理，若使用堆分配則需顯式提供銷毀方法并處理重復訪問問題，而局部靜態(tài)變量方式會在程序退出時自動銷毀，簡化管理。上述方案根據需求選擇適用場景。

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 instantiation 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.

基本上就這些。

以上是如何在C中實現單例模式？的詳細內容。更多信息請關注PHP中文網其他相關文章！