本次博文假設有一個Manager管理類，並以此為探究單例類的設計模式。

一般作法

類聲明：

class Manager{
public:
~Manager();
 
//提供單例對象訪問
static Manager* getInstance();
 
//刪除單例對象
void deleteInstance();
 
void dosometing();
 
private:
//構造函數聲明為 保護方法
Manager();
 
//單例對象指針
static Manager* s_Manager;
};

類方法定義：

//單例對象指針初始化為nullptr，防止指向了未定義的數據
Manager* Manager::s_Manager = nullptr;
 
 
//提供單例類對象訪問
static Manager* Manager::getInstance(){
if(!s_Manager)s_Manager = new CacheManger();
return s_Manager;
}
 
//刪除單例類
void Manager::deleteInstance(){
if(s_Manager){
deleted s_Manager;
s_Manager = nullptr;}//別忘了賦予空指針，否則指向未定義的數據
}
 
void Manager::dosometing(){
//dosometing
}

這樣我們就能在平時的程序用

Manager::getInstance()
 
->dosomething();

來運用單例類來做某些操作了。

思考

在實際項目中，我發現有大量的工廠管理等需要單例化的類，如果每個類都要寫getInstance(),deleteInstance()方法未免太過麻煩。

基於這個缺點（偷懶點），自然而然想到用模板。
（因為大部分單例類都是共有getInstance(),deletedInstance()，而模板可以重載這些共有的類函數，於是思路如下）

模板解決方法

模板：

template<class T>
class Singleton{
private:
static T * s_instance;
public:
 
static T * getInstance();
static void deleteInstance();
};
 
//模板類提供單例類訪問方
template<class T>
T * Singleton<T>::getInstance() {
if (!s_instance)s_instance = new T();
return s_instance;
}
 
//模板類刪除單例類
template<class T>
void Singleton<T>::deleteInstance() {
if (s_instance) {delete s_instance;
s_instance = nullptr;
}
}
 
//模板類靜態變量初始化
template<class T>
T* Singleton<T>::s_instance = nullptr;

類聲明：

class Manager : public Singleton<Manager>{
public:
~Manager();
 
void dosomething();
 
//由於Singleton<CacheManger>無法訪問CacheManger的private方法（就是那個構造函數），只能借助友元提供權限.
friend Singleton<CacheManger>;
 
private:
//構造函數聲明為 私有方法
Manager();
};

類定義：

void Manager::dosomething(){
//dosometing
}

使用方法：

CacheManger::getInstance()->dosomething();

總結

相比第一個的一般做法，
Manager把單例方法轉移到在Singleton的實現裏，從而
使Manager的類聲明和定義清爽了很多，簡潔了一些。
這在需要多個單例類的項目中能讓程序員避免了多余冗雜的代碼，提高碼字效率（偷懶）。

（警告：本文並未考慮線程安全）

綜合起來，依個人愚見，在某個項目中需要大量單例類時，采取第二種即單例模板方法較為妥當。
而平時用用第一種單例類方法也沒什麽壞處。

C++單例類設計模式的思考