Question

For the upcoming Coursework in January, I started developing a small DirectX engine. To find out if there is a performance increase I wanted to try to not use any virtuals at all (I know that virtuals aren’t all bad, but I just wanted to see if it is possible without them).

When I started playing around with a simple StateManager, it got hard to avoid virtuals, but this is my current approach:

#include <boost\function.hpp>
#include <boost\bind.hpp>

template <class Derived>
struct TBaseState {
  bool update(float delta) {
    return static_cast<Derived *>(this)->update(delta);
  };
};

struct CTestState : TBaseState<CTestState> {
  bool update(float delta) {
      return true;
  }
};

class StateManager
{
public:
    template <class StateClass> static void setState(StateClass nextState)
    {
        m_funcptrUpdate = boost::bind(&TBaseState<StateClass>::update,     boost::ref(nextState), _1);
    }
    static bool update(float delta) 
    {
        return m_funcptrUpdate(delta);
    }
protected:
private:
    static boost::function<bool (float)> m_funcptrUpdate;
};

Visual Studio 2010’s Intellisense seems to think everything is fine, but when I want to compile the program and test the StateManager with a very basic approach:

CTestState* t = new CTestState(); 
StateManager::setState(*t);
StateManager::update(0.0f);

The following error is thrown during linking phase:

error LNK2001: unresolved external symbol "private: static class boost::function<bool __cdecl(float)> StateManager::m_funcptrUpdate" (?m_funcptrUpdate@StateManager@@0V?$function@$$A6A_NM@Z@boost@@A)

So obviously he can’t find the binded function, but how can I solve this issue? I get similar errors if I use boost::bind directly to some class. Since I am a computer science student I would also be interested in some insight or approaches without boost (e.g. bind1st, …).

EDIT:
I was also thinking about using C++11 Variadic Templates, but one of the coursework requirements is to stick to VS2012.

Answer 1

Static class members need to be given storage. They’re like extern variables. Add a definition to one of your .cpp files, outside of the class definition:

boost::function<bool (float)> StateManager::m_funcptrUpdate;

Also, in this code:

template <class StateClass> static void setState(StateClass nextState)
{
    m_funcptrUpdate = boost::bind(&TBaseState<StateClass>::update,
        boost::ref(nextState), _1);
}

You’re maintaining storing a reference to the local variable nextState. That reference will be invalid after setState returns.