笔记：Gof设计模式--Strategy

1、意图

  Define a family of algorithms, encapsulate each one, and make them interchangeable.Strategy lets the algorithm vary independently from clients that use it.

2、适应性

  Use the Strategy pattern
  •  many related classes differ only in their behavior. Strategiesprovide a way to configure a class with one of many behaviors.

  •  you need different variants of an algorithm. For example, you might definealgorithms reflecting different space/time trade-offs.Strategies can be used when these variants are implemented as a classhierarchy of algorithms [HO87].
  •  an algorithm uses data that clients shouldn't know about. Use theStrategy pattern to avoid exposing complex, algorithm-specific datastructures.

  •  a class defines many behaviors, and these appear as multipleconditional statements in its operations. Instead of manyconditionals, move related conditional branches into their ownStrategy class.

3、结构

4、示例代码

  The Composition class maintains a collection ofComponent instances, which represent text and graphicalelements in a document. Note that Compositor is an abstract class. Concretesubclasses define specific linebreaking strategies.

class Composition { public:     Composition(Compositor*);     void Repair(); private:     Compositor* _compositor;     Component* _components;     // the list of components     int _componentCount;        // the number of components     int _lineWidth;              // the Composition's line width     int* _lineBreaks;            // the position of linebreaks     // in components     int _lineCount;             // the number of lines }; void Composition::Repair () {     Coord* natural;     Coord* stretchability;     Coord* shrinkability;     int componentCount;     int* breaks;      // prepare the arrays with the desired component sizes     // ...      // determine where the breaks are:     int breakCount;     breakCount = _compositor->Compose(     natural, stretchability, shrinkability,     componentCount, _lineWidth, breaks     );      // lay out components according to breaks     // ... } 

 The Compositor interface lets the composition pass thecompositor all the information it needs. This is an example of"taking the data to the strategy":

class Compositor { public:     virtual int Compose(     Coord natural[], Coord stretch[], Coord shrink[],     int componentCount, int lineWidth, int breaks[]     ) = 0; protected:     Compositor(); }; 

Now let's look at the Compositor subclasses:

// SimpleCompositor examines components a line at a time todetermine where breaks should go:class SimpleCompositor : public Compositor { public:   SimpleCompositor();   virtual int Compose(   Coord natural[], Coord stretch[], Coord shrink[],   int componentCount, int lineWidth, int breaks[]    );   // ... }; // TeXCompositor uses a more global strategy. It examines a paragraph at a time, taking // into account the components' sizeand stretchability.class TeXCompositor : public Compositor { public:   TeXCompositor();   virtual int Compose(   Coord natural[], Coord stretch[], Coord shrink[],   int componentCount, int lineWidth, int breaks[]   );   // ... }; // ArrayCompositor breaks the components into lines at regularintervals. class ArrayCompositor : public Compositor { public:   ArrayCompositor(int interval);   virtual int Compose(   Coord natural[], Coord stretch[], Coord shrink[],   int componentCount, int lineWidth, int breaks[]   );   // ... }; 

// To instantiate Composition, you pass it the compositoryou want to use:  Composition* quick = new Composition(new SimpleCompositor);  Composition* slick = new Composition(new TeXCompositor);  Composition* iconic = new Composition(new ArrayCompositor(100));