結構型模式用來處理類或者對象的組合，主要包含以下7種設計模式：
1. 代理模式（Proxy Pattern）就是為其他對象提供一種代理以控制對這個對象的訪問。
2. 裝飾者模式（Decorator Pattern）動態的給一個對象添加一些額外的職責。就增加功能來說，此模式比生成子類更為靈活。?
3. 適配器模式（Adapter Pattern）是將一個類的接口轉換成客戶希望的另外一個接口。使得原本由于接口不兼容而不能一起工作的那些類可以一起工作。?
4. 組合模式（Composite Pattern）是將對象組合成樹形結構以表示“部分--整體”的層次結構。使得用戶對單個對象和組合對象的使用具有一致性。
5. 橋接模式（Bridge Pattern）是將抽象部分與實際部分分離，使它們都可以獨立的變化。
6. 外觀模式（Facade Pattern）是為子系統中的一組接口提供一個一致的界面，此模式定義了一個高層接口，這個接口使得這一子系統更加容易使用。
7. 享元模式（Flyweight Pattern）是以共享的方式高效的支持大量的細粒度的對象。

1. 代理模式

#include <iostream> #include <stdlib.h> using namespace std;// /*為其他對象提供一種代理以控制對這個對象的訪問。（就是把一個類注入到另一個類中，也就是作為參數，或者成員） */ //class BookShop //書店 { public:virtual ~BookShop(){}virtual void sailBook() = 0; //提供賣書接口 protected: private: };class RealBookShop :public BookShop //實體書店 { public:virtual void sailBook(){cout << "實體書店賣書" << endl;} protected: private: };// /*實現方法1 沒有繼承父類 */ class DangDangProxy //當當網代理賣書，也賣其他的東西 { public:~DangDangProxy(){delete book;book = NULL;}void sailBook(){book = new RealBookShop; //通過父類的指針來調用子類的方法.book->sailBook();sailShose();}void sailShose(){cout << "代理賣鞋" << endl;} protected: private:BookShop *book; };// /*實現方法2 繼承父類繼承父類，可以實現通過父類的指針或者引用來調用子類的方法， */ class TaoBao :public BookShop { public:~TaoBao(){delete book;book = NULL;}virtual void sailBook(){book = new RealBookShop; //通過父類的指針來調用子類的方法.dazhe();book->sailBook();dazhe();}void dazhe(){cout << "節日打折" << endl;} protected: private:BookShop *book; };// /*cocos2d 就是使用代理模式 */ // class Protocol { public:virtual bool applicationDidFinish() = 0; protected: private: };class Application :public Protocol { public:Application();int run();static Application *pointerApp;static Application* getPointerApp(); protected: private: }; Application* Application::pointerApp = NULL; //靜態變量初始化 Application::Application() //構造函數 {pointerApp = this;//靜態變量賦值 } Application* Application::getPointerApp() {return pointerApp; } int Application::run() {applicationDidFinish();return 0; }class AppDelegate : private Application //注意是private繼承 { public:virtual bool applicationDidFinish(); protected: private: }; bool AppDelegate::applicationDidFinish() {cout << "start game" << endl;return true; }int main() {cout << "-----------DangDang------------" << endl;DangDangProxy dangdang;dangdang.sailBook();cout << "-----------TaoBao------------" << endl;BookShop* book = new TaoBao;book->sailBook();delete book;cout << "------------coco2d 入口函數分析------------" << endl;AppDelegate appdelete;Application::getPointerApp()->run();system("pause");return 0; }

2. 裝飾者模式

#include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std;// /*裝飾（ Decorator ）模式又叫做包裝模式。通過一種對客戶端透明的方式來擴展對象的功能，是繼承關系的一個替換方案。裝飾模式就是把要添加的附加功能分別放在單獨的類中，并讓這個類包含它要裝飾的對象，當需要執行時，客戶端就可以有選擇地、按順序地使用裝飾功能包裝對象。其實就是在一個類中聲明一個父類的指針，通過父類的指針指向另外一個子類，并調用那個子類的函數 */ //class Car //汽車 { public:virtual void show() = 0;virtual ~Car(){} protected: private: };class RunCar : public Car //跑車 { public:RunCar(Car* car = NULL){this->m_car = car;}~RunCar(){delete m_car;m_car = NULL;}virtual void show(){if (m_car != NULL)m_car->show();run();}void run(){cout << "可以跑" << endl;} protected: private:Car *m_car; };class SwimCar : public Car { public:SwimCar(Car *car=NULL){this->m_car = car;}~SwimCar(){delete m_car;m_car = NULL;}void swim(){cout << "會游泳" << endl;}virtual void show(){if (m_car!=NULL)m_car->show();swim();} protected: private:Car *m_car; };class FlyCar : public Car { public:FlyCar(Car *car){this->m_car = car;}~FlyCar(){delete m_car;m_car = NULL;}void fly(){cout << "會飛行" << endl;}virtual void show(){if (this->m_car != NULL)m_car->show();fly();} protected: private:Car *m_car; };int main() {Car* myCar = NULL;myCar = new RunCar;myCar->show();cout << "--------------------" << endl;FlyCar* flyCar = new FlyCar(myCar);flyCar->show();cout << "--------------------" << endl;SwimCar *swimCar = new SwimCar(flyCar);swimCar->show();system("pause");delete swimCar; swimCar = NULL;delete flyCar; flyCar = NULL;delete myCar; myCar = NULL;return 0; }

