设计模式学习之------State模式（状态模式）

什么是状态模式

状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。
1. 这个模式将状态封装成为独立的类，并将动作委托到代表当前状态的对象，我们知道行为会随着内部状态而改变。
2. 使用组合通过简单因为不同的状态对象来造成类改变的假象。

/*
 * IState.h
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */

#ifndef ISTATE_H_
#define ISTATE_H_
class Context;
class IState {
public:
    IState() {m_pContext = NULL;};
    virtual ~IState() {};
    virtual void Handler() = 0;
protected:
    Context *m_pContext;
};
#endif /* ISTATE_H_ */

/*
 * ConcreteStateA.h
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */

#ifndef CONCRETESTATEA_H_
#define CONCRETESTATEA_H_
#include "IState.h"
class ConcreteStateA : public IState
{
public:
    ConcreteStateA(Context *context);
    ~ConcreteStateA(void);
    void Handler();
};



#endif /* CONCRETESTATEA_H_ */

/*
 * ConcreteStateA.cpp
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */
#include <iostream>
#include "Context.h"
#include "ConcreteStateA.h"
#include "ConcreteStateB.h"
using namespace std;

ConcreteStateA::ConcreteStateA(Context * context)
{
    m_pContext = context;
}
ConcreteStateA::~ConcreteStateA()
{
}

void ConcreteStateA::Handler()
{
    cout << "current state is A" << endl;
    m_pContext->SetState(Context::pConcreteStateB);
}

/*
 * ConcreteStateB.h
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */

#ifndef CONCRETESTATEB_H_
#define CONCRETESTATEB_H_


#include "IState.h"
class ConcreteStateB : public IState
{
public:
    ConcreteStateB(Context *context);
    ~ConcreteStateB(void);
    void Handler();
};

#endif

/*
 * ConcreteStateB.cpp
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */

#include <iostream>
#include "ConcreteStateA.h"
#include "ConcreteStateB.h"
#include "Context.h"
using namespace std;

ConcreteStateB::ConcreteStateB(Context *context)
{
    m_pContext = context;
}
ConcreteStateB::~ConcreteStateB()
{
}
void ConcreteStateB::Handler()
{
    cout << "current state is B" << endl;
    m_pContext->SetState(Context::pConcreteStateA);
}

/*
 * Context.h
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */

#ifndef CONTEXT_H_
#define CONTEXT_H_
#include "IState.h"
#include "ConcreteStateA.h"
#include "ConcreteStateB.h"
class Context {
public:
    Context();
    Context(IState *state);
    ~Context();
    static ConcreteStateA *pConcreteStateA;
    static ConcreteStateB *pConcreteStateB;
    void SetState(IState *state);
    void Handler();
private:
    IState *m_pstate;
};
#endif /* CONTEXT_H_ */

/*
 * Context.cpp
 *
 *  Created on: Jul 4, 2017
 *      Author: gwwu
 */
#include <iostream>
#include "Context.h"
using namespace std;
Context::Context(IState *state)
{
    m_pstate = state;
    pConcreteStateA = new ConcreteStateA(this);
    pConcreteStateB = new ConcreteStateB(this);
}
ConcreteStateA* Context::pConcreteStateA = NULL;
ConcreteStateB* Context::pConcreteStateB = NULL;

Context::Context()
{
    m_pstate = NULL;
    pConcreteStateA = new ConcreteStateA(this);
    pConcreteStateB = new ConcreteStateB(this);
}
Context::~Context()
{
    delete pConcreteStateA;
    pConcreteStateA = NULL;
    delete pConcreteStateB;
    pConcreteStateB = NULL;
}

void Context::SetState(IState *state)
{
    m_pstate = state;
}

void Context::Handler()
{
    m_pstate->Handler();
}
int main(int argc, char *argv[])
{
    Context context;
    context.SetState(Context::pConcreteStateA);
    context.Handler();
    context.Handler();
    context.Handler();
    context.Handler();
    return 0;
}

编译运行：