#include <iostream>
#include <vector>
#include <string>
using namespace std;

template <class MyDummyClass, typename ReturnType, typename Parameter>
class SingularCallBack
{
public:
	typedef ReturnType (MyDummyClass ::*Method)(const Parameter&);

	SingularCallBack(MyDummyClass* _class_instance, Method _method, Parameter h)
	{
		class_instance = _class_instance;
		method             = _method;
		hh = h;
	};

	ReturnType execute(Parameter parameter)
	{
		return (class_instance->*method)(parameter);
	};

private:
	MyDummyClass*   class_instance;
	Method  method;
	Parameter hh;
};


template <typename MyDummyClass, typename ReturnType, typename Parameter>
class BaseClass
{
public:
       std :: vector<SingularCallBack<MyDummyClass, ReturnType, Parameter> > myvec;

       BaseClass ()
       {
	    if (myvec.empty () == false)
	    {
	       myvec[0].execute (55);
	    }
	    else
	    {
		 cout << "\nNothing to print\n";
		 cout << "\ny" << y;
	    }
       }	
};

template <typename ReturnType, typename Parameter>
class AClass : public BaseClass<AClass<ReturnType, Parameter>, ReturnType, Parameter>
{
public:     
	AClass ()
	{
		this->myvec.push_back( SingularCallBack<AClass, ReturnType, Parameter>(this, &AClass::f, 55) );
	}
	ReturnType f (const Parameter& foo) 
	{
		cout << "\nasdsads\n";
		return ReturnType();
	}
};

int main()
{     
	AClass<int, int> test;
	return 0;
}

#include <string>
#include <iostream>
#include <vector>
#include <exception>

//using namespace std; <<-- DON'T do this, brings a lot of stuff into global namespace

template <class MyDummyClass, typename ReturnType, typename Parameter> class SingularCallBack{
public:
//Don't mix tabs and spaces. 
	typedef ReturnType (MyDummyClass::*Method)(Parameter);

	 	  
	//
	/*SingularCallBack(MyDummyClass* _class_instance, Method _method){ <-- variable names shoudl not begin with underscore - those are reserved
		If you REALLY want underscore, try putting it at the end of the name*/
	SingularCallBack(MyDummyClass* classInstance_, Method method_)
	:classInstance(classInstance_), method(method_){//<<-- don't use assignments, when you can use initializer list
		/*class_instance = classInstance_;
		method = method_;*/
	};

	ReturnType execute(Parameter parameter){//you could use operator()
		return (classInstance->*method)(parameter);
	};

	inline ReturnType operator()(Parameter parameter){
		return execute(parameter);
	}
private:
	MyDummyClass*   classInstance;
	Method  method;
};


class BaseClass{
public:
	virtual bool DerivedMethod (const std::string& str){
		return true; 
	}
};

#if 0// won't work, disabled
//class AClass : public BaseClass{
//public:
	/*template<class derivedComponent, class Allocator = allocator<derivedComponent>> class callbackList;*/
	// ^^^ nope. It isn't a variable, it is a type. You clealry want variable. You can't (AFAIK) make template variables, only functions.
	
     	  
//	AClass(){} <-- nothing to initialize, no need for construtor, unless you want to support assignment operators and such.
 
//	bool AMethod( std::string& str){
//		std::cout << "AClass[]: " << str << std::endl;
//		return true;
//	}     	
//};
#endif 

class OutOfRange: public std::exception{
public:
	virtual const char* what() const throw(){
		return "array index out of range";
	}
};

template <class Class, typename Result, typename Argument> class AClass{
public:
	typedef SingularCallBack<Class, Result, Argument> Callback;
protected:
	typedef std::vector<Callback> CallbackList;
	CallbackList callbackList;
public:

	size_t size() const{
		return callbackList.size();
	}

	void clear(){
		callbackList.clear();
	}

	void addCallback(Class* classInstance, typename Callback::Method method){
		callbackList.push_back(Callback(classInstance, method));
	}

	Result runCallback(size_t index, Argument argument){
		if (index > size())
			throw OutOfRange();
		Callback& cur = callbackList[index];
		return cur(argument);
	}	
};              	

class TestClass{
public:
	bool doIt(std::string arg){//technically, we need to use const std::string& here.
		std::cout << arg << std::endl;
		return true;
	}
};

int main(int argc, char** argv){     
	TestClass test;
	AClass<TestClass, bool, std::string> callbacks;   
	callbacks.addCallback(&test, &TestClass::doIt);
	callbacks.runCallback(0, "In my restless dreams, I see that town.");
	//a.callbackList.push_back (SingularCallBack < AClass, bool, const std::string& > (&a, &AClass :: AMethod, "sadsa"));
	//^^^You will need two different classes here, otherwise it will be impossible to declare aclass.


	return 0;
}

#include <iostream>
#include <vector>

typedef int ResultType;
typedef int ParameterType;

struct BaseCallBack {
    virtual ~BaseCallBack() {}
    virtual ResultType execute( ParameterType ) = 0;
};

template <class Object>
struct CallBack : public BaseCallBack {
    typedef ResultType (Object::* Fun) ( ParameterType );
    Object& m_object;
    Fun m_fun;
    CallBack( Object& object, Fun fun ) :
        m_object( object ),
        m_fun( fun )
    {}
    ~CallBack() {}
    ResultType execute( ParameterType p) {
        return (m_object.*m_fun)( p );
    }
};

struct CallBackManager // No objects of this type.  All members are static
{
    static std::vector<BaseCallBack*> call_backs;
    template <class A, class F>
    static void add( A& a, F f ) {
        call_backs.push_back( new CallBack<A>(a, f) );
    }
    static ResultType execute_next( ParameterType p ) {
        ResultType result = call_backs[0]->execute( p );
        delete call_backs[0];
        call_backs.erase( call_backs.begin() );
        return result;
    }
};
std::vector<BaseCallBack*> CallBackManager::call_backs;

struct AClass {
    ResultType fred( ParameterType p ) {
        std::cout << "AClass::fred was called with parameter " << p << std::endl;
        return 1;
    }
};

struct BClass {
    ResultType george( ParameterType p ) {
        std::cout << "BClass::george was called with parameter " << p << std::endl;
        return 2;
    }
};

int main()
{
    AClass a;
    BClass b;

    CallBackManager::add( a, &AClass::fred );
    CallBackManager::add( b, &BClass::george );

    std::cout << "Finished adding" << std::endl;

    ResultType r = CallBackManager::execute_next( 11 );
    std::cout << "First execute returned " << r << std::endl;
    r = CallBackManager::execute_next( 12 );
    std::cout << "Second execute returned " << r << std::endl;

    return 0;
}

CallBackManager a;
///initialized and filled with method.
{ 
    CallBackManager b(a);
    CallBackManager c = a;
}
//do something with a's pointers.