C++中的状态模式

最新推荐文章于 2024-09-30 16:29:36 发布
最新推荐文章于 2024-09-30 16:29:36 发布
阅读量623 收藏 3
点赞数 10
分类专栏： C++的自我救赎 学习 分享 文章标签： c++ 状态模式 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/golojo/article/details/139619849
版权
分享 同时被 3 个专栏收录
61 篇文章 0 订阅
订阅专栏
学习
59 篇文章 0 订阅
订阅专栏
C++的自我救赎
52 篇文章 2 订阅
订阅专栏

目录

状态模式（State Pattern）

实际应用

停车收费系统

音乐播放器的播放状态

电梯控制系统

总结

状态模式（State Pattern）

状态模式是一种行为型设计模式，它允许对象在其内部状态改变时改变其行为。这种模式可以避免在对象中使用大量的条件语句，从而使我们开发的代码更加清晰和易于维护。

状态模式主要包含以下角色：
1. Context（上下文）：定义客户感兴趣的接口，并且维护一个ConcreteState子类的实例，这个实例定义当前状态。
2. State（状态）：定义一个接口以封装与Context的一个特定状态相关的行为。
3. ConcreteState（具体状态）：每一个具体状态类实现了State接口。

实际应用

停车收费系统

-- 实现一个停车收费系统，根据停车时间计算费用，不同的时间段有不同的收费标准。

#include <iostream>
#include <memory>

// 上下文类
class ParkingMeter;

// 状态接口类
class ParkingState {
public:
    virtual void enterTime(ParkingMeter* meter, int minutes) = 0;
    virtual void calculateFee(ParkingMeter* meter) = 0;
};

// 上下文类
class ParkingMeter {
private:
    std::unique_ptr<ParkingState> state;
    int totalMinutes;
    double fee;

public:
    ParkingMeter();
    void setState(std::unique_ptr<ParkingState> newState);
    void addTime(int minutes);
    void calculateFee();
    int getTotalMinutes() const;
    void setFee(double newFee);
    double getFee() const;
};

// 具体状态类：免费时间段
class FreeState : public ParkingState {
public:
    void enterTime(ParkingMeter* meter, int minutes) override;
    void calculateFee(ParkingMeter* meter) override;
};

// 具体状态类：收费时间段
class PaidState : public ParkingState {
public:
    void enterTime(ParkingMeter* meter, int minutes) override;
    void calculateFee(ParkingMeter* meter) override;
};

// ParkingMeter方法的实现
ParkingMeter::ParkingMeter() : totalMinutes(0), fee(0.0) {
    state = std::make_unique<FreeState>();
}

void ParkingMeter::setState(std::unique_ptr<ParkingState> newState) {
    state = std::move(newState);
}

void ParkingMeter::addTime(int minutes) {
    state->enterTime(this, minutes);
}

void ParkingMeter::calculateFee() {
    state->calculateFee(this);
}

int ParkingMeter::getTotalMinutes() const {
    return totalMinutes;
}

void ParkingMeter::setFee(double newFee) {
    fee = newFee;
}

double ParkingMeter::getFee() const {
    return fee;
}

// FreeState方法的实现
void FreeState::enterTime(ParkingMeter* meter, int minutes) {
    int newTotalMinutes = meter->getTotalMinutes() + minutes;
    meter->setFee(0.0); // 免费时间段，费用为0

    if (newTotalMinutes > 60) {
        // 超过60分钟，进入收费时间段
        meter->setState(std::make_unique<PaidState>());
        meter->addTime(newTotalMinutes - 60);
    } else {
        // 在免费时间段内
        std::cout << "Time entered: " << minutes << " minutes. Total time: " << newTotalMinutes << " minutes." << std::endl;
    }
}

void FreeState::calculateFee(ParkingMeter* meter) {
    std::cout << "Total parking fee: $" << meter->getFee() << " (Free period)" << std::endl;
}

// PaidState方法的实现
void PaidState::enterTime(ParkingMeter* meter, int minutes) {
    int newTotalMinutes = meter->getTotalMinutes() + minutes;
    meter->setFee(newTotalMinutes * 0.5); // 收费时间段，每分钟0.5美元

    std::cout << "Time entered: " << minutes << " minutes. Total time: " << newTotalMinutes << " minutes." << std::endl;
}

void PaidState::calculateFee(ParkingMeter* meter) {
    std::cout << "Total parking fee: $" << meter->getFee() << " (Paid period)" << std::endl;
}

