C++ Game - Should I initialize game states more than once? - vector

Question

I have a bare bones game state system worked out however I need some advice on how to improve it. I have a GameState.h that all the game states inherit from. Therefore to manage the game states I have a class that stores a vector of game states
std::vector<GameState *> gameStates;
This handles the game states but using function like pop/push(_back).
At the moment I am creating my game states like this:
.h
GameState *mainMenu = nullptr;
GameState *inGame = nullptr;
.cpp
mainMenu = new MainMenuState();
inGame = new InGameState();
then initializing them like so:
mainMenu->initialize(this, camera);
inGame->initialize(this, camera);
then adding them to the vector like this:
setCurrentGameState(mainMenu);
should I do it like I am already doing it or like this:
setCurrentGameState(new MainMenuState(this, camera));
Should I initialize all of the game states at the start of the game or should I initialize them when they are pushed into the vector then delete them again whey they are popped? In the past I have tried to initialize them when they are pushed however it makes handling the memory much harder. However would initializing all of the game states a the start of the game hinder performance?

Answer 1

What i can say from my experience is: It depends on how big is your game.
A little suggestion. You can split your game in multiple FSM. One for main menu/options/credits part and one for the "real" game part. In this way you can instantiate all the states for the current FSM in use and call the related methods to activate them.
One little architecture example:
class State
{
public:
virtual void OnEnter() = 0;
virtual void OnUpdate(float i_fTime) = 0;
virtual void OnExit() = 0;
};
class FSM
{
public:
/*
here you call onenter for the state where you want
to go and onexit for the current state
*/
virtual void GoToState( const std::string& state_name ) = 0;
/*
here you call OnUpdate method on m_pCurrentState
*/
virtual void Update( float i_fTime ) = 0;
private:
State* m_pCurrentState;
std::map<std::string, State*> m_mStates;
};
class FSMSystem
{
public:
void SetCurrentFSM( FSM* i_pFSM );
void Update( float i_fTime );
private:
FSM* m_pCurrentFSM;
};
For each of your custom fsm, you have to implement from FSM interface. For each of your custom state, you have to implement State class.
Initialize your state inside constructor ( or an init method ) during the creation of your FSM. Leave the heavy stuff ( like texture loading/complex algorithm or similar request to the OnEnter method ).