2. 程式人生 > >【設計模式】商場促銷 -- 策略模式

【設計模式】商場促銷 -- 策略模式

阿新 • • 發佈：2019-01-04

一，概念

        策略模式定義了一系列的演算法，並將每一個演算法封裝起來，而且使它們還可以相互替換。策略模式讓演算法獨立於使用它的客戶而獨立變化。

二，策略模式的組成

　　 1）抽象策略角色： 策略類，通常由一個介面或者抽象類實現。 　　 2）具體策略角色：包裝了相關的演算法和行為。

　　 3）環境角色：持有一個策略類的引用，最終給客戶端呼叫。

三，補充C++知識

類物件的構造順序是這樣的：
  1.分配記憶體，呼叫建構函式時，隱式／顯示的初始化各資料成員
  2.進入建構函式後在建構函式中執行一般計算
       1）類裡面的任何成員變數在定義時是不能初始化的。
       2）一般的資料成員可以在建構函式中初始化。
       3）const資料成員必須在建構函式的初始化列表中初始化。
       4）static要在類的定義外面初始化。  
       5）陣列成員是不能在初始化列表裡初始化的。
       6）不能給陣列指定明顯的初始化。 
這6條一起，說明了一個問題：C++裡面是不能定義常量陣列的！因為3和5的矛盾。這個事情似乎說不過去啊？沒有辦法，我只好轉而求助於靜態資料成員。
到此，我的問題解決。但是我還想趁機複習一下C++類的初始化：
  1.初始化列表：CSomeClass::CSomeClass() : x(0), y(1){}
  2.類外初始化：int CSomeClass::myVar=3;
  3.const常量定義必須初始化，C++類裡面使用初始化列表;
  4.C++類不能定義常量陣列。

在C++類中，必須做如下事情：

1.必須對任何const或引用型別成員以及沒有預設建構函式的 類 型別 的任何成員 顯示地使用初始化列表進行初始化

2.類成員在定義時是不能被初始化的。

3.類的成員初始化順序與成員變數在建構函式中的位置選後順序無關，至於成員變數在類中定義的先後順序有關。

C++預設繼承方式為private

C++ new 生成的物件為指標，所以new 前面的物件要宣告為指標型別

四，例項

        計算器簡單工廠模式的精簡實現

#include <iostream>
using namespace std;

class COperation//基類
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

