设计模式

对修改关闭，对稳定的开发。将变化的封装在稳定的里面提供接口给外部子类实现。

传入对象又返回对象，达到链式调用。

调用时：obj->productname(“xxx”).companyname(“XXX”).part1(“XXX”).part2(“XXX”).part3(“xxx”).part4(“xxx”).bulid(); 而且是有先后顺序的，最后一个函数对赋值后的对象整体build。

就是在类实现一个接口，让接口可以克隆（会重新new一个对象）当前的对象并返回，很方便的复制一个对象。克隆是如果对象有结合/引用的对象要替换结合/引用对象。 如果引用（指针）也拷贝过来，那么后期修改克隆对象里面的引用，原始对象也会一起改变。因为这两个对象的引用指向同一个位置的。解决就是：克隆对象的时候，引用指向的位置也要重新克隆创建一份，再替换克隆的引用到克隆的对象（在大的对象的克隆函数里面实现这些克隆引用的操作）。

直接克隆有容量的变量叫做浅拷贝，拷贝对象里的引用（需要创建引用指向的位置的数据）叫深拷贝。

当对象里面只包含数据就浅拷贝，当对象里面含有引用等可变对象的时候进行深拷贝。

数组需要深拷贝

共享对象在多线程时需要用互斥锁

适配器主要起转换作用，是两个不兼容放入对象也可以互相沟通。

类的视频器模式使用继承的方法、对象的适配器模式使用组合的方法。

组合是引用到让后计算出来，委托一样的 。

继承是不好的，会继承很多没用的方法。

符号开闭原则：对修改关闭，对拓展开放。

抽象僵尸的共性作为父类，普通僵尸和旗手僵尸分别继承父类并实现自己的不同部分。

定义好各种算法，运行时，传什么算法就执行什么算法。而不想之前的一个僵尸继承一个僵尸，代码的阅读性上非常不好，改动代码需要了解很多的父类。

对于开发者，实现一个抽象的接口和接口会接收各种算法，算法也提前实现好。对于使用者，只需拿到抽象接口，然后对接口传入各种算法就可以实现不一样的功能。

定义一个父类抽象接口，具体的实现交给子类实现，子类在实现的时候接收一个动态的传入的参数即算法。

*

抽象方法（C++里面的虚函数）其实就是一个指针。类里面的方法其实是就是一个全局函数，就算没有参数也会接收一个参数this指针。

每一个对象都专注做自己的业务处理，如果成功继续进入下一个链接节点，不成功直接返回结束流程。各个节点没有耦合关系。

经典案列，过滤器，网站登录

• 计算机软件的设计原则

不要将与对象无光的函数直接定义在对象里面，而应该形成一个接口，在对象里面实现接口，而且其他的对象也可以实现这个接口，而不用去继承最开始那个对象。

依赖倒置就是抽象出来，然后运行时赋值，由程序高层实现，而不是底层自己实现。

• 抽象类和混入类

接口又叫抽象类，需要在子类中实现，抽象类不能被实例化，非抽象类叫做具体类。

混入类给其他的类提供公共接口，可以被多个对象继承，作为对象的一部分。

• 对象的组合和继承

对象的继承：是在编译时候确定的，不能在运行时动态改变父类。父类代码的任何改变都会直接影响找到子类。

对象的组合：是通过获得其他对象的引用而在运行时动态定义的。运行时还可以用一个相同的对象替换另一个对象。

优先使用对象组合，而不是继承。但是使用继承要比创建新的构件容易，而且在编译时就确定。

使用组合将会有更好的复用性。

• 委托

委托是一种组合方法。例如一个对象要获得求圆对象的面积方法，我们只需在对象中定义一个求圆面积的方法并将圆对象的引用作为参数传入，从而委托圆对象返回自己的面积。

因为委托是基于对象组合的，也具有动态性，比静态的继承更难理解。

• 参数化类型

参数化类型，在定义类时不指定类型，在创建对象时以参数形式传入。传入什么参数就创建什么参数类型的对象。

• 懒汉和饿汉初始化

懒汉初始化：在需要使用的时候创建（注意考虑线程安全防止多次创建），饿汉初始化：在编译的时候就创建。

文章以下所有的斜体表示抽象类和对象，正常字体表示具体类和对象。

• 四人组GOF23

GoF（Gang of Four），中文名——四人组。

• SOLID设计七大原则

创建型模式

• 1.AbstractFactory—抽象工厂模式

1.将客户与类的实现分离。

2.客户通过抽象的接口操纵实例。

3.产品的类名被隔离，即它们不出现在客户代码中。

被抽象出来的接口就好像一个工厂（有造产品的方法），生产者（实现造产品的方法）根据不同的产品提供不同的造产品的方法。

工厂 – –> 产品，工厂根据方法生产出一模一样的产品。

缺点是：难以支持新种类的产品。

1
2
3
4

class factory // 工厂
{
    create_product(); // 工厂方法，编译时确定
};

• 2.Build（生成器）—对象创建行模式

根据生成器里面的标志，决定使用生成器里面哪种方法进行生成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Build // 接口抽象类
{
    ops_A(); // 装配方法
    ops_B();
    ops_C();
};

// 阅读器
class reader
{
    int type;
    get_type_and_do(class Build); // 根据不同的type采用不同的装配方法
    int do_done; // 表示产品已经被装配完成，用来给客户检索产品是否装配完成
};

//具体的bulid_A
class build_A
{
    class Build; // 实现接口抽象类
}

将具体的bulid算法和对象独立开，build中有各种各有的build算法，使用哪种算法取决于reader。

它将构造代码和表示代码分开，客户不需要知道产品具体的创建和装配方法。

bulid本身自己并不会创建和装配，build_A才会具体的创建和装配。

