策略模式通过封装算法并动态切换实现行为解耦：定义抽象基类声明纯虚接口，具体策略类继承实现，上下文持策略指针运行时委托执行。
策略模式通过定义一系列算法，把它们一个个封装起来，并且使它们可以互相替换。C++中常用抽象基类声明策略接口，具体策略类继承并实现，上下文（Context）持有一个策略指针或引用，运行时动态切换行为。
用纯
虚函数声明统一的操作契约，确保所有具体策略提供一致的调用方式：
class PaymentStrategy {
public:
virtual ~PaymentStrategy() = default;
virtual void pay(double amount) const = 0; // 纯虚函数，强制子类实现
};每个策略类独立封装一种算法逻辑，互不影响，便于新增或修改：
class CreditCardStrategy : public PaymentStrategy {
std::string cardNumber;
std::string expiryDate;
public:
CreditCardStrategy(const std::string& number, const std::string& date)
: cardNumber(number), expiryDate(date) {}
void pay(double amount) const override {
std::cout << "Paid $" << amount << " via credit card: "
<< cardNumber.substr(0, 4) << "****\n";
}};
class PayPalStrategy : public PaymentStrategy {
std::string email;
public:
PayPalStrategy(const std::string& e) : email(e) {}
void pay(double amount) const override {
std::cout << "Paid $" << amount << " via PayPal: " << email << "\n";
}};
上下文不关心策略内部怎么实现，只负责持有和委托执行；支持运行时更换策略：
class ShoppingCart {
private:
std::vector> items;
std::unique_ptr strategy; // 智能指针管理生命周期
public:
void addItem(const std::string& name, double price) {
items.emplace_back(name, price);
}
double getTotal() const {
return std::accumulate(items.begin(), items.end(), 0.0,
[](double sum, const auto& item) { return sum + item.second; });
}
void setPaymentStrategy(std::unique_ptr s) {
strategy = std::move(s);
}
void checkout() const {
if (!strategy) {
std::cout << "No payment strategy set.\n";
return;
}
strategy->pay(getTotal());
} };
客户端代码清晰解耦：策略选择与业务逻辑分离，易于测试和扩展：
int main() {
ShoppingCart cart;
cart.addItem("Laptop", 1200.0);
cart.addItem("Mouse", 25.5);
// 切换为信用卡支付
cart.setPaymentStrategy(std::make_unique("1234567890123456", "12/25"));
cart.checkout(); // 输出：Paid $1225.5 via credit card: 1234****
// 切换为PayPal支付
cart.setPaymentStrategy(std::make_unique("user@example.com"));
cart.checkout(); // 输出：Paid $1225.5 via PayPal: user@example.com
return 0;
}