class AddOperation : public COperation//加法
{
public:
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

class SubOperation : public COperation//減法
{
public:
	virtual double GetResult()
	{
		return m_nFirst-m_nSecond;
	}
};


class CCalculatorFactory//工廠類
{
    
public://靜態方法屬於類本身，不屬於哪個物件 
	static COperation* Create(char cOperator);

};

COperation* CCalculatorFactory::Create(char cOperator)//工廠類的實現
{
	COperation *oper;
	
    //在C#中可以用反射來取消判斷時用的switch，在C++中用什麼呢？RTTI？？
	switch (cOperator)
	{
		case '+':
			oper=new AddOperation();
		     break;
		case '-':
			oper=new SubOperation();
            break;
		default:
			oper=new AddOperation();
	     	break;
	}
	return oper;
}

int main()
{
	int a,b;
	cin>>a>>b;
	
	/*靜態方法為類所有，可以通過物件來使用，也可以通過類來使用。
	但一般提倡通過類名來使用，因為靜態方法只要定義了類，不必建立類的例項就可使用*/
	COperation * op = CCalculatorFactory::Create('-');//靜態方法呼叫方式 
	op->m_nFirst=a;
	op->m_nSecond=b;
	cout<<op->GetResult()<<endl;
	return 0;
}

將簡單工廠模式優化為策略模式後的程式碼如下： 
#include <iostream>
using namespace std; 

//策略基類
class COperation
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具體類-加法類
class AddOperation : public COperation
{
public:
	AddOperation(int a,int b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

class Context//策略類 
{
private:
	COperation* op;
public:
    Context(COperation* temp)//引數為策略基類（傳遞的時候被初始化為子類） 
	{
        op=temp;
	}
	double GetResult()
	{
		return op->GetResult();
	}
};

//客戶端
int main()
{
	int a,b;
    char c;
	cin>>a>>b;
    cout<<"請輸入運算子：";
    cin>>c;
    switch(c)
    {
       case '+':
	        Context *context=new Context(new AddOperation(a,b));
     	        cout<<context->GetResult()<<endl;
            break;
       default:
            break;
    }
	return 0;
}

這裡將策略（操作符）封裝成一個Context類，通過傳遞操作符子物件來返回相應子物件下操作結果。

菜鳥實現工廠模式和策略模式

        客戶端只需訪問Context類，而不用知道其它任何類資訊，實現了低耦合。在上例基礎上，修改下面內容

#include <iostream>
using namespace std;
 
 
 //策略基類
class COperation
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具體類-加法類
class AddOperation : public COperation
{
public:
	AddOperation(int a,int b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	AddOperation()
	{
		m_nFirst=0;
		m_nSecond=0;
	}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};
class Context
{
private:
	COperation* op;
public:
    Context(char cType)
	{
        switch (cType)
        {
		case '+':
			op=new AddOperation(3,8);
			break;
		default:
			op=new AddOperation();
			break;
        }
	}
	double GetResult()
	{
		return op->GetResult();
	}
};
//客戶端
int main()
{
	Context *test=new Context('+');
	cout<<test->GetResult()<<endl;
	return 0;
}

五，商場促銷例子

        這裡想說的是，abstract 關鍵字是微軟為C#定義的，抽象類關鍵字。C++中沒有抽象類，如果想成為抽象類在類中定義純虛擬函式就可以了。只要擁有純虛擬函式的類就是抽象類，由於抽象類包含了沒有定義的純虛擬函式，所以不能定義抽象類的物件。

         商場促銷的簡單工廠實現：

#include <iostream>

using namespace std;

class CashSuper //現金收費抽象類
{
public:
    virtual double acceptCash(double money)//不能設定為純虛擬函式，後面還要生成物件用呢！！！！ (不能只定義，而不實現)
    {
        
    }
};

class CashNormal : public CashSuper //收費子類，正常收費
{
public:
     double acceptCash(double money)
     {
         return money;
     }
    
};

class CashRebate : public CashSuper //打折收費子類
{
private:
    double moneyRebate;//不允許初始化
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
         return money*moneyRebate;
    }
};

class CashReturn :public CashSuper //返利收費子類（預設繼承為私有繼承）
{
private:
    double moneyCondition ;//返利購買額度
    double moneyReturn ;//返利多少
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result = money;
        if(money >= moneyCondition )
            result = money-(money/moneyCondition)*moneyReturn;
        return result;
        
    }
};

class CashFactory
{
public:
    static CashSuper* creatCashAccept(string type)//根據子類type來生成相應收費子類
    {
        CashSuper *cs;
        if(type=="CashNormal")
            cs=new CashNormal();
        else if(type == "CashRebate")
            cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            cs=new CashReturn(300,100);
        
        return cs;
    }
};

int main(int argc, char** argv) {

    CashSuper *csuper = CashFactory::creatCashAccept("CashRebate");
    double result=csuper->acceptCash(500);//500打八折，應該輸出 400
    cout<<"CashRebate 500 is："<<result<<endl;
    return 0;
}

    策略模式：定義了演算法家族，分別封裝起來，讓它們之間可以相互替換，演算法的變化不會影響使用演算法的客戶。
        主要升級就是，將演算法封裝到Context中，然後通過傳遞物件生成相應子類物件，然後得到結果。 
#include <iostream>

using namespace std;

class CashSuper //現金收費抽象類
{
public:
    virtual double acceptCash(double money)//不能設定為純虛擬函式，後面還要生成物件用呢！！！！ 
    {
        
    }
};

class CashNormal : public CashSuper //收費子類，正常收費
{
public:
     double acceptCash(double money)
     {
         return money;
     }
    
};

class CashRebate : public CashSuper //打折收費子類
{
private:
    double moneyRebate;//不允許初始化
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
         return money*moneyRebate;
    }
};

class CashReturn :public CashSuper //返利收費子類（預設繼承為私有繼承）
{
private:
    double moneyCondition ;//返利購買額度
    double moneyReturn ;//返利多少
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result = money;
        if(money >= moneyCondition )
            result = money-(money/moneyCondition)*moneyReturn;
        return result;
        
    }
};

/*class CashFactory
{
public:
    static CashSuper* creatCashAccept(string type)//根據子類type來生成相應收費子類
    {
        CashSuper *cs;
        if(type=="CashNormal")
            cs=new CashNormal();
        else if(type == "CashRebate")
            cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            cs=new CashReturn(300,100);
        
        return cs;
    }
};*/

class CashContext
{
private:
    CashSuper cs;
public:
    CashContext(CashSuper csuper)
    {
        this->cs=csuper;
    }
    double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
};

int main(int argc, char** argv) {

    //CashSuper *csuper = CashFactory::creatCashAccept("CashRebate");
    //double result=csuper->acceptCash(500);//500打八折，應該輸出 400
    
    
     CashContext *cs;
     string type="CashRebate";
     
     if(type=="CashNormal")
            cs=CashContext(new CashNormal());
     else if(type == "CashRebate")
            cs=CashContext(new CashRebate(0.8));
     else if(type == "CashReturn")
            cs=CashContext(new CashReturn(300,100));
        
        
    cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl;
    return 0;
}