抽象工厂模式和build模式，都可以用来构建产品，只是抽象工厂侧重于快速构建一个一个的相同产品，build模式侧重于怎样一步一步的构建产品的过程。先ops_A–>ops_B–>ops_C.

• 3.Factory Method（工厂方法）–对象创建型模型

别名：虚构造器（工厂方法）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。使一个类的实例化延时到子类。

当一个类不知道它应该创建什么样的对象的时候。

当需要委托另外一个类来帮助创建一个对象的时候。

就是在接口里面定义一个创建对象方法让别人去实现。

用于分层思想实现，上层只使用接口里面的函数，而下层负责实现里面的函数，上层委托下层，下层向上层提交工厂方法。

上层使用的参数对象都是虚的，它们具体的实现都在下层。上层就是一个工厂，只是提供了一个生成的环境，知道这个工厂能造什么产品，工厂怎么造产品的作业指导书是需要下层提供。

工厂方法主要用于工具包和框架中。

• 4.Prototype（原型）–对象创建型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

构建一个通用的类（框架），通过在此框架扩展其它类。

实现一个原型管理器，所有的原型串起来。用于客户检索用，原型管理器即注册表。

克隆和实例化一个对象效果一样，会申请空间。克隆完后可再修改其中需要改变的地方，在抽象类添加一个init函数。

如对象里面有引用则需要进行深拷贝。

• 5.Singleton（单例模式）–对象创建型模式

保证一个应用的一个类只能被实例化一次，每次返回这个类的对象。

静态模式创建：在编译时分配空间，饿汉模式，动态模式创建：懒汉模式需要加锁并双重检测加voaliter，或者使用内部类，类里面包含一个类用于实例化对象。

结构型模式

• 6.Adapter（适配器）–类的结构型模式

适用于对一个以存在的类，但它的接口不符合你的需求。

对一个已存在的类进行扩展操作。

适配器使用多重继承，继承需适配和被适配类。

双向适配器。

类的适配器模式使用继承，对象的适配器模式使用的组合。

• 7.Bridge（桥接）–对象结构型模式

将接口和其实现部分分离，一个接口不一定只能绑定在一个实现上，在运行时可以动态改变实现。

改变一个实现类，并不需要重新编译abstraction类和它的客户端程序。

实现的细节对客户透明。

抽象接口在设计编译的时候就被确定，而接口的额实现是在运行的时候动态加载，这使得抽线接口和实现部分可以独立进行改变。

对它的接口和实现部分进行桥接。接口是稳定的，怎么实现是变化的。

事先知道抽象和实现两者是独立演化的，实现是有多种的。

• 8.Composite（组合）–对象结构型模式

将对象组合成树形的结构以表示“部分 - 整体”的层次结构。使得用户对单个对象和组合对象的使用具有一致性。

简单的Text和Line等小类，另外定义一个容器类包含这些小类。

将多个类组合起来挂载到一个容器类，提供一个统一的抽象接口给用户添加、删除、遍历，这有利于减少维护类的个数，减少程序复杂度。

rtthread的设备IO管理器就是使用组合模式实现。

组合类需要提供一个接口给各个小类实现。组合类中有一个由于串联存放这些接口实现的集合对象。

小类的基本对象也可以是组合类，这样小类又包含很多小小类，可以组成一个复杂的树形结构。

如果需要频繁的对组合对遍历查找，可以在组合类中设计一些缓存子节点的变量。

• 9.Decorator（装饰）–对象结构型模式

动态地给一个对象添加一些额外的职责。扩展对象功能。

采用继承的机制扩展父类，更加好的方法是保存引用的方法，比静态继承更灵活，防止多个子类继承产生许多新的类。

被添加进入的功能称为装饰品，用来装饰父类的。

装饰的对象接口必须与它所装饰的接口是一致的。所有的被装饰者必须有一个公共的父类。

策略模式可以改变对象的内核，而装饰模式仅改变对象的外观。

• 10.Facade（门面、外观）–对象结构型模式

为子系统定义一个一致的界面，Facade模式定义一个高层的接口，这个接口使得子系统更加容易使用。

将一个系统划分成为若干个子系统有利于降低系统的复杂性。一个常见的设计目标是使子系统间的通信和相互依赖关系达到最小。达到该目标的途径之一是就是引入一个外观。

编译器的外观可方便大多数程序员使用,同时对少数懂得如何使用底层功能的人,它并不隐藏这些功能，外观也叫用例。就是一个系统的使用场景。用户看得见的。

由于用户操作的是外观，程序中各个子系统被独立开。

如果用户想实现更加定制化的功能可以直接跨过外观。

客户通过发送请求的的方法给Facade通信，Facade将这些消息转发给适当的子系统对象。

使用Facade的客户端程序不需要直接访问子系统对象。

Facade模式有助于建立层次结构。

Facade模式可以消除复杂的循环依赖关系，这一点在客户程序和子系统分别实现的时候尤为重要。

• 11.Flyweight（享元）–对象结构型模式

运用共享技术有效地支持大量细粒度的对象。

每个共享对象是独立的，在不同实例下和普通的对象是一样的。

共享对象的粒度不可太小否则系统开销会过大。

共享对象不能保存除共享对象外的外部的状态，共享对象必须独立和别的对象无关。

共享对象池，保存一类共享对象。

频繁使用的对象有必要作为共享对象。

共享对象需要保证它的线程安全。

一般是一些不可变的对象来作为共享对象。

共享对象只会被创建一次，并保存在共享池中。下次如果有需要用到已有的共享对象只需要引用这个对象而不必再创建。

必须保证共享对象被创建后不会再修改，以保证其线程安全。

共享模式通常和组合模式一起使用。

• 12.Proxy（代理）–对象结构型模式

为其他对象提供一种代理以控制对这个对象的访问。

