Funktionspointer übergeben

Hallo Leute,

habe zwei Klasse die wie folgt aussehen:

class B {
public:
  B(/* hier kommt der Funktionspointer rein*/){
    // irgend welcher Code
    // Hier dann der aufruf A::barA
  }
  ~B(){}
};

class A {
public:
  A(){}
  ~A(){}
  void fooA () {
     B *b = new B(/* übergebe ich den Aufruf A::barA */);
  }
  void barA ( int a ) {
     // Do something
  }
};

Klasse A wird irgendwann mal ein Objekt der Klasse B erstellen und soll ihm nun den Funktionspointer "barA" übergeben damit die Klasse B den irgend wann mal aufrufen kann.

Das besondere daran soll halt sein, dass die Klasse B nicht ausdrücklich einen Funktionspointer von A annehmen soll, sondern irgend ein Funktionspointer von einer X beliebigen Klasse.

Also ich müsste da mit Templates arbeiten, aber finde kein Ansatz wie ich das realisieren soll.

Gruß
Slux

#include <iostream>
using namespace std;

template<typename T>
class B
{
	public:
		B(void (T::*ptmf)(int))
		{
			A a;
			(a.*(ptmf))(123);
		}
		~B() {}
};

class A
{
	public:
		A()  {}
		~A() {}
		void fooA ()
		{
			B<A> *b = new B<A>(&A::barA);
			delete b;
		}
		void barA ( int a )
		{
			cout << a;
		}
};

int main()
{
	A a;
	a.fooA();
}

Allerdings sieht das Ganze sehr merkwürdig aus und ich habe keinen blassen Dunst, was du damit überhaupt erreichen willst.

LordJaxom

EDIT:
out's Quelltext nicht richtig gelesen - sorry.

class B {
public:
  B(std::function< void (int) > func){
    // irgend welcher Code
    func(123);
  }
  ~B(){}
};

class A {
public:
  A(){}
  ~A(){}
  void fooA () {
     B *b = new B(std::bind(&A::barA, this, _1));
  }
  void barA ( int a ) {
     // Do something
  }
};

Ich habe das Prinzip stark vereinfacht von dem was ich da gerade habe und deswegen wirkt es etwas komisch.

Hab das Problem noch auf eine andere Art und Weise gelöst - ich habe mit signals gearbeitet, boost::signal bzw sigc::signal, damit kann man etwas komplexer arbeiten.