class A {
public:
 void __stdcall F1(int k)
 {
   printf("A::F1(%d)\n",k);
 }
};

class B: public A {
public:
 void __stdcall F1(int k,int d)
 {
   printf("B::F1(%d,%d)\n",k,d);
 }
};

...

void* pFNA = A::F1;
void* pFNB = B::F1;

...

на сервере
class A {
public:
 virtual void __stdcall F1(int k)
 {
   printf("A::F1(%d)\n",k);
 }
};

и где-то там-же

 A a;
 MyRpcRegisterMethod("A::F1",&a,A::F1);

на стороне клиента
 MyRpcCall("A::F1",5);

ну и соответственно на сервере 
вывелось бы

 A::F1(5)

I> а надо эт для того чтобы некий гипотетический программист создал класс ну к примеру так

I> парметрами исправте код в моей библиотеке

template<typename ret, typename arg1> ret f(arg1)
{
// ...
}

template<typename ret, typename arg1, typename arg2> ret f(arg1, arg2)
{
// ...
}
...

class A {
public:
 void __stdcall F1(int k)
 {
   printf("A::F1(%d)\n",k);
 }
};

class B: public A {
public:
 void __stdcall F1(int k,int d)
 {
   printf("B::F1(%d,%d)\n",k,d);
 }
};

struct Method {
 void*        mthdOwner;
 void*    mthdFunction;
 Method(void* Owner,...)
 {
  va_list mthd;
  va_start(mthd,Owner);
  mthdOwner    = Owner;
  mthdFunction    = va_arg(mthd,void*);
  va_end(mthd);
 }
};

Ну и где то в коде 

B b;
Method m(&b,B::F1);

#include <iostream>

class A
{
   int a;
   public:
      void Func()
           {
           }
};

class B : virtual public A
{
   int b;
};

class C : virtual public A
{
   int c;
};

class F
{
   int f;
};

class D : public F, public B, public C
{
};

int main()
{
   void (A::*func)() = &A::Func;
   D d;
   (d.*func)();
   return 0;
}

АЯ>Это и есть Ирокез, я просто сменил имя

class A
{
};

class B: virtual public A {
public:
    void __stdcall F1(int k,int d){}
};


int main()
{
    B b;
    Method m(&b,B::F1);


    printf("%i", sizeof (&B::F1));
}

#include <iostream>
using namespace std;

struct A
{
};

struct B : virtual A
{
  virtual void foo() {}
};

int main()
{
  cout << "size of void*   = " << sizeof(void*  ) << endl;
  cout << "size of &B::foo = " << sizeof(&B::foo) << endl;
}

#include <iostream>

class    A
  {
  public :
    void f() {}
  };

typedef void (A::*meth_ptr_t)();

int
main()
  {
    void * vp = 0;
    meth_ptr_t mp = 0;

    std::cout << "sizeof(vp): " << sizeof(vp) << ", "
      << "sizeof(mp): " << sizeof(mp) << std::endl;

    return 0;
  }

АЯ>B b;
АЯ>Method m(&b,B::F1);
АЯ>

Method m(&b, &B::F1);

[Sorry, skipped] 

 А> теперь внимание ответ. 
 А> [code]
 А> struct Method {
 А>  void*  mthdOwner;
 А>  void* mthdFunction;
 А>  Method(void* Owner,...)
 А>  {
 А>   va_list mthd;
 А>   va_start(mthd,Owner);
 А>   mthdOwner = Owner;
 А>   mthdFunction = va_arg(mthd,void*);
 А>   va_end(mthd);
 А>  }
 А> };

 А> Ну и где то в коде 

 А> B b;
 А> Method m(&b,B::F1);

 А>

 void* tmp = reinterpret_cast<void*>(&A::F1);

