设计模式---行为类型---策略

1、意图

定义一系列的算法，把他们一个个封装起来，并且使他们可相互替换。本模式使得算法可独立于使用它的客户而变化。

2、动机

有许多算法可对一个正文流进行分析。将这些算法硬编进使用他们的类中是不可取的，其原因如下：

1）需要换行功能的客户程序如果直接包含换行算法代码的话将会变得复杂，这使得客户程序庞大而且难以维护，尤其当其需要支持多种换行算法时问题会更加严重。

2）不同的时候需要不同的算法，我们不想支持我们并不使用的换行算法。

3）当换行功能是客户程序的一个难以分割的成分时，增加新的换行算法或改变现有算法将十分困难。

3、适用性

当存在以下情况时使用Strategy模式

1）许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。

2）需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间/时间权衡的算法。当这些变体实现为一个算法的类层次时，可以使用策略模式。

3）算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。

4）一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以替换这些条件语句。

4、C++实例

// Test.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <Windows.h>
#include <list>
#include <string>

using namespace std;

struct Coord
{
Coord()
{
_x = 0;
_y = 0;
}

Coord( int x, int y )
{
_x = x;
_y = y;
}
int _x;
int _y ;
};

class Compositor
{
public:

virtual int Compose( Coord natural, Coord strecth, Coord shrink,
int componentCount, int lineWidth, int breaks ) = 0;

protected:

Compositor()
{

}

};

class Composition
{

public:

Composition( Compositor* comp )
{
_compositor = comp;

_lineWidth = 10;
}

void Repair();

private:

Compositor *_compositor;

int _componentCount;

int _lineWidth;

int *_lineBreaks;

int _lineCount;
};

void Composition::Repair()
{
Coord natural( 1, 2 );
Coord stretch( 3, 4 );
Coord shrink( 5, 6 );

int breakCount;
int componentCount = 7;
int breaks = 8;

breakCount = _compositor->Compose( natural, stretch, shrink, componentCount, _lineWidth, breaks );
}

class SimpleCompositor: public Compositor
{

public:

SimpleCompositor()
{

}

virtual int Compose( Coord natural, Coord strecth, Coord shrink,
int componentCount, int lineWidth, int breaks )
{
cout<<"SimpleCompositor:Compose "<<"natural: x : "<<natural._x<<" y : "<<natural._y<<endl;
return 0;
}
};

class TexCompositor: public Compositor
{

public:

TexCompositor()
{

}

virtual int Compose( Coord natural, Coord strecth, Coord shrink,
int componentCount, int lineWidth, int breaks )
{
cout<<"TexCompositor:Compose "<<"strecth: x : "<<strecth._x<<" y  : "<<strecth._y<<endl;
return 0;
}
};

class ArrayCompositor: public Compositor
{

public:

ArrayCompositor()
{

}

virtual int Compose( Coord natural, Coord strecth, Coord shrink,
int componentCount, int lineWidth, int breaks )
{
cout<<"ArrayCompositor:Compose "<<"shrink: x : "<<shrink._x<<" y : "<<shrink._y<<endl;
return 0;
}
};

int _tmain(int argc, _TCHAR* argv[])
{
Compositor  *simple = new SimpleCompositor;
Composition *quick  = new Composition( simple );
quick->Repair();

Compositor *tex = new TexCompositor;
Composition *slick = new Composition( tex );
slick->Repair();

Compositor *array = new ArrayCompositor;
Composition *iconic = new Composition( array );
iconic->Repair();

delete simple;
delete quick;

delete tex;
delete slick;

delete array;
delete iconic;

return 0;
}