用一个简单的占用空间的小的对象，暂时表示一个大的对象，在需要正真用到大的对象的时候实例化大的对象，然后小的对象指向大的对象，外部通过这个小的对象访问大的对象，小的对象是大的对象的一个代理。

在正真需要对象的时候才分配空间初始化，而不是一开始就分配初始化好，用一个小的对象表示它，证明它的存在。

实例化的对象的操作由代理在需要的时候完成。

小对象代理大对象叫做虚代理。

还有远程代理、保护代理、智能指引。

保护代理：可以通过代理设置一道访问权限。

远程代理：类似映射，不同的地址空间访问。

智能指引：在访问一个对象的时候提供一些附加操作，检查是否已经锁定它，以确保其他对象不能改变它。

Proxy:保存一个引用使得代理可以访问实体。

subject：定义一个代理和实体的共用接口，这样在任何使用实体的地方都可以使用代理。

代理根据其种类在适当的时间向实体转发请求。

适配器模式是提供一个与适配对象不同的接口，而代理则相反，提供一个与被代理对象相同的接口。

装饰模式与代理的实现部分相似，但装饰的目的不一样。装饰是为了增加扩展功能，而代理是为了控制对象的访问。

小结：

适配器和桥接：适配器是对两个已经存在的类，使它们能相互沟通，适配器相当于一个翻译员。桥接是使用者事先知道了一个抽象会有很多实现，而设计的将抽象和实现分离，因为抽象和实现在以后需要独立演化。

门面和适配器：门面是定义一组新的接口，同一给对外访问。而适配器是复用原有接口。

代理模式和装饰模式：装饰模式是为了扩展对象的功能，而代理模式是为了控制对象的访问。两个模式的出发目的不同。

装饰模式和组合模式：装饰模式通过生成子类来给类添加功能。这避免了静态实现所有的功能，导致子类的急剧增加。而组合模式不同，组合模式通过构造一个新的容器类，将具有相同接口的类同一处理，把多个对象当做一个对象处理。它的重点不再修饰，而正在表示。将多个相似的类用一个类就可以表示出来。装饰模式和组合模式目的截然不同，而且恰好互补，因而通常将这两个模式在一起使用。

行为型模式

• 13.Chain of Responsiblity（责任链）–对象行为型模式

一个链表的所有节点候选对象可以处理请求，具体谁处理是隐式的，可以是候选对象中的任一个。

对于一个节点若可以处理，处理之，否则转发给下一个节点，直到这个请求被处理

降低了耦合度，对象无需知道具体是哪个对象处理请求，只需要向整条责任链发送请求。

也有可能整条责任链没有一个节点可以处理这个请求。

当一个事件产生，这个事件就沿责任链传播，责任链常和组合模式一起使用，组合的容器用来挂载处理对象。

• B站上的责任链

使多个对象都有机会处理请求，从而避免请求者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

一个请求可以分解成很多小的检测，如果小的检测失败整个检测返回失败（状态机是转移状态），否则继续下一步小的检测，这些小的检测通过一个链表连接起来。全部检测通过才正真转发给请求的接收者。

• 14.Command（命令）–对象行为型模式

将一个请求封装成一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队或记录日志，以及支持可撤销的操作。

这就是main_task工作队列的实现方法。封装命令类，创建命令调用类（存放命令的链表和执行命令），实例化命令对象，放入命令调用对象，命令调用对象执行list中所有的命令。

抽象出来待执行的动作以参数化某对象，你可以用过程语言的回调函数表达这种参数化机制。

所谓回调函数是指函数现在某处注册，而他将在稍后某个需要的时候被调用。

将调用操作的对象与知道如何实现该操作的对象解耦。

在被放入历史列表前必须被拷贝的命令起到一种原型的作用。

• 15.Interpreter（解释器）–类的行为模式

给定一个语言（如正则表达式、SQL语句），定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

当一种特定类型的问题经常发生，可以定义一个语句表示这一特定问题发生，一个解释器子类专门解释这个语句。

抽象语法树：抽象语法树中所有的节点所共享。

易于改变和扩展文法。

• 16.Iterator（迭代器）–对象行为模式

提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。

一个聚合对象例如列表。

迭代器主要是将聚合对象和他的遍历操作分离，使得聚合对象不需要在其内部实现遍历的操作。分离出迭代器可以有复用性，复用于各种聚合对象，而且可以在迭代器里面丰富各不同遍历操作，前序遍历、中序遍历、后序遍历。

rtthread的rt_list函数集就相当是一个迭代器，它让只要包含rt_list对象的对象都能使用这个迭代器进行遍历、插入、删除等操作。

index：记录当前的遍历节点信息。

外部迭代器和内部迭代器：

外部迭代器：由用户自己实现，可以更加灵活，必须用户自己手动推进遍历的步伐，显示的向迭代器请求下一个元素。

内部迭代器：客户只需要向迭代器发送一个迭代的指令，迭代器内部自动完成整个遍历。

谁定义遍历算法：如果是聚合对象本身实现遍历算法，在遍历的过程中迭代器只是用来储存当前迭代的状态，这种迭代器又称为游标。

在迭代的时候，删除、插入聚合对象是非常危险的，可能导致一个对象漏掉或被两次迭代。可以先复制一份聚合对象，保证插入删除操作不会影响迭代操作。

• 17.Mediator（中介者）–对象行为模式

用一个中间对象来封装一系列的对象交互，使各个对象不需要显式地互相引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

虽然一个系统分割成许多小的对象可以增强其复用性，但大量对象互相连接的激增会降低其可复用性。最坏的情况各个对象之间耦合紧密，不可分割。

将集体行为封装在一个单独的中介者对象来避免各个对象之间的紧耦合。中介负责协调各个对象工作，成为一个中转中心。

1)列表框告诉它的操作者它被改变了。
2)导控者从列表框中得到选中的选择项。
3)导控者将该选择项传递给人口域。
4)现在入口域已有正文,导控者使得用于发起一个动作(如“半黑体” , “斜体”)的某个按钮可用。