struct Method {
 void*    mthdOwner;
 void (A::*mthdFunction)();
 Method(void* Owner,...)
 {
  va_list mthd;
  va_start(mthd,Owner);
  mthdOwner    = Owner;
  mthdFunction    = va_arg(mthd,void A::*);
  va_end(mthd);
 }
};

#include <iostream>

struct A {
  int i;
  A() : i(1) {}
  void print() { std::cout << i << std::endl; }
};

struct B {
  int i;
  B() : i(2) {}
  void print() { std::cout << i << std::endl; }
};

struct C : A, B {
  int i;
  C() : i(3) {}
};

void call(C* pc, void (C::*pm)()) {
  (pc->*pm)();
}

int main() {
  C c;
  call(&c, &A::print);
  call(&c, &B::print);
}

00401080   mov         eax,dword ptr [esp+4]
00401084   mov         ecx,dword ptr [esp+0Ch]
00401088   add         ecx,eax
0040108A   jmp         dword ptr [esp+8]

#include <stdio.h>
#include <stdarg.h>

class A
{
public:
    void __stdcall Fn1()
    {
        printf("A::Fn1()\n");
    }
    virtual void __stdcall Fn2() = 0;
};

class B : public virtual A
{
public:
    void __stdcall Fn1(int& k,int& d)
    {
        printf("B::Fn1(%d-%d)\n",k,d);
    }
    virtual void __stdcall Fn2()
    {
        printf("B::Fn2()\n");
    }
};

struct Method
{
    Method(void* Owner,...)
    {
        va_list mthd;
        va_start(mthd,Owner);
        mthdOwner = Owner;
        unsigned long tag1 = va_arg(mthd,unsigned long);
        mthdFunction  = va_arg(mthd,void*);
        unsigned long tag2 = va_arg(mthd,unsigned long);
        printf("owner = %p, tag1 = %08X, func = %p, tag2 = %08X\n", mthdOwner, tag1, mthdFunction, tag2);
        va_end(mthd);
        // dump the stack again...
        printf("Ellipsis is ...\n");
        va_start(mthd,Owner);
        do
        {
            tag2 = va_arg(mthd,unsigned long);
            printf("... %08X\n", tag2);
        }
        while(tag2 != 0xDEADBEEF);
        va_end(mthd);
    }
};

int main()
{
    B b;
    Method m(&b, 0xFEEDFACE, &B::Fn2, 0xDEADBEEF);
}

owner = 0012FF78, tag1 = FEEDFACE, func = 004011A0, tag2 = 00000000 <--- а где же дохлая корова?
Ellipsis is ...
... FEEDFACE
... 004011A0
... 00000000
... 00000004
... DEADBEEF         <--- а вот она!

struct Method {
    typedef long (__stdcall Method::*Function)();
    void*        mthdOwner;
    Function    mthdFunction;
    Method(void* Owner,...)
    {
        va_list mthd;
        va_start(mthd,Owner);
        mthdOwner        = Owner;
        mthdFunction    = static_cast<Function>(va_arg(mthd,Function));
        va_end(mthd);
    }
    long Run(int iCount,...)
    {
        void* pArgs[10];

        void* Owner = mthdOwner;
        void* Fn = mthdFunction;
        long Result;

        va_list marker;
        va_start( marker, iCount );

        int i=0;
        while(iCount --){
            pArgs[i ++] = va_arg( marker, void*);
        }
        va_end(marker);

        while(i--){
            __asm mov eax,i
            __asm mov eax,dword ptr pArgs[eax*4]
            __asm push eax

        }

        __asm push Owner
        __asm mov eax,Fn
        __asm call eax

        return Result;
    }
};

