State Pattern

The State pattern is a behavioral design pattern that allows an object to alter its behavior when its internal state changes. This pattern encapsulates state-specific behavior into separate classes, delegating the object’s behavior to the current state. It effectively allows an object to change its class at runtime.

What is State Pattern

The State pattern addresses situations where an object’s behavior depends on its state, and it must change its behavior at runtime depending on that state. Instead of using large conditional statements that become unwieldy and difficult to maintain, the State pattern provides a cleaner and more flexible approach.

In-depth Explanation:

The core idea of the State pattern is to define an abstract State class that declares an interface for all concrete state classes. Each concrete state class represents a specific state of the object and implements the behavior associated with that state. The context object maintains a reference to the current state object and delegates state-specific requests to it.

Key Components:

Context: The object whose behavior varies depending on its state. It maintains a reference to the current State object.
State (Interface): An abstract class or interface that defines the interface for all concrete state classes.
Concrete State: Classes that implement the State interface and define the specific behavior for each state.

Edge Cases:

State Transitions: Carefully manage state transitions. Consider how states change and who is responsible for initiating those changes. Centralized transition logic can simplify management but can also create a bottleneck. Decentralized transition logic (where states themselves determine the next state) can be more flexible but harder to reason about.
Shared State: If multiple contexts share the same state object, be aware of potential concurrency issues. Ensure that state modifications are thread-safe if necessary.
Complex State Machines: For complex state machines with many states and transitions, consider using a state machine library or framework to simplify implementation and management.

Performance Considerations:

The State pattern generally has minimal performance overhead. Creating state objects and delegating requests to them is relatively inexpensive. However, if state transitions are frequent or involve complex computations, consider caching frequently used state objects or optimizing state transition logic. The primary benefit of the State pattern is improved code organization and maintainability, which can indirectly lead to better performance through easier optimization.

Syntax and Usage

The general structure of the State pattern in C++ is as follows:


class Context; // Forward declaration
 
class State {
public:
    virtual ~State() = default;
    virtual void handle(Context* context) = 0;
};
 
class ConcreteStateA : public State {
public:
    void handle(Context* context) override;
};
 
class ConcreteStateB : public State {
public:
    void handle(Context* context) override;
};
 
class Context {
private:
    State* state_;
 
public:
    Context(State* state) : state_(state) {}
    ~Context() { delete state_; }
 
    void setState(State* state) {
        delete state_;
        state_ = state;
    }
 
    void request() {
        state_->handle(this);
    }
};
 
void ConcreteStateA::handle(Context* context) {
    std::cout << "ConcreteStateA handles the request.\n";
    context->setState(new ConcreteStateB()); // Transition to state B
}
 
void ConcreteStateB::handle(Context* context) {
    std::cout << "ConcreteStateB handles the request.\n";
    context->setState(new ConcreteStateA()); // Transition to state A
}
 
int main() {
    Context context(new ConcreteStateA());
    context.request(); // Output: ConcreteStateA handles the request.
    context.request(); // Output: ConcreteStateB handles the request.
    context.request(); // Output: ConcreteStateA handles the request.
    return 0;
}

Basic Example

Let’s consider a simplified TCP connection that can be in one of three states: Closed, Established, or Listening.


#include <iostream>
#include <string>
 
class TCPConnection; // Forward declaration
 
class TCPState {
public:
    virtual ~TCPState() = default;
    virtual void open(TCPConnection* connection) = 0;
    virtual void close(TCPConnection* connection) = 0;
    virtual void acknowledge(TCPConnection* connection, const std::string& data) = 0;
};
 
class TCPClosed : public TCPState {
public:
    void open(TCPConnection* connection) override;
    void close(TCPConnection* connection) override {
        std::cout << "TCPClosed: Already closed.\n";
    }
    void acknowledge(TCPConnection* connection, const std::string& data) override {
        std::cout << "TCPClosed: Cannot acknowledge, connection is closed.\n";
    }
};
 
class TCPListening : public TCPState {
public:
    void open(TCPConnection* connection) override {
        std::cout << "TCPListening: Already listening.\n";
    }
    void close(TCPConnection* connection) override;
    void acknowledge(TCPConnection* connection, const std::string& data) override {
        std::cout << "TCPListening: Received data: " << data << ". Establishing connection.\n";
        connection->setState(new TCPEstablished());
    }
};
 
class TCPEstablished : public TCPState {
public:
    void open(TCPConnection* connection) override {
        std::cout << "TCPEstablished: Already established.\n";
    }
    void close(TCPConnection* connection) override;
    void acknowledge(TCPConnection* connection, const std::string& data) override {
        std::cout << "TCPEstablished: Received data: " << data << ".\n";
    }
};
 
class TCPConnection {
private:
    TCPState* state_;
 
public:
    TCPConnection() : state_(new TCPClosed()) {}
    ~TCPConnection() { delete state_; }
 
    void setState(TCPState* state) {
        delete state_;
        state_ = state;
    }
 
    void open() {
        state_->open(this);
    }
 
    void close() {
        state_->close(this);
    }
 
    void acknowledge(const std::string& data) {
        state_->acknowledge(this, data);
    }
};
 
