策略模式（Strategy Pattern）是一种行为型设计模式，广泛用于需要动态切换算法或行为的场景

最新推荐文章于 2026-07-07 11:01:44 发布

原创最新推荐文章于 2026-07-07 11:01:44 发布 · 709 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

策略模式（Strategy Pattern）是一种行为型设计模式，广泛用于需要动态切换算法或行为的场景。

以下是对策略模式的详细讲解，涵盖其定义、核心概念、C++实现、代码示例、优缺点、面试常见问题及解答，以及在实际项目中的应用示例。

我会结合C++特性（如智能指针、模板、RAII）提供高效实现，并针对你的上下文（C++相关问题）确保内容清晰、全面。

如果你有特定场景或问题想深入探讨，请告诉我！

1. 策略模式的核心概念

1.1 定义策略模式定义了一系列算法或行为，将每个算法封装成独立的类，使它们可以互相替换，且不影响使用算法的客户端。客户端通过上下文（Context）动态选择具体策略。

1.2 核心思想

封装变化：将可变的行为（算法）封装到独立类中，符合开闭原则（对扩展开放，对修改关闭）。
动态切换：客户端在运行时选择不同策略，无需修改上下文代码。
解耦：客户端与具体算法解耦，只依赖抽象接口。

1.3 结构

Strategy（策略接口）：定义算法的抽象接口，通常是抽象类或纯虚函数。
ConcreteStrategy（具体策略）：实现策略接口，提供具体算法。
Context（上下文）：持有策略对象的引用，调用选定的策略执行操作。

1.4 适用场景

需要动态选择不同算法（如排序、加密、压缩）。
多个类只有算法或行为不同。
需要避免大量条件语句（如if-else或switch）。
示例：游戏中的AI行为、支付系统的支付方式、日志输出方式。

2. C++中的策略模式实现C++的特性（如虚函数、智能指针、模板）使策略模式实现更灵活和安全。以下是一个完整的C++实现示例，展示策略模式的结构和用法。

2.1 基本实现代码示例：cpp

#include <iostream>
#include <memory>

// 策略接口
class Strategy {
public:
    virtual void execute(const std::string& data) const = 0;
    virtual ~Strategy() = default; // 虚析构函数，防止内存泄漏
};

// 具体策略A
class ConcreteStrategyA : public Strategy {
public:
    void execute(const std::string& data) const override {
        std::cout << "Strategy A: Processing " << data << std::endl;
    }
};

// 具体策略B
class ConcreteStrategyB : public Strategy {
public:
    void execute(const std::string& data) const override {
        std::cout << "Strategy B: Handling " << data << " differently" << std::endl;
    }
};

// 上下文
class Context {
private:
    std::unique_ptr<Strategy> strategy_; // 使用智能指针管理策略
public:
    Context() : strategy_(nullptr) {}

    void setStrategy(std::unique_ptr<Strategy> strategy) {
        strategy_ = std::move(strategy); // 动态切换策略
    }

    void executeStrategy(const std::string& data) const {
        if (strategy_) {
            strategy_->execute(data);
        } else {
            std::cout << "No strategy set" << std::endl;
        }
    }
};

int main() {
    Context context;
    
    // 使用策略A
    context.setStrategy(std::make_unique<ConcreteStrategyA>());
    context.executeStrategy("Test Data");

    // 切换到策略B
    context.setStrategy(std::make_unique<ConcreteStrategyB>());
    context.executeStrategy("Test Data");

    return 0;
}

输出：

Strategy A: Processing Test Data
Strategy B: Handling Test Data differently

代码分析：

Strategy接口：Strategy定义纯虚函数execute，强制派生类实现。
具体策略：ConcreteStrategyA和ConcreteStrategyB提供不同实现。
上下文：Context持有std::unique_ptr<Strategy>，支持运行时切换策略。
C++特性：
- 使用std::unique_ptr管理策略对象，避免内存泄漏。
- 虚析构函数确保派生类正确释放。
- const成员函数（execute）保证不修改对象状态。

2.2 使用模板实现静态策略模式C++模板支持静态多态，可以避免虚函数的性能开销（vtable查找）。以下是使用CRTP（Curiously Recurring Template Pattern）的静态策略模式实现。

代码示例：cpp

#include <iostream>

// 策略基类模板
template <typename Derived>
class Strategy {
public:
    void execute(const std::string& data) const {
        static_cast<const Derived*>(this)->doExecute(data); // 静态调用
    }
};

// 具体策略A
class ConcreteStrategyA : public Strategy<ConcreteStrategyA> {
public:
    void doExecute(const std::string& data) const {
        std::cout << "Static Strategy A: Processing " << data << std::endl;
    }
};

