网站模板下载后怎么使用,代刷业务网站建设,优化设计三年级上册语文答案,做关于灯饰的网站五、设计模式 设计模式是在软件开发中#xff0c;经过验证的、在特定场景的解决⽅案。另⼀种说法是扩展隔离变化点#xff0c;抽象稳定点。 5.1 设计原则 1. 单⼀职责原则#xff1a;就⼀个类⽽⾔#xff0c;应该仅有⼀个引起它变化的原因。 2. 开放封闭原则#xff1…五、设计模式 设计模式是在软件开发中经过验证的、在特定场景的解决⽅案。另⼀种说法是扩展隔离变化点抽象稳定点。 5.1 设计原则 1. 单⼀职责原则就⼀个类⽽⾔应该仅有⼀个引起它变化的原因。 2. 开放封闭原则对程序的改动可以通过增加代码来完成但是不能改动现有的代码 3. ⾥⽒代换原则如果⼀个实体适⽤⼀个基类那么⼀定适⽤于其派⽣类 4. 依赖倒置原则针对接⼝编程不要针对实现编程 5. 迪⽶特原则如果⼀个类需要调⽤另⼀个类的某个⽅法的话可以通过第三个类转发这个调⽤ 6. 接⼝隔离原则每个接⼝中不应该存在派⽣类⽤不到却必须实现的⽅法否则就要将接⼝拆分 5.2 常⽤设计模式
单例模式 保证⼀个类仅有⼀个实例并提供⼀个访问它的⽅法。有饿汉模式和懒汉模式两种饿汉模式是该类定义的时候进⾏实例化且是线程安全的。 饿汉式 class Singleton
{public:static Singleton *getInstance(){return instance;}private:// Singleton() default;Singleton() {}Singleton(const Singleton instance) default;Singleton operator(const Singleton instance) default;static Singleton *instance;
};Singleton *Singleton::instance new Singleton(); 懒汉式 #include mutexclass Singleton
{public:static Singleton *getInstance(){if (instance nullptr){mtx.lock();if (instance nullptr){instance new Singleton();}mtx.unlock();}return instance;}private:Singleton() default;Singleton(const Singleton instance) default;Singleton operator(const Singleton instance) default;static Singleton *instance;static mutex mtx;
};mutex Singleton::mtx;
Singleton *Singleton ::instance nullptr; 简单⼯⼚模式 主要⽤于创建对象。⽤⼀个⼯⼚来根据输⼊的条件产⽣不同的类然后依据不同类的虚函数得到不同的结果。创建对象之间⽆依赖。产品基类定义纯虚函数其派⽣类实现该虚函数。⼯⼚类定义返回产品接⼝的函数通过判断传⼊的参数确定返回产品类型。 #include bits/stdc.h
using namespace std;
class IProduct {
public:
virtual void show() 0;virtual ~Product(){};
};
class ProductA : public IProduct {
public:
void show() {
cout ProductA.show() endl;
}
~ProductA(){};
};
class ProductB : public IProduct {
public:
void show() {
cout ProductB.show() endl;
}
~ProductB(){};
};
class SimpleFactory {
public:
IProduct* product(const string str) {
if (str productA) {
return new ProductA();
}
else if (str productB) {
return new ProductB();
}
return nullptr;
}
};
int main() {
SimpleFactory fac;
IProduct* pro;
pro fac.product(productA);
pro-show();
delete pro;
pro fac.product(productB);
pro-show();
delete pro;
return 0;
} 模板⽅法 定义⼀个操作中的算法框架⽽将⼀些步骤延迟到⼦类中。该⽅法使得⼦类可以不改变⼀个算法的结构即可重定义该算法的某些特定步骤。基类实现总处理步骤顺序的函数⽽每个步骤定义为虚函数。派⽣类实现所要改变某步骤的虚函数即可。 #include bits/stdc.h
using namespace std;
class Show {
public:
void show() { // 固定流程封装到这⾥
show0();
show1();
show2();
show3();
}
protected:
// ⼦流程 允许⼦类访问防⽌客户调⽤
virtual void show0() {
cout show0 endl;
}
virtual void show1() {
cout show1 endl;
}
virtual void show2() {
cout show2 endl;
}
virtual void show3() {
cout show3 endl;
}
};
class ShowEx: public Show {
protected:
virtual void show1() {
cout show1 update endl;
}
virtual void show2() {
cout show2 update endl;
}
};
int main() {
Show* zs new ShowEx;
zs-show();return 0;
} 责任链模式 使多个对象都有机会处理请求从⽽避免请求的发送者和接收者之间存在耦合关系。将这些对象连成⼀条链并沿着这条链传递请求直到有个对象处理它为⽌。基类有个指向⾃⼰的指针next还有两个函数分别是定义为纯虚函数的处理函数和设置下⼀个对象的函数。派⽣类实现虚处理函数包含⾃⼰的处理逻辑、传递给下⼀个对象操作、⽆法处理对应的操作等 #include bits/stdc.h
using namespace std;
class IHandler {
protected:
IHandler *next;
public:
void setNextHandler(IHandler* n) { next n; }
virtual bool handleRequest(string ctx) 0;
};
class HandleByMainProgram: public IHandler {
public:
virtual bool handleRequest(string ctx) {
if (ctx 1) {
cout HandleByMainProgram endl;
}
else if (next){
next-handleRequest(ctx);
}
else {
cout NO endl;
}
}
};
class HandleByProjMgr: public IHandler {
public:
virtual bool handleRequest(string ctx) {
if (ctx 2) {
cout HandleByProjMgr endl;
}
else if (next){
next-handleRequest(ctx);
}
else {
cout NO endl;
}
}
};
class HandleByBoss: public IHandler {
public:
virtual bool handleRequest(string ctx) {
if (ctx 3) {
cout HandleByBoss endl;
}
else if (next){
next-handleRequest(ctx);
}
else {
cout NO endl;
}
}
};
int main() {
IHandler *h1 new HandleByMainProgram();
IHandler *h2 new HandleByProjMgr();
IHandler *h3 new HandleByBoss();
h1-setNextHandler(h2);
h2-setNextHandler(h3);
h1-handleRequest(3);return 0;
} 装饰器模式 动态地给对象增加额外的功能。就增加功能⽽⾔该模式⽐⽣成⼦类更为灵活。与责任链最⼤不同在于是否有顺序关系。 基类有⼀个指向⾃⼰的指针变量同时有⼀个原始功能函数被定义为虚函数。派⽣类实现该虚函数并通过基类指针调⽤基类的功能函数。 #include bits/stdc.h
using namespace std;
class CalcBonus {
public:
CalcBonus(CalcBonus *c nullptr): cc(c) {}
virtual double calc(Context ctx) {
return 0.0;
}
protected:
CalcBonus *cc;
};
class CalcMonthBonus: public CalcBonus {
public:
CalcMonthBonus(CalcBonus *c): CalcBonus(c) {}
virtual double Calc(Context ctx) {
double mbonus 0.0;
return mbonus cc-calc(ctx);
}
};
class CalcSumBonus: public CalcBonus {
public:
CalcSumBonus(CalcBonus *c): CalcBonus(c) {}
virtual double Calc(Context ctx) {
double sbonus 0.0;
return sbonus cc-calc(ctx);
}
};
class CalcGroupBonus: public CalcBonus {
public:
CalcGroupBonus(CalcBonus *c): CalcBonus(c) {}
virtual double Calc(Context ctx) {
double gbonus 0.0;
return gbonus cc-calc(ctx);
}
};
int main() {
// 普通员⼯
Context ctx1;
CalcBonus *base new CalcBonus();
CalcBonus *cb1 new CalcMonthBonus(base);
CalcBonus *cb2 new CalcSumBonus(cb1);
cb2-calc(ctx1);
// 部⻔经理
Context ctx2;
CalcBonus *cb3 new CalcGroupBonus(cb2);
cb3-calc(ctx2);return 0;
} 观察者设计模式如何实现 1. 观察者设计模式的定义 指 多个对象间存在一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都得到 通知并被自动更新 。这种模式有时又称作发布 - 订阅模式、模型 - 视图模式它是对象行为型模式。 2. 优点 1 降低了目标与观察者之间的耦合关系 两者之间是抽象耦合关系。符合依赖倒置原则。 2 目标与观察者之间建立了一套触发机制。 3. 缺点 1 目标与观察者之间的依赖关系并没有完全解除而且有可能出 现循环引用。 2 当观察者对象很多时通知的发布会花费很多时间影响程序的效率。 4. 观察者设计模式的结构与实现 观察者模式的主要角色如下 1 抽象主题 Subject 角色也叫抽象目标类它提供了一个用于保存观察者对象的聚集类和 增加、删除观察者对象的方法以及通知所有观察者的抽象方法。 2 具体主题 Concrete Subject 角色也叫具体目标类它实现抽象目标中的通知方法当 具体主题的内部状态发生改变时通知所有注册过的观察者对象。 3 抽象观察者 Observer 角色它是一个抽象类或接口它包含了一个更新自己的抽象方 法当接到具体主题的更改通知时被调用。 4 具体观察者 Concrete Observer 角色实现抽象观察者中定义的抽象方法以便在得到 目标的更改通知时更新自身的状态。 可以举个博客订阅的例子当博主发表新文章的时候即博主状态发生了改变那些订阅的读者就会收 到通知然后进行相应的动作比如去看文章或者收藏起来。博主与读者之间存在种一对多的依赖关系。 #include iostream
#include vector
#include list
#include memory
#include algorithm
using namespace std;//观察者 --用户
class Observer
{
public:Observer() {}virtual ~Observer() {}virtual void Update() {}
};//博客 --主题
class Blog
{
public:Blog() {}virtual ~Blog() {}void Attach(Observer *observer){m_observers.push_back(observer);}void Remove(Observer *observer){m_observers.remove(observer);}void Notify(){listObserver *::iterator iter m_observers.begin();for (; iter ! m_observers.end(); iter){(*iter)-Update();}}virtual void SetStatus(string s){m_status s;} //设置状态virtual string GetStatus(){return m_status;} //获得状态private:listObserver * m_observers; //观察者链表protected:string m_status; //状态。
};//具体 主题
class BlogCSDN : public Blog
{
private:string m_name;public:BlogCSDN(string name) : m_name(name) {}~BlogCSDN() {}virtual void setStatus(string s){m_status CSDN 通知 m_name s; //具体设置状态信息}string GetStatus(){return m_status;}
};//具体观察者。
class ObserverBlog : public Observer
{private:string m_name;Blog *m_blog;public:ObserverBlog(string name, Blog *blog) : m_name(name), m_blog(blog) {}~ObserverBlog() {}void Update(){string status m_blog-GetStatus();cout m_name -------------------- status endl;}
};//测试案例。
int main()
{Blog *blog new BlogCSDN(wuzhekai1985);Observer *observer1 new ObserverBlog(tutupig, blog);blog-Attach(observer1);blog-SetStatus(Publishing Design Pattern CImplementation (15) - Observer Pattern);blog-Notify();delete blog;delete observer1;system(pause);return 0;
}
