设计模式

最新推荐文章于 2024-11-17 22:33:54 发布
最新推荐文章于 2024-11-17 22:33:54 发布
阅读量112 收藏
点赞数
分类专栏： c++ 文章标签： 设计模式 c++
原文链接：https://leetcode-cn.com/leetbook/read/cpp-interview-highlights/o5v4w6/
版权

设计模式有 6 大设计原则

  1. 单一职责原则：基于一个类而言，应该只有一个引起它变化的原因。
  2. 开放封闭原则：软件实体可以扩展，但不能修改。即面对需求，对程序的改动可以通过增加代码来完成，但不能通过修改现有代码。
  3. 里氏代换原则：一个软件实体如果使用的是一个基类，那么一定适用于其派生类。即在软件中，把基类替换成派生类，程序的行为没有变化。
  4. 依赖倒转原则：抽象不应该依赖细节，细节应该依赖抽象。即针对接口编程，而不是针对实现编程。
  5. 迪米特原则：如果两个类不直接通信，那么这两个类就不应当发生直接关系。如果一个类要调用另一个类中的某个方法，可以通过第三个类转发这个调用。
  6. 接口隔离原则：每个接口不存在派生类中用不到却必须实现的方法，如若不然，则将接口拆分，使用多个隔离的接口。

设计模式分为三类

  1. 创造型模式：单例模式、工厂模式、建造者模式、原型模式
  2. 结构性模式：适配器模式、桥接模式、外观模式、组合模式、装饰模式、享元模式、代理模式
  3. 行为型模式：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式

下面介绍常见的几种设计模式：

  • 单例模式：保证一个类仅有一个实例，并提供一个访问他的全局访问点。

  • 工厂模式：包括简单工厂模式、抽象工厂模式和工厂方法模式

    • 简单工厂模式：主要用于创建对象。用一个工厂来根据输入条件产生不同的类，然后通过不同类的虚函数得到不同的结果。
      应用场景： 适用于针对不同情况创建不同类时，只需传入工厂类的参数即可，无需了解具体实现方法。例如：计算器中对于同样的输入，执行不同的操作：加、减、乘、除。
    #include <iostream>
#include <vector>
using namespace std;

// Here is the product class
class Operation
{
public:
    int var1, var2;
    virtual double GetResult()
    {
        double res = 0;
        return res;
    }
};

class Add_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 + var2;
    }
};

class Sub_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 - var2;
    }
};

class Mul_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 * var2;
    }
};

class Div_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 / var2;
    }
};

// Here is the Factory class
class Factory
{
public:
    static Operation *CreateProduct(char op)
    {
        switch (op)
        {
        case '+':
            return new Add_Operation();

        case '-':
            return new Sub_Operation();

        case '*':
            return new Mul_Operation();

        case '/':
            return new Div_Operation();

        default:
            return new Add_Operation();
        }
    }
};

int main()
{
    int a, b;
    cin >> a >> b;
    Operation *p = Factory::CreateProduct('+');
    p->var1 = a;
    p->var2 = b;
    cout << p->GetResult() << endl;

    p = Factory::CreateProduct('*');
    p->var1 = a;
    p->var2 = b;
    cout << p->GetResult() << endl;

    return 0;
}
    • 抽象工厂模式：定义了一个创建一系列相关或相互依赖的接口，而无需指定他们的具体类。
      应用场景：
    1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
    2. 系统中有多于一个的产品族，而每次只使用其中某一产品族。
    3. 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。
    4. 产品等级结构稳定，设计完成之后，不会向系统中增加新的产品等级结构或者删除已有的
      产品等级结构。
    #include <iostream>
#include <vector>
using namespace std;

// Here is the product class
class Operation_Pos
{
public:
    int var1, var2;
    virtual double GetResult()
    {
        double res = 0;
        return res;
    }
};

class Add_Operation_Pos : public Operation_Pos
{
public:
    virtual double GetResult()
    {
        return var1 + var2;
    }
};

class Sub_Operation_Pos : public Operation_Pos
{
public:
    virtual double GetResult()
    {
        return var1 - var2;
    }
};

class Mul_Operation_Pos : public Operation_Pos
{
public:
    virtual double GetResult()
    {
        return var1 * var2;
    }
};

