模式
? ? ? ? ?在一定環(huán)境中解決某一問題的方案，包括三個(gè)基本元素--問題，解決方案和環(huán)境。
? ? ? ? ?大白話：在一定環(huán)境下，用固定套路解決問題。
設(shè)計(jì)模式（Design pattern）
是一套被反復(fù)使用、多數(shù)人知曉的、經(jīng)過分類編目的、代碼設(shè)計(jì)經(jīng)驗(yàn)的總結(jié)。使用設(shè)計(jì)模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。 毫無疑問，設(shè)計(jì)模式于己于他人于系統(tǒng)都是多贏的；設(shè)計(jì)模式使代碼編制真正工程化；設(shè)計(jì)模式是軟件工程的基石脈絡(luò)，如同大廈的結(jié)構(gòu)一樣。
設(shè)計(jì)模式的分類（Gang of Four的“DesignPatterns: Elements of Resualbel Software”書將設(shè)計(jì)模式歸納為三大類型，共23種）
? ? ? ? 創(chuàng)建型模式 : ?通常和對(duì)象的創(chuàng)建有關(guān)，涉及到對(duì)象實(shí)例化的方式。（共5種模式)
? ? ? ? 結(jié)構(gòu)型模式： 描述的是如何組合類和對(duì)象以獲得更大的結(jié)構(gòu)。(共7種模式)
? ? ? ? 行為型模式： 用來對(duì)類或?qū)ο笤鯓咏换ズ驮鯓臃峙渎氊?zé)進(jìn)行描述。(共11種模式)

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

1.單例模式

代碼1:

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

懶漢式單實(shí)例和多線程問題

