nøddeknækker

En ikke ret køn løsning:

#include <iostream>
#include <string>

class C1
{
public:
  void callFunction(std::string name, void *p, void (* PFunc)(void *))
  {
    std::cout << name << std::endl;
    PFunc(p);
  }
}g_c1;

class C2
{
public:
  C2()
  {
    g_c1.callFunction("fb1", this, foo1);
    g_c1.callFunction("fb2", this, foo2);
  }
  static void foo1(void *p)
  {
    ((C2 *)p)->foobar1();
  }

  static void foo2(void *p)
  {
    ((C2 *)p)->foobar2();
  }
  void foobar1()
  {
    std::cout << "foobar" << std::endl;
  }

  void foobar2()
  {
    std::cout << "foobar2" << std::endl;
  }
};

int main()
{
  C2 c2;
}

Lidt kønnere løsning:
#include <iostream>
#include <string>

class C2Base
{
public:
  virtual void foobar1() = 0;
  virtual void foobar2() = 0;
};

class C1
{
public:
  void callFunction(std::string name, C2Base *Obj, void (C2Base::*PFunc)())
  {
    std::cout << name << std::endl;
    (Obj->*PFunc)();
  }
}g_c1;

class C2 : public C2Base
{
public:
  C2()
  {
    g_c1.callFunction("fb1", this, &C2Base::foobar1);
    g_c1.callFunction("fb2", this, &C2Base::foobar2);
  }
  void foobar1()
  {
    std::cout << "foobar" << std::endl;
  }

  void foobar2()
  {
    std::cout << "foobar2" << std::endl;
  }
};

int main()
{
  C2 c2;
}

Og endelig en med template funktion:

#include <iostream>
#include <string>

class C2Base
{
public:
  virtual void foobar1() = 0;
  virtual void foobar2() = 0;
};

class C3Base
{
public:
  virtual void whatever() = 0;
  virtual void something() = 0;
};

class C1
{
public:
  template <class T>
  void callFunction(std::string name, T *Obj, void (T::*PFunc)())
  {
    std::cout << name << std::endl;
    (Obj->*PFunc)();
  }
}g_c1;

class C2 : public C2Base
{
public:
  C2()
  {
    g_c1.callFunction<C2Base>(std::string("fb1"), this, &C2Base::foobar1);
    g_c1.callFunction<C2Base>(std::string("fb2"), this, &C2Base::foobar2);
  }
  void foobar1()
  {
    std::cout << "foobar" << std::endl;
  }

  void foobar2()
  {
    std::cout << "foobar2" << std::endl;
  }
};

class C3 : public C3Base
{
public:
  C3()
  {
    g_c1.callFunction<C3Base>(std::string("What"), this, &C3Base::whatever);
    g_c1.callFunction<C3Base>(std::string("Some"), this, &C3Base::something);
  }
  void whatever()
  {
    std::cout << "Whatever" << std::endl;
  }

  void something()
  {
    std::cout << "Something" << std::endl;
  }
};

int main()
{
  C2 c2;
  C3 c3;
}

tak skal du have det var lige hvad jeg havde brug for

Ved nærmere eftertanke; man behøver ikke der virtuelle base class'er hvis man bruger template funktionen:

#include <iostream>
#include <string>

class C1
{
public:
  template <class T>
  void callFunction(std::string name, T *Obj, void (T::*PFunc)())
  {
    std::cout << name << std::endl;
    (Obj->*PFunc)();
  }
}g_c1;

class C2
{
public:
  C2()
  {
    g_c1.callFunction<C2>(std::string("fb1"), this, &C2::foobar1);
    g_c1.callFunction<C2>(std::string("fb2"), this, &C2::foobar2);
  }
  void foobar1()
  {
    std::cout << "foobar" << std::endl;
  }

  void foobar2()
  {
    std::cout << "foobar2" << std::endl;
  }
};

class C3
{
public:
  C3()
  {
    g_c1.callFunction<C3>(std::string("What"), this, &C3::whatever);
    g_c1.callFunction<C3>(std::string("Some"), this, &C3::something);
  }
  void whatever()
  {
    std::cout << "Whatever" << std::endl;
  }

  void something()
  {
    std::cout << "Something" << std::endl;
  }
};

int main()
{
  C2 c2;
  C3 c3;
}