// 客户端代码
int main() {
    ParkingMeter meter;
    meter.addTime(30); // 免费时间段
    meter.calculateFee();

    meter.addTime(40); // 转入收费时间段
    meter.calculateFee();

    meter.addTime(20); // 收费时间段
    meter.calculateFee();

    return 0;
}

音乐播放器的播放状态

-- 实现一个音乐播放器，可以在播放、暂停和停止状态之间切换。

#include <iostream>
#include <memory>
#include <string>

// 上下文类
class MusicPlayer;

// 状态接口类
class PlayerState {
public:
    virtual void play(MusicPlayer* player) = 0;
    virtual void pause(MusicPlayer* player) = 0;
    virtual void stop(MusicPlayer* player) = 0;
};

// 上下文类
class MusicPlayer {
private:
    std::unique_ptr<PlayerState> state;
    std::string currentTrack;

public:
    MusicPlayer();
    void setState(std::unique_ptr<PlayerState> newState);
    void play();
    void pause();
    void stop();
    void setTrack(const std::string& track);
    std::string getTrack() const;
};

// 具体状态类：播放状态
class PlayingState : public PlayerState {
public:
    void play(MusicPlayer* player) override;
    void pause(MusicPlayer* player) override;
    void stop(MusicPlayer* player) override;
};

// 具体状态类：暂停状态
class PausedState : public PlayerState {
public:
    void play(MusicPlayer* player) override;
    void pause(MusicPlayer* player) override;
    void stop(MusicPlayer* player) override;
};

// 具体状态类：停止状态
class StoppedState : public PlayerState {
public:
    void play(MusicPlayer* player) override;
    void pause(MusicPlayer* player) override;
    void stop(MusicPlayer* player) override;
};

// MusicPlayer方法的实现
MusicPlayer::MusicPlayer() {
    state = std::make_unique<StoppedState>();
}

void MusicPlayer::setState(std::unique_ptr<PlayerState> newState) {
    state = std::move(newState);
}

void MusicPlayer::play() {
    state->play(this);
}

void MusicPlayer::pause() {
    state->pause(this);
}

void MusicPlayer::stop() {
    state->stop(this);
}

void MusicPlayer::setTrack(const std::string& track) {
    currentTrack = track;
}

std::string MusicPlayer::getTrack() const {
    return currentTrack;
}

// PlayingState方法的实现
void PlayingState::play(MusicPlayer* player) {
    std::cout << "Already playing " << player->getTrack() << std::endl;
}

void PlayingState::pause(MusicPlayer* player) {
    std::cout << "Pausing " << player->getTrack() << std::endl;
    player->setState(std::make_unique<PausedState>());
}

void PlayingState::stop(MusicPlayer* player) {
    std::cout << "Stopping " << player->getTrack() << std::endl;
    player->setState(std::make_unique<StoppedState>());
}

// PausedState方法的实现
void PausedState::play(MusicPlayer* player) {
    std::cout << "Resuming " << player->getTrack() << std::endl;
    player->setState(std::make_unique<PlayingState>());
}

void PausedState::pause(MusicPlayer* player) {
    std::cout << "Already paused " << player->getTrack() << std::endl;
}

void PausedState::stop(MusicPlayer* player) {
    std::cout << "Stopping " << player->getTrack() << std::endl;
    player->setState(std::make_unique<StoppedState>());
}

// StoppedState方法的实现
void StoppedState::play(MusicPlayer* player) {
    std::cout << "Playing " << player->getTrack() << std::endl;
    player->setState(std::make_unique<PlayingState>());
}

void StoppedState::pause(MusicPlayer* player) {
    std::cout << "Cannot pause, " << player->getTrack() << " is not playing" << std::endl;
}

void StoppedState::stop(MusicPlayer* player) {
    std::cout << "Already stopped " << player->getTrack() << std::endl;
}

// 客户端代码
int main() {
    MusicPlayer player;
    player.setTrack("Song A");

    player.play(); // Playing Song A
    player.pause(); // Pausing Song A
    player.play(); // Resuming Song A
    player.stop(); // Stopping Song A

    player.setTrack("Song B");
    player.play(); // Playing Song B
    player.stop(); // Stopping Song B
    player.pause(); // Cannot pause, Song B is not playing

    return 0;
}

电梯控制系统

