Hoffe, ich konnte helfen,

Felix

class INode {
public:
  bool doSth() = 0;
};

typedef (bool) INode::_fptr();
struct mptr {
private:
  INode& node;
  _fptr fptr;
public:
  mptr(INode& _node, _fptr _fptr) : node(_node)
    , fptr(_fptr) {}

  bool operator()() {
    return node.(*fptr);
  }
};

class Node : public INode {
public:
   bool func() { ... }
};

int main() {
   Node myNode;
   mptr myPtr(myNode, myNode.func);
   if(myPtr())
     cout << hell ya << endl;

   return 0;

}

so in etwa.
Ich hab's grad eben nur schnell runtergeschrieben - aber so in etwa.

typedef void (CXX::*f)(void);

struct t_data {
  t_data(CXX* pPage_, f pFunc_)
      : pPage(pPage_), pFunc(pFunc_) {}

  ~t_data() {
      pPage = 0;
      pFunc = 0;
  }

  void operator() () {
      if(pPage && pFunc)
        (pPage->*pFunc)();
  }
protected:
  CXX* pPage;
  f pFunc;
}; 

class CXX {
public:
  void funk();
protected:
  void bla();
};

void CXX::bla() {
  t_data pio(this, funk);
  pio();
}

Natürlich isses mit Templates schöner und flexibler.

und wie könnte jetzte ein funktionszeiger auf eine methode aussehen(methodenzeiger?)?

class Test {

  public:
         int myInt;
         int myfunc();
};

...

int Test::*daten;     //Elementzeiger auf die Daten deiner Klasse
int (Test::*funcs)(); //Elementzeiger auf die Funktionen deiner Klasse

Test la;

//Nun die Offsets der Elemente holen
daten = &Test::myInt;
funcs = &Test::myfunc();

//Anhand des Offsets über ein Objekt das Element ansprechen;
cout << la.*daten;
(la.*myfunc)();