C++單例模式實現（採用C++11智能指針）

原創 于大博 2019-09-16 00:50
原文鏈接：https://blog.csdn.net/cjbct/article/details/79266057

    單例模式，顧名思義，即一個類只有一個實例對象。C++一般的方法是將構造函數、拷貝構造函數以及賦值操作符函數聲明爲private級別，從而阻止用戶實例化一個類。那麼，如何才能獲得該類的對象呢？這時，需要類提供一個public&static的方法，通過該方法獲得這個類唯一的一個實例化對象。這就是單例模式基本的一個思想。

    下面首先討論不考慮線程安全的問題（即：單線程環境），這樣能體現出單例模式的本質思想。常見的單例模式分爲兩種：

    1、餓漢式：即類產生的時候就創建好實例對象，這是一種空間換時間的方式

    2、懶漢式：即在需要的時候，才創建對象，這是一種時間換空間的方式

首先說一下餓漢式：餓漢式的對象在類產生的時候就創建了，一直到程序結束才釋放。即對象的生存週期和程序一樣長，因此 該實例對象需要存儲在內存的全局數據區，故使用static修飾。代碼如下(注：類的定義都放在了一個頭文件CSingleton.h中，爲了節省空間，該類有些實現和定義就放在測試的主文件中，沒有單獨創建一個CSingleton.cpp文件)：

頭文件：

// 餓漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
    static CSingleton myInstance; // 單例對象在這裏！
public:
    static CSingleton* getInstance()
    {        
        return &myInstance;
    }
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include"CSingleton.h"
 
using namespace std;
CSingleton CSingleton::myInstance;
int main()
{
    CSingleton *ct1 = CSingleton::getInstance();
    CSingleton *ct2 = CSingleton::getInstance();
    CSingleton *ct3 = CSingleton::getInstance();
 
    return 0;
}

對於餓漢式來說，是線程安全的。

運行結果如下所示：

能夠看出，類的實例只有一個，並且正常銷燬。這裏，問題來了！！！

頭文件：

// 餓漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
    static CSingleton *myInstance; // 這裏改了！
public:
    static CSingleton* getInstance()
    {        
        return myInstance; // 這裏也改了！
    }
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include"CSingleton.h"
 
using namespace std;
CSingleton * CSingleton::myInstance=new CSingleton();
int main()
{
    CSingleton *ct1 = CSingleton::getInstance();
    CSingleton *ct2 = CSingleton::getInstance();
    CSingleton *ct3 = CSingleton::getInstance();
 
    return 0;
}

運行結果如下所示：

咦！怎麼沒有進入析構函數？這裏就有問題了，如果單例模式的類中申請了其他資源，就無法釋放，導致內存泄漏！

原因：此時全局數據區中，存儲的並不是一個實例對象，而是一個實例對象的指針，即一個地址變量而已！實例對象呢？在堆區，因爲是通過new得來的！雖然這樣能夠減小全局數據區的佔用，把實例對象這一大坨都放到堆區。可是！如何釋放資源呢？

首先能想到的第一個方法：我自己手動釋放呀！我在程序結束的時候delete不就可以了？對！這是可以的，程序如下：

頭文件：

// 餓漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
    static CSingleton *myInstance; 
public:
    static CSingleton* getInstance()
    {        
        return myInstance;
    }
    static void releaseInstance() // 這裏加了個方法
    {
        delete myInstance;
    }
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include"CSingleton.h"
 
using namespace std;
CSingleton * CSingleton::myInstance=new CSingleton();
int main()
{
    CSingleton *ct1 = CSingleton::getInstance();
    CSingleton *ct2 = CSingleton::getInstance();
    CSingleton *ct3 = CSingleton::getInstance();
        CSingleton::releaseInstance(); // 手動釋放
    return 0;
}

運行結果如下：

運行結果沒問題！可是，要是我寫着寫着我忘記了，沒有顯式調用釋放的函數怎麼辦？如果有一個自動釋放的方法就好了！天無絕人之路。

方法二：

頭文件：

// 餓漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
    static CSingleton *myInstance; 
public:
    static CSingleton* getInstance()
    {        
        return myInstance;
    }
 
private:
    // 定義一個內部類
    class CGarbo{
    public:
        CGarbo(){};
        ~CGarbo()
        {
            if (nullptr != myInstance)
            {
                delete myInstance;
                myInstance = nullptr;
            }
        }
    };
    // 定義一個內部類的靜態對象
    // 當該對象銷燬時，順帶就釋放myInstance指向的堆區資源
    static CGarbo m_garbo; 
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include"CSingleton.h"
 
using namespace std;
CSingleton * CSingleton::myInstance=new CSingleton();
CSingleton::CGarbo CSingleton::m_garbo; // 注意這裏！！！
int main()
{
    CSingleton *ct1 = CSingleton::getInstance();
    CSingleton *ct2 = CSingleton::getInstance();
    CSingleton *ct3 = CSingleton::getInstance();
 
    return 0;
}

運行結果如下：


可見能夠正常釋放堆區申請的資源了！問題解決！這裏又會想到，C++11中把boost庫中的智能指針變成標準庫的東西。智能指針可以在引用計數爲0的時候自動釋放內存，方便使用者管理內存，爲什麼不嘗試用一下智能指針呢？現在修改代碼如下（不可以正常運行）：

頭文件：

// 餓漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
#include<memory>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
    static shared_ptr<CSingleton> myInstance; 
public:
    static shared_ptr<CSingleton> getInstance()
    {        
        return myInstance;
    }
 
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include<memory>
#include"CSingleton.h"
 
using namespace std;
shared_ptr<CSingleton> CSingleton::myInstance(new CSingleton());
int main()
{
    shared_ptr<CSingleton>  ct1 = CSingleton::getInstance();
    shared_ptr<CSingleton>  ct2 = CSingleton::getInstance();
    shared_ptr<CSingleton>  ct3 = CSingleton::getInstance();
    
    return 0;
}

結果編譯都過不了。仔細一看，原來智能指針shared_ptr無法訪問私有化的析構函數。當shared_ptr內部的引用計數爲零時，會自動調用所指對象的析構函數來釋放內存。然而，此時單例模式類的析構函數爲private，故出現編譯錯誤。如何修改呢？當然，最簡單的方法是把析構函數變成public。但是如果某用戶不小心手殘，顯式調用了析構函數，這不就悲劇了。第二種方法，就是不通過析構函數來釋放對象的資源。怎麼辦呢？不要忘了shared_ptr在定義的時候可以指定刪除器（deleter）。可是通過測試，無法直接傳入析構函數。我現在想到的一個方法是，在單例函數內部再定義一個Destory函數，該函數也要爲static的，即通過類名可直接調用。當然，在使用該單例類的時候，也需要使用shared_ptr獲取單一實例對象。

代碼如下：

頭文件：

// 餓漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
#include<memory>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
    static void Destory(CSingleton *){ cout << "在這裏銷燬單例對象！" << endl; };//注意這裏
    static shared_ptr<CSingleton> myInstance; 
public:
    static shared_ptr<CSingleton> getInstance()
    {        
        return myInstance;
    }
 
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include<memory>
#include"CSingleton.h"
 
using namespace std;
shared_ptr<CSingleton> CSingleton::myInstance(new CSingleton(), CSingleton::Destory);
int main()
{
    shared_ptr<CSingleton>  ct1 = CSingleton::getInstance();
    shared_ptr<CSingleton>  ct2 = CSingleton::getInstance();
    shared_ptr<CSingleton>  ct3 = CSingleton::getInstance();
    
    return 0;
}

運行結果如下：

刪除器聲明時（即static void Destory(CSingleton *)），需要傳入該對象的指針，否則編譯出錯。這裏僅作說明，用不上該指針，故沒有給形參取名字。詳細說明一下，通過去掉形參的聲明，出錯後，就能定位到 頭文件<memory>中釋放對象的位置，代碼如下：

    template<class _Ux>
    void _Resetp(_Ux *_Px)
        {    // release, take ownership of _Px
        _TRY_BEGIN    // allocate control block and reset
        _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
        _CATCH_ALL    // allocation failed, delete resource
        delete _Px;
        _RERAISE;
        _CATCH_END
        }
 
    template<class _Ux,
        class _Dx>
        void _Resetp(_Ux *_Px, _Dx _Dt)
        {    // release, take ownership of _Px, deleter _Dt
        _TRY_BEGIN    // allocate control block and reset
        _Resetp0(_Px, new _Ref_count_del<_Ux, _Dx>(_Px, _Dt));
        _CATCH_ALL    // allocation failed, delete resource
        _Dt(_Px);
        _RERAISE;
        _CATCH_END
        }

可以看出，上面代碼中第一個_Resetp就是沒有指明deleter時調用的函數。第二個_Resetp是指明deleter時調用的函數，此時deleter _Dt需要接收一個參數_Px（即指向shared_ptr內部對象的指針），從而釋放shared_ptr內部對象的內容。

