021.设计模式之Strategy 模式

 

一、概述
Strategy（策略）模式又称Policy模式，用于定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。这里的算法并非狭义的数据结构或算法理论中所讨论的KMP、shell sort等算法，而是指应用程序设计中不同的处理逻辑，前面所说的狭义的算法只是其中的一部分。Strategy模式使得算法与算法的使用者相分离，减少了二者间的耦合度，使得算法可独立于使用它的客户而变化；同时，由于设计粒度的减小，程序的复用性也得到了进一步提高，分离出来的算法可以更好地适应复用的需要。

二、结构
Strategy模式的结构如下图所示：

图 1.Strategy模式类图示意
上图中存在如下角色：

从结构上看，Strategy模式与上一篇讨论的State模式有几分相似，但二者所讨论的Context（情景）具有显著的差异：
State模式在于将其状态信息分离出来保存到一个独立的对象中，以便状态信息的获取或状态的转换；Strategy模式在于将可能的算法分离出来，根据需要进行适当的选择。此外，二者的区别还在于，Strategy模式中各个Strategy（算法、策略）往往用于解决相同的问题，即只是解决同一问题的不同“策略”、“途径”，而且，一次只能有一个Strategy为上次应用提供服务；而State模式中的各个State本身往往具有一定的差异，但他们之间存在明显的相互转换的关系，而且这种转换往往会在程序运行过程中经常性地发生，同时存在一个以上State也是可能的。

区别参考：二者的应用场合不同。状态模式用于处理对象有不同状态（状态机）的场合，策略模式用于随不同外部环境采取不同行为的场合。在状态模式中，状态的变迁是由对象的内部条件决定，外界只需关心其接口，不必关心其状态对象的创建和转化；而策略模式里，采取何种策略由外部条件决定。所以，有人说“状态模式是完全封装且自修改的策略模式”。至于Bridge，在结构上与前两者都不一样了。要说相似之处，就是三者都有具有对外接口统一的类，展现出多态性而已。

三、应用
当存在以下情况时可考虑使用Strategy模式：
1.许多相关的类仅仅是行为有异。“策略”提供了一种用多个行为中的一个行为来配置一个类的方法。
2.需要使用一个算法的不同变体。例如，你可能会定义一些反映不同的空间 /时间权衡的算法，当这些变体实现为一个算法的类层次时，可以使用策略模式。
3.算法使用客户不应该知道的数据。可使用策略模式以避免暴露复杂的、与算法相关的数据结构。
4.一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。
更具体的应用实例包括：
1.以不同的格式保存文件；
2.以不同的方式对文件进行压缩或其他处理；
3.以不同的方式绘制 /处理相同的图形数据；
等等。

四、优缺点

五、举例
下面是一个应用Strategy模式对vector进行排序的例子，为了简化问题，其中的排序Strategy实际上调用的是STL的排序算法：sort和stable_sort。

#include <iostream>
#include <vector>
#include <algorithm>
#include <time.h>
using namespace std ;

template  < typename T >
class SortStrategy     // Strategy
{
public :
    virtual  void Sort ( vector <T >& v_t  ) =  0 ;
};

template  < typename T >
class SortQuick  :  public SortStrategy <T >     // ConcreateStrategy1
{
public :
    void Sort ( vector <T >& v_t  ) { std ::sort ( v_t .begin (), v_t .end () ); }
};

template  < typename T >
class SortStable  :  public SortStrategy <T >     // ConcreateStrategy1
{
public :
    void Sort ( vector <T >& v_t  ) { std ::stable_sort (v_t .begin (), v_t .end ()); }
};

template  < typename T >
class Context  {         // Context, who or whose client takes charge of which strategy will be selected
public :
    Context () { m_pStrategy  = NULL ; }
    virtual  ~Context () {  if  (m_pStrategy  != NULL )  delete m_pStrategy ; }

    void SetStrategy (SortStrategy <T >* pStrategy );     // select a strategy

    void ReadVector ( vector <T >& v_t );
    bool SortVector ();
    void OutputVector ();
private :
    vector <T > m_vt ;
    SortStrategy <T >*  m_pStrategy ;     // a pointer to current strategy
};

template  < typename T >
void Context <T >::SetStrategy ( SortStrategy <T >* pStrategy  )
{
    if  ( NULL  != m_pStrategy  )
        delete m_pStrategy ;

    m_pStrategy  = pStrategy ;
}

template  < typename T >
void Context <T >::ReadVector ( vector <T >& v_t )
{
    m_vt .clear ();
    copy ( v_t .begin (), v_t .end (), back_inserter ( m_vt  ) );
}

template  < typename T >
bool Context <T >::SortVector ()
{
    if  ( NULL  == m_pStrategy  )
        return  false;

    m_pStrategy ->Sort ( m_vt  );

    return  true;
}

template  < typename T >
void Context <T >::OutputVector ()
{
    copy ( m_vt .begin (), m_vt .end (), ostream_iterator <T >( cout ,  " "  ) );
}

// a functor to generate random int
struct RandGen
{
    RandGen ( int ratio ) { m_ratio  = ratio ; }
    int  operator () () {  return rand () % m_ratio  +  1 ; }
private :
    int m_ratio ;
};

int  main ()
{
    const  int NUM  =  9 ;
    vector <  int  > vi ;
    time_t t ;
    srand ( ( unsigned ) time (&t ) );

    // create a vector with random information
    vi .reserve (NUM  +  1 );
    generate_n (back_inserter (vi ), NUM , RandGen (NUM ));

    Context <  int  >  con ;
    con .SetStrategy (  new SortQuick < int >() );
    con .ReadVector ( vi  );
    con .OutputVector ();

    cout  << endl ;

    con .SortVector ();
    con .OutputVector ();

    return  0 ;
}