А>struct Method {
А>    typedef long (__stdcall Method::*Function)();
А>    void*        mthdOwner;
А>    Function    mthdFunction;
А>    Method(void* Owner,...)
А>    {
А>        va_list mthd;
А>        va_start(mthd,Owner);
А>        mthdOwner        = Owner;
А>        mthdFunction    = static_cast<Function>(va_arg(mthd,Function));
А>        va_end(mthd);
А>    }
А>    long Run(int iCount,...)
А>    {
А>        void* pArgs[10];

А>        void* Owner = mthdOwner;
А>        void* Fn = mthdFunction;
А>        long Result;

А>        va_list marker;
А>        va_start( marker, iCount );

А>        int i=0;
А>        while(iCount --){
А>            pArgs[i ++] = va_arg( marker, void*);
А>        }
А>        va_end(marker);

А>        while(i--){
А>            __asm mov eax,i
А>            __asm mov eax,dword ptr pArgs[eax*4]
А>            __asm push eax

А>        }

А>        __asm push Owner
А>        __asm mov eax,Fn
А>        __asm call eax

А>        return Result;
А>    }
А>};
А>

void* Fn = mthdFunction;

struct A {
  int i;
  A() : i(1) {}
  void __stdcall print() { std::cout << i << std::endl; }
};

struct B {
  int i;
  B() : i(2) {}
  void __stdcall print() { std::cout << i << std::endl; }
};

struct C : A, B {
  int i;
  C() : i(3) {}
};

void call(C* pc, void (__stdcall C::*pm)()) {
  (pc->*pm)();
  Method p(pc, pm);
  p.Run(0);
}

int main() {
  C c;
  call(&c, &A::print);
  call(&c, &B::print);
}

1
1
2
1

int Sum(int a, int b)
{
  return 4;
}

void* Fn = mthdFunction;

error C2440: 'initializing' : cannot convert from 'long (__stdcall Method::*)(void)' to 'void *' 
             There is no context in which this conversion is possible

...
        __asm mov eax,Fn
        __asm call eax
...

struct A { int x; void a(); };
struct B { int y; void b(); };
struct C : A, B { int z; void c(); }
typedef void (C::*CF)();

int main()
{
  CF cf = &B::b;

  C* pc = new C;
  B* pb = pc; // явное приведение типа, с коррекцией адреса
  pb->b(); // коррекция не нужна
  pc->b(); // коррекция на стадии компиляции: неявное приведение к B*
  (pc->*cf)(); // откуда взять коррекцию? - только из cf
}

struct C: A, B
{
  int z;
  void call_b() { b(); } // коррекция указателя - здесь
};

int main()
{
  CF fb = &B::b; // компилятор подставит &C::call_b
}

typedef void (B::*BF)();

int main()
{
  BF bf = &B::b;
  .....
  CF cf = bf; // какой прокси подставить сюда?
}

struct A { int x; void a() {} };
struct B: A { int y; virtual void b() {} };
struct C: B { int z; virtual void b() {} };

typedef void (A::*FA)();
typedef void (B::*FB)();
typedef void (C::*FC)();

int main()
{
  B* pb = new C;

  FB fa = &A::a;
  FB fb = &B::b; // заметьте! мы здесь ничего не знаем про C

  pb->a(); // статический вызов
  pb->b(); // динамический вызов C::b

  (pb->*fa)(); // статический вызов
  (pb->*fb)(); // динамический вызов - обращаемся к vfptr/vtbl
}

#include <stdio.h>

struct simple_a { void A() { } };
struct simple_b : simple_a { void B() { } };

struct vt_a { virtual void vA() { } };
struct vt_b : vt_a { virtual void vB() { } };
struct vt_c : vt_a { virtual void vC() { } };

struct mi_a : vt_b, vt_c { void mA() { } };
struct mi_b : virtual vt_b, virtual vt_c { void mB() { } };

void print_dw(void *p, int sz)
{
    for (int i = sz/4 - 1; i >= 0; --i)
        printf("%08X ", (unsigned*)p + i);
    printf("\n");
}

template <class P>
union hack_cast
{
    P p_;
    void *v_;
    hack_cast(const P& p) : p_(p) { }
    operator void * () { return v_; }
};

