C++ 筹划模式——战略模式

战略模式

战略模式是一种举动筹划模式，它界说了一系列算法，将每一个算法封装起来，并使它们可以互换。战略模式让算法的变革独立于使用算法的客户。
引入"战略“筹划模式的界说：界说一些列算法类（战略类），将每个算法封装起来，让他们可以相互更换。换句话说，战略模式通常把一系列算法封装到一系列具体战略类中作为抽象战略类的字类，然后根据现实须要实用这些字类。
告急构成部分

• 战略接口 (Strategy)：界说一个同一的接口，声明全部支持的算法（战略）的方法。客户端通过这个接口调用具体战略。
  
• 具体战略类 (Concrete Strategy)：实现战略接口，界说具体的算法或举动。每个具体战略类实现差别的算法。
  
• 上下文类 (Context)：持有对战略接口的引用，负责调用具体战略的方法。上下文类可以在运行时动态地切换战略。
  

例一：渐渐重构并引入战略模式

假设我们须要实现差别的排序算法（如冒泡排序和快速排序）。最初的实现大概是重复的代码。渐渐重构的过程如下：
第一步：初始实现

为每种排序算法编写独立的处置惩罚逻辑：

1. #include <iostream>
2. #include <vector>
4. void bubbleSort(std::vector<int>& arr) {
5.     for (size_t i = 0; i < arr.size() - 1; ++i) {
6.         for (size_t j = 0; j < arr.size() - i - 1; ++j) {
7.             if (arr[j] > arr[j + 1]) {
8.                 std::swap(arr[j], arr[j + 1]);
9.             }
10.         }
11.     }
12. }
14. void quickSort(std::vector<int>& arr, int low, int high) {
15.     if (low < high) {
16.         int pivot = arr[high];
17.         int i = low - 1;
18.         for (int j = low; j < high; ++j) {
19.             if (arr[j] < pivot) {
20.                 ++i;
21.                 std::swap(arr[i], arr[j]);
22.             }
23.         }
24.         std::swap(arr[i + 1], arr[high]);
25.         quickSort(arr, low, i);
26.         quickSort(arr, i + 2, high);
27.     }
28. }
30. int main() {
31.     std::vector<int> data = {5, 3, 8, 6, 2};
33.     bubbleSort(data);
34.     // 或者使用 quickSort(data, 0, data.size() - 1);
36.     return 0;
37. }

复制代码

第二步：提取共性并实现战略接口

辨认出排序的共性步调，并创建一个战略接口 SortStrategy，界说排序方法：

1. class SortStrategy {
2. public:
3.     virtual void sort(std::vector<int>& arr) = 0; // 策略接口
4. };

复制代码

第三步：实现具体战略类

为每种排序算法实现具体战略类，重写排序方法：

1. class BubbleSort : public SortStrategy {
2. public:
3.     void sort(std::vector<int>& arr) override {
4.         for (size_t i = 0; i < arr.size() - 1; ++i) {
5.             for (size_t j = 0; j < arr.size() - i - 1; ++j) {
6.                 if (arr[j] > arr[j + 1]) {
7.                     std::swap(arr[j], arr[j + 1]);
8.                 }
9.             }
10.         }
11.     }
12. };
14. class QuickSort : public SortStrategy {
15. public:
16.     void sort(std::vector<int>& arr) override {
17.         quickSort(arr, 0, arr.size() - 1);
18.     }
20. private:
21.     void quickSort(std::vector<int>& arr, int low, int high) {
22.         if (low < high) {
23.             int pivot = arr[high];
24.             int i = low - 1;
25.             for (int j = low; j < high; ++j) {
26.                 if (arr[j] < pivot) {
27.                     ++i;
28.                     std::swap(arr[i], arr[j]);
29.                 }
30.             }
31.             std::swap(arr[i + 1], arr[high]);
32.             quickSort(arr, low, i);
33.             quickSort(arr, i + 2, high);
34.         }
35.     }
36. };

复制代码

第四步：实现上下文类

创建一个上下文类 Sorter，用于使用战略：

1. class Sorter {
2. private:
3.     SortStrategy* strategy;
5. public:
6.     Sorter(SortStrategy* strategy) : strategy(strategy) {}
8.     void setStrategy(SortStrategy* strategy) {
9.         this->strategy = strategy;
10.     }
12.     void sort(std::vector<int>& arr) {
13.         strategy->sort(arr);
14.     }
15. };

复制代码

战略模式 UML 图

战略模式的 UML 图剖析