代碼2： #include "stdafx.h" #include "windows.h" #include "winbase.h" #include "afxmt.h" #include <process.h> #include <stdlib.h> #include <iostream> using namespace std;/*☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆懶漢模式和多線程結(jié)合時(shí)，當(dāng)在構(gòu)造函數(shù)中Sleep 時(shí)，當(dāng)一個(gè)線程創(chuàng)建對(duì)象并進(jìn)入構(gòu)造函數(shù)時(shí)，會(huì)先把線程掛起，然后下一個(gè)線程再次創(chuàng)建對(duì)象并進(jìn)入構(gòu)造函數(shù)時(shí),也會(huì)掛起線程，此時(shí)，每個(gè)線程判定m_p_t都是NULL,這樣會(huì)導(dǎo)致創(chuàng)建多個(gè)對(duì)象。也就是每個(gè)線程都會(huì)創(chuàng)建一個(gè)類的對(duì)象，這就變成多實(shí)例，而不是單實(shí)例，同時(shí)還會(huì)出現(xiàn)資源共享的情況，可能出現(xiàn)資源鎖。也就是搶占資源，會(huì)造成程序的輸出不確定的結(jié)果。這就是線程間的同步問題。為了保證線程的同步，可以使用臨界區(qū)技術(shù)。(還可以使用互斥量、信號(hào)量)就是把線程共享的部分鎖定，保證相同的部分每次都只有一個(gè)線程進(jìn)行操作。臨界區(qū)（Critical Section）。臨界區(qū)對(duì)象通過提供一個(gè)進(jìn)程內(nèi)所有線程必須共享的對(duì)象來控制線程。只有擁有那個(gè)對(duì)象的線程可以訪問保護(hù)資源。在另一個(gè)線程可以訪問該資源之前，前一個(gè)線程必須釋放臨界區(qū)對(duì)象，以便新的線程可以索取對(duì)象的訪問權(quán)。互斥量（Mutex Semaphore）。互斥量的工作方式非常類似于臨界區(qū)，只是互斥量不僅保護(hù)一個(gè)進(jìn)程內(nèi)為多個(gè)線程使用的共享資源，而且還可以保護(hù)系統(tǒng)中兩個(gè)或多個(gè)進(jìn)程之間的的共享資源。信號(hào)量（Semaphore）。信號(hào)量可以允許一個(gè)或有限個(gè)線程訪問共享資源。它是通過計(jì)數(shù)器來實(shí)現(xiàn)的，初始化時(shí)賦予計(jì)數(shù)器以可用資源數(shù)，當(dāng)將信號(hào)量提供給一個(gè)線程時(shí)，計(jì)數(shù)器的值減1，當(dāng)一個(gè)線程釋放它時(shí)，計(jì)數(shù)器值加1。當(dāng)計(jì)數(shù)器值小于等于0時(shí)，相應(yīng)線程必須等待。信號(hào)量是Windows98同步系統(tǒng)的核心。從本質(zhì)上講，互斥量是信號(hào)量的一種特殊形式。 ☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆*/class Singleton_lazy_thread { private:Singleton_lazy_thread(){ cout << "Singleton_lazy_thread() 構(gòu)造函數(shù)begin\n";Sleep(1000);cout << "Singleton_lazy_thread() 構(gòu)造函數(shù)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() //測(cè)試函數(shù){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(); }// /*--------------------------使用臨界區(qū)技術(shù)（鎖定線程公共操作部分）-----------------------------*/ // 線程同步問題 //臨界區(qū) //類CCriticalSection的對(duì)象表示一個(gè)“臨界區(qū)”，它是一個(gè)用于同步的對(duì)象， //同一時(shí)刻只允許一個(gè)線程存取資源或代碼區(qū)。 //臨界區(qū)在控制一次只有一個(gè)線程修改數(shù)據(jù)或其它的控制資源時(shí)非常有用。 //使用時(shí)必須包含頭文件#include "afxmt.h" static CCriticalSection cs;class Singleton_lazy_thread_Sync { private:Singleton_lazy_thread_Sync(){//TRACE()宏一般是用在mfc中的，用于將調(diào)試信息輸出到vs的輸出窗口中(這是關(guān)鍵),//這在使用vs作為開發(fā)工具的時(shí)候，是非常方便的。//TRACE("Singleton begin\n");m_count++;cout << "Singleton_lazy_thread_Sync() 構(gòu)造函數(shù)begin\n";Sleep(1000);cout << "Singleton_lazy_thread_Sync() 構(gòu)造函數(shù)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) //第一次檢查看實(shí)例有沒有被創(chuàng)建{cs.Lock(); //只有當(dāng)pInstance等于null時(shí)，才開始使用枷鎖機(jī)制 二次檢查//第二個(gè)線程在創(chuàng)建時(shí)不知道第一個(gè)線程已經(jīng)創(chuàng)建了，//所以在臨界區(qū)檢查，防止被多次創(chuàng)建(著名的二次檢查)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() //測(cè)試函數(shù){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: };//--------------------------簡(jiǎn)單工廠模式。------------------------ //也就是所有的操作都是在類里面完成的，不符合設(shè)計(jì)模式的設(shè)計(jì)規(guī)則 //所以可以進(jìn)行改進(jìn)。 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: };// /*改進(jìn)后的工廠模式 為每個(gè)對(duì)象都產(chǎn)生一個(gè)單獨(dú)的工廠，專門生產(chǎn)一種產(chǎn)品。 */ class Factory { public:virtual Fruit* produceFruit() = 0; protected: private: };class BananaFactory:public Factory { public://函數(shù)的返回值是一個(gè)父類的指針virtual Fruit* produceFruit(){//函數(shù)體里面返回的是一個(gè)子類的指針//通過父類的指針或者引用來調(diào)用子類的函數(shù)，實(shí)現(xiàn)多態(tài)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 << "---------簡(jiǎn)單工廠模式---------" << 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");////改進(jìn)后的工廠(工廠抽象成一個(gè)虛基類)cout << endl << "---------改進(jìn)后的工廠模式---------" << 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: };////工廠模式只能生產(chǎn)一個(gè)產(chǎn)品。（要么香蕉、要么蘋果） //抽象工廠可以一下生產(chǎn)一個(gè)“產(chǎn)品族”（里面有很多產(chǎn)品組成）,就是可以生產(chǎn)多種產(chǎn)品。//缺點(diǎn)是： //抽象工廠的缺點(diǎn)就是產(chǎn)品線寫死了。 //如果需要添加新的產(chǎn)品，就需要在原來抽象類上改 // class AbstractFactory { public://抽象工廠的缺點(diǎn)就是產(chǎn)品線寫死了。//如果需要添加新的產(chǎn)品，就需要在原來抽象類上改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：為創(chuàng)建產(chǎn)品各個(gè)部分，統(tǒng)一抽象接口。 2) ConcreteBuilder：具體的創(chuàng)建產(chǎn)品的各個(gè)部分，部分A， 部分B，部分C。 3) Director：構(gòu)造一個(gè)使用Builder接口的對(duì)象。 4) Product：表示被構(gòu)造的復(fù)雜對(duì)象。 ConcreteBuilder創(chuàng)建該產(chǎn)品的內(nèi)部表示并定義它的裝配過程，包含定義組成部件的類， 包括將這些部件裝配成最終產(chǎn)品的接口。適用情況： 一個(gè)對(duì)象的構(gòu)建比較復(fù)雜，將一個(gè)對(duì)象的構(gòu)建（？）和對(duì)象的表示（？）進(jìn)行分離。建造者模式設(shè)計(jì)三個(gè)類對(duì)象（案例）：設(shè)計(jì)者(也叫指揮者)、工程隊(duì)（可以造別墅、平房、四合院等），房子（有門、窗戶、墻等） */ ///建造者模式產(chǎn)生原因///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; };///建造者模式/ /*建造者模式設(shè)計(jì)三個(gè)類對(duì)象（案例）：設(shè)計(jì)者(也叫指揮者、主管)、------------------ class Director 主管類工程隊(duì)（可以造別墅、平房、四合院等），------ class Builder 工程隊(duì)類房子（有門、窗戶、墻等）-------------------- class House 房子類擴(kuò)展：設(shè)計(jì)師(指揮者) 負(fù)責(zé)建造邏輯。建筑隊(duì) 干具體的活再讓設(shè)計(jì)師分三六九等，指揮三六九等建筑隊(duì)，建造三六九等的房子也就是可以把設(shè)計(jì)師在細(xì)化分類，建筑隊(duì)也可以再細(xì)化分類，房子同樣可以細(xì)化不同的房子。就是“主管抽象、工程隊(duì)抽象、房子抽象”。 */class House { public:virtual void setDoor(string door){}; //虛函數(shù)必須有實(shí)現(xiàn)代碼，純虛函數(shù)可以沒實(shí)現(xiàn)代碼。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 << "-----------------工程隊(duì)造房子-----------------" << 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 << "---------三等指揮，三等建造者，建設(shè)平房-------------" << endl;director = new SanDengDirector(sanBuilder);director->Construct();flat->getDoor();flat->getWindow();flat->getWall();cout << "---------三等指揮，三等建造者，建設(shè)樓房-------------" << endl;director = new SanDengDirector(liuBuilder);director->Construct();floor->getDoor();floor->getWindow();floor->getWall();cout << "---------三等指揮，三等建造者，建設(shè)別墅-------------" << endl;director = new SanDengDirector(jiuBuilder);director->Construct(); villa->getDoor();villa->getWindow();villa->getWall();cout << endl << "因?yàn)閚ew的太多，不再一個(gè)一個(gè)刪除，先不用管內(nèi)存泄露" << endl;system("pause");return 0; }

