设计模式系列1-----C++实现策略模式(Strategy)

什么是策略模式？

wikipedia的定义为：Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

换言之，就是做一件事情有很多种方法，每种方法可以称为一种策略strategy。由于策略的方式很多，而且可能经常变更，甚至不断有新的策略出现，需要封装每一种策略，使得变化限定在各种策略内部，而不影响使用他的代码。

 

类图结构：

 

Strategy为接口(在C++中为抽象类)，各种Concrete Strategy实现它定义的接口。 Context使用Strategy，它不知道具体完成任务的是哪一个具体的策略。只要接口不变，如果策略变了，只需要改某一个具体的策略。如果要加新的策略，需要实现Strategy定义的接口，Context并不需要知情。

 

体现的面向对象设计原则：

1. Encapsulate what varies

    策略是变化源，具体实现封装在一个个具体策略类中。

2. Favor composition over inheritance

    策略模式中，Context持有一个strategy指针(引用)，即组合。Composition最大的好处是灵活，在策略模式中的体现就是可以在运行时替换不同的策略。而继承结构一旦确定，就固定下来，难以达到这种灵活性。

3. Program to interface, not implementation

    Context使用strategy类型，但是并不需要知道具体的Concrete Strategy，这样的设计的好处就是当具体策略的实现变化的时候，并不会对Context造成影响。

4. Open/closed principle

    开合原则即是对扩展开发，对改变封闭。在策略模式中的体现就是策略的改变封闭在各个具体的策略类中，并不对外界造成影响，因为外界是通过它的抽象接口沟通的。另外，策略的扩展很简单，新的策略类只需要实现抽象类，但是这种扩展并不会对这个系统产生影响。

Example：

下面的例子用C++实现，模拟商店购物的计价过程。对某一商品，SaleManager计算一定数量商品的总价格。由于计算有很多种方法，比如学生享受五折优惠，有批发购买权的顾客购买超过100件时打7折等等。由于计算方法会经常变更，需要封装起来，其他可能的策略如五一购物优惠、套餐优惠等等。这里策略模式就派上了用场。

SaleStrategy是策略抽象类，具体的策略类包括RegularSaleStrategy、StudentSaleStrategy、BulkSaleStrategy。下面具体分析代码

SaleStrategy为抽象类，至少需要定义一个纯虚函数，在这里就是计算价钱的借口，定义如下：

class SaleStrategy
{
public:
	virtual float calculate(float price, int amount) = 0;
};

 

RegularSaleStrategy为一种具体策略类，实现SaleStrategy。它用普特的计价方法：购买数量*单价，

class RegularSaleStrategy : public SaleStrategy
{
public:
	virtual float calculate(float price, int amount)
	{
		return price * amount;
	}
};

 

StudentSaleStrategy、BulkSaleStrategy与上类似，实现如下：

class StudentSaleStrategy : public SaleStrategy
{
public:
	virtual float calculate(float price, int amount)
	{
		const float DISCOUNT = 0.5f;	//学生半价

		return (1-DISCOUNT) * price * amount;
	}
};

class BulkSaleStrategy : public SaleStrategy
{
public:
	virtual float calculate(float price, int amount)
	{
		const float DISCOUNT = 0.3f;	//批发折扣
		const int BULK_LIMIT = 100;		//>=100件按批发价

		if (amount >= BULK_LIMIT)
			return (1-DISCOUNT) * price * amount;
		return price * amount;
	}
};

 

SaleManager即是上面结构图中的Context类，所以它有一个SaleStrategy指针m_pSaleStrategy，可以在构造函数中传入或者用setStrategy函数在运行时设置，可以看到他在使用SaleStrategy时，并不需要知道到底m_pSaleStrategy指向的是哪一种具体策略。这是C++的多态提供的好处。代码如下：

class SaleManager
{
public:
	SaleManager(SaleStrategy* pSaleStrategy = NULL) : m_pSaleStrategy(pSaleStrategy) {}

public:
	void setStrategy(SaleStrategy* pSaleStrategy)
	{
		m_pSaleStrategy = pSaleStrategy;
	}

	float calculateTotal(float price, int amount)
	{
		assert(m_pSaleStrategy != NULL);
		float calResult = m_pSaleStrategy->calculate(price, amount);
		cout << "total price is: " << calResult << endl;
		return calResult;
	}

private:
	SaleStrategy* m_pSaleStrategy;
};

 

最终的测试代码如下，可以看到各种策略可以动态切换并正确工作：

int main(int argc, char** argv)
{
	SaleStrategy* pSaleStrategy = new RegularSaleStrategy();
	SaleStrategy* pStudentSaleStrategy = new StudentSaleStrategy();
	SaleStrategy* pBulkSaleStrategy = new BulkSaleStrategy();

	SaleManager saleManager(pSaleStrategy);
	cout << "Regular Sale Strategy:\n"; 
	saleManager.calculateTotal(2.5f, 100);

	saleManager.setStrategy(pStudentSaleStrategy);
	cout << "Student Sale Strategy:\n";
	saleManager.calculateTotal(2.5f, 100);

	saleManager.setStrategy(pBulkSaleStrategy);
	cout << "Bulk Sale Strategy:\n";
	saleManager.calculateTotal(2.5f, 100);

	delete pBulkSaleStrategy;
	delete pStudentSaleStrategy;
	delete pSaleStrategy;

	return 0;
}

 

 

参考资料：

Wikipedia:Strategy Pattern

<<Head First Design Pattern>>

<<Design Patterns—Elements of Reusable Object-Oriented Software>>

posted on 2011-12-03 20:04  GraphicsMe  阅读(1053)  评论(0)  编辑  收藏  举报

导航