• 上下文类 (Context)：
  
  
  
  • Sorter 类：它是上下文类，负责使用战略并持有战略的引用。Sorter 类通过 setStrategy 方法设置具体的排序战略，并通过 sort 方法调用该战略举行排序。
    
  
  
• 抽象战略类 (Strategy)：
  
  
  
  • SortStrategy 类：这是战略接口，界说了一个公共方法 sort，该方法由具体战略类实现。它确保全部具体战略类都有同等的接口。
    
  
  
• 具体战略类 (Concrete Strategy)：
  
  
  
  • BubbleSort 类：实现了 SortStrategy 接口，提供了冒泡排序的具体实现。
    
  • QuickSort 类：实现了 SortStrategy 接口，提供了快速排序的具体实现。
    
  
  

例二：渐渐重构并引入战略模式

第一步：初始实现

起首，从一个简朴的实现开始，此中战斗者类直接实现道具使用逻辑。

1. #include <iostream>
2. using namespace std;
4. class Fighter {
5. public:
6.     Fighter(int life) : m_life(life) {}
7.    
8.     void UseBXD() { // 使用补血丹
9.         m_life += 200;
10.         cout << "使用补血丹，生命值增加200。" << endl;
11.     }
13.     void UseDHD() { // 使用大还丹
14.         m_life += 300;
15.         cout << "使用大还丹，生命值增加300。" << endl;
16.     }
18.     void UseSHD() { // 使用守护丹
19.         m_life += 500;
20.         cout << "使用守护丹，生命值增加500。" << endl;
21.     }
23.     int GetLife() {
24.         return m_life;
25.     }
27. private:
28.     int m_life;
29. };
31. int main() {
32.     Fighter warrior(1000);
33.     cout << "初始生命值：" << warrior.GetLife() << endl;
35.     warrior.UseDHD();
36.     cout << "当前生命值：" << warrior.GetLife() << endl;
38.     warrior.UseBXD();
39.     cout << "当前生命值：" << warrior.GetLife() << endl;
41.     warrior.UseSHD();
42.     cout << "当前生命值：" << warrior.GetLife() << endl;
44.     return 0;
45. }

复制代码

第二步：提取共性并实现战略接口

在该实现中，Fighter 类包罗全部道具使用的逻辑。可以提取出道具使用的共性，界说一个道具战略接口。

1. class ItemStrategy {
2. public:
3.     virtual void UseItem(Fighter* fighter) = 0;
4.     virtual ~ItemStrategy() {}
5. };

复制代码

第三步：实现具体战略类

为每种道具创建具体的战略类，实现 ItemStrategy 接口。

• 补血丹战略类：
  

1. class ItemStrategy_BXD : public ItemStrategy {
2. public:
3.     void UseItem(Fighter* mainobj) override {
4.         mainobj->SetLife(mainobj->GetLife() + 200); // 补充200点生命值
5.     }
6. };

复制代码

• 大还丹战略类：
  

1. class ItemStrategy_DHD : public ItemStrategy {
2. public:
3.     void UseItem(Fighter* mainobj) override {
4.         mainobj->SetLife(mainobj->GetLife() + 300); // 补充300点生命值
5.     }
6. };

复制代码

• 守卫丹战略类：
  

1. class ItemStrategy_SHD : public ItemStrategy {
2. public:
3.     void UseItem(Fighter* mainobj) override {
4.         mainobj->SetLife(mainobj->GetLife() + 500); // 补充500点生命值
5.     }
6. };

复制代码

第四步：实现上下文类：

在 Fighter 类中添加设置道具战略的方法，并移除具体的道具使用逻辑，并界说战斗者的子类（可以不须要字类）。

1. class Fighter {
2. public:
3.     Fighter(int life) : m_life(life), itemStrategy(nullptr) {}
5.     void SetItemStrategy(ItemStrategy* strategy) {
6.         itemStrategy = strategy;
7.     }
9.     void UseItem() {
10.         if (itemStrategy) {
11.             itemStrategy->UseItem(this);
12.         }
13.     }
15.     int GetLife() {
16.         return m_life;
17.     }
19.     void SetLife(int life) {
20.         m_life = life;
21.     }
23. private:
24.     int m_life;
25.     ItemStrategy* itemStrategy;
26. };
27. class F_Warrior : public Fighter {
28. public:
29.     F_Warrior(int life, int magic, int attack)
30.         : Fighter(life, magic, attack) {}
31.     // 其他战士特有的方法
32. };
34. class F_Mage : public Fighter {
35. public:
36.     F_Mage(int life, int magic, int attack)
37.         : Fighter(life, magic, attack) {}
38.     // 其他法师特有的方法
39. };

复制代码

