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