2. 程式人生 > >(C++)用模板或巨集實現單例模式

(C++)用模板或巨集實現單例模式

阿新 • • 發佈：2019-02-16

最近在cocos2d-x開發中經常會用到單例模式，而每個單例模式類實際上具備相似的基礎結構，為了便於快速寫出一個具有單例模式的類，可以藉助模板或者巨集。

1.單例模式的類實現

首先，給出一個基本的實現單例模式的程式碼：

class Singleton
{
public:
	inline static Singleton& GetInstance()
	{
		static Singleton s_instance;
		return s_instance;
	}

private:
	Singleton();
	Singleton(Singleton const&){};
	Singleton& operator= (Singleton const&){return *this;};
	~Singleton();
};
#define SGL Singleton::GetInstance()
因為是用於cocos2d-x下的開發，而手機遊戲很多時候僅需要單執行緒就足夠了，因此此處沒有考慮執行緒安全問題，如果有執行緒安全方面的考慮，則對此類稍加改動即可。另外GetInstance函式沒有返回一個指標而是返回引用，是希望使用者像使用一個物件一樣使用此類，而且這樣的寫法對於改寫成模板或者巨集都更容易，程式碼也更簡潔。為了使用方便，為獲取單例的函式寫了一個巨集，當然這個是可選項，不寫也無所謂。

建構函式、拷貝建構函式、賦值操作符與解構函式全部設為私有，以防止類的使用者不小心對類重新建立和賦值，保證類有且僅有一個例項。

在單例模式中，拷貝建構函式與賦值操作符因為完全沒有用，因此此處直接給出了空實現"{}"，而建構函式和解構函式此處並未給出空實現，因為它們往往需要根據具體情況給出具體實現，而且建構函式和解構函式並不適合成為inline。

2.單例模式的模板實現

用模板實現單例模式實際上與基本類實現程式碼大同小異：

#ifndef SINGLETON_H_
#define SINGLETON_H_

template<typename T>
class Singleton
{
public:
	inline static T& GetInstance()
	{
		static T s_instance;
		return s_instance;
	}

private:
	Singleton();
	Singleton(Singleton const&);
	Singleton& operator= (Singleton const&);
	~Singleton();
};
#endif//SINGLETON_H_

如上，大部分程式碼與普通的類實現沒有區別。不過需要注意的是，除了多了一個template宣告式之外，還有一個在文章中難以體現的區別是這種實現方式可能不需要cpp檔案，尤其如果你和我一樣用它做cocos2d-x開發的話，也不需要給出4個私有函式的實現。

使用模板時則類似於這樣
#include "Singleton.h"
class Example
{

};
typedef Singleton<Example> SglExample;
#define SGL_EXAMPLE SglExample::GetInstance()

將需要成為單例模式的類嵌入模板即可，而Example類的程式碼與普通類沒有任何區別。

示例程式碼的最後多出了一個類別名（typedef語句）和一個巨集（#define），作用是方便使用者使用單例，而不需要寫重複程式碼，尤其是模板風格程式碼--實在算不上優美。

需要注意的是，這裡的實現思路是將Example類作為了Singleton模板的“實現素材”，真正的單例是Singleton<Example>而不是Example，關於此設計的缺點，會在稍後詳述。

3.單例模式的巨集實現

巨集實現的程式碼實際上與類實現的程式碼依舊思路相同：

#ifndef SINGLETON_DIFINE_H_
#define SINGLETON_DIFINE_H_

//單例模式巨集
#define SINGLETON(_CLASS_)					\
public:										\
	inline static _CLASS_& GetInstance()	\
	{										\
	static _CLASS_ s_instance;				\
	return s_instance;						\
	}										\
private:									\
	_CLASS_();								\
	_CLASS_(_CLASS_ const&){}				\
	_CLASS_& operator= (_CLASS_ const&){return *this;}	\
	~_CLASS_();								\

