Fonction membre vers pointer non typé

Est-il possible de convertir une fonction membre (d'une class) vers un pointer non typé(void*)
class A{
 int foo(int,int){};
void init(){
  void *t;
  A *x;
  x=this;
  int(A::*z)(int,int);
  t=&A::foo;
  z=t;
  (x->*z)(2,5);
};
}

j'ai une bonne raison de passer par un pointer non typé.
(j'aurai pu faire z=&A::foo mais n est pas ce que je cherche à faire)


FoxZ...

Salut,
A quoi ca peut bien te servir tout ce bricolage ?

mon but est de pouvoir chainer des methodes virtual sur des class multi-instances.

class A{
    virtual int foo(int){};
};

class B:A{
    int foo(int){};
}

class C:A{
    int foo(int){};
};

class D:B,C{};

...
D r;
r.foo(5); // la le compilo plante.
...

maintenant, je voudrais que D::foo() appel C::foo() qui appel lui meme B::foo() etc.
ET CEUX SELON L ORDRE DE LA DECLARATION.

FoxZ...

#include <cstdlib>
#include <iostream>

using namespace std;
#define vp virtual public

class SomeClass;

template <class T>
class SC{
    public:
        SomeClass*c;
        T f;
};

#define dcvl(r,v,p) typedef r(SomeClass::*td##v)p;typedef SC<td##v> ih##v;ih##v v;
#define dinh(c,v) c::ih##v ih##v;
#define vpp(v) ih##v=v;
#define ovr(cl,v) v.c=(SomeClass*)(this);v.f=(cl::td##v)
#define inh(v) (ih##v.c->*ih##v.f)
#define vcc(v) (v.c->*v.f)

class A{
    protected:
        dcvl(int,r,(int)); // declare int(SomeClass::*r)(int) (pointer de function membre)
    public:
        virtual int cascad(int x){
            vcc(r)(x);    // appele *r (un pointer de function s'appel comme suit class*->*pointer)
        };
};

class B:vp A{
    private:
        int foo(int x){
            std::cout << "B\n";       
        };
    public:
        B(){
            ovr(A,r)(&B::foo); // A::*r pointera sur B::foo
        };
};

class C:vp A{
    private:
        dinh(A,r);                // declare que A::*r aura un heritier
        int foo(int x){
            std::cout << "C\n";
            inh(r)(x);            // appele l'heriter
        };
    public:
        C(){
            vpp(r);                // sauvegarde l'heritier (cf inh plus haut)
            ovr(A,r)(&C::foo);    // A::*r pointera sur C::foo
        };
};


class e:vp B,vp C{};

int main(int argc, char *argv[])
{
    e z;
    z.cascad(3);
    system("PAUSE");
    return EXIT_SUCCESS;
}

un truc comme ca quoi...

ca donne
C
B

FoxZ...

Salut,
Dans ton exemple il n'y a pas de D::foo(), et c'est normal qu'il plante a l'appel de foo car il y a une ambiguité entre B::foo et C::foo.
Pour l'appel en cascade des autres methodes foo, je ne pense pas que ca soit possible, c'est a toi de le faire manuellement.