百度网站降级的原因,堵博网站建设,专门做中式的设计网站,制作网页常见的布局方法有结构型模式用来处理类或者对象的组合#xff0c;主要包含以下7种设计模式#xff1a;1. 代理模式#xff08;Proxy Pattern#xff09;就是为其他对象提供一种代理以控制对这个对象的访问。2. 装饰者模式#xff08;Decorator Pattern#xff09;动态的给一个对象添加一些…结构型模式用来处理类或者对象的组合主要包含以下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 *carNULL){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* current110Vnew Current110V;Current220V* current220Vnew 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 listIFile** 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 listIFile** 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 listIFile** getChild(){return m_list;}
protected:
private:string m_dirName;listIFile** 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(子目录)listIFile* *myList root-getChild();if (myList ! NULL) //说明是一个目录{for (listIFile*::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, level1);}}}
}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);listIFile** myList root-getChild();for (listIFile *::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;mapstring, Person *::iterator it mapTeachers.begin();tmp it-second;mapTeachers.erase(it); //把第一个结点 从容器中删除delete tmp;}}Person* getTeacher(string id){Person* tmp NULL;mapstring, 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(pairstring,Person*(id,tmp));}else{tmp it-second;}return tmp;}
protected:
private:mapstring, 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;
}
