设计模式-策略模式

最近学习C++设计新思维一书，顺带把设计模式里想关模式一并在看了看，贴出些学习笔记，以帮助记忆

通过虚函数接口实现的策略模式

//Strategy.cpp
//策略模式
/**
适用性
1. 许多相关类行为有异，用多个行为中的一个行为来配置一个类的方法
2. 需要使用一个算法的不同变体
3. 一个类定义了多种行为，，将类中条件语句移入各自的strategy类中
（将任务委托给一个子类从而消除条件语句）
*/
#include <iostream>

class Compositor
{
public:
virtual void Compose(/*argc*/) = 0;
};

class Composition
{
public:
Composition(Compositor* compositor) :
_compositor(compositor)
{}

void Repaire()
{
//...
_compositor->Compose();
//...
}
private:
Compositor* _compositor;
};

class SimpleCompose : public Compositor
{
public:
SimpleCompose(){};
virtual void Compose(/*argc*/)
{
std::cout << "SimpleCompose::Compose\n";
}
};

class TexCompose : public Compositor
{
public:
TexCompose(){};
virtual void Compose(/*argc*/)
{
std::cout << "TexCompose::Compose\n";
}
};

class ArrayCompositor : public Compositor
{
public:
ArrayCompositor(){};

virtual void Compose()
{
std::cout << "ArrayCompositor::Compose\n";
}
};

int main(int argc, char const *argv[])
{
Composition* quick = new Composition(new SimpleCompose());
quick->Repaire();
return 0;
}

//cl  /EHsc /W4 Strategy.cpp && Strategy

模版实现版本：

//在编译期选择policy

#include <iostream>

class SimpleCompose
{
public:
void Compose()
{
std::cout << "SimpleCompose::Compose\n";
}
protected:
~SimpleCompose(){}
};

class TexCompose
{
public:
void Compose()
{
std::cout << "TexCompose::Compose\n";
}
protected:
~TexCompose(){}
};

class ArrayCompositor
{
public:
void Compose()
{
std::cout << "ArrayCompositor::Compose\n";
}

void Compose1()
{
std::cout << "ArrayCompositor::Compose1\n";
}
protected:
~ArrayCompositor(){}
};

template <class Policy = SimpleCompose>
class Composition : public Policy
{
public:
Composition(){};

void Repaire()
{
//Policy().Compo
4000
se();
Policy& thePolicy = *this;
thePolicy.Compose();
}

void Switch()
{
Policy& thePolicy = *this;
thePolicy.Compose1();
}
};

typedef Composition<TexCompose> TexComposition;
typedef Composition<ArrayCompositor> ArrayComposition;

int main(int argc, char const *argv[])
{
Composition<> simple;
simple.Repaire();

TexComposition  tex;
tex.Repaire();

ArrayComposition array;
array.Repaire();
array.Switch();

return 0;
}

//cl  /EHsc /W4 Strategy_Template.cpp && Strategy_Template

设计模式一书中作者提到在2种情况下可利用模版机制，1，在编译期选择策略，2. 不需要在运行时改变

而新思维作者认为模版是一种很适合“组合各种行为”的机制进而给使用者提供了多样性选择，首先指出全功能接口的不可行，同时也指出使用多重继承机制进行行为组合的缺点，最后andrei提出： 如果我们将templates和多重继承组合起来，将会产生非常具弹性的设备（device），应该很适合用来产生程序库中的“设计元素”（design elements）

以复合或者继承的方式使用定义的policies， hosts负责把policies提供的结构和行为组成一个更复杂的结构和行为

设计policy-based class最困难的部分，是把class正确分解成policies, 一个准则是，将参与class行为的设计鉴别出来并命名之，任何事情只要能以一种以上的方式解决，都应该被分析出来，并从class中移出来成为policy