3. 適配器模式

#include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std;// /*Adapter模式也叫適配器模式，是構造型模式之一，通過Adapter模式可以改變已有類（或外部類）的接口形式。適用于：是將一個類的接口轉換成客戶希望的另外一個接口。使得原本由于接口不兼容而不能一起工作的那些類可以一起工作。220v 電壓 <----相互適配----> 110v 電壓 */ // class DianYa { public: protected:int v; //擴展：可以使用v表示電壓，改變v的值 };class Current220V :virtual public DianYa { public:virtual void use220V(){cout << "220V 電壓" << endl;} protected: private: };class Current110V : virtual public DianYa { public:virtual void use110V(){cout << "110V 電壓" << endl;} protected: private: };class Adapter : public Current110V, public Current220V { public:Adapter(){m_110V = NULL;m_220V = NULL;}Adapter(Current110V* m_110V){this->m_110V = m_110V;}Adapter(Current220V* m_220V){this->m_220V = m_220V;}virtual void use110V(){if (m_220V != NULL){cout << "適配器 適配 220V" << endl;m_220V->use220V();}else cout << "110V" << endl;}virtual void use220V(){if (m_110V != NULL){cout << "適配器 適配 110V" << endl;m_110V->use110V();}else cout << "220V" << endl;} protected: private:Current110V* m_110V;Current220V* m_220V; };int main() {Current110V* current110V=new Current110V;Current220V* current220V=new Current220V;Adapter* adap = NULL;adap = new Adapter(current110V); //輸入110Vadap->use220V(); //經適配器后，輸出220Vdelete adap; adap = NULL;adap = new Adapter(current220V); //輸入220Vadap->use110V(); //經適配器后，輸出110Vdelete adap; adap = NULL;delete current220V; current220V = NULL;delete current110V; current110V = NULL;system("pause");return 0; }

4. 組合模式

#include <stdlib.h> #include <stdio.h> #include <iostream> #include <list> #include <string> using namespace std;// /* Composite模式也叫組合模式，是構造型的設計模式之一。 通過遞歸手段來構造樹形的對象結構，并可以通過一個對象來訪問整個對象樹。 */ //class IFile { public:virtual void disPaly() = 0;virtual int add(IFile *ifile) = 0;virtual int remove(IFile* ifile) = 0;virtual list<IFile*>* getChild() = 0; protected: private: };//文件 節點 class File : public IFile { public:File(string filename){this->m_filename = filename;}virtual void disPaly(){cout << "文件名：" << m_filename << endl;}virtual int add(IFile *ifile){return -1;}virtual int remove(IFile* ifile){return -1;}virtual list<IFile*>* getChild(){return NULL;} protected: private:string m_filename; };//目錄 節點 class Dir : public IFile { public:Dir(string dirName){this->m_dirName = dirName;this->m_list = new list < IFile* > ;m_list->clear();}virtual void disPaly(){cout << "文件夾名：" << m_dirName << endl;}virtual int add(IFile *ifile){m_list->push_back(ifile);return 0;}virtual int remove(IFile* ifile){m_list->remove(ifile);return 0;}virtual list<IFile*>* getChild(){return m_list;} protected: private:string m_dirName;list<IFile*>* m_list; };// level用來控制顯示層次結構 void showTree(IFile* root,int level) {int i = 0;if (root == NULL)return;for (i = 0; i < level; i++)cout << "\t";root->disPaly(); //顯示根節點//2 若根結點 有孩子 //判讀孩子是文件,顯示名字 )//判斷孩子是目錄,showTree(子目錄)list<IFile*> *myList = root->getChild();if (myList != NULL) //說明是一個目錄{for (list<IFile*>::iterator it = myList->begin(); it != myList->end();it++){if ((*it)->getChild() == NULL) //文件直接打印{for (i = 0; i <= level; i++) //注意 <= {printf("\t");}(*it)->disPaly();}else{//目錄再遞歸調用,層次加1showTree(*it, level+1);}}} }int main() {Dir* root = new Dir("C");root->disPaly();File *fileAAA = new File("aaa.txt");File *fileBBB = new File("bbb.txt");File *fileCCC = new File("ccc.txt");Dir *dir001 = new Dir("001"); Dir *dir002 = new Dir("002");Dir* dir003 = new Dir("003");root->add(dir001);root->add(dir002);root->add(fileAAA);dir002->add(dir003);dir002->add(fileBBB);dir003->add(fileCCC);list<IFile*>* myList = root->getChild();for (list<IFile *>::iterator it = myList->begin(); it != myList->end(); it++){(*it)->disPaly();}cout << "通過 showTree 方式 顯示 root 結點下的 所有子結點" << endl;showTree(root, 0);system("pause");return 0; }

