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

于 2024-08-26 00:08:09 发布
阅读量809 收藏 11
点赞数 24
分类专栏： C++ 设计模式 文章标签： c++ 设计模式 状态模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141537017
版权

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

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

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

1. 主要组成成分

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

2. 逐步构建状态模式

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

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

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

4. 状态模式的优点

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

5. 状态模式的缺点

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

6. 状态模式的适用场景

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

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

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

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

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

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

完整代码

1. Monster.h
#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
#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
#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
#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
#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;
}
不是仙人的闲人
关注
  • 24
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——状态模式（state pattern）
净无邪博客
10-09 956
一、原理讲解 别名状态对象（object for state）。 1.1意图 允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。 1.2应用场景 一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为； 一个操作中含有庞大的分支语句的条件语句，且这些分支依赖于该对象的状态； 1.3结构图（UML图） 1.4代码实现步骤 a1 定义一个状态接口类IState，定义一个接口函数handle()； a2 定义一个具体状态类ConcreteState，实现接口函数handl
C++设计模式——适配器模式
Abieai的博客
10-14 556
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
C++设计模式——状态模式
草上爬的博客
10-30 2922
前言 在实际开发中，我们经常会遇到这种情况；一个对象有多种状态，在每一个状态下，都会有不同的行为。那么在代码中我们经常是这样实现的。 typedef enum tagState { state, state1, state2 }State; void Action(State actionState) { if (actionState == st
C++ 设计模式——单例模式
qq_68194402的博客
08-22 1138
单例模式（Singleton Pattern）也称单件模式/单态模式，是一种创建型模式，用于创建只能产生一个对象实例的类。
C++设计模式——观察者模式
zhangchuan7758的博客
12-09 3060
观察者模式：当一个对象状态更新时，会自动通知依赖它的对象。
C++设计模式——装饰模式(Decorator Pattern)
leonardohaig的博客
11-09 812
C++设计模式——装饰模式(Decorator Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——装饰模式(Decorator Pattern)目录定义代码示例总结装饰模式和代理模式适用场景优缺点装饰模式的简化参考资料 定义 Attach additional responsibilities to an object dynamically keeping the same interface. Decorators provide a flexible alternati
C++设计模式——原型模式(Prototype Pattern)
leonardohaig的博客
06-02 1288
C++设计模式——原型模式(Prototype Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——原型模式(Prototype Pattern)目录定义代码示例普通指针方式实现智能指针方式实现总结为什么需要原型模式优缺点 定义 Specify the kinds of Objects to create using a prototypical instance, and create new objects by copying this prototype. 用原型实例指
C++设计模式——单例模式
zhangchuan7758的博客
12-07 4448
单例模式：提供了一种访问其唯一对象的方式，可直接访问，不需要实例化对象
C++设计模式——享元模式(Flyweight Pattern)
leonardohaig的博客
08-01 906
C++设计模式——享元模式(Flyweight Pattern) 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——享元模式(Flyweight Pattern)目录定义定义结构代码示例总结对比优缺点适用场景参考资料 定义 定义 Flyweight Pattern: Use sharing to support large numbers of fine-grained objects efficiently. 使用共享对象可有效地支持大量的细粒度的对象 享元（Flyweight）模式的定义
c++设计模式GoF23
10-28
### c++设计模式GoF23 #### 0. 引言 - **设计模式的重要性**：“Next to My Life, Software Is My Passion”——Robert C. Martin 的名言揭示了软件设计的重要地位。掌握设计模式意味着理解面向对象分析与设计...
C++设计模式之备忘录模式
01-20
前言 又到年底了，也静不下心来写代码了，大家都很浮躁；...在GOF的《设计模式:可复用面向对象软件的基础》一书中对备忘录模式是这样说的：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这
设计模式实现——观察者模式
09-04
在《设计模式实现——观察者模式》这篇博客中，作者可能详细解释了观察者模式的概念、结构以及其在实际编程中的应用。以下是对观察者模式的详细阐述： 1. **模式定义**：观察者模式是一种对象行为型模式，它允许...
设计模式C++版
06-13
设计模式C++版文档主要聚焦于面向对象设计与分析的核心——设计模式，并以C++语言实现为示范。这份文档详尽阐述了23种GoF（Gang of Four）设计模式，并结合具体的C++源码示例，旨在帮助读者深入理解并掌握这些设计...
设计模式——GFour
08-22
《设计模式——GFour》是一本深受IT从业者喜爱的经典书籍，尤其在C++开发者中具有广泛影响力。设计模式是软件工程领域中的一种最佳实践，它总结了在特定情境下解决问题的常见方法，使得代码可读性更强，复用性更高，...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 707
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 558
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 374
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
【C语言篇】
最新发布
2301_81072404的博客
08-25 96
条件编译（#ifdef、#ifndef、#else、#elif、#endif）指针与动态内存分配（malloc、calloc、realloc、free）文件的读写操作（fread、fwrite、fprintf、fscanf等）控制语句（if、for、while、do-while、switch等）字符串处理函数（strlen、strcpy、strcat等）运算符（算术运算符、关系运算符、逻辑运算符等）文件的打开与关闭（fopen、fclose）数据类型（整型、浮点型、字符型等）函数参数传递（传值、传址）
C++ 基础
weixin_51883798的博客
08-22 269
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值