class Div_Operation_Pos : public Operation_Pos
{
public:
    virtual double GetResult()
    {
        return var1 / var2;
    }
};
/*********************************************************************************/
class Operation_Neg
{
public:
    int var1, var2;
    virtual double GetResult()
    {
        double res = 0;
        return res;
    }
};

class Add_Operation_Neg : public Operation_Neg
{
public:
    virtual double GetResult()
    {
        return -(var1 + var2);
    }
};

class Sub_Operation_Neg : public Operation_Neg
{
public:
    virtual double GetResult()
    {
        return -(var1 - var2);
    }
};

class Mul_Operation_Neg : public Operation_Neg
{
public:
    virtual double GetResult()
    {
        return -(var1 * var2);
    }
};

class Div_Operation_Neg : public Operation_Neg
{
public:
    virtual double GetResult()
    {
        return -(var1 / var2);
    }
};
/*****************************************************************************************************/

// Here is the Factory class
class Factory
{
public:
    virtual Operation_Pos *CreateProduct_Pos() = 0;
    virtual Operation_Neg *CreateProduct_Neg() = 0;
};

class Add_Factory : public Factory
{
public:
    Operation_Pos *CreateProduct_Pos()
    {
        return new Add_Operation_Pos();
    }
    Operation_Neg *CreateProduct_Neg()
    {
        return new Add_Operation_Neg();
    }
};

class Sub_Factory : public Factory
{
public:
    Operation_Pos *CreateProduct_Pos()
    {
        return new Sub_Operation_Pos();
    }
    Operation_Neg *CreateProduct_Neg()
    {
        return new Sub_Operation_Neg();
    }
};

class Mul_Factory : public Factory
{
public:
    Operation_Pos *CreateProduct_Pos()
    {
        return new Mul_Operation_Pos();
    }
    Operation_Neg *CreateProduct_Neg()
    {
        return new Mul_Operation_Neg();
    }
};

class Div_Factory : public Factory
{
public:
    Operation_Pos *CreateProduct_Pos()
    {
        return new Div_Operation_Pos();
    }
    Operation_Neg *CreateProduct_Neg()
    {
        return new Div_Operation_Neg();
    }
};

int main()
{
    int a, b;
    cin >> a >> b;
    Add_Factory *p_fac = new Add_Factory();
    Operation_Pos *p_pro = p_fac->CreateProduct_Pos();
    p_pro->var1 = a;
    p_pro->var2 = b;
    cout << p_pro->GetResult() << endl;

    Add_Factory *p_fac1 = new Add_Factory();
    Operation_Neg *p_pro1 = p_fac1->CreateProduct_Neg();
    p_pro1->var1 = a;
    p_pro1->var2 = b;
    cout << p_pro1->GetResult() << endl;

    return 0;
}
    • 工厂方法模式：修正了简单工厂模式中不遵守开放封闭原则。把选择判断移到了客户端去实现，如果想添加新功能就不用修改原来的类，直接修改客户端即可。
      应用场景：
    1. 一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
    2. 一个类通过其派生类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其派生类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，派生类对象将覆盖父类对象，从而使得系统更容易扩展。
    3. 将创建对象的任务委托给多个工厂派生类中的某一个，客户端在使用时可以无须关心是哪一个工厂派生类创建产品派生类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。
    #include <iostream>
#include <vector>
using namespace std;

// Here is the product class
class Operation
{
public:
    int var1, var2;
    virtual double GetResult()
    {
        double res = 0;
        return res;
    }
};

class Add_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 + var2;
    }
};

class Sub_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 - var2;
    }
};

class Mul_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 * var2;
    }
};

class Div_Operation : public Operation
{
public:
    virtual double GetResult()
    {
        return var1 / var2;
    }
};

class Factory
{
public:
    virtual Operation *CreateProduct() = 0;
};

class Add_Factory : public Factory
{
public:
    Operation *CreateProduct()
    {
        return new Add_Operation();
    }
};

class Sub_Factory : public Factory
{
public:
    Operation *CreateProduct()
    {
        return new Sub_Operation();
    }
};

class Mul_Factory : public Factory
{
public:
    Operation *CreateProduct()
    {
        return new Mul_Operation();
    }
};