5. 橋接模式

#include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std;// /*橋接模式 : 就是多對多的關系；發動機有多種型號，汽車也有多個品牌每個型號的發動機可以被各個型號的汽車使用每個品牌的汽車也可以使用各個型號的發動機等于在中間架設一座橋，（在抽象類中聲明另一個抽象類的指針，用來調用另一個抽象類子類的方法） */ //class Car; //前向聲明 class Engine { public:virtual void engineType() = 0; protected:Car* car; private: };class Type2900 :public Engine { public:virtual void engineType(){cout << "2900 型號發動機" << endl;} protected: private: };class Type3500 :public Engine { public:virtual void engineType(){cout << "3500 型號發動機" << endl;} protected: private: };class Type7200 :public Engine { public:virtual void engineType(){cout << "7200 型號發動機" << endl;} protected: private: };class Car { public:virtual void carType() = 0;Car(Engine* engine){this->m_engine = engine;} protected:Engine *m_engine; private: };class BMW : public Car { public:BMW(Engine* engine) :Car(engine){}virtual void carType(){cout << "BMW Car: ";m_engine->engineType();} protected: private: };class Jeep : public Car { public:Jeep(Engine* engine) :Car(engine){}virtual void carType(){cout << "Jeep Car: ";m_engine->engineType();} protected: private:};int main() {Engine *engine = NULL;Car* car = NULL;engine = new Type2900;car = new BMW(engine);car->carType();delete car; car = NULL;delete engine; engine = NULL;engine = new Type3500;car = new BMW(engine);car->carType();delete car; car = NULL;delete engine; engine = NULL;engine = new Type3500;car = new Jeep(engine);car->carType();delete car; car = NULL;delete engine; engine = NULL;system("pause");return 0; }

6. 外觀模式

#include <stdlib.h> #include <stdio.h> #include <iostream> using namespace std;// /*外觀模式就是封裝了一層外殼，提供統一的操作界面也就是把“操作相似的類” 注入到另一個類里面，提供統一操作 */ //class SubSystemA { public:void doSomething(){cout << "SubSystemA run" << endl;} protected: private: };class SubSystemB { public:void doSomething(){cout << "SubSystemB run" << endl;} protected: private: };class SubSystemC { public:void doSomething(){cout << "SubSystemC run" << endl;} protected: private: };class Facade { public:Facade(){sysA = new SubSystemA;sysB = new SubSystemB;sysC = new SubSystemC;}~Facade(){delete sysA;delete sysB;delete sysC;}void doSomething(){sysA->doSomething();sysB->doSomething();sysC->doSomething();} protected: private:SubSystemA *sysA;SubSystemB *sysB;SubSystemC *sysC; };int main() {cout << "沒有Facade類時的調用方式" << endl;SubSystemA *sysA = new SubSystemA;SubSystemB *sysB = new SubSystemB;SubSystemC *sysC = new SubSystemC;sysA->doSomething();sysB->doSomething();sysC->doSomething();delete sysA;delete sysB;delete sysC;cout << "使用Facade類的調用方式" << endl;Facade *f = new Facade;f->doSomething();delete f;system("pause"); }

7. 享元模式

#include <stdlib.h> #include <stdio.h> #include <iostream> #include <map> #include <string> using namespace std;// /*Flyweight模式也叫享元模式，是構造型模式之一，它通過與其他類似對象共享數據來減小內存占用。所謂的享元模式“就是有相同的不用管，沒有相同的繼續添加”。只需要在添加的時候判斷下有沒有相同的。 */ //class Person { public:Person(string name, int age) :m_name(name), m_age(age){}virtual void printT() = 0; protected:string m_name;int m_age; private: };class Teacher : public Person { public:Teacher(string name, int age, string id) :Person(name, age),m_id(id){}virtual void printT(){cout << "name:" << m_name << " age:" << m_age << " m_id:" << m_id << endl;} protected: private:string m_id; };class FlyWeightTeacher { public:FlyWeightTeacher(){mapTeachers.clear();}~FlyWeightTeacher(){while (!mapTeachers.empty()){Person *tmp = NULL;map<string, Person *>::iterator it = mapTeachers.begin();tmp = it->second;mapTeachers.erase(it); //把第一個結點 從容器中刪除delete tmp;}}Person* getTeacher(string id){Person* tmp = NULL;map<string, Person*>::iterator it;it = mapTeachers.find(id);if (it == mapTeachers.end()) //沒有找到{string tmpName;int tmpAge;cout << "\n輸入老師的Name：";cin >> tmpName;cout << "\n輸入老師的Age：";cin >> tmpAge;tmp = new Teacher(tmpName,tmpAge,id);mapTeachers.insert(pair<string,Person*>(id,tmp));}else{tmp = it->second;}return tmp;} protected: private:map<string, Person*> mapTeachers; };int main() {Person *p1 = NULL;Person *p2 = NULL;FlyWeightTeacher * fwty = new FlyWeightTeacher;p1->printT();p2 = fwty->getTeacher("001");p2->printT();delete fwty;system("pause");return 0; }

總結

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

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