策略模式（C++）

定义

定义一系列算法，把它们一个个封装起来，并且使它们可互相替换((变化)。该模式使得算法可独立手使用它的客户程序稳定)而变化(扩展，子类化)。
——《设计模式》GoF

使用场景

在软件构建过程中，某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象变得异常复杂;而且有时候支持不使用的算法也是一个性能负担。
如何在运行时根据需要透明地更改对象的算法?将算法与对象本身解耦，从而避免上述问题?

结构

在这里插入图片描述

代码示例

//Strategy.h
/****************************************************/
#ifndef STRATEGY_H
#define STRATEGY_H
#include<iostream>
using namespace std;
 
//创建一个定义活动的Strategy的抽象接口
class Strategy
{
public:
	Strategy() {};
	virtual ~Strategy() {};
	virtual int doOperation(int num1, int num2)=0;
};
 
//创建一个实体活动的OperationAdd类
class OperationAdd:Strategy
{
public:
	OperationAdd() {};
	virtual ~OperationAdd() {};
	int doOperation(int num1, int num2) { return num1 + num2; };
};
 
//创建一个实体活动的OperationSubstract类
class OperationSubstract :Strategy
{
public:
	OperationSubstract() {};
	virtual ~OperationSubstract() {};
	int doOperation(int num1, int num2) { return num1 - num2; };
};
 
//创建一个实体活动的OperationMultiply类
class OperationMultiply :Strategy
{
public:
	OperationMultiply() {};
	virtual ~OperationMultiply() {};
	int doOperation(int num1, int num2) { return num1 * num2; };
};
 
//创建一个使用某种策略的Context类
class Context
{
public:
	Context(Strategy *strate) { mstrate = strate; };
	virtual ~Context() { delete mstrate; mstrate = NULL; };
	int executeStrategy(int num1, int num2) { return mstrate->doOperation(num1,num2); };
private:
	Strategy *mstrate;
};

#endif

//test.cpp
/****************************************************/
#include <iostream>
#include <string>
#include "Strategy.h"
 
int main()
{
	Context *c1 = new Context((Strategy*)new OperationAdd());
	Context *c2 = new Context((Strategy*)new OperationSubstract());
	Context *c3 = new Context((Strategy*)new OperationMultiply());
 
	cout <<"1 + 2 = "<<c1->executeStrategy(1, 2) << endl;
	cout <<"1 - 2 = "<< c2->executeStrategy(1, 2) << endl;
	cout <<"1 * 2 = "<< c3->executeStrategy(1, 2) << endl;
 
	delete c1;
	c1 = NULL;
 
	delete c2;
	c2 = NULL;
 
	delete c3;
	c3 = NULL;
	return 0;
}