C++特殊類設計（單例模式等）

引言

1.請設計一個類，不能被拷貝

2. 請設計一個類，只能在堆上創建對象

為什么設置實例的方法為靜態成員呢

3. 請設計一個類，只能在棧上創建對象

4. 請設計一個類，不能被繼承

5. 請設計一個類，只能創建一個對象(單例模式)

餓漢模式

懶漢模式

單例對象一般不考慮析構

為什么私有析構呢？

引言

在當今的軟件開發實踐中，特殊類設計模式扮演著至關重要的角色，它們不僅提高了代碼的可維護性和可擴展性，還確保了系統的穩定性和性能。其中，單例模式作為最常用的設計模式之一，以其獨特的實例管理方式，成為了許多場景下的首選解決方案。本文旨在探討C++中單例模式及其他特殊類設計的精髓，通過分析其背后的設計哲學和實現技巧，幫助讀者掌握這些高級編程技巧，以提升其在軟件開發過程中的設計能力和代碼質量。

在我們設計一個特殊類的時候，一般要把構造、拷貝和賦值私有保護，防止被其他類拷貝或者產生不想要（意料之外）的錯誤。

1.請設計一個類，不能被拷貝

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

只需讓該類不能調用拷貝構造函數以及賦值運算符重載即可 。

C++98

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

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

C++11

C++11擴展delete的用法，delete除了釋放new申請的資源外，如果在默認成員函數后跟上

=delete，表示讓編譯器刪除掉該默認成員函數。

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

同時我們還可以設置一個基類，讓子類繼承基類，讓子類正常實現功能，設置基類不可被拷貝即可。

2. 請設計一個類，只能在堆上創建對象

實現方式：

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

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

只能在堆上創建對象，即只能new對象，不允許在棧上創建臨時變量。當然要禁用拷貝、構造、賦值函數（非單例）

class HeapOnly ? ?
{ ? ? 
public: ? ? static HeapOnly* CreateObject() ?{ ? ? ?return new HeapOnly; ? ?}
private: ? ?HeapOnly() {}// C++98// 1.只聲明,不實現。因為實現可能會很麻煩，而你本身不需要// 2.聲明成私有HeapOnly(const HeapOnly&)；// or// C++11 ? ?HeapOnly(const HeapOnly&) = delete;
}

由于沒有this指針，無法調用構造，而是只是去new這個鍍錫，由系統去完成資源的申請

靜態不能調用非靜態就是因為沒有this指針，缺少調用的參數

但是new和delete這種操作不需要this指針

那每次調的時候，返回的都是一個新的靜態對象嗎？--- NO！這個方法是靜態的，但是返回的變量不是靜態的

為什么設置實例的方法為靜態成員呢

收線確定的是，一定是內部new創建的對象。

因為如果設置為非靜態成員，那就只能通過對象去調用，但是我們不能去在棧區創建對象。

并且構造私有，外部一定不可以創建對象，只能用類調用，所以必須靜態！

為什么禁用拷貝構造：比如A a1(a2)；這樣a1依然是在棧區！

3. 請設計一個類，只能在棧上創建對象

只能通過類型創建，禁止new對象

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

依然需要把構造私有，需要注意的是，不能把構造和拷貝工構造私有

class StackOnly
{
public:static StackOnly CreateObj(){StackOnly obj;return obj;}void* operator new(size_t size) = delete;void operator delete(void* p) = delete;
private:StackOnly() ?:_a(0){}
private:int _a;
};

1.設置為靜態：

并且構造私有，外部一定不可以創建對象，只能用類調用，所以必須靜態！

2.為什么不可以禁用拷貝構造：比如A a1(a2)；這樣a1依然是在棧區！符合要求，并且匿名對象的聲明周期只在這一行！為了防止匿名對象周期太短，無法進行較好的連續性開發，所以需要賦值給另一個棧區的對象。

3.可以返回臨時對象，只需要賦值給其他對象即可（棧區）；也可以返回非匿名對象，也是采用賦值的方式進行連續性開發。

4.為了防止創建堆區對象，需要禁用new和delete（為了防止創建棧區對象時，需要禁用拷貝、賦值）

????????

4. 請設計一個類，不能被繼承

C++98方式

// C++98中構造函數私有化，派生類中調不到基類的構造函數。則無法繼承
class NonInherit
{
public:static NonInherit GetInstance(){return NonInherit();}
private:NonInherit(){}
};

C++11方法

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

class A ?final
{// ....
};

5. 請設計一個類，只能創建一個對象(單例模式)

設計模式：

