程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> 深刻懂得C++之戰略形式

深刻懂得C++之戰略形式

編輯：關於C++

深刻懂得C++之戰略形式。本站提示廣大學習愛好者：（深刻懂得C++之戰略形式）文章只能為提供參考，不一定能成為您想要的結果。以下是深刻懂得C++之戰略形式正文

1 會飛的鴨子

Duck 基類，包括兩個成員函數 (swim, display)；派生類 MallardDuck，RedheadDuck 和 RubberDuck，各自重寫繼續自基類的 display 成員函數

class Duck {
public:
  void swim();
  virtual void display();
};

class MallardDuck : public Duck {
public:
  void display(); // adding virtual is OK but not necessary
};

class RedheadDuck ...

如今請求，為鴨子增長會飛的技巧 -- fly，那末應當若何設計呢？

1.1 繼續

斟酌到並不是一切的鴨子都邑飛，可在 Duck 中加個通俗虛函數 fly，則“會飛”的派生類繼續 fly 的一個缺省完成，而“不會飛”的派生類重寫 fly 的完成

void Duck::fly() { std::cout << "I am flying !" << std::endl; }

void RubberDuck::fly() { std::cout << "I cannot fly !" << std::endl; }

1.2 接口

現實上，應用普通虛函數來完成多態並不是良策，在前文 C++11 之 override 症結字中的 “1.2 普通虛函數” 曾經有所說明，經常使用的取代辦法是 “純虛函數 + 缺省完成”，

行將 fly 在基類中聲明為純虛函數，同時寫一個缺省完成

由於是純虛函數，所以只要“接口”會被繼續，而缺省的“完成”卻不會被繼續，能否挪用基類裡 fly 的缺省完成，則取決於派生類裡重寫的 fly 函數

void MallardDuck::fly() { Duck::fly(); } 
void RedheadDuck::fly() { Duck::fly(); }

1.3 設計形式

到今朝為止，並沒有應用設計形式，但成績看上去曾經被處理了，現實上應用或不應用設計形式，取決於現實需求，也取決於開辟者

<Design Patterns> 中，關於戰略形式的實用情形，以下所示：

1) many related classes differ only in their behavior

2) you need different variants of an algorithm

3) an algorithm uses data that clients shouldn't know about

4) a class defines many behaviors, and these appear as multiple conditional statements in its operations

明顯，鴨子的各個派生類屬於 “related classes”，症結就在於“飛”這個行動，假如只是將“飛”的行動，簡略劃分為“會飛”和“不會飛”，則不應用設計形式完整可以

假如“飛翔方法”，跟著派生類的增多，至多會有幾十種；或許視“飛翔方法”為一種算法，今後還會赓續改良；再或“飛翔方法”作為封裝算法，供給給第三方應用。

那末此時，設計形式的價值就表現出來了 -- 易復用，易擴大，易保護。

而第 4) 種實用情形，多見於重構當中 -- "WordStr Type Code with State/Strategy"

2 設計准繩

在引出戰略形式之前，先來看面向對象的三個設計准繩

1) 隔離變更：identify what varies and separate them from what stays the same

Duck 基類中，很顯著“飛翔方法“是變更的，因而把 fly 擇出來，和殘剩不變的分離隔來

2) 編程到接口：program to an interface, not an implementation

分出 fly 以後，將其封裝為一個接口，外面完成各類分歧的“飛翔方法” (一系列”算法“)，添加或修正算法都在這個接口外面停止。“接口”對應於 C++ 就是籠統基類，

行將“飛翔方法”封裝為 FlyBehavior 類，該類中聲明 fly 成員函數為純虛函數

class FlyBehavior {
public:
  virtual void fly() = 0;
};

class FlyWithWings : public FlyBehavior {
public:
  virtual void fly();
};

class FlyNoWay ...class FlyWithRocket ...

詳細完成各類分歧的算法 -- “飛翔方法”，以下所示：

void FlyWithWings::fly() { std::cout << "I am flying !" << std::endl; }

void FlyNoWay::fly() { std::cout << "I cannot fly !" << std::endl; }

void FlyWithRocket::fly() { std::cout << "I am flying with a rocket !" << std::endl; }

3) 復合 > 繼續：favor composition (has-a) over inheritance (is-a)

<Effective C++> 條目 32 中提到，私有繼續等於“is-a”，而條目 38 則說起 Composition (復合或組合) 的一個寄義是 “has-a”。是以，可以在 Duck 基類中，

聲明 FlyBehavior 類型的指針，如斯，只需經由過程指針 _pfB 即可挪用響應的”算法“ -- ”飛翔方法“

class Duck {
public：
  ...
private:
  FlyBehavior* _pfB; // 或 std::shared_ptr<FlyBehavior> _pfB;
};

3 戰略形式

3.1 內容

即使不懂設計形式，只要嚴厲依照下面的三個設計准繩，則最初的設計思緒也會和戰略形式相似，能夠只是一些纖細處的差異

上面來看戰略形式的詳細內容和構造圖：

Defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently

from clients that use it.

Context 指向 Strategy (由指針完成)；Context 經由過程 Strategy 接口，挪用一系列算法；ConcreteStrategy 則完成了一系列詳細的算法

3.2 智能指針

上例中，戰略形式的“接口” 對應於籠統基類 FlyBehavior，“算法完成”分離對應派生類 FlyWithWings, FlyNoWay, FlyWithRocket，“援用”對應 _pfB 指針

為了簡化內存治理，可以將 _pfB 聲明為一個“智能指針”，同時在 Duck 類的結構函數中，初始化該“智能指針”

Duck::Duck(std::shared_ptr<FlyBehavior> pflyBehavior) : _pfB(pflyBehavior) {}

直不雅上看， Duck 對應於 Context，但 Duck 基類其實不直接經由過程 FlyBehavior 接口來挪用各類“飛翔方法” -- 即“算法”，現實是其派生類 MallardDuck，RedheadDuck 和RubberDuck，如許，就須要在各個派生類的結構函數中，初始化 _pfB

MallardDuck::MallardDuck(std::shared_ptr<FlyBehavior> pflyBehavior) : Duck(pflyBehavior) {}

然後，在 Duck 基類中，經由過程指針 _pfB，完成了對 fly 的挪用

void Duck::performFly()
{
  _pfB->fly();
}

除在結構函數中初始化 _pfB 外，還可在 Duck 類中，界說一個 setFlyBehavior 成員函數，靜態的設置“飛翔方法”

void Duck::setFlyBehavior(std::shared_ptr<FlyBehavior> pflyBehavior)
{
  _pfB = pflyBehavior;
}

最初，main 函數以下：

void main()
{
  shared_ptr<FlyBehavior> pfWings = make_shared<FlyWithWings>();
  shared_ptr<FlyBehavior> pfRocket = make_shared<FlyWithRocket>();

  // fly with wings
  shared_ptr<Duck> pDuck = make_shared<MallardDuck>(pfWings);
  pDuck->performFly();

  // fly with a rocket
  pDuck->setFlyBehavior(pfRocket);
  pDuck->performFly();
}

小結：

1) 面向對象的三個設計准繩：隔離變更，編程到接口，復合 > 繼續

2) 戰略形式重要觸及的是“一系列算法“，熟習其實用的四種情形

參考材料：

<年夜話設計形式> 第二章

<Head First Design Patterns> chapter 1

<Effective C++> item 32, item 38

<Design Paterns> Strategy

<Refactoring> chapter 8

以上這篇深刻懂得C++之戰略形式就是小編分享給年夜家的全體內容了，願望能給年夜家一個參考，也願望年夜家多多支撐。