//This is the templated function to point to:

template <class T>
void testFunc(T* unknownObj) {
//...

}
//this is the "templated function pointer":

template <class T>
void (*pFn)(T*) = Create;

//the templated function to point totemplate <class T>void testFunc(void* unknownObj) {//now... you want your defined object right?T* desiredObj = reinterpret_cast<T*>(unknownObj);}//And the function pointer:typedef void (*pFn)(void*);//now you can use the function pointer for any instance of testFunc(void* unknownObj)pFn pFuncWithSomeClass = testFunc<SomeClass>;pFn pFuncString = testFunc<char>;pFn pFuncSomeOtherClass = terstFunc<SomeOtherClass>;

template <class T>void* Create(char* name) {return new T;}//now I need a templated function pointer! right?//But I don't know how to do it?!//The same "hack" above works for this situation:template <class T>void* Create(char* name) {return new T;}typedef void* (*pFn)(char*);pFn pFuncSomeClass = Create<SomeClass>;//I would need to typecast the returned pointer :(SomeClass* tempObj = reinterpret_cast<SomeClass*>((*pFuncSomeClass)("SomeValue"));//this "hack" only works since I KNOW what type the//function returns... since I need to make a cast.//BUT WHAT IF I WOULDN'T KNOW?

#include <iostream>template <typename T>class pFn{	public:		typedef void (*PFN)(T*);		pFn(PFN p)		{			func = p;		}		void operator()(T* t)		{			func(t);		}	private:		PFN func;};template <typename T>void testFunc(T* t){	std::cout << *t << ''\n'';}int main(){	pFn<int> intPFn(testFunc);	pFn<float> floatPFn(testFunc);	pFn<char*> charPointerPFn(testFunc);	int i = 7;	float f = 32.2f;	char* cp = "test string";	intPFn(&i);	floatPFn(&f);	charPointerPFn(&cp);}

//the object factory has this://...typedef void* (*pFnInterfaceInstance)();std::map<const char*, pFnInterfaceInstance> CreateCallbackMap;RegisterInterface(const char* sVersion, pFnInterfaceInstance GetInstance);//...//this is how the object registers itself...//...namespace {void* GetISoundBaseInterface() {return new ISoundBase;}Interfaces::RegisterInterface("BaseInterface", GetISoundInterface);}//...//then I have a newer version of the ISoundInterfacenamespace {void* GetISoundV2Interface() {return new ISoundV2;}Interfaces::RegisterInterface("v.2", GetISoundV2Interface);}//...//Lets say I have a Dll that Implements the Game stuff... and//lets say I need to be able to use the Implementations of my//ISound interface for playing sound.... so I have something//like this:class Game {//...ISoundBase* soundInterface;//...};//then I would load animplementetion of the sound interface//and I could choose to use an older version of it if I//would want... but the standard would be the latest version//of the interface...//etc...