How can I achieve polymorphism in this simple minimal example?

Question

The problem

I'm trying to achieve polymorphism by having types of Event subtypes inherit from the base class Event. The idea is that there is always an active event, denoted by the pointer in Runner (Event* current_event). When the Runner::step method is called, the Event::go method is called, which flips some switches and changes the current behaviour of the program. Then, the pointer is pointed at a different event until Runner::step is called again.

The issue is that the pointer is always using the base class Event versions of variables. It might be a simple fix but I'd be greatful if somebody could point it out to me.

The code

#include <iostream>

using namespace std;


struct Flags {
public:
    bool withCheese = false;
    bool withBiscuits = false;

};

class Event {
    std::string description = "The base class";
public:
    std::string id = "Base";

    Event() = default;

    ~Event() = default;

    Event(Event const &event) = default;

    Event &operator=(Event &&) = default;

    virtual void go(Flags &flags) {};

    virtual void printDescription() {
        std::cout << description << std::endl;
    }
};


class EatCheese : public Event {
    std::string description = "We eat cheese now";
public:
    using Event::Event;
    std::string id = "EatCheese";

    void go(Flags &flags) override {
        flags.withCheese = true;
        flags.withBiscuits = false;
    };
};

class EatBiscuits : public Event {
    std::string description = "We eat biscuits now";
public:
    using Event::Event;
    std::string id = "EatBiscuits";

    void go(Flags &flags) override {
        flags.withCheese = false;
        flags.withBiscuits = true;
    };
};


class Runner {
public:
    EatCheese eventA;
    EatBiscuits eventB;
    Event *current_event = &eventA; // The problematic line: this still points to Base, not eventA.

    Flags flags;

    Event* step() {
        cout << "description: ";
        current_event->printDescription();
        current_event->go(flags);


        if (current_event->id == "EatCheese") {
            cout << "We have EatCheese"<<endl;
            current_event = &eventB;
        }

        else if (current_event->id == "EatBiscuits") {
            cout << "We have EatBiscuits"<<endl;
            current_event = &eventA;
        }
        cout << endl;

        return current_event;
    }

};


int main() {
    Runner runner;
    cout << "current_event_id: " << runner.current_event->id << ", with biscuits: " << runner.flags.withBiscuits << ", with Cheese: " << runner.flags.withCheese << endl;
    runner.step();
    cout << "current_event_id: " << runner.current_event->id<< ", with biscuits: " << runner.flags.withBiscuits << ", with Cheese: " << runner.flags.withCheese << endl;
    runner.step();
    cout << "current_event_id: " << runner.current_event->id<< ", with biscuits: " << runner.flags.withBiscuits << ", with Cheese: " << runner.flags.withCheese << endl;
    return 0;
};

This will output

current_event_id: Base, with biscuits: 0, with Cheese: 0
description: The base class

current_event_id: Base, with biscuits: 0, with Cheese: 1
description: The base class

current_event_id: Base, with biscuits: 0, with Cheese: 1

Where I expect it to output:

current_event_id: EatCheese, with biscuits: 0, with Cheese: 1
description: We eat cheese now

current_event_id: EatBiscuits, with biscuits: 1, with Cheese: 0
description: We eat biscuits now

current_event_id: EatCheese, with biscuits: 1, with Cheese: 0```

Answer 1

You are referring to non-virtual members in your main function.

struct Base { int myNumber = 0; };

struct Child : Base { int myNumber = 10 };

both classes have a myNumber member but since Child is a derviative of Base it has actually 2 myNumber of which the one from the base class is hidden.

If you do

Child obj;
std::cout << obj.myNumber;

it would print 10, because your expression refers to Child::myNumber. However, if you make it a pointer or reference of your base class

Child obj;
Base* ptr = &obj;
Base& ref = obj;
std::cout << ptr->myNumber << ref.myNumber;

both will print 0 because the object is now treated as type Base. The member variable in question usually hides the base member, but since our variable has a different type now, the access path to that variable is different aswell and Base::myNumber is the symbol we're referring to now.

So create virtual getter functions:

class Event {
    std::string description = "The base class";
public:
    std::string id = "Base";

    virtual std::string const& getDescription() const;
    virtual std::string const& getId() const;
    // ...
};

and override them in your child class.

Also, for further reading I recommend: Why does an overridden function in the derived class hide other overloads of the base class?