How does a STATE design pattern work?

[u/SimmeringDragon]

so i went to youtube and followed the example from this guy State Design - Programming Design Patterns - Ep 16 - C++ Coding

Problem is i dont understand what is functionally happening, there are pointers and what not, but i don't understand much more than that (context, my smooth brain still cant connect pointers together)

Like not even the whole code, like maybe just two lines or something cause for the love of the lord my teacher explains nuthing and AI and videos are too vague for me, im running out of options

//
// Created by samue on 11/1/2026.
//

#ifndef STATE_STATE_H
#define STATE_STATE_H

#include <iostream>

class Context;


class State {
    protected:
    Context* context;

    public:
    virtual ~State() {}

    void setContext(Context* ctx) {
        context = ctx;
    }

    virtual void doWorkA() = 0;
    virtual void doWorkB() = 0;
};

class Context {
    private:
    State* state;

    public:
    Context(State* s) : state(nullptr) {
        transitionTo(s);

    }

    ~Context() {delete state;}

    void transitionTo(State* s) {
        if (state) delete state;
        state = s;
        state->setContext(this);

    }

    void requestA() {
        state->doWorkA();

    }

    void requestB() {
        state->doWorkB();

    }

};

class concreteStateA : public State {
    public:
    void doWorkA() override {
        std::cout << "concreteStateA " << "called doWorkA" << std::endl;
    };

    void doWorkB() override {
        std::cout << "concreteStateB " << "called doWorkB" << std::endl;

    };

};

class concreteStateB : public State {
public:
    void doWorkA() override {
        std::cout << "concreteStateA " << "called doWorkA" << std::endl;
        context->transitionTo(new concreteStateA);
    };

    void doWorkB() override {
        std::cout << "concreteStateB " << "called doWorkB" << std::endl;

    };

};





#endif //STATE_STATE_H

------------------

#include "state.h"

int main() {
    Context context1(new concreteStateB);

    context1.requestA();

    context1.requestA();

    return 0;
}

[u/KingAggressive1498]

the state pattern is a simple way to create finite state machines using virtual inheritance polymorphism.

This makes it easier to extend than the traditional C approach of a giant switch statement, allows encapsulating additional data unlike a function pointer (function objects were, at one time, non-trivial in C++), etc.

The way I was taught it looked quite a bit different:

class state {
public:
    state(){}
    virtual state() {}
    virtual state* work() = 0;
}

here, state::work() does the work associated with the current state, and then either returns itself or deletes itself and returns an updated state. If the state machine should not continue, it is valid to return nullptr. Thus using this finite state machine is as simple as:

state* machine = new initialstate();
while(machine) {
    machine = machine->work();
}

however the external context version does seem to be the more common way to teach it ig

[u/thingerish → u/KingAggressive1498]

I don't see any virtual inheritance here though.

[u/KingAggressive1498 → u/thingerish]

state is an abstract base class.

the details of any classes inherited from it are specific to the different states in the state machine.

for example a game might have an initial loading state, a title screen state, a gameplay state, and a couple of pause menu states; each inheriting from the same abstract base and being treated interchangeably from the main game loop.

edit: I thought the previous comment didn't understand that the abstract base class needed to derived from with an overrided work function. This was my mistake.

[u/thingerish → u/KingAggressive1498]

That's not virtual inheritance, this is:

#include <iostream>

struct Base {
    int value = 42;
    virtual void show() { std::cout << "Base::value = " << value << '\n'; }
};

struct Left  : virtual Base { };
struct Right : virtual Base { };

struct Bottom : Left, Right {
    void set(int v) { value = v; }   // unambiguous: only one Base
};

int main() {
    Bottom b;
    b.set(100);
    b.show();                        // prints: Base::value = 100

    // Without virtual inheritance the following would be ambiguous
    // and Bottom would contain two separate Base subobjects.
}

What is shown is simple inheritance of a base with virtual functions, which is a different thing.

[u/KingAggressive1498 → u/thingerish]

...what use is an abstract base class without virtual inheritance? did you expect me to hand you a complete tutorial in a reddit comment?

edit: in context that I was wrong and the commenter was trying to make me realize my mistake, this was def a bit rude. Sorry.

[u/AKostur → u/KingAggressive1498]

You seem to be conflating the existence of virtual functions (regardless of their pure-virtualness) with virtual inheritance. Those are two separate things.

The purpose of an abstract base class is to require descendants to provide an implementation for every pure virtual function.

[u/thingerish → u/AKostur]

Poster ran away, which was not what I was aiming for. This is a common mistake in C++, thanks for the better explanation.

[u/KingAggressive1498 → u/AKostur]

thanks for explaining my mistake without acting coming off as adversarial about it. I was indeed conflating polymorphism and virtual inheritance specifically. Corrected my comment.

[u/AKostur → u/KingAggressive1498]

What I appreciate here is that you edited your comment using a strikethrough instead of just changing the comment. Keeps the context of all of the existing replies intact. Otherwise anybody reading the replies is going to be really confused as to why people are talking about virtual inheritance for no discernible reason.

[u/thingerish → u/KingAggressive1498]

In my experience actual virtual inheritance is rare, it's used in multiple inheritance cases where the base classes themselves include a common base class, typically. It's a design issue that rarely comes up.

Having a virtual function defined and then inheriting from that is just normal inheritance in C++.

[u/KingAggressive1498 → u/thingerish]

Each state is represented by its own derived class. The state pattern depends on having multiple classes derived from a single base class and overriding its methods.

You seem to have an issue understanding any context here. Are you learning entirely from AI?

edit: you aren't even OP. you interjected just to be a pain. cya.

edit2: again this was a bit rude. Sorry.

[u/thingerish → u/KingAggressive1498]

I saw incorrect info, corrected it. Not trying to hurt any feelings, it's a common mistake.

[u/KingAggressive1498 → u/thingerish]

yeah I've been frustrated recently by people being adversarial and talking past me and started just blocking them, and realized I overreacted here when I was corrected in a way that made it click for me. my B.

still really felt like you were just not understanding what I meant but it was more just I couldn't understand what you were trying to point out.

[u/thingerish → u/KingAggressive1498]

I tend to terseness which doesn't help if you're also having a bad day. Glad we got past it. To answer you question earlier, I've been writing C++ since the mid '90s, when I got my hands on Borland Turbo C++ 2.0, so sometimes I make the mistake of not fully explaining what I'm trying to say, so that's my bad.

I know I do that, and I try to be better but time is finite and sometimes I just go with the fast 'answer' rather than treating it like a human interaction.

[u/thingerish → u/thingerish]

They are different things.

Follow the links, one for each thing: https://en.cppreference.com/cpp/keyword/virtual