腳本之家服務器常用軟件

快捷導航

C++深入詳解單例模式與特殊類設(shè)計的實現(xiàn)

更新時間：2022年06月13日 14:27:47 作者：你算哪一個bug?

這篇文章主要為大家詳細介紹了C++單例模式和特殊類的設(shè)計，單例模式這種類型的設(shè)計模式屬于創(chuàng)建型模式，它提供了一種創(chuàng)建對象的最佳方式，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助

單例模式

什么是單例模式

單例模式（Singleton），保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。–大話設(shè)計模式

應用場景

保證一個類只有一個實例

如Windows下的任務管理器，回收站等。
日志管理，計數(shù)器等。

簡而言之，你需要唯一實例時就可以考慮單例模式。這樣它可以嚴格地控制客戶怎樣訪問即何時訪問它，即對唯一實例的受控訪問。

優(yōu)缺點

優(yōu)點

減少內(nèi)存開銷，因為在系統(tǒng)中只有一個實例。
避免了頻繁的創(chuàng)建和銷毀對象，提高了性能
避免對資源的多重占用，比如單例時多人只寫一個日志文件，如果有多個日志文件可能導致對相同的日志文件進行寫操作
設(shè)置全局訪問點

缺點

職責過重，與單一職責存在沖突
不能繼承（構(gòu)造方法私有）

實現(xiàn)

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

注意單例模式的概念，大概就是唯一實例且有全局訪問點，我們從這兩點入手。

唯一實例：構(gòu)造函數(shù)私有+防拷貝

拷貝構(gòu)造是一種構(gòu)造方式，所以需要防止，構(gòu)造函數(shù)私有不讓別人new。

全局訪問點：給一個公共的接口

餓漢模式

簡單來說，把東西一開始就做好，需要的時候直接吃。

#include <iostream>
using namespace std;
class Singleton
{
public:
	static Singleton& GetInstance()
	{
		return _instance;
	}
	int GetRandom()//由于側(cè)重點不是隨機數(shù) 所以直接返回一個30
	{
		return 30;
	}
private:
	Singleton() {}//構(gòu)造函數(shù)私有
	Singleton(Singleton&) = delete;//防拷貝，被=delete修飾表明這個函數(shù)被刪除，即可以只聲明不實現(xiàn),換言之禁用了該函數(shù)
	Singleton& operator=(const Singleton&) = delete;//防拷貝
	static Singleton _instance;
};
Singleton Singleton::_instance;//類外必須初始化，類內(nèi)只是聲明
int main()
{
	//1.調(diào)用
	cout<<Singleton::GetInstance().GetRandom()<<endl;
	//2.
	Singleton& s = Singleton::GetInstance();
	cout<<s.GetRandom()<<endl;
	return 0;
}

通過防拷貝和構(gòu)造函數(shù)私有化之后下面的幾種辦法都失效了

Singleton s;//err
Singleton s1(s);//err
Singleton s1=s;//err

從上面我們可以看出餓漢模式的優(yōu)缺點了，有點顯而易見就是實現(xiàn)很簡單粗暴，缺點很明顯，類加載時單例對象就已經(jīng)生成了，即還沒有用就已經(jīng)加載出來了，比如這個資源很大，又在游戲啟動時加載，那就會造成游戲啟動很慢。且如果有多個單例對象啟動時實例化順序不確定（不同源文件類內(nèi)的單例對象實例化順序是不確定的，懶漢模式解決了這個問題，因為懶漢模式的實例化在函數(shù)內(nèi)部，可以通過調(diào)用函數(shù)的順序來解決實例化的順序問題）。

類加載時靜態(tài)初始化解決了線程安全問題。

懶漢模式

什么時候需要就什么時候做飯，然后吃。

class Singleton
{
public:
	static Singleton* GetInstance()
	{
		if (_instance == nullptr)
		{
			_mtx.lock();//double lock保證線程安全
			if (_instance == nullptr)//必須再次檢查  不然可能另一個線程那已經(jīng)new完了，這邊又new違背了單例，且可能覆蓋數(shù)據(jù)。
			{
				_instance = new Singleton();
			}
			_mtx.unlock();
		}
		return _instance;
	}
	int GetRandom()
	{
		return 30;
	}
	class Clear//資源回收的內(nèi)部類，必須是公有的，不然外部聲明報錯
	{
	public:
		~Clear()
		{
			cout << "釋放資源" << endl;
			delete _instance;
		}
	};
private:
	static Clear _cle;
	Singleton() {}
	Singleton(Singleton&) = delete;
	Singleton& operator=(const Singleton&) = delete;
	static Singleton* _instance;
	static mutex _mtx;//線程安全
};
Singleton* Singleton::_instance = nullptr;
mutex Singleton::_mtx;
Singleton::Clear _cle;
int main()
{	
	//1.
	cout<<Singleton::GetInstance()->GetRandom()<<endl;
	//2/
	static Singleton* s = Singleton::GetInstance();
	cout << s->GetRandom() << endl;
	//不能用左值引用接收的原因  返回值是右值 得用右值引用接收
	//為什么函數(shù)返回值是右值  因為返回值是借助臨時變量返回的拿不到地址
	//如果返回值是左值引用就能用左值引用接收
	return 0;
}

