C++ 超詳細深入分析單例模式

更新時間：2022年03月24日 14:18:31 作者：ymz123_

單例模式（Singleton Pattern）是最簡單的設(shè)計模式之一。這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式，這種模式涉及到一個單一的類，該類負責創(chuàng)建自己的對象，同時確保只有單個對象被創(chuàng)建

不能被拷貝的類

拷貝只會放生在兩個場景中：拷貝構(gòu)造函數(shù)以及賦值運算符重載，因此想要讓一個類禁止拷貝，只需讓該類不能調(diào)用拷貝構(gòu)造函數(shù)以及賦值運算符重載即可。

C++98

將拷貝構(gòu)造函數(shù)與賦值運算符重載只聲明不定義，并且將其訪問權(quán)限設(shè)置為私有即可。

class CopyBan
{
	//...
private:
	CopyBan(const CopyBan&);
	CopyBan& operator=(const CopyBan&);
	//...
};

原因：

設(shè)置成私有：如果只聲明沒有設(shè)置成private，用戶自己如果在類外定義了，就可以不能禁止拷貝了

只聲明不定義：不定義是因為該函數(shù)根本不會調(diào)用，定義了其實也沒有什么意義，不寫反而還簡單，而且如果定義了就不會防止成員函數(shù)內(nèi)部拷貝了。

C++11

C++11擴展delete的用法，delete除了釋放new申請的資源外，如果在默認成員函數(shù)后跟上=delete，表示讓編譯器刪除掉該默認成員函數(shù)。

class CopyBan
{
	//...
	CopyBan(const CopyBan&) = delete;
	CopyBan& operator = (const CopyBan&) = delete;
	//...
};

只能在堆上創(chuàng)建對象的類

實現(xiàn)方式：

將類的構(gòu)造函數(shù)私有，拷貝構(gòu)造聲明成私有。防止別人調(diào)用拷貝在棧上生成對象。

提供一個靜態(tài)的成員函數(shù)，在該靜態(tài)成員函數(shù)中完成堆對象的創(chuàng)建

class HeapOnly
{
public:
	//提供一個static公有函數(shù)創(chuàng)建對象，對象創(chuàng)建的都在堆上
	static HeapOnly* CreateObject()
	{
		return new HeapOnly;
	}
private:
	HeapOnly(){}

	//C++98 防拷貝 只聲明，不實現(xiàn)
	HeapOnly(const HeapOnly&);
	
	//C++11
	HeapOnly(const HeapOnly&) = delete;
};

只能在棧上創(chuàng)建對象的類

方法一：同上將構(gòu)造函數(shù)私有化，然后設(shè)計靜態(tài)方法創(chuàng)建對象返回即可。

class StackOnly
{
public:
	StackOnly(){}
public:
	//C++11
	void* operator new(size_t size) = delete;
	void operator delete(void* p) = delete;
private:
	//C++98 防調(diào)用
	void* operator new(size_t size);
	void operator delete(void* p);
};

屏蔽new

因為new在底層調(diào)用void* operator new(size_t size)函數(shù)，只需將該函數(shù)屏蔽掉即可。注意：也要防止定位new

class StackOnly
{
public:
	StackOnly(){}
private:
	void* operator new(size_t size);
	void operator delete(void* p);
};

不能被繼承的類

C++98

//C++98這種方式不夠直接
//這里是可以繼承的，但是Derive不能創(chuàng)建對象，因為Derive的構(gòu)造函數(shù)必須要調(diào)用父類NonOnherit構(gòu)造，但是NonInherit的構(gòu)造函數(shù)私有了，私有在子類不可見，那么這里繼承不會報錯，繼承的子類創(chuàng)建對象會報錯
class NonInherit
{
public:
	static NonInherit GetInstance()
	{
		return NonInherit();
	}
private:
	NonInherit()
	{}
};

C++11

final關(guān)鍵字，final修飾類，表示該類不能被繼承。

class A final
{
	//...
};

只能創(chuàng)建一個對象的類（單例模式）

設(shè)計模式

設(shè)計模式（Design Pattern）是一套被反復使用、多數(shù)人知曉的、經(jīng)過分類的、代碼設(shè)計經(jīng)驗的總結(jié)。為什么會產(chǎn)生設(shè)計模式這樣的東西呢？就像人類歷史發(fā)展會產(chǎn)生兵法。最開始部落之間打仗時都是人拼人的對砍。后來春秋戰(zhàn)國時期，七國之間經(jīng)常打仗，就發(fā)現(xiàn)打仗也是有套路的，后來孫子就總結(jié)出了《孫子兵法》。孫子兵法也是類似。

使用設(shè)計模式的目的：為了代碼可重用性、讓代碼更容易被他人理解、保證代碼可靠性。設(shè)計模式使代碼編寫真正工程化；設(shè)計模式是軟件工程的基石脈絡(luò)，如同大廈的結(jié)構(gòu)一樣。

單例模式

定義一個全局對象，大家都能用，也能保證單例，但這種方式存在很大的缺陷，你要讓大家都能用，這個對象就只能定義在一個.h，如果這個.h在多個.cpp包含，那么鏈接會報錯。全局靜態(tài)，只在當前文件可見，不再是同一個對象，每個xxx.cpp中各自是一個對象。 extern可以使鏈接不報錯，但不能保證全局只有唯一一個v，可能某個地方又重新定義了一個變量v 所以我們可以在.h中聲明，在.cpp中定義，聲明和定義分離。否則在.h中定義，多個cpp包含就會有多份。

