策略模式(C++版)

情景介绍

假设我们实现了一个鸭子类（Duck Class），起初，每个鸭子都会飞和叫。但是某一天，你收到了一个需求，需要添加一个模型鸭（ModelDuck），这个模型鸭不会飞也不会叫但同样属于鸭子的一种。这样的问题使抽象一个鸭子接口，并实现飞和叫方法或者将这两个方法设计为抽象的方式不太适用，都会在有新需求的时候修改源代码，此时我们可以通过策略模式解决这一问题。

代码详情

鸭子接口

class Duck {
    public:
        Duck() = default;

        explicit Duck(const std::shared_ptr<FlyBehavior> &flyBehavior,
                      const std::shared_ptr<QuackBehavior> &quackBehavior)
                : flyBehavior(flyBehavior), quackBehavior(quackBehavior) {}
                
        virtual ~Duck() = default;

        //动态设置
        void setFlyBehavior(const std::shared_ptr<FlyBehavior> &flyBehavior) {
            Duck::flyBehavior = flyBehavior;
        }

        void setQuackBehavior(const std::shared_ptr<QuackBehavior> &quackBehavior) {
            Duck::quackBehavior = quackBehavior;
        }
    
        //通过委托组件的方式，实现对应方法
        void performFly() {
            flyBehavior->fly();
        }

        void performQuack() {
            quackBehavior->quack();
        }

        virtual void display() = 0;

    private:
        //使用组合的方式 在内部保存了FlyBehavior和QuackBehavior的智能指针
        //使用智能指针是为了可以动态加载
        std::shared_ptr<FlyBehavior> flyBehavior{nullptr};
        std::shared_ptr<QuackBehavior> quackBehavior{nullptr};
    };

    class DecoyDuck : public Duck {
    public:
        DecoyDuck() {
            setFlyBehavior(std::make_shared<FlyNoWay>());
            setQuackBehavior(std::make_shared<MuteQuack>());
        }

        void display() override {
            std::cout << "I am a duck Decoy" << std::endl;
        }
    };

    class MallardDuck : public Duck {
    public:
        MallardDuck() {
            setFlyBehavior(std::make_shared<FlyWithWings>());
            setQuackBehavior(std::make_shared<Quack>());
        }

        void display() override {
            std::cout << "I am a real Mallard duck" << std::endl;
        }
    };

    class ModelDuck : public Duck {
    public:
        ModelDuck() {
            setFlyBehavior(std::make_shared<FlyNoWay>());
            setQuackBehavior(std::make_shared<Quack>());
        }

        void display() override {
            std::cout << "I am a model duck" << std::endl;
        }
    };

    class RedHeadDuck : public Duck {
    public:
        RedHeadDuck() {
            setFlyBehavior(std::make_shared<FlyWithWings>());
            setQuackBehavior(std::make_shared<Quack>());
        }

        void display() override {
            std::cout << "I am a real Red Headed duck" << std::endl;
        }
    };

    class RubberDuck : public Duck {
    public:
        RubberDuck() {
            setFlyBehavior(std::make_shared<FlyNoWay>());
            setQuackBehavior(std::make_shared<Squeak>());
        }

        void display() override {
            std::cout << "I am a rubber duckie" << std::endl;

        }
    };

算法族定义

    //*********飞行为********
    class FlyBehavior {
    public:
        //定义为pure virtual函数，子类应有自己的实现
        virtual void fly() = 0;

        //只是为了遵守 基类的析构函数应为virtual 
        virtual ~FlyBehavior() = default;
    };

    class FlyNoWay : public FlyBehavior {
    public:
        void fly() override {
            std::cout << "I can not fly" << std::endl;
        }
    };

    class FlyRocketPowered : public FlyBehavior {
    public:
        void fly() override {
            std::cout << "I am flying with a rocket" << std::endl;
        }
    };

    class FlyWithWings : public FlyBehavior {
    public:
        void fly() override {
            std::cout << "I am flying " << std::endl;
        }
    };



    //*****叫行为********
    class QuackBehavior {
    public:
        virtual void quack() = 0;

        virtual ~QuackBehavior() = default;
    };

    class FakeQuack : public QuackBehavior {
    public:
        void quack() override {
            std::cout << "Qwak" << std::endl;

        }
    };

    class MuteQuack : public QuackBehavior {
    public:
        void quack() override {
            std::cout << "<<Silence>>" << std::endl;
        }
    };

    class Quack : public QuackBehavior {
    public:
        void quack() override {
            std::cout << "Quack" << std::endl;
        }
    };

    class Squeak : public QuackBehavior {
    public:
        void quack() override {
            std::cout << "Squeak" << std::endl;
        }
    };

示例

void strategyTest() {
    Strategy::MallardDuck mallardDuck;
    Strategy::RubberDuck rubberDuck;
    Strategy::DecoyDuck decoyDuck;

    Strategy::ModelDuck modelDuck;

    mallardDuck.performQuack();
    rubberDuck.performQuack();
    decoyDuck.performQuack();
    modelDuck.performQuack();
    //在运行时设置行为
    modelDuck.setQuackBehavior(std::make_shared<Strategy::FakeQuack>());
    modelDuck.performQuack();
}

总结

整个策略模式的架构如下：

将会改变的Fly和Quack部分抽象出来，单独实现。根据不同鸭子的需求可设置不同的行为。

策略模式

策略模式定义了算法族（一组fly行为），分别封装起来，让它们之间可以相互替换（因为实现了同一个接口），此模式让算法的变化独立于使用算法的客户；

设计原则

1. 找到程序中变化的地方，封装变化；

2. 多用组合，少用继承；

3. 针对接口编程，不针对实现编程：

void setFlyBehavior(const std::shared_ptr<FlyBehavior> &flyBehavior) {
            Duck::flyBehavior = flyBehavior;
}

想要实现这一特性，势必需要使用大量指针，为了减少内存管理问题，大量使用智能指针（后面学习也会如此）；