這樣仍然存在缺點：就是讓客戶端來判斷生成哪個子類。

改進策略是，讓策略模式和工廠模式結合

#include <iostream>

using namespace std;

class CashSuper //現金收費抽象類
{
public:
    virtual double acceptCash(double money)//不能設定為純虛擬函式，後面還要生成物件用呢！！！！ 
    {
        
    }
};

class CashNormal : public CashSuper //收費子類，正常收費
{
public:
     double acceptCash(double money)
     {
         return money;
     }
    
};

class CashRebate : public CashSuper //打折收費子類
{
private:
    double moneyRebate;//不允許初始化
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
         return money*moneyRebate;
    }
};

class CashReturn :public CashSuper //返利收費子類（預設繼承為私有繼承）
{
private:
    double moneyCondition ;//返利購買額度
    double moneyReturn ;//返利多少
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result = money;
        if(money >= moneyCondition )
            result = money-(money/moneyCondition)*moneyReturn;
        return result;
        
    }
};

/*class CashFactory
{
public:
    static CashSuper* creatCashAccept(string type)//根據子類type來生成相應收費子類
    {
        CashSuper *cs;
        if(type=="CashNormal")
            cs=new CashNormal();
        else if(type == "CashRebate")
            cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            cs=new CashReturn(300,100);
        
        return cs;
    }
};*/

class CashContext
{
private:
    CashSuper cs;
public:
    CashContext(string type)
    {
        if(type=="CashNormal")
            this->cs=new CashNormal();
        else if(type == "CashRebate")
            this->cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            this->cs=new CashReturn(300,100);
              
    }
    double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
};

int main(int argc, char** argv) {

     CashContext *cs=new CashContext("CashRebate");
           
     cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl;
    return 0;
}

這樣客戶端只需要更改金額和打折手段就可以了。相對簡單工廠的提升為：簡單工廠需要讓客戶呼叫兩個類SuperCash和CashFactory。而結合之後僅僅需要呼叫CashContext就可以了

相對與策略模式的提升為：客戶端需要承擔的判斷更少了，更簡潔了

相關推薦

【設計模式】商場促銷 -- 策略模式

一，概念         策略模式定義了一系列的演算法，並將每一個演算法封裝起來，而且使它們還可以相互替換。策略模式讓演算法獨立於使用它的客戶而獨立變化。 二，策略模式的組成 　　 1）抽象策略角色： 策略類，通常由一個介面或者抽象類實現。 　　 2）具體策略角色：包裝

Java版大話設計模式（二）---計算器商場促銷---策略模式

package dataStruct; abstract class CashSuper { public abstract double acceptCash(double money); } //正常收費子類 class CashNormal extends CashS

設計模式之二 商場促銷-策略模式

   策略模式是一種定義一系列演算法的方法，從概念上來看，所有這些演算法完成的都是相同的工作，只是實現不同，它可以以相同的方式呼叫所有的演算法，減少了各種演算法類與使用演算法類之間的耦合。    策略模式（Strategy）：它定義了演算法家族，分別封裝起來，讓它們之間可以互

《大話設計模式》之--第2章 商場促銷----策略模式

第2章商場促銷----策略模式 2.1商場收銀軟體 “小菜，給你出個作業，做一個商場收銀軟體，營業員根據客戶所購買商品的單價和數量，向客戶收費。” “就這個？木問題。”小菜說，“用兩個文字框來輸入單價和數量，一個確定按鍵來算出每種商品的費用，用個列表框來記錄商品的清單，一個標

【機房重構】——下機（策略模式+職責鏈模式）

【前言】 下機功能在整個機房收費系統中也算是一個難點吧，因為下機的過程中涉及到的表比較多，有不同的收費標誌。針對這些要點，我分別採用了職責鏈模式來實現分段計費，策略模式來實現不同使用者的收費標準。下面請看我一一道來。   【內容】 一、什麼是策略模式  

【設計模式】策略模式——以商場促銷為例

