设计模式<c++> （1）策略模式

标签：设计模式 策略 void 模式 Code Duck include public View

一、定义

　　策略模式定义了算法族，分别封装起来，让他们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。

二、使用场景

　　客户需要很多种鸭子。

　　要求：

　　　　1.每种鸭子都要会游泳。

　　　　2.每种鸭子有叫和飞的行为。

　　　　3.鸭子的叫和飞的行为可以在使用时动态的设置。

　　思考：有绿头鸭、红头鸭、橡皮鸭、木头鸭。。。可能有N多种鸭子，我们如何设计，来满足上面的要求呢？

三、客户使用代码实现

　　

我们可能封装了18个飞的算法、22个叫的算法，每种类型的算法之间可以相互替换而不影响其他的功能。如上，可以随便改鸭子的飞和叫的行为（算法）。这是策略模式牛逼之处。

四、具体实现

　　1）项目结构

　　　　

　　2）鸭子飞的行为（算法）相关

　　FlyBehavior.h

1 #pragma once
2 #include <iostream>
3 class FlyBehavior
4 {
5 public:
6     virtual void fly()=0;
7 };

View Code

　　FlyNoWay.h

#pragma once
#include "FlyBehavior.h"
class FlyNoWay :
    public FlyBehavior
{
    void fly() override;
};

View Code

　　FlyNoWay.cpp

#include "FlyNoWay.h"
void FlyNoWay::fly() {
    std::cout << "不会飞!" << std::endl;
}

View Code

　　FlyRocketPowered.h

#pragma once
#include "FlyBehavior.h"
class FlyRocketPowered :
    public FlyBehavior
{
    void fly() override;
};

View Code

　　FlyRocketPowered.cpp

#include "FlyRocketPowered.h"

void FlyRocketPowered::fly() {
    std::cout << "用火箭动力飞!" << std::endl;
}

View Code

　　FlyWithWings.h

#pragma once
#include "FlyBehavior.h"
class FlyWithWings :
    public FlyBehavior
{
    void fly() override;
};

View Code

　　FlyWithWings.cpp

#include "FlyWithWings.h"
void FlyWithWings::fly() {
    std::cout << "用翅膀飞!" << std::endl;
}

View Code

 　　3）鸭子叫的行为（算法）相关

　　QuackBehavior.h

#pragma once
#include <iostream>
class QuackBehavior
{
public:
    virtual void quack()=0;
};

View Code

　　QuackMute.h

#pragma once
#include "QuackBehavior.h"
class QuackMute :
    public QuackBehavior
{
    void quack() override;
};

View Code

　　QuackMute.cpp

#include "QuackMute.h"
void QuackMute::quack() {
    std::cout << "<嘘~~ 我不发声>" << std::endl;
}

View Code

　　QuackOnly.h

#pragma once
#include "QuackBehavior.h"
class QuackOnly :
    public QuackBehavior
{
    void quack() override;
};

View Code

　　QuackOnly.cpp

#include "QuackOnly.h"

void QuackOnly::quack(){
    std::cout << "呱呱呱~~" <<std::endl;
}

View Code

　　4）鸭子类

　　Duck.h

#pragma once
#include <iostream>
#include "FlyBehavior.h"
#include "QuackBehavior.h"

class Duck
{
public:
    FlyBehavior* m_pFlyBehavior;
    QuackBehavior *m_pQuackBehavior;

    virtual void display()=0;
    void performFly();
    void performQuack();
    void swim();
    void setFlyBehavior(FlyBehavior *);
    void setQuackBehavior(QuackBehavior *);
};

　　Duck.cpp

#include "Duck.h"
void Duck::performFly() {
    m_pFlyBehavior->fly();
}
void Duck::performQuack() {
    m_pQuackBehavior->quack();
    }
void Duck::swim() {
    std::cout << "所有的鸭子都可以游泳，就在Duck基类中." << std::endl;
}
void Duck::setFlyBehavior(FlyBehavior* behavior) {
    m_pFlyBehavior = behavior;
}
void Duck::setQuackBehavior(QuackBehavior* behavior) {
    m_pQuackBehavior = behavior;
}

　　DuckMallard.h （绿头鸭）

#pragma once
#include "Duck.h"
#include "FlyWithWings.h"
class DuckMallard :
    public Duck
{
public:
    DuckMallard();
     void display() override;
};

　　DuckMallard.cpp

#include "DuckMallard.h"
#include "QuackOnly.h"

DuckMallard::DuckMallard(){
    m_pFlyBehavior = new FlyWithWings();
    m_pQuackBehavior = new QuackOnly();
 }

void DuckMallard::display(){
    std::cout << "我是绿头鸭!" << std::endl;
}

　　DuckModel.h（模型鸭）

#pragma once
#include "Duck.h"
class DuckModel :
    public Duck
{
public:
    DuckModel();
    void display() override;
};

　　DuckModel.cpp

#include "DuckModel.h"
#include "FlyNoWay.h"
#include "QuackMute.h"
DuckModel::DuckModel() {
    m_pFlyBehavior = new FlyNoWay();
    m_pQuackBehavior = new QuackMute();

}
void DuckModel::display() {
    std::cout << "我是模型鸭！" << std::endl;

}

标签：设计模式,策略,void,模式,Code,Duck,include,public,View
From： https://www.cnblogs.com/airduce/p/17923288.html