class Foo
{
public:
  void A()
  {
      PORTA = 0;
  }
  void B()
  {
      PORTA = 0xff;
  }
};
// тип указателя на функцию член Foo, возвращающую void и не принимающую аргументов
typedef void (Foo::*FooFuncPtr)();

int main()
{
// экземпляр класса Foo
  Foo foo;
// fPtr указывает на Foo::A
  FooFuncPtr fPtr = Foo::A;
// вызываем Foo::A через указатель для объекта foo
  (foo.*fPtr)();
// fPtr указывает на Foo::B
  fPtr = Foo::B;
// вызываем Foo::B через указатель для объекта foo
  (foo.*fPtr)();
  return 0;
}

// fPtr указывает на Foo::A
  FooFuncPtr fPtr = &Foo::A;

class A {
public:
    void f(unsigned char b) {
        // какие-то действия
    }
};
class B {
public:
    void f(unsigned char b) {
        // какие-то действия
    }
};

int main( void )
{
    A a;
    B b;
    // FuncPtr - такой указатель чтоб на любой метод (с учётом сигнатуры конечно)
    // конкретного экземпляра указывал
    FuncPtr f_ptr;
    f_ptr=&a.f();
    f_ptr();// вызов a.f

    f_ptr=&a.f();
    f_ptr();// вызов b.f

}

struct GenericClass{};
typedef void (GenericClass::*VoidFuncPtr)();

class delegate{
public:
  template<class ObjT>
  explicit delegate(ObjT *obj, void (ObjT::*func)() )
  {
    _func = reinterpret_cast<VoidFuncPtr>(func);
    _pThis = reinterpret_cast<GenericClass*>(obj);
  }
  void operator ()(){
     (_pThis->*_func)();
  }
private:
  VoidFuncPtr _func;
  GenericClass *_pThis;
};

class Foo{
public:
  void Func(){
    PORTA = 0xff;
  }
};

int main()
{
  Foo foo;
  delegate d(&foo, &Foo::Func);
  d();
  return 0;}

#pragma vector=TIMER1_COMPA_vect
__interrupt void ISR_10_Hz()
{
// какие-то действия
}