//單例模式預設建構函式與解構函式（配合單例模式巨集使用）
#define SINGLETON_C_D(_CLASS_)		\
	_CLASS_::_CLASS_(){}			\
	_CLASS_::~_CLASS_(){}			\

#endif //SINGLETON_DIFINE_H_

巨集的實現與模板實現具有一些相似的特徵，比如只需要.h檔案。但又有很多區別，比如在巨集定義中需要給出拷貝建構函式和賦值操作符的空實現，否則巨集的使用者將必須手動實現這兩個不會被也不該被使用的函式，而建構函式與解構函式的定義許可權，依舊保留給巨集的使用者，如果使用者不希望手動定義這兩個函式，也可以在cpp檔案中用配套的巨集SINGLETON_C_D來幫助自己節省一些力氣。

使用單例模式巨集時則類似這樣：

#include "SingletonDefine.h"

class Example
{
	SINGLETON(Example);
};
#define SGL_EXAMPLE Example::GetInstance()
由於不會產生模板風格的程式碼，因此省去了一個typedef。類使用方法與普通手寫的單例模式類（如1中所述那樣的類）沒有任何區別。

4.三種實現方式的分析

三種實現方式中類實現的可讀性最好--當然對於這麼幾行程式碼，其實可讀性對於任何人應該都不成問題。除此之外類實現的方式依賴性也最低，這裡指的依賴性不是類之間的依賴性而是檔案依賴性，即當代碼檔案被遷移到其他專案中去時，不需要額外附帶一個單例模式.h檔案（無論是模板的.h還是巨集的.h），缺陷顯而易見，當單例類比較多時，需要重複寫很多思路相同的程式碼。當寫一些可能被遷移的基礎類時--如底層資料管理類，可以考慮選用這種方式。

下面比較模板實現方式和巨集實現方式。兩種實現都會導致程式碼膨脹，但機制卻並不相同，巨集定義的替換屬於預處理，實際上是發生在編譯前，而模板實現則在編譯期生成實際程式碼，當然對於類的使用者來說並不會感知這種區別，尤其是有對應的typedef和define的幫助下。

但是，兩種實現方式依然有其他一些區別，這些區別足以影響應該選擇哪一種方式。

在模板實現一段中提到實際上作為“實現素材”的類Example並非單例，實際的單例是Singleton<Example>，也就是說使用模板實現將不可避免的在專案中產生兩個功能幾乎一樣的類，一個是作為實際使用的單例，而另一個則是它的“影子”，一個除了做單例模板的素材之外，再不會被使用的類。這將產生一個隱患：難以避免類的使用者在無意中使用那個影子類。而影子類一旦被使用，則單例則被打破，會出現什麼結果則難以預料。另一個更麻煩的問題是，如果Example中用到了列舉，則所有Example中的列舉都是屬於Example類的而非Singleton<Example>，即使編譯時生成了單例模式的程式碼，使用時卻無法徹底擺脫原先的影子類。

巨集實現沒有模板實現的上述缺點，它不會產生“影子類”，類中如果有列舉甚至巢狀類也不會影響使用。當然，大多數時候在C++中是不推薦使用巨集的，關於使用巨集的隱患和缺點，相關文章很多，此處不再展開。這裡要說的是，由於單例模式的實現巨集使用範圍非常狹窄，而且引數單一，因此，很多擔憂的問題實際上並不容易發生。如果暫時擱置巨集本身的問題，暫且只比較上面兩種實現的話，巨集實現明顯的弱點是：巨集定義比較醜，至少比模板定義醜，如果進行巢狀，醜陋指數加倍。

5.總結

優先使用巨集實現。

可能頻繁在多個專案中被遷移的程式碼，可以考慮使用最簡單的類實現方式。

類中沒有列舉，或者需要模板巢狀才能實現功能時，且能保證類使用者不會無意中使用“影子類”的情況下，使用模板實現。

6.補充

最近發現原來寫的巨集在vs下正常，而在eclipse下編譯時會有警告，原因是拷貝建構函式未將所有成員（除了容器）進行初始化。在C++11中可利用委託建構函式消除此警告。方法是將_CLASS_(_CLASS_ const&) {}改為_CLASS_(_CLASS_ const&) : _CLASS_(){}即可。但是在C++03下除了自己寫定義手動新增初始化列表之外我還未找到更好的辦法。

另外賦值操作符雖然不會被呼叫，但定義中未寫返回值，這也是不嚴謹的寫法，儘管在一些編譯器環境下可以通過編譯，但在其他編譯器上可能引起編譯錯誤或者警告，因此也加入了返回值。

更改之後的完整程式碼如下（編譯環境需支援C++11或以後的更新的版本規範）：

#ifndef SINGLETON_DIFINE_H_
#define SINGLETON_DIFINE_H_

//單件類巨集
#define SINGLETON(_CLASS_)								\
public:													\
	inline static _CLASS_& GetInstance()				\
	{													\
	static _CLASS_ s_instance;							\
	return s_instance;									\
	}													\
private:												\
	_CLASS_();											\
	_CLASS_(_CLASS_ const&) : _CLASS_(){}				\
	_CLASS_& operator= (_CLASS_ const&){return *this;}	\
	~_CLASS_();											

//單件類的構造與解構函式（配合單件類巨集使用）
#define SINGLETON_C_D(_CLASS_)		\
	_CLASS_::_CLASS_(){}			\
	_CLASS_::~_CLASS_(){}			\

#endif //SINGLETON_DIFINE_H_

==========

====更新記錄====

2015-02-22：修正了部分程式碼排版問題和一些文字描述問題。

2015-04-27：修正了拷貝建構函式引起警告的問題，修正了賦值操作符定義的語法錯誤。



相關推薦

(C++)用模板或巨集實現單例模式