解决问题：

一组对象定义良好但他们之间通信复杂，产生相互依赖的关系难以理解。

一个对象引用很对其他对象并且直接与这些对象通信导致难以复用这个对象。

想定制一个分布在多饿类中的行为，但又不想生成太多的子类。

同事对象：各个对象

中介者使对象控制集中化，中介者和门面模式的区别：中介者是为了对象间协同工作对内来说的，门面模式是提供给客户使用的是对外来说的，中介模式类似于适配器模式，使对象和对象能够沟通。门面模式是对子系统进行抽象，从而提供宇哥方便的总接口，它的协议是单向的，而中介模式协议是双向的。

• 18.Memento（备忘录）–对象行为模式

在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，在以后就可以将该对象恢复到原先保存的状态。

别名：token

一个备忘录是一个对象，它储存另一个对象在某一瞬间的内部状态，这个瞬间状态叫做备忘录的原发器。当需要生成一个备份的时候，向原发器请求一个备忘录。

备忘录可以让其他对象直接得到一个对象的状态，而有不会暴露对象的实现细节并破环对象的封装性。

原发器new一个备忘录，从Memento获取状态到备忘录并返回这个备忘录指针。

备忘录是被动的，只有创建备忘录的原发器才会对它的状态赋值和检索。

• 19.Observer（观察者）–对象行为模式

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

别名：依赖，发布-订阅

关键对象：目标、观察者

一个目标也可以有任意数目的依赖它的观察者。一旦目标发生改变，所有的观察者都得到通知。作为对这个通知的响应，每个观察者都将查询目标以使其状态与目标的状态同步。

ConcreteObserver观察者维护一个指向目标的引用，以便在收到通知时观察者和目标进行状态同步。

观察者模式运行独立地改变目标和观察者，你可以单独复用目标对象而无需同时复用其观察者，反之亦然。

它也运行你在不该动目标和观察者的情况下增加观察者。

此模式类似与，notify工具：区别update的是具体的参数而 不是对象引用。

目标的每个观察者都符合抽象的Observer类的简单接口，目标和观察者不是紧密耦合，因此它们可以处于一个系统中不同的抽象层次。一个处于较低层次的目标对象可以和一个处于较高层次的观察者通信并通知它。

Observer类的简单接口：回调的函数的封装，属于观察者的。

支持广播，一对多。

观察多个目标的时候，必须扩展update接口以使观察者知道是哪个目标送来的通知然后去检查哪个目标。

拉模型和推模型：拉模型强调的是目标不知道它的观察者，而推模型假定目标知道一些观察者需要的信息。推模型可能难以复用因为它做出了假设，拉模型效率较差。

拉模型：目标除最小通知外，什么也不送出去。在此之后由观察者显式地向目标询问细节。

推模型：目标向观察者发送关于改变的详细信息，而不管观察者需要与否。

解决以上冲突：显示的指定感兴趣的改变，扩展目标的注册接口，让观察者注册仅对自己感兴趣的事件，以提高更新效率。类似与mqtt里面的主题概念。订阅主题，只接收与主题相关的数据。linux里面的消息队列也是基于这样的思想，队列会有一个主题链表，订阅的主题才会收到，首先查主题链表，不在这条主题链表上的消息收不到。

对以上增加一个更改管理器：

更改管理器分别实现不同的更新协议。当不存在多重更新是使用简单变化管理器就可以满足。

changManager是中介者模式的一个实现，中介两个已存在的目标和观察者对象。通常一个系统只有一个changManager，这里可以用单例模式实现。

RTOS的软件定时器就是基于观察者模式，启动一个软件定时器就是创建了一个观察者，硬件定时器（目标）中断中，改变管理器每1ms检查一次它的观察者如果有超时的定时器，则通知该观察者（软件定时器）。观察者接收到通知就知道它的定时时间到了。

观察者结合中介者模式，通过在中介中封装复杂的更新协议，作为更新管理器。

使用单例模式保证系统中只存在一个更新管理器，并且是可全局访问的。

• 20.State（状态）–对象行为模式

允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

别名：状态对象

这一模式引入一个TCPState的抽象类。

Context：环境，定义客户感兴趣的接口，维护一个指向ConcreteState子类的引用。

State：定义一个接口以封装与Context的一个特定状态相关的行为。抽象出来给客户调用的。

简而言之：Context中的State引用在不同的时候指向不同的对象实现。不同的时候表现出不同的行为。

状态模式：每个状态的行为定义成一个类，使得可以很容易地添加删除新的状态和转换，不用在Context的实现内部遍布使用case、if等判断，增加一个状态需要修改代码逻辑，使维护变得复杂。状态模式使得每个状态相互独立结构和程序意图清晰。使得状态转换显式化。

状态的State可以被共享，不光Context对象可以使用这个状态，其他的包含State引用的对象也可以使用。

上面都是说的哪个状态使用什么行为，具体到底谁负责控制状态的转换：需要在Context中增加一个设置状态的接口，显式地进行状态转换。

在ConcreteState中可以有一个指向下一个状态的后继状态，隐式进行状态的转换，类似一个责任链模式。但这种模式会时状态和状态之间产生依赖。

更好的方法是实现一个状态表，将状态的转换关系定义在一个状态表中。通过查表进制状态转换，这种叫做表驱动的状态机。

• 21.Strategy（策略）–对象行为型模式

定义一系列算法把他们一个个封装起来，并且使用他们可以互相替换。使得算法可以独立于它的客户而变化。

如果客户程序直接包含具体的算法实现，会使客户程序变得复杂。

不同的时候需要不同的算法。

当客户和算法混在一起时，要想新增或者修改一个算法变得时分困难。

将算法封装成一个个策略解决上述问题。

