首页网站怎么做,中国工商网注册官网,做高铁在哪个网站买,长春财经学院多大介绍 策略模式定义一系列算法类#xff0c;将每一个算法封装起来#xff0c;并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化#xff0c;也称为政策模式。策略模式是一种对象行为模式。 实现
myclass.h
//
// Created by yuwp on 2024/1/12.
//#ifndef DES…介绍 策略模式定义一系列算法类将每一个算法封装起来并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化也称为政策模式。策略模式是一种对象行为模式。 实现
myclass.h
//
// Created by yuwp on 2024/1/12.
//#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H#include iostream
#include unordered_map
#include atomic
#include vector
#include memoryclass Strategy { // 抽象策略类
public:virtual void algorithm() 0;
};class Context { // 抽象状态类
public:void setStrategy(Strategy *strategy);void algorithm();private:std::shared_ptrStrategy m_strategy;
};class ConcreteStrategyA : public Strategy {
public:void algorithm() override;
};class ConcreteStrategyB : public Strategy {
public:void algorithm() override;
};#endif //DESIGNPATTERNS_MYCLASS_Hmyclass.cpp
//
// Created by yuwp on 2024/1/12.
//#include myclass.h
#include thread
#include unistd.h
#include sstreamvoid Context::setStrategy(Strategy *strategy) {m_strategy.reset(strategy);
}void Context::algorithm() {if (m_strategy) {m_strategy-algorithm();} else {std::cout 当前没有策略 std::endl;}
}void ConcreteStrategyA::algorithm() {std::cout 采用策略A std::endl;
}void ConcreteStrategyB::algorithm() {std::cout 采用策略B std::endl;
}main.cpp
#include iostream
#include mutex
#include myclass.hint main() {Strategy *strategyA new ConcreteStrategyA;Strategy *strategyB new ConcreteStrategyB;Context *context new Context;context-setStrategy(strategyA);context-algorithm();context-setStrategy(strategyB);context-algorithm();delete context;return 0;
} 总结
优点 1. 策略模式提供了对开闭原则的完美支持。用户可以在不修改原有系统的基础上选择算法或行为也可以灵活地增加新的算法或行为。 2. 策略模式提供了管理相关的算法族的办法。策略类的等级结构定义了一个算法或行为族恰当使用继承可以把公共的代码移到抽象策略类中从而避免重复代码。 3. 策略模式提供了一种可以替换继承关系的办法。如果不使用策略模式那么使用算法的环境类就可能会有一些子类每一个子类提供一种不同的算法。但是这样一来算法的使用就和算法本身混在一起不符合单一职责原则。决定使用哪一种算法的逻辑和该算法本身混合在一起从而不可能再独立演化而且使用继承无法实现算法或行为在程序运行时的动态切换。 4. 使用策略模式可以避免多重条件选择语句。多重条件选择语句不易维护它把采取哪一种算法或行为的逻辑与算法或行为本身的实现逻辑混合在一起将它们全部硬编码Hard Coding在一个庞大的多重条件选择语句中比直接继承环境类的办法还要原始和落后。 5. 策略模式提供了一种算法的复用机制。由于将算法单独提取出来封装在策略类中因此不同的环境类可以方便地复用这些策略类。
缺点 1. 客户端必须知道所有的策略类并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别以便适时选择恰当的算法。换言之策略模式只适用于客户端知道所有的算法或行为的情况。 2. 策略模式将造成系统产生很多具体策略类。任何细小的变化都将导致系统要增加一个新的具体策略类。 3. 无法同时在客户端使用多个策略类。也就是说在使用策略模式时客户端每次只能使用一个策略类不支持使用一个策略类完成部分功能后再使用另一个策略类来完成剩余功能的情况。
适用场景 1. 一个系统需要动态地在几种算法中选择一种。可以将这些算法封装到一个个的具体算法类中而这些具体算法类都是一个抽象算法类的子类。换言之这些具体算法类均具有统一的接口。根据里氏代换原则和面向对象的多态性客户端可以选择使用任何一个具体算法类并只需要维持一个数据类型是抽象算法类的对象。 2. 一个对象有很多的行为如果不用恰当的模式这些行为就只好使用多重条件选择语句来实现。此时使用策略模式把这些行为转移到相应的具体策略类里面就可以避免使用难以维护的多重条件选择语句。 3. 不希望客户端知道复杂的、与算法相关的数据结构。在具体策略类中封装算法与相关的数据结构可以提高算法的保密性与安全性。 练习
myclass.h
//
// Created by yuwp on 2024/1/12.
//#ifndef DESIGNPATTERNS_MYCLASS_H
#define DESIGNPATTERNS_MYCLASS_H#include iostream
#include unordered_map
#include atomic
#include vector
#include memoryclass TakeOff { // 起飞抽象策略类
public:virtual void takeOff() 0; // 起飞
};class Flight { // 飞行抽象策略类
public:virtual void flight() 0; // 飞行
};class Plane {
public:Plane(TakeOff *takeOff, Flight *flight);virtual ~Plane();virtual void takeOff();virtual void flight();
private:TakeOff *m_takeoff;Flight *m_flight;
};class Simulator { // 模拟系统
public:void setPlane(Plane *plane);void start();private:std::shared_ptrPlane m_plane;
};class VerticalTakeOff : public TakeOff { // 垂直起飞策略类
public:void takeOff() override;
};class LongDistanceTakeOff : public TakeOff { // 长距离起飞策略类
public:void takeOff() override;
};class SubSonicFly : public Flight { // 亚音速飞行策略类
public:void flight() override;
};class SuperSonicFly : public Flight { // 超音速飞行策略类
public:void flight() override;
};class Helicopter : public Plane { // 直升机
public:Helicopter();void takeOff() override;void flight() override;
};class AirPlane : public Plane { // 客机
public:AirPlane();void takeOff() override;void flight() override;
};class FighterPlane : public Plane { // 歼击机
public:FighterPlane();void takeOff() override;void flight() override;
};class HarrierPlane : public Plane { // 鹞式战斗机
public:HarrierPlane();void takeOff() override;void flight() override;
};#endif //DESIGNPATTERNS_MYCLASS_Hmyclass.cpp
//
// Created by yuwp on 2024/1/12.
//#include myclass.h
#include thread
#include unistd.h
#include sstreamPlane::Plane(TakeOff *takeOff, Flight *flight) {m_takeoff takeOff;m_flight flight;
}Plane::~Plane() {if (m_takeoff) {delete m_takeoff;}if (m_flight) {delete m_flight;}
}void Plane::takeOff() {if (m_takeoff) {m_takeoff-takeOff();} else {std::cout 没有设置起飞特征 std::endl;}
}void Plane::flight() {if (m_flight) {m_flight-flight();} else {std::cout 没有设置飞行特征 std::endl;}
}void Simulator::setPlane(Plane *plane) {m_plane.reset(plane);
}void Simulator::start() {if (m_plane) {m_plane-takeOff();m_plane-flight();} else {std::cout 请先设置飞机种类 std::endl;}
}void VerticalTakeOff::takeOff() {std::cout 垂直起飞 std::endl;
}void LongDistanceTakeOff::takeOff() {std::cout 长距离起飞 std::endl;
}void SubSonicFly::flight() {std::cout 亚音速飞行 std::endl;
}void SuperSonicFly::flight() {std::cout 超音速飞行 std::endl;
}Helicopter::Helicopter() : Plane(new VerticalTakeOff(), new SubSonicFly()) {}void Helicopter::takeOff() {std::cout 直升机开始起飞 std::endl;Plane::takeOff();
}void Helicopter::flight() {std::cout 直升机开始飞行 std::endl;Plane::flight();
}AirPlane::AirPlane() : Plane(new LongDistanceTakeOff(), new SubSonicFly()) {}void AirPlane::takeOff() {std::cout 客机开始起飞 std::endl;Plane::takeOff();
}void AirPlane::flight() {std::cout 客机开始飞行 std::endl;Plane::flight();
}FighterPlane::FighterPlane() : Plane(new LongDistanceTakeOff(), new SuperSonicFly()) {}void FighterPlane::takeOff() {std::cout 歼击机开始起飞 std::endl;Plane::takeOff();
}void FighterPlane::flight() {std::cout 歼击机开始飞行 std::endl;Plane::flight();
}HarrierPlane::HarrierPlane() : Plane(new VerticalTakeOff(), new SuperSonicFly()) {}void HarrierPlane::takeOff() {std::cout 鹞式战斗机开始起飞 std::endl;Plane::takeOff();
}void HarrierPlane::flight() {std::cout 鹞式战斗机开始飞行 std::endl;Plane::flight();
}main.cpp
#include iostream
#include mutex
#include myclass.hint main() {Simulator *simulator new Simulator();Plane *plane new Helicopter();simulator-setPlane(plane);simulator-start();std::cout ---------------------- std::endl;plane new AirPlane();simulator-setPlane(plane);simulator-start();std::cout ---------------------- std::endl;plane new FighterPlane();simulator-setPlane(plane);simulator-start();std::cout ---------------------- std::endl;plane new HarrierPlane();simulator-setPlane(plane);simulator-start();delete simulator;return 0;
}
