怎样设计C++中的状态模式 使用智能指针管理状态转换逻辑

#include <iostream>
#include <memory> // For std::unique_ptr

// 前向声明 Context，因为 State 需要访问它
class Context;

// 抽象状态基类
class IState {
public:
    virtual ~IState() = default;
    // 允许状态访问其上下文，以便进行状态转换
    void set_context(Context* context) {
        this->context_ = context;
    }
    virtual void handle_event_A() = 0;
    virtual void handle_event_B() = 0;

protected:
    Context* context_; // 通常用裸指针或std::weak_ptr避免循环引用
};

// 上下文类
class Context : public std::enable_shared_from_this<Context> {
private:
    std::unique_ptr<IState> current_state_;

public:
    explicit Context(std::unique_ptr<IState> initial_state) {
        set_state(std::move(initial_state));
    }

    // 状态转换方法
    void set_state(std::unique_ptr<IState> new_state) {
        std::cout << "Context: Changing state." << std::endl;
        if (current_state_) {
            // 可以在这里打印旧状态信息，如果需要
        }
        current_state_ = std::move(new_state);
        // 将上下文指针传递给新状态，以便状态可以触发后续的上下文操作
        current_state_->set_context(this);
        // 可以在这里打印新状态信息
    }

    // 将请求委托给当前状态
    void request_event_A() {
        std::cout << "Context: Handling event A." << std::endl;
        current_state_->handle_event_A();
    }

    void request_event_B() {
        std::cout << "Context: Handling event B." << std::endl;
        current_state_->handle_event_B();
    }
};

// 具体状态类：StateA
class ConcreteStateA : public IState {
public:
    void handle_event_A() override {
        std::cout << "StateA: Already in StateA, doing nothing specific for A." << std::endl;
    }

    void handle_event_B() override {
        std::cout << "StateA: Handling event B, transitioning to StateB." << std::endl;
        // 状态可以自行创建并设置新的状态
        context_->set_state(std::make_unique<class ConcreteStateB>());
    }
};

// 具体状态类：StateB
class ConcreteStateB : public IState {
public:
    void handle_event_A() override {
        std::cout << "StateB: Handling event A, transitioning to StateA." << std::endl;
        context_->set_state(std::make_unique<ConcreteStateA>());
    }

    void handle_event_B() override {
        std::cout << "StateB: Already in StateB, doing nothing specific for B." << std::endl;
    }
};

// 注意：为了让上面的代码示例完整，需要在使用前定义 ConcreteStateB。
// 这里在 ConcreteStateA 中前向声明了 ConcreteStateB，反之亦然。
// 实际项目中，通常会把所有状态类定义放在一起或单独的文件中。

/*
int main() {
    auto initial_state = std::make_unique<ConcreteStateA>();
    Context context(std::move(initial_state));

    context.request_event_A(); // StateA 响应 A
    context.request_event_B(); // StateA 响应 B，切换到 StateB

    context.request_event_A(); // StateB 响应 A，切换到 StateA
    context.request_event_B(); // StateA 响应 B，切换到 StateB

    return 0;
}
*/

#include <iostream>
#include <memory> // For std::unique_ptr and std::make_unique

// 前向声明 AudioPlayer
class AudioPlayer;

// 抽象播放器状态接口
class IPlayerState {
public:
    virtual ~IPlayerState() = default;
    void set_player(AudioPlayer* player) {
        this->player_ = player;
    }

    virtual void play() = 0;
    virtual void pause() = 0;
    virtual void stop() = 0;

protected:
    AudioPlayer* player_; // 状态需要引用其上下文
};

// 音频播放器上下文
class AudioPlayer {
private:
    std::unique_ptr<IPlayerState> current_state_;
    // 假设播放器有一些内部数据
    std::string current_track_ = "No Track";

public:
    // 构造函数，初始化为停止状态
    explicit AudioPlayer(std::unique_ptr<IPlayerState> initial_state) {
        set_state(std::move(initial_state));
    }

    // 设置新状态的方法
    void set_state(std::unique_ptr<IPlayerState> new_state) {
        std::cout << "Player: Transitioning from "
                  << (current_state_ ? typeid(*current_state_).name() : "Null")
                  << " to " << typeid(*new_state).name() << std::endl;
        current_state_ = std::move(new_state);
        current_state_->set_player(this); // 将自身指针传递给新状态
    }

    // 播放器操作，委托给当前状态
    void start_playback(const std::string& track_name) {
        current_track_ = track_name;
        std::cout << "Player: Attempting to play '" << current_track_ << "'." << std::endl;
        current_state_->play();
    }

    void pause_playback() {
        std::cout << "Player: Attempting to pause." << std::endl;
        current_state_->pause();
    }

    void stop_playback() {
        std::cout << "Player: Attempting to stop." << std::endl;
        current_state_->stop();
    }

    // 可以有其他访问器，例如获取当前曲目名
    const std::string& get_current_track() const {
        return current_track_;
    }
};

// 具体状态：停止状态
class StoppedState : public IPlayerState {
public:
    void play() override {
        std::cout << "StoppedState: Starting playback of '" << player_->get_current_track() << "'." << std::endl;
        player_->set_state(std::make_unique<class PlayingState>());
    }

    void pause() override {
        std::cout << "StoppedState: Cannot pause, already stopped." << std::endl;
    }

    void stop() override {
        std::cout << "StoppedState: Already stopped." << std::endl;
    }
};

// 具体状态：播放状态
class PlayingState : public IPlayerState {
public:
    void play() override {
        std::cout << "PlayingState: Already playing '" << player_->get_current_track() << "'." << std::endl;
    }

    void pause() override {
        std::cout << "PlayingState: Pausing playback of '" << player_->get_current_track() << "'." << std::endl;
        player_->set_state(std::make_unique<class PausedState>());
    }

    void stop() override {
        std::cout << "PlayingState: Stopping playback of '" << player_->get_current_track() << "'." << std::endl;
        player_->set_state(std::make_unique<StoppedState>());
    }
};

// 具体状态：暂停状态
class PausedState : public IPlayerState {
public:
    void play() override {
        std::cout << "PausedState: Resuming playback of '" << player_->get_current_track() << "'." << std::endl;
        player_->set_state(std::make_unique<PlayingState>());
    }

    void pause() override {
        std::cout << "PausedState: Already paused." << std::endl;
    }

    void stop() override {
        std::cout << "PausedState: Stopping playback from paused state." << std::endl;
        player_->set_state(std::make_unique<StoppedState>());
    }
};

// 为了让代码在某些编译器上编译通过，确保所有状态类在使用前都被定义。
// 实际中通常会将所有状态类放在一个或多个头文件中。

/*
int main() {
    // 初始状态为停止
    AudioPlayer player(std::make_unique<StoppedState>());

    std::cout << "\n--- Scenario 1: Play and Pause ---\n";
    player.start_playback("My Favorite Song.mp3"); // Stopped -> Playing
    player.pause_playback();                       // Playing -> Paused
    player.play_playback();                        // Paused -> Playing
    player.stop_playback();                        // Playing -> Stopped

    std::cout << "\n--- Scenario 2: Try invalid transitions ---\n";
    player.pause_playback(); // Already Stopped, cannot pause
    player.stop_playback();  // Already Stopped, still Stopped

    std::cout << "\n--- Scenario 3: Play and Stop directly ---\n";
    player.start_playback("Another Tune.wav"); // Stopped -> Playing
    player.stop_playback();                    // Playing -> Stopped

    return 0;
}
*/