A brief introduction to strategy pattern in C++ design patterns

Strategy pattern definition:

defines a family of algorithms and encapsulates them separately so that they can be replaced with each other. This pattern allows changes in the algorithm to not affect the customers who use the algorithm.

Strategy pattern includes the following roles:

Context: Environment class

Strategy: Abstract strategy class

ConcreteStrategy: Concrete strategy class

UML class diagram:

Test case

[code]int main(){
    //商品费用
    double cost;
    //采取某种收费策略之后的费用
    double result;
    //假如
    cost = 1029.88;

    //声明要使用的具体策略类
    //这里显示出了策略类的缺点：客户端必须知道有哪些具体封装的算法。如本例必须知道三种收费方式Normal、Return、Rebate。
    StrategyCashSuper *Normal = new ConerectStrategyNormal(cost);//抽象策略类（基类）指针指向派生类->具体策略类（普通收费方式）
    StrategyCashSuper *Return = new ConerectStrategyReturn(cost); //满300返100收费方式
    StrategyCashSuper *Rebate = new ConerectStrategyRebate(cost); //打八折收费
    //声明环境类，具体调用的算法，由它来维护
    Context *c = new Context();
    //设置使用的策略类
    c->setStrategy(Normal);//设置为普通收费
    //调用算法
    result = c->getChargeResult();
    std::cout << "Accrued expenses: " << result << std::endl;

    c->setStrategy(Return);//设置为满300返100收费方式
    //调用算法
    result = c->getChargeResult();
    std::cout << "Accrued expenses: " << result << std::endl;

    c->setStrategy(Rebate);//设置为打八折收费
    //调用算法
    result = c->getChargeResult();
    std::cout << "Accrued expenses: " << result << std::endl;

    return 0;
}

Header file Strategy.h

[code]#ifndef _2STRATEGY_H_
#define _2STRATEGY_H_
//策略类，算法基类
class StrategyCashSuper{
protected:
    //商品应付费用，定义为保护成员供子类继承
    double cost;   
public:
    //构造函数
    StrategyCashSuper(double c):cost(c){}
    //收费结果算法
    virtual double ChargeResult();//本想定义为纯虚函数，但不可以。因为虚基类本不能实例化
};

//正常收费算法
class ConerectStrategyNormal: public StrategyCashSuper{
public:
    //构造函数
    ConerectStrategyNormal(double c):StrategyCashSuper(c){}
    //根据本类的收费方式，重写继承的收费算法
    double ChargeResult()override;
};

//满300返100收费算法
class ConerectStrategyReturn: public StrategyCashSuper{
public:
    //构造函数
    ConerectStrategyReturn(double c):StrategyCashSuper(c){}
    //重写收费算法
    double ChargeResult()override;    
};

//打八折收费算法
class ConerectStrategyRebate: public StrategyCashSuper{
public:
    //构造函数
    ConerectStrategyRebate(double c):StrategyCashSuper(c){}
    //重写收费算法
    double ChargeResult()override;  

};

//环境类，根据具体算法，维护上下文使用的类
class Context{
private:
    //策略基类
    StrategyCashSuper *SCS;
public:
    //设置使用的策略
    void setStrategy(StrategyCashSuper *s);
    //具体执行的算法
    double getChargeResult();
};

#endif

Implementing Strategy.cpp

[code]#include "2Strategy.h"
//基类
double StrategyCashSuper::ChargeResult(){
    return 0;
}

//正常收费
double ConerectStrategyNormal::ChargeResult(){
    return cost;
}

//满300返100收费算法
double ConerectStrategyReturn::ChargeResult(){
    double res = cost;
    if(res >= 300)
        res = cost - 100;
    return res;
}
//打八折收费算法
double ConerectStrategyRebate::ChargeResult(){
    return cost *0.8;
}

//设置使用的算法
void Context::setStrategy(StrategyCashSuper *s){
    SCS = s;
}

//具体执行的算法
double Context::getChargeResult(){
    return SCS->ChargeResult();
}

Summary:

The strategy pattern allows the algorithm to change independently of the clients using it, also becoming the policy pattern. Strategy pattern is an object behavior pattern.

The strategy pattern contains 3 roles: the abstract strategy class declares abstract methods for the supported algorithms and is the parent class of all strategy classes; the concrete strategy class implements the algorithm defined in the abstract strategy class. The environment class can use multiple strategy classes to solve a certain problem (the disadvantage is that the client needs to know all the encapsulated strategy classes), and maintain a reference instance to the abstract strategy class in the environment class.

The strategy pattern is an encapsulation of the algorithm. It separates the responsibility of the algorithm from the algorithm itself and delegates it to different object management. The strategy pattern usually encapsulates a series of algorithms into a series of strategy classes, as a subclass of an abstract strategy class.

The main advantage of the strategy mode is its perfect support for the "opening and closing principle". Algorithms can be replaced or new algorithms can be added without modifying the original system. It manages the algorithm family very well and improves the reusability of the code. , is an implementation method that replaces inheritance and avoids multiple conditional transfer statements; its disadvantage is that the client must know all the policy classes and understand their differences. At the same time, it increases the number of classes in the system to a certain extent, and there may be Lots of strategy classes.

Applicable situations of the strategy pattern include: there are many classes in a system, and the difference between them is only their behavior. Using the strategy pattern can dynamically let an object choose one behavior among many behaviors; a system needs to dynamically Choose one of several algorithms; avoid using multiple conditional selection statements that are difficult to maintain; hope to encapsulate the algorithm and its related data structures in a specific strategy class.

The above is the content of the strategy pattern of C++ design pattern. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!