迴歸正題，到這裏，我們可以看到：餓漢式的單例模式原理很簡單，也很好寫，並且線程安全，不需要考慮線程同步！

懶漢式單例模式

懶漢式單例模式，是在第一次調用getInstance()的時候，才創建實例對象。想到這裏，是不是直接把對象定義爲static，然後放在getInstance()中。第一次進入該函數，就創建實例對象，然後一直到程序結束，釋放該對象。動手試一試。

代碼如下：

頭文件：

// 懶漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
 
public:
    static CSingleton * getInstance()
    {    
        static CSingleton myInstance;
        return &myInstance;
    }
 
};
 
#endif

源文件：

//源文件，用於測試用例的生成
#include<iostream>
#include"CSingleton.h"
 
using namespace std;
 
int main()
{
    CSingleton *   ct1 = CSingleton::getInstance();
    CSingleton *   ct2 = CSingleton::getInstance();
    CSingleton *   ct3 = CSingleton::getInstance();
    
    return 0;
}

運行結果如下：


程序正常運行。此時，如果想把對象放在堆區，也可以這麼實現：

頭文件：

// 懶漢式單例的實現
#ifndef C_SINGLETON_H
#define C_SINGLETON_H
 
#include<iostream>
#include<memory>
using namespace std;
class CSingleton
{
private:
    CSingleton(){ cout << "單例對象創建！" << endl; };
    CSingleton(const CSingleton &);
    CSingleton& operator=(const CSingleton &);
    ~CSingleton(){ cout << "單例對象銷燬！" << endl; };
 
    static CSingleton *myInstance;
 
 
public:
    static CSingleton * getInstance()
    {    
        if (nullptr == myInstance)
        {
            myInstance = new CSingleton();
        }
        return myInstance;
    }
 
private:
    // 定義一個內部類
    class CGarbo{
    public:
        CGarbo(){};
        ~CGarbo()
        {
            if (nullptr != myInstance)
            {
                delete myInstance;
                myInstance = nullptr;
            }
        }
    };
    // 定義一個內部類的靜態對象
    // 當該對象銷燬時，順帶就釋放myInstance指向的堆區資源
    static CGarbo m_garbo;
};
 
#endif

源文件：

// 源文件，用於測試用例的生成
#include<iostream>
#include<memory>
#include"CSingleton.h"
 
using namespace std;
CSingleton * CSingleton::myInstance = nullptr;
CSingleton::CGarbo CSingleton::m_garbo;
int main()
{
    CSingleton *   ct1 = CSingleton::getInstance();
    CSingleton *   ct2 = CSingleton::getInstance();
    CSingleton *   ct3 = CSingleton::getInstance();
    
    return 0;
}

運行結果如下：

對於懶漢式這兩種情況，當調用getInstance()函數時，如果對象還沒產生（第一種狀態），就需要產生對象，然後返回對象指針。如果對象已經存在了（第二種狀態），就直接返回對象指針。當單線程時，沒有問題。但是，多線程情況下，如果一個函數中不同狀態有不同操作，就要考慮線程同步的問題了。因此，我們需要修改一下getInstance中的實現。

舉例如下：

第一種懶漢式：

static CSingleton * getInstance()
{    
    lock();
    static CSingleton myInstance;
    unlock();
    return &myInstance;
}

第二種懶漢式：

static CSingleton * getInstance()
{    
    if (nullptr == myInstance)
    {
        lock();// 需要自己採用適當的互斥方式
        if (nullptr == myInstance)
        {
            myInstance = new CSingleton();
        }
        unlock();
    }
    return myInstance;
}

注意！由於線程和使用的操作系統有關，因此這裏的lock()和unlock()函數僅作說明示意，並未實現。都是常見的線程同步方法，可以查詢其他資料來實現。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

貪喫蛇 C++

<pre name="code" class="cpp"> 本文爲用C++寫的一個貪喫蛇的小程序。旨在融入進面向對象編程的思想。希望鞏固所學，這裏有全部的源代碼，也希望你不吝惜筆墨提出自己的看法。我將試着展示如何利用面向對象的思維從最初

Univcsdn 2020-07-08 11:45:49

codeforces 1251E1/E2 Voting

Codeforces 1251E1/E2 Voting題意思路代碼 題意 給你n個人，你需要讓這n個人全部給你投票。讓第i個人給你投票的方法有兩種：給他pi塊錢收買他，或者當前已經有mi個人爲你投票，他就會爲你免費投票。問最少花費

祤溪 2020-07-08 12:36:32

