模式
? ? ? ? ?在一定環境中解決某一問題的方案，包括三個基本元素--問題，解決方案和環境。
? ? ? ? ?大白話：在一定環境下，用固定套路解決問題。
設計模式（Design pattern）
是一套被反復使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。使用設計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。 毫無疑問，設計模式于己于他人于系統都是多贏的；設計模式使代碼編制真正工程化；設計模式是軟件工程的基石脈絡，如同大廈的結構一樣。
設計模式的分類（Gang of Four的“DesignPatterns: Elements of Resualbel Software”書將設計模式歸納為三大類型，共23種）
? ? ? ? 創建型模式 : ?通常和對象的創建有關，涉及到對象實例化的方式。（共5種模式)
? ? ? ? 結構型模式： 描述的是如何組合類和對象以獲得更大的結構。(共7種模式)
? ? ? ? 行為型模式： 用來對類或對象怎樣交互和怎樣分配職責進行描述。(共11種模式)

創建型模式用來處理對象的創建過程，主要包含以下5種設計模式：?
1: 單例模式（Singleton Pattern）是保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。
2: 工廠模式（Factory Method Pattern）的用意是定義一個創建產品對象的工廠接口，將實際創建工作推遲到子類中。
3: 抽象工廠模式（Abstract Factory Pattern）的意圖是提供一個創建一系列相關或者相互依賴的接口，而無需指定它們具體的類。
4: 建造者模式（Builder Pattern）的意圖是將一個復雜的構建與其表示相分離，使得同樣的構建過程可以創建不同的表示。
5: 原型模式（Prototype Pattern）是用原型實例指定創建對象的種類，并且通過拷貝這些原型創建新的對象。

1.單例模式

代碼1:

#include <iostream> using namespace std; // //單例模式就是把“構造函數私有化”，就不能在類外構造對象了，只能在類里面調用構造函數，創建對象，讓后通靜態變量返回對象//------------單例模式（懶漢式）-------------------- /*所謂的懶漢式：就是在需要的使用對象的時候再創建對象的實例。就是當調用函數時，才創建類的對象。*/ class Singleton_lazy { private:Singleton_lazy(){cout << "Singleton_lazy 構造函數" << endl;} public:static Singleton_lazy* getInstance(){//判斷是否為空，用來限制創建單個實例（就是在此處限制只能產生單個實例）if (m_pSingleton == NULL){//如果不為空，開辟空間，返回指針(使用new時，會自動調用構造函數)m_pSingleton = new Singleton_lazy; //創建類的對象}return m_pSingleton;}static void freeInstance(){if (m_pSingleton != NULL){//“指針變量”和指針所“指向的內存空間”是兩個不同的概念delete m_pSingleton; //釋放所指向的內存空間m_pSingleton = NULL; //讓指指向NULL}} private:static Singleton_lazy *m_pSingleton;int temp; }; int globleVar = 10; //靜態成員的初始化 Singleton_lazy* Singleton_lazy::m_pSingleton = NULL;// //------------單例模式（餓漢式）-------------------- class Singleton_hungry { private:Singleton_hungry(){cout << "Singleton_hungry 構造函數" << endl;} public:static Singleton_hungry* getInstance(){return m_pSingleton_h;}static void freeInstance(){if (m_pSingleton_h != NULL){delete m_pSingleton_h;m_pSingleton_h = NULL;}} private:static Singleton_hungry* m_pSingleton_h;int temp; };/*☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆ 全局變量優先于main函數，所以輸出結果是先顯示“pSingleton1和pSingleton2是一個實例” 這也是餓漢模式的原理：就是靜態變量在類外面初始化，并且在類的聲明的下面。 在編譯的時候，先給類開辟空間，然后給全局變量開辟空間，并給全局變量初始化。 全局變量調用類的構造，構造一個對象，然后開始進入main函數，執行main函數體。 ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆*///餓漢式和懶漢式不同的地方。就是靜態變量先new 一個對象，全局變量的初始化優先于main函數執行。所以先顯示“pSingleton1和pSingleton2是一個實例” Singleton_hungry* Singleton_hungry::m_pSingleton_h = new Singleton_hungry;int main() {//------------------------懶漢式--------------------------------Singleton_lazy *pSingleton1 = Singleton_lazy::getInstance();Singleton_lazy *pSingleton2 = Singleton_lazy::getInstance();if (pSingleton1 == pSingleton2){cout << "pSingleton1和pSingleton2是一個實例" << endl;}else{cout << "pSingleton1和pSingleton2不是同一個實例" << endl;}Singleton_lazy::freeInstance();//-------------------------餓漢式------------------------------------Singleton_hungry *pSingleton_h1 = Singleton_hungry::getInstance();Singleton_hungry *pSingleton_h2 = Singleton_hungry::getInstance();if (pSingleton_h1 == pSingleton_h2){cout << "pSingleton_h1和pSingleton_h2是同一個實例" << endl;}else{cout << "pSingleton_h1和pSingleton_h2不是同一個實例" << endl;}Singleton_hungry::freeInstance();system("pause"); }

