can't find where virtual method is being called from

[Stauricus]

hello
i'm creating a simple gui system for games (as it's just for learning purposes, i'd like to create it from scratch).
but I can't find where this pure virtual function is being called from. I know i'ts about 100 lines of code, but this is the minimal example that I could get that reproduces the problem:

#include <vector>
#include <string>
#include <functional>

///Widgets
class Button{
protected:
    std::function<void()> action;
public:
    virtual void run() = 0;
};

class TextButton : public Button{
public:
    TextButton(const std::function<void()>&);
    void run();
};
TextButton::TextButton(const std::function<void()>& function){
    action = function;
}
void TextButton::run(){
    action();
}

///Gui Manager
class GuiManager{
public:
    std::vector<TextButton> m_text_buttons;

    void addTextButton(const std::function<void()>&);
    void removeAll();
    void run();
};

void GuiManager::addTextButton(const std::function<void()>& function){
    m_text_buttons.push_back(TextButton(function));
}

void GuiManager::removeAll(){
    m_text_buttons.clear();
}

void GuiManager::run(){
    for (auto &n : m_text_buttons) n.run();
}

///Menu Class that uses GUI
enum MenuHandlerEnum{Title, NewGame, LoadGame, Options, Credits, Exit};
class MenuHandler{
    public:
    MenuHandlerEnum m_current_menu;
    GuiManager m_gui;

    void changeMenu(MenuHandlerEnum);
    void startMainMenu();
    void startNewGameMenu();

    MenuHandler();

    void processEvents();
};
MenuHandler::MenuHandler(){
    changeMenu(MenuHandlerEnum::Title);
}
void MenuHandler::processEvents(){
    m_gui.run();
}
void MenuHandler::startMainMenu(){
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::NewGame);});
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::LoadGame);});
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::Options);});
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::Credits);});
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::Exit);});
}
void MenuHandler::startNewGameMenu(){
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::Title);});
    m_gui.addTextButton([&](){changeMenu(MenuHandlerEnum::NewGame);});
}
void MenuHandler::changeMenu(MenuHandlerEnum new_menu){
    m_gui.removeAll();
    switch (new_menu){
        case MenuHandlerEnum::Title:{
            startMainMenu();
            break;
        }
        case MenuHandlerEnum::NewGame:{
            startNewGameMenu();
            break;
        }
        default:{
            m_current_menu = MenuHandlerEnum::Title;
            break;
        }
    }
    m_current_menu = new_menu;
}

///Main
int main(){
    MenuHandler menu;
    menu.processEvents();
    return 0;
}

if I execute it, i gte the error

pure virtual method called
terminate called without an active exception
Aborted

is it calling the method from inside the base class (Button)? if yes, why, and when exactly?

thanks in advance!

[helios]

The problem is that GuiManager::run() is calling run() on each of the TextButtons, which is equivalent to activating the buttons. The actions for all the buttons involve calling MenuHandler::changeMenu(), which calls GuiManager::removeAll(), which clears GuiManager::m_text_buttons.
In other words, you're modifying an std::vector as you traverse it.

This would fix the crash, although I doubt it's what you intended:

auto v = std::move(m_text_buttons);
for (auto &n : v)
    n.run();

You'll probably want a display() function or something.

[mbozzi]

this is the minimal example that I could get that reproduces the problem

This program contains multiple layers of trivial passthrough functions and purposeless class types.

There is some abstract class hierarchy being managed by a manager which is handled by some handler but the program just calls some functions in a list.

If the program was written to solve the problem directly, it would be more obvious that it modifies the list of functions while iterating over it.

This snippet reproduces the failure:

#include <vector>
#include <functional>

int main()
{
  std::vector<std::function<void()>> manager
   { [&]{ manager.push_back([]{}); manager.push_back([]{}); }, []{} };
  
  for (auto &component: manager) component();
}

[Stauricus]

In other words, you're modifying an std::vector as you traverse it.

I actually hadn't realized that. so after modifying it, i tried to call the action() from a place in memory where there were nothing?

This program contains multiple layers of trivial passthrough functions and purposeless class types.

yes. as I said, its the minimal I could get still reproducing the error, so its not built from scratch, but a code stripped down.


anyway, thanks everybody! i changed the run() function in TextButton (line 22) to:

bool TextButton::run(){
    if (buttonPressed()){
        action();
        return true;
    }
    else return false;
}

and the GuiManager run() (line 43) to:

void GuiManager::run(){
    for (auto &n : m_text_buttons) if (n.run()) break;
}

now if any button is pressed (the code for checking it isn't in the example, of course), it breaks the 'for' loop.

[helios]

i tried to call the action() from a place in memory where there were nothing?

You tried to use an object that had already been destructed.