-- 实现一个电梯控制系统，电梯有多种状态，如运行状态、停止状态和维护状态。

#include <iostream>
#include <memory>
#include <string>

// 上下文类
class Elevator;

// 状态接口类
class ElevatorState {
public:
    virtual void goUp(Elevator* elevator) = 0;
    virtual void goDown(Elevator* elevator) = 0;
    virtual void stop(Elevator* elevator) = 0;
    virtual void maintain(Elevator* elevator) = 0;
};

// 上下文类
class Elevator {
private:
    std::unique_ptr<ElevatorState> state;

public:
    Elevator();
    void setState(std::unique_ptr<ElevatorState> newState);
    void goUp();
    void goDown();
    void stop();
    void maintain();
};

// 具体状态类：运行状态
class RunningState : public ElevatorState {
public:
    void goUp(Elevator* elevator) override;
    void goDown(Elevator* elevator) override;
    void stop(Elevator* elevator) override;
    void maintain(Elevator* elevator) override;
};

// 具体状态类：停止状态
class StoppedState : public ElevatorState {
public:
    void goUp(Elevator* elevator) override;
    void goDown(Elevator* elevator) override;
    void stop(Elevator* elevator) override;
    void maintain(Elevator* elevator) override;
};

// 具体状态类：维护状态
class MaintenanceState : public ElevatorState {
public:
    void goUp(Elevator* elevator) override;
    void goDown(Elevator* elevator) override;
    void stop(Elevator* elevator) override;
    void maintain(Elevator* elevator) override;
};

// Elevator方法的实现
Elevator::Elevator() {
    state = std::make_unique<StoppedState>();
}

void Elevator::setState(std::unique_ptr<ElevatorState> newState) {
    state = std::move(newState);
}

void Elevator::goUp() {
    state->goUp(this);
}

void Elevator::goDown() {
    state->goDown(this);
}

void Elevator::stop() {
    state->stop(this);
}

void Elevator::maintain() {
    state->maintain(this);
}

// RunningState方法的实现
void RunningState::goUp(Elevator* elevator) {
    std::cout << "The elevator is already running upward." << std::endl;
}

void RunningState::goDown(Elevator* elevator) {
    std::cout << "The elevator is already running downward." << std::endl;
}

void RunningState::stop(Elevator* elevator) {
    std::cout << "Stopping the elevator." << std::endl;
    elevator->setState(std::make_unique<StoppedState>());
}

void RunningState::maintain(Elevator* elevator) {
    std::cout << "Cannot enter maintenance mode while running." << std::endl;
}

// StoppedState方法的实现
void StoppedState::goUp(Elevator* elevator) {
    std::cout << "The elevator is going up." << std::endl;
    elevator->setState(std::make_unique<RunningState>());
}

void StoppedState::goDown(Elevator* elevator) {
    std::cout << "The elevator is going down." << std::endl;
    elevator->setState(std::make_unique<RunningState>());
}

void StoppedState::stop(Elevator* elevator) {
    std::cout << "The elevator is already stopped." << std::endl;
}

void StoppedState::maintain(Elevator* elevator) {
    std::cout << "Entering maintenance mode." << std::endl;
    elevator->setState(std::make_unique<MaintenanceState>());
}

// MaintenanceState方法的实现
void MaintenanceState::goUp(Elevator* elevator) {
    std::cout << "Cannot go up while in maintenance mode." << std::endl;
}

void MaintenanceState::goDown(Elevator* elevator) {
    std::cout << "Cannot go down while in maintenance mode." << std::endl;
}

void MaintenanceState::stop(Elevator* elevator) {
    std::cout << "Cannot stop while in maintenance mode." << std::endl;
}

void MaintenanceState::maintain(Elevator* elevator) {
    std::cout << "Already in maintenance mode." << std::endl;
}

// 客户端代码
int main() {
    Elevator elevator;

    elevator.goUp(); // The elevator is going up.
    elevator.stop(); // Stopping the elevator.
    elevator.maintain(); // Entering maintenance mode.
    elevator.goUp(); // Cannot go up while in maintenance mode.
    elevator.stop(); // Cannot stop while in maintenance mode.

    elevator.setState(std::make_unique<StoppedState>()); // Simulate exiting maintenance
    elevator.goDown(); // The elevator is going down.
    elevator.stop(); // Stopping the elevator.

    return 0;
}

总结

状态模式通过将状态转换逻辑从上下文类中抽离出来，使代码更加清晰和易于维护。

