C++设计模式--工厂模式

1.设计模式

C++设计模式共有以下几种：
1. **创建型模式**：关注于对象的创建过程。包括工厂方法模式、抽象工厂模式、单例模式、建造者模式和原型模式。
2. **结构型模式**：关注类和对象的组合。包括适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式和享元模式。
3. **行为型模式**：关注对象之间的通信。包括策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式和解释器模式。

此外，还有并发模式和线程池模式等其他类型的模式。每种设计模式都有其特定的使用场景和解决的问题。了解这些设计模式有助于编写更加灵活、可维护且可重用的代码。

2.设计模式作用

它们不仅是最佳实践的体现，而且是众多开发者长时间试验和总结的成果。以下是使用设计模式的一些具体作用：

1. 提高代码重用性：通过遵循设计模式，可以确保相同的功能不需要多次编写，这样可以节省时间并减少错误的可能性。
2. 增强可读性：设计模式提供了一种编程规范，使得代码更易于其他程序员阅读和理解，这对于团队合作尤为重要。
3. 提升可扩展性：当需要向现有系统添加新功能时，良好的设计模式可以使这一过程更加方便，同时也保证了原有功能的稳定性。
4. 保证可靠性：设计模式的应用有助于降低新增功能对原有系统的影响，从而提高软件的整体可靠性。
5. 促进高内聚低耦合：设计模式鼓励创建高内聚且低耦合的代码，这有助于构建更加健壮和灵活的系统。
6. 遵循设计原则：设计模式基于七大原则，如单一职责原则、开闭原则等，这些原则是设计模式设计的基础，也是编程时应遵守的规则。
7. 实现工程化：设计模式使代码编制更加工程化，它们是软件工程的基石，对于构建稳定的大型系统至关重要。

3.工厂模式

1.设计思想

工厂模式是一种创建型设计模式，它的核心思想是提供一个创建对象的接口，但由子类决定要实例化的类是哪一个。这样可以将对象的创建过程封装起来，使得代码更加灵活和可维护。

使用工厂模式可以带来以下好处：

1. **封装性**：客户端代码不需要知道如何创建对象，只需要知道如何从工厂请求它即可。这样，如果创建对象的逻辑发生变化，只需要修改工厂类，而不需要修改依赖于工厂的客户端代码。
2. **扩展性**：当需要添加新的产品类时，只需扩展具体的工厂类和产品类，而不会影响到其他代码，符合软件设计的开闭原则。
3. **灵活性**：可以通过改变工厂类的实现来改变所创建的产品类型，而无需修改调用它的代码。
4. **依赖倒置原则**：高层模块不依赖于底层模块，它们都依赖于抽象。这意味着我们的代码更加模块化，各个模块之间的耦合度降低，提高了代码的可维护性和稳定性。
5. **避免直接实例化对象**：通过工厂方法创建对象而不是直接调用构造函数，可以更灵活地控制对象的创建过程，例如添加缓存机制或者在创建对象前后执行一些操作。

总的来说，在C++开发中使用工厂模式可以使代码更加灵活、可维护且易于扩展，同时遵循了SOLID设计原则中的开闭原则和依赖倒置原则。

2.示例

#include <iostream>
#include <memory>

// 抽象产品类
class Product {
public:
    virtual ~Product() {}
    virtual void Show() = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    void Show() override {
        std::cout << "我是产品A" << std::endl;
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    void Show() override {
        std::cout << "我是产品B" << std::endl;
    }
};

// 抽象工厂类
class Factory {
public:
    virtual ~Factory() {}
    virtual std::unique_ptr<Product> CreateProduct() = 0;
};

// 具体工厂类A
class ConcreteFactoryA : public Factory {
public:
    std::unique_ptr<Product> CreateProduct() override {
        return std::make_unique<ConcreteProductA>();
    }
};

// 具体工厂类B
class ConcreteFactoryB : public Factory {
public:
    std::unique_ptr<Product> CreateProduct() override {
        return std::make_unique<ConcreteProductB>();
    }
};

int main() {
    // 使用具体工厂A创建产品A
    std::unique_ptr<Factory> factoryA = std::make_unique<ConcreteFactoryA>();
    std::unique_ptr<Product> productA = factoryA->CreateProduct();
    productA->Show();

    // 使用具体工厂B创建产品B
    std::unique_ptr<Factory> factoryB = std::make_unique<ConcreteFactoryB>();
    std::unique_ptr<Product> productB = factoryB->CreateProduct();
    productB->Show();
	system("pause");
    return 0;
}

1. Product是一个抽象产品类，定义了一个纯虚函数Show。
2. ConcreteProductA和ConcreteProductB是具体的产品类，它们都继承自Product并实现了Show方法。
3. Factory是一个抽象工厂类，定义了一个纯虚函数CreateProduct。
4. ConcreteFactoryA和ConcreteFactoryB是具体的工厂类，它们都继承自Factory并实现了CreateProduct方法。
5. 在main函数中，我们首先使用具体工厂A创建了一个产品A，然后使用具体工厂B创建了一个产品B。