懶漢式單實例和多線程問題

代碼2： #include "stdafx.h" #include "windows.h" #include "winbase.h" #include "afxmt.h" #include <process.h> #include <stdlib.h> #include <iostream> using namespace std;/*☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆懶漢模式和多線程結合時，當在構造函數中Sleep 時，當一個線程創建對象并進入構造函數時，會先把線程掛起，然后下一個線程再次創建對象并進入構造函數時,也會掛起線程，此時，每個線程判定m_p_t都是NULL,這樣會導致創建多個對象。也就是每個線程都會創建一個類的對象，這就變成多實例，而不是單實例，同時還會出現資源共享的情況，可能出現資源鎖。也就是搶占資源，會造成程序的輸出不確定的結果。這就是線程間的同步問題。為了保證線程的同步，可以使用臨界區技術。(還可以使用互斥量、信號量)就是把線程共享的部分鎖定，保證相同的部分每次都只有一個線程進行操作。臨界區（Critical Section）。臨界區對象通過提供一個進程內所有線程必須共享的對象來控制線程。只有擁有那個對象的線程可以訪問保護資源。在另一個線程可以訪問該資源之前，前一個線程必須釋放臨界區對象，以便新的線程可以索取對象的訪問權。互斥量（Mutex Semaphore）。互斥量的工作方式非常類似于臨界區，只是互斥量不僅保護一個進程內為多個線程使用的共享資源，而且還可以保護系統中兩個或多個進程之間的的共享資源。信號量（Semaphore）。信號量可以允許一個或有限個線程訪問共享資源。它是通過計數器來實現的，初始化時賦予計數器以可用資源數，當將信號量提供給一個線程時，計數器的值減1，當一個線程釋放它時，計數器值加1。當計數器值小于等于0時，相應線程必須等待。信號量是Windows98同步系統的核心。從本質上講，互斥量是信號量的一種特殊形式。 ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆*/class Singleton_lazy_thread { private:Singleton_lazy_thread(){ cout << "Singleton_lazy_thread() 構造函數begin\n";Sleep(1000);cout << "Singleton_lazy_thread() 構造函數end\n";} public:static Singleton_lazy_thread* getInstance(){if (m_p_t == NULL){count++;m_p_t=new Singleton_lazy_thread;}return m_p_t;}static void freeInstance(){if (m_p_t != NULL){delete m_p_t;m_p_t = NULL;} }static void printS() //測試函數{cout << "Singleton_lazy_thread printS test" << endl;} private:static Singleton_lazy_thread* m_p_t;static int count;int temp; };Singleton_lazy_thread* Singleton_lazy_thread::m_p_t = NULL; int Singleton_lazy_thread::count = 0; void MyThreadFunc(void *) {//cout << "我是線程體 ...." << endl;cout << "我是線程體 ....\n";Singleton_lazy_thread::getInstance()->printS(); }// /*--------------------------使用臨界區技術（鎖定線程公共操作部分）-----------------------------*/ // 線程同步問題 //臨界區 //類CCriticalSection的對象表示一個“臨界區”，它是一個用于同步的對象， //同一時刻只允許一個線程存取資源或代碼區。 //臨界區在控制一次只有一個線程修改數據或其它的控制資源時非常有用。 //使用時必須包含頭文件#include "afxmt.h" static CCriticalSection cs;class Singleton_lazy_thread_Sync { private:Singleton_lazy_thread_Sync(){//TRACE()宏一般是用在mfc中的，用于將調試信息輸出到vs的輸出窗口中(這是關鍵),//這在使用vs作為開發工具的時候，是非常方便的。//TRACE("Singleton begin\n");m_count++;cout << "Singleton_lazy_thread_Sync() 構造函數begin\n";Sleep(1000);cout << "Singleton_lazy_thread_Sync() 構造函數end\n";//TRACE("Singleton end\n");}Singleton_lazy_thread_Sync(const Singleton_lazy_thread_Sync&);Singleton_lazy_thread_Sync& operator=(const Singleton_lazy_thread_Sync&); public: static Singleton_lazy_thread_Sync* getInstance(){if (m_p_t_Sync == NULL) //第一次檢查看實例有沒有被創建{cs.Lock(); //只有當pInstance等于null時，才開始使用枷鎖機制 二次檢查//第二個線程在創建時不知道第一個線程已經創建了，//所以在臨界區檢查，防止被多次創建(著名的二次檢查)if (m_p_t_Sync == NULL) //double check 。第二次檢查，{ m_count++;m_p_t_Sync = new Singleton_lazy_thread_Sync;}cs.Unlock();}return m_p_t_Sync;}static void freeInstance(){if (m_p_t_Sync != NULL){delete m_p_t_Sync;m_p_t_Sync = NULL;}}static void printS() //測試函數{cout << "Singleton_lazy_thread_Sync printS test" << endl;}static void printV(){//TRACE("printV..m_count:%d \n", m_count);cout << "printV..m_count:" << m_count << endl;} private:static Singleton_lazy_thread_Sync* m_p_t_Sync;static int m_count;int temp; }; Singleton_lazy_thread_Sync & Singleton_lazy_thread_Sync::operator=(const Singleton_lazy_thread_Sync &) {// TODO: 在此處插入 return 語句 } Singleton_lazy_thread_Sync* Singleton_lazy_thread_Sync::m_p_t_Sync = NULL; int Singleton_lazy_thread_Sync::m_count = 0; void MyThreadFuncSync(void *) {//cout << "我是線程體 ...." << endl;cout << "我是線程體 ....\n";Singleton_lazy_thread_Sync::getInstance()->printV(); }int main() {HANDLE hThread1[10];for (int i = 0; i < 3;i++){hThread1[i] = (HANDLE)_beginthread(MyThreadFunc, 0, NULL);}for (int i = 0; i < 3;i++){WaitForSingleObject(hThread1[i], INFINITE);}cout << "hello word" << endl;//cout << "---------------線程同步問題---------------" << endl;int i = 0;DWORD dwThreadId[201], dwThrdParam = 1;HANDLE hThread[201];int threadnum = 3;for (i = 0; i < threadnum; i++){//hThread[i] = (HANDLE)_beginthreadex( NULL, 0, &threadfunc, NULL, 0,&dwThreadId[i] );hThread[i] = (HANDLE)_beginthread(&MyThreadFuncSync, 0, 0);if (hThread[i] == NULL){//TRACE("begin thread %d error!!!\n", i);printf("begin thread %d error!!!\n", i);break;}}for (i = 0; i < threadnum; i++){WaitForSingleObject(hThread[i], INFINITE);}system("pause");return 0; }

