设计模式之状态模式

在后续的随笔中将会注意“类的前置声明”和“类的头文件”这两者的使用。

#pragma once

class Context;

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

    virtual void OperationInterface(Context *) = 0;

    virtual void OperationChangeState(Context *) = 0;

protected:
    bool ChangeState(Context *con, State *st);
};

#include "State.h"
#include "Context.h"
#include <iostream>


State::State()
{
}


State::~State()
{
}

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

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

void State::OperationChangeState(Context *con)
{
    return;
}

 

#pragma once
#include "State.h"

class Context;

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

    virtual void OperationInterface(Context *);

    virtual void OperationChangeState(Context *);
};

#include "ConcreateStateA.h"
#include "ConcreateStateB.h"
#include "Context.h"
#include <iostream>


ConcreateStateA::ConcreateStateA()
{
}


ConcreateStateA::~ConcreateStateA()
{
}

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

void ConcreateStateA::OperationChangeState(Context *con)
{
    OperationInterface(con);

    this->ChangeState(con, new ConcreateStateB());
}

 

#pragma once
#include "State.h"

class Context;

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

    virtual void OperationInterface(Context *);

    virtual void OperationChangeState(Context *);
};

#include "ConcreateStateB.h"
#include "ConcreateStateA.h"
#include "Context.h"
#include <iostream>


ConcreateStateB::ConcreateStateB()
{
}


ConcreateStateB::~ConcreateStateB()
{
}

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

void ConcreateStateB::OperationChangeState(Context *con)
{
    OperationInterface(con);

    this->ChangeState(con, new ConcreateStateA());
}

 

#pragma once

class State;

class Context
{
public:
    Context();
    ~Context();

    Context(State *state);

    void OperationInterface();

    void OperationChangeState();

private:
    friend class State;　　//State类中可以访问Context的私有字段

    bool ChangeState(State *state);

    State *m_state;
};

#include "Context.h"
#include "State.h"


Context::Context()
{
}


Context::~Context()
{
}

Context::Context(State *state)
{
    this->m_state = state;
}

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

bool Context::ChangeState(State *state)
{
    this->m_state = state;
    return true;
}

void Context::OperationChangeState()
{
    m_state->OperationChangeState(this);
}

 

测试

#include <iostream>
#include "Context.h"
#include "ConcreateStateA.h"
#include "ConcreateStateB.h"

int main()
{
    State *st = new ConcreateStateA();
    Context *con = new Context(st);

    con->OperationChangeState();

    con->OperationChangeState();

    con->OperationChangeState();

    if (con)
    {
        delete con;
        con = NULL;
    }

    if (st)
    {
        delete st;
        st = NULL;
    }
    std::cout << "Hello World!\n"; 
}