宜和购物电视购物官方网站,百度右边相关网站怎么做的,静态网站 apache,小学生做创客大赛网站的题设计模式
如何解决复杂性#xff1f;
分解
核心思想#xff1a;分而治之#xff0c;将大问题分解为多个小问题#xff0c;将复杂问题分解为多个简单的问题。
抽象
核心思想#xff1a;从高层次角度讲#xff0c;人们处理复杂性有一个通用的技术#xff0c;及抽象。…设计模式
如何解决复杂性
分解
核心思想分而治之将大问题分解为多个小问题将复杂问题分解为多个简单的问题。
抽象
核心思想从高层次角度讲人们处理复杂性有一个通用的技术及抽象。由于不能掌握全部的复杂对象选择护士他的非本质细节而去处理泛化和理想化的对象模型。
总结来说就是复用最好的代码就是复用性高。
面向对象设计原则
对象的概念
从语言实现层面来看对象封装了代码和数据。从规格层面讲对象是一系列可被使用的公共接口。从概念层面讲对象时某种拥有责任的抽象。
设计原则
依赖倒置原则DIP
高层模块稳定不应该依赖于低层模块变化二者都应该依赖于抽象稳定。抽象稳定不应该依赖于实现细节变化实现细节应该依赖于抽象稳定。
开放封闭原则OCP
对扩展开放对更改封闭。类模块应该是可扩展的但是不可修改。
单一职责原则SRP
一个类应该仅有一个引起它变化的原则。变化的方向隐含着类的责任。
Liskov替换原则LSP
子类必须能够替换他们的基类。继承表达类型抽象
接口隔离原则ISP
不应该强迫客户程序依赖他们不用的方法。接口应该小而完备。
优先使用对象组合而不是类继承
类继承通常为“白箱复用”对象组合通常为“黑箱复用”。继承在某种程度上破坏了封装性子类父类耦合度很高。而对象组合则只要求被组合的对象具有良好定义的接口耦合度低。
封装变化点
使用封装来创建对象之间的分界层让设计者可以在分界层的一侧进行修改而不会对另一侧产生不良影响从而实现层次间的松耦合。
针对接口与编码而不是针对实现编程产业强盛的标志
不将变量类型声明为某个特定的具体类而是声明为某个接口客户程序无需获知对象的具优类型只需要知道对象所具有的接口。减少系统中各部分的依赖关系从而实现“高内聚、松耦合’的类型设计方案。
GOF-23模式分类
从目的来看
创建型模式将对象的部分创建工作延迟到子类或者其他对象从而应对需求变化为对象创建时具体类型实现引来的冲击。结构型模式通过类继承或者对象组合获得更灵活的结构从而应对需求变化为对象的结构带来的冲击。行为型模式通过类继承或者对象组合来划分类与对象间的职责从而应对需求变化为多个交互的对象带来的冲击。
从范围来看
类模式处理类与子类的静态关系。对象模式处理对象间的动态关系。
C设计模式
工厂模式
工厂模式主要是封装了对象的创建。
简单工厂(Simple Factory)
优点
把对象的创建封装在一个接口函数里面通过传入不同的标识返回创建的对象。使用者不需要自己负责new对象不用了解对象创建的详细过程。
缺点
提供创建对象实例的接口函数不闭合不能对修改关闭。
工厂方法(Factory Method)
优点
使用Factory基类提供一个纯虚函数创建产品定义派生类具体产品的工厂负责创建对应的产品可以做到不同的产品在不同的工厂进行创建。能对现有工厂以及产品的修改关闭
缺点
忽略了产品之间的关联关系属于一个产品簇的不应该放到不同的工厂里面去创建。不符合产品对象创建逻辑工厂类太多难以维护。
抽象工厂(Abstact Factory)
优点
把现有关联关系、属于同一个产品簇的所有产品创建的接口函数放在一个抽象工厂里面派生类具体产品的工厂应该负责创建该产品簇里面的所有产品。
这里使用了一个汽车生产的工厂示例列举了简单工厂和工厂方法并使用智能指针进行对象空间优化回收。
简单工厂和工厂方法
#include iostream
#include string
#includememoryusing namespace std;class Car
{
public:Car(string name):_name(name){}virtual void show() 0; //定义纯虚函数子类必须实现protected:string _name;private:
};
class BMW:public Car
{
public:// 使用Car(name)类似于_name(name)还是用了Car的_name// 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658BMW(string name) : Car(name){};void show(){cout 获取了一辆宝马汽车 _name endl;}
protected :
private:
};
class Audi : public Car
{
public:// 使用Car(name)类似于_name(name)还是用了Car的_name// 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658Audi(string name) : Car(name){};void show(){cout 获取了一辆奥迪汽车 _name endl;}protected:
private:
};// ------------------------------------------------------------------------------------------
/*
简单工厂存在以下问题开闭原则新增一个汽车则需要修改很多代码BMW类和Audi类都在一个工厂里面生产
*/
enum CarType
{bmw,audi
};
class SimpleFactory
{
public:Car* createCar(CarType ct){switch (ct){case bmw:return new BMW(X1);case audi:return new Audi(A6);default:cout 传入工厂的参数不正确 ct endl;break;}return nullptr;}
};
// ------------------------------------------------------------------------------------------
/*
工厂方法
*/
class Factory
{
public:virtual Car* createCar(string name) 0;
};
class BMWFactory:public Factory
{
public:Car* createCar(string name){return new BMW(name);}
};
class AudiFactory : public Factory
{
public:Car *createCar(string name){return new Audi(name);}
};
// ------------------------------------------------------------------------------------------int main()
{// unique_ptr无法进行普通拷贝构造和赋值unique_ptrCar p1new BMW(X1);是错误的// 最原始的对象产生unique_ptrCar p1(new BMW(X1));unique_ptrCar p2(new Audi(A6));// 简单工厂// unique_ptrSimpleFactory factory(new SimpleFactory());// unique_ptrCar p1(factory-createCar(bmw));// unique_ptrCar p2(factory-createCar(audi));// 工厂方法// unique_ptrFactory bmwFactory(new BMWFactory);// unique_ptrFactory audiFactory(new AudiFactory);// unique_ptrCar p1(bmwFactory-createCar(X6));// unique_ptrCar p2(audiFactory-createCar(A8));p1-show();p2-show();return 0;
}抽象工厂方法
上一节中的工厂方法会存在一个问题在定义了一个Factory抽象类后每一个类将对应一个类的工厂如BWM-BMWFactoryAudi-AudiFactory这样会导致一个问题在生产一类产品时如手机充电器和充电线那么就又需要两个工厂来实现所以这样就会导致工厂冗余。所以提出了抽象工厂来解决这个问题这里以汽车的生产部件为例进行说明
#include iostream
#include string
#includememoryusing namespace std;class Car
{
public:Car(string name):_name(name){}virtual void show() 0; //定义纯虚函数子类必须实现protected:string _name;private:
};
class BMW:public Car
{
public:// 使用Car(name)类似于_name(name)还是用了Car的_name// 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658BMW(string name) : Car(name){};void show(){cout 获取了一辆宝马汽车 _name endl;}
protected :
private:
};
class Audi : public Car
{
public:// 使用Car(name)类似于_name(name)还是用了Car的_name// 子类继承父类的构造函数可以参考 https://blog.csdn.net/aquapisces/article/details/104371658Audi(string name) : Car(name){};void show(){cout 获取了一辆奥迪汽车 _name endl;}protected:
private:
};class Light
{
public:virtual void show() 0;
};class BMWLight:public Light
{
public:void show(){cout BMW light! endl;}
};class AudiLight : public Light
{
public:void show(){cout Audi light! endl;}
};
/*
抽象工厂对一组关联关系的产品簇提供产品对象的统一创建。
有点类似于工厂方法
*/
class AbstractFactory
{
public:virtual Car *createCar(string name) 0;virtual Light *createCarLight() 0;
};
class BMWFactory : public AbstractFactory
{
public:Car *createCar(string name){return new BMW(name);}Light *createCarLight(){return new BMWLight();}
};
class AudiFactory : public AbstractFactory
{
public:Car *createCar(string name){return new Audi(name);}Light *createCarLight(){return new AudiLight();}
};int main()
{// 抽象工厂方法unique_ptrAbstractFactory bmwFactory(new BMWFactory);unique_ptrAbstractFactory audiFactory(new AudiFactory);unique_ptrCar p1(bmwFactory-createCar(X6));unique_ptrCar p2(audiFactory-createCar(A8));unique_ptrLight l1(bmwFactory-createCarLight());unique_ptrLight l2(audiFactory-createCarLight());p1-show();p2-show();l1-show();l2-show();return 0;
}代理模式
代理proxy模式通过代理类来控制实际对象的访问权限。其实也就是定义一个虚基类子类继承虚基类实现不同级别对象的实现可以看以下类似代码
#include iostream
#include string
#includememoryusing namespace std;class VideoSite
{
public:virtual void freeMovie() 0;virtual void vipMovie() 0;virtual void ticketMovie() 0;
};
class FixBugVideoSite:public VideoSite
{// 不同的用户的访问权限可能不够所以下面三个函数有些对象不能调用void freeMovie(){cout 观看免费电影 endl;}void vipMovie(){cout 观看vip电影 endl;}void ticketMovie(){cout 观看电影券电影 endl;}
};// 代理类用于代理FixBugVideoSite
class FreeVideoSiteProxy:public VideoSite
{
public:FreeVideoSiteProxy(){pVideo new FixBugVideoSite();}~FreeVideoSiteProxy(){if(pVideo!nullptr){delete pVideo;}pVideo nullptr;}void freeMovie(){pVideo-freeMovie();}void vipMovie(){cout 您目前只是普通用户需要升级成vip才能观看vip电影 endl;}void ticketMovie(){cout 您目前只是普通用户需要购买电影券才能观看电影 endl;}private:VideoSite *pVideo;
};
class VipVideoSiteProxy : public VideoSite
{
public:VipVideoSiteProxy(){pVideo new FixBugVideoSite();}~VipVideoSiteProxy(){if (pVideo ! nullptr){delete pVideo;}pVideo nullptr;}void freeMovie(){pVideo-freeMovie();}void vipMovie(){pVideo-vipMovie();}void ticketMovie(){cout 您目前只是普通用户需要购买电影券才能观看电影 endl;}private:VideoSite *pVideo;
};
int main()
{// unique_ptrVideoSite p1(new FreeVideoSiteProxy());unique_ptrVideoSite p1(new VipVideoSiteProxy());p1-freeMovie();p1-vipMovie();p1-ticketMovie();return 0;
}观察者模式
行为型模式主要关注的是对象之间的通信。
以观察者-监听者模式发布-订阅模式设计模式主要关注的是对象的一对多的关系也就是多个对象都依赖一个对象当该对象的状态发生改变时其他对象都能够结束到相应的通知。
ps一组数据改变数据对象-通过这一组数据-曲线图对象1/柱状图对象2/圆饼图对象3。当数据对象改变时对象1、对象2、对象3应该及时的收到相应的通知。
#include iostream
#include string
#includelist
#includeunordered_mapusing namespace std;
/**
观察者模式/订阅模式当一个对象发生改变时会通知其他对象去处理对象的事件。
*/
class Observer
{
public:virtual void handle(int msgid) 0;
};
class Observer1:public Observer
{void handle(int msgid){switch (msgid){case 1:cout observer1 recv 1 msg. endl;break;case 2:cout observer1 recv 2 msg. endl;break;default:cout observer1 recv unknow msg. endl;break;}}
};
class Observer2 : public Observer
{void handle(int msgid){switch (msgid){case 3:cout observer2 recv 3 msg. endl;break;case 2:cout observer2 recv 2 msg. endl;break;default:cout observer2 recv unknow msg. endl;break;}}
};
class Observer3 : public Observer
{void handle(int msgid){switch (msgid){case 1:cout observer3 recv 1 msg. endl;break;case 3:cout observer3 recv 3 msg. endl;break;default:cout observer3 recv unknow msg. endl;break;}}
};
class Subjects
{
public:// 给主题添加观察者对象void addObserver(Observer* obser,int msgid){// 和下面的操作一致如果存在msgid为key的情况就直接插入没有就创建一个并插入_submap[msgid].push_back(obser);/**// 查找map中是否存在有key为msgid的值auto it _submap.find(msgid);if(it ! _submap.end()){it-second.push_back(obser);}else{listObserver * olist;olist.push_back(obser);_submap.insert(make_pair(msgid, olist));}*/}// 主题检测发生改变通知相应的观察者对象处理事件void dispatch(int msg){auto it _submap.find(msg);if (it ! _submap.end()){for(Observer* pObser:it-second){pObser-handle(msg);}}}
private:unordered_mapint, listObserver * _submap;
};
int main()
{Subjects sub;Observer *p1 new Observer1();Observer *p2 new Observer2();Observer *p3 new Observer3();sub.addObserver(p1, 1);sub.addObserver(p2, 3);sub.addObserver(p3, 1);sub.addObserver(p3, 2);sub.addObserver(p1, 3);sub.dispatch(2);return 0;
}适配器模式
适配器模式让不兼容的接口可以在一起工作。
下方使用C实现了一个电脑播放投影视频的例子电脑仅仅支持VGA接口如何实现HDMI接口转化成VGA来适配电脑使用。也就是如何实现一个VGA和HEMI类的转化接口。
#include iostream
#include stringusing namespace std;class VGA
{
public:virtual void play() 0;
};
class TV01:public VGA
{
public:void play() { cout 通过VGA接口连接投影仪进行视频播放 endl; }
};class HDMI
{
public:virtual void play() 0;
};
class TV02 : public HDMI
{
public:void play() { cout 通过HDMI接口连接投影仪进行视频播放 endl; }
};// 一定要继承原来的类
class VGA2HDMIAdapter:public VGA
{
public:VGA2HDMIAdapter(HDMI* p):phdmi(p){}void play() { phdmi-play(); }private:HDMI *phdmi;
};
class Computer
{
public:// 由于电脑只支持VGA接口所以该方法的参数也只支持VGA接口的指针/引用void playVideo(VGA *pVGA) { pVGA-play(); }
};int main()
{// HDMI和VGA无法进行互相转化电脑如何使用HDMI的play方法/*1、换一个支持HDMI的电脑也就是对Computer类进行重构叫做代码重构。2、使用一个适配器转化头把VGA类转化为HDMI类叫做添加适配器类。*/Computer computer;computer.playVideo(new TV01());computer.playVideo(new VGA2HDMIAdapter(new TV02()));return 0;
}装饰器模式
装饰器decorate模式和代理模式类似。代理模式也就是定义委托类和代理类继承抽象类并重写函数方法通过在代理类中使用委托类的对象调用不同级别代理的方法访问。
装饰器主要是增加现有类的功能但是添加现有类的一个方法还有一个方法就是新建一个子类。如果每次新建一个功能都需要新建一个子类的话那么代码中就会有很多的子类被添加进来。
以下实现了一个汽车装饰类的代码实现
#include iostream
#include stringusing namespace std;class Car
{
public:virtual void show() 0;
};
class BMW : public Car
{
public:void show() { cout 这是一辆宝马汽车有基本配置; }
};
class Audi : public Car
{
public:void show() { cout 这是一辆奥迪汽车有基本配置; }
};
class Benc : public Car
{
public:void show() { cout 这是一辆奔驰汽车有基本配置; }
};
// 装饰器
class CarDecorator01 : public Car
{
public:CarDecorator01(Car *p) : pCar(p){};void show(){pCar-show();cout ,辅助驾驶;}
private: Car *pCar;
};
class CarDecorator02 : public Car
{
public:CarDecorator02(Car *p) : pCar(p){};void show(){pCar-show();cout ,自动校正;}private:Car *pCar;
};
class CarDecorator03 : public Car
{
public:CarDecorator03(Car *p) : pCar(p){};void show(){pCar-show();cout ,车道偏离;}private:Car *pCar;
};
int main()
{Car *p1 new CarDecorator01(new BMW());p1 new CarDecorator02(p1);p1-show();cout endl;Car *p2 new CarDecorator02(new Audi());p2-show();cout endl;Car *p3 new CarDecorator03(new Benc());p3-show();cout endl;return 0;
}单例模式
常见的类创建一个对象便会得到一个新的对象。而单例模式则有些不同。
单例模式一个类不管创建多少次对象永远只能得到该类型一个对象的实例。可以查看C实现MySQL数据库连接池中的线程池获取代码将线程池定义为静态成员方法和静态成员变量导致其处于静态变量区只需要初始化一次。类似的日志模块应该也可以使用单例模式。
饿汉式单例模式还没有获取实例对象实例对象就已经产生了。 懒汉式单例模式唯一的实例对象直到第一次获取它的时候才产生。
下面介绍了两种单例模式的代码设计其中提供了两种懒汉式单例模式的示例
#include iostream
#include string
#includemutex
using namespace std;// 饿汉式单例模式线程安全的
class HungrySingleton
{
public:// 因为其不能依赖对象所以要定义成静态成员方法获取类的唯一实例对象的方法static HungrySingleton* getSingleton(){return instance;}
private:// 单例模式不允许用户new对象所以需要使用构造函数私有化HungrySingleton(){}static HungrySingleton instance;// 将拷贝构造函数和赋值操作符重载进行删除使其不能完成对象创建只能依赖getSingleton过去唯一的实例化对象HungrySingleton operator(const HungrySingleton ) delete;HungrySingleton(const HungrySingleton ) delete;
};
// 类内定义类外初始化更多static初始化查看 https://blog.csdn.net/sevenjoin/article/details/81772792
// 静态成员在数据段在main函数之前就创建了如果不使用的话这个资源就浪费了
HungrySingleton HungrySingleton::instance;mutex lazySingletonMtx;// 懒汉式单例模式线程安全的
class LazySingleton
{
public:// 因为其不能依赖对象所以要定义成静态成员方法获取类的唯一实例对象的方法// 可重入函数的概念一个线程还没执行完该函数不能被另一个线程执行也就是线程互斥static LazySingleton *getSingleton(){ if(instancenullptr){lock_guardmutex lck(lazySingletonMtx); // 所以多线程环境下需要加锁和双重判断/*不是线程安全下面这个instance new LazySingleton()需要执行-开辟内存、构造对象、instance赋值*/if(instancenullptr){ // 双重判断防止两个线程同时进入上层的if判断中instance new LazySingleton();}}return instance;}private:// 单例模式不允许用户new对象所以需要使用构造函数私有化LazySingleton(){}static LazySingleton*volatile instance;// 将拷贝构造函数和赋值操作符重载进行删除使其不能完成对象创建只能依赖getSingleton过去唯一的实例化对象LazySingleton operator(const LazySingleton ) delete;LazySingleton(const LazySingleton ) delete;
};
// 类内定义类外初始化更多static初始化查看 https://blog.csdn.net/sevenjoin/article/details/81772792
// 静态成员在数据段在main函数之前就创建了如果不使用的话这个资源就浪费了
LazySingleton*volatile LazySingleton::instancenullptr;// 懒汉式单例模式线程安全的
class LazySingleton2
{
public:// 因为其不能依赖对象所以要定义成静态成员方法获取类的唯一实例对象的方法// 可重入函数的概念一个线程还没执行完该函数不能被另一个线程执行也就是线程互斥static LazySingleton2 *getSingleton(){// 静态对象运行到这个函数才开始初始化// 函数静态局部变量的初始化在汇编指令上已经自动添加线程互斥指令static LazySingleton2 instance;return instance;}private:// 单例模式不允许用户new对象所以需要使用构造函数私有化LazySingleton2(){}// 将拷贝构造函数和赋值操作符重载进行删除使其不能完成对象创建只能依赖getSingleton过去唯一的实例化对象LazySingleton2 operator(const LazySingleton2 ) delete;LazySingleton2(const LazySingleton2 ) delete;
};int main()
{HungrySingleton *p1 HungrySingleton::getSingleton();HungrySingleton *p2 HungrySingleton::getSingleton();HungrySingleton *p3 HungrySingleton::getSingleton();cout p1 p2 p3 endl; // 0x407030 0x407030 0x407030LazySingleton *p4 LazySingleton::getSingleton();LazySingleton *p5 LazySingleton::getSingleton();LazySingleton *p6 LazySingleton::getSingleton();cout p4 p5 p6 endl; // 0x25d2430 0x25d2430 0x25d2430// HungrySingleton t *p1; // 拷贝构造函数私有化之后就不能完成拷贝构造了return 0;
}一般情况下第二种懒汉式单例模式用的比较多也更简单在静态成员方法中定义静态成员对象。
