设计模式之一策略模式（c++实现）

最新推荐文章于 2024-06-27 23:35:14 发布

godop

最新推荐文章于 2024-06-27 23:35:14 发布

阅读量183

点赞数

分类专栏：设计模式

设计模式专栏收录该内容

1 篇文章

订阅专栏

前段时间春招实习面试，面试官问到设计模式这方面问题，没学过，很尬。马上又要面试，就补一补设计模式知识。

这是在网上看的，分别摘自两位大佬，感觉写的不错，自作主张将他们总结了一下

http://www.cnblogs.com/wanggary/archive/2011/04/07/2008796.html 文中实例出自这篇文章

https://blog.youkuaiyun.com/lh844386434/article/details/16825861 很多定义则出自这篇文章

定义：策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

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

UML图：

简单提示和实现编码。

1.1.解释

main()，赵云

CContext，锦囊

IStrategy，策略接口

CBackDoor，策略之一

CGivenGreenLight，策略之二

CBlockEnemy，策略之三

说明：一个策略放到一个锦囊里。当用的时候，找到这个锦囊，从锦囊里拿出策略来使用。

注意：锦囊只是简单的装载和调用策略，锦囊里没有逻辑。策略会有更大的自主权，运行更多的逻辑。

看代码：

//Context.h

#pragma once
#include "IStrategy.h"
class CContext
{
public:
    CContext(IStrategy *pStrategy);
    ~CContext(void);
    void Operate(void);
private:
    IStrategy *m_pStrategy;
};

//Context.cpp

#include "StdAfx.h"
#include "Context.h"
CContext::CContext(IStrategy *pStrategy)
{
    this->m_pStrategy = pStrategy;
}
CContext::~CContext(void)
{
    delete this->m_pStrategy;
}
void CContext::Operate(void)
{
    this->m_pStrategy->Operate();
}

//IStrategy.h

#pragma once

class IStrategy
{
public:
    IStrategy(void);
    virtual ~IStrategy(void);
    virtual void Operate(void) = 0;
};

//BackDoor.h

#pragma once
#include "istrategy.h"
class CBackDoor :
    public IStrategy
{
public:
    CBackDoor(void);
    ~CBackDoor(void);
    void Operate(void);
};

//BackDoor.cpp

#include "StdAfx.h"
#include "BackDoor.h"
#include <iostream>
using std::cout;
using std::endl;
CBackDoor::CBackDoor(void)
{
}
CBackDoor::~CBackDoor(void)
{
}
void CBackDoor::Operate(void)
{
    cout << "找乔国老帮忙，让吴国太给孙权施加压力" << endl;
}

//GivenGreenLight.h

#pragma once
#include "istrategy.h"
class CGivenGreenLight :
    public IStrategy
{
public:
    CGivenGreenLight(void);
    ~CGivenGreenLight(void);
    void Operate(void);
};

//GivenGreenList.cpp

#include "StdAfx.h"
#include "GivenGreenLight.h"
#include <iostream>
using std::cout;
using std::endl;
CGivenGreenLight::CGivenGreenLight(void)
{
}
CGivenGreenLight::~CGivenGreenLight(void)
{
}
void CGivenGreenLight::Operate(void)
{
    cout << "求吴国太开个绿灯，放行！" << endl;
}

//BlockEnemy.h

#pragma once
#include "istrategy.h"
class CBlockEnemy :
    public IStrategy
{
public:
    CBlockEnemy(void);
    ~CBlockEnemy(void);
    void Operate(void);
};

//BlockEnemy.cpp

#include "StdAfx.h"
#include "BlockEnemy.h"
#include <iostream>
using std::cout;
using std::endl;
CBlockEnemy::CBlockEnemy(void)
{
}
CBlockEnemy::~CBlockEnemy(void)
{
}
void CBlockEnemy::Operate()
{
    cout << "孙夫人断后，挡住追兵" << endl;
}

//Strategy.cpp

#include "stdafx.h"
#include "Context.h"
#include "BackDoor.h"
#include "GivenGreenLight.h"
#include "BlockEnemy.h"
#include <iostream>
using std::cout;
using std::endl;
int _tmain(int argc, _TCHAR* argv[])
{
    CContext *pContext;

    cout << "\14\n\n\n\n\17" << endl;
    cout << "----------刚刚到吴国的时候拆第一个----------" << endl;
    pContext = new CContext(new CBackDoor());
    pContext->Operate();
    delete pContext;

    cout << "\14\n\n\n\n\17" << endl;
    cout << "----------刘备乐不思蜀了，拆第二个了----------" << endl;
    pContext = new CContext(new CGivenGreenLight());
    pContext->Operate();
    delete pContext;

    cout << "\14\n\n\n\n\17" << endl;
    cout << "----------孙权的小兵追了，咋办？拆第三个----------" << endl;
    pContext = new CContext(new CBlockEnemy());
    pContext->Operate();
    delete pContext;

    _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
    _CrtDumpMemoryLeaks();
    return 0;
}

总的说来策略模式：

优点：
1、使用策略模式可以避免使用多重条件转移语句。多重转移语句不易维护。
2、策略模式让你可以动态的改变对象的行为，动态修改策略

缺点：
1、客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
2、类过多---策略模式造成很多的策略类，每个具体策略类都会产生一个新类。（这点可以通过享元模式来克服类过多）