最近在cocos2d-x開發中經常會用到單例模式，而每個單例模式類實際上具備相似的基礎結構，為了便於快速寫出一個具有單例模式的類，可以藉助模板或者巨集。 1.單例模式的類實現 首先，給出一個基本的實現單例模式的程式碼： class Singleton { public:

利用c++的private和static實現單例模式

精髓就是 將建構函式設定為private屬性，並且將複製建構函式和賦值建構函式也設定為private屬性，這樣的話，就無法在外部建立物件，所以此時還需要一個public的函式：getHumanInterface()，這個函式來呼叫private屬性的建構函式來生成我們需要的物件，並且將這個物

C++：利用靜態成員實現“單例模式”

在網上看了兩三天的網課，瞭解了一下C++，正好做作業遇到一個問題，解決之後覺得有必要寫到部落格裡，就發出來了。 問題是：如何實現“單例模式”，也就是說某個物件只能有一個例項。 思路： 1.需要一個

為什麼用列舉類來實現單例模式越來越流行？

前言 單例模式是 Java 設計模式中最簡單的一種，只需要一個類就能實現單例模式，但是，你可不能小看單例模式，雖然從設計上來說它比較簡單，但是在實現當中你會遇到非常多的坑，所以，繫好安全帶，上車。 單例模式的定義 單例模式就是在程式執行中只例項化一次，建立一個全域性唯一物件，有點像 Java 的靜態變數，但是

用C++實現單例模式4——C++11實現

std::atomic<Singleton*> Singleton::m_instance; std::mutex Singleton::m_mutex; Singleton* Singleton::getInstance() { Singleton* tmp = m_instance

用單例物件實現單例模式

2018-12-04 14:55:07 object SingletonDemo { //object修飾的為物件 def main(args: Array[String]): Unit = { val s = SessionFactory println(s.getS

C++實現單例模式

提幾個問題吧 1.執行緒安全 2.單件物件與物件彼此依賴，析構可能出現問題 3.必須從此類派生 有時候想想，單件這東西真是有點多餘，文件齊全命名規範的全域性變數或全域性函式完全不會有問題。

C++ （設計模式）實現單例模式

設計模式 從實踐的角度來看，設計模式有兩個重要的屬性。首先，它們描述了經過驗證的、成功的設計技術，這些技術可以按上下文相關的方式進行定製，一遍滿足新的設計場合的要求。其次，並且可能更重要的是，在提及某個特定模式的應用時不僅包括其中用到的技術，還包括應用該模式的動因以及應用後所達到的效果。

C++實現單例模式（包括採用C++11中的智慧指標）

    對於設計模式來說，以前只是看過基礎的理論，很多都沒有實現和使用過。這段時間看到了別人C++程式碼中使用了單例模式，發現了很多新的東西，特此總結記錄一下。說話比較囉嗦，希望由淺入深，幫助大家理解！     單例模式，顧名思義，即一個類只有一個例項物件。C++一般的方法

C++ 實現單例模式

單例模式是任何面嚮物件語言繞不過的，單例模式是很有必要的，接下來我用最樸素的語言來解釋和記錄單例模式的學習。什麼是單例模式？單例模式就是一個類只能被例項化一次 ，更準確的說是只能有一個例項化的物件的類。建立一個單例模式的類（初想）一個類只能有一個例項化的物件，那麼這個類就要禁

linux下c++ 實現單例模式

singleton.h，下面是原始碼#include <unistd.h> #include <pthread.h> using namespace std; class Lock { private: pthr

C++如何實現單例模式

C++有時會用到單例模式，比如和資料庫連線的類，我們只需要一個物件，那麼這時候我們就要限制類物件產生的數量，允許一個類產生一個物件，如何讓一個類產生一個物件呢，也就是實現單例模式？ 方法一：將建構函式

python一種用classmethod實現單例模式方法的探討

初步實現程式碼如下： class Singleton(object): instance = None def __init__(self): pass @classmethod def get_instance(cls):

溫故而知新(java實現)單例模式的七種寫法

反序 防止 代碼 工作 html 我想 變種 evel 才會 第一種（懶漢，線程不安全）： Java代碼 public class Singleton { private static Singleton instance; private S

Java枚舉enum以及應用：枚舉實現單例模式

tee configure adr 自由 這樣的 pre 單例模式 做到 build 枚舉作為一個常規的語言概念，一直到Java5才誕生不得不說有點奇怪，以至於到現在為止很多程序員仍然更喜歡用static final的形式去命名常量而不使用，一般情況下，Java程序員用這種

C++ 多線程下的單例模式

!= ret ati c++ 靜態 出現 建議 進行 多個實例 /* 代碼中經常會使用到單例模式，單例模式就是隱藏構造函數，提供獲取一個實例的靜態方法。 但是在多線程場景下，單例模式會有一些不同。例如Config類的instance方法如下 */

Python 實現單例模式

python 單例模式 Python 實現單例模式 # 使用Python實現單例模式 # 方法一: 使用__new__方法 class SingleTon(object): def __new__(cls, *args, **kwargs): if not ha

使用靜態代碼塊來實現單例模式

對象 代碼 over 說明 override out min .get admin package com.wz.thread.staticlump;/** * 使用靜態代碼塊來實現單例模式 * @author Administrator * */public class

枚舉實現單例模式

min () bject oca serve oid ros manager [] package com.wz.thread.enums;import java.sql.Connection;import java.sql.DriverManager;/** * 使用枚舉

python實現單例模式

一次 color 中大 我們 浪費 python實現 判斷 內存 () 有這麽一種場景，我們把數據封裝到類體或類的某個方法裏，然而我們new出這個類只是為了拿到這部分數據，那麽當多次這樣調用的時候，每次都來拿數據並放到內存中大大浪費了內存。 那我們就可以想，我們拿到一次數據