template <class P>
void ptm(P p)
{
    print_dw(hack_cast<P>(p), sizeof(p) );
}

void main()
{
    typedef void (simple_b::*simple_p)();
    typedef void (vt_c::*vt_p)();
    typedef void (mi_a::*multiple_p)();
    typedef void (mi_b::*multiple_vt_p)();
    printf("%d\n", sizeof(simple_p));
    printf("%d\n", sizeof(vt_p));
    printf("%d\n", sizeof(multiple_p));
    printf("%d\n", sizeof(multiple_vt_p));

    ptm(&mi_a::mA);
    ptm(&mi_b::mB);
}

4
4
8
12
00401104 00401100
00401108 00401104 00401100

• tiny (flat) — и код, и данные разделяют один и тот же селектор. Все указатели ближние.
  
• small — указатели ближние, но код и данные — в разных сегментах.
  
• compact — данные не умещаются в один сегмент, используются дальние указатели. sizeof(void*) > sizeof(void(*)()).
  
• medium — код не умещается в один сегмент. sizeof(void*) < sizeof(void(*)()).
  
• large — дальние указатели и кода, и данных.

I am so not going to cover virtual inheritance. That way lies madness.

G>struct Method {
G> void*    mthdOwner;
G> void (A::*mthdFunction)();
G> Method(void* Owner,...)
G> {
G>  va_list mthd;
G>  va_start(mthd,Owner);
G>  mthdOwner    = Owner;
G>  mthdFunction    = va_arg(mthd,void A::*);
G>  va_end(mthd);
G> }
G>};

G>

struct Method {
  void*    mthdOwner;
  void (A::*mthdFunction)();
  Method(void* Owner, void (A::*method)())
  {
    mthdOwner = Owner;
    mthdFunction = method;
  }
};

#include <iostream>

class    A;

typedef void (A::*meth_ptr_t)();

int
main()
  {
    void * vp = 0;
    meth_ptr_t mp = 0;

    std::cout << "sizeof(vp): " << sizeof(vp) << ", "
      << "sizeof(mp): " << sizeof(mp) << std::endl;

    return 0;
  }

class    A;
typedef void (A::*method_of_A)();

void
do_something( A * a, method_of_A m );

#include "a_forward.hpp"

void
do_something( A * a, method_of_A m )
  {
    (a->*m)();
  }

class    A
  {
  public :
    void f();
  };

#include "a_implementation.hpp"
#include "a_forward.hpp"

void
A::f() {}

int
main()
  {
    A a;
    do_something( &a, &A::f );

    return 0;
  }

Digital Mars C++, uses a different optimization. For single-inheritance classes, a member function pointer is just the address of the function. When more complex inheritance is involved, the member function pointer points to a 'thunk' function, which performs the necessary adjustments to the this pointer, and then calls the real member function. One of these little thunk functions is created for every member function that's involved in multiple inheritance. This is the most efficient implementation.

struct A {
  int i;
  A() : i(1) {}
};

struct B {
  int i;
  B() : i(2) {}
};

struct C : A, B {
  int i;
  C() : i(3) {}
  void print() { std::cout << i << std::endl; }
};

void call(B* pb, void (B::*pm)()) {
  (pb->*pm)();
}

int main() {
  C c;
  call(&c, static_cast<void (B::*)()>(&C::print));
}

3

АТ>struct A {
АТ>  int i;
АТ>  A() : i(1) {}
АТ>};

АТ>struct B {
АТ>  int i;
АТ>  B() : i(2) {}
АТ>};

АТ>struct C : A, B {
АТ>  int i;
АТ>  C() : i(3) {}
АТ>  void print() { std::cout << i << std::endl; }
АТ>};

АТ>void call(B* pb, void (B::*pm)()) {
АТ>  (pb->*pm)();
АТ>}

АТ>int main() {
АТ>  C c;
АТ>  call(&c, static_cast<void (B::*)()>(&C::print));
АТ>}
АТ>

