策略模式（Strategy）：它定義了演算法家族，分別封裝起來，讓他們之間可以互相替換，此模式讓演算法的變化，不會影響到使用演算法的客戶。

context，用一個ConcreteStrategy來配置，維護一個對Strategy物件的引用。

策略模式和工廠模式的不同之處：
工廠來生成演算法物件，這沒有錯，但演算法只是一種策略，最重要的是這些演算法是隨時間都可能互相替換的，這就是變化點，而封裝變化就是面向物件的一個重要的思維方式，
策略模式結構圖如下所示：

來舉一個栗子：

程式執行截圖如下；

原始碼如下：

strategy.h

#pragma once

#include <iostream>
using namespace std;

class Strategy{

public:
	virtual void algorithmInterface() = 0;
	virtual ~Strategy(){
		cout << "~Strategy() called!" << endl;
	}

};

class ConcreteStrategyA: public Strategy{

public:
	void algorithmInterface(){

		cout << "arithmetic A is called!" << endl;
	}

	~ConcreteStrategyA(){

		cout << "~ConcreteStrategyA() called!" << endl;
	}
};

class ConcreteStrategyB: public Strategy{

public:
	void algorithmInterface(){

		cout << "arithmetic A is called!" << endl;
	}

	~ConcreteStrategyB(){
	
		cout << "~ConcreteStrategyB() called!" << endl;
	}
};

class ConcreteStrategyC: public Strategy{

public:
	void algorithmInterface(){

		cout << "arithmetic C is called!" << endl;
	}

	~ConcreteStrategyC(){

		cout << "~ConcreteStrategyC() called!" << endl;
	}
};

class Context{
	
public:
	Context(Strategy *strategy){
		m_strategy = strategy;
	}

	~Context(){
		delete m_strategy;
	}

	void contextInterface(){
		m_strategy->algorithmInterface();
	}


private:
	Strategy *m_strategy;
};
 

main.cpp

#include "strategy.h"

int main(){

	Context *contextA, *contextB, *contextC;
	//由於例項化不同的策略，所以最終在呼叫context->contextInterface()時，所獲得的結果就不盡相同
	contextA = new Context(new ConcreteStrategyA);
	contextA->contextInterface();
	delete contextA;

	cout << endl << "----------**********----------" << endl;
	
	contextB = new Context(new ConcreteStrategyB);
	contextB->contextInterface();
	delete contextB;

	cout << endl << "----------**********----------" << endl;

	contextC = new Context(new ConcreteStrategyC);
	contextC->contextInterface();
	delete contextC;

	getchar();
	return 0;
}