qq_33766994的博客

桥模式由于某些类型固有的实现逻辑，使得他们有多个维度的变化。即一个抽象基类对应的子类中，有多种变化的路径。桥模式：将抽象部分(业务功能)与实现部分(平台实现)分离，使它们都可以独立地变化。通过实例代码来理解这个解释：class Messager{public: //业务抽象维度的变化 virtual void Login(string username, string password)=0; virtual void SendMessage(string message)=0;

装饰模式

适配器模式由于环境的变化，常常需要将“一些现存的对象”放在新的环境中应用，但是新环境要求的接口是这些现存对象不满足的。主要应对迁移变化。适配器模式：将一个类的接口转换成客户希望的另一个接口。使得将原本由于接口不兼容而不能一起工作的那些类可以一起工作。#include<iostream>using namespace std;//目标接口class ITarget {public: virtual void process() = 0; virtual ~ITarget() {

代理模式在面向对象系统中，有些对象由于某种原因（对象的创建开销很大、某些操作需要安全控制、需要进程外的访问等）直接访问会给使用者、系统结构带来麻烦。代理模式：为其他对象提供一种代理以控制（隔离、使用接口）对这个对象的访问。#include<iostream>using namespace std;class Isubject {public: virtual void process() = 0;};//proxy的设计，实际实现会比较复杂。尤其是分布式系统class

外观模式：简化外部客户程序和系统间的交互接口。即在系统内外搭建桥梁（间接）。外观模式：为了系统中的一组接口提供一个一致（稳定）的界面Façade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用（复用）。#include<iostream>using namespace std;class A {public: void subOperation() { cout << "A Method..." << endl; }};class B

享元模式在软件系统采用对象方案解决问题在于大量细粒度的对象会充斥整个系统。而对象也有一定的开销。享元模式：运用共享技术有效地支持大量细粒度的对象。#include<iostream>#include<string>#include<map>using namespace std;class Font {private: string key;public: Font(const string& str):key(str){} void o

组合模式在软件某些情况下，客户代码过多地依赖于对象容器复杂的内部实现结构，对象容器内部实现结构（而非抽象接口）的变化将引起客户代码的频繁变化，带来了代码的维护性、扩展性弊端。组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性（稳定）#include<iostream>#include<list>#include<string>#include<algorithm>using

解释器模式在软件构建中，若某一特定领域的问题比较复杂，类似的结果不断重复出现，使用普通的编程方式来实现的话面临非常频繁的重复操作。解释器模式：给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。#include <iostream>#include <map>#include <stack>using namespace std;class Expression {public: virtual int

访问器模式在软件构建中，由于需求的变化，某些类层次结构中常常需要增加新的行为（方法），如果直接在基类中添加，会给子类带来繁重的变更负担，破坏原有设计。访问器模式：表示一个作用于某对象结构中的各元素的操作。使得可以在不改变（稳定）各元素类的前提下定义（扩展）作用于这些元素的新操作（变化）。#include<iostream>using namespace std;class Visitor;class Element {public: virtual void accept(Vi

命令模式软件构建过程中，“行为请求者”与“行为实现者”通常呈现一种紧耦合关系，在某些具体的事务中，比如需要对行为进行记录、撤销、事务等处理，这种情况下就需要解耦。命令模式：将一个请求(行为)封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志、支持可撤销的操作。#include<iostream>#include<string>#include<vector>using namespace std;class Command {

职责链模式在软件的构建中，一个请求可能被多个对象处理，但是每个请求在运行时只能有一个接受者，若显示指定，将带来发送者与接受者之间的紧耦合。职责链模式就是使多个对象都有机会处理请求，避免请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递请求，直到一个对象处理它为止。#include<iostream>#include<string>using namespace std;enum class RequestType{ REQ_HANDLE1,

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。#include<iostream>#include<string>#include<vector>using namespace std;class Iterator {public: virtual string first() = 0; virtual string next() = 0; virtual bool isDone() const = 0;

备忘录模式某些对象的状态在转换的过程中，可能有需要回溯到之前状态的需求。在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。#include<iostream>#include<string>#include<vector>using namespace std;class Memento {//备忘录，存储原发器对象的内部状态statepublic: Memento(const string& str) :state(s

状态模式在软件构建过程中，某些对象的状态变化会导致行为也随之变化。允许一个对象在其内部状态改变时改变它的行为，使对象看起来似乎修改了其行为。enum NetworkState{ Network_Open, Network_Close, Network_Connect,};class NetworkProcessor{ NetworkState state;public: void Operation1(){ if (state == Netw

中介者模式在软件构建过程中，经常出现多个对象相互关联交互的情况，对象之间常常会维持一种复杂的引用关系，如果遇到需求变更，这种引用关系会面临不断地变化（不稳定）。在这种情况下，使用一个中介对象来封装一系列的对象交互（封装变化），使得各对象不需要显式的相互依赖（编译时依赖->运行时依赖），达到松耦合的目的（管理变化）。代码如下：以租房为例（此处对象只有两个：租房者和房东）#pragma once#ifndef MEDIATOR_H#define MEDIATOR_H#include<st

观察者模式定义对象间的一种一对多的依赖关系，当一个对象的状态发送改变时，所以依赖于他的对象得到通知并被自动更新。具体代码如下：#pragma once#ifndef OBSERVER_H#define OBSERVER_H#include<vector>#include<iostream>using namespace std;class Subject;class Observer {//抽象观察者public: virtual int getState

策略模式策略模式主要解决枚举变化的情况，转化为一系列算法类。enum TaxBase{ CN_Tax, UR_Tax, UK_Tax, FR_Tax};class SalesOrder {private: TaxBase tax;public: double CalculateTax() { if (tax == CN_Tax) { //... } else if(tax==UR_Tax){ //... } else if (tax == UK_T

模板方法模式主要解决父类中不稳定的方法，延迟到子类中去实现的问题。抽象类代码如下：#pragma once#ifndef TEMPLATE_H#define TEMPLATE_H#include<iostream>using namespace std;class Library {public: void Run() { step1(); if (step2()) {//支持变化，多态调用 step3(); } for (int i = 0;

原型模式类似于工厂模式，将工厂模式中的抽象工厂类和具体工厂类合并。适用于复杂对象，即需要调用拷贝构造函数，而工厂模式对于复杂的函数对象实现麻烦。简单的对象创建就可以直接用工厂。看代码：#pragma once#include<iostream>using namespace std;class ISplitter {public: virtual void split() = 0; virtual ISplitter* clone() = 0;//克隆自己来创建对象 v

构建者模式主要是将一个复杂对象的构建和表示分离(类似模板方法模式)。直接上代码：#pragma once#include<iostream>#include<string>using namespace std;class House {public: virtual void setWall(const string& str) = 0; virtual void setWindow(const string& str) = 0; virtua

抽象工厂模式抽象工厂模式和工厂模式不同的是：创建一系列相互依赖的对象先上代码：#pragma once#include<string>#include<iostream>using namespace std;class IDBConnection {public: virtual void ConnectionString(string& str) = 0;};class IDBCommand {public: virtual void Comman

工厂模式很多博客都有工厂模式相关的理论介绍，就不照本宣科了，直接从问题出发。看代码：#pragma once#include<cmath>const double PI = acos(-1.0);class IGraph {public: virtual double Area() = 0;//计算图形的面积 virtual ~IGraph() {};};class Square :public IGraph {//正方形public: Square(double Sq

单例模式类的定义：class Singleton{private: Singleton(); Singleton(const Singleton& other);public: static Singleton* getInstance(); static Singleton* m_instance;};Singleton* Singleton::m_instance=nullptr;要点：1、无参数和有参数的构造函数私有化(防止系统自动生成或者用户