class Div_Factory : public Factory
{
public:
    Operation *CreateProduct()
    {
        return new Div_Operation();
    }
};

int main()
{
    int a, b;
    cin >> a >> b;
    Add_Factory *p_fac = new Add_Factory();
    Operation *p_pro = p_fac->CreateProduct();
    p_pro->var1 = a;
    p_pro->var2 = b;
    cout << p_pro->GetResult() << endl;

    Mul_Factory *p_fac1 = new Mul_Factory();
    Operation *p_pro1 = p_fac1->CreateProduct();
    p_pro1->var1 = a;
    p_pro1->var2 = b;
    cout << p_pro1->GetResult() << endl;

    return 0;
}

  • 装饰模式：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比派生类类更灵活。

  • 观察者模式：定义了一种一对多的关系，让多个观察对象同时监听一个主题对象，主题对象发生变化时，会通知所有的观察者，使他们能够更新自己。
    观察者模式中存在两种角色：

    • 观察者：内部包含被观察者对象，当被观察者对象的状态发生变化时，更新自己的状态。（接收通知更新状态）
    • 被观察者：内部包含了所有观察者对象，当状态发生变化时通知所有的观察者更新自己的状态。（发送通知）
      应用场景：
    1. 当一个对象的改变需要同时改变其他对象，且不知道具体有多少对象有待改变时，应该考虑使用观察者模式；
    2. 一个抽象模型有两个方面，其中一方面依赖于另一方面，这时可以用观察者模式将这两者封装在独立的对象中使它们各自独立地改变和复用。
    #include <iostream>
#include <string>
#include <list>
using namespace std;

class Subject;
//观察者 基类 （内部实例化了被观察者的对象sub）
class Observer
{
protected:
    string name;
    Subject *sub;

public:
    Observer(string name, Subject *sub)
    {
        this->name = name;
        this->sub = sub;
    }
    virtual void update() = 0;
};

class StockObserver : public Observer
{
public:
    StockObserver(string name, Subject *sub) : Observer(name, sub)
    {
    }
    void update();
};

class NBAObserver : public Observer
{
public:
    NBAObserver(string name, Subject *sub) : Observer(name, sub)
    {
    }
    void update();
};
//被观察者 基类 （内部存放了所有的观察者对象，以便状态发生变化时，给观察者发通知）
class Subject
{
protected:
    list<Observer *> observers;

public:
    string action; //被观察者对象的状态
    virtual void attach(Observer *) = 0;
    virtual void detach(Observer *) = 0;
    virtual void notify() = 0;
};

class Secretary : public Subject
{
    void attach(Observer *observer)
    {
        observers.push_back(observer);
    }
    void detach(Observer *observer)
    {
        list<Observer *>::iterator iter = observers.begin();
        while (iter != observers.end())
        {
            if ((*iter) == observer)
            {
                observers.erase(iter);
                return;
            }
            ++iter;
        }
    }
    void notify()
    {
        list<Observer *>::iterator iter = observers.begin();
        while (iter != observers.end())
        {
            (*iter)->update();
            ++iter;
        }
    }
};

void StockObserver::update()
{
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "梁所长来了!")
    {
        cout << "我马上关闭股票，装做很认真工作的样子！" << endl;
    }
}

void NBAObserver::update()
{
    cout << name << " 收到消息：" << sub->action << endl;
    if (sub->action == "梁所长来了!")
    {
        cout << "我马上关闭NBA，装做很认真工作的样子！" << endl;
    }
}

