ich schreibe gerade eine GameState Klasse für mein SFML Projekt und stehe gerade auf den Schlauch

Mein Ziel ist es jeder State eine ID zu vergeben:

StateManager sm;
sm.add( states::id::menu, std::unique_ptr< State >( new Menu() ) );
sm.add( states::id::game, std::unique_ptr< State >( new Game() ) );

Mein Problem ist das ich nicht alle State Klassen sofort initialisieren will, bei der Eintragung soll nur festgelegt werden welche Klasse eine ID zurückgibt.

Die State soll dann so aufgerufen werden:

sm.push( states::id::menu );

Zwei Möglichkeiten sind mir eingefallen um das Problem zu lösen:
-nur einen Zeiger übergeben
-eine std::function übergeben

Sind die Ideen gut oder gibt es eine bessere Möglichkeit ?

sm.emplace<Menu>();

finde ich genauso kurz und es ist um einiges flexibler.

Eine std::function zu übergeben wäre natürlich ein schneller Fix, aber wozu das ganze enum-Getue?

Ich habe noch nie eine GameState geschrieben und finde im Internet kein gutes Beispiel( c++11 und SFML ). Deswegen habe ich angefangen meine eigene zu schreiben.

#ifndef STATEMANAGER_H
#define STATEMANAGER_H

#include <memory>
#include <vector>
#include <iostream>
#include <algorithm>

template< class T >
class StateManager
{
    public:
        StateManager( T ptr );

        void change( T ptr );

        void push( T ptr );

        void pop();

        void clear();

        void draw();

        void handleEvents();

        void update();

        void manageAction();

        bool empty();

    private:
        std::vector< T > stateStack;
};

template< class T >
StateManager<T>::StateManager( T ptr )
{
    stateStack.push_back( std::move( ptr ) );
}

template< class T >
void StateManager<T>::change( T Ptr )
{
    pop();
    push( std::move( Ptr ) );
}

template < class T >
void StateManager<T>::push( T ptr )
{
    stateStack.push_back( std::move( ptr ) );
}

template < class T >
void StateManager<T>::pop()
{
    stateStack.pop_back();
}

template< class T >
void StateManager<T>::clear()
{
	stateStack.back()->clear();
}

template < class T >
void StateManager<T>::draw()
{
    stateStack.back()->draw();
}

template< class T >
void StateManager<T>::handleEvents()
{
    stateStack.back()->handleEvents();
}

template < class T >
void StateManager<T>::update()
{
    stateStack.back()->update();
}

template< class T >
void StateManager<T>::manageAction()
{
    stateStack.back()->manageAction(*this);
}

template< class T >
bool StateManager<T>::empty()
{
    return stateStack.empty();
}
#endif // STATEMANAGER_H

#ifndef STATE_H
#define STATE_H

#include "StateManager.h"
#include <memory>

class State
{
    public:
        typedef std::unique_ptr< State > Ptr;

        void changeState( StateManager< Ptr >& sm, Ptr p );

        void pushState( StateManager< Ptr >& sm, Ptr p );

        void popState( StateManager< Ptr >& sm );

		virtual void clear() = 0;

        virtual void draw() = 0;

        virtual void handleEvents() = 0;

        virtual void update() = 0;

        virtual void manageAction( StateManager< Ptr >& sm ) = 0;

        virtual ~State();

};

Ich wollte versuchen mit enums die manageAction Funktion zu ersetzen, damit die State nicht vollen Zugriff auf den StateManager hat.

Ich habe noch nie eine GameState geschrieben und finde im Internet kein gutes Beispiel( c++11 und SFML ).

Im SFML-Buch wird so eine State-Architektur Schritt für Schritt hergeleitet. Wenn du das Buch nicht kaufen willst (das E-Book gibts momentan fast umsonst), kannst du auch den zugehörigen Source-Code auf GitHub anschauen.