1. 策略模式:
它定义了算法家族, 分别封装起来,使他们之间可以相互替换,此模式让算法变化, 不会影响到使用算法的客户。
用相同的方法调用不同的算法,减少各种算法类与使用算法类之间的耦合。
实例中策略模式与工厂模式相结合,不同之处在于 main函数的使用体现,
如果用但纯的工厂模式则必须知道两个类, 但是两种模式结合后,客户端只需要知道一个类 context .
另外,工厂模式生产的是具体的算法, 而策略模式则是能通过不同策略调用不同算法,直接获取需要的结果。
实例:
strategy.h 策略基类
#ifndef STRATEGY_H
#define STRATEGY_H
class Strategy
{
public:
Strategy();
void virtual AlgorithmInterface();
};
#endif // STRATEGY_H
strategy.cpp
#include "strategy.h"
Strategy::Strategy()
{
}
void Strategy::AlgorithmInterface()
{
}
concretestrategy.h 具体策略实现, 省篇幅,写在一起
#ifndef CONCRETESTRATEGY_H
#define CONCRETESTRATEGY_H
#include "strategy.h"
class ConcreteStrategyA : public Strategy
{
public:
void AlgorithmInterface();
};
class ConcreteStrategyB : public Strategy
{
public:
void AlgorithmInterface();
};
class ConcreteStrategyC : public Strategy
{
public:
void AlgorithmInterface();
};
#endif // CONCRETESTRATEGY_H
concretestrategy.cpp
#include "concretestrategy.h"
#include <stdio.h>
void ConcreteStrategyA::AlgorithmInterface()
{
printf("ConcreteStrategyA\n");
}
void ConcreteStrategyB::AlgorithmInterface()
{
printf("ConcreteStrategyB\n");
}
void ConcreteStrategyC::AlgorithmInterface()
{
printf("ConcreteStrategyC\n");
}
context.h 上下文类
#ifndef CONTEXT_H
#define CONTEXT_H
#include "strategy.h"
#include "concretestrategy.h"
#include <string>
using namespace std;
class Context
{
public:
Context(string type);
Strategy* strategy;
void contextInterFace();
};
#endif // CONTEXT_H
context.cpp
#include "context.h"
Context::Context(string type)
{
if( type == "A" )
strategy = new ConcreteStrategyA();
else if( type == "B" )
strategy = new ConcreteStrategyB();
else if( type == "C" )
strategy = new ConcreteStrategyC();
}
void Context::contextInterFace()
{
strategy->AlgorithmInterface();
}
main.cpp
#include <iostream>
#include "context.h"
using namespace std;
int main()
{
cout << "strategy test!" << endl;
Context *context = new Context("C");
context->contextInterFace();
return 0;
}