2.工廠模式

#include <iostream> #include <stdlib.h> using namespace std;class Fruit { public:virtual void getFruit() = 0; protected: private: };class Banana:public Fruit { public:virtual void getFruit(){cout << "我是香蕉" << endl;} protected: private: };class Apple :public Fruit { public:virtual void getFruit(){cout << "我是蘋果" << endl;} protected: private: };class Pear :public Fruit { public:virtual void getFruit(){cout << "我是梨" << endl;} protected: private: };//--------------------------簡單工廠模式。------------------------ //也就是所有的操作都是在類里面完成的，不符合設計模式的設計規則 //所以可以進行改進。 class Factory_Simple { public:Fruit* produceFruit(char* p){if (strcmp(p, "banana") == 0){return new Banana;}if (strcmp(p, "apple") == 0){return new Apple;}if (strcmp(p, "pear") == 0){return new Pear;}else{printf("不支持\n");return NULL;}} protected: private: };// /*改進后的工廠模式 為每個對象都產生一個單獨的工廠，專門生產一種產品。 */ class Factory { public:virtual Fruit* produceFruit() = 0; protected: private: };class BananaFactory:public Factory { public://函數的返回值是一個父類的指針virtual Fruit* produceFruit(){//函數體里面返回的是一個子類的指針//通過父類的指針或者引用來調用子類的函數，實現多態return new Banana;} protected: private: };class AppleFactory:public Factory { public:virtual Fruit* produceFruit(){return new Apple;} protected: private: }; class PearFactory :public Factory { public:virtual Fruit* produceFruit(){return new Pear;} protected: private: };int main() {cout << endl << "---------簡單工廠模式---------" << endl;Fruit* fruit = NULL;Factory_Simple* factorySimple = new Factory_Simple;fruit = factorySimple->produceFruit("banana");fruit->getFruit();delete fruit;fruit = NULL;fruit = factorySimple->produceFruit("apple");fruit->getFruit();delete fruit;fruit = NULL;fruit = factorySimple->produceFruit("pear");fruit->getFruit();delete factorySimple;delete fruit;fruit = NULL;factorySimple = NULL;system("pause");////改進后的工廠(工廠抽象成一個虛基類)cout << endl << "---------改進后的工廠模式---------" << endl;Factory *factory = NULL;factory = new BananaFactory;fruit = factory->produceFruit();fruit->getFruit();delete factory;delete fruit;fruit = NULL;factory = new AppleFactory;fruit = factory->produceFruit();fruit->getFruit();delete factory;delete fruit;fruit = NULL;factory = new PearFactory;fruit = factory->produceFruit();fruit->getFruit();delete factory;delete fruit;system("pause");return 0; }