一个个算法被封装成策略定义在代码里面，需要使用的时候实例化并把Composition内的compositor引用指向该策略。

使用策略可以避免暴露复杂的与算法相关的数据结构。

一个个算法变成独立的可被其他对象复用。使算法易于切换、易于理解、易于扩展。

• 22.Template Method（模板方法）–类的行为型模式

定义一个操作的算法骨架，而将一些步骤延迟到子类。使得子类可以不改变一个算法的结构即可以重定义该算法的某些特定步骤。

就是抽像出一些特定步骤，并定义这些步骤的执行步骤（骨架），特定的执行步骤的细节延时到子类显示。这个抽象出来的骨架就叫做模板。

AbstractClass定义抽象的原语操作，具体的子类将实现他们。

模板方法是一种代码复用的基本技术，模板方法导致一种反向控制结构，即“别找我们，我们找你”，指一个父类调用子类的操作。

钩子操作：提供一种缺省的行为，子类可以在必要时进行扩展。缺省即公共的操作在父类就存在，在子类做其他的步骤补充。

钩子操作是强制执行的公共操作子类不必重写这些公共操作。子类需要把握哪些操作需被重新定义哪些是不需要重写的。

模板方法模式和工厂方法模式非常相似，只是模板方法里面多了一个实现算法骨架的模板方法。客户可以直接使用模板方法，或者使用各个步骤实现自己想要的步骤。

一次性实现算法不变的部分，并把它在TemplateMethod实现好。

1
2
3
4
5
6
7
8
9
10
11

void TemplateMethod(void)
{
    .....
    .....
    //算法预处理固定的部分钩子操作
        PrimitiveOperation1();
    	PrimitiveOperation1();
    //算法的收尾工作固定的部分钩子操作
    ....
    ....
}

• 23.Vistor（访问者）–对象行为模式

表示一个作用于某对象结构的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

简单说就是在一个原有的对象接口里面实现一个accept函数，accept函数接收一个Vistor对象指针，在Vistor对象里面实现一个访问函数这个函数接收一个this指针以访问对象里面所有的成员。Vistor是需要用户自己定义实现，类似于给原来的对象传一个Vistor对象指针（一个升级包，升级包可以访问对象里面的所有成员）以扩展原有对象的功能或者改变原有对象的私有成员的值。

一个使用Visitor模式的客户必须创建一个ConcreteVisitor对象，然后遍历该对象结构，并用该访问者访问每一个元素。

每个对象将有一个相关的Visitor类。这个抽象的类为每个ConcreteElement类声明一个VisitorConcreteElement操作。

行为模式的讨论

封装变化：当一个程序的某方面的特征经常发生改变时，这些模式就定义一个封装这方面的对象。这样当该程序的其他部分依赖这个方面时，他们都可以与此对象协作。通常封装一个抽象类。例如：

策略模式封装一个算法。

状态模式封装一个状态。

中介者模式封装对象之间的协议。

迭代器模式封装访问和遍历一个聚集对象中各个构建的方法。

对象作为参数：访问者模式（访问者作为参数）、命令模式（封装一个command对象作为参数）、备忘录模式（备忘录对象传给要恢复源的对象）。

对发送者和接收者解耦：当合作的对象直接互相引用时，它们互相依赖，这可能对整个系统的分层和复用产生负面影响。命令、观察者、中介者和职责链等模式都用于解决这个问题。

出少数例外情况，各个行为设计模式之间是互相补充和互相加强的关系。

原子操作（原语操作）：

内核或微核提供核外调用的过程或函数称为原语(primitive)。
原语是一段用机器指令编写的完成特定功能的程序,在执行过程中不允许中断。
在多进程（线程）的操作系统中不能被其它进程（线程）打断的操作就叫原子操作，文件的原子操作是指操作文件时的不能被打断的操作。
原子还有一层意思，当该次操作不能完成的时候，必须回到操作之前的状态，原子操作不可拆分。
所有原子操作是同步的，而且不可被外部中断（内中断可以，不过一般是致命错误处理）。
也就是说，原子操作是中断安全的。

结论

面向对象软件的生命周期分为几个阶段：原型阶段、扩展阶段、巩固阶段。

名词

抽象耦合：若类A维护一个指向抽象类B的引用，则称A抽象耦合于B。

相识关系：一个类指向另一个类，则这两个类之间有相识关系。

具体类：不含抽象操作的类，它可以实例化。

黑箱复用：一种基于对象组合的复用方式。这些被组合的对象不开放各自的内部细节，因此叫做“黑箱”。白箱复用反之。

耦合：软件构件之间互相依赖的程度。

委托：一种实现机制，即一个对象把发给它的请求转发/委托给另一个对象。而受委托的对象将代表原对象执行请求操作。

动态绑定：在运行时将一个请求与一个对象及其一个操作关联起来。C++中只有虚函数可以被动态绑定。

封装：其结构是将对象的表示和实现隐藏起来。在对象之外看不到其内部表示，也不能直接对其进行访问。操作是访问和修改对象表示的唯一途径。

框架（用例、外观）：一组相互协作的类，形成某类软件的一个可复用设计。矿建将设计划分一组抽象类，并定义他们各自的责任及相互之间的合作，以此来指导体系结构级的设计。开发者通过继承框架中的类和组合其实例来定制该框架以生成特定的应用。用例：用来描述系统中一个用户场景的一组对象集合，对象互相协作。

继承：一个实体是基于另一个实体定义的，子类继承父类的接口和实现。继承分接口继承和实现继承，接口继承：以一个或多个已有的接口为基础定义新的接口。实现继承：以一个或多已有实现为基础定义新的实现。

实例变量：定义部分对象表示的数据。C++中使用术语”数据成员“。

交互图：展示对象间请求流程的一种示意图。

