设计模式2—结构型模式

结构型模式用来处理类或者对象的组合,主要包含以下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;
}








本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/497169.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

C++学习之路 | PTA乙级—— 1022 D进制的A+B (20分)(精简)

1022 D进制的AB (20分) 输入两个非负 10 进制整数 A 和 B (≤2 ​30 ​​ −1)&#xff0c;输出 AB 的 D (1<D≤10)进制数。 输入格式&#xff1a; 输入在一行中依次给出 3 个整数 A、B 和 D。 输出格式&#xff1a; 输出 AB 的 D 进制数。 输入样例&#xff1a; 123 45…

Form Template Method(塑造模板函数)

有一些子类&#xff0c;其中相应的某些函数以相同顺序执行类似的操作&#xff0c;但各个操作的细节有不同 重构&#xff1a;将这些操作分别放进独立函数中&#xff0c;并保持它们都有相同的签名&#xff0c;然后将原函数上移至超类

自动驾驶第一案结果敲定,谷歌无人驾驶和Uber达成2.5亿美元和解协议

来源&#xff1a;36氪概要&#xff1a;Uber 与谷歌无人驾驶部门 Waymo 的法律纠纷以庭外和解的方式告一段落。Uber 与谷歌无人驾驶部门 Waymo 的法律纠纷以庭外和解的方式告一段落。上周五 &#xff0c;Uber 表示&#xff0c;公司已经和 AlphabetInc 旗下的无人驾驶汽车公司 Wa…

FastReport v3.2.5在BDS2006中的安装方法

FastReport v3.2.5在BDS2006中的安装方法 // Windows XP Pro SP2 Delphi2006 Update 1 TeeChart pro v7.06 // 安装前请删除老版本的FastReport控件。 1. "Tools|Options|Environmet Options|Delphi Options|Library - Win32"中的"Directories"标签面…

C++学习之路 | PTA乙级—— 1023 组个最小数 (20分)(精简)

1023 组个最小数 (20分) 给定数字 0-9 各若干个。你可以以任意顺序排列这些数字&#xff0c;但必须全部使用。目标是使得最后得到的数尽可能小&#xff08;注意 0 不能做首位&#xff09;。例如&#xff1a;给定两个 0&#xff0c;两个 1&#xff0c;三个 5&#xff0c;一个 8…

物联网将在2018年实现大规模发展:以下是IBM的4大预测

来源&#xff1a;forbes物联网智库 编译概要&#xff1a;随着连接设备的数量达到110亿台&#xff08;不包括电脑和手机的连接量&#xff09;&#xff0c;很显然&#xff0c;在2018年&#xff0c;物联网将继续成为热点话题。随着连接设备的数量达到110亿台&#xff08;不包括电脑…

佛祖说出的爱情箴言

一、石头问&#xff1a;我究竟该找个我爱的人做我的妻子呢&#xff1f;还是该找个爱我的人做我的妻子呢&#xff1f;佛笑了笑&#xff1a;这个问题的答案其实就在你自己的心底。这些年来&#xff0c;能让你爱得死去活来&#xff0c;能让你感觉得到生活充实&#xff0c;能让你挺…

Replace Inheritance with Delegation(以委托取代继承)

某个子类只使用超类接口中的一部分&#xff0c;或是根本不需要继承而来的数据 重构&#xff1a;在子类中新建一个字段用来保存超类&#xff0c;调整子类函数&#xff0c;令它改而委托超类&#xff0c;然后去掉两者的继承关系

设计模式3—行为型模式

行为型模式用来对类或对象怎样交互和怎样分配职责进行描述&#xff0c;主要包含以下11种设计模式&#xff1a; 模板方法模式&#xff08;Template Method Pattern&#xff09; 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 命令模式&#xff08;Command…

javax.servlet.http.HttpServletRequest接口(HTTP版本)

< DOCTYPE html PUBLIC -WCDTD XHTML StrictEN httpwwwworgTRxhtmlDTDxhtml-strictdtd> HttpServletRequest类主要处理&#xff1a;1.读取和写入HTTP头标2.取得和设置cookies3.取得路径信息4.标识HTTP会话。HttpServletRequest接口中的方法 String getAuthType() …

