C++20 策略模式精讲：告别if-else，提升代码可维护性

在软件开发中，我们经常遇到需要根据不同的条件执行不同的算法或行为的情况。如果简单地使用 if-else 或 switch 语句来处理这些情况，会导致代码变得臃肿、难以维护和扩展。C++20 中的策略模式正是为了解决这个问题而生的。它允许我们定义一系列算法，并将每一个算法封装到一个独立的类中，使得它们可以互相替换，而不会影响客户端代码。本文将深入探讨策略模式在 C++20 中的应用，并结合具体案例进行讲解。

问题场景：电商平台的促销活动

假设我们正在开发一个电商平台的后端系统，需要支持各种促销活动，例如满减、折扣、买赠等。如果我们使用 if-else 语句来处理这些活动，代码可能会变成下面这样：

#include <iostream>
#include <string>

class Order {
public:
    double calculateTotalPrice(std::string promotionType, double originalPrice) {
        if (promotionType == "满减") {
            // 满减逻辑
            if (originalPrice >= 100) {
                return originalPrice - 20;
            }
        } else if (promotionType == "折扣") {
            // 折扣逻辑
            return originalPrice * 0.8;
        } else if (promotionType == "买赠") {
            // 买赠逻辑
            if (originalPrice >= 50) {
                return originalPrice; // 赠送小礼品，价格不变
            }
        } else {
            return originalPrice;
        }
        return originalPrice;
    }
};

int main() {
    Order order;
    double price = 120.0;
    std::cout << "原价: " << price << std::endl;
    std::cout << "满减后价格: " << order.calculateTotalPrice("满减", price) << std::endl;
    std::cout << "折扣后价格: " << order.calculateTotalPrice("折扣", price) << std::endl;
    return 0;
}

这段代码的缺点非常明显：

• 代码逻辑耦合度高，所有促销活动的处理逻辑都集中在一个函数中。
• 可维护性差，每次新增或修改促销活动，都需要修改这个函数。
• 可扩展性差，难以支持更多的促销活动。

底层原理：策略模式的核心思想

策略模式的核心思想是将算法的定义和使用分离，将每个算法封装到一个独立的策略类中，并定义一个抽象的策略接口。客户端代码通过选择不同的策略类来执行不同的算法。策略模式包含以下几个角色：

• 策略接口（Strategy）： 定义所有策略类需要实现的接口。
• 具体策略类（ConcreteStrategy）： 实现策略接口，封装具体的算法。
• 上下文类（Context）： 持有一个策略对象的引用，负责调用策略对象的方法。

这种设计模式可以有效降低代码的耦合度，提高代码的可维护性和可扩展性。类似于 Nginx 的模块化设计，不同的模块（对应不同的策略）可以灵活地配置和替换，从而实现不同的功能。 Nginx 的负载均衡策略就是一个很好的例子，你可以选择轮询、加权轮询、IP Hash 等不同的策略来实现不同的负载均衡效果。 这些策略的切换无需修改 Nginx 的核心代码，极大地提高了 Nginx 的灵活性和可维护性。

代码实现：C++20 策略模式的应用

下面我们使用 C++20 来实现策略模式，重构上面的促销活动代码：

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

// 策略接口
class PromotionStrategy {
public:
    virtual double applyPromotion(double originalPrice) = 0;
    virtual ~PromotionStrategy() = default; // 添加虚析构函数
};

// 具体策略类：满减
class FullReductionStrategy : public PromotionStrategy {
public:
    double applyPromotion(double originalPrice) override {
        if (originalPrice >= 100) {
            return originalPrice - 20;
        }
        return originalPrice;
    }
};

// 具体策略类：折扣
class DiscountStrategy : public PromotionStrategy {
public:
    double applyPromotion(double originalPrice) override {
        return originalPrice * 0.8;
    }
};

// 具体策略类：买赠
class BuyGiftStrategy : public PromotionStrategy {
public:
    double applyPromotion(double originalPrice) override {
        if (originalPrice >= 50) {
            // 赠送小礼品，价格不变
            return originalPrice;
        }
        return originalPrice;
    }
};

// 上下文类
class Order {
private:
    std::unique_ptr<PromotionStrategy> strategy; // 使用智能指针

public:
    Order(std::unique_ptr<PromotionStrategy> strategy) : strategy(std::move(strategy)) {}

    double calculateTotalPrice(double originalPrice) {
        return strategy->applyPromotion(originalPrice);
    }

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

int main() {
    double price = 120.0;
    std::cout << "原价: " << price << std::endl;

    // 使用满减策略
    Order order1(std::make_unique<FullReductionStrategy>());
    std::cout << "满减后价格: " << order1.calculateTotalPrice(price) << std::endl;

    // 使用折扣策略
    Order order2(std::make_unique<DiscountStrategy>());
    std::cout << "折扣后价格: " << order2.calculateTotalPrice(price) << std::endl;

    // 动态切换策略
    order1.setPromotionStrategy(std::make_unique<BuyGiftStrategy>());
    std::cout << "买赠后价格: " << order1.calculateTotalPrice(price) << std::endl; // 赠送礼品

    return 0;
}

在这个例子中，我们定义了一个 PromotionStrategy 接口，以及三个具体的策略类 FullReductionStrategy、DiscountStrategy 和 BuyGiftStrategy。Order 类作为上下文类，持有一个 PromotionStrategy 对象的引用，并负责调用策略对象的方法。 客户端代码可以通过传递不同的策略对象来执行不同的促销活动。 我们使用了 std::unique_ptr 来管理策略对象的生命周期，避免了内存泄漏的问题。 这种方式比之前的 if-else 方案更加灵活，易于维护和扩展。 当需要添加新的促销活动时，只需要创建一个新的策略类并实现 PromotionStrategy 接口即可，无需修改现有的代码。

实战避坑：策略模式的注意事项

• 策略类的粒度： 策略类的粒度需要根据实际情况进行调整。如果策略类过于简单，可能会导致策略模式失去意义。如果策略类过于复杂，可能会导致策略类的维护成本过高。
• 策略对象的创建： 策略对象的创建可以由客户端代码负责，也可以由工厂模式来创建。如果策略对象的创建逻辑比较复杂，建议使用工厂模式。
• 策略对象的生命周期： 策略对象的生命周期需要根据实际情况进行管理。可以使用智能指针来管理策略对象的生命周期，避免内存泄漏的问题。
• 性能问题： 策略模式可能会引入额外的性能开销，因为每次调用策略方法都需要进行一次函数调用。对于性能要求较高的场景，可以考虑使用内联函数或模板来实现策略模式。

总结

策略模式是一种非常有用的设计模式，可以帮助我们更好地组织代码，提高代码的可维护性和可扩展性。 在 C++20 中，我们可以使用智能指针来管理策略对象的生命周期，避免内存泄漏的问题。 在实际应用中，我们需要根据具体情况选择合适的策略模式实现方式，并注意策略类的粒度、策略对象的创建和生命周期以及性能问题。理解并合理运用策略模式，可以帮助我们写出更加健壮和灵活的代码，构建更稳定的后端系统，应对高并发、大流量的挑战，例如在电商秒杀场景下，可以灵活切换不同的流量削峰策略，保证系统的稳定性。