C/C++ How to declare a type for event handler in a class?

Question

I need help in C/C++ to know how to define a type for event handler that will be used as a class member.

This is an example that works with simple variables and functions:

    #include "cstdlib"
    #include "stdio.h"

    using namespace std;
    typedef int(*fun_type)(int a,int b);  /* Tipo define a interface para o manipulador */

    int soma(int a,int b);
    int multiplica(int a,int b);

    int main(int argc, char** argv) {
        /* ESSE CARA NÃO FUNCIONA QUANDO É UM MEMBRO DE CLASSE */
        fun_type fun = NULL;  /* Declara a variável para guardar o manipulador */
        int a,b,c,r;
        a = 2;
        b = 5;

        fun = &soma;   /* define o manipulador apontando para soma() */
        r = fun(a,b);  /* chama o manipulador especificado */
        printf("%d + %d = %d\n",a,b,r);

        /*Altera o manipulador*/
        fun = &multiplica;     /* Agora apontando para multiplica */
        r = fun(a,b);
        printf("%d x %d = %d\n",a,b,r);

        return 0
    }

    /* Os manipuladores do exemplo */
    int soma(int a,int b){ return a + b; }
    int multiplica(int a,int b){ return a * b; }

The above example works, but not when fun is a member of a class. How should I declare 'fun_type' to accept a method from any other object.

No delphy would be a statement like:

<code>
   TFun_type = function(sender:TObject,p1,p2:Integer):Integer of Object;
</code>

A better example I need is something that works like this:

#include <stdio.h>
#include <string.h>

/* Esta classe tem o manipulador do evento (metodo manipulador) */
class A_manipulaEvento{
public:
    A_manipulaEvento();
   ~A_manipulaEvento();

   int manipulador(int __val);
};

class Z_manipulaEvento{
public:
    Z_manipulaEvento();
   ~Z_manipulaEvento();

   int manipulador(int __val);
};


/* Esta classe chama um manipulador que pode ser de um Objeto A_manipulaEvento ou qualquer outra classe
   desde que tenha a mesma interface (sequencia de parametros e tipo de retorno)*/
class B_disparador{
public:
    B_disparador();
    ~B_disparador();

    void fazAlgumaCoisa(int __valor);

    /*Aqui declara o ponteiro para o metodo é de outro objeto de classe diferente que não é especifica,
     * deve aceitar metodo de qualquer objeto seja lá qual for a classe respeitando-se a interface do método.
     * a interrogações significa que essa é a parte que não sei como declarar
     */
    int (*??ponteiro???)(int __val);
};

/* código do manipulador de evento A */
int A_manipulaEvento::manipulador(int __val){ printf("A_manipulaEvento::manipulador(%d)\n", __val); }

/* código do manipulador de evento Z */
int Z_manipulaEvento::manipulador(int __val){ printf("Z_manipulaEvento::manipulador(%d)\n", __val); }


B_disparador::B_disparador(){
   /* ao instanciar B_disparador o ponteiro não aponta pra ninguem */
   this->ponteiro = NULL;
}

void B_disparador::fazAlgumaCoisa(int __valor){
    printf("Fazendo alguma coisa");

    if (*this->ponteiro != NULL){
       this->ponteiro(__valor);
    }
}

int main(){

    A_manipulaEvento man_1;
    Z_manipulaEvento man_2;
    B_disparador  disp;

    /* Aqui disp vai chamar o método manipulador do objeto man_1*/
    disp.ponteiro = &man_1.manipulador;
    disp.fazAlgumaCoisa(10);

    /* Aqui o mesmo disp vai chamar o método manipulador do objeto man_2
     * objeto diferente e classe diferente */
    disp.ponteiro = &man_2.manipulador;
    disp.fazAlgumaCoisa(20);

}