Modèle de conception C brève introduction au modèle de stratégie

Définition du mode stratégie :

définit une famille d'algorithmes et les encapsule séparément afin qu'ils puissent être remplacés les uns par les autres. Ce mode permet aux modifications de l'algorithme de ne pas affecter les clients qui utilisent l'algorithme.

Le modèle de stratégie comprend les rôles suivants :

Contexte : classe d'environnement

Stratégie : classe de stratégie abstraite

ConcreteStrategy : classe de stratégie concrète

Diagramme de classes UML :

Cas de test

[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;
}

Fichier d'en-tête 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

Implement 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();
}

Résumé :

Le modèle de stratégie permet à l'algorithme de changer indépendamment des clients qui l'utilisent, devenant également le modèle de politique. Le modèle de stratégie est un modèle de comportement d'objet.

Le modèle de stratégie contient 3 rôles : la classe de stratégie abstraite déclare les méthodes abstraites pour les algorithmes pris en charge et est la classe parent de toutes les classes de stratégie ; la classe de stratégie concrète implémente l'algorithme défini dans la classe de stratégie abstraite. La classe d'environnement peut utiliser plusieurs classes de stratégie pour résoudre un certain problème (l'inconvénient est que le client doit connaître toutes les classes de stratégie encapsulées) et conserver une instance de référence à la classe de stratégie abstraite dans la classe d'environnement.

Le modèle de stratégie est une encapsulation de l'algorithme. Il sépare la responsabilité de l'algorithme de l'algorithme lui-même et la délègue à différentes gestions d'objets. Le modèle de stratégie encapsule généralement une série d’algorithmes dans une série de classes de stratégie, en tant que sous-classe d’une classe de stratégie abstraite.

Le principal avantage du mode stratégie est son parfait support du "principe d'ouverture et de fermeture". Les algorithmes peuvent être remplacés ou de nouveaux algorithmes peuvent être ajoutés sans modifier le système d'origine. Il gère très bien la famille d'algorithmes et. améliore le code La réutilisabilité est un moyen de remplacer l'héritage et d'éviter plusieurs instructions de transfert conditionnel ; son inconvénient est que le client doit connaître toutes les classes de stratégie et comprendre leurs différences, et en même temps, cela augmente le nombre de classes dans le système ; dans une certaine mesure, il peut y avoir de nombreuses classes de stratégie.

Les situations applicables du modèle de stratégie incluent : il existe de nombreuses classes dans un système, et la différence entre elles réside uniquement dans leur comportement. L'utilisation du modèle de stratégie peut permettre à un objet de choisir dynamiquement un comportement parmi de nombreux comportements ; Le système doit sélectionner dynamiquement l'un des nombreux algorithmes ; éviter d'utiliser plusieurs instructions de sélection conditionnelle difficiles à maintenir et espérer encapsuler les algorithmes et les structures de données associées dans des classes de stratégie spécifiques ;

Ce qui précède est le contenu d'une brève introduction au modèle de conception et au modèle de stratégie C. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !