c_shell_python的博客

设计模式起源 GOF首次在书中提到设计模式的概念，他们所提出的设计模式原则主要是针对接口编程而不是对实现编程，优先使用对象的组合而不是继承。 学习设计模式的好处 设计模式经过了长时间的发展，是一套被反复使用的代码设计经验的总结。它们不仅提供了软件开发时面临的一些问题的解决方法，还能强化对面向对象编程和对接口编程的掌握理解，使得代码有更高的重用性和扩展性。 设计模式入口： 创建型模式 工厂方法模式 抽象工厂模式 单例模式 建造者模式 原型模式 结构型模式： 适配器模式 桥接模式.

中介者模式 定义：采用一个中介对象来封装一系列的对象交互。 优点：使得各个对象不需要显式的相互引用，达到解耦的效果。 属于行为型模式 栗子场景：买房和卖房都担心被骗，然后通过房产中介做交互 代码 #include <iostream> #include <string> using namespace std; class HousePerson; class BuyHousePerson; class SellHousePerson; //抽象中介类 class

装饰模式 定义：动态的给一个对象添加一些额外的职责 优点：对于增加功能而言，装饰模式比生产子类更加灵活。 属于结构型模式 代码： #include <iostream> #include <vector> #include <iostream> using namespace std; class Component{ public: virtual ~Component(){} virtual void add()=0; }; class Conc

单例模式 定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。 单例可以分为饿汉单例和懒汉单例 饿汉式：类定义的时候就去实例化 优点：以空间换时间，不用担心多线程同步的问题 缺点：如果没有被使用，会浪费内存空间 懒汉式:直到第一次使用时才实例化对象 优点：以时间换空间 缺点：需要考虑多线程同步的问题 代码： #include <iostream> #include <mutex> using namespace std; /* ...

工厂方法模式定义 定义一个用于创建对象的接口，让子类决定实例化哪一个类。核心结构分别是抽象工厂以及具体工厂，抽象产品以及具体产品。 #include <iostream> using namespace std; //抽象产品 class IWine { public: virtual ~IWine(){} virtual void createWine() = 0; }; //抽象工厂类 class IFactory { public: virtual ~IFactory()

备忘录模式 定义：捕获一个对象的内部状态，并在该对象之外保存这个状态。以后就可以将该对象恢复到之前被保存的状态。 场景栗子：以前特别喜欢玩s11Pk版，有时候玩了一段时间，发现进展和预想的不一样，上将军邢道荣被敌方抓了，但又不想重新开始，于是重新读档，回到之前的状态，继续玩。 代码： #include <iostream> #include <vector> using namespace std; class San11PkStorage; class San11PkS

代理模式 #include <iostream> using namespace std; //抽象工厂 class IFactory { public: virtual ~IFactory(){} virtual void createProduct()=0; }; //苹果AirPods耳机工厂 class AppleAirpodsFactory:public IFactory { public: void create

建造者模式 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示 属于创建型模式 代码： #include <iostream> #include <vector> #include <iostream> using namespace std; //电脑产品 class Computer { public: void addPart(string p) { m_vecParts.push_back(p); } void

迭代器模式 定义：提供一种方法顺序访问一个集合对象中的元素，但是又不暴露该对象的内部显示 这里采用了类模板来定义类，强化对模板的运用。 代码： #include <iostream> #include <list> #include <vector> using namespace std; //抽象迭代器类 template<typename T> class Iterator { public: virtual T firstItem()

职责链模式 定义：使得多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系，将这个对象连成一条链，并沿着该链传递该请求，直到有一个对象处理它为止。 属于行为型模式。 代码： #include <iostream> using namespace std; class Handle{ public: void setHandle(Handle *h) { m_handle = h; } virtual void handleRequest(int scor

命令模式 定义：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。 场景栗子：通信兵接收到司令官的命令，将命令发送给军队。 代码 #include<iostream> #include <list> using namespace std; class Signalman; class Action; class Command { public: Command(Action *action) {

模板方法属于属于行为型模式 定义：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。 优点：使得子类可以不改变一个算法的结构，就可以重定义改算法的某些特定的步骤 场景栗子：连接设备的分为TCP和串口连接 代码： #include <iostream> using namespace std; class IConnect { public: int connectDevice() { configArgs(); cout << "配置完毕" <&

桥接模式 定义：把抽象部分和它的实现部分分离，使得它们都可以独立的变化 栗子场景：华山派和崆峒派先后获得了武林秘籍辟邪剑谱和九阴真经，于是开始苦练此功.. 代码： #include<iostream> using namespace std; class Sects; //功夫 class Kungfu { public: virtual void practice() = 0; }; //九阴真经 class JiuyinZj :public Kungfu { public:

