C++單例模式實例分析

本篇內容介紹了“C++單例模式實例分析”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

不能被拷貝的類

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

C++98

將拷貝構造函數與賦值運算符重載只聲明不定義，并且將其訪問權限設置為私有即可。

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

原因：

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

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

C++11

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

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

只能在堆上創建對象的類

實現方式：

將類的構造函數私有，拷貝構造聲明成私有。防止別人調用拷貝在棧上生成對象。

提供一個靜態的成員函數，在該靜態成員函數中完成堆對象的創建

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

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

只能在棧上創建對象的類

方法一：同上將構造函數私有化，然后設計靜態方法創建對象返回即可。

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

屏蔽new

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

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

不能被繼承的類

C++98

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

C++11

final關鍵字，final修飾類，表示該類不能被繼承。

class A final
{
	//...
};

只能創建一個對象的類（單例模式）

設計模式

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

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

單例模式

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

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

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

單例模式有兩種實現模式：餓漢實現方式和懶漢實現方式

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

餓漢模式

在main函數之前，一開始就創建對象

.h：

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

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

	//1.構造函數私有化，不能隨意創建對象
	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;
}

優點：簡單

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

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

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

懶漢模式

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

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

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

Singleton& Singleton::GetInstance()
{
	//雙檢查加鎖 提高效率
	if (_spinst == nullptr)
	{
		_mtx.lock();
		if (_spinst == nullptr)
		{
			//第一次調用
			_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;

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

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

		//或實現一個內嵌垃圾回收類
	class CGarbo {
	public:
		~CGarbo() {
			if (Singleton::_spinst)
				delete Singleton::_spinst;
		}
	};

	//定義一個靜態成員變量，程序結束時，系統會自動調用它的析構函數從而釋放單例對象
	static CGarbo Garbo;
	
private:
	//vector<int> _v;

	//1.構造函數私有化，不能隨意創建對象
	Singleton()
	{}

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

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

“C++單例模式實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！