3.抽象工廠模式

#include <iostream> #include <stdlib.h> using namespace std;class Fruit { public:virtual void getFruitName() = 0; protected: private: };class Banana :public Fruit { public:virtual void getFruitName(){cout << "香蕉" << endl;} protected: private: }; class Apple :public Fruit { public:virtual void getFruitName(){cout << "蘋果" << endl;} protected: private: }; class Pear : public Fruit { public:virtual void getFruitName(){cout << "梨" << endl;} protected: private: }; class Mango : public Fruit { public:virtual void getFruitName(){cout << "芒果" << endl;} protected: private: };////工廠模式只能生產一個產品。（要么香蕉、要么蘋果） //抽象工廠可以一下生產一個“產品族”（里面有很多產品組成）,就是可以生產多種產品。//缺點是： //抽象工廠的缺點就是產品線寫死了。 //如果需要添加新的產品，就需要在原來抽象類上改 // class AbstractFactory { public://抽象工廠的缺點就是產品線寫死了。//如果需要添加新的產品，就需要在原來抽象類上改virtual Fruit* produceBanana() = 0;virtual Fruit* produceApple() = 0;virtual Fruit* producePear() = 0;virtual Fruit* produceMango() = 0; protected: private: };class Factory : public AbstractFactory { public:virtual Fruit* produceApple(){return new Apple;}virtual Fruit* produceBanana(){return new Banana;}virtual Fruit* producePear(){return new Pear;}virtual Fruit* produceMango(){return new Mango;} protected: private: };int main() {cout << "---------------抽象工廠模式---------------" << endl;Factory* factory = new Factory;Fruit* fruit = NULL;fruit = factory->produceApple();fruit->getFruitName();delete fruit;fruit = NULL;fruit = factory->produceBanana();fruit->getFruitName();delete fruit;fruit = NULL;fruit = factory->producePear();fruit->getFruitName();delete fruit;fruit = NULL;fruit = factory->produceMango();fruit->getFruitName();delete fruit;fruit = NULL;delete factory;factory = NULL;system("pause");return 0; }

4.建造者模式

#include <iostream> #include <stdlib.h> #include <string> using namespace std;// /* 1) Builder：為創建產品各個部分，統一抽象接口。 2) ConcreteBuilder：具體的創建產品的各個部分，部分A， 部分B，部分C。 3) Director：構造一個使用Builder接口的對象。 4) Product：表示被構造的復雜對象。 ConcreteBuilder創建該產品的內部表示并定義它的裝配過程，包含定義組成部件的類， 包括將這些部件裝配成最終產品的接口。適用情況： 一個對象的構建比較復雜，將一個對象的構建（？）和對象的表示（？）進行分離。建造者模式設計三個類對象（案例）：設計者(也叫指揮者)、工程隊（可以造別墅、平房、四合院等），房子（有門、窗戶、墻等） */ ///建造者模式產生原因///class House_Previous { public://set 屬性void setDoor(string door){ this->m_door = door; }void setWindow(string window){ this->m_window = window; }void setWall(string wall){ this->m_wall = wall; }//get 屬性string getDoor(){ cout << m_door << endl; return m_door; }string getWindow(){ cout << m_window << endl; return m_window; }string getWall(){ cout << m_wall << endl; return m_wall; } protected: private:string m_door;string m_window;string m_wall; };class Builder_Previous { public:Builder_Previous(){this->m_house = new House_Previous;}void buildHouse(){buildDoor();buildWindow();buildWall();}void buildDoor(){m_house->setDoor("門");}void buildWindow(){m_house->setWindow("窗戶");}void buildWall(){m_house->setWall("墻壁");}House_Previous* getHouse(){return m_house;} protected: private:House_Previous *m_house; };///建造者模式/ /*建造者模式設計三個類對象（案例）：設計者(也叫指揮者、主管)、------------------ class Director 主管類工程隊（可以造別墅、平房、四合院等），------ class Builder 工程隊類房子（有門、窗戶、墻等）-------------------- class House 房子類擴展：設計師(指揮者) 負責建造邏輯。建筑隊 干具體的活再讓設計師分三六九等，指揮三六九等建筑隊，建造三六九等的房子也就是可以把設計師在細化分類，建筑隊也可以再細化分類，房子同樣可以細化不同的房子。就是“主管抽象、工程隊抽象、房子抽象”。 */class House { public:virtual void setDoor(string door){}; //虛函數必須有實現代碼，純虛函數可以沒實現代碼。virtual void setWindow(string window){};virtual void setWall(string wall){};string getDoor(){ cout << m_door << endl; return m_door; };string getWindow(){ cout << m_window << endl; return m_window; };string getWall(){ cout << m_wall << endl; return m_wall; };protected:string m_door;string m_window;string m_wall; private: };//平房、公寓 class Flat :public House { public:virtual void setDoor(string door){ this->m_door = door; }virtual void setWindow(string window){ this->m_window = window; }virtual void setWall(string wall){ this->m_wall = wall; } protected: private: };// 樓房 class Floor :public House { public:virtual void setDoor(string door){ this->m_door = door; }virtual void setWindow(string window){ this->m_window = window; }virtual void setWall(string wall){ this->m_wall = wall; } protected: private: };// 別墅 class Villa :public House { public:virtual void setDoor(string door){ this->m_door = door; }virtual void setWindow(string window){ this->m_window = window; }virtual void setWall(string wall){ this->m_wall = wall; } protected: private: };class Builder //建造者 { public:/*void buildHouse(){buildDoor();buildWindow();buildWall();}*/virtual void buildHouse() = 0;virtual void buildDoor() = 0;virtual void buildWindow() = 0;virtual void buildWall() = 0; protected:House *m_house; private: };class SanDengBuilder : public Builder //三等builder { public:SanDengBuilder(House* house){m_house = house; }virtual void buildHouse(){buildDoor();buildWindow();buildWall();}virtual void buildDoor(){m_house->setDoor("三等門");}virtual void buildWindow(){m_house->setWindow("三等窗戶");}virtual void buildWall(){m_house->setWall("三等墻壁");} protected: private: }; class LiuDengBuilder : public Builder // 六等builder { public:LiuDengBuilder(House *house){m_house = house; }virtual void buildHouse(){buildDoor();buildWindow();buildWall();}virtual void buildDoor(){m_house->setDoor("六等門");}virtual void buildWindow(){m_house->setWindow("六等窗戶");}virtual void buildWall(){m_house->setWall("六等墻壁");} protected: private: }; class JiuDengBuilder : public Builder //九等builder { public:JiuDengBuilder(House *house){m_house = house; }virtual void buildHouse(){buildDoor();buildWindow();buildWall();}virtual void buildDoor(){m_house->setDoor("九等門");}virtual void buildWindow(){m_house->setWindow("九等窗戶");}virtual void buildWall(){m_house->setWall("九等墻壁");} protected: private: };class Director { public:virtual void Construct() = 0; protected:Builder* m_builder; private: };class SanDengDirector : public Director { public:SanDengDirector(Builder *builder){m_builder = builder;}virtual void Construct(){m_builder->buildDoor();m_builder->buildWindow();m_builder->buildWall();} protected: private: };class LiuDengDirector : public Director { public:LiuDengDirector(Builder *builder){m_builder = builder;}virtual void Construct(){m_builder->buildDoor();m_builder->buildWindow();m_builder->buildWall();} protected: private: };class JiuDengDirector : public Director { public:JiuDengDirector(Builder *builder){m_builder = builder;}virtual void Construct(){m_builder->buildDoor();m_builder->buildWindow();m_builder->buildWall();} protected: private: };int main() {cout << "-----------------客戶直接造房子-----------------" << endl;House_Previous *house_pre = new House_Previous;house_pre->setDoor("門");house_pre->setWindow("窗戶");house_pre->setWall("墻壁");house_pre->getDoor();house_pre->getWindow();house_pre->getWall();delete house_pre; house_pre = NULL;cout << "-----------------工程隊造房子-----------------" << endl;Builder_Previous *builder_Previous = new Builder_Previous;builder_Previous->buildDoor();builder_Previous->buildWindow();builder_Previous->buildWall();house_pre = builder_Previous->getHouse();house_pre->getDoor();house_pre->getWindow();house_pre->getWall();delete house_pre; house_pre = NULL;delete builder_Previous; builder_Previous = NULL;cout << "---------------建造者模式------------------" << endl;//定義房子Flat *flat = new Flat; //平房Floor *floor = new Floor; //樓房Villa *villa = new Villa; //別墅//定義基類的指針Director *director = NULL;Builder *builder = NULL;House* house = NULL;SanDengBuilder *sanBuilder = new SanDengBuilder(flat);LiuDengBuilder *liuBuilder = new LiuDengBuilder(floor);JiuDengBuilder *jiuBuilder = new JiuDengBuilder(villa);cout << "---------三等指揮，三等建造者，建設平房-------------" << endl;director = new SanDengDirector(sanBuilder);director->Construct();flat->getDoor();flat->getWindow();flat->getWall();cout << "---------三等指揮，三等建造者，建設樓房-------------" << endl;director = new SanDengDirector(liuBuilder);director->Construct();floor->getDoor();floor->getWindow();floor->getWall();cout << "---------三等指揮，三等建造者，建設別墅-------------" << endl;director = new SanDengDirector(jiuBuilder);director->Construct(); villa->getDoor();villa->getWindow();villa->getWall();cout << endl << "因為new的太多，不再一個一個刪除，先不用管內存泄露" << endl;system("pause");return 0; }