接口：一个对象所有操作定义的型构的集合。接口刻划了一个对象可响应的请求的集合。

混入类：一种被设计为通过继承与其他类结合的类。混入类通常是抽象类。

对象(object) ：一个封装了数据及作用于这些数据的操作的运行实体。
对象组合(object composition)： 组装和组合一组对象以获得更复杂的行为。
对象图(object diagram ) ：描述运行时刻特定对象结构的示意图。
对象引用(object reference) ：用于标识另一对象的一个值。
操作( operation ) ：对象的数据仅能由其自身的操作来存取。对象受到请求时执行操作。在C++中,操作称为成员函数,而Smalltalk使用术语“方法”。
重定义(overriding)： 在一个子类中重定义(从父类继承下来的)操作。
参数化类型( parameterized type)： 一种含有未确定成分类型的类型。在使用时,将未确定类型处理成参数。在C++中,参数化类型称为模板( template )。
父类( parent class) ：被其他类继承的类。Smalltalk又称之为超类(superclass ), C++中又称之为基类(base class),有时又称为祖先类( ancestor class )。
多态( polymorphism ) ：在运行时刻接口匹配的对象能互相替换的能力。
私有继承( private inheritance ) ：在C++中,一种仅出于实现目的的继承。
协议( protocol ) ：接口概念的扩展,包含指明可允许的请求序列。
接收者(receiver ) ：一个请求的目标对象
请求( request) ：一个对象当受到其他对象的请求时执行相应的操作。通常请求又称为消息。
型构(signature)： 一个操作的型构定义了它的名称、参数和返回值。
子类(subclass ) ：继承了另一个类的类。在C++中,子类又称为派生类(derived class )。
子系统( subsystem ) ：一组相互协作的类形成的一个相对独立的部分,完成一定的功能。
子类型(subtype)： 如果一个类型的接口包含另一类型的接口,则前一类型称为后一类型的子类型。

超类型( supertype)： 为其他类型继承的父类型。
工具箱(tookit ) ：一组提供实用功能的类,但它们并不包含任何具体应用的设计。
类型(type)：一个特定接口的名称。
白箱复用( white-box reuse) ：一种基于类继承的复用。子类复用父类的接口和实现,但它也可能存取其父类的其他私有部分。

三种图示例：

假如一个uint32常量是一个指针变量P，其里面储存了另一个指针变量PP，PP指针变量里面储存了一个uint32的变量，请问怎么修改这个变量？

小结：

*(uint8_t * *)和(uint8_t *)：虽然都表示的是一个一级指针。

*(uint8_t * *)：表示的是一个一级指针变量，是被保存在一个二级指针指向地址里面的，是可以被修改的变量。

(uint8_t *)：是将一个变量或者常量强制转换为一个一级指针，如果是(uint8_t *)【变量】，也可以被修改，但如果是(uint8_t *)【常量】或者(uint8_t *)【表达式】，不可以被修改。

强制转换只是改变了类型，并不会改变强制转换对象是变量还是常量的事实。

分享一款自定义图床软件

在使用Typora写MD文件的时候，由于我们的截图都是保存在本地，所以复制MD文件到其他电脑或者需要把MD文件上传到网上，就会导致图片显示不出来。因为图片是在你的电脑里面，别人的电脑里面没有。

• www

chevereto是一款云端储存图片的软件。可以部署在自己的服务器上。Typora支持在粘贴图片的时候自动上传到图床，将本地图片地址转换url地址。

• 步骤

在Typora下载软件

• 配置PicGo软件

图床有很多种类可以配置，图片上的实例是我自己的图床，为了保险起见建议配置公共图床（我的服务器可能不稳定）。

• 效果

• chevereto免费版服务端 gitHub源码

https://github.com/Chevereto/Chevereto-Free

• shell命令

1
2
3
4
5
6
7
8

mount -t davfs http://127.0.0.1:50000 /mnt/seafdav/ # 挂载云盘到本地
docsify serve /mnt/seafdav/同步云盘/docsify # 前台启动
Ctrl + z # 挂起到后台
jobs # 查看后台被挂起的进程作业号
bg %1	# 后台继续运行
disown -h %1 # 忽略HUP信号，脱离终端
netstat -ntpl # 列出所有使用的端口
systemctl restart thingsboard # 重启服务

我们经常会碰到这样的问题，用 telnet/ssh 登录了远程的 Linux 服务器，运行了一些耗时较长的任务， 结果却由于网络的不稳定导致任务中途失败。如何让命令提交后不受本地关闭终端窗口/网络断开连接的干扰呢？下面举了一些例子， 您可以针对不同的场景选择不同的方式来处理这个问题。

nohup/setsid/&

场景：

如果只是临时有一个命令需要长时间运行，什么方法能最简便的保证它在后台稳定运行呢？

hangup 名称的来由

在 Unix 的早期版本中，每个终端都会通过 modem 和系统通讯。当用户 logout 时，modem 就会挂断（hang up）电话。 同理，当 modem 断开连接时，就会给终端发送 hangup 信号来通知其关闭所有子进程。

解决方法：

我们知道，当用户注销（logout）或者网络断开时，终端会收到 HUP（hangup）信号从而关闭其所有子进程。因此，我们的解决办法就有两种途径：要么让进程忽略 HUP 信号，要么让进程运行在新的会话里从而成为不属于此终端的子进程。

1. nohup

nohup 无疑是我们首先想到的办法。顾名思义，nohup 的用途就是让提交的命令忽略 hangup 信号。让我们先来看一下 nohup 的帮助信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

NOHUP(1)                        User Commands                        NOHUP(1)

NAME
       nohup - run a command immune to hangups, with output to a non-tty

SYNOPSIS
       nohup COMMAND [ARG]...
       nohup OPTION

DESCRIPTION
       Run COMMAND, ignoring hangup signals.

       --help display this help and exit

       --version
              output version information and exit 