int main()
{
    Subject *dwq = new Secretary();
    Observer *xs = new NBAObserver("xiaoshuai", dwq);
    Observer *zy = new NBAObserver("zouyue", dwq);
    Observer *lm = new StockObserver("limin", dwq);

    dwq->attach(xs);
    dwq->attach(zy);
    dwq->attach(lm);

    dwq->action = "去吃饭了！";
    dwq->notify();
    cout << endl;
    dwq->action = "梁所长来了!";
    dwq->notify();
    return 0;
}
GoodLinGL
关注
专栏目录
《C++ 设计模式》
青春不老，奋斗不止！
02-09 9万+
设计模式代表了最佳的实践，在面向对象的编程中被很多老鸟们反复使用。使用设计模式有很多好处：可重用代码、保证代码可靠性、使代码更易被他人理解 ......
设计模式课程设计---使用5个以上不同的设计模式完成（java）
12-19
在本设计模式课程设计中，我们重点探讨了五个核心的设计模式：原型模式、单例模式、抽象工厂模式、代理模式和建造者模式。这些模式在Java编程中具有广泛的应用，能够帮助开发者创建更加灵活、可扩展和易于维护的代码...
今天在知乎上看到一边关于工厂模式的文章，在这里给大家分享下
weixin_45942124的博客
08-15 724
1.1为什么要用工厂模式？想想我们为什么要用工厂模式？下面我就简单举例子：文件IO的操作我们会经常用得到吧，所以BufferedReader对象经常要创建的：// 创建一个BufferedReader对象 BufferedReader bf = new BufferedReader(new FileReader(new File("aa.txt"))); 你说麻烦吗？其实也不麻烦，就一行代码嘛，哪里麻烦了~如果不太熟悉IO流的同学就没有那么机灵了，创建一个BufferedReader可能就是以下的
Java 创建型设计模式详解
WenZhang的博客
08-15 1991
概念抽象工厂模式提供了一个接口，用于创建一系列相关或互相依赖的对象，而无需指定它们的具体类。它通常用于创建一组相关产品，如操作系统的不同界面风格。结构抽象工厂类（AbstractFactory）：声明创建一组相关产品的方法。具体工厂类（ConcreteFactory）：实现抽象工厂的方法，生成一系列具体产品。抽象产品类（AbstractProduct）：定义产品的接口。具体产品类（ConcreteProduct）：实现具体产品。示例代码// 抽象产品Avoid use();
行为型设计模式
shaofei_huai的博客
06-04 3582
行为型设计模式目的是将多个类或对象相互协作，共同完成单个类或对象无法单独完成的任务。行为型设计模式共11种，分别为解释器模式、模板方法模式、责任链模式、命令模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、访问者模式。 ......
C++设计模式（23种）汇总及代码实现
songbijian的博客
09-03 5201
它是继承复用的基石，只有当衍生类可以替换掉基类，软件单位功能不受到影响的时候，基类才能真正被复用，而衍生类也能够在积累的基础上增加新的行为。提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示。它结合了两个独立接口的功能，将一个类的接口转换成客户期望的另一个接口，让原本不兼容的类或者函数可以协同运作，是两个不兼容的接口之间的桥梁。3.当进行深拷贝的时候，需要编写较为复杂的代码，而且当对象之间存在多重嵌套时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现复杂。
Pipeline 设计模式的优缺点和实践案例
明明如月的技术博客
03-14 2568
之前文章中介绍了 Pipeline 设计模式，核心思想是创建一组操作（管道）并将数据在这些操作中传递，每个操作可以独立工作，同时处理多个数据流。有同学提到几个问题，本文简单探讨下。 （1）例子中 Pipeline 的代码使用硬编码也可以实现，为什么要用这个模式，有什么好处？ （2）Pipeline 设计模式在实际的编码中是怎样体现的？ （3)Pipeline 设计模式有什么缺点？如何避免？
设计模式常见面试题
libaowenBlog的博客
06-06 6130
1、单列模式：单列模式是保证系统唯一性的重要的手段，单列模式首先通过建类的实列化方法私有化来防止程序通过其它的方式创建该类的实列，然后通过提供一个全局的唯一获得该类的实列的方法来帮助用户来获得该类的实例，用户只需要也只能通过调用该方法获得全局类实列常见的方法：1、懒汉模式 2、饿汉模式 3、双重校验锁 4 静态内部类2、工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但这些方法针对不同的数据进行了不同的操作，当得到子类的实列后，开发人员调用基本的方法而不必考
设计模式-外观模式（Facade）
miaoyl的博客
11-08 2233
外观模式（Facade Pattern）是一种结构型设计模式，这种模式通过为多个复杂的子系统提供一个一致的接口，来隐藏系统的复杂性，从而使得这些子系统更加容易被访问。该模式的主要意图是为子系统中的一组接口提供一个一致的界面，定义了一个高层接口，使得这一子系统更加容易使用。外观模式在日常开发中是经常被使用的一种设计模式，它通过引入一个外观角色，简化了客户端与子系统之间的交互关系，为复杂的子系统调用提供一个统一的入口，降低了客户端的使用难度。
设计模式总结
Abmuyu的博客
04-22 1721
设计模式可以看成是一类特定问题的核心解决方案。我们遇到的问题一般都可以被归纳成有限的几种类型，每个类型的问题都在重复发生，经过长时间的探索和实践，前人已经总结出一些针对这些特定类型问题的有效解决方案，这些方案就可以看作一种设计模式。1、设计模式本身是经过大量实践检验的，是一种高效的解决方案，尤其对于缺乏经验的新手程序员来讲，这些设计模式是更优的方案。2、设计模式本身是经过抽象提取的，是适合去解决一类特定类型问题的，意味着设计模式复用性很强，可以用来重复的解决同一类型的多个问题。
什么是设计模式，要掌握那些知识
weixin_47260194的博客
09-09 1856
设计模式是经验总结出来的、用于解决软件开发中常见问题的最佳实践。它不是代码，而是一种解决问题的模板或思路，可以被应用在不同的场景中。
软件设计模式综合实验（课程设计）源码
03-08
3.仿照教材上面围棋软件的设计思路，设计一款五子棋，采用至少5种设计模式。 说明： （1）实验报告中把设计的思路说清楚，给出你所采用的设计模式的原始类图。 （2）对于你系统中使用了设计模式的模块绘制其类图，...
设计模式与游戏完美开发
07-06
设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏完美开发 设计模式与游戏...
java设计模式课程设计
10-13
使用5种设计模式完成的一个点单系统，显示不同系列下的所有商品，点击选择冰度甜度之后添加到订单中，计算总金额，下单之后发送订单到门店的后厨制作商品。使用了抽象工厂模式、装饰模式、单例模式、代理模式、原型...
《Java设计模式》刘伟 课后习题及模拟试题答案.rar
08-24
《Java设计模式》是刘伟老师的一本经典教材，它深入浅出地讲解了软件设计中的重要概念——设计模式。设计模式是经验丰富的开发者在解决常见问题时总结出的通用解决方案，是软件开发中的智慧结晶。这本书的课后习题和...
单例模式详解
最新发布
Z_oioihoii
11-17 651
依赖注入是一种设计模式，通过将类的依赖项通过构造函数、属性或方法传入，而不是类自己创建依赖对象。
怎样在软件设计中选择使用GOF设计模式
Joshua的专栏
11-14 1319
在软件设计中选择使用GOF设计模式需要综合考虑需求、问题域、模式的适用场景以及模式的优缺点。通过理解设计模式的核心思想，并结合具体的示例进行实践，可以有效地提高软件的可维护性、可扩展性和代码复用性。理解设计模式的设计意图、类之间的关联关系，以及重新设计的原因是非常重要的。通过这些要点，可以更有针对性地选择合适的模式，解决系统设计中的具体问题，提高代码的可维护性、可扩展性和灵活性。
前端开发设计模式——责任链模式
jxnd123456的博客
11-13 1442
责任链模式是一种行为设计模式，它允许多个对象依次处理同一个请求。每个对象都有机会处理请求，如果一个对象不能处理请求，它会将请求传递给下一个对象，直到有一个对象能够处理请求或者请求到达链的末尾包含一个指向下一个处理者的引用和一个处理请求的抽象方法。抽象方法通常接受一个请求参数，并返回一个处理结果或者将请求传递给下一个处理者。
23 种设计模式详解
weixin_46764753的博客
11-13 825
定义：确保一个类最多只有一个实例，并提供一个全局访问点单例模式可以分为两种：预加载和懒加载定义：定义了一个创建对象的类，由这个类来封装实例化对象的行为。定义：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。定义：定义了一个接口用于创建相关或有依赖关系的对象族，而无需明确指定具体类。简单工厂模式：建立一个实例化对象的类，在该类中对多个对象实例化。工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。
C语言实现设计模式探索
"C语言设计模式，尽管通常与面向对象语言如C#、Java或C++关联，但也可以应用于C语言。本文档旨在展示如何在C语言中运用各种设计模式，以提高代码质量和可维护性。设计模式包括单件模式、工厂模式、抽象工厂模式、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值