А>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 — дальние указатели и кода, и данных.