本文內容參考自《大話設計模式》（程傑 著） 注：以下程式碼為java實現 版本1 需求： 做一個商場收銀軟體，營業員根據客戶所購買商品的單價和數量，向客戶收費。 關鍵程式碼： public class Cash { pri

C#設計模式之十九策略模式（Stragety Pattern）【行為型】

多條件 第一次 必須 this 數據傳遞 名稱 面向 div 想要 原文:C#設計模式之十九策略模式（Stragety Pattern）【行為型】一、引言 今天我們開始講“行為型”設計模式的第七個模式，該模式是【策略模式】，英文名稱是：Stragety Pattern。

【JS設計模式】溫習簡單工廠模式、工廠方法模式、抽象工廠模式概念

his mac script 開頭 str new 每一個 簡單工廠 pattern 註：空心箭頭表示的是種繼承關系，工廠類和產品類之間是一種依賴關系。是用箭頭加虛線表示的，以下的模型圖是用的實線是不正確（時間不夠用，在這裏我偷懶了。這個習慣不好，呵呵）簡單工廠模式（S

【Unity與23種設計模式】叠代器模式（Iterator）

存儲對象 函數庫 叠代器 每一個 語言 不知道 集合體 程序設計 順序 GoF中定義： “在不知道集合內部細節的情況下，提供一個按序方法存取一個對象集合體的每一個單元。” 叠代器模式由於經常使用到 已經被現代程序設計語言納為標準語句或收錄到標準函數庫中 在C#中

【Python設計模式】06 觀察者模式－瞭解物件的情況

六、觀察者模式－瞭解物件的情況 這章可以討論行為型設計模式：觀察者設計模式 本章主題 行為型設計模式簡介 觀察者設計模式及其 UML圖 利用 Python3.x程式碼實現一個真實用例 鬆耦合的強大威力 常見問答 1. 行為型模式簡介

【Python設計模式】02 單例模式

1. python實現經典的單例模式 python通過覆蓋__new__()方法來控制物件的建立。 if not hasattr(cls, ‘instance’):方法hasattr用於檢視物件cls是否具有屬性instance, 該屬性的作用是檢查該類是否已經生成了一個物件。

【設計原則】軟體設計模式六大原則---學習

又有一種說法：   http://www.cnblogs.com/yuanhailiang/p/9432198.html ———————————————————————————— 原文：https://www.cnblogs.com/zhanghengscnc/p/8299

【JAVA設計模式】1.簡單工廠模式

簡單工廠模式是建立型設計模式： 建立型設計模式即封裝了具體生成物件的細節，僅暴露出生成物件的方法。只需向建立物件的方法提供引數，而不用自行實現判斷的邏輯。 UML圖（圖片來自網路）： 簡單工廠模式提供了一個建立者類，暴露了一個工廠方法，用於根據接收的引數返回對應的具

【設計模式】之物件池模式--JDBC連線池簡單實現案例

文章目錄 物件池設計模式 物件池設計模式的目標 問題 討論 結構 示例 核驗單 經驗法則 連線池模式示例程式碼 ObjectPool.java

【JAVA設計模式】12.享元模式

享元模式將物件資訊分為兩類，一個是不受物件具體資訊影響，即可共享的物件資訊，另一個是不同物件間獨立的資訊。 由於存在可共享的資訊，則可設計一個工廠類，工廠類內部儲存了大量物件，所有物件都有一個共同的資訊，例如：產品類別。 先建立一個享元介面： interface Fly

【設計模式】之模板方法模式

1.模式動機與定義 模板方法定義：定義一個操作中演算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個演算法的結構即可重定義該演算法的特定步驟。 模板方法是一種行為型模式。 2.模式結構與分析 /** * 實現了一個模板方法，定義了演算法的骨架。 * 具體子類將重新定義primi

【設計模式】之觀察者模式

觀察者模式 什麼是觀察者模式 觀察者模式屬於行為模式的一種，定義了物件的通用交流方式。 觀察者模式定義了一對多的關係，一個物件改變了狀態，則其它所有依賴它的物件都會收到通知。 觀察者模式有時候在網路模

【設計模式】-09觀察者模式

1.什麼是觀察者模式?   定義:在物件之間定義了一對多的依賴，這樣一來，當一個物件改變狀態，依賴它的物件會收到通知並自動更新. 舉個栗子: 張三和李四準備上演一場搶劫銀行的行動,張三負責搶劫,李四負責放哨,他們兩約定,如果李四這邊看到警察來就立即通知張三,張三收到通知後立馬逃

【設計模式】迭代器模式

模式定義 迭代器模式提供一種方法順序訪問一個聚合物件中的各個元素，而又不暴露其內部的表示。 下圖是該模式的類圖： 一個生動的例子 迭代器介面： public interface Iterator<E> { boolean hasNext(); E ne

【Java設計模式】：建立型模式—建造者模式

1.建造者模式定義 建造者模式，顧名思義的就是類似建房子，有一個固定的流程。在大話設計模式中，作者舉了一個例子大概意思是同一道菜在中國的每一個地方都有不同的味道（LZ印象最深的是酸菜魚，來杭州之後印象最深刻的是清蒸鱸魚。），而肯德基的雞腿、漢堡在每一個城市都是一樣的味道。建造者模式實