C++策略模式：函数对象与lambda现代用法

策略模式在C++中通过函数对象和Lambda表达式实现，可提升灵活性与代码简洁性。1. 定义策略接口提高可读性和维护性；2. 使用函数对象实现有状态或复杂逻辑的策略；3. 使用Lambda表达式实现无状态且简单的策略；4. 通过上下文类维护策略并在运行时动态切换；5. 客户端根据需求传递不同策略。函数对象适合复杂逻辑，Lambda适合简洁实现，策略模式适用于排序算法、支付系统等需动态选择算法的场景，但应避免过度设计。

策略模式在C++中的实现，核心在于定义一系列算法，并将每一个算法封装起来，使它们可以互相替换。函数对象（Functors）和 Lambda 表达式是实现策略模式的现代且灵活的方式。

策略模式允许在运行时选择算法，避免了使用大量的条件语句。

解决方案

在C++中，使用函数对象和Lambda表达式实现策略模式，可以获得更高的灵活性和代码简洁性。下面展示如何通过这些技术实现策略模式：

1. 定义策略接口（可选）：

   虽然不是强制性的，但定义一个策略接口可以提高代码的可读性和可维护性，尤其是在策略比较复杂时。

   

   class Strategy {
   public:
       virtual int execute(int a, int b) = 0;
       virtual ~Strategy() = default;
   };

2. 使用函数对象实现策略：

   函数对象是重载了 operator() 的类。它们可以像函数一样被调用，并且可以携带状态。

   class AdditionStrategy {
   public:
       int execute(int a, int b) {
           return a + b;
       }
   };
   
   class SubtractionStrategy {
   public:
       int execute(int a, int b) {
           return a - b;
       }
   };

3. 使用 Lambda 表达式实现策略：

   Lambda 表达式提供了一种更简洁的方式来定义策略。

   auto multiplicationStrategy = [](int a, int b) { return a * b; };
   auto divisionStrategy = [](int a, int b) {
       if (b == 0) throw std::runtime_error("Division by zero!");
       return a / b;
   };

4. 上下文类：

   上下文类维护一个指向策略的指针或函数对象，并提供一个方法来执行策略。

   #include 
   #include 
   
   class Context {
   private:
       std::function strategy; // 使用 std::function
   
   public:
       Context(std::function strategy) : strategy(strategy) {}
   
       int executeStrategy(int a, int b) {
           return strategy(a, b);
       }
   
       void setStrategy(std::function newStrategy) {
           strategy = newStrategy;
       }
   };

5. 客户端代码：

   客户端代码创建上下文对象，并将不同的策略传递给它。

   int main() {
       AdditionStrategy add;
       SubtractionStrategy subtract;
   
       Context contextAdd([&](int a, int b){ return add.execute(a, b); });
       std::cout << "Addition: " << contextAdd.executeStrategy(5, 3) << std::endl;
   
       Context contextSubtract([&](int a, int b){ return subtract.execute(a, b); });
       std::cout << "Subtraction: " << contextSubtract.executeStrategy(5, 3) << std::endl;
   
       // 使用 Lambda 表达式
       Context contextMultiply([](int a, int b) { return a * b; });
       std::cout << "Multiplication: " << contextMultiply.executeStrategy(5, 3) << std::endl;
   
       Context contextDivide([](int a, int b) {
           if (b == 0) throw std::runtime_error("Division by zero!");
           return a / b;
       });
   
       try {
           std::cout << "Division: " << contextDivide.executeStrategy(10, 2) << std::endl;
           //std::cout << "Division by zero: " << contextDivide.executeStrategy(10, 0) << std::endl; // 会抛出异常
       } catch (const std::exception& e) {
           std::cerr << "Exception: " << e.what() << std::endl;
       }
   
       // 动态切换策略
       contextAdd.setStrategy([](int a, int b) { return a * a + b * b; });
       std::cout << "Dynamic Strategy: " << contextAdd.executeStrategy(2, 3) << std::endl;
   
       return 0;
   }

如何选择函数对象还是 Lambda 表达式？

函数对象适合于需要维护状态或需要更复杂的逻辑的策略。Lambda 表达式则更适合简单的、无状态的策略，可以使代码更简洁。

策略模式在实际项目中的应用场景有哪些？

策略模式在多种场景下都非常有用。例如，在排序算法中，可以使用策略模式来选择不同的排序方法（如快速排序、归并排序等）。在支付系统中，可以根据不同的支付方式（信用卡、支付宝、微信支付）选择不同的支付策略。

如何避免策略模式过度设计？

虽然策略模式很强大，但过度使用会导致代码变得复杂。只在确实需要动态选择算法时才使用策略模式。如果算法的选择是静态的，那么直接使用条件语句可能更简单。同时，要避免创建过于复杂的策略接口，保持接口的简洁性。