某些類, 只應該具有一個對象(實例), 就稱之為單例.

在很多服務(wù)器開發(fā)場景中, 經(jīng)常需要讓服務(wù)器加載很多的數(shù)據(jù) (上百G) 到內(nèi)存中. 此時往往要用一個單例的類來管理這些數(shù)據(jù)

單例模式有兩種實現(xiàn)模式：餓漢實現(xiàn)方式和懶漢實現(xiàn)方式

[洗碗的例子]：吃完飯, 立刻洗碗, 這種就是餓漢方式. 因為下一頓吃的時候可以立刻拿著碗就能吃飯. 吃完飯, 先把碗放下, 然后下一頓飯用到這個碗了再洗碗, 就是懶漢方式. 懶漢方式最核心的思想是 “延時加載”. 從而能夠優(yōu)化服務(wù)器的啟動速度.

餓漢模式

在main函數(shù)之前，一開始就創(chuàng)建對象

.h：

//餓漢模式：main函數(shù)之前，一開始就創(chuàng)建對象
//全局只要唯一的Singleton實例對象，那么他里面的成員也就是單例的
class Singleton
{
public:
	//3.提供一個獲取單例對象的static成員函數(shù)
	static Singleton& GetInstance();

	//如果vector對象是私有，想訪問，只能再封裝一層
	//void PushBack(int x)
	//{
	//	_v.push_back(x);
	//}
	vector<int> _v;
private:
	//vector<int> _v;

	//1.構(gòu)造函數(shù)私有化，不能隨意創(chuàng)建對象
	Singleton()
	{}

	//防拷貝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//2.類里面聲明一個static Singleton對象，在cpp定義這個對象
	//保證全局只要一個唯一對象
	//這里的static類比的是全局變量，只是受類域的限制，沒有改變鏈接屬性
	static Singleton _sinst;
};

.cpp：

#include "Singleton.h"

//定義
Singleton Singleton::_sinst;

Singleton& Singleton::GetInstance()
{
	return _sinst;
}

優(yōu)點：簡單

缺點：main函數(shù)之前創(chuàng)建初始化的。如果單例對象的構(gòu)造函數(shù)中要做很多工作，可能會導致進程啟動慢。

且如果有多個單例類對象實例啟動順序不確定。

如果這個單例對象在多線程高并發(fā)環(huán)境下頻繁使用，性能要求較高，那么顯然使用餓漢模式來避免資源競爭，提高響應速度更好。

懶漢模式

餓漢式在應用啟動時就創(chuàng)建了實例，餓漢式是線程安全的，是絕對單例的。懶漢式在對外提供的獲取方法被調(diào)用時會實例化對象。在多線程情況下，懶漢模式不是線程安全的。

第一次使用實例對象時，創(chuàng)建對象。進程啟動無負載。多個單例實例啟動順序自由控制。

//定義
Singleton* Singleton::_spinst = nullptr;
mutex Singleton::_mtx;

Singleton& Singleton::GetInstance()
{
	//雙檢查加鎖 提高效率
	if (_spinst == nullptr)
	{
		_mtx.lock();
		if (_spinst == nullptr)
		{
			//第一次調(diào)用
			_spinst = new Singleton;
		}
		_mtx.unlock();
	}

	return *_spinst;
}

void Singleton::DelInstance()
{
	if (_spinst != nullptr)
	{
		_mtx.lock();
		if (_spinst != nullptr)
		{
			delete _spinst;
			_spinst = nullptr;
		}
		_mtx.unlock();
	}
}

#pragma once
#include <vector>
#include <iostream>
#include <mutex>
using namespace std;

//懶漢模式：第一次調(diào)用GetInstance時，才會創(chuàng)建初始化單例對象
//相對于餓漢，不存在可能會導致啟動慢的問題，也可以控制順序依賴的問題了
class Singleton
{
public:
	//3.提供一個獲取單例對象的static成員函數(shù)
	static Singleton& GetInstance();

	//如果vector對象是私有，想訪問，只能再封裝一層
	//void PushBack(int x)
	//{
	//	_v.push_back(x);
	//}
	vector<int> _v;

		//或?qū)崿F(xiàn)一個內(nèi)嵌垃圾回收類
	class CGarbo {
	public:
		~CGarbo() {
			if (Singleton::_spinst)
				delete Singleton::_spinst;
		}
	};

	//定義一個靜態(tài)成員變量，程序結(jié)束時，系統(tǒng)會自動調(diào)用它的析構(gòu)函數(shù)從而釋放單例對象
	static CGarbo Garbo;
	
private:
	//vector<int> _v;

	//1.構(gòu)造函數(shù)私有化，不能隨意創(chuàng)建對象
	Singleton()
	{}

	//防拷貝
	Singleton(const Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;

	//2.類里面聲明一個static Singleton對象，在cpp定義這個對象
	//保證全局只要一個唯一對象
	static Singleton* _spinst;
	static mutex _mtx;
};

到此這篇關(guān)于C++ 超詳細深入分析單例模式的文章就介紹到這了,更多相關(guān)C++ 單例模式內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: