状态模式 C++实现

这个模式太绕了，核心是各个状态的自动切换，Mark一下。cpp文件：

// state.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include "state.h"

Context::Context ( ) :_state (0)
{

}

Context::Context (State* st) : _state (st)
{

}

Context::~Context ( )
{
    if(_state)
    {
        delete _state;
        _state = 0;
    }
}

void Context::OperationInterface ( )
{
    _state->OperationInterface (this);
}

void Context::OperationChangState ( )
{
    if (_state)
        _state->OperationChangeState (this);
}

bool Context::ChangeState (State* st)
{
     State* _s = this->_state;
    if(_s)
    {
        delete _s;
        _s = 0;
    }
    this->_state = st;
    return true;
}
//------------------------------------------
State::State ( )
{

}

State::~State ( )
{
    //std::cout << "State::~State ( )" << std::endl;
}

void State::OperationInterface (Context*)
{
    std::cout << "State..." << std::endl;
}

void State::OperationChangeState (Context* co)
{

}

bool State::ChangeState (Context* c, State* st)
{
    return c->ChangeState (st);
}

//--------------------------------------------

ConcreteStateA::ConcreteStateA ( ) :State ( ) {};

ConcreteStateA::~ConcreteStateA ( ) {};

void ConcreteStateA::OperationInterface (Context*)
{
    std::cout << "ConcreteStateA:OperationInterface" << std::endl;
}
void ConcreteStateA::OperationChangeState (Context* co)
{
    OperationInterface (co);
    this->ChangeState (co, new ConcreteStateB ( ));
}

ConcreteStateB::ConcreteStateB ( ) {};

ConcreteStateB::~ConcreteStateB ( ) {};

void ConcreteStateB::OperationInterface (Context*)
{
    std::cout << "ConcreteStateB:OperationInterface" << std::endl;
}
void ConcreteStateB::OperationChangeState (Context* co)
{
    OperationInterface (co);
    this->ChangeState (co, new ConcreteStateA ( ));
}


int _tmain(int argc, _TCHAR* argv[])
{
    State* st = new ConcreteStateA ( );
    Context* co = new Context (st);
    co->OperationChangState ( );
    co->OperationChangState ( );
    co->OperationChangState ( );
    delete co;

	return 0;
}

h文件：

#ifndef STATE_H_
#define STATE_H_

class State;

class Context
{
public:
    Context ( );
    Context (State* st);
    ~Context ( );
    void OperationInterface ( );
    void OperationChangState ( );
private:
    friend class State;
    bool ChangeState (State* st);
private:
    State* _state;
};


class State
{
public:
    State ( );
    virtual ~State ( );
    virtual void OperationInterface (Context*) = 0;
    virtual void OperationChangeState (Context*) = 0;
protected:
    virtual bool ChangeState (Context* c, State* st);
};


class ConcreteStateB : public State
{
public:
    ConcreteStateB ( );
    virtual ~ConcreteStateB ( );
    virtual void OperationInterface (Context*);
    virtual void OperationChangeState (Context* co);

};

class ConcreteStateA : public State
{
public:
    ConcreteStateA ( );
    virtual ~ConcreteStateA ( );

    virtual void OperationInterface (Context*);
    virtual void OperationChangeState (Context* co);
};

#endif //STATE_H_