0
点赞
收藏
分享

微信扫一扫

设计模式(六)策略模式C++


策略模式定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。该模式使得算法可独立于使用它的客户而变化。
策略模式为了适应不同的需求,只把变化点封装了,这个变化点就是实现不同需求的算法,但是,用户需要知道各种算法的具体情况。就像加班工资,不同的加班情况,有不同的算法。我们不能在程序中将计算工资的算法进行硬编码,而是能自由的变化的。这就是策略模式。

角色:
    抽象策略角色(Strategy): 抽象策略类。
    具体策略角色(ConcreteStrategy):封装了继续相关的算法和行为。
    环境角色(Context):持有一个策略类的引用,最终给客户端调用。

下面是最直观最简单的策略模式

#include <iostream>
#include <windows.h>
using namespace std;

// The abstract strategy
class Strategy
{
public:
virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyA." << endl;
}
};

class ConcreteStrategyB : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyB." << endl;
}
};

class ConcreteStrategyC : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyC." << endl;
}
};

class Context
{
public:
Context(Strategy *pStrategyArg) : pStrategy(pStrategyArg)
{
}
void ContextInterface()
{
pStrategy->AlgorithmInterface();
}
private:
Strategy *pStrategy;
};

int main()
{
// Create the Strategy
Strategy *pStrategyA = new ConcreteStrategyA;
Strategy *pStrategyB = new ConcreteStrategyB;
Strategy *pStrategyC = new ConcreteStrategyC;
Context *pContextA = new Context(pStrategyA);
Context *pContextB = new Context(pStrategyB);
Context *pContextC = new Context(pStrategyC);
pContextA->ContextInterface();
pContextB->ContextInterface();
pContextC->ContextInterface();

if (pStrategyA) delete pStrategyA;
if (pStrategyB) delete pStrategyB;
if (pStrategyC) delete pStrategyC;

if (pContextA) delete pContextA;
if (pContextB) delete pContextB;
if (pContextC) delete pContextC;

system("pause");

return 0;
}

在实际操作的过程中,我们会发现,在main函数中,也就是在客户端使用策略模式时,会创建非常多的Strategy,而这样就莫名的增加了客户端的压力,让客户端的复杂度陡然增加了。怎么办?可以把策略直接作为参数传递给Context,但是Context内部要有对资源的释放部分

更改之后如下

#include <iostream>
#include <windows.h>
#define free_ptr(p) \
if(p) delete p; p = NULL;

using namespace std;

// The abstract strategy
class Strategy
{
public:
virtual void AlgorithmInterface() = 0;
};

class ConcreteStrategyA : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyA." << endl;
}
};

class ConcreteStrategyB : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyB." << endl;
}
};

class ConcreteStrategyC : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyC." << endl;
}
};

class Context
{
public:
Context(Strategy *pStrategyArg) : m_pStrategy(pStrategyArg)
{
}
~Context()
{
free_ptr(m_pStrategy);
}

void ContextInterface()
{
m_pStrategy->AlgorithmInterface();
}
private:
Strategy *m_pStrategy;
};

int main()
{
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;
if (pContextB) delete pContextB;
if (pContextC) delete pContextC;

system("pause");

return 0;
}

第三种实现方式是简单工厂+策略模式,通过简单工厂同样能够避免一次创建多个Strategy,代码如下

#include <iostream>
#include <windows.h>
using namespace std;

// Define the strategy type
typedef enum StrategyType
{
StrategyA,
StrategyB,
StrategyC
}STRATEGYTYPE;

// The abstract strategy
class Strategy
{
public:
virtual void AlgorithmInterface() = 0;
virtual ~Strategy() = 0; // 谢谢hellowei提出的bug,具体可以参见评论
};

Strategy::~Strategy()
{}

class ConcreteStrategyA : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyA." << endl;
}

~ConcreteStrategyA() {}
};

class ConcreteStrategyB : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyB." << endl;
}

~ConcreteStrategyB() {}
};

class ConcreteStrategyC : public Strategy
{
public:
void AlgorithmInterface()
{
cout << "I am from ConcreteStrategyC." << endl;
}

~ConcreteStrategyC() {}
};

class Context
{
public:
Context(STRATEGYTYPE strategyType)
{
switch (strategyType)
{
case StrategyA:
pStrategy = new ConcreteStrategyA;
break;

case StrategyB:
pStrategy = new ConcreteStrategyB;
break;

case StrategyC:
pStrategy = new ConcreteStrategyC;
break;

default:
break;
}
}

~Context()
{
if (pStrategy) delete pStrategy;
}

void ContextInterface()
{
if (pStrategy)
pStrategy->AlgorithmInterface();
}

private:
Strategy *pStrategy;
};

int main()
{
Context *pContext = new Context(StrategyA);
pContext->ContextInterface();

if (pContext) delete pContext;

system("pause");
return 0;
}

​​参考链接​​

​​参考链接2​​


举报

相关推荐

0 条评论