void TCPClosed::open(TCPConnection* connection) {
    std::cout << "TCPClosed: Opening connection. Switching to Listening state.\n";
    connection->setState(new TCPListening());
}
 
void TCPListening::close(TCPConnection* connection) {
    std::cout << "TCPListening: Closing connection. Switching to Closed state.\n";
    connection->setState(new TCPClosed());
}
 
void TCPEstablished::close(TCPConnection* connection) {
    std::cout << "TCPEstablished: Closing connection. Switching to Closed state.\n";
    connection->setState(new TCPClosed());
}
 
int main() {
    TCPConnection connection;
    connection.open();
    connection.acknowledge("SYN");
    connection.acknowledge("Data");
    connection.close();
    connection.close();
    return 0;
}

Explanation:

The TCPConnection class represents the context. Its state changes based on actions performed on it.
TCPState is the abstract state class.
TCPClosed, TCPListening, and TCPEstablished are concrete state classes, each implementing the open, close, and acknowledge methods differently based on the state.
The setState method in TCPConnection allows changing the current state. Critically, it also manages the memory of the previous state.

Advanced Example

Consider a more complex scenario: a vending machine. The machine can be in states like Idle, Selecting, Dispensing, and OutOfStock. Each state handles user input and manages the machine’s behavior differently.


#include <iostream>
#include <string>
#include <vector>
#include <limits> // Required for numeric_limits
 
class VendingMachine; // Forward declaration
 
class VendingMachineState {
public:
    virtual ~VendingMachineState() = default;
    virtual void insertCoin(VendingMachine* machine, int amount) = 0;
    virtual void selectProduct(VendingMachine* machine, int productCode) = 0;
    virtual void dispenseProduct(VendingMachine* machine) = 0;
    virtual void displayInventory(VendingMachine* machine) = 0;
};
 
class IdleState : public VendingMachineState {
public:
    void insertCoin(VendingMachine* machine, int amount) override;
    void selectProduct(VendingMachine* machine, int productCode) override {
        std::cout << "Idle: Please insert coins first.\n";
    }
    void dispenseProduct(VendingMachine* machine) override {
        std::cout << "Idle: No product selected.\n";
    }
	void displayInventory(VendingMachine* machine) override;
};
 
class SelectingState : public VendingMachineState {
public:
    void insertCoin(VendingMachine* machine, int amount) override;
    void selectProduct(VendingMachine* machine, int productCode) override;
    void dispenseProduct(VendingMachine* machine) override {
        std::cout << "Selecting: Wait for the product to be dispensed.\n";
    }
	void displayInventory(VendingMachine* machine) override;
};
 
class DispensingState : public VendingMachineState {
public:
    void insertCoin(VendingMachine* machine, int amount) override {
        std::cout << "Dispensing: Please wait. Product is being dispensed.\n";
    }
    void selectProduct(VendingMachine* machine, int productCode) override {
        std::cout << "Dispensing: Please wait. Product is being dispensed.\n";
    }
    void dispenseProduct(VendingMachine* machine) override;
	void displayInventory(VendingMachine* machine) override;
};
 
class OutOfStockState : public VendingMachineState {
public:
    void insertCoin(VendingMachine* machine, int amount) override {
        std::cout << "OutOfStock: Machine is out of stock. Please try again later.\n";
    }
    void selectProduct(VendingMachine* machine, int productCode) override {
        std::cout << "OutOfStock: Machine is out of stock. Please try again later.\n";
    }
    void dispenseProduct(VendingMachine* machine) override {
        std::cout << "OutOfStock: Machine is out of stock. Please try again later.\n";
    }
	void displayInventory(VendingMachine* machine) override;
};
 
 
class VendingMachine {
private:
    VendingMachineState* state_;
    int currentBalance_;
    std::vector<std::pair<std::string, int>> inventory_; // Product name, quantity
    std::vector<int> productPrices_; // Prices corresponding to inventory
 
public:
    VendingMachine() : state_(new IdleState()), currentBalance_(0) {
        inventory_.push_back({"Coke", 5});
        inventory_.push_back({"Sprite", 3});
        inventory_.push_back({"Water", 10});
 
        productPrices_.push_back(150); // Coke price
        productPrices_.push_back(125); // Sprite price
        productPrices_.push_back(100); // Water price
    }
    ~VendingMachine() { delete state_; }
 
    void setState(VendingMachineState* state) {
        delete state_;
        state_ = state;
    }
 
    void insertCoin(int amount) {
        state_->insertCoin(this, amount);
    }
 
    void selectProduct(int productCode) {
        state_->selectProduct(this, productCode);
    }
 
    void dispenseProduct() {
        state_->dispenseProduct(this);
    }
 
    int getCurrentBalance() const { return currentBalance_; }
    void setCurrentBalance(int balance) { currentBalance_ = balance; }
 
    const std::vector<std::pair<std::string, int>>& getInventory() const { return inventory_; }
    std::vector<std::pair<std::string, int>>& getInventoryRef() { return inventory_; }
 
	const std::vector<int>& getProductPrices() const { return productPrices_; }
 
