C++ 设计模式——状态模式
C++ 设计模式——状态模式
- C++ 设计模式——状态模式
- 1. 主要组成成分
- 2. 逐步构建状态模式
- 1. 状态接口定义
- 2. 具体状态类实现
- 3. 上下文类的实现
- 4. 主函数
- 3. 状态模式 UML 图
- 状态模式 UML 图解析
- 4. 状态模式的优点
- 5. 状态模式的缺点
- 6. 状态模式的适用场景
- 完整代码
- 1. Monster.h
- 2. Monster.cpp
- 3. MonsterStatus.h
- 4. MonsterStatus.cpp
- 5. main.cpp
C++ 设计模式——状态模式
状态模式（State Pattern）是一种行为型设计模式，它允许对象在其内部状态发生变化时，动态地改变其行为。该模式的核心在于将状态相关的行为封装到独立的状态类中，使得对象的行为随状态而变化，从而减少冗余的条件判断。
1. 主要组成成分
- 上下文（Context）：持有一个状态对象的引用，负责与客户端交互，并将请求委托给当前状态对象。
- 状态接口（State）：定义了所有具体状态类的公共接口。
- 具体状态（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 图解析
- 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;
}