设计模式C++学习笔记之十九（State状态模式）

最新推荐文章于 2021-11-09 22:25:20 发布
转载 最新推荐文章于 2021-11-09 22:25:20 发布 · 434 阅读 · 0
文章标签：

#设计模式

本文通过电梯控制实例详细解析了状态模式的实现方式与应用场景，展示了如何利用状态模式简化复杂逻辑。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

博文很精彩，为方便个人学习特转载，地址：http://www.cnblogs.com/wanggary/archive/2011/04/21/2024117.html
19.1.解释

概念：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。

main()，客户

CLiftState，电梯状态抽象类

CCloseingState，电梯门关闭

COpenningState，电梯门打开

CRunningState，电梯运行

CStoppingState，电梯停止

CContext，电梯的控制面板

说明：CContext保持电梯的状态，并提供操作的接口函数。当函数被调用时，CContext直接调用当前状态的相应函数。由状态的接口函数来确定是否可以执行这个动作，以及修改状态为执行这个动作后的状态。

看代码：第一块是不使用模式的做法，第二块是使用模式的做法，在main()函数里会有调用的方式。

复制代码
//ILift.h
#pragma once
class ILift
{
public:

    ILift(void)
    {
    }

    virtual ~ILift(void)
    {
    }
    static const int OPENING_STATE = 1;
    static const int CLOSING_STATE = 2;
    static const int RUNNING_STATE = 3;
    static const int STOPPING_STATE = 4;
    virtual void SetState(int state) = 0;
    virtual void Open() = 0;
    virtual void Close() = 0;
    virtual void Run() = 0;
    virtual void Stop() = 0;
};

//Lift.h
#pragma once
#include "ilift.h"
class CLift :
    public ILift
{
public:
    CLift(void);
    ~CLift(void);
    void SetState(int state);
    void Open();
    void Close();
    void Run();
    void Stop();
private:
    int m_state;
    void OpenWithoutLogic();
    void CloseWithoutLogic();
    void RunWithoutLogic();
    void StopWithoutLogic();
};

//Lift.cpp
#include "StdAfx.h"
#include "Lift.h"
#include <iostream>
using std::cout;
using std::endl;

CLift::CLift(void)
{
    this->m_state = 0;
}

CLift::~CLift(void)
{
}

void CLift::SetState(int state)
{
    this->m_state = state;
}

void CLift::Open()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:
        this->OpenWithoutLogic();
        this->SetState(OPENING_STATE);
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        this->OpenWithoutLogic();
        this->SetState(OPENING_STATE);
        break;
    }
}

void CLift::Close()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        this->CloseWithoutLogic();
        this->SetState(CLOSING_STATE);
        break;
    case CLOSING_STATE:
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        break;
    }
}

void CLift::Run()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:
        this->RunWithoutLogic();
        this->SetState(RUNNING_STATE);
        break;
    case RUNNING_STATE:
        break;
    case STOPPING_STATE:
        this->RunWithoutLogic();
        this->SetState(RUNNING_STATE);
        break;
    }
}

void CLift::Stop()
{
    switch(this->m_state)
    {
    case OPENING_STATE:
        break;
    case CLOSING_STATE:
        this->StopWithoutLogic();
        this->SetState(CLOSING_STATE);
        break;
    case RUNNING_STATE:
        this->StopWithoutLogic();
        this->SetState(CLOSING_STATE);
        break;
    case STOPPING_STATE:
        break;
    }
}

void CLift::OpenWithoutLogic()
{
    cout << "电梯门开启..." << endl;
}

void CLift::CloseWithoutLogic()
{
    cout << "电梯门关闭..." << endl;
}

void CLift::RunWithoutLogic()
{
    cout << "电梯上下跑起来..." << endl;
}

void CLift::StopWithoutLogic()
{
    cout << "电梯停止了..." << endl;
}
复制代码

复制代码
//LiftState.h
#pragma once
class CContext;
class CLiftState
{
public:
    CLiftState(void);
    virtual ~CLiftState(void);
    void SetContext(CContext *pContext);
    virtual void Open() = 0;
    virtual void Close() = 0;
    virtual void Run() = 0;
    virtual void Stop() = 0;
protected:
    CContext *m_pContext;
};

//LiftState.cpp
#include "StdAfx.h"
#include "LiftState.h"

CLiftState::CLiftState(void)
{
}

CLiftState::~CLiftState(void)
{
}

void CLiftState::SetContext( CContext *pContext )
{
    m_pContext = pContext;
}