獲取某一目錄下所有文件夾名，返回vector「string」

vector<string> listFiles(const char * dir) { vector<string> FolderNames; HANDLE hFind; WIN32_FIND_DATA findData;

COSummer 2020-07-08 12:27:32

linux環境下開源庫jsoncpp使用教程

文章目錄前言Unix/Linux下配置使用1.下載jsoncpp到linux上2.生成靜態庫libjsoncpp.a3.拷貝頭文件與靜態庫到/usr/local下4.執行測試程序 前言 json是一種常用的數據格式，開源庫json

Worthy_Wang 2020-07-08 12:19:12

C++：模擬實現list容器（支持迭代器）

模擬實現list容器（支持迭代器） 要模擬實現一個list容器，主要就是相關頭插頭刪尾插尾刪的接口，這些非常常用。 另外有一個點灰常重要！！那就是list的迭代器，list的迭代器不能用原生指針去模擬實現，因爲鏈表的迭代器加一是下

ETalien_ 2020-07-08 12:19:01

C++（面試題）：給40億個不重複的無符號整數，沒排過序，如何快速判斷一個數是否在這40億個數中

給40億個不重複的無符號整數，沒排過序，給你一個無符號整數，如何快速判斷這個數是否在這40億個數中？ 首先看到這個題第一個想到的就是遍歷一遍，看這個數在不在。但是這樣的時間複雜度太高了O(N)，數據量太大，因此該方法不行。 其次我

ETalien_ 2020-07-08 12:19:01

指針的引用（*&）

Void TEncSlice::compressSlice( TComPic* & rpcPic )函數參數傳遞的是指針的引用 函數參數傳遞有三種方法，值傳遞，址傳遞，傳遞引用； 這裏說的是傳遞指針的引用。 Void TE

yang-彧 2020-07-08 11:40:24

C++ 併發中的無鎖編程

  基礎預備：c++ automic類型以及c++內存模型 https://blog.csdn.net/qq_35865125/article/details/105611985 https://blog.csdn.net/qq_3586

蚓无爪牙之利 2020-07-08 11:23:03

數據結構——數組（3） 在有序數組中找出重複的次數最多的數

先總結有序數組，無序的後面再總結。。 1.以空間換時間法。 算法思想：目標數組array[length]，是一個有序數組，比如int array[]={1,1,2,2,4,4,4,4,4,5,5,6,10};總共有13個元素，

zhangying_496 2020-07-08 10:38:18

數據結構——數組（1）數組求和&打印二維數組&判斷數組是否遞增

數組求和 方法一：直接一次for循環 int GetSum1(int *a,int n) { int sum=0; for (int i=0; i<n;i++) { sum+=a[i];

zhangying_496 2020-07-08 10:38:18

C語言實現的json解析程序

只有一個頭文件和一個源文件，僅使用C語言標準庫。 作用就是讀取json文件，然後解析爲若干個互相關聯的結構，結構如下： typedef enum json_st { djson_string = 1, djson_number,

lindorx 2020-07-08 10:35:53

大話設計模式C++版本-04-代理模式

概念 代理模式：爲其他對象提供一種代理以控制對這個對象的訪問 使用場景 想在訪問一個類時做一些控制； 直接訪問對象時會帶來的問題，比如說：要訪問的對象在遠程的機器上。 一般步驟 將被代理者和代理者的共同行爲抽象出來作爲一個類

wkd_007 2020-07-08 10:27:39

大話設計模式C++版本-07-模板方法模式

概述 模板方法模式：定義一個操作中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。 優點： 封裝不變部分，擴展可變部分 提取公共代碼，便於維護 行爲由父類控制，子類

wkd_007 2020-07-08 10:27:28

大話設計模式C++版本-05-工廠方法模式

概念 工廠方法模式：定義一個創建對象的接口，讓其子類自己決定實例化哪一個工廠類，工廠模式使其創建過程延遲到子類進行。 與簡單工廠模式對比 簡單工廠模式最大優點就是工廠類中包含了必要的邏輯判斷，可以根據不同條件動態實例化相關的類，

wkd_007 2020-07-08 10:27:26

大話設計模式C++版本-06-原型模式

概念 原型模式：用原型實例指定創建對象的種類，並且通過拷貝這些原型創建新的對象。 原理：利用一個Clone函數來封裝了自身的拷貝構造函數，調用Clone函數時就會觸發拷貝構造。 使用場景 利用已有的一個原型對象，快速地生成和原型對

wkd_007 2020-07-08 10:27:25