设计模式分类

Open sidebar

设计模式分类

Model: Default

设计模式有多少种

设计模式是在软件设计中反复出现的一些最佳实践和解决方案的集合。根据 Gang of Four（GoF）的经典著作《设计模式：可复用面向对象软件的基础》一书，设计模式可分为以下三类：

创建型模式（Creational Patterns）：处理对象的创建机制，旨在通过控制对象的创建来达到解耦的目的，以提高系统的灵活性和可维护性。包括简单工厂模式、工厂方法模式、抽象工厂模式、单例模式、原型模式、建造者模式等。
结构型模式（Structural Patterns）：处理对象之间的组合关系，以实现更加灵活和高效的结构。包括适配器模式、桥接模式、装饰器模式、组合模式、外观模式、享元模式、代理模式等。
行为型模式（Behavioral Patterns）：处理对象之间的通信和职责分配，以实现更加灵活和可扩展的行为。包括模板方法模式、策略模式、命令模式、职责链模式、状态模式、观察者模式、中介者模式、备忘录模式、访问者模式、解释器模式等。

目前已经有超过 20 种设计模式被正式定义和广泛应用，但是这个数字随着时间的推移也在不断增加。

c++实现这些模式

C++是一种强大的面向对象编程语言，可以很方便地实现各种设计模式。以下是一些常见设计模式的C++实现示例：

单例模式

c++Copy codeclass Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

private:
    Singleton() {} // 私有化构造函数
    Singleton(const Singleton&) = delete; // 禁止拷贝构造
    Singleton& operator=(const Singleton&) = delete; // 禁止赋值操作
};

工厂方法模式

c++Copy codeclass Product {
public:
    virtual void use() = 0;
};

class ConcreteProduct : public Product {
public:
    void use() override {
        // 具体产品的实现
    }
};

class Creator {
public:
    virtual Product* createProduct() = 0;
};

class ConcreteCreator : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProduct();
    }
};

观察者模式

c++Copy codeclass Observer {
public:
    virtual void update() = 0;
};

class Subject {
public:
    void attach(Observer* observer) {
        observers_.push_back(observer);
    }

    void detach(Observer* observer) {
        observers_.remove(observer);
    }

    void notify() {
        for (auto observer : observers_) {
            observer->update();
        }
    }

private:
    std::list<Observer*> observers_;
};

class ConcreteObserver : public Observer {
public:
    void update() override {
        // 具体观察者的更新操作
    }
};

以上是一些常见设计模式的C++实现示例，实际上每种模式的具体实现都会因为业务场景而略有不同，所以这里的示例仅供参考。

工厂模式的主要作用是什么

工厂模式是一种创建型设计模式，其主要作用是将对象的创建与使用分离开来，以提高系统的可维护性、灵活性和可扩展性。工厂模式通过将对象的创建委托给工厂类来实现，从而降低了客户端与具体产品的耦合度。

工厂模式的主要作用包括：

将对象的创建和使用分离开来，使得客户端无需了解具体产品的实现细节，从而降低了系统的耦合度。
可以在不修改现有代码的情况下添加新的产品类型，提高了系统的可扩展性和灵活性。
可以封装产品的实现细节，隐藏了产品的具体实现方式，从而提高了系统的安全性和稳定性。
可以统一管理产品的创建过程，避免了代码的重复，提高了系统的代码复用率。

总之，工厂模式是一种非常重要的设计模式，在实际的软件开发中经常被使用，其主要作用是将对象的创建与使用分离开来，以提高系统的可维护性、灵活性和可扩展性。

给出实例

以下是一个简单的示例，用于说明工厂模式的应用。

假设有一个应用程序，需要根据用户的需求创建不同类型的图表，例如柱状图、折线图、饼状图等。在不使用工厂模式的情况下，我们需要在客户端代码中直接创建图表对象，如下所示：

c++Copy codevoid client() {
    std::string type = getUserInput(); // 获取用户输入的图表类型
    Chart* chart = nullptr;
    if (type == "bar") {
        chart = new BarChart(); // 创建柱状图对象
    } else if (type == "line") {
        chart = new LineChart(); // 创建折线图对象
    } else if (type == "pie") {
        chart = new PieChart(); // 创建饼状图对象
    }
    chart->display(); // 显示图表
}

这种实现方式存在以下问题：

客户端代码与具体产品耦合度高，需要了解每个产品的实现细节，一旦产品发生变化，客户端代码也需要相应地修改。
客户端代码需要负责对象的创建，增加了代码的复杂度和重复性。
无法轻松地添加新的产品类型，需要修改现有代码并重新编译，增加了开发的成本和风险。

使用工厂模式可以解决这些问题。我们可以定义一个工厂类，负责创建不同类型的图表对象，客户端代码只需要通过工厂类来获取图表对象，而不需要直接与具体产品耦合，如下所示：

c++Copy codeclass ChartFactory {
public:
    virtual Chart* createChart() = 0;
};

class BarChartFactory : public ChartFactory {
public:
    Chart* createChart() override {
        return new BarChart();
    }
};

class LineChartFactory : public ChartFactory {
public:
    Chart* createChart() override {
        return new LineChart();
    }
};

class PieChartFactory : public ChartFactory {
public:
    Chart* createChart() override {
        return new PieChart();
    }
};

void client() {
    std::string type = getUserInput(); // 获取用户输入的图表类型
    ChartFactory* factory = nullptr;
    if (type == "bar") {
        factory = new BarChartFactory(); // 创建柱状图工厂对象
    } else if (type == "line") {
        factory = new LineChartFactory(); // 创建折线图工厂对象
    } else if (type == "pie") {
        factory = new PieChartFactory(); // 创建饼状图工厂对象
    }
    Chart* chart = factory->createChart(); // 通过工厂对象获取图表对象
    chart->display(); // 显示图表
    delete factory; // 释放工厂对象
    delete chart; // 释放图表对象
}

这种实现方式的优点在于：

客户端代码与具体产品解耦，只需要通过工厂类来获取产品对象，无需了解产品的实现细节，减

New chat

开发喵星球

设计模式分类

设计模式分类