Eine kurze Einführung in Strategiemuster in C++-Entwurfsmustern

Strategiemodusdefinition:

definiert eine Familie von Algorithmen und kapselt sie separat, sodass sie untereinander ersetzt werden können. Dieser Modus ermöglicht, dass Änderungen am Algorithmus keine Auswirkungen auf die Kunden haben, die den Algorithmus verwenden.

Das Strategiemuster umfasst die folgenden Rollen:

Kontext: Umgebungsklasse

Strategie: Abstrakte Strategieklasse

ConcreteStrategy: Konkrete Strategieklasse

UML-Klassendiagramm:

Testfall

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

Zusammenfassung:

Das Strategiemuster ermöglicht es dem Algorithmus, sich unabhängig von den Clients zu ändern, die ihn verwenden, und wird auch zum Richtlinienmuster. Strategiemuster ist ein Objektverhaltensmuster.

Das Strategiemuster enthält drei Rollen: Die abstrakte Strategieklasse deklariert abstrakte Methoden für die unterstützten Algorithmen und ist die übergeordnete Klasse aller Strategieklassen. Die konkrete Strategieklasse implementiert den in der abstrakten Strategieklasse definierten Algorithmus. Die Umgebungsklasse kann mehrere Strategieklassen verwenden, um ein bestimmtes Problem zu lösen (der Nachteil besteht darin, dass der Client alle gekapselten Strategieklassen kennen muss) und eine Referenzinstanz auf die abstrakte Strategieklasse in der Umgebungsklasse verwalten.

Das Strategiemuster ist eine Kapselung des Algorithmus. Es trennt die Verantwortung des Algorithmus vom Algorithmus selbst und delegiert sie an eine andere Objektverwaltung. Das Strategiemuster kapselt normalerweise eine Reihe von Algorithmen in eine Reihe von Strategieklassen als Unterklasse einer abstrakten Strategieklasse.

Der Hauptvorteil des Strategiemodus ist seine perfekte Unterstützung des „Öffnungs- und Schließprinzips“. Es können Algorithmen ersetzt oder neue Algorithmen hinzugefügt werden, ohne das ursprüngliche System zu ändern Verbessert den Code. Die Wiederverwendbarkeit ist eine Möglichkeit, die Vererbung zu ersetzen und mehrere bedingte Übertragungsanweisungen zu vermeiden. Der Nachteil besteht darin, dass der Client alle Strategieklassen kennen und ihre Unterschiede verstehen muss. Gleichzeitig erhöht sich dadurch die Anzahl der Klassen im System Bis zu einem gewissen Grad kann es viele Strategieklassen geben.

Zu den anwendbaren Situationen des Strategiemusters gehören: Es gibt viele Klassen in einem System, und der Unterschied zwischen ihnen besteht nur in ihrem Verhalten. Durch die Verwendung des Strategiemusters kann ein Objekt dynamisch ein Verhalten unter vielen Verhaltensweisen auswählen Das System muss dynamisch einen von mehreren Algorithmen auswählen. Es muss vermieden werden, mehrere bedingte Auswahlanweisungen zu verwenden, die schwer zu warten sind, und darauf zu achten, dass Algorithmen und zugehörige Datenstrukturen in bestimmten Strategieklassen gekapselt werden.

Das Obige ist der Inhalt einer kurzen Einführung in das C++-Entwurfsmuster und das Strategiemuster. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!