tarasevich.cpp(25) : warning C4407: cast between different pointer to member representations, compiler may generate incorrect code

tarasevich.cpp(25) : error C2664: 'call' : cannot convert parameter 2 from 'void (__thiscall C::* )(void)' to 'void (__thiscall B::* )(void)'
Types pointed to are unrelated; conversion requires reinterpret_cast, C-style cast or function-style cast

struct TClass : A, B, C, virtual D, virtual E
{
};

static void (TClass::*)() _ptm_TClass_Run = &TClass::Run;

void *p = &_ptm_TClass_Run;

#include <iostream>

struct A {
  int i;
  A() : i(1) {}
};

struct B {
  int i;
  B() : i(2) {}
};

struct C : A, B {
  int i;
  C() : i(3) {}
  void print() { std::cout << i << std::endl; }
};

void call(B* pb, void (B::*pm)()) {
  (pb->*pm)();
}

int main() {
  C c;
  call(&c, &C::print );

  return 0;
}

Borland C++ 5.6 for Win32 Copyright (c) 1993, 2002 Borland
tarasevich.cpp:
Error E2034 tarasevich.cpp 25: Cannot convert 'void (C::*)()' to 'void (B::*)()' in function main()
Error E2342 tarasevich.cpp 25: Type mismatch in parameter 'pm' (wanted 'void (B::*)()', got 'void (C::*)()') in function main()
*** 2 errors in Compile ***

tarasevich.cpp: In function `int main()':
tarasevich.cpp:25: error: cannot convert `void (C::*)()' to `void (B::*)()' for
argument `2' to `void call(B*, void (B::*)())'

Thank you for testing your code with Comeau C/C++!
Tell others about http://www.comeaucomputing.com/tryitout !

Your Comeau C/C++ test results are as follows:

Comeau C/C++ 4.3.3 (Aug 6 2003 15:13:37) for ONLINE_EVALUATION_BETA1
Copyright 1988-2003 Comeau Computing. All rights reserved.
MODE:strict errors C++

"ComeauTest.c", line 25: error: argument of type "void (C::*)()" is incompatible
with parameter of type "void (B::*)()"
call(&c, &C::print );
^

1 error detected in the compilation of "ComeauTest.c".
In strict mode, with -tused, Compile failed

#include <stdio.h>

struct A {
  int i;
  A() : i(1) {}
};

struct B {
  int i;
  B() : i(2) {}
};

typedef void (B::*meth_t)();

struct C : A, B {
  int i;
  C() : i(3) {}
  void print() { printf( "C::print: %d\n", i ); }
};

struct D : B {
  int i;
  D() : i(4) {}
  void print() { printf( "D::print: %d\nFormat C: complete!\n", i ); }
};

void call(B* pb, meth_t pm ) {
  (pb->*pm)();
}

int main() {
  meth_t pm = static_cast< meth_t >( &C::print );

  C c;
  call( &c, pm );

  D d;
  call( &d, pm );

  return 0;
}

C::print: 3
C::print: 4