第五步：更新主函数

更新主函数以使用新的战略模式布局。

1. int main() {
2.     Fighter warrior(1000);
3.     cout << "初始生命值：" << warrior.GetLife() << endl;
5.     ItemStrategy* strategy1 = new ItemStrategy_DHD();
6.     warrior.SetItemStrategy(strategy1);
7.     warrior.UseItem();
8.     cout << "当前生命值：" << warrior.GetLife() << endl;
10.     ItemStrategy* strategy2 = new ItemStrategy_BXD();
11.     warrior.SetItemStrategy(strategy2);
12.     warrior.UseItem();
13.     cout << "当前生命值：" << warrior.GetLife() << endl;
15.     ItemStrategy* strategy3 = new ItemStrategy_SHD();
16.     warrior.SetItemStrategy(strategy3);
17.     warrior.UseItem();
18.     cout << "当前生命值：" << warrior.GetLife() << endl;
20.     delete strategy1;
21.     delete strategy2;
22.     delete strategy3;
24.     return 0;
25. }

复制代码

战略模式 UML 图

战略模式的 UML 图剖析

• Context(情况类)：也叫上下文类，是使用算法的脚色，该类中维持着一个对抽象战略类的指针或引用。这里指Fighter类。
  
• Stategy(抽象战略类)：界说所支持的算法的公共接口，是全部战略类的父类。这里指 ItemStrategy 类。
  
• ConcreteStrategy(具体战略类)：抽象战略类的子类，实现抽象战略类中声明的接口。这里指ItemStrategy_BXD、ItemStrategy_DHD、ItemStrategy_SHD类。
  

战略模式优缺点

优点：

• 机动性：可以在运行时选择差别的战略，增长了步伐的机动性和可扩展性。
  
• 开放-关闭原则：新的战略可以通过实现战略接口而无需修改现有代码，符合开放-关闭原则。
  
• 清楚的职责分离：将差别的算法封装在差别的类中，使得代码更加清楚，易于维护。
  
• 淘汰条件语句：制止了使用大量的条件语句（如 if-else 或 switch），使代码布局更加简便。
  
• 易于测试：每个战略类可以独立测试，便于单元测试和调试。
  

缺点：

• 类的数目增长：每种战略都须要一个新的类，大概导致类的数目增长，增长了体系的复杂性。
  
• 客户端必须相识全部战略：客户端须要相识全部可用的战略，以便选择符合的战略，这大概增长了使用的复杂性。
  
• 性能开销：在某些情况下，频仍地创建和烧毁战略对象大概导致性能开销。
  
• 不得当简朴的算法：对于简朴的算法，使用战略模式大概显得过于复杂，增长了不须要的抽象。
  

战略模式实用场景

• 多种算法：当有多个算法可以选择时，战略模式可以将它们封装起来，方便切换。
  
• 制止条件语句：当使用大量条件语句来选择算法时，可以使用战略模式来简化代码布局。
  
• 动态选择算法：当须要在运行时选择算法时，战略模式提供了机动性。
  
• 算法复用：当多个类须要使用同一算法时，可以将算法封装成战略类，促进代码复用。
  

例一的完备代码

以下是完备的实当代码：

1. #include <iostream>#include <vector>// 战略接口class SortStrategy{public:    virtual void sort(std::vector<int>& arr) = 0; // 战略接口};// 具体战略：冒泡排序class BubbleSort : public SortStrategy {public:    void sort(std::vector<int>& arr) override {        for (size_t i = 0; i < arr.size() - 1; ++i) {            for (size_t j = 0; j < arr.size() - i - 1; ++j) {                if (arr[j] > arr[j + 1]) {                    std::swap(arr[j], arr[j + 1]);                }            }        }    }};// 具体战略：快速排序class QuickSort : public SortStrategy {public:    void sort(std::vector<int>& arr) override {        quickSort(arr, 0, arr.size() - 1);    }private:    void quickSort(std::vector<int>& arr, int low, int high) {        if (low < high) {            int pivot = arr[high];            int i = low - 1;            for (int j = low; j < high; ++j) {                if (arr[j] < pivot) {                    ++i;                    std::swap(arr[i], arr[j]);                }            }            std::swap(arr[i + 1], arr[high]);            quickSort(arr, low, i);            quickSort(arr, i + 2, high);        }    }};// 上下文类class Sorter {
2. private:
3.     SortStrategy* strategy;
5. public:
6.     Sorter(SortStrategy* strategy) : strategy(strategy) {}
8.     void setStrategy(SortStrategy* strategy) {
9.         this->strategy = strategy;
10.     }
12.     void sort(std::vector<int>& arr) {
13.         strategy->sort(arr);
14.     }
15. };
16. // 示例用法int main() {    std::vector<int> data = {5, 3, 8, 6, 2};    Sorter sorter(new BubbleSort());    sorter.sort(data); // 使用冒泡排序    sorter.setStrategy(new QuickSort());    sorter.sort(data); // 使用快速排序    return 0;}