5.原型模式

#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <stdlib.h> #include <string> using namespace std;// /* 原型模式 Prototype模式是一種對象創建型模式，它采取復制原型對象的方法來創建對象的實例。 使用Prototype模式創建的實例，具有與原型一樣的數據。 1）由原型對象自身創建目標對象。也就是說，對象創建這一動作發自原型對象本身。 2）目標對象是原型對象的一個克隆。也就是說，通過Prototype模式創建的對象，不僅僅與原型對象具有相同的結構，還與原型對象具有相同的值。 3）根據對象克隆深度層次的不同，有淺度克隆與深度克隆。其實原型模式就是返回一個和自己一模一樣的類型的數據（深淺拷貝）*/ //class Person { public:virtual Person* clone() = 0;virtual void printT() = 0; protected:string m_name;int m_age;char *m_resume; private: };class CPlusPlusProgrammer : public Person { public:CPlusPlusProgrammer(){m_name = "";m_age = 0;m_resume = NULL;}CPlusPlusProgrammer(string name, int age){m_name = name;m_age = age;m_resume = NULL;setResume("aaaa");}void setResume(char *p){if (m_resume != NULL){delete m_resume;}m_resume = new char[strlen(p) + 1];strcpy(m_resume, p);}virtual Person* clone(){CPlusPlusProgrammer *tmp = new CPlusPlusProgrammer;*tmp = *this; // 淺拷貝 (深拷貝需要考慮開辟空間的問題) 使用默認拷貝構造函數（值傳遞）return tmp;}virtual void printT(){cout << "m_name"<<m_name << " m_age" << m_age << "m_resume:" << m_resume << endl;} protected: private: };int main() {Person *c1 = new CPlusPlusProgrammer("皇帝",20);c1->printT();Person *c2 = c1->clone();c2->printT();system("pause");return 0; }

總結

以上是生活随笔為你收集整理的设计模式1—创建型模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。