├── CMakeLists.txt ├── README.md └── src ├── CMakeLists.txt ├── 代理模式 └── proxy.cpp ├── 单例模式 ├── C++11 │ └── Singleton_C++11.cpp ├── 懒汉模式 │ └── Singleton_lh.cpp └── 饿汉模式 │ └── Singleton_eh.cpp ├── 外观模式Facade └── Facade.cpp ├── 工厂模式 └── Factory.cpp ├── 抽象工厂模式 └── AbstractFactory.cpp ├── 装饰器模式 └── Decorator.cpp ├── 观察者模式 └── Observer.cpp ├── 解释器模式 └── Interpreter.cpp ├── 访问者模式visitor └── Visitor.cpp ├── 迭代器模式 └── Iterator.cpp └── 适配器模式 ├── ClassAdapter.cpp └── ObjectAdapter.cpp /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.8.2) 2 | project(DesignModels) 3 | 4 | set(CMAKE_CXX_STANDARD 11) 5 | list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake_modules) 6 | set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin) 7 | #set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib) 8 | #####################dependenicecs########################## 9 | set(THIRD_PARTY_LIBS 10 | ) 11 | 12 | include_directories(${PROJECT_SOURCE_DIR}/include) 13 | ####################source and test######################### 14 | add_subdirectory(src) 15 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # DesignModels 2 | ## 设计模式C++实现 （参考开源中国-黑客画家-C++设计模式） 3 | 4 | ### 设计模式C++实现--Singleton模式 5 | 1、单例类只能有一个实例。 6 | 2、单例类必须自己创建自己的唯一实例。 7 | 3、单例类必须给所有其他对象提供这一实例。 8 | 9 | 意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 10 | 11 | 主要解决：一个全局使用的类频繁地创建与销毁。 12 | 13 | 何时使用：当您想控制实例数目，节省系统资源的时候。 14 | 15 | 如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。 16 | 17 | 关键代码：构造函数是私有的。 18 | 19 | 应用实例： 1、一个党只能有一个主席。 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。 20 | 21 | 优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。 22 | 23 | 缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。 24 | 25 | 使用场景： 1、要求生产唯一序列号。 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。 26 | 27 | 注意事项：getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。 28 | 29 | ### 设计模式C++实现--AbstractFactory模式 30 | 抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 31 | 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。 32 | 33 | 意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 34 | 35 | 主要解决：主要解决接口选择的问题。 36 | 37 | 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。 38 | 39 | 如何解决：在一个产品族里面，定义多个产品。 40 | 41 | 关键代码：在一个工厂里聚合多个同类产品。 42 | 43 | 应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OO 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。 44 | 45 | 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。 46 | 47 | 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。 48 | 49 | 使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。 50 | 51 | 注意事项：产品族难扩展，产品等级易扩展。 52 | 53 | ### 设计模式C++实现--Factory模式 54 | 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。 55 | 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 56 | 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。 57 | 58 | 主要解决：主要解决接口选择的问题。 59 | 60 | 何时使用：我们明确地计划不同条件下创建不同实例时。 61 | 62 | 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。 63 | 64 | 关键代码：创建过程在其子类执行。 65 | 66 | 应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。 67 | 68 | 优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。 69 | 70 | 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。 71 | 72 | 使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。 73 | 74 | 注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。 75 | 76 | ### 设计模式C++实现--Iterator模式 77 | 迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。 78 | 迭代器模式属于行为型模式。 79 | 意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。 80 | 81 | 主要解决：不同的方式来遍历整个整合对象。 82 | 83 | 何时使用：遍历一个聚合对象。 84 | 85 | 如何解决：把在元素之间游走的责任交给迭代器，而不是聚合对象。 86 | 87 | 关键代码：定义接口：First, Next,isEnd,CurItem,。 88 | 89 | 应用实例：JAVA 中的 iterator。 90 | 91 | 优点： 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。 92 | 93 | 缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。 94 | 95 | 使用场景： 1、访问一个聚合对象的内容而无须暴露它的内部表示。 2、需要为聚合对象提供多种遍历方式。 3、为遍历不同的聚合结构提供一个统一的接口。 96 | 97 | 注意事项：迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。 98 | 99 | ### 设计模式C++实现--Facade外观模式 100 | 外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。 101 | 102 | 意图：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 103 | 104 | 主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。 105 | 106 | 何时使用： 1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个"接待员"即可。 2、定义系统的入口。 107 | 108 | 如何解决：客户端不与系统耦合，外观类与系统耦合。 109 | 110 | 关键代码：在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。 111 | 112 | 应用实例： 1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。 2、JAVA 的三层开发模式。 113 | 114 | 优点： 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。 115 | 116 | 缺点：不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。 117 | 118 | 使用场景： 1、为复杂的模块或子系统提供外界访问的模块。 2、子系统相对独立。 3、预防低水平人员带来的风险。 119 | 120 | 注意事项：在层次化结构中，可以使用外观模式定义系统中每一层的入口。 121 | 122 | ### 设计模式C++实现--Observer观察者模式 123 | 当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。 124 | 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。 125 | 126 | 127 | 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。 128 | 129 | 何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。 130 | 131 | 如何解决：使用面向对象技术，可以将这种依赖关系弱化。 132 | 133 | 关键代码：在抽象类里有一个 ArrayList 存放观察者们。 134 | 135 | 应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。 136 | 137 | 优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。 138 | 139 | 缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。 140 | 141 | 使用场景： 142 | 143 | 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使它们可以各自独立地改变和复用。 144 | 一个对象的改变将导致其他一个或多个对象也发生改变，而不知道具体有多少对象将发生改变，可以降低对象之间的耦合度。 145 | 一个对象必须通知其他对象，而并不知道这些对象是谁。 146 | 需要在系统中创建一个触发链，A对象的行为将影响B对象，B对象的行为将影响C对象……，可以使用观察者模式创建一种链式触发机制。 147 | 注意事项： 1、JAVA 中已经有了对观察者模式的支持类。 2、避免循环引用。 3、如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。 148 | 149 | ### 设计模式C++实现--Interpreter解释器模式 150 | 解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。 151 | 适用性： 152 | 在以下情况下可以考虑使用解释器模式： 153 | 154 | (1) 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 155 | 156 | (2) 一些重复出现的问题可以用一种简单的语言来进行表达。 157 | 158 | (3) 一个语言的文法较为简单。 159 | 160 | (4) 执行效率不是关键问题。（注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。） 161 | 162 | 优缺点： 163 | 优点： 164 | (1) 易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。 165 | 166 | (2) 每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。 167 | 168 | (3) 实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。 169 | 170 | (4) 增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。 171 | 172 | 缺点： 173 | (1) 对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。 174 | 175 | (2) 执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。 176 | 177 | 总论： 178 | 尽量不要在重要模块中使用解释器模式，因为维护困难。在项目中，可以使用脚本语言来代替解释器模式。 179 | 180 | ### 设计模式C++实现--Decorator装饰器模式 181 | 182 | 装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。 183 | 184 | 意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。 185 | 186 | 主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。 187 | 188 | 何时使用：在不想增加很多子类的情况下扩展类。 189 | 190 | 如何解决：将具体功能职责划分，同时继承装饰者模式。 191 | 192 | 关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。 193 | 194 | 应用实例： 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。 195 | 196 | 优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。 197 | 198 | 缺点：多层装饰比较复杂。 199 | 200 | 使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。 201 | 202 | 注意事项：可代替继承。 203 | 204 | ### 设计模式C++实现--visitor访问者模式 205 | 206 | 在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。 207 | 208 | 意图：主要将数据结构与数据操作分离。 209 | 210 | 主要解决：稳定的数据结构和易变的操作耦合问题。 211 | 212 | 何时使用：需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，使用访问者模式将这些封装到类中。 213 | 214 | 如何解决：在被访问的类里面加一个对外提供接待访问者的接口。 215 | 216 | 关键代码：在数据基础类里面有一个方法接受访问者，将自身引用传入访问者。 217 | 218 | 应用实例：您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。 219 | 220 | 优点： 1、符合单一职责原则。 2、优秀的扩展性。 3、灵活性。 221 | 222 | 缺点： 1、具体元素对访问者公布细节，违反了迪米特原则。 2、具体元素变更比较困难。 3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。 223 | 224 | 使用场景： 1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。 2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。 225 | 226 | 注意事项：访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。 227 | 228 | ### 设计模式C++实现--Adapter适配器模式 229 | 230 | 适配器就是一种适配中间件，它存在于不匹配的二者之间，用于连接两者，将不匹配变得匹配，简单的理解就是平常所见的转接头、转换器之类的存在。 231 | 232 | 适配器的模式有3种：类适配器、对象适配器、接口适配器 233 | 234 | C++11中的std::bind()就是一种适配器模式，它接受一个仿函数，将其与参数绑定，返回一个新的仿函数 235 | 236 | 1、类适配器模式： 237 | 原理： 通过继承来实现适配器的功能。 238 | 3个角色： Target->客户需要的类接口,需要Request方法 Adaptee->需要适配的类，其中没有Request方法 Adapter->适配器，实现了Target接口，继承Adaptee 239 | Adaptee类没有Request方法，而客户期待这个方法。为了使客户能够使用Adaptee类，提供一个中间环节，即类Adapter类，Adapter类实现了Target接口，并继承自Adaptee，Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。 240 | 241 | 2、对象适配器模式： 242 | 原理：通过组合来实现适配器的功能。 243 | 当我们要访问的接口A中没有我们想要的方法，却在另一个接口B中找到了合适的方法，我们又不能改变接口A，在这种情况下，我们定义一个适配器p来进行中转，这个适配器p要实现我们访问的接口A,这样我们就能继续访问当前接口A中的方法，然后在适配器p中 244 | 定义私有变量C(对象，B接口指向变量名)，再定义一个带参数的构造器为对象C赋值，再在A接口的方法实现中使用对象C调用其来源于B接口的方法。 245 | 客户端需要调用Request方法，而Adaptee没有该方法，为了使客户端能够使用Adaptee类，需要提供一个包装（Wrapper）类Adapter。这个包装类包装了一个Adaptee的实例，从而将客户端与Adaptee衔接起来。由于Adapter与Adaptee是委派关系，这决定了这个适配器模式是对象的。 246 | 247 | ### 设计模式C++实现--代理模式 248 | 249 | 意图：为其他对象提供一种代理以控制对这个对象的访问。 250 | 251 | 代理模式的定义：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。 252 | 尽管Decorator（装饰器模式）的实现部分与代理相似，但Decorator的目的不一样。Decorator为对象添加一个或多个功能，而代理则控制对对象的访问。 253 | java中的Spring AOP,这是个典型的代理模式 254 | 255 | 应用及优点： 256 | 职责清晰（实现好内部结构就可以，具体客户要求由代理进行分化） 257 | 高扩展性（具体主题角色随时变化，只要他实现了接口，无论如何都逃不出代理的手掌，所以代理无论如何都是可以使用的） 258 | 259 | 适用性： 260 | 在需要用比较通用和复杂的对象指针代替简单的的指针的时候，使用代理模式。 261 | 262 | 角色定义： 263 | 264 | Subject抽象主体角色，抽象类或者接口，是一个普通的业务类型定义 265 | 266 | RealSubject具体主体角色，也叫作被委托角色，被代理角色。业务逻辑的具体执行者 267 | 268 | Proxy代理主体角色，委托类，代理类。 269 | -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | ###################单例模式################################ 2 | add_executable(Singleton_eh 单例模式/饿汉模式/Singleton_eh.cpp) 3 | target_link_libraries(Singleton_eh pthread) 4 | add_executable(Singleton_lh 单例模式/懒汉模式/Singleton_lh.cpp) 5 | target_link_libraries(Singleton_lh pthread) 6 | add_executable(Singleton_C++11 单例模式/C++11/Singleton_C++11.cpp) 7 | target_link_libraries(Singleton_C++11 pthread) 8 | 9 | 10 | ###################抽象工厂模式################################ 11 | add_executable(AbstractFactory 抽象工厂模式/AbstractFactory.cpp) 12 | 13 | ######################工厂模式################################ 14 | add_executable(Factory 工厂模式/Factory.cpp) 15 | 16 | ######################迭代器模式################################ 17 | add_executable(Iterator 迭代器模式/Iterator.cpp) 18 | 19 | ######################外观模式################################ 20 | add_executable(Facade 外观模式Facade/Facade.cpp) 21 | 22 | ######################观察者模式################################ 23 | add_executable(Observer 观察者模式/Observer.cpp) 24 | 25 | ######################解释器模式################################ 26 | add_executable(Interpreter 解释器模式/Interpreter.cpp) 27 | 28 | ######################装饰器模式################################ 29 | add_executable(Decorator 装饰器模式/Decorator.cpp) 30 | 31 | ######################访问者模式################################ 32 | add_executable(Visitor 访问者模式visitor/Visitor.cpp) 33 | 34 | #######################适配器模式############################### 35 | add_executable(ClassAdapter 适配器模式/ClassAdapter.cpp) 36 | add_executable(ObjectAdapter 适配器模式/ObjectAdapter.cpp) 37 | 38 | #######################代理模式############################## 39 | add_executable(Proxy 代理模式/proxy.cpp) -------------------------------------------------------------------------------- /src/代理模式/proxy.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-7-17. 3 | // 4 | #include 5 | using namespace std; 6 | /* 7 | * 代理模式 8 | * 例子： 假若你有一个工厂开始是生产手机的，但是它现在不想自己生产了，它把自己的东西交给了一家代工厂富士康去生产，那么便有了下面的代码去构建。 9 | * Subject抽象主体角色，抽象类或者接口，是一个普通的业务类型定义 10 | * RealSubject具体主体角色，也叫作被委托角色，被代理角色。业务逻辑的具体执行者 11 | * Proxy代理主体角色，委托类，代理类。 12 | */ 13 | //Subject接口 统一的抽象接口 14 | class Subject{ 15 | public: 16 | virtual void Request() = 0; //具体代理的任务接口 17 | }; 18 | 19 | //Subject接口实现类 20 | class ConcreteSubject : public Subject { 21 | public: 22 | void Request() override { 23 | cout<<"ConcreteSubject"<subject_ = subject; 33 | } 34 | 35 | void Request() override { 36 | subject_->Request(); //代理类控制被代理类的访问 37 | } 38 | 39 | private: 40 | Subject* subject_; //代理类拿到被代理类的对象 41 | }; 42 | 43 | int main() 44 | { 45 | Subject* subject = new ConcreteSubject(); 46 | Proxy* proxy = new Proxy(subject); 47 | proxy->Request(); //利用代理对象来间接访问ConcreteSubject对象 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /src/单例模式/C++11/Singleton_C++11.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-22. 3 | // 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | /* 11 | * Singleton 12 | * 用C++11 call_once实现Singleton 13 | */ 14 | 15 | class Singleton{ 16 | public: 17 | static Singleton* m_instance; 18 | static Singleton* getInstance(); 19 | 20 | private: 21 | 22 | Singleton(){cout<<"Construct Class Singleton!!!"< 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace std; 11 | 12 | /* 13 | * Singleton 14 | * 懒汉模式：单例只在第一次使用时初始化一次 15 | * 16 | * 问题： 17 | * (1) 线程不安全 (多个线程同时getInstance，同时判断m_data是否为空，导致多次初始化实例) 18 | * (2) 析构函数没有执行(无法解决) 19 | */ 20 | 21 | class Singleton{ 22 | public: 23 | /* 24 | * 双重检查锁定模式(DCLP) 25 | * 问题:因为c++编译器在编译过程中会对代码进行优化， 26 | * 所以实际的代码执行顺序可能被打乱，另外因为CPU有一级二级缓存(cache), 27 | * CPU的计算结果并不是及时更新到内存的,所以在多线程环境， 28 | * 不同线程间共享内存数据存在可见性问题，从而导致使用DCLP也存在风险。 29 | */ 30 | static Singleton* getInstance() 31 | { 32 | if(m_data == nullptr) //第一次判断m_data是否为空，线程不安全，可能多个线程同时判空 33 | { 34 | std::lock_guard lock(mu); 35 | if(m_data == nullptr) //第二次判空，加互斥锁，线程安全，保证只有一个线程来初始化Singleton 36 | { 37 | m_data = new Singleton(); 38 | } 39 | return m_data; 40 | } 41 | else 42 | { 43 | return m_data; 44 | } 45 | } 46 | 47 | /* 48 | * 借助（内存栅栏技术 memory fence）来解决双重检查锁定模式的风险 49 | * 利用C++11提供的atomic_thread_fence实现内存栅栏memory fence 50 | * 在c++11中，可以获取(acquire/consume)和释放(release)内存栅栏 51 | * 使用c++11中的atomic类型来包装m_instance指针，这使得对m_instance的操作是一个原子操作。 52 | */ 53 | 54 | 55 | private: 56 | std::atomic Singleton::m_instance; 57 | 58 | static Singleton* m_data; //类内声明一个指向Singleton的静态指针，由getInstance在第一次调用时，初始化该指针 59 | 60 | static std::mutex mu; //互斥量，保障getInstance线程安全 61 | 62 | Singleton(){cout<<"Construct Class Singleton!!!"<> threadPool; 82 | for(int i=0;i<100;i++) 83 | { 84 | threadPool.push_back(std::make_shared(&task)); 85 | } 86 | while(1) 87 | { 88 | this_thread::sleep_for(std::chrono::milliseconds(100)); 89 | } 90 | return 0; 91 | } 92 | -------------------------------------------------------------------------------- /src/单例模式/饿汉模式/Singleton_eh.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-21. 3 | // 4 | #include 5 | using namespace std; 6 | 7 | /* 8 | * Singleton 9 | * 饿汉模式：是指单例程序在运行时，被立即执行初始化 10 | * 问题：静态成员的初始化顺序是无法保障（假如两个单例，其中一个是另一个的成员，成员单例初始化发生在外部单例初始化工作之后，程序就会崩溃） 11 | */ 12 | class Singleton { 13 | public: 14 | static Singleton& getInstance() //饿汉模式，单例运行时已经初始化了m_data 每次返回m_data的引用 15 | { 16 | return m_data; 17 | } 18 | 19 | private: 20 | 21 | static Singleton m_data; //静态成员，类内声明 22 | 23 | Singleton(){cout<<"Construct Class Singleton!!!"< 5 | using namespace std; 6 | /* 7 | * 外观模式Facade 8 | */ 9 | //写出一个编译器工作的几个阶段 10 | class Scanner { 11 | public: 12 | void Scan(){cout<<"词法分析"< 5 | #include 6 | using namespace std; 7 | 8 | /* 9 | * 1. 创建接口 10 | */ 11 | class Shape { 12 | public: 13 | virtual ~Shape(){cout<<"Destruct Class Shape"< getShape(const std::string& shapeType) 50 | { 51 | if(shapeType=="Circle") 52 | { 53 | return std::make_shared(); 54 | } 55 | else if(shapeType=="Square") 56 | { 57 | return std::make_shared(); 58 | } 59 | else if(shapeType=="Rectangle") 60 | { 61 | return std::make_shared(); 62 | } 63 | return nullptr; 64 | } 65 | }; 66 | 67 | 68 | /* 69 | * 使用该工厂，通过传递类型信息来获取实体类的对象 70 | */ 71 | int main() 72 | { 73 | ShapeFactory factory; 74 | auto shape1 = factory.getShape("Circle"); 75 | shape1->draw(); 76 | auto shape2 = factory.getShape("Square"); 77 | shape2->draw(); 78 | auto shape3 = factory.getShape("Rectangle"); 79 | shape3->draw(); 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /src/抽象工厂模式/AbstractFactory.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-22. 3 | // 4 | #include 5 | using namespace std; 6 | 7 | /* 8 | * 1. 定义产品接口 9 | */ 10 | //产品A接口 11 | class AbstractProductA { 12 | public: 13 | virtual void use()=0; 14 | }; 15 | //产品B接口 16 | class AbstractProductB { 17 | public: 18 | virtual void eat()=0; 19 | }; 20 | 21 | /* 22 | * 2. 定义抽象工厂 23 | */ 24 | class AbstractFactory { 25 | public: 26 | virtual AbstractProductA* CreateProductA()=0; //创建产品A 接口 27 | virtual AbstractProductB* CreateProductB()=0; //创建产品B 接口 28 | }; 29 | 30 | /* 31 | * 3. 实现产品接口 32 | */ 33 | //实现产品A 34 | class ProductA1 : public AbstractProductA { 35 | public: 36 | void use() override 37 | { 38 | cout<<"ProductA1 use()"<CreateProductA(); 102 | AbstractProductA* productA2 = abstractFactory2->CreateProductA(); 103 | productA1->use(); 104 | productA2->use(); 105 | AbstractProductB* productB1 = abstractFactory1->CreateProductB(); 106 | AbstractProductB* productB2 = abstractFactory1->CreateProductB(); 107 | productB1->eat(); 108 | productB2->eat(); 109 | return 0; 110 | } 111 | -------------------------------------------------------------------------------- /src/装饰器模式/Decorator.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-22. 3 | // 4 | #include 5 | using namespace std; 6 | /* 7 | * Decorator 8 | * 装饰器模式 9 | */ 10 | 11 | /* 12 | * 创建一个接口 13 | */ 14 | class Shape { 15 | public: 16 | virtual ~Shape(){} 17 | virtual void draw()=0; 18 | }; 19 | 20 | 21 | /* 22 | * 实现接口的实体类 23 | */ 24 | class Circle : public Shape { 25 | public: 26 | void draw() override { 27 | cout<<"Draw a Circle"<draw(); 48 | } 49 | 50 | protected: 51 | Shape* shape_; 52 | }; 53 | 54 | /* 55 | * 创建扩展了 ShapeDecorator 类的实体装饰类。 56 | */ 57 | class RedShapeDecorator : public ShapeDecorator { 58 | public: 59 | explicit RedShapeDecorator(Shape* shape):ShapeDecorator(shape){} 60 | 61 | void draw() override { 62 | std::cout << "" << std::endl; 63 | shape_->draw(); 64 | std::cout << "" << std::endl; 65 | } 66 | }; 67 | 68 | class GreeShapeDecorator : public ShapeDecorator { 69 | public: 70 | explicit GreeShapeDecorator(Shape* shape):ShapeDecorator(shape){} 71 | 72 | void draw() override { 73 | std::cout << ""<< std::endl; 74 | shape_->draw(); 75 | std::cout << "" << std::endl; 76 | } 77 | }; 78 | 79 | 80 | /* 81 | * 使用 RedShapeDecorator 和 GreenShapeDecorator来装饰 Shape 对象。 82 | */ 83 | int main() 84 | { 85 | Shape* circle = new Circle(); 86 | Shape* rectangle = new Rectangle(); 87 | circle->draw(); 88 | rectangle->draw(); 89 | Shape* redDecorator = new RedShapeDecorator(circle); 90 | Shape* greenDecorator = new GreeShapeDecorator(circle); 91 | redDecorator->draw(); 92 | greenDecorator->draw(); 93 | return 0; 94 | } 95 | -------------------------------------------------------------------------------- /src/观察者模式/Observer.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-22. 3 | // 4 | #include 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | /* 10 | * Observer 11 | * 观察者模式 12 | * 关键代码：在抽象类里有一个 ArrayList存放观察者们。 13 | */ 14 | 15 | /* 16 | * 创建Observer接口 17 | */ 18 | class Subject; 19 | class Observer { 20 | protected: 21 | Subject* subject_; //被观察者 22 | 23 | public: 24 | Observer(Subject* subject):subject_(subject){} 25 | virtual ~Observer(){} 26 | virtual void update()=0; 27 | }; 28 | 29 | /* 30 | * 创建Subject类 31 | * 被观察者 32 | */ 33 | class Subject { 34 | private: 35 | list observers_; //观察者 36 | int state_; //状态 37 | 38 | public: 39 | //获取状态 40 | int GetState() 41 | { 42 | return state_; 43 | } 44 | 45 | //设置状态 46 | void SetState(int state) 47 | { 48 | state_ = state; 49 | NotifyAllObservers(); 50 | } 51 | 52 | //绑定观察者 53 | void Attach(Observer* observer) 54 | { 55 | observers_.push_back(observer); 56 | } 57 | 58 | //通知所有观察者 59 | void NotifyAllObservers() 60 | { 61 | for_each(observers_.begin(),observers_.end(), 62 | [](Observer* x) 63 | { 64 | x->update(); 65 | }); 66 | } 67 | }; 68 | 69 | /* 70 | * 创建实体观察者类，实现Observer接口 71 | */ 72 | //观察者1 73 | class BinaryObserver : public Observer { 74 | public: 75 | BinaryObserver(Subject* subject):Observer(subject) 76 | { 77 | subject_->Attach(this); //将该观察者绑定到被观察者上 78 | } 79 | void update() override { 80 | cout<<"Binary String:"<GetState()<Attach(this); //将该观察者绑定到被观察者上 89 | } 90 | 91 | public: 92 | void update() override { 93 | cout<<"Octal String:"<GetState()<Attach(this); //将该观察者绑定到被观察者上 102 | } 103 | 104 | void update() override { 105 | cout<<"Hex String:"<GetState()<SetState(1); 123 | subject->SetState(10); 124 | 125 | return 0; 126 | } 127 | -------------------------------------------------------------------------------- /src/解释器模式/Interpreter.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-22. 3 | // 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | /* 10 | * Interpreter 11 | * 解释器模式 12 | */ 13 | /* 14 | * 创建上下文context 15 | */ 16 | class Context { 17 | private: 18 | map valueMap_; 19 | 20 | public: 21 | int getValue(const string& key) 22 | { 23 | return valueMap_[key]; 24 | } 25 | 26 | void addValue(const string& key, int value) 27 | { 28 | valueMap_.insert(make_pair(key,value)); 29 | } 30 | }; 31 | 32 | /* 33 | * 创建抽象表达式接口 34 | */ 35 | class AbstractExpression { 36 | public: 37 | virtual ~AbstractExpression(){} 38 | virtual int interpreter(Context &context)=0; 39 | }; 40 | 41 | /* 42 | * 创建两种非终结表达式 43 | */ 44 | class AddNontermialExpression : public AbstractExpression { 45 | private: 46 | AbstractExpression* left_; 47 | AbstractExpression* right_; 48 | 49 | public: 50 | AddNontermialExpression(AbstractExpression* left, AbstractExpression* right) 51 | :left_(left),right_(right) 52 | {} 53 | 54 | int interpreter(Context &context) override { 55 | return left_->interpreter(context) + right_->interpreter(context); 56 | } 57 | 58 | }; 59 | 60 | class SubNontermialExpression : public AbstractExpression { 61 | private: 62 | AbstractExpression* left_; 63 | AbstractExpression* right_; 64 | 65 | public: 66 | SubNontermialExpression(AbstractExpression* left, AbstractExpression* right) 67 | :left_(left),right_(right) 68 | {} 69 | 70 | int interpreter(Context &context) override { 71 | return left_->interpreter(context) - right_->interpreter(context); 72 | } 73 | }; 74 | 75 | /* 76 | * 创建终结表达式 77 | */ 78 | class TerminalExpression : public AbstractExpression { 79 | private: 80 | int i_; //终结符不能再切割 81 | 82 | public: 83 | TerminalExpression(int i):i_(i){} 84 | 85 | int interpreter(Context &context) override { 86 | return i_; 87 | } 88 | }; 89 | 90 | int main() 91 | { 92 | Context context; 93 | context.addValue("a",1); 94 | context.addValue("b",2); 95 | context.addValue("c",3); 96 | AbstractExpression* sub_left = new TerminalExpression(context.getValue("a")); 97 | AbstractExpression* sub_right= new TerminalExpression(context.getValue("b")); 98 | AbstractExpression* subvalue = new SubNontermialExpression(sub_left,sub_right); 99 | cout<<"subvalue = "<interpreter(context)<accept(visitor); 108 | }); 109 | visitor->visit(this); 110 | } 111 | }; 112 | 113 | 114 | 115 | /* 116 | * 创建实现访问者接口的实体类 117 | */ 118 | class ComputerPartDisplayVisitor : public ComputerPartVisitor { 119 | public: 120 | void visit(Computer *computer) override { 121 | cout<<"display :"<getName()<getName()<getName()<getName()<getName()<getName()<getName()<getName()<accept(displayVisitor); 167 | computer->accept(outputVisitor); 168 | return 0; 169 | } 170 | -------------------------------------------------------------------------------- /src/迭代器模式/Iterator.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-6-22. 3 | // 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | /* 9 | * 1. 创建接口 10 | */ 11 | //迭代器接口 12 | template 13 | class Iterator { 14 | public: 15 | virtual ~Iterator(){cout<<"Destruct Class Iterator"< 25 | class Container { 26 | public: 27 | Container() = default; 28 | virtual ~Container(){} 29 | 30 | virtual int getSize()=0; 31 | virtual void pushItem(const Item &item)=0; 32 | virtual Item& operator[](int index)=0; 33 | virtual Iterator *getIterator()=0; 34 | }; 35 | /* 36 | * 2. 创建实现Iterator的实体类 37 | */ 38 | template 39 | class ConcreteIterator : public Iterator { 40 | public: 41 | //构造函数 42 | ConcreteIterator(Container* container):container_(container),curIndex_(0) 43 | {} 44 | 45 | void First() override { 46 | curIndex_ = 0; 47 | } 48 | 49 | void Next() override { 50 | ++curIndex_; 51 | } 52 | 53 | bool isEnd() override { 54 | return curIndex_>=container_->getSize(); 55 | } 56 | 57 | Item *CurItem() override { 58 | if(curIndex_getSize()) 59 | { 60 | return &(*container_)[curIndex_]; 61 | } 62 | return nullptr; 63 | } 64 | 65 | 66 | private: 67 | Container* container_; 68 | int curIndex_; 69 | }; 70 | 71 | /* 72 | * 3. 创建实现了 Container 接口的实体类 73 | */ 74 | template 75 | class ConcreteContainer : public Container { 76 | public: 77 | virtual ~ConcreteContainer() 78 | { 79 | if(iterator_) 80 | { 81 | delete(iterator_); 82 | } 83 | } 84 | 85 | int getSize() override { 86 | return data_.size(); 87 | } 88 | 89 | void pushItem(const Item &item) override { 90 | data_.push_back(item); 91 | } 92 | 93 | Item &operator[](int index) override { 94 | return data_[index]; 95 | } 96 | 97 | //获取迭代器 98 | Iterator *getIterator() override { 99 | if(iterator_) 100 | { 101 | return iterator_; 102 | } 103 | else 104 | { 105 | return iterator_ = new ConcreteIterator(this); 106 | } 107 | } 108 | 109 | 110 | private: 111 | std::vector data_; 112 | Iterator* iterator_{nullptr}; 113 | }; 114 | 115 | 116 | 117 | /* 118 | * 验证迭代器工作 119 | */ 120 | int main() 121 | { 122 | Container* container = new ConcreteContainer(); 123 | container->pushItem(1); 124 | container->pushItem(2); 125 | container->pushItem(3); 126 | container->pushItem(4); 127 | container->pushItem(5); 128 | 129 | Iterator * iterator = container->getIterator(); 130 | for(iterator->First(); !iterator->isEnd(); iterator->Next()) 131 | { 132 | cout<<*(iterator->CurItem())< 5 | using namespace std; 6 | /* 7 | * 类适配器 8 | * 以 PS2 转 USB 转接器（适配器）为例 9 | */ 10 | 11 | //PS2接口 12 | class PS2{ 13 | public: 14 | virtual void isPS2()=0; 15 | }; 16 | 17 | //USB接口 18 | class USB{ 19 | public: 20 | virtual void isUSB()=0; 21 | }; 22 | //USB实现类 23 | class USBer : public USB 24 | { 25 | public: 26 | void isUSB() override { 27 | cout<<"This is a USB!"<SpecificRequest(); 79 | cout<<"-------------------"<isPS2(); 87 | 88 | //类模式Adapter 89 | Target* pTarget = new Adapter2(); 90 | pTarget->Request(); 91 | return 0; 92 | } 93 | -------------------------------------------------------------------------------- /src/适配器模式/ObjectAdapter.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by chijinxin on 18-7-17. 3 | // 4 | #include 5 | using namespace std; 6 | /* 7 | * 对象适配器 8 | * 1. 以PS2转USB转化器（适配器）为例 9 | */ 10 | //PS2接口 11 | class PS2{ 12 | public: 13 | virtual ~PS2(){} 14 | virtual void isPS2() = 0; 15 | }; 16 | //USB接口 17 | class USB{ 18 | public: 19 | virtual void idUSB() = 0 ; 20 | }; 21 | //USB实现 22 | class USBer : public USB { 23 | public: 24 | void idUSB() override { 25 | cout<<"This is a USB"<usb = usb; 38 | } 39 | 40 | void isPS2() override { 41 | usb->idUSB(); 42 | } 43 | }; 44 | 45 | /* 46 | * 例2 对象适配器模式 47 | * 角色：Target Adaptee Adapter 48 | * 客户端需要调用Request方法，而Adaptee类中没有该方法，为了使客户端能够使用Adaptee类 49 | * 需要提供一个包装（Wrapper）类Adapter，这个包装类包装了一个Adaptee的实例，从而将客户端 50 | * 与Adaptee衔接了起来。由于Adapter与Adaptee是委派关系 51 | */ 52 | //Target接口 53 | class Target{ 54 | public: 55 | virtual void Request()=0; 56 | }; 57 | 58 | //Adaptee类 59 | class Adaptee{ 60 | public: 61 | void SpecificRequest() 62 | { 63 | cout<<"Called SpecificRequest()"<adaptee_ = a; 75 | } 76 | 77 | void Request() override { 78 | adaptee_->SpecificRequest(); 79 | } 80 | }; 81 | 82 | 83 | int main() 84 | { 85 | USB* usb = new USBer(); 86 | PS2* p = new Adapter(usb); 87 | p->isPS2(); 88 | 89 | Adaptee* aa = new Adaptee(); 90 | Target *t = new Adapter2(aa); 91 | t->Request(); 92 | return 0; 93 | } 94 | --------------------------------------------------------------------------------