C++ function pointers

// command storage base classstruct CommandBase {	std::string name;};// stores a class-specific function pointertemplate< typename T >struct CommandSpecific : CommandBase {	CommandSpecific( std::string _name, void (T::*_fnp)(int a) ) {		name = _name;		fnp = _fnp;	}	// declare the function-pointer storage variable 'fnp'	void (T::*fnp)(int a);};class Console {private:	std::vector< CommandBase* > cmdlist;public:	// adds a command and stores its pointer	template< typename T >	void addCommand( void (T::*fnp)(int a), std::string cmd ) 	{		CommandBase *cb = new CommandSpecific< T >( cmd, fnp );		cmdlist.push_back( cb );	}	// attempt to call a command	template< typename T >	void attemptCommand( T& inst, std::string cmd ) 	{		std::vector<CommandBase*>::iterator i = cmdlist.begin();		// look for the command to see if its listed		for(; i!=cmdlist.end(); i++ ) 		{			if( (*i)->name == cmd ) 			{				// now we know the command calls match,				// cast the stored pointer to retreive the class-specific function pointer				CommandSpecific<T> *cp = static_cast< CommandSpecific<T>* > ( (*i) );				// do the funtion call, supply some random number for fun :)				(inst.*(cp->fnp))( rand() % 100 );			}		}	}	virtual ~Console() {		// cleanup fn ptrs		std::vector<CommandBase*>::iterator i = cmdlist.begin();		for( ; i != cmdlist.end(); i++ ) {			delete (*i);			*i = NULL;		}		cmdlist.clear();	}};

// our test classesclass SomeClass {	std::string sig;public:	SomeClass( std::string _sig ) : sig(_sig) {}	void foo(int a) {		std::cout << "SomeClass: " << sig.c_str() << " : " << a << std::endl;	}};// our test classesclass SomeOtherClass {	std::string sig;public:	SomeOtherClass( std::string _sig ) : sig(_sig) {}	void foobar(int a) {		std::cout << "SomeOtherClass: " << sig.c_str() << " : " << a << std::endl;	}};int main() {	SomeClass myObjA("Booom!");	SomeOtherClass myObjB("KaPow!");	Console con;	con.addCommand< SomeClass >( &SomeClass::foo, "SomeClass_foo" );	con.addCommand< SomeOtherClass >( &SomeOtherClass::foobar, "SomeOtherClass_foobar" );		con.attemptCommand< SomeClass >( myObjA, "SomeClass_foo" );	con.attemptCommand< SomeOtherClass >( myObjB, "SomeOtherClass_foobar" );	return 0;}

 // DIRECTLY FROM FUNCTION-POINTER.ORG, COPYRIGHT (C) 2004-2005   class TClassA   {   public:      void Display(const char* text) { cout << text << endl; };      static void Wrapper_To_Call_Display(void* pt2Object, char* text);      /* more of TClassA */   };   // static wrapper-function to be able to callback the member function Display()   void TClassA::Wrapper_To_Call_Display(void* pt2Object, char* string)   {       // explicitly cast to a pointer to TClassA       TClassA* mySelf = (TClassA*) pt2Object;       // call member       mySelf->Display(string);   }   // function does something which implies a callback   // note: of course this function can also be a member function   void DoItA(void* pt2Object, void (*pt2Function)(void* pt2Object, char* text))   {      /* do something */      pt2Function(pt2Object, "hi, i'm calling back using a argument ;-)");  // make callback   }   // execute example code   void Callback_Using_Argument()   {      // 1. instantiate object of TClassA      TClassA objA;      // 2. call 'DoItA' for <objA>      DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display);   }