	void displayInventory(){
		state_->displayInventory(this);
	}
};
 
void IdleState::insertCoin(VendingMachine* machine, int amount) {
    std::cout << "Idle: Coin inserted: " << amount << " cents.\n";
    machine->setCurrentBalance(machine->getCurrentBalance() + amount);
    machine->setState(new SelectingState());
	machine->displayInventory();
}
 
void SelectingState::insertCoin(VendingMachine* machine, int amount) {
    std::cout << "Selecting: Coin inserted: " << amount << " cents.\n";
    machine->setCurrentBalance(machine->getCurrentBalance() + amount);
	machine->displayInventory();
}
 
void DispensingState::dispenseProduct(VendingMachine* machine){
 
	std::cout << "Dispensing product.\n";
	machine->setState(new IdleState());
	machine->setCurrentBalance(0);
	machine->displayInventory();
}
 
void SelectingState::selectProduct(VendingMachine* machine, int productCode) {
	if (productCode < 0 || productCode >= machine->getInventory().size()) {
        std::cout << "Selecting: Invalid product code.\n";
        return;
    }
 
    if (machine->getInventory()[productCode].second == 0) {
        std::cout << "Selecting: Product is out of stock.\n";
		machine->setState(new OutOfStockState());
        return;
    }
 
 
    int price = machine->getProductPrices()[productCode];
    if (machine->getCurrentBalance() < price) {
        std::cout << "Selecting: Insufficient balance. Please insert more coins.\n";
        return;
    }
 
    std::cout << "Selecting: Dispensing " << machine->getInventory()[productCode].first << ".\n";
    machine->setCurrentBalance(machine->getCurrentBalance() - price);
    machine->getInventoryRef()[productCode].second--;
 
    machine->setState(new DispensingState());
	machine->dispenseProduct();
 
 
	if (machine->getInventory()[productCode].second == 0){
		std::cout << "Product is now out of stock.\n";
		machine->setState(new OutOfStockState());
	}
 
}
 
 
void IdleState::displayInventory(VendingMachine* machine){
	std::cout << "Available Products:\n";
	const auto& inventory = machine->getInventory();
    for (size_t i = 0; i < inventory.size(); ++i) {
        std::cout << i << ": " << inventory[i].first << " (Quantity: " << inventory[i].second << ", Price: " << machine->getProductPrices()[i] << " cents)\n";
    }
}
 
void SelectingState::displayInventory(VendingMachine* machine){
	std::cout << "Available Products:\n";
	const auto& inventory = machine->getInventory();
    for (size_t i = 0; i < inventory.size(); ++i) {
        std::cout << i << ": " << inventory[i].first << " (Quantity: " << inventory[i].second << ", Price: " << machine->getProductPrices()[i] << " cents)\n";
    }
	std::cout << "Current balance: " << machine->getCurrentBalance() << " cents\n";
}
 
void DispensingState::displayInventory(VendingMachine* machine){
	std::cout << "Dispensing product.  Please wait.\n";
}
 
void OutOfStockState::displayInventory(VendingMachine* machine){
	std::cout << "Machine is out of stock.\n";
}
 
 
int main() {
    VendingMachine machine;
    machine.displayInventory();
    machine.insertCoin(100);
    machine.insertCoin(50);
    machine.selectProduct(0); // Select Coke
	machine.selectProduct(0); // Select Coke
	machine.selectProduct(0); // Select Coke
	machine.selectProduct(0); // Select Coke
	machine.selectProduct(0); // Select Coke
	machine.selectProduct(0); // Select Coke - Out of Stock
 
    return 0;
}

Common Use Cases

UI Controls: Handling different states of a UI element (e.g., enabled/disabled, focused/unfocused).
Workflow Engines: Managing the different states of a workflow process.
Game Development: Representing different states of a game character (e.g., idle, walking, attacking).
Network Protocols: Implementing different states of a network connection (e.g., connecting, connected, disconnecting).
Order Processing: Managing order status transitions (e.g., created, paid, shipped, delivered).

Best Practices

Clearly Define States: Each state should represent a distinct and well-defined mode of operation.
Encapsulate State-Specific Behavior: All behavior specific to a state should be encapsulated within that state’s class.
Minimize Dependencies: States should have minimal dependencies on other parts of the system.
Consider State Machines: For complex state transitions, consider using a dedicated state machine library or framework.
Avoid God Classes: Don’t create a single, monolithic state class that handles all possible states.

Common Pitfalls

Large Conditional Statements: Using large if-else or switch statements instead of the State pattern.
Tight Coupling: States tightly coupled to the context or other states.
Ignoring State Transitions: Failing to properly manage state transitions, leading to unexpected behavior.
Shared Mutable State: Sharing mutable state between multiple contexts without proper synchronization.
Over-Engineering: Applying the State pattern to simple scenarios where it’s not necessary.

Key Takeaways

The State pattern allows an object to alter its behavior when its internal state changes.
It encapsulates state-specific behavior into separate classes.
It promotes code organization, maintainability, and flexibility.
Proper state transition management and careful consideration of shared state are crucial.
Avoid using the State pattern when simpler solutions suffice.