享元模式 定义：运用共享技术有效地支持大量细粒度的对象。 优点：减少单个实例的数目，来避免相似类的开销。 属于结构型模式。 栗子场景：人在江湖飘，哪有不挨刀，加入一个门派成为了武林人士的首选。 #include <iostream> #include <map> using namespace std; //侠客类 class KnightErrant { public: KnightErrant(string n) :m_name("") { m_name

适配器模式 定义：将一个类的接口转换为用户希望的另外一个接口，使得原本因为接口不兼容而不能一起工作的类能在一起工作。 它属于结构型模式, 代码： #include <iostream> using namespace std; //客户需要的接口类 即对外提供的类 class IProvide { public: virtual void Connect() = 0; }; //需要适配的类 class Tcp{ public: void tcpConnect() {

原型模式 定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象 它属于创建者模式，其实就是通过一个对象再创建另外一个对象的副本，但是不需要知道任何创建对象所需要的细节。 优点： 1、当一个对象经过一段时间后，它内部的状态已经发生了变化，这时候，程序的其他业务需要当前状态下 的对象去进行其他的操作。这时候如果直接在new一个新的对象出来，它的状态就对应不上了。这时候采用原型模式，就可以获取一个状态一致的对象。 2、有时候创建对象时，构造函数需要的参数却很多，但是我们又不完全的知道每个

状态模式 定义：当一个对象的内在状态改变时，允许改变它的行为，这个对象看起来像是改变了其类。 它属于行为型模式 栗子场景：一天根据当前的时间段，来决定一个人是吃早饭还是午饭以及晚饭。即根据时间的状态变化，改变人吃什么的行为。 代码： #include <iostream> #include <Windows.h> using namespace std; class Eat; class MealStatus { public: virtual void doEa

外观模式 定义：为子系统中的一组接口提供一个一致的接口，使得这些子系统更加容易被使用 栗子场景：最近股市特别火，小王也尝试着去买卖一下股票，试一下当操盘手的感觉 代码： #include <iostream> using namespace std; //股票A class SharesA{ public: void buySharesA() { cout << "股票A买入" << endl; } void sellSharesA() {

观察者模式属于行为型模式，即当对象间存在一对多关系时，则考虑使用观察者模式。比如，当一个对象被修改时，则会自动通知依赖它的对象。 栗子场景：课堂上，李老师（具体通知者）叫小明（具体观察者）和大红（具体观察者）坐下，然后再单独叫小明站起来。 代码： #include <iostream> #include <list> using namespace std; //抽象观察者 class Observer{ public: virtual void update(std:

策略模式是行为型模式，它是一种定义一系列算法的方法，所有的这些算法完成的都是相同的工作，只是实现不同。所以可以用相同的方式去调用所有的算法，降低了算法类与使用算法的类之间的耦合度。 代码： #include <iostream> using namespace std; /* 策略模式 */ //抽象算法 class ConnectDevice { public: virtual void connect() = 0; }; //tcp连接 class TcpConnect :

抽象工厂模式和工厂方法模式类似，因此也被称为工厂家族模式，属于创建型设计模式。 定义：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类。 以下的例子说明： 市场上有神奇公司和希望公司，他们同时可以生产鼠标和电池，但是两个公司的鼠标和电池型号却是不一样的。 IMouseProduct（抽象鼠标产品） IBatteryProduct（抽象电池产品） -----------------------------------------------------------------

目录 简单工厂模式 定义 优缺点 代码实现 简单工厂模式 定义 它又被叫做静态工厂方法模式，是由一个工厂对象去决定创建出哪一种产品类的实例， 在工厂模式家族中，是最简单但是很实用的模式， 优缺点 优点：根据客户的需要，去动态实例化相关的类，去除了客户对具体产品的依赖。 缺点：每次增加新的功能，就需要去修改现有工厂代码，违反了“开闭原则”。 代码实现 首先需要提供一个抽象产品类，和具体产品的实现类。并需要一个生产的工厂类。 以下以生产酒为场景，介绍简单工厂模式的代码实现。 #i

一、依赖倒置原则 定义：1、高层模块不应该依赖于低层模块，二者都应该依赖于抽象。 2、抽象不应该依赖于实现细节，实现细节应该依赖于抽象。 二、开发封闭原则 定义：对扩展开放，对修改关闭。 三、单一职责原则 定义：一个类应该仅有一个引起它变化的原因。 四、里氏替换原则 定义：子类必须能够替换它们的父类。 五、接口隔离原则 定义：不应该强迫客户程序依赖它们不用的方法 六、优先使用对象组合，而不是类继承 七、迪米特法则也叫最少知识原则 定义：如果两个类不必彼此直接通信，那么这两个类就不应