C++学习之路 | PTA(天梯赛)—— L3-003 社交集群 (30分) (带注释) (并查集) (精简)

L3-003 社交集群 (30分) 当你在社交网络平台注册时&#xff0c;一般总是被要求填写你的个人兴趣爱好&#xff0c;以便找到具有相同兴趣爱好的潜在的朋友。一个“社交集群”是指部分兴趣爱好相同的人的集合。你需要找出所有的社交集群。 输入格式&#xff1a; 输入在第一行给出…

国家重点研发计划高新领域 “智能机器人、网络协同制造和智能工厂”重点专项2018年度项目申报指南建议

来源&#xff1a;机器人创新生态概要&#xff1a; 针对我国网络协同制造和智能工厂发展模式创新不足、技术能力尚未形成、融合新生态发展不足、核心技术/软件支撑能力薄弱等问题。征求意见时间为2018年2月8日至2018年2月22日。电子邮箱&#xff1a;重点专项名称邮箱地址智能机器…

Replace Delegation with Inheritance(以继承取代委托)

两个类之间使用委托关系&#xff0c;并经常为整个接口编写许多极简单的委托函数 重构&#xff1a;让委托类继承受托类

C++学习之路 | PTA(天梯赛)—— L2-024 部落 (25分)(带注释)(并查集)(精简)

L2-024 部落 (25分) 在一个社区里&#xff0c;每个人都有自己的小圈子&#xff0c;还可能同时属于很多不同的朋友圈。我们认为朋友的朋友都算在一个部落里&#xff0c;于是要请你统计一下&#xff0c;在一个给定社区中&#xff0c;到底有多少个互不相交的部落&#xff1f;并且检…

人造神经元计算速度超过人脑

来源&#xff1a;《科学进展》概要&#xff1a;一种以神经元为模型的超导计算芯片&#xff0c;能比人脑更高效快速地加工处理信息。一种以神经元为模型的超导计算芯片&#xff0c;能比人脑更高效快速地加工处理信息。近日刊登于《科学进展》的新成果&#xff0c;或许将成为科学…

[导入]将Byte数组转化为String

文章来源:http://blog.csdn.net/21aspnet/archive/2007/03/24/1539848.aspx 转载于:https://www.cnblogs.com/zhaoxiaoyang2/archive/2007/03/24/816232.html

Command 和 Active Object 模式

Command 和 Active Object 模式 Command 模式是封装了一个没有任何变量的函数。 public interface Command {public void do(); } 简单的Command 打印机工作流 开启/关闭继电器—RelayOnCommand、RelayOffCommand&#xff1b; 开启/关闭发动机—MotorOnCommand、MotorOffC…

C++学习之路 | PTA(天梯赛)—— L2-013 红色警报 (25分)(带注释)(并查集)(精简)

L2-013 红色警报 (25分) 战争中保持各个城市间的连通性非常重要。本题要求你编写一个报警程序&#xff0c;当失去一个城市导致国家被分裂为多个无法连通的区域时&#xff0c;就发出红色警报。注意&#xff1a;若该国本来就不完全连通&#xff0c;是分裂的k个区域&#xff0c;而…

成员函数指针作为参数是,静态函数和非静态函数的区别

成员函数指针作为参数时&#xff0c;静态函数和非静态函数的区别 举个 QT 的例子&#xff08;没学过QT的也不要紧&#xff0c;这适用于学习C的同学&#xff09;&#xff0c;当我有两个类&#xff0c;Teacher 类和 Student 类。现在有一个场景就是&#xff0c;Teacher 类会发出…

谷歌云TPU服务正式全面开放:「AlphaGo背后的芯片」进入商用化

来源&#xff1a;机器之心概要&#xff1a;作为科技巨头的谷歌早已把这种高度定制化产品应用在了自己的服务器中&#xff0c;而本周一&#xff0c;谷歌宣布其他公司马上也将可以享受新型芯片带来的计算服务了。2016 年 5 月&#xff0c;谷歌向世人发布了一款特别的机器学习专属…