Creating a font in initializer list

[Dante12129]

I have a state machine in my game in order to handle different menus, gameplay sequences, credits and etc. Each state stores a reference to the main font in the game. The problem is that I am using a game class so that I can keep the code in my main down to a minimum. This class stores the actual font. The thing is that I initialize my state manager with the first state, so I use the initializer list. The thing is that I have to initialize the font before it, but I can't get it to work.

The variables are declared like this:

sf::RenderWindow main_window;
sf::Font main_font;

dte::StateManager m_state_manager;
 

And the game class' constructor looks like this:

Game::Game() : main_window(sf::VideoMode(640, 480), "Animal Instincts"), main_font(), m_state_manager(new MenuState(main_window, main_font)) { main_font.loadFromFile("Unispacerg.ttf"); }
 

The state manager has to take its first state in its constructor in order to work properly, as I have no function to initialize it later.

And the MenuState's constructor:

MenuState::MenuState(sf::RenderWindow& window, sf::Font& font) : m_window_ptr(&window), m_font(font), m_needs_change(false), m_welcome_message("Welcome", m_font, 30)
    {
        m_welcome_message.setColor(sf::Color::White);
        dte::CenterTextHor(m_welcome_message, *m_window_ptr);

        std::cout << "Menu state created." << std::endl;
    }
 

The problem is that this code will only show the text if I cause a new Menustate to be created. How would I go about initializing the font in the initializer list so that it will work the first time?

[Laurent]

sf::Font loadFont(...) {...}

..., main_font(loadFont(...)), ...

But this is a very bad design in my opinion. It doesn't allow you to detect and handle a loading error. And saying "my code wants that, but I can only do this" is usually a bad sign; don't forget that you write the code, so you should adapt the design to what you want to do, not the other way round.

[Silvah]

sf::Font loadFont(...) {...}

..., main_font(loadFont(...)), ...

But this is a very bad design in my opinion. It doesn't allow you to detect and handle a loading error.

Actually, it does.

sf::Font loadFont(const Foo& foo)
{
  if(loadingFailed)
    throw std::runtime_error("oh noes");
}

Game::Game()
try
  : /* ... */, main_font(loadFont(someFoo)), /* ... */
{
}
catch(std::exception& e)
{
  // handle the error, or just allow it to propagate
}

In fact, just letting it propagate is likely the right thing to do.

[Dante12129]

I'm adding a method to my state manager to allow it to be initialized with a state after construction.

[Nexus]

I'm adding a method to my state manager to allow it to be initialized with a state after construction.

...and the design gets uglier and uglier.

Why don't you just keep things simple? Construct the state manager as a member of another class (not globally), and initialize it during construction. If there is an error, throw an exception -- that's what exceptions are for. But don't leave the object in an invalid state and require to call an initialize method after construction, this just injures invariants and works around the intent of constructors.

[Dante12129]

The state manager already is part of my game class, and it wouldn't work properly because I couldn't initialize the game class' font in the initialzer list before it.