【C++】【设计模式】状态模式

【C++】【设计模式】状态模式

定义

• 行为型模式
• 允许一个对象在其内部状态改变时改变其行为，看起来就像是改变了其类一样。

结构

• 抽象状态
• 具体状态
• 上下文

UML类图

#include <iostream>
#include <string>

class Order;

class OrderState {
public:
    virtual ~OrderState() {}
    virtual void cancel(Order& order) {}
    virtual void ship(Order& order) {}
    virtual void complete(Order& order) {}
};

class PendingState : public OrderState {
public:
    void cancel(Order& order) override;
    void ship(Order& order) override;
};

class ShippedState : public OrderState {
public:
    void cancel(Order& order) override;
    void complete(Order& order) override;
};

class DeliveredState : public OrderState {
public:
    void cancel(Order& order) override;
    void complete(Order& order) override;
};

class CompletedState : public OrderState {
public:
    void cancel(Order& order) override;
};

class CanceledState : public OrderState {
public:
    void ship(Order& order) override;
    void complete(Order& order) override;
};

class Order {
public:
    Order();
    ~Order();
    void setState(OrderState* state);
    void cancel();
    void ship();
    void complete();
private:
    OrderState* m_state;
};

Order::Order() {
    m_state = new PendingState();
}

Order::~Order() {
    if (m_state != nullptr) {
        delete m_state;
    }
}

void Order::setState(OrderState* state) {
    if (m_state != state) {
        delete m_state;
        m_state = state;
    }
}

void Order::cancel() {
    m_state->cancel(*this);
}

void Order::ship() {
    m_state->ship(*this);
}

void Order::complete() {
    m_state->complete(*this);
}

void PendingState::cancel(Order& order) {
    std::cout << "Order canceled" << std::endl;
    order.setState(new CanceledState());
}

void PendingState::ship(Order& order) {
    std::cout << "Order shipped" << std::endl;
    order.setState(new ShippedState());
}

void ShippedState::cancel(Order& order) {
    std::cout << "Cannot cancel shipped order" << std::endl;
}

void ShippedState::complete(Order& order) {
    std::cout << "Order delivered" << std::endl;
    order.setState(new DeliveredState());
}

void DeliveredState::cancel(Order& order) {
    std::cout << "Cannot cancel delivered order" << std::endl;
}

void DeliveredState::complete(Order& order) {
    std::cout << "Order completed" << std::endl;
    order.setState(new CompletedState());
}

void CompletedState::cancel(Order& order) {
    std::cout << "Cannot cancel completed order" << std::endl;
}

void CanceledState::ship(Order& order) {
    std::cout << "Cannot ship canceled order" << std::endl;
}

void CanceledState::complete(Order& order) {
    std::cout << "Cannot complete canceled order" << std::endl;
}

int main() {
    Order order;
    order.ship();
    order.complete();
    order.cancel();
    order.ship();
    order.complete();

    return 0;
}

总结与分析

• 状态模式适合需要频繁切换状态的系统设计。
• 状态模式可以简化复杂的条件判断
• 每个具体状态类只负责一个特定状态的行为使代码更易维护和拓展
• 增加系统类和对象类的个数