C++ 设计模式——状态模式

不是仙人的闲人2024-08-29 21:05

C++ 设计模式------状态模式

    • [C++ 设计模式------状态模式](#C++ 设计模式——状态模式)
      • [1. 主要组成成分](#1. 主要组成成分)
      • [2. 逐步构建状态模式](#2. 逐步构建状态模式)
        • [1. 状态接口定义](#1. 状态接口定义)
        • [2. 具体状态类实现](#2. 具体状态类实现)
        • [3. 上下文类的实现](#3. 上下文类的实现)
        • [4. 主函数](#4. 主函数)
      • [3. 状态模式 UML 图](#3. 状态模式 UML 图)
        • [状态模式 UML 图解析](#状态模式 UML 图解析)
      • [4. 状态模式的优点](#4. 状态模式的优点)
      • [5. 状态模式的缺点](#5. 状态模式的缺点)
      • [6. 状态模式的适用场景](#6. 状态模式的适用场景)
      • 完整代码
        • [1. Monster.h](#1. Monster.h)
        • [2. Monster.cpp](#2. Monster.cpp)
        • [3. MonsterStatus.h](#3. MonsterStatus.h)
        • [4. MonsterStatus.cpp](#4. MonsterStatus.cpp)
        • [5. main.cpp](#5. main.cpp)

C++ 设计模式------状态模式

状态模式（State Pattern）是一种行为型设计模式，它允许对象在其内部状态发生变化时，动态地改变其行为。该模式的核心在于将状态相关的行为封装到独立的状态类中，使得对象的行为随状态而变化，从而减少冗余的条件判断。

1. 主要组成成分

  1. 上下文（Context）：持有一个状态对象的引用，负责与客户端交互，并将请求委托给当前状态对象。
  2. 状态接口（State）：定义了所有具体状态类的公共接口。
  3. 具体状态（Concrete State）：实现了状态接口，封装了与特定状态相关的行为。

2. 逐步构建状态模式

以下是一个简单的状态模式示例，模拟一个怪物的状态变化。

1. 状态接口定义
  • MonsterStatus 是一个抽象类，定义了所有具体状态类必须实现的接口。
  • Attacked 方法用于处理怪物被攻击的逻辑，接受攻击力和怪物对象的引用。
cpp 复制代码 
//怪物状态类的父类
class MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj) = 0;
	virtual ~MonsterStatus() {}
};
2. 具体状态类实现
  • 每个状态类继承自 MonsterStatus，并实现 Attacked 方法。
  • 使用单例模式以确保每种状态只有一个实例，减少内存开销。
cpp 复制代码 
//凶悍状态类
class MonsterStatus_Feroc :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Feroc* getInstance()
	{
		static MonsterStatus_Feroc instance;
		return &instance;
	}

};

//不安状态类
class MonsterStatus_Worr :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Worr* getInstance()
	{
		static MonsterStatus_Worr instance;
		return &instance;
	}

};

//恐惧状态类
class MonsterStatus_Fear :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Fear* getInstance()
	{
		static MonsterStatus_Fear instance;
		return &instance;
	}

};

//死亡状态类
class MonsterStatus_Dead :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Dead* getInstance()
	{
		static MonsterStatus_Dead instance;
		return &instance;
	}

};
3. 上下文类的实现
  • Monster 类作为上下文类，持有当前状态的引用。
  • checkAndSwitchState 方法用于根据当前生命值判断并切换状态。
  • Attacked 方法调用当前状态的 Attacked 方法。
cpp 复制代码 
//怪物类
class Monster
{
public:
	Monster(int life);
	~Monster();

public:
	void Attacked(int power);  //怪物被攻击

public:
	int GetLife() //获取怪物血量
	{
		return m_life;
	}
	void SetLife(int life) //设置怪物血量
	{
		m_life = life;
	}
	MonsterStatus* getCurrentState() //获取怪物当前状态
	{
		return m_pState;
	}
	void setCurrentState(MonsterStatus* pstate) //设置怪物当前状态
	{
		m_pState = pstate;
	}

private:
	int            m_life;    //血量（生命值）
	MonsterStatus* m_pState;  //持有状态对象
};
4. 主函数
cpp 复制代码 
int main()
{
    Monster monster(500);
    cout << "怪物出生，当前处于凶悍状态，500点血！" << endl;
    monster.Attacked(20);
    monster.Attacked(100);
    monster.Attacked(200);
    monster.Attacked(170);
    monster.Attacked(100);
    monster.Attacked(100);

    return 0;
}

3. 状态模式 UML 图

状态模式 UML 图解析
  • Context（环境类） ：也称为上下文类，该类的对象维护多种状态。在本例中，Monster 类充当上下文，负责管理当前状态并委托请求给当前状态对象。
  • State（抽象状态类） ：定义了与环境类特定状态相关的行为接口。在这里，MonsterStatus 是抽象状态类，声明了状态相关的方法（如 Attacked），具体状态类需要实现这些方法。
  • ConcreteState（具体状态类） ：具体状态类是抽象状态类的子类，实现与环境类该状态相关的行为。每个状态类（如 MonsterStatus_Feroc、MonsterStatus_Worr、MonsterStatus_Fear 和 MonsterStatus_Dead）实现了不同的 Attacked 方法，表现出不同的行为。

4. 状态模式的优点

  • 清晰的代码结构：通过将状态行为封装在状态对象中，避免了大量的条件语句，使代码更加清晰易读。
  • 易于扩展：增加新状态只需添加新的状态类，而无需修改现有代码，符合开闭原则。
  • 灵活的状态切换：状态之间的切换逻辑集中管理，便于维护和修改。

5. 状态模式的缺点

  • 类数量增加：每种状态都需要一个具体的状态类，可能导致类的数量增加，从而增加系统的复杂性。
  • 管理复杂性：状态之间的关系和切换逻辑可能变得难以管理，尤其是在状态较多时，可能需要额外的设计来处理状态转移。

6. 状态模式的适用场景

  • 对象的行为依赖于其状态，并且可以在运行时改变状态。

  • 需要避免使用大量条件语句来管理对象的状态。

  • 状态的改变会影响到对象的多个方法。

  • 行为依赖于状态：对象的行为依赖于其状态，并且可以在运行时改变状态。

  • 避免条件语句：需要避免使用大量条件语句来管理对象的状态，特别是在状态和行为较多的情况下。

  • 状态影响多个方法：状态的改变会影响到对象的多个方法，适合使用状态模式来管理这些变化。

完整代码

1. Monster.h
cpp 复制代码 
#ifndef __MONSTER__
#define __MONSTER__	
class MonsterStatus; //类前向声明
//怪物类
class Monster
{
public:
	Monster(int life);
	~Monster();

public:
	void Attacked(int power);  //怪物被攻击

public:
	int GetLife() //获取怪物血量
	{
		return m_life;
	}
	void SetLife(int life) //设置怪物血量
	{
		m_life = life;
	}
	MonsterStatus* getCurrentState() //获取怪物当前状态
	{
		return m_pState;
	}
	void setCurrentState(MonsterStatus* pstate) //设置怪物当前状态
	{
		m_pState = pstate;
	}

private:
	int            m_life;    //血量（生命值）
	MonsterStatus* m_pState;  //持有状态对象
};
#endif
2. Monster.cpp
cpp 复制代码 
#include <iostream>
#include "Monster.h"
#include "MonsterStatus.h"

using namespace std;

//构造函数，怪物的初始状态从"凶悍"开始
Monster::Monster(int life) :m_life(life), m_pState(nullptr)
{
	m_pState = MonsterStatus_Feroc::getInstance();
}

//析构函数
Monster::~Monster(){}

//怪物被攻击

void Monster::Attacked(int power)
{
	m_pState->Attacked(power, this);
}
3. MonsterStatus.h
cpp 复制代码 
#ifndef __MONSTERSTATUS__
#define __MONSTERSTATUS__
class Monster; //类前向声明
//怪物状态类的父类
class MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj) = 0;
	virtual ~MonsterStatus() {}
};
//凶悍状态类
class MonsterStatus_Feroc :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Feroc* getInstance()
	{
		static MonsterStatus_Feroc instance;
		return &instance;
	}

};

//不安状态类
class MonsterStatus_Worr :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Worr* getInstance()
	{
		static MonsterStatus_Worr instance;
		return &instance;
	}

};

//恐惧状态类
class MonsterStatus_Fear :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Fear* getInstance()
	{
		static MonsterStatus_Fear instance;
		return &instance;
	}

};

//死亡状态类
class MonsterStatus_Dead :public MonsterStatus
{
public:
	virtual void Attacked(int power, Monster* mainobj);

public:
	static MonsterStatus_Dead* getInstance()
	{
		static MonsterStatus_Dead instance;
		return &instance;
	}

};
#endif
4. MonsterStatus.cpp
cpp 复制代码 
#include <iostream>
#include "Monster.h"
#include "MonsterStatus.h"

using namespace std;

//各个状态子类的Attacked成员函数实现代码
void MonsterStatus_Feroc::Attacked(int power, Monster* mainobj)
{
	int orglife = mainobj->GetLife();  //暂存原来的怪物血量值用于后续比较		
	if ((orglife - power) > 400)       //怪物原来处于凶悍状态，现在依旧处于凶悍状态
	{
		//状态未变
		mainobj->SetLife(orglife - power); //怪物剩余的血量
		cout << "怪物处于凶悍状态中，对主角进行疯狂的反击！" << std::endl;
		//处理其他动作逻辑比如反击
	}
	else
	{
		//不管下个状态是啥，总之不会是凶悍状态，只可能是不安、恐惧、死亡状态之一，先无条件转到不安状态去（不安状态中会进行再次判断）
		mainobj->setCurrentState(MonsterStatus_Worr::getInstance());
		mainobj->getCurrentState()->Attacked(power, mainobj);
	}
}

void MonsterStatus_Worr::Attacked(int power, Monster* mainobj)
{
	int orglife = mainobj->GetLife();
	if ((orglife - power) > 100)       //怪物原来处于不安状态，现在依旧处于不安状态
	{
		//状态未变
		mainobj->SetLife(orglife - power); //怪物剩余的血量
		cout << "怪物处于不安状态中，对主角进行反击并呼唤支援！" << std::endl;
		//处理其他动作逻辑比如反击和不停的呼唤支援
	}
	else
	{
		//不管下个状态是啥，总之不会是凶悍和不安状态，只可能是恐惧、死亡状态之一，先无条件转到恐惧状态去
		mainobj->setCurrentState(MonsterStatus_Fear::getInstance());
		mainobj->getCurrentState()->Attacked(power, mainobj);
	}
}

void MonsterStatus_Fear::Attacked(int power, Monster* mainobj)
{
	int orglife = mainobj->GetLife();
	if ((orglife - power) > 0)       //怪物原来处于恐惧状态，现在依旧处于恐惧状态
	{
		//状态未变
		mainobj->SetLife(orglife - power); //怪物剩余的血量
		cout << "怪物处于恐惧状态中，处于逃跑之中！" << std::endl;
		//处理其他动作逻辑比如逃跑
	}
	else
	{
		//不管下个状态是啥，总之不会是凶悍、不安和恐惧状态，只可能是死亡状态
		mainobj->setCurrentState(MonsterStatus_Dead::getInstance());
		mainobj->getCurrentState()->Attacked(power, mainobj);
	}
}

void MonsterStatus_Dead::Attacked(int power, Monster* mainobj)
{
	int orglife = mainobj->GetLife();
	if (orglife > 0)
	{
		//还要把怪物生命值减掉
		mainobj->SetLife(orglife - power); //怪物剩余的血量
		//处理怪物死亡后事宜比如怪物尸体定时消失等
	}
	cout << "怪物死亡！" << std::endl;
}
5. main.cpp
cpp 复制代码 
#include <iostream>
#include "Monster.h"

using namespace std;

int main()
{
	Monster monster(500);
	cout << "怪物出生，当前处于凶悍状态，500点血！" << endl;
	monster.Attacked(20);
	monster.Attacked(100);
	monster.Attacked(200);
	monster.Attacked(170);
	monster.Attacked(100);
	monster.Attacked(100);

	return 0;
}

物剩余的血量

//处理怪物死亡后事宜比如怪物尸体定时消失等

}

cout << "怪物死亡！" << std::endl;

}

#### 5. main.cpp

```cpp
#include <iostream>
#include "Monster.h"

using namespace std;

int main()
{
	Monster monster(500);
	cout << "怪物出生，当前处于凶悍状态，500点血！" << endl;
	monster.Attacked(20);
	monster.Attacked(100);
	monster.Attacked(200);
	monster.Attacked(170);
	monster.Attacked(100);
	monster.Attacked(100);

	return 0;
}
相关推荐
神经网络的应用3 分钟前
C++程序设计例题——第三章程序控制结构
c++·学习·算法
zfenggo23 分钟前
c/c++ 无法跳转定义
c语言·开发语言·c++
图灵猿26 分钟前
【Lua之·Lua与C/C++交互·Lua CAPI访问栈操作】
c语言·c++·lua
A懿轩A1 小时前
C/C++ 数据结构与算法【树和二叉树】 树和二叉树，二叉树先中后序遍历详细解析【日常学习，考研必备】带图+详细代码
c语言·数据结构·c++·学习·二叉树·树
bandaoyu1 小时前
【设计模式】装饰器模式（Decorator Pattern）
设计模式·装饰器模式
hjxxlsx1 小时前
探索 C++ 自定义函数的深度与广度
开发语言·c++
lijiachang0307182 小时前
设计模式（一）：单例模式
c++·笔记·学习·程序人生·单例模式·设计模式·大学生
<但凡.2 小时前
题海拾贝：蓝桥杯 2020 省AB 乘法表
c++·算法·蓝桥杯
DogDaoDao3 小时前
leetcode 面试经典 150 题：矩阵置零
数据结构·c++·leetcode·面试·矩阵·二维数组·矩阵置零
抓哇FullStack-Junior3 小时前
设计模式——适配器模式
java·设计模式·适配器模式
热门推荐
01大模型国产化适配7-华为昇腾LLM落地可选解决方案（MindFormers、ModelLink、MindIE）02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03玄机平台应急响应—webshell查杀04电赛2024年H题智能小车基于MSPM0G3507主控MCU（利用8路灰度加上MPU6050的解决方式）具体项目报告05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06支付宝短视频平台创作分成激励项目07怎么找小红书美食探店博主合作？08【一文读懂】NTN（非地面网络）技术介绍09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站