// 具体策略B
class ConcreteStrategyB : public Strategy<ConcreteStrategyB> {
public:
    void doExecute(const std::string& data) const {
        std::cout << "Static Strategy B: Handling " << data << std::endl;
    }
};

// 上下文
template <typename TStrategy>
class Context {
private:
    TStrategy strategy_;
public:
    void executeStrategy(const std::string& data) const {
        strategy_.execute(data);
    }
};

int main() {
    Context<ConcreteStrategyA> contextA;
    contextA.executeStrategy("Test Data");

    Context<ConcreteStrategyB> contextB;
    contextB.executeStrategy("Test Data");

    return 0;
}

输出：

Static Strategy A: Processing Test Data
Static Strategy B: Handling Test Data

说明：

CRTP：Strategy模板通过static_cast调用派生类的doExecute，避免虚函数开销。
性能优势：静态多态在编译时解析，适合高性能场景（如游戏引擎）。
局限性：策略类型在编译时确定，无法运行时动态切换。

3. 策略模式的优缺点

3.1 优点

开闭原则：新策略可通过添加新类实现，无需修改上下文。
解耦：客户端与具体算法解耦，只依赖抽象接口。
灵活性：运行时动态切换策略，适应不同需求。
可维护性：算法封装在独立类中，易于测试和修改。

3.2 缺点

类数量增加：每个策略需要一个新类，可能增加代码量。
客户端复杂性：客户端需了解并选择合适的策略。
虚函数开销：动态多态版本有vtable查找成本（可用模板缓解）。

4. 面试常见问题及解答以下是策略模式相关的常见面试问题，结合C++实现和你的上下文（C++设计模式）。

问题1：策略模式与状态模式的区别？答案：

策略模式：客户端主动选择不同算法，行为独立封装。
状态模式：对象根据内部状态自动切换行为，状态管理逻辑。

C++示例（状态模式）：cpp

class State {
public:
    virtual void handle() = 0;
    virtual ~State() = default;
};
class Context {
    std::unique_ptr<State> state_;
public:
    void setState(std::unique_ptr<State> state) { state_ = std::move(state); }
    void handle() { state_->handle(); }
};

区别：策略模式由客户端控制切换，状态模式由对象状态驱动。

问题2：如何在C++中优化策略模式的性能？答案：

使用模板和CRTP实现静态多态，消除虚函数开销。
使用final关键字优化虚函数调用。

示例：cpp

class Strategy {
public:
    virtual void execute() const final { /* 优化调用 */ }
};

问题3：策略模式如何避免内存泄漏？答案：

使用std::unique_ptr或std::shared_ptr管理策略对象。
确保基类有虚析构函数。

示例（你的代码相关）：cpp

class Strategy {
public:
    virtual ~Strategy() = default; // 防止泄漏
};

问题4：策略模式适合哪些场景？答案：

动态选择算法（如排序、加密）。
替换大量条件语句。
需要扩展新行为。
示例：支付系统支持多种支付方式（PayPal、CreditCard）。

问题5：动态多态与静态多态在策略模式中的取舍？答案：

动态多态（虚函数）：运行时切换策略，灵活但有vtable开销。
静态多态（模板/CRTP）：编译时确定策略，性能高但缺乏运行时灵活性。
选择依据：高性能场景（如游戏）用静态多态，动态配置场景（如插件系统）用动态多态。

5. 实际项目中的应用示例以下是策略模式在C++项目中的具体应用，结合你的上下文（类似FileParser的插件系统）。

5.1 应用1：

文件压缩系统场景：支持多种压缩算法（如ZIP、GZIP），动态选择。

代码示例：cpp

#include <iostream>
#include <memory>
#include <string>

// 压缩策略接口
class CompressionStrategy {
public:
    virtual void compress(const std::string& file) const = 0;
    virtual ~CompressionStrategy() = default;
};

// ZIP压缩
class ZipCompression : public CompressionStrategy {
public:
    void compress(const std::string& file) const override {
        std::cout << "Compressing " << file << " using ZIP" << std::endl;
    }
};

// GZIP压缩
class GzipCompression : public CompressionStrategy {
public:
    void compress(const std::string& file) const override {
        std::cout << "Compressing " << file << " using GZIP" << std::endl;
    }
};

// 上下文
class Compressor {
private:
    std::unique_ptr<CompressionStrategy> strategy_;
public:
    void setStrategy(std::unique_ptr<CompressionStrategy> strategy) {
        strategy_ = std::move(strategy);
    }

    void compressFile(const std::string& file) const {
        if (strategy_) {
            strategy_->compress(file);
        }
    }
};