复制代码

例二的完备代码

1. #include <iostream>
2. using namespace std;
4. class Fighter; // 类前向声明
6. //道具策略类的父类
7. class ItemStrategy
8. {
9. public:
10.     virtual void UseItem(Fighter* mainobj) = 0;
11.     virtual ~ItemStrategy() {}
12. };
14. //战斗者父类
15. class Fighter
16. {
17. public:
18.     Fighter(int life, int magic, int attack) :m_life(life), m_magic(magic), m_attack(attack) {}
19.     virtual ~Fighter() {}
21. public:
22.     void SetItemStrategy(ItemStrategy* strategy) //设置道具使用的策略
23.     {
24.         itemstrategy = strategy;
25.     }
26.     void UseItem() //使用道具（吃药）
27.     {
28.         itemstrategy->UseItem(this);
29.     }
30.     int  GetLife() //获取人物生命值
31.     {
32.         return m_life;
33.     }
34.     void SetLife(int life) //设置人物生命值
35.     {
36.         m_life = life;
37.     }
39. private:
40.     ItemStrategy* itemstrategy = nullptr; //C++11中支持这样初始化
42. protected:
43.     int m_life;
44.     int m_magic;
45.     int m_attack;
46. };
48. //“战士”类，父类为Fighter
49. class F_Warrior :public Fighter
50. {
51. public:
52.     F_Warrior(int life, int magic, int attack) :Fighter(life, magic, attack) {}
53. };
55. //“法师”类，父类为Fighter
56. class F_Mage :public Fighter
57. {
58. public:
59.     F_Mage(int life, int magic, int attack) :Fighter(life, magic, attack) {}
60. };
62. //补血丹策略类
63. class ItemStrategy_BXD : public ItemStrategy
64. {
65. public:
66.     virtual void UseItem(Fighter* mainobj)
67.     {
68.         mainobj->SetLife(mainobj->GetLife() + 200); //补充200点生命值
69.         cout << "使用补血丹，生命值增加200。" << endl;
70.     }
71. };
73. //大还丹策略类
74. class ItemStrategy_DHD : public ItemStrategy
75. {
76. public:
77.     virtual void UseItem(Fighter* mainobj)
78.     {
79.         mainobj->SetLife(mainobj->GetLife() + 300); //补充300点生命值
80.         cout << "使用大还丹，生命值增加300。" << endl;
81.     }
82. };
84. //守护丹策略类
85. class ItemStrategy_SHD : public ItemStrategy
86. {
87. public:
88.     virtual void UseItem(Fighter* mainobj)
89.     {
90.         mainobj->SetLife(mainobj->GetLife() + 500); //补充500点生命值
91.         cout << "使用守护丹，生命值增加500。" << endl;
92.     }
93. };
95. int main()
96. {
97.     // 创建战斗者对象
98.     Fighter* prole_war = new Fighter(1000, 0, 200);
100.     // 打印初始生命值
101.     cout << "初始生命值：" << prole_war->GetLife() << endl;
103.     // 使用大还丹
104.     ItemStrategy* strategy1 = new ItemStrategy_DHD();
105.     prole_war->SetItemStrategy(strategy1);
106.     prole_war->UseItem();
107.     cout << "当前生命值：" << prole_war->GetLife() << endl;
109.     // 使用补血丹
110.     ItemStrategy* strategy2 = new ItemStrategy_BXD();
111.     prole_war->SetItemStrategy(strategy2);
112.     prole_war->UseItem();
113.     cout << "当前生命值：" << prole_war->GetLife() << endl;
115.     // 使用守护丹
116.     ItemStrategy* strategy3 = new ItemStrategy_SHD();
117.     prole_war->SetItemStrategy(strategy3);
118.     prole_war->UseItem();
119.     cout << "当前生命值：" << prole_war->GetLife() << endl;
121.     // 释放资源
122.     delete strategy1;
123.     delete strategy2;
124.     delete strategy3;
125.     delete prole_war;
126.    
127.     F_Mage mage(800, 300, 100);
128.     cout << "法师初始生命值：" << mage.GetLife() << endl;
130.     // 可以为法师设置道具策略并使用
131.     // ...
133.     return 0;
134. }

复制代码