5.原型模式

#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <stdlib.h> #include <string> using namespace std;// /* 原型模式 Prototype模式是一種對(duì)象創(chuàng)建型模式，它采取復(fù)制原型對(duì)象的方法來創(chuàng)建對(duì)象的實(shí)例。 使用Prototype模式創(chuàng)建的實(shí)例，具有與原型一樣的數(shù)據(jù)。 1）由原型對(duì)象自身創(chuàng)建目標(biāo)對(duì)象。也就是說，對(duì)象創(chuàng)建這一動(dòng)作發(fā)自原型對(duì)象本身。 2）目標(biāo)對(duì)象是原型對(duì)象的一個(gè)克隆。也就是說，通過Prototype模式創(chuàng)建的對(duì)象，不僅僅與原型對(duì)象具有相同的結(jié)構(gòu)，還與原型對(duì)象具有相同的值。 3）根據(jù)對(duì)象克隆深度層次的不同，有淺度克隆與深度克隆。其實(shí)原型模式就是返回一個(gè)和自己一模一樣的類型的數(shù)據(jù)（深淺拷貝）*/ //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; // 淺拷貝 (深拷貝需要考慮開辟空間的問題) 使用默認(rèn)拷貝構(gòu)造函數(shù)（值傳遞）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; }

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。