АЯ>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;
    }
};