@TOC

前言

在软件设计中，常常会遇到需要根据不同情况选择不同算法或行为的情况。策略模式和简单工厂模式是两种常见的设计模式，它们分别解决了对象行为的抽象和对象创建的抽象问题。在某些情况下，将这两种模式结合起来可以更好地满足实际需求，提高代码的灵活性和可维护性。

策略模式与简单工厂模式的结合：

策略模式用于定义一系列算法，将每个算法封装到独立的类中，并使它们可以相互替换，从而使得算法可以独立于客户端而变化。简单工厂模式用于封装对象的创建过程，将对象的创建与客户端解耦。

将策略模式与简单工厂模式结合起来，可以使得在创建具体策略对象时更加灵活，同时保持了策略对象的封装性。通过简单工厂模式，我们可以根据客户端的需求动态创建不同的具体策略对象，而策略模式则确保了这些对象可以被客户端无缝地使用。

一、为什么需要策略模式+简单工厂模式

当我们面对需要根据不同情况选择不同算法或行为的情况时，策略模式是一个很好的选择。它允许我们将不同的算法封装成独立的类，并且可以在运行时灵活地切换这些算法，而不影响客户端代码。然而，单独使用策略模式时，我们需要在客户端代码中显式地创建具体策略对象，这可能导致代码变得复杂，尤其当需要根据不同条件选择不同的策略时。

这时候，简单工厂模式可以派上用场。简单工厂模式提供了一个统一的接口来创建对象，客户端只需提供简单的参数，而不必了解具体对象的创建过程。将策略模式与简单工厂模式结合起来，可以在需要时动态地创建不同的具体策略对象，同时保持代码的简洁和可维护性。简单工厂模式负责对象的创建，而策略模式确保了这些对象可以被灵活地使用，让我们的软件更加智能和适应变化。这种结合使用的设计模式能够提高代码的灵活性、可扩展性和可维护性，使得软件系统更加健壮和易于理解。

二、策略模式+简单工厂模式实现原理

• 策略模式：

首先定义一个策略接口（或抽象类），其中包含定义了一系列算法的方法。
创建具体的策略类，分别实现策略接口中的方法，每个具体策略类代表一个具体的算法。
在客户端中，持有一个策略接口的指针（或引用），可以动态切换不同的具体策略对象。
当客户端需要使用某个具体的算法时，调用策略接口中定义的方法即可。

• 简单工厂模式：

创建一个工厂类，负责根据传入的参数来创建具体的对象。
工厂类中包含一个方法，根据不同的参数返回不同的具体对象实例。

• 结合实现原理：

在策略模式中，客户端通常需要显式地创建具体策略对象，这可能会导致代码的复杂性。
为了解决这个问题，可以将具体策略对象的创建委托给简单工厂，通过简单工厂模式动态地创建具体的策略对象。
这样，客户端只需要和简单工厂打交道，向工厂传递参数即可获取所需的具体策略对象，而无需直接创建对象。
当需要在运行时根据不同条件选择不同的策略时，可以通过简单工厂来创建不同的策略对象，然后使用策略模式来执行具体的算法。

三、UML图

通过UML图可以发现简单工厂模式和策略模式+简单工厂模式非常的像啊！其主要差别就是工厂生成的类有一个统一执行的函数execute函数用来变成策略模式，进而就有了策略模式的特征了

四、示例代码

#include <iostream>
#include <memory>

// 抽象策略类
class Strategy {
public:
    virtual void execute() const = 0;
    virtual ~Strategy() {}
};

// 具体策略类 A
class ConcreteStrategyA : public Strategy {
public:
    void execute() const override {
        std::cout << "Executing strategy A\n";
    }
};

// 具体策略类 B
class ConcreteStrategyB : public Strategy {
public:
    void execute() const override {
        std::cout << "Executing strategy B\n";
    }
};

// 工厂类，用于创建具体策略对象
class StrategyFactory {
public:
    static Strategy* createStrategy(char type) {
        switch (type) {
        case 'A':
            return new ConcreteStrategyA;
        case 'B':
            return new ConcreteStrategyB;
        default:
            throw std::invalid_argument("Invalid strategy type");
        }
    }
};

int main() {
    // 使用工厂类创建具体策略对象
    auto strategyA = StrategyFactory::createStrategy('A');
    auto strategyB = StrategyFactory::createStrategy('B');

    // 执行策略
    strategyA->execute();
    strategyB->execute();

    return 0;
}

抽象策略类（Strategy）：定义了执行策略的接口 execute()，所有具体策略类都要实现这个接口。

具体策略类（ConcreteStrategyA 和 ConcreteStrategyB）：实现了具体的策略，分别是策略 A 和策略 B。它们提供了不同的行为实现方式。

工厂类（StrategyFactory）：用于创建具体策略对象。createStrategy 方法根据传入的参数类型决定创建哪种具体策略对象。

主函数（main）：在 main 函数中，通过工厂类创建了具体的策略对象 strategyA 和 strategyB，分别对应策略 A 和策略 B。然后调用这些策略对象的 execute() 方法执行相应的策略。

实现决策的原理在于通过工厂类的 createStrategy 方法根据输入的参数类型来动态创建具体的策略对象。这种方式使得客户端代码与具体策略对象的创建过程解耦，同时利用了策略模式的灵活性，能够在运行时动态地切换不同的策略。

总结

策略模式与简单工厂模式的结合，能够很好地将对象的行为和对象的创建分离，使得系统更具灵活性和可扩展性。通过将具体策略对象的创建委托给简单工厂，我们可以在不改变客户端代码的情况下动态地切换不同的策略，从而更好地满足不同的业务需求。这种结合使用的设计模式在实际项目中具有广泛的应用价值，可以帮助我们更好地组织和管理代码结构，提高代码的可维护性和可扩展性。