//CloseingState.h
#pragma once
#include "liftstate.h"
class CCloseingState :
    public CLiftState
{
public:
    CCloseingState(void);
    ~CCloseingState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//CloseingState.cpp
#include "StdAfx.h"
#include "CloseingState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

CCloseingState::CCloseingState(void)
{
}

CCloseingState::~CCloseingState(void)
{
}

void CCloseingState::Open()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);
    this->CLiftState::m_pContext->GetLiftState()->Open();
}

void CCloseingState::Close()
{
    cout << "电梯门关闭..." << endl;
}

void CCloseingState::Run()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);
    this->CLiftState::m_pContext->GetLiftState()->Run();
}

void CCloseingState::Stop()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);
    this->CLiftState::m_pContext->GetLiftState()->Stop();
}

//OpenningState.h
#pragma once
#include "liftstate.h"
class COpenningState :
    public CLiftState
{
public:
    COpenningState(void);
    ~COpenningState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//OpenningState.cpp
#include "StdAfx.h"
#include "OpenningState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

COpenningState::COpenningState(void)
{
}

COpenningState::~COpenningState(void)
{
}

void COpenningState::Open()
{
    cout << "电梯门开启..." << endl;
}

void COpenningState::Close()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pCloseingState);
    this->CLiftState::m_pContext->GetLiftState()->Close();
}

void COpenningState::Run()
{
    //do nothing
}

void COpenningState::Stop()
{
    //do nothing
}

//RunningState.h
#pragma once
#include "liftstate.h"
class CRunningState :
    public CLiftState
{
public:
    CRunningState(void);
    ~CRunningState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//RunningState.cpp
#include "StdAfx.h"
#include "RunningState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

CRunningState::CRunningState(void)
{
}

CRunningState::~CRunningState(void)
{
}

void CRunningState::Open()
{
    //do nothing
}

void CRunningState::Close()
{
    //do nothing
}

void CRunningState::Run()
{
    cout << "电梯上下跑..." << endl;
}

void CRunningState::Stop()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pStoppingState);
    this->CLiftState::m_pContext->GetLiftState()->Stop();
}

//StoppingState.h
#pragma once
#include "liftstate.h"
class CStoppingState :
    public CLiftState
{
public:
    CStoppingState(void);
    ~CStoppingState(void);
    void Open();
    void Close();
    void Run();
    void Stop();
};

//StoppingState.cpp
#include "StdAfx.h"
#include "StoppingState.h"
#include "Context.h"
#include <iostream>
using std::cout;
using std::endl;

CStoppingState::CStoppingState(void)
{
}

CStoppingState::~CStoppingState(void)
{
}

void CStoppingState::Open()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pOpenningState);
    this->CLiftState::m_pContext->GetLiftState()->Open();
}

void CStoppingState::Close()
{
    //do nothing
}

void CStoppingState::Run()
{
    this->CLiftState::m_pContext->SetLiftState(CContext::pRunningState);
    this->CLiftState::m_pContext->GetLiftState()->Run();
}

void CStoppingState::Stop()
{
    cout << "电梯停止了..." << endl;
}
复制代码

复制代码
//Contex.h
#pragma once
#include "LiftState.h"
#include "OpenningState.h"
#include "CloseingState.h"
#include "RunningState.h"
#include "StoppingState.h"
class CContext
{
public:
    CContext(void);
    ~CContext(void);
    static COpenningState *pOpenningState;
    static CCloseingState *pCloseingState;
    static CRunningState *pRunningState;
    static CStoppingState *pStoppingState;
    CLiftState * GetLiftState();
    void SetLiftState(CLiftState *pLiftState);
    void Open();
    void Close();
    void Run();
    void Stop();
private:
    CLiftState *m_pLiftState;
};

//Context.cpp
#include "StdAfx.h"
#include "Context.h"
COpenningState* CContext::pOpenningState = NULL;
CCloseingState* CContext::pCloseingState = NULL;
CRunningState* CContext::pRunningState = NULL;
CStoppingState* CContext::pStoppingState = NULL;

CContext::CContext(void)
{
    m_pLiftState = NULL;
    pOpenningState = new COpenningState();
    pCloseingState = new CCloseingState();
    pRunningState = new CRunningState();
    pStoppingState = new CStoppingState();
}

CContext::~CContext(void)
{
    delete pOpenningState;
    pOpenningState = NULL;
    delete pCloseingState;
    pCloseingState = NULL;
    delete pRunningState;
    pRunningState = NULL;
    delete pStoppingState;
    pStoppingState = NULL;
}

CLiftState * CContext::GetLiftState()
{
    return m_pLiftState;
}

