如何在C++中实现状态机_状态模式应用实例

class DoorState {
public:
    virtual void open(class Door* door) {}
    virtual void close(class Door* door) {}
    virtual void lock(class Door* door) {}
    virtual void unlock(class Door* door) {}
    virtual ~DoorState() {} // 确保基类有虚析构函数
};

#include <iostream>

// Forward declaration of Door class

class DoorState {
public:
    virtual void open(class Door* door);
    virtual void close(class Door* door);
    virtual void lock(class Door* door);
    virtual void unlock(class Door* door);
    virtual ~DoorState() {} // Ensure base class has virtual destructor
};


class OpenState : public DoorState {
public:
    void close(Door* door) override;
    void lock(Door* door) override;
};

class ClosedState : public DoorState {
public:
    void open(Door* door) override;
    void lock(Door* door) override;
};

class LockedState : public DoorState {
public:
    void unlock(Door* door) override;
};


class Door {
public:
    DoorState* state;

    Door(DoorState* initialState) : state(initialState) {}

    void setState(DoorState* newState) {
        delete state; // Important: Prevent memory leaks
        state = newState;
    }

    void open() {
        state->open(this);
    }

    void close() {
        state->close(this);
    }

    void lock() {
        state->lock(this);
    }

    void unlock() {
        state->unlock(this);
    }

    ~Door() {
        delete state; // Clean up the state object
    }
};

void OpenState::close(Door* door) {
    std::cout << "Closing the door.\n";
    door->setState(new ClosedState());
}

void OpenState::lock(Door* door) {
    std::cout << "Cannot lock an open door.\n";
}

void ClosedState::open(Door* door) {
    std::cout << "Opening the door.\n";
    door->setState(new OpenState());
}

void ClosedState::lock(Door* door) {
    std::cout << "Locking the door.\n";
    door->setState(new LockedState());
}

void LockedState::unlock(Door* door) {
    std::cout << "Unlocking the door.\n";
    door->setState(new ClosedState());
}


int main() {
    Door* door = new Door(new ClosedState()); // Start with the door closed

    door->open();
    door->close();
    door->lock();
    door->unlock();
    //door->unlock(); // Example of unlocking when already unlocked - no transition

    delete door; // Clean up the Door object
    return 0;
}

#include <mutex>

class Door {
public:
    DoorState* state;
    std::mutex mtx; // 添加互斥锁

    Door(DoorState* initialState) : state(initialState) {}

    void setState(DoorState* newState) {
        std::lock_guard<std::mutex> lock(mtx); // 加锁
        delete state;
        state = newState;
    }

    // ... 其他方法 ...
};