АТ>Последнее соврешенно не верно. Никакая "ошибка программиста" через 'static_cast' не подавляется. 'static_cast', по своей идее, не может подавлять никаких "ошибок программиста" (для этого предназначен 'reinterpret_cast' . Использованная мною конверсия является соврешенно легальной функциональностью 'static_cast', четко описанной в отдельном разделе стандарта 5.2.9/9. Меня всегда удивляло, почему программисты с достаточной степенью готовности вопринимают идею ковариантности для обычных указателей, а вот в существовоание контравариантности дял указателей на члены не верят и считают, что без хака тут не обойтись.

#include <iostream>

struct A {
  int i;
  A() : i(1) {}
};

struct B {
  int i;
  B() : i(2) {}

  void print() { std::cout << i << std::endl; }
};

struct C : A, B {
  int i;
  C() : i(3) {}
};

void call(B* pb, void (B::*pm)()) {
  (pb->*pm)();
}

int main() {
  C c;
  call(&c, &C::print );

  return 0;
}

#include <stdio.h>

struct A {
  int i;
  A() : i(1) {}
};

struct B {
  int i;
  B() : i(2) {}

  virtual void print() { printf( "B::print: %d\n", i ); }
};

struct C : A, B {
  int i;
  C() : i(3) {}

  virtual void print() { printf( "C::print: %d\n", i ); }
};

void call(B* pb, void (B::*pm)()) {
  (pb->*pm)();
}

int main() {
  C c;
  call(&c, static_cast< void (B::*)() >( &C::print ) );

  return 0;
}

char c = ...;
unsigned int u = static_cast< unsigned int >( c );

... In particular, a pointer to member cannot be converted to a void*.

E>#include <stdio.h>

E>struct A {
E>  int i;
E>  A() : i(1) {}
E>};

E>struct B {
E>  int i;
E>  B() : i(2) {}
E>};

E>typedef void (B::*meth_t)();

E>struct C : A, B {
E>  int i;
E>  C() : i(3) {}
E>  void print() { printf( "C::print: %d\n", i ); }
E>};

E>struct D : B {
E>  int i;
E>  D() : i(4) {}
E>  void print() { printf( "D::print: %d\nFormat C: complete!\n", i ); }
E>};

E>void call(B* pb, meth_t pm ) {
E>  (pb->*pm)();
E>}

E>int main() {
E>  meth_t pm = static_cast< meth_t >( &C::print );

E>  C c;
E>  call( &c, pm );

E>  D d;
E>  call( &d, pm );

E>  return 0;
E>}
E>

АТ>>Последнее соврешенно не верно. Никакая "ошибка программиста" через 'static_cast' не подавляется. 'static_cast', по своей идее, не может подавлять никаких "ошибок программиста" (для этого предназначен 'reinterpret_cast' . Использованная мною конверсия является соврешенно легальной функциональностью 'static_cast', четко описанной в отдельном разделе стандарта 5.2.9/9. Меня всегда удивляло, почему программисты с достаточной степенью готовности вопринимают идею ковариантности для обычных указателей, а вот в существовоание контравариантности дял указателей на члены не верят и считают, что без хака тут не обойтись.

E>Посмотрел пункт 5.2.9/9 стандарта, а заодно и ссылку оттуда на пункт 4.11. Казуистика еще та, сразу вспомнилась русская пословица про "закон, что дышло..." + еще мои (не)знания английского языка К сожалению, стандарт C++ далек от совершенства, допускает различные варианты интерпритации (что видно на особенностях разных компиляторов).

E>char c = ...;
E>unsigned int u = static_cast< unsigned int >( c );
E>

unsigned int u = c;

template <typename classType> const void *GetClassMethodAddress(classType clt)
{
    union
    {
        classType    _clt;
        const void    *ptr;
    };
    _clt = clt;
    return ptr;
}

I>class A {
I>public:
I> void __stdcall F1(int k)
I> {
I>   printf("A::F1(%d)\n",k);
I> }
I>};
I>

I>class B: public A {
I>public:
I> void __stdcall F1(int k,int d)
I> {
I>   printf("B::F1(%d,%d)\n",k,d);
I> }
I>};
I>

I>...

I>void* pFNA = A::F1;
I>void* pFNB = B::F1;

I>...
I>

I>Кстати прочитал Александреску — ничего примечательного

template<typename Class, typename Result, typename Arg0>
void* void_cast(Result (Class::*method)(Arg0))
{
  typedef Result (Class::*Method)(Arg0);
  union
  {
    Method m;
    void* p; 
  }u;
  u.m = method;
  return u.p;
}

//Применение:
class A
{
public:
  int foo(const char*);
};

void* p = void_cast(&A::foo);