void CContext::SetLiftState(CLiftState *pLiftState)
{
    this->m_pLiftState = pLiftState;
    this->m_pLiftState->SetContext(this);
}

void CContext::Open()
{
    this->m_pLiftState->Open();
}

void CContext::Close()
{
    this->m_pLiftState->Close();
}

void CContext::Run()
{
    this->m_pLiftState->Run();
}

void CContext::Stop()
{
    this->m_pLiftState->Stop();
}

// State.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include "ILift.h"
#include "Lift.h"
#include "Context.h"
#include "OpenningState.h"
#include "CloseingState.h"
#include "RunningState.h"
#include "StoppingState.h"
#include <iostream>
using std::cout;
using std::endl;

void DoIt()
{
    //ILift.h, Lift.h, Lift.cpp
    ILift *pLift = new CLift();
    pLift->SetState(ILift::STOPPING_STATE);//电梯的初始条件是停止状态。
    pLift->Open();//首先是电梯门开启，人进去
    pLift->Close();//然后电梯门关闭
    pLift->Run();//再然后，电梯跑起来，向上或者向下
    pLift->Stop();//最后到达目的地，电梯停下来
    delete pLift;
}


void DoNew()
{
    //LiftState.h, LiftState.cpp, OpenningState.h, CloseingState.h, RunningState.h, StoppingState.h
    //Context.h, Context.cpp
    CContext context;
    CCloseingState closeingState;
    context.SetLiftState(&closeingState);
    context.Close();
    context.Open();
    context.Run();
    context.Stop();
}

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "----------使用模式之前----------" << endl;
    DoIt();
    cout << "----------使用模式之后----------" << endl;
    DoNew();

    _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF | _CRTDBG_ALLOC_MEM_DF);
    _CrtDumpMemoryLeaks();
    return 0;
}
复制代码

状态模式也是行为型模式。写了好多天了，才发现如何在页面上插入代码。这样方便多了，看起来也清楚多了。博客园也许需要开个入门贴子，免得新来博客园的童鞋都不大会用。这几天还在学习数据结构中的排序，入排序入手来学习数据结构还是比较容易的。上学的时候只顾着考试了，该学的也都学了，但考完试就全忘掉，已经成为了一种习惯。现在再补回来。鼓励自己加油！一定要做一个学习型的程序员。