設計模式（Design Pattern）是一套 被反復使用、多數人知曉的、經過分類的、代碼設計經驗的

總結。為什么會產生設計模式這樣的東西呢？就像人類歷史發展會產生兵法。最開始部落之間打

仗時都是人拼人的對砍。后來春秋戰國時期，七國之間經常打仗，就發現打仗也是有套路的，后

來孫子就總結出了《孫子兵法》。孫子兵法也是類似。

使用設計模式的目的：為了代碼可重用性、讓代碼更容易被他人理解、保證代碼可靠性。設計模

式使代碼編寫真正工程化；設計模式是軟件工程的基石脈絡，如同大廈的結構一樣。

單例模式：

一個類只能創建一個對象，即單例模式，該模式可以保證系統中該類只有一個實例，并提供一個

訪問它的全局訪問點，該實例被所有程序模塊共享。比如在某個服務器程序中，該服務器的配置

信息存放在一個文件中，這些配置數據由一個單例對象統一讀取，然后服務進程中的其他對象再

通過這個單例對象獲取這些配置信息，這種方式簡化了在復雜環境下的配置管理。

單例模式有兩種實現模式：

餓漢模式

餓漢模式：已經餓得不行了，要求立刻有東西吃，即在main函數之前就得創建好---全局

餓漢：設置為全局，提前創建。

既然是單例，一定先把構造私有。

在類的外部雖然不能創建全局的對象，但是在類的內部可以創建。----思路：類的內部聲明靜態成員，類的外部定義，這樣就是一個全局的數據。

demo

// 懶漢模式：第一次用的時候再創建（現吃現做）
class A {
public:static A* GetInstance() {return _inst;}
private:A() {}map<string, string> _dict;int _n = 0;static A* _inst;
};

我們在類的內部創建對象的時候，當然不能

? ?class? ? ? ? A

｛

? ? ? ? A? ?_a；

??｝

這樣屬于嵌套定義。

但是也不能內部用靜態成員方法去獲取，因為函數需要在主函數內調用。

當我們在內部使用靜態成員的時候，當然不是嵌套定義，因為靜態不屬于某個對象，而是屬于整個類。并且，我們只能是在類內聲明，并沒有定義，需要在類的外部定義。

在類的外部定義的時候，只需要點名：類型 + 作用域即可，不需要再次聲明靜態，靜態只需要聲明一次即可，但是定義（實例化），必須使用類型。

當需要使用這個實例的時候，調用實例方法去獲取即可。

總結：

1.類內聲明靜態，類外實例化靜態（全局）

2.類內提供獲取實例的犯法

同時刪除拷貝構造和賦值

訪問成員需要借助對象，這時候就需要調用GetInstance函數

優點：創建簡單?

缺點：1.進程啟動慢

?????????? 2.一旦存在兩個全局單例，不能控制單例啟動的先后順序。

懶漢模式

現吃現做，不著急，main函數內創建。

? 只需要把靜態的對象換成指針即可，獲取實例的時候，如果指針是nullptr，那么創建，如果不是，那么直接返回

線程不安全，兩個線程同時進來，可能會new兩個對象---加鎖

單例對象一般不考慮析構

惡漢不存在釋放的問題--全局，

懶漢對象也一般不需要釋放---單例對象一般是生命周期伴隨整個程序，對整個程序都起到至關重要的作用，進程結束時，會自動釋放。

就算要釋放，如果我們期望既可以手動釋放（析構不能手動釋放），也可以在main函數結束時自動釋放

class B
{
public:static B* GetInstance(){if (_inst == nullptr){_inst = new B;}return _inst;}static void DelInstance(){if (_inst){delete _inst;_inst = nullptr;}}private:B(){}~B(){// 持久化：要求把數據寫到文件cout << "數據寫到文件" << endl;}B(const B& aa) = delete;B& operator=(const B& aa) = delete;map<string, string> _dict;int _n = 0;static B* _inst;class gc{public:~gc(){DelInstance();}};static gc _gc;
};B* B::_inst = nullptr;
B::gc B::_gc;

可以私有析構函數

提供一個調用析構函數的接口DelInstance，我們可以手動調用這個接口去進行析構。

我們新建一個內部類，這個內部類是外部類的友元，可以訪問私有。等main函數結束的時候_gc調用析構，析構會調用DelInstance。

這樣可以做到：1.顯示釋放（析構不允許顯示調用，但是delete指針的時候，可以調用析構）

? ? ? ? ? ? ? ? ? ? ? ? 2.沒有顯示釋放，等程序結束也會釋放