/
// Strategy pattern
// - Define a family of algorithms, encapsulate each one, and make them
// interchangeable. Strategy lets the algorithm vary independently from
// clients that use it.
// - Code containing many conditional statements often indicates the need to
// apply the Strategy pattern.
//
// Author : ZAsia
// Date : 15/05/17
// Warning : In practice, declaration and implementation should
// be separated(.h and .cpp).
//
#include
using namespace std;
// Strategy
// - declares an interface common to all supported algorithms. Context uses
// this interface to call the algorithm defines by a ConcreteStrategy.
class Strategy
{
public:
virtual void AlgorithmInterface() = 0;
};
// ConcreteStrategy
// - implements the algorithm using the Strategy interface.
class ConcreteStrategyA : public Strategy
{
public:
virtual void AlgorithmInterface()
{
cout << "ConcreteStrategyA::AlgorithmInterface" << endl;
}
};
class ConcreteStrategyB : public Strategy
{
public:
virtual void AlgorithmInterface()
{
cout << "ConcreteStrategyB::AlgorithmInterface" << endl;
}
};
class ConcreteStrategyC : public Strategy
{
public:
virtual void AlgorithmInterface()
{
cout << "ConcreteStrategyC::AlgorithmInterface" << endl;
}
};
// Context
// - is configured with a ConcreteStrategy object.
// - maintains a reference toa Strategy object.
// - may define an interface that lets Strategy access its data.
class Context
{
public:
Context(Strategy *strategy) : _strategy(strategy) { }
~Context()
{
if (_strategy)
{
delete _strategy;
}
}
void ContextInterface()
{
_strategy->AlgorithmInterface();
}
private:
Strategy *_strategy;
};
// collaborations
// - Strategy and Context interact to implement the chosen algorithm. A context
// may pass all data required by the algorithm to the strategy when the algorithm
// is called. Alternatively, the context can pass itself as an argument to Strategy
// operations. That lets the strategy call back on the context as required.
// - A context frowards requests from its clients to its strategy. Clients usually
// create and pass a ConcreteStratey object to the context; thereafter, clients
// interact with the context exclusively. There is often a family of ConcreteStrategy
// classes for a client to choose from.
int main()
{
// here, i make Context responsible for free ConcreteStrategy.
Context *pContextA = new Context(new ConcreteStrategyA());
Context *pContextB = new Context(new ConcreteStrategyB());
Context *pContextC = new Context(new ConcreteStrategyC());
pContextA->ContextInterface();
pContextB->ContextInterface();
pContextC->ContextInterface();
if (pContextA)
{
delete pContextA;
pContextA = nullptr;
}
if (pContextB)
{
delete pContextB;
pContextB = nullptr;
}
if (pContextC)
{
delete pContextC;
pContextC = nullptr;
}
return 0;
}
// 1.Clients must be aware of different Strategies. The pattern has a potential
// drawback in that a client must understand how Strategies differ before it
// can select the appropriate one.
DesignPatterns_Strategy
最新推荐文章于 2021-12-29 22:15:08 发布