int main() {
    Compressor compressor;
    compressor.setStrategy(std::make_unique<ZipCompression>());
    compressor.compressFile("data.txt");
    compressor.setStrategy(std::make_unique<GzipCompression>());
    compressor.compressFile("data.txt");
    return 0;
}

输出：

Compressing data.txt using ZIP
Compressing data.txt using GZIP

说明：

策略模式：CompressionStrategy定义压缩接口，ZipCompression和GzipCompression实现具体算法。
C++特性：使用std::unique_ptr管理策略对象，虚析构函数确保安全。
与你的代码的关联：类似FileParser，支持动态添加新策略（如RAR压缩），符合插件系统设计。

5.2 应用2：

游戏AI行为场景：游戏中敌人动态切换行为（如巡逻、攻击）。

代码示例：cpp

#include <iostream>
#include <memory>

// AI行为策略接口
class AIBehavior {
public:
    virtual void act() const = 0;
    virtual ~AIBehavior() = default;
};

// 巡逻行为
class PatrolBehavior : public AIBehavior {
public:
    void act() const override { std::cout << "Patrolling area" << std::endl; }
};

// 攻击行为
class AttackBehavior : public AIBehavior {
public:
    void act() const override { std::cout << "Attacking player" << std::endl; }
};

// 敌人上下文
class Enemy {
private:
    std::unique_ptr<AIBehavior> behavior_;
public:
    void setBehavior(std::unique_ptr<AIBehavior> behavior) {
        behavior_ = std::move(behavior);
    }

    void performAction() const {
        if (behavior_) {
            behavior_->act();
        }
    }
};

int main() {
    Enemy enemy;
    enemy.setBehavior(std::make_unique<PatrolBehavior>());
    enemy.performAction();
    enemy.setBehavior(std::make_unique<AttackBehavior>());
    enemy.performAction();
    return 0;
}

输出：

Patrolling area
Attacking player

说明：

策略模式：AIBehavior定义行为接口，PatrolBehavior和AttackBehavior实现具体行为。
动态切换：Enemy在运行时切换行为，适应游戏状态。
C++特性：std::unique_ptr管理行为对象，const成员函数确保只读操作。

6. 与你的上下文的关联你的代码（FileParser、JsonParser、XmlParser、FileProcessor）与策略模式有相似之处：

FileParser类似策略接口：定义了parse纯虚函数，强制派生类实现。
JsonParser和XmlParser类似具体策略：实现不同解析逻辑。
FileProcessor类似上下文：持有多个FileParser对象，动态调用。

区别：

你的代码更接近微内核架构或组合模式，FileProcessor管理多个解析器，执行所有策略。
策略模式通常一次只使用一个策略，Context持有单一策略对象。

改进为策略模式：

若将你的代码改为严格的策略模式，可限制FileProcessor一次只持有一个解析器：cpp

class FileProcessor {
private:
    std::unique_ptr<FileParser> parser_; // 单一策略
public:
    void setParser(std::unique_ptr<FileParser> parser) {
        parser_ = std::move(parser);
    }

    void process(const std::string& file) const {
        if (parser_) {
            parser_->parse(file);
        }
    }
};

int main() {
    FileProcessor processor;
    processor.setParser(std::make_unique<JsonParser>());
    processor.process("data.json");
    processor.setParser(std::make_unique<XmlParser>());
    processor.process("data.xml");
    return 0;
}

输出：

Parsing json data.json
Parsing XML file: data.xml

说明：改为单一parser_，更符合策略模式的定义，强调动态切换单一行为。

7. 注意事项

内存管理：
- 使用std::unique_ptr或std::shared_ptr管理策略对象，避免内存泄漏。
- 基类（如Strategy）必须定义虚析构函数。
性能优化：
- 使用模板/CRTP实现静态多态，适合高性能场景。
- 使用final关键字优化虚函数调用。
设计原则：
- 遵循开闭原则，新策略只需添加新类。
- 避免客户端直接实例化具体策略，可结合工厂模式创建。

线程安全：

如果上下文在多线程中共享，需加锁保护策略切换：cpp

class Context {
    std::unique_ptr<Strategy> strategy_;
    std::mutex mutex_;
public:
    void setStrategy(std::unique_ptr<Strategy> strategy) {
        std::lock_guard<std::mutex> lock(mutex_);
        strategy_ = std::move(strategy);
    }
};

8. 总结策略模式通过封装可变算法，提供动态切换能力，适合需要灵活行为切换的场景。C++实现结合虚函数（动态多态）和模板（静态多态），使用智能指针确保内存安全。

你的FileParser代码与策略模式相似，但更偏向多策略执行，稍作调整可完全符合策略模式。

实际应用（如压缩系统、游戏AI）展示了其灵活性和扩展性。关键点：