【c++设计模式18】行为模式3：迭代器模式（Iterator Pattern）
junxuezheng的博客
06-17 826
迭代器模式定义了一个迭代器接口（Iterator），该接口包含了对容器对象（如列表或集合）进行遍历的方法。具体容器对象（Concrete Collection）实现了迭代器接口，并且提供了创建迭代器对象的方法。迭代器对象（Iterator Object）封装了对容器对象的访问和遍历逻辑。
状态模式（State）
行走
05-04 590
设计模式系列 State 状态模式——对象行为模式 1.意图 允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。 2.适用性 一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为。 一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常，有多个操作包含这一相同的条件结构。State模式...
设计模式之State
Alinker
11-11 1325
State模式的定义: 不同的状态,不同的行为;或者说,每个状态有着相应的行为.何时使用?State模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If elseif else 进行状态切换, 如果针对状态的这样判断切换反复出现,我们就要联想到是否可以采取State模式了.不只是根据状态,也有根据属性.如果某个对象的属性不同,对象的行为就不一样,这点在数据库系统中出现频率比较
基于HeadFirstDesignPatterns的Java设计模式学习源码笔记
最新发布
10-05
而这份笔记则是将书中的概念转化为Java语言的实例，提供了学习设计模式的实战应用。 首先，设计模式可以大致分为三大类：创建型模式、结构型模式和行为型模式。创建型模式涉及对象的创建机制，结构型模式关注的是类...
大话设计模式学习笔记C++
fazstyle的博客
10-26 885
一、简单工厂模式 1、面向对象的好处 通过封装、继承、多态把程序的耦合度降低。 用设计模式使得程序更加的灵活，容易修改，并且易于复用。 如实现计算机的功能时，将业务逻辑与界面逻辑分开，让它们的耦合度下降。只有分开，才可以达到容易维护或扩展。 2、紧耦合VS.送耦合 计算器有加、减、乘、除等功能，如果在实现加法功能时，影响到乘法功能，则说明两者的的耦合性高，否则为松耦合。 3、简单工厂模式 封装、继承和多态。 用类的方式实现封装，如加法类、减法类等；用父类、子类的方式实现继承，如运算类
《设计模式》学习笔记
09-30
### 设计模式学习笔记 #### 引言 设计模式（Design Patterns）是在软件设计领域内广泛应用的一种实践指南，它提供了一系列解决常见问题的方案。设计模式可以被理解为面向对象软件设计的经验总结，是对特定面向对象...
设计模式学习笔记--状态模式
puppet_master的专栏
04-27 3506
今天来学习一下设计模式中的状态模式。之前经常听说状态机之类的东东，自己也有用过，但是状态机和状态模式还是有一些区别，今天主要看一下状态模式的定义，例子，应用，最后再分析一下状态模式和我们所说的有限状态机之间到底是什么关系。 一.状态模式的定义 所谓状态，我们经常提到。比如水有几种状态，液态，固态，气态，而且达到一定条件之后，水可以在这三种状态之间相互转化。所谓状态模式，是指当一个对象的
Java设计模式系列之状态模式
weixin_34025151的博客
04-18 183
状态模式(State)的定义 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类 状态模式(State)适用性   1.一个对象的行为取决于它的状态,并且它必须在运行时刻根据状态改变它的行为。   2.一个操作中含有庞大的多分支的条件语句，且这些分支依赖于该对象的状态...
java常用设计模式之状态模式
xuedongabc的专栏
08-29 191
------------------------------ 状态模式(state) -------------------------------(1)State模式定义：不同的状态,不同的行为; 或者说,每个状态有着相应的行为.适用场合：State模式在实际使用中比较多,适合"状态的切换".因为我们经常会使用If elseif else 进行状态切换, 如果针对状态的这样判断切换反复出现,我...
STATE模式
小那的博客
10-14 426
STATE模式   有限状态自动机，FSM，是一种抽象，为了将复杂问题简单化，容易理解；并且易于实现和修改。使用有限状态自动机的好处是，即使是复杂系统，也可以清晰的展现系统状态的变化，并且对于各种状态的变化不容易遗漏。 1. 问题描述     分布式系统中，守护进程通常用来监控节点的资源和进程，管理其生命周期，并上报到集群控制模块，例如kuberntes中的kubelet模块。 在这里使用项目中实际遇到的情况通过简化之后作为用例。     集群的每个节点中都拥有多数量多类型执行器。执行器拥有四个状态为： 初
状态模式
u012138730的专栏
04-16 340
状态模式是一种将状态封装成类对象，将与状态相关的行为都封装到类中去作为类成员函数的模式。 在什么时候会使用状态模式呢？——当一个对象的行为取决于他现在所处于的状态，并且在输入事件或者随着时间的推移会改变对象的状态的时候。 状态模式是实现状态机的方法之一，另一方法为是枚举+条件分支，在《游戏编程模式》中的状态模式章节中可以看到分别用这两种方法实现的状态机的事例。 ...
状态(State)模式
qq_38636211的博客
07-30 1111
文章目录状态(State)模式1. 意图2. 别名3. 动机4. 适用性5. 结构6. 参与者7. 协作8. 效果9. 实现10. 代码示例11. 已知应用12. 相关模式13. 设计原则口袋14. 参考文献 状态(State)模式 隶属类别——对象行为模式 1. 意图 允许一个对象在其内部状态发生改变时改变它的行为。对象看起来似乎修改了它的类。 2. 别名 状态对象(Object for St...
状态模式（State模式）
热门推荐
qq_35784669的博客
11-09 1万+
在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。如人都有高兴和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。 对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。但是显然这种做法对
State状态模式
寻找甘当科学家的女人/男人
12-10 524
状态state模式是GOF23种模式中的一种，和命令模式一样，也是一种行为模式。状态模式和命令模式相当像，一样是“接口—实现类”这种模式的应用，是面向接口编程原则的体现。 状态模式属于对象创建型模式，其意图是允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了他的类。比较常见的例子是在一个表示网络连接的类TCPConnection，一个TCPConnection对象的状态处于若干
状态模式(State Pattern)
JayCoding
06-05 528
用类表示状态 1.基本介绍 状态模式使用对象的形式来记录某种状态。使用状态模式可以省去多个if-else或者是switch的判断。可以直接使用对象方法的形式来处理逻辑。 我们在编写代码的时候，遇到大量的条件判断的时候，可能会采用策略模式来优化结构，因为这时涉及到策略的选择，但有时候仔细查看下，就会发现，这些所谓的策略其实是对象的不同状态，更加明显的是，对象的某种状态也成为判断的条件。 2.实例分...
C++状态模式详解与Demo19_State实例分析
资源摘要信息:"设计模式C++学习之状态模式（State）" 状态模式（State）是软件工程中23种设计模式之一，属于行为型模式。该模式的主要目的是允许一个对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值