C++20 策略模式深度剖析：告别硬编码，拥抱灵活扩展

在软件开发过程中，经常会遇到需要根据不同条件选择不同算法或行为的情况。如果直接使用大量的 if-else 或 switch 语句进行判断，代码将会变得冗长、难以维护，且扩展性差。C++20 的策略模式正是为了解决这类问题而生。它通过将算法封装成独立的策略类，并在运行时动态选择使用哪个策略，从而实现算法与客户端之间的解耦。

问题场景重现：电商平台的促销策略

假设我们正在开发一个电商平台，需要实现各种促销活动，例如满减、打折、买赠等。最初，我们可能会这样实现：

#include <iostream>
#include <string>

class Order {
public:
  double calculateDiscount(std::string promotionType, double amount) {
    if (promotionType == "full_reduction") { // 满减
      if (amount >= 100) {
        return amount - 20;
      } else {
        return amount;
      }
    } else if (promotionType == "discount") { // 打折
      return amount * 0.8;
    } else if (promotionType == "buy_one_get_one") { // 买一送一（简化为赠送固定金额）
      return amount - 10;
    } else {
      return amount;
    }
  }
};

int main() {
  Order order;
  double finalAmount = order.calculateDiscount("full_reduction", 120);
  std::cout << "Final Amount: " << finalAmount << std::endl; // 输出：Final Amount: 100
  return 0;
}

这种实现方式存在明显的问题：

• 代码冗余： 所有的促销逻辑都集中在一个函数中。
• 难以维护： 修改或新增促销策略都需要修改 calculateDiscount 函数。
• 可扩展性差： 当促销策略越来越多时，if-else 语句会变得越来越复杂。

策略模式的底层原理：解耦与委托

策略模式的核心思想是将算法封装成独立的类，这些类都实现同一个接口。客户端代码通过持有策略类的引用，并在运行时动态切换策略，从而实现算法的选择。这种方式实现了算法与客户端之间的解耦，使得算法可以独立变化，而不会影响客户端代码。

在底层实现上，策略模式通常包含以下几个角色：

• 策略接口（Strategy）： 定义所有策略类需要实现的接口，通常是一个抽象类或接口。
• 具体策略类（ConcreteStrategy）： 实现策略接口，封装具体的算法。
• 环境类（Context）： 持有策略类的引用，并在运行时根据需要切换策略。

C++20 代码解决方案：灵活的促销策略

下面是用 C++20 实现的策略模式的示例代码：

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

// 策略接口
class PromotionStrategy {
public:
  virtual double applyDiscount(double amount) = 0;
  virtual ~PromotionStrategy() = default;
};

// 具体策略类：满减
class FullReductionStrategy : public PromotionStrategy {
private:
  double threshold;
  double reduction;

public:
  FullReductionStrategy(double threshold, double reduction) : threshold(threshold), reduction(reduction) {}
  double applyDiscount(double amount) override {
    if (amount >= threshold) {
      return amount - reduction;
    } else {
      return amount;
    }
  }
};

// 具体策略类：打折
class DiscountStrategy : public PromotionStrategy {
private:
  double discountRate;

public:
  DiscountStrategy(double discountRate) : discountRate(discountRate) {}
  double applyDiscount(double amount) override {
    return amount * discountRate;
  }
};

// 具体策略类：买一送一
class BuyOneGetOneStrategy : public PromotionStrategy {
public:
  double applyDiscount(double amount) override {
    return amount - 10; // 简化为赠送固定金额
  }
};

// 环境类
class Order {
private:
  std::unique_ptr<PromotionStrategy> strategy;

public:
  void setPromotionStrategy(std::unique_ptr<PromotionStrategy> strategy) {
    this->strategy = std::move(strategy);
  }

  double calculateDiscount(double amount) {
    if (strategy) {
      return strategy->applyDiscount(amount);
    } else {
      return amount;
    }
  }
};

int main() {
  Order order;

  // 设置满减策略
  order.setPromotionStrategy(std::make_unique<FullReductionStrategy>(100, 20));
  double finalAmount1 = order.calculateDiscount(120);
  std::cout << "Final Amount (Full Reduction): " << finalAmount1 << std::endl; // 输出：Final Amount (Full Reduction): 100

  // 设置打折策略
  order.setPromotionStrategy(std::make_unique<DiscountStrategy>(0.8));
  double finalAmount2 = order.calculateDiscount(120);
  std::cout << "Final Amount (Discount): " << finalAmount2 << std::endl; // 输出：Final Amount (Discount): 96

  return 0;
}

在这个例子中，PromotionStrategy 是策略接口，FullReductionStrategy、DiscountStrategy 和 BuyOneGetOneStrategy 是具体的策略类，Order 是环境类。客户端代码可以通过 setPromotionStrategy 方法动态切换促销策略。

实战避坑经验：策略选择的灵活性

在实际应用中，策略的选择可以更加灵活。例如，可以使用配置文件、数据库或者用户输入来动态确定使用哪个策略。在大型电商项目中，常常会用到类似 Nginx 的反向代理服务器做负载均衡，保证服务的高可用。如果后端服务需要频繁切换促销策略，可以将策略信息缓存在 Redis 中，减少数据库访问压力。同时，需要考虑并发连接数的问题，合理设置 Nginx 的 worker 进程数和连接超时时间，防止服务器过载。也可以使用宝塔面板等工具来简化服务器的运维管理。

另外，需要注意策略类的生命周期管理。在本例中，使用了 std::unique_ptr 来管理策略类的内存，避免内存泄漏。在更复杂的场景中，可能需要使用智能指针或其他内存管理技术。

C++20 的策略模式可以有效地解决算法选择的问题，提高代码的可维护性和可扩展性。在实际项目中，需要根据具体情况选择合适的策略模式实现方式，并注意策略选择的灵活性和策略类的生命周期管理。