可见，nohup 的使用是十分方便的，只需在要处理的命令前加上 nohup 即可，标准输出和标准错误缺省会被重定向到 nohup.out 文件中。一般我们可在结尾加上**”&”**来将命令同时放入后台运行，也可用">*filename* 2>&1"来更改缺省的重定向文件名。

nohup 示例

1
2
3
4
5
6
7
8

                
[root@pvcent107 ~]# nohup ping www.ibm.com &
[1] 3059
nohup: appending output to `nohup.out'
[root@pvcent107 ~]# ps -ef |grep 3059
root      3059   984  0 21:06 pts/3    00:00:00 ping www.ibm.com
root      3067   984  0 21:06 pts/3    00:00:00 grep 3059
[root@pvcent107 ~]#	 

2。setsid

nohup 无疑能通过忽略 HUP 信号来使我们的进程避免中途被中断，但如果我们换个角度思考，如果我们的进程不属于接受 HUP 信号的终端的子进程，那么自然也就不会受到 HUP 信号的影响了。setsid 就能帮助我们做到这一点。让我们先来看一下 setsid 的帮助信息：

1
2
3
4
5
6
7
8
9
10

SETSID(8)                 Linux Programmer’s Manual                 SETSID(8)

NAME
       setsid - run a program in a new session

SYNOPSIS
       setsid program [ arg ... ]

DESCRIPTION
       setsid runs a program in a new session. 

可见 setsid 的使用也是非常方便的，也只需在要处理的命令前加上 setsid 即可。

setsid 示例

1
2
3
4
5
6

                
[root@pvcent107 ~]# setsid ping www.ibm.com
[root@pvcent107 ~]# ps -ef |grep www.ibm.com
root     31094     1  0 07:28 ?        00:00:00 ping www.ibm.com
root     31102 29217  0 07:29 pts/4    00:00:00 grep www.ibm.com
[root@pvcent107 ~]#   

值得注意的是，上例中我们的进程 ID(PID)为31094，而它的父 ID（PPID）为1（即为 init 进程 ID），并不是当前终端的进程 ID。请将此例与nohup 例中的父 ID 做比较。

3。&

这里还有一个关于 subshell 的小技巧。我们知道，将一个或多个命名包含在“()”中就能让这些命令在子 shell 中运行中，从而扩展出很多有趣的功能，我们现在要讨论的就是其中之一。

当我们将”&”也放入“()”内之后，我们就会发现所提交的作业并不在作业列表中，也就是说，是无法通过jobs来查看的。让我们来看看为什么这样就能躲过 HUP 信号的影响吧。

subshell 示例

1
2
3
4
5
6

                
[root@pvcent107 ~]# (ping www.ibm.com &)
[root@pvcent107 ~]# ps -ef |grep www.ibm.com
root     16270     1  0 14:13 pts/4    00:00:00 ping www.ibm.com
root     16278 15362  0 14:13 pts/4    00:00:00 grep www.ibm.com
[root@pvcent107 ~]#    

从上例中可以看出，新提交的进程的父 ID（PPID）为1（init 进程的 PID），并不是当前终端的进程 ID。因此并不属于当前终端的子进程，从而也就不会受到当前终端的 HUP 信号的影响了。

disown

场景：

我们已经知道，如果事先在命令前加上 nohup 或者 setsid 就可以避免 HUP 信号的影响。但是如果我们未加任何处理就已经提交了命令，该如何补救才能让它避免 HUP 信号的影响呢？

解决方法：

这时想加 nohup 或者 setsid 已经为时已晚，只能通过作业调度和 disown 来解决这个问题了。让我们来看一下 disown 的帮助信息：

1
2
3
4
5
6
7
8
9
10
11

disown [-ar] [-h] [jobspec ...]
	Without options, each jobspec is  removed  from  the  table  of
	active  jobs.   If  the -h option is given, each jobspec is not
	removed from the table, but is marked so  that  SIGHUP  is  not
	sent  to the job if the shell receives a SIGHUP.  If no jobspec
	is present, and neither the -a nor the -r option  is  supplied,
	the  current  job  is  used.  If no jobspec is supplied, the -a
	option means to remove or mark all jobs; the -r option  without
	a  jobspec  argument  restricts operation to running jobs.  The
	return value is 0 unless a jobspec does  not  specify  a  valid
	job.

可以看出，我们可以用如下方式来达成我们的目的。

灵活运用 CTRL-z

在我们的日常工作中，我们可以用 CTRL-z 来将当前进程挂起到后台暂停运行，执行一些别的操作，然后再用 fg 来将挂起的进程重新放回前台（也可用 bg 来将挂起的进程放在后台）继续运行。这样我们就可以在一个终端内灵活切换运行多个任务，这一点在调试代码时尤为有用。因为将代码编辑器挂起到后台再重新放回时，光标定位仍然停留在上次挂起时的位置，避免了重新定位的麻烦。

• 用disown -h *jobspec* 来使某个作业忽略HUP信号。
• 用disown -ah 来使所有的作业都忽略HUP信号。
• 用disown -rh 来使正在运行的作业忽略HUP信号。

需要注意的是，当使用过 disown 之后，会将把目标作业从作业列表中移除，我们将不能再使用jobs来查看它，但是依然能够用ps -ef查找到它。

但是还有一个问题，这种方法的操作对象是作业，如果我们在运行命令时在结尾加了**”&”**来使它成为一个作业并在后台运行，那么就万事大吉了，我们可以通过jobs命令来得到所有作业的列表。但是如果并没有把当前命令作为作业来运行，如何才能得到它的作业号呢？答案就是用 CTRL-z（按住Ctrl键的同时按住z键）了！

CTRL-z 的用途就是将当前进程挂起（Suspend），然后我们就可以用jobs命令来查询它的作业号，再用bg *jobspec* 来将它放入后台并继续运行。需要注意的是，如果挂起会影响当前进程的运行结果，请慎用此方法。

disown 示例1（如果提交命令时已经用“&”将命令放入后台运行，则可以直接使用“disown”）

1
2
3
4
5
6
7
8
9
10

                
[root@pvcent107 build]# cp -r testLargeFile largeFile &
[1] 4825
[root@pvcent107 build]# jobs
[1]+  Running                 cp -i -r testLargeFile largeFile &
[root@pvcent107 build]# disown -h %1
[root@pvcent107 build]# ps -ef |grep largeFile
root      4825   968  1 09:46 pts/4    00:00:00 cp -i -r testLargeFile largeFile
root      4853   968  0 09:46 pts/4    00:00:00 grep largeFile
[root@pvcent107 build]# logout   

disown 示例2（如果提交命令时未使用“&”将命令放入后台运行，可使用 CTRL-z 和“bg”将其放入后台，再使用“disown”）

1
2
3
4
5
6
7
8
9
10
11
12
13

                
[root@pvcent107 build]# cp -r testLargeFile largeFile2

[1]+  Stopped                 cp -i -r testLargeFile largeFile2
[root@pvcent107 build]# bg %1
[1]+ cp -i -r testLargeFile largeFile2 &
[root@pvcent107 build]# jobs
[1]+  Running                 cp -i -r testLargeFile largeFile2 &
[root@pvcent107 build]# disown -h %1
[root@pvcent107 build]# ps -ef |grep largeFile2
root      5790  5577  1 10:04 pts/3    00:00:00 cp -i -r testLargeFile largeFile2
root      5824  5577  0 10:05 pts/3    00:00:00 grep largeFile2
[root@pvcent107 build]#   

screen

场景：

我们已经知道了如何让进程免受 HUP 信号的影响，但是如果有大量这种命令需要在稳定的后台里运行，如何避免对每条命令都做这样的操作呢？

解决方法：

此时最方便的方法就是 screen 了。简单的说，screen 提供了 ANSI/VT100 的终端模拟器，使它能够在一个真实终端下运行多个全屏的伪终端。screen 的参数很多，具有很强大的功能，我们在此仅介绍其常用功能以及简要分析一下为什么使用 screen 能够避免 HUP 信号的影响。我们先看一下 screen 的帮助信息：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

SCREEN(1)                                                           SCREEN(1)

NAME
       screen - screen manager with VT100/ANSI terminal emulation

SYNOPSIS
       screen [ -options ] [ cmd [ args ] ]
       screen -r [[pid.]tty[.host]]
       screen -r sessionowner/[[pid.]tty[.host]]

DESCRIPTION
       Screen  is  a  full-screen  window manager that multiplexes a physical
       terminal between several  processes  (typically  interactive  shells).
       Each  virtual  terminal provides the functions of a DEC VT100 terminal
       and, in addition, several control functions from the  ISO  6429  (ECMA
       48,  ANSI  X3.64)  and ISO 2022 standards (e.g. insert/delete line and
       support for multiple character sets).  There is a  scrollback  history
       buffer  for  each virtual terminal and a copy-and-paste mechanism that
       allows moving text regions between windows.	

使用 screen 很方便，有以下几个常用选项：

• 用screen -dmS *session name* 来建立一个处于断开模式下的会话（并指定其会话名）。
• 用screen -list 来列出所有会话。
• 用screen -r *session name* 来重新连接指定会话。
• 用快捷键CTRL-a d 来暂时断开当前会话。

screen 示例

1
2
3
4
5
6
7
8

                
[root@pvcent107 ~]# screen -dmS Urumchi
[root@pvcent107 ~]# screen -list
There is a screen on:
        12842.Urumchi   (Detached)
1 Socket in /tmp/screens/S-root.

[root@pvcent107 ~]# screen -r Urumchi	 

当我们用“-r”连接到 screen 会话后，我们就可以在这个伪终端里面为所欲为，再也不用担心 HUP 信号会对我们的进程造成影响，也不用给每个命令前都加上“nohup”或者“setsid”了。这是为什么呢？让我来看一下下面两个例子吧。

1. 未使用 screen 时新进程的进程树

1
2
3
4
5
6
7
8
9
10

                
[root@pvcent107 ~]# ping www.google.com &
[1] 9499
[root@pvcent107 ~]# pstree -H 9499
init─┬─Xvnc
     ├─acpid
     ├─atd
     ├─2*[sendmail]	
     ├─sshd─┬─sshd───bash───pstree
     │       └─sshd───bash───ping

我们可以看出，未使用 screen 时我们所处的 bash 是 sshd 的子进程，当 ssh 断开连接时，HUP 信号自然会影响到它下面的所有子进程（包括我们新建立的 ping 进程）。

2. 使用了 screen 后新进程的进程树

1
2
3
4
5
6
7
8
9

[root@pvcent107 ~]# screen -r Urumchi
[root@pvcent107 ~]# ping www.ibm.com &
[1] 9488
[root@pvcent107 ~]# pstree -H 9488
init─┬─Xvnc
     ├─acpid
     ├─atd
     ├─screen───bash───ping
     ├─2*[sendmail]	

而使用了 screen 后就不同了，此时 bash 是 screen 的子进程，而 screen 是 init（PID为1）的子进程。那么当 ssh 断开连接时，HUP 信号自然不会影响到 screen 下面的子进程了。

总结

现在几种方法已经介绍完毕，我们可以根据不同的场景来选择不同的方案。nohup/setsid 无疑是临时需要时最方便的方法，disown 能帮助我们来事后补救当前已经在运行了的作业，而 screen 则是在大批量操作时不二的选择了。

转载原文链接：https://www.cnblogs.com/york-hust/archive/2012/05/30/2525842.html