A class-based state machine?

In C++ I'm trying to make a simple state machine for a game, based on classes.

stateMan.setState<mainMenuState>();

I have a class with the declaration as:

class stateManager
{
  ...
  template <class T>
  void setState(void);
}

And the test code as:

template <class T>
void stateManager::setState<T>(void)
{
  T* blah = new T;
  delete blah;
}

And obviously this doesn't work since funct开发者_如何学Pythonion template partial specialization ‘setState<T>’ is not allowed.

Would there be a better way to do this besides doing it non-OO?

---

The definition of the member function template should be this:

template <class T>
void stateManager::setState(void)
{
   //...
}

That is, it should be simply setState instead of setState<T>. The latter syntax is used in function template specialization. Since T is a type parameter, the specialization would be considered as function partial template specialization which is not allowed.

---

Hard to say without the details, but you could do a base State class, and the different states inherit from it.

If you still want to use classes for this, you can see an interesting example using boost.mpl.

---

Another option that avoids templates would be to define a pure virtual base class for your game states, and then pass references to different game-states to your function. For instance,

//pure virtual base class that will define the state interfaces
class base_state { /*...*/ }; 

//a derived state class
class mainMenuState : public base_state { /*...*/ }; 

class stateManager
{
    //...

    //you can pass any derived base_state to this function
    void setState(base_state* state); 
};