前言

看了一会儿大话设计模式，我感觉平常的话，策略模式还挺常用的，记录一下。个人理解策略模式，就是抽象一个算法，然后你可以有很多不同的实现，这些实现去重写抽象算法的虚方法。然后在一个上下文类中有一个抽象算法的指针，根据客户端输入参数的不同，去动态决定使用哪个具体的实现，客户端调用的函数在内部其实就是抽象算法指针指向的类的具体实现。这样就可以无限扩展不同的实现方式了，而客户端的接口不用变，只需要改变约定的参数。

代码

#include<iostream>

class MaskMatchStrategy // MaskMatch的算法抽象
{
public:
	virtual void do_mask_match() = 0;
};

// 实现具体算法1
class RigidMaskMatch :public MaskMatchStrategy
{
	void do_mask_match() override {
		std::cout << "执行rigid mask match" << std::endl;
	}
};

// 实现具体算法2
class DeformableMaskMatch :public MaskMatchStrategy
{
	void do_mask_match() override {
		std::cout << "执行deformable mask match" << std::endl;
	}
};

// 客户端调用MaskMatch的类, 只需要给客户端看的
class MaskMatchContext
{
private:
	MaskMatchStrategy* _mask_match_strategy;
	int _type_param;

public:
	void do_mask_match() 
	{
		if (_mask_match_strategy != nullptr) {
			_mask_match_strategy->do_mask_match();
		}
		else {
			std::cout << "参数设置有误, type_param="<<_type_param
				<<" : [未支持的参数]"
				<< std::endl;
		}
	}

	// 由构造函数传入参数
	MaskMatchContext(int type_param=0);// 设置默认参数

	~MaskMatchContext()
	{
		delete _mask_match_strategy;
		std::cout << "MaskMatchContext deconstructor complete" << std::endl;
	}
};


MaskMatchContext::MaskMatchContext(int type_param):_type_param(type_param)
{
	switch (type_param)
	{
	case 0:
		_mask_match_strategy = new RigidMaskMatch;
		break;
	case 1:
		_mask_match_strategy = new DeformableMaskMatch;
		break;
	default:
		_mask_match_strategy = nullptr;
		break;
	}
}

int main()
{
	MaskMatchContext c;
	c.do_mask_match();

	return 0;
}

结果