沉夢志昂丶
关注
专栏目录
C++状态模式
我不是萧海哇的博客
10-29 323
头文件： #ifndef CSTATEMODE_H #define CSTATEMODE_H #include<QDebug> #include <iostream> #include<string> #include <vector> using namespace std; #define cout qDebug() << "[" << __FILE__ << ":" << __LINE__ <&
【C++】状态模式
编程记录，亲测有效
10-15 4355
状态模式也是设计模式的一种，这种设计模式思想不复杂，就是实现起来的代码有点复杂。主要出现在类传递参数上，尤其是C++这种不能直接类间互相调用都语言，实现状态模式更难，当然，一切设计模式都是为了更简短的主函数。 状态模式是当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类，主要解决的是当控制一个对象状态转换的条件表达式过于复杂时的情况。把状态的判断逻辑转移到表示不同的一系列类当
C++ 状态机
最新发布
qq_50373827的博客
09-30 1127
在 C++ 中，状态机是一种设计模式，用于管理对象的状态及其状态之间的转换。它常用于系统中状态复杂且有多个状态切换的场景，如嵌入式系统、游戏开发、协议解析等。状态机可以帮助你更好地组织代码，简化状态切换的逻辑和维护。
c++状态模式
11-05 505
设计模式--状态模式
C++之状态(State)模式
lovely_yoshino的博客
07-18 5524
0. 简介 状态模式是一种行为设计模式， 让你能在一个对象的内部状态变化时改变其行为， 使其看上去就像改变了自身所属的类一样。这其实就有点类似算法中的有限状态机的形式。 其主要思想是程序在任意时刻仅可处于几种有限的状态中。 在任何一个特定状态中， 程序的行为都不相同， 且可瞬间从一个状态切换到另一个状态。 不过， 根据当前状态， 程序可能会切换到另外一种状态， 也可能会保持当前状态不变。 这些数量有限且预先定义的状态切换规则被称为转移。 1. 状态模式示意图 策略模式和状态模式两个模式很相似，区别就在于策
状态模式（C++）
先锋小牛
05-08 434
简述当一个对象内在状态改变时，允许改变其行为，这个对象看起来像改变了其类，单控制一个对象的状态转换的条件表达式过于复杂时，把状态的判断逻辑转移，到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化场景说明状态模式中，不同状态对象表现的也不同。就像变色龙一样，它随自己心情的变化会变成不同的颜色，它心情平静时为蓝色，心情兴奋时就变成了黄色UML类图对象说明State, 抽象的状态类CalmState...
C++设计模式之状态模式
09-04
在C++中，状态模式能够有效地消除复杂的条件分支语句，使得代码更易于理解和维护。 在GOF的设计模式经典著作中，状态模式被定义为：“允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。”...
解析C++编程中如何使用设计模式中的状态模式结构
09-02
在C++编程中，状态模式的应用能够帮助我们更好地管理和组织代码，特别是在处理具有多种可能状态的对象时，避免了复杂的条件分支语句，提高了代码的可读性和可维护性。 状态模式的核心在于将状态相关的操作封装在...
设计模式C++学习之状态模式（State）
09-07
在C++中，状态模式通常包含以下几个关键组件： 1. **Context**（环境类）：持有对当前状态对象的引用，定义了客户所关心的接口，并将与特定状态相关的操作委托给当前状态对象。在C++中，环境类通常作为抽象基类，...
实例讲解C++设计模式编程中State状态模式的运用场景
09-02
在给出的实例中，`Context`类是状态模式的核心，它定义了所有可能的状态行为，并持有当前状态对象的引用。`Context`类有两个主要的方法：`Handle()`和`OperationForStateA()`以及`OperationForStateB()`。`Handle()`...
c++设计模式-行为型模式-状态模式
06-20
c++设计模式-行为型模式-状态模式；qt工程；c++简单源码； 状态（State）模式的定义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
[C++]状态模式
就是那个党伟
04-12 538
在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。 在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。 C++代码如下： // 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // // 参考大话设计模式 #include <iostream> usin...
C++ 状态模式
青春不老，奋斗不止！
11-27 7358
状态模式（State Pattern）是行为设计模式之一。当对象根据其内部状态改变其行为时，将使用状态设计模式。
状态模式c++
lv836735240的专栏
05-31 1620
headfirst-状态模式（c++实现）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

沉夢志昂丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值