Strategy(HeadFirstb版)

README.md

@@ -43,6 +43,7 @@
 + [Template Method](https://github.com/liu-jianhao/Cpp-Design-Patterns/tree/master/Template%20Method)
 + [Observer/Event](https://github.com/liu-jianhao/Cpp-Design-Patterns/tree/master/Observer)
 + [Strategy](https://github.com/liu-jianhao/Cpp-Design-Patterns/tree/master/Strategy)
++ [Strategy(Head-First版)](https://github.com/liu-jianhao/Cpp-Design-Patterns/tree/master/Strategy-Pattern)
 ### 单一职责：
 + [Decorator](https://github.com/liu-jianhao/Cpp-Design-Patterns/tree/master/Decorator)
 + [Bridge](https://github.com/liu-jianhao/Cpp-Design-Patterns/tree/master/Bridge)

Strategy-Pattern/DecoyDuck.cpp

+#include "DecoyDuck.hpp"
+
+#include "FlyNoWay.hpp"
+#include "MuteQuack.hpp"
+
+#include <iostream>
+
+DecoyDuck::DecoyDuck() :
+    Duck(std::make_unique<FlyNoWay>(), std::make_unique<MuteQuack>()) {
+}
+
+void DecoyDuck::display() {
+    std::cout << "I'm a real decoy duck" << std::endl;
+}
+

Strategy-Pattern/DecoyDuck.hpp

+#ifndef DECOYDUCK_HPP
+#define DECOYDUCK_HPP
+
+#include "Duck.hpp"
+
+class DecoyDuck : public Duck {
+public:
+    DecoyDuck();
+
+    void display();
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/Duck.hpp

+#ifndef DUCK_HPP
+#define DUCK_HPP
+
+#include "FlyBehavior.hpp"
+#include "QuackBehavior.hpp"
+
+#include <memory>
+#include <iostream>
+
+class Duck {
+public:
+    std::unique_ptr<FlyBehavior> flyBehavior;
+    std::unique_ptr<QuackBehavior> quackBehavior;
+
+    Duck(std::unique_ptr<FlyBehavior> fb, std::unique_ptr<QuackBehavior> qb) : flyBehavior(std::move(fb)), quackBehavior(std::move(qb)) {}
+
+    virtual ~Duck(){}
+
+    // 下面两个函数使用了多态
+    void performFly(){
+        flyBehavior->fly();
+    }
+
+    void performQuack(){
+        quackBehavior->quack();
+    }
+
+    void swim(){
+        std::cout << "All ducks swim!" << std::endl;
+    }
+    virtual void display(){}
+};
+
+
+#endif
\ No newline at end of file

Strategy-Pattern/FlyBehavior.hpp

+#ifndef FLYBEHAVIOR_HPP
+#define FLYBEHAVIOR_HPP
+
+// 接口类
+class FlyBehavior {
+public:
+    virtual void fly() = 0;
+    
+    virtual ~FlyBehavior() = default;
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/FlyNoWay.hpp

+#ifndef FLYNOWAY_HPP
+#define FLYNOWAY_HPP
+
+#include "FlyBehavior.hpp"
+
+#include <iostream>
+
+class FlyNoWay : public FlyBehavior {
+public:
+    void fly() {
+        std::cout << "I can't fly" << std::endl;
+    }
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/FlyWithWings.hpp

+#ifndef FLYWITHWINGS_HPP
+#define FLYWITHWINGS_HPP
+
+#include "FlyBehavior.hpp"
+
+#include <iostream>
+
+class FlyWithWings : public FlyBehavior {
+public:
+    void fly() {
+        std::cout << "I'm flying" << std::endl;
+    }
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/Makefile

+all:
+	g++ -g -Wall ./*.cpp -o main
+
+clean:
+	rm main

Strategy-Pattern/MallardDuck.cpp

+#include "MallardDuck.hpp"
+
+#include "FlyWithWings.hpp"
+#include "Quack.hpp"
+
+#include <iostream>
+
+MallardDuck::MallardDuck() :
+    Duck(std::make_unique<FlyWithWings>(), std::make_unique<Quack>()) {
+}
+
+void MallardDuck::display() {
+    std::cout << "I'm a real mallard duck" << std::endl;
+}
+

Strategy-Pattern/MallardDuck.hpp

+#ifndef MALLARDDUCK_HPP
+#define MALLARDDUCK_HPP
+
+#include "Duck.hpp"
+
+class MallardDuck : public Duck {
+public:
+    MallardDuck();
+
+    void display();
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/MuteQuack.hpp

+#ifndef MUTEQUACK_HPP
+#define MUTEQUACK_HPP
+
+#include "QuackBehavior.hpp"
+
+#include <iostream>
+
+class MuteQuack : public QuackBehavior {
+public:
+    void quack() {
+        std::cout << "Mute Quack" << std::endl;
+    }
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/Quack.hpp

+#ifndef QUACK_HPP
+#define QUACK_HPP
+
+#include "QuackBehavior.hpp"
+
+#include <iostream>
+
+class Quack : public QuackBehavior {
+public:
+    void quack() {
+        std::cout << "Quack" << std::endl;
+    }
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/QuackBehavior.hpp

+#ifndef QUACKBEHAVIOR_HPP
+#define QUACKBEHAVIOR_HPP
+
+// 接口类
+class QuackBehavior {
+public:
+    virtual void quack() = 0;
+    
+    virtual ~QuackBehavior() = default;
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/README.md

+## ????
+
+![](https://img-blog.csdnimg.cn/20190527222242725.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlc3Ricm9va2xpdQ==,size_16,color_FFFFFF,t_70)

Strategy-Pattern/RedHeadDuck.cpp

+#include "RedHeadDuck.hpp"
+
+#include "FlyWithWings.hpp"
+#include "Quack.hpp"
+
+#include <iostream>
+
+RedHeadDuck::RedHeadDuck() :
+    Duck(std::make_unique<FlyWithWings>(), std::make_unique<Quack>()) {
+}
+
+void RedHeadDuck::display() {
+    std::cout << "I'm a real red head duck" << std::endl;
+}
+

Strategy-Pattern/RedHeadDuck.hpp

+#ifndef REDHEADDUCK_HPP
+#define REDHEADDUCK_HPP
+
+#include "Duck.hpp"
+
+class RedHeadDuck : public Duck {
+public:
+    RedHeadDuck();
+
+    void display();
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/RubberDuck.cpp

+#include "RubberDuck.hpp"
+
+#include "FlyNoWay.hpp"
+#include "Squeak.hpp"
+
+#include <iostream>
+
+RubberDuck::RubberDuck() :
+    Duck(std::make_unique<FlyNoWay>(), std::make_unique<Squeak>()) {
+}
+
+void RubberDuck::display() {
+    std::cout << "I'm a real rubber duck" << std::endl;
+}
+

Strategy-Pattern/RubberDuck.hpp

+#ifndef RUBBERDUCK_HPP
+#define RUBBERDUCK_HPP
+
+#include "Duck.hpp"
+
+class RubberDuck : public Duck {
+public:
+    RubberDuck();
+
+    void display();
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/Squeak.hpp

+#ifndef SQUEAK_HPP
+#define SQUEAK_HPP
+
+#include "QuackBehavior.hpp"
+
+#include <iostream>
+
+class Squeak : public QuackBehavior {
+public:
+    void quack() {
+        std::cout << "Squeak" << std::endl;
+    }
+};
+
+#endif
\ No newline at end of file

Strategy-Pattern/main.cpp

+#include "MallardDuck.hpp"
+#include "RedHeadDuck.hpp"
+#include "DecoyDuck.hpp"
+#include "RubberDuck.hpp"
+
+#include <iostream>
+
+int main() {
+    MallardDuck mallard;
+    mallard.display();
+    mallard.swim();
+    mallard.performQuack();
+    mallard.performFly();
+    
+    std::cout << std::endl;
+    
+    RedHeadDuck redHead;
+    redHead.display();
+    redHead.swim();
+    redHead.performQuack();
+    redHead.performFly();
+    
+    std::cout << std::endl;
+
+    DecoyDuck decoy;
+    decoy.display();
+    decoy.swim();
+    decoy.performQuack();
+    decoy.performFly();
+    
+    std::cout << std::endl;
+
+    RubberDuck rubberDuckie;
+    rubberDuckie.display();
+    rubberDuckie.swim();
+    rubberDuckie.performQuack();
+    rubberDuckie.performFly();
+    
+    std::cout << std::endl;
+
+    return 0;
+}
+