设计模式之结构型模式与行为模式

可参考菜鸟教程
github：https://github.com/duchenlong/linux-text/tree/master/designMode

结构型模式（Structural Patterns）

主要功能

处理类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式

他描述两种不同的事物，即类与类的实例（对象），于是就可以分为`类结构型模式`和`对象结构型模式`

适配器模式

意图

适配器模式将一个接口转换成客户希望的另一个接口，从而使得接口不兼容的那些类可以一起工作

使用

1. 系统需要使用现有的类，而此类的接口不符合系统的需要
2. 想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口
3. 通过接口转换，将一个类插入另一个类系中

注意：

适配器不是在详细设计时添加的，而是解决正在服役的项目的问题

生活中的适配器的场景

1. 手机的type-c充电器或者安卓充电器。比如说，华为手机想要充电，使用别人相同型号的充电器，也可以充电
2. 插座。只要插座中有对应的插孔，那么就可以给不同的电器供电使用

模拟

提供一个操作和两个场景，一个是该操作原本的需求，另一个则是附加的需求

类声明

class Target
{

public:
	Target();

	virtual ~Target();
	virtual void Operation() const;

};

class Adapter : public Target
{

public:
	Adapter();
	virtual ~Adapter();

	virtual void Operation() const;

};

main函数定义

运行结果：

另外，在C++的STL中，有一些常见的容器也用到适配器的例子，比如说stack，queue底层的默认数据结构就是deque，而map，set底层的默认数据结构就是rb-tree

桥接模式

桥接模式是将抽象部分与实现部分分离，是他们都可以独立的变化。

意义

解耦。将原本类与类之间一对多的关系，向上一层进行抽象，变为两个接口之间的一对一的关系。

改变了下面的这种类与类之间之间直接调用的关联关系

特点

1. 抽象和实现的分离
2. 优秀的扩展能力
3. 实现细节对客户透明

使用场景

1. 如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系
2. 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用
3. 一个类存在两个独立变化的维度，且这两个维度都需要进行扩展

模拟

对于抽象的调用类，建立的需求就是，传递一个参数 A ，边调用接口A的实现方法；传递一个参数B，调用接口B的实现方法

类声明

class abstration
{

public:
	abstration() {

	}

	virtual ~abstration() {

	}
	implement *m_implement;

	virtual void operation() =0;

};

class abstrationA : public abstration
{

public:
	abstrationA();
	virtual ~abstrationA();

	virtual void operation();

};

class implement
{

public:
	implement() {

	}

	virtual ~implement() {

	}

	virtual void operation() =0;

};

class implementA : public implement
{

public:
	implementA();
	virtual ~implementA();

	virtual void operation();

};


class implementB : public implement
{

public:
	implementB();
	virtual ~implementB();

	virtual void operation();

};

运行结果

函数实现

组合模式

组合模式，又称为整体-部分模式。通过组合多个对象形成的树状结构，以表示整体-部分的结构层次。

对单个对象（叶子对象），和组合对象（容器对象）的使用具有一致性

特点

1. 高层模块调用简单
2. 节点自由增加

应用

算术表达式包括操作数、操作符和另一个操作数，其中，操作数也可以是操作数、操作符和另一个操作数

模拟场景

需求是构造出下面这种树形结构，通过对跟节点的操作，可以打印出整个树的节点

类声明

树形结构在类图中的描述，便是使用聚合的方式

class Component
{

public:
	Component() {

	}

	virtual ~Component() {

	}

	virtual void Operation(int n) =0;
	void indent(int n);
};

class Leaf : public Component
{

public:
	Leaf();
	virtual ~Leaf();

	virtual void Operation(int n);
};

class Composite : public Component
{

public:
	Composite();
	virtual ~Composite();

	virtual void Operation(int n);
	void add(Component*& c);
private:
	list<Component*> _child;

};

main函数实现

运行结果

装饰模式

装饰模式，可以动态的给一个对象增加一些额外的职责。在增加对象的功能方面，比生成子类的实现更为灵活。

特点

装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能

注意

可代替继承

模拟场景

现在的需求是做一个衣服，附加的条件是给衣服加个颜色。

那么衣服就可以使用 Basic，装饰的颜色使用Decorator类表示，颜色为A，B 两种

类的声明

class Component
{

public:
	Component() {

	}

	virtual ~Component() {

	}

	virtual void Operation() =0;

};

class BasicComponent : public Component
{

public:
	BasicComponent();
	virtual ~BasicComponent();

	virtual void Operation();

};

class Decorator : public Component
{

public:
	Decorator();
	virtual ~Decorator();
	Component *m_Component;

	Decorator(Component* c);
	virtual void Operation();

};

class DecoratorA : public Decorator
{

public:
	DecoratorA();
	virtual void Operation();
};

class DecoratorB : public Decorator
{

public:
	DecoratorB();
	virtual void Operation();
};

main函数实现

运行结果

行为模式

行为模式涉及到算法和对象间的职责和分配。他描述了通信方式、控制方法以及对象之间的联系方式

1. 类行为模式，使用继承关系在几个类之间分配行为
2. 对象行为模式，使用对象的聚合来分配行为

责任链模式

责任链模式，是一种对象行为模式，避免了请求发送者与接受者耦合在一起，让多个对象都有可能接收到消息，将这些对象连接成一条链，然后沿着这条链传递请求，直到有对象对他进行处理为止

处理场景

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了

使用创建

1. 有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定
2. 在不明确指定接收者的情况下，向多个对象中的一个提交一个请求
3. 可动态指定一组对象处理请求

解释

传统的模式中，为了保证每个请求可以被任何响应接收，那么就变成了请求与响应之间多对多的一个关系

责任链模式中，将请求与响应分开，请求者需要告诉响应者需要几号响应，然后内部的操作会找到这个响应，并进行调用

模拟

有三个处理请求的类，建立如下所示的一条链，然后输入对于的编号，依次找到调用的那个类

类声明

class ChainOfResponsibility
{

public:
	ChainOfResponsibility(ChainOfResponsibility* ch) {

	}

	virtual ~ChainOfResponsibility() {

	}
	virtual void Handle(int i) =0;

protected:
	void Next(int i) =0;

private:
	ChainOfResponsibility* _successor;

};

class Extend1Chain : public ChainOfResponsibility
{

public:
	Extend1Chain(ChainOfResponsibility* ch);

	virtual void Handle(int i);
};

Extend1Chain::Extend1Chain(ChainOfResponsibility* ch){

}
void Extend1Chain::Handle(int i){

}

main 函数逻辑

运行结果

观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式

作用

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

特点

1. 观察者和被观察者是抽象耦合的
2. 建立一套触发机制。

使用场景

1. 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。
2. 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。
3. 一个对象必须通知其他对象，而并不知道这些对象是谁。
4. 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。

注意

1. 避免循环引用。
2. 如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

模拟

有这样一个需求，观察者有多种行为：二进制打印数字，十六进制打印数字。

当某一个类对变量进行修改的时候，对修改后的结果进行打印，通知给所有的观察者。

类模型

main函数实现

运行结果