State Design Pattern without Dynamic Memory

The state design pattern, as described in this Refactoring Guru example, is a great tool. There is, however, at least one thing I do not like at this implementation. That is the fact that a state object is freed and new one is allocated each time the state transition is requested. In this article I would like to introduce my solution to this problem. My solution will also allow easy extension of the context object with new states.

Firstly, a type needs to be defined that identifies each known state with an integer.

enum class StateId
{
    FIRST_STATE_ID

    // Other state IDs are defined by the implementations of the actual states
};

The State class is the base of every state class belonging to the Context. This class also contains few static helper methods:

• registerStateEmplacer() allows to register a state class represented by 'emplacer' (a special type of a factory method that constructs the state inside the context itself) and to assign it a state ID.
• emplaceNewState() invokes correct 'emplacer' for given state ID.

The actual states will be derived from BaseState class which is derived from the State class. The BaseState class will be defined later. This split is due to the fact that the Sate does not need a complete definition of the Context class, however BaseState does.

#include <vector>

class Context;

class State
{
public:
    static bool emplaceNewState(StateId id, Context & owner)
    {
        const std::size_t pos = static_cast<std::size_t>(id) -
                static_cast<std::size_t>(StateId::FIRST_STATE_ID);
        auto & emp = emplacers();
        if (pos >= emp.size())
            return false;
        emp[pos](owner);
        return true;
    }

    State() = default;
    State(const State &) = delete;
    State(State &&) = delete;

    virtual void doStuff() = 0;

    virtual ~State() = default;

protected:
    using StateEmplacer = void(*)(Context &);

    static StateId registerStateEmplacer(StateEmplacer emplacer)
    {
        auto & emp = emplacers();
        const std::size_t pos = emp.size();
        emp.push_back(emplacer);
        return static_cast<StateId>(pos +
                static_cast<std::size_t>(StateId::FIRST_STATE_ID));
    }

private:
    static std::vector<StateEmplacer> & emplacers()
    {
        static std::vector<StateEmplacer> emplacers;
        return emplacers;
    }
};

The Context class is the main external interface of the object with internal exchangeable state. It also holds the context shared among individual states. The main part of the interface is the method doStuff(), whose polymorphic counterpart is implemented by individual states. The state objects are constructed in the space provided by the storage_ member (notice the type of this member, it is quite crucial in making this design work on various platforms).

#include <type_traits>

class BaseState;

class Context
{
public:
    void doStuff()
    {
        state_->doStuff();
    }

    void changeState(StateId new_state)
    {
        resetState();
        State::emplaceNewState(new_state, *this);
    }

    ~Context()
    {
        resetState();
    }

private:
    State * state_ = nullptr;
    typename std::aligned_storage<128>::type storage_;

    void resetState()
    {
        if (state_)
            state_->~State();
        state_ = nullptr;
    }

    friend class BaseState;
};

The BaseState class is the direct parent of all states. This class provides single helper static method that checks all pre-conditions of the state class, creates the 'emplacer' factory method, and registers the state. This piece of code also provides macro for easier registration of new states. This macro also enforces STATE_ID static member of each state class, which holds the state ID assigned to that state.

#include <type_traits>

class BaseState: public State
{
public:
    BaseState() = delete;
    BaseState(const BaseState &) = delete;
    BaseState(BaseState &&) = delete;

protected:
    BaseState(Context & context):
        context_(context)
    { }

    template <typename STATE>
    static StateId registerState()
    {
        static_assert(std::is_base_of<State, STATE>::value,
                "Not a valid state type");
        static_assert(sizeof(STATE) <= sizeof(decltype(Context::storage_)),
                "Incorrect state size");
        static_assert(alignof(STATE) <= alignof(decltype(Context::storage_)),
                "Incorrect state alignment");

        return registerStateEmplacer(
                +[](Context  & context) -> void
                {
                    context.state_ = new(&context.storage_) STATE{context};
                });
    }

protected:
     Context & context_;
};

#define STATE_REGISTER(state_type)  \
    const StateId state_type::STATE_ID =  \
            BaseState::registerState<state_type>();

Creation and registration of individual states is shown in the code below.

#include <iostream>

class StateA: public BaseState
{
public:
    static const StateId STATE_ID;

    StateA(Context & context): BaseState(context) { }

    void doStuff() override
    {
        std::cout << "State A" << std::endl;
    }
};
STATE_REGISTER(StateA);

class StateB: public BaseState
{
public:
    static const StateId STATE_ID;

    StateB(Context & context): BaseState(context) { }

    void doStuff() override
    {
        std::cout << "State B" << std::endl;
    }
};
STATE_REGISTER(StateB);

int main()
{
    Context c;
    c.changeState(StateA::STATE_ID);
    c.doStuff();  // "State A"

    c.changeState(StateB::STATE_ID);
    c.doStuff();  // "State B"

    return 0;
}

The main goal of the design was to remove the need for dynamic memory allocation every time a state is changed, which might be necessary to avoid on embedded and or real-time applications. The only downside is the fact that the context needs to have some knowledge on the individual state classes, namely their maximum size and alignment requirements. These are, however, thanks to the static_assert statements checked at compile time.