懶漢模式的優(yōu)缺點也很明顯，優(yōu)點是什么時候第一次用就什么時候?qū)嵗送饪梢酝ㄟ^調(diào)用函數(shù)解決多個單例對象實例化的順序問題，缺點就是寫起來復雜，要考慮線程安全和內(nèi)存泄露方面的問題。懶漢采用的是指針也更好回收資源（餓漢采用的是對象）

懶漢可能因為多線程丟數(shù)據(jù)，線程加鎖保證在多線程環(huán)境下一定只有一個線程去new對象，只創(chuàng)建出一個單例對象，加鎖可能導致頻繁切換上下文，double lock解決。

特殊類設(shè)計

我們一般會通過構(gòu)造函數(shù)，拷貝構(gòu)造和賦值重載創(chuàng)建對象，現(xiàn)在把這幾種方法全禁用了，然后自己再寫一個外部可調(diào)用的接口來自定義類的創(chuàng)建方式。

當然也有別的辦法，這種經(jīng)常可以作為一種通解思路。

下面的禁用采用C++11的delete關(guān)鍵字實現(xiàn)，作用是禁止編譯器生成默認的函數(shù)版本，即有聲明但無實現(xiàn)。

設(shè)計一個類只能在堆上創(chuàng)建對象

簡單來說只能通過new來創(chuàng)建對象。

方法一

構(gòu)造方法禁用，然后給一個接口讓外部調(diào)用。

構(gòu)造方法的禁用=構(gòu)造函數(shù)私有+禁用拷貝構(gòu)造+禁用賦值重載

class HeapOnly
{
public:
	static HeapOnly* GetInstance()
	{
		return new HeapOnly;
	}
	void Test()
	{
		cout << "I am Test" << endl;
	}
private:
	HeapOnly() {}
	HeapOnly(HeapOnly&) = delete;
	HeapOnly& operator=(const HeapOnly&) = delete;
};
int main()
{	
	HeapOnly* ho = HeapOnly::GetInstance();
	ho->Test();
	delete ho;
	return 0;
}

方法二

析構(gòu)函數(shù)私有

對象建立在棧上，是由編譯器分配空間的，編譯器管理對象的生命周期，對象使用完后編譯器會檢查這個對象所有的非靜態(tài)函數(shù)，包括析構(gòu)函數(shù)，當編譯器發(fā)現(xiàn)析構(gòu)函數(shù)不能訪問后就不能回收這塊空間，所以編譯器無法為其分配空間，編譯器檢查到這種情況也會報錯。

析構(gòu)函數(shù)私有的方法不建議使用，因為在類外無法使用delete釋放空間，容易造成內(nèi)存泄漏。

class HeapOnly
{
public:
	void Test()
	{
		cout << "I am Test" << endl;
	}
private:
	~HeapOnly();
};
int main()
{	
	//HeapOnly ho_stack;//err
	HeapOnly* ho = new HeapOnly;
	ho->Test();
	return 0;
}

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

方法一

不能使用new --> 重載operator new即可。

這種存在一個缺陷，就是仍然可以在靜態(tài)區(qū)創(chuàng)建對象

方法二

將構(gòu)造函數(shù)設(shè)為私有再自定義一個接口

這里不用禁用構(gòu)造函數(shù)，拷貝構(gòu)造，賦值重載，因為對于下面的場景來說，匿名對象的拷貝構(gòu)造更符合場景，編譯器會選拷貝構(gòu)造來進行構(gòu)造，所以如果我們禁用了拷貝構(gòu)造會報錯，因為我們的delete關(guān)鍵字是有聲明無實現(xiàn)，并不是真的把這個函數(shù)連帶聲明刪除了。所以StackOnly()一看有我們自己寫的拷貝構(gòu)造的聲明就會去匹配這個拷貝構(gòu)造，我們自己寫的拷貝構(gòu)造又沒有實現(xiàn)拷貝功能就會報錯。

理解這個和編譯鏈接知識有關(guān)，編譯器看到聲明就去匹配了，而不是一定要看到函數(shù)實現(xiàn)才匹配，鏈接時候才會去找實現(xiàn)，當發(fā)現(xiàn)有聲明無實現(xiàn)時就很容易導致鏈接錯誤。