DV>class C
DV>{
DV>   private:
DV>     void Proc1(char *c);
DV>     void Proc2(void);
DV>}
DV><...>

DV>void C::Proc2(void)
DV>{
DV>  int addr;
DV>  unsigned char *buffer;
DV>  void (C::*ptr)(char *) = &C::Proc1;
DV>  addr = (int)ptr; // ошибка type cast
DV>  buffer = (unsigned char*)ptr; // ошибка type cast
DV>}
DV>

#include <iostream>

class C
{
public:
  C() : c('C') { }

  virtual void f() = 0;
  virtual void g() = 0;

  void h() { std::cout << "C::h, " << c << std::endl; }
  void i() { std::cout << "C::i, " << c << std::endl; }

private:
  char c;
};

class D
{
public:
  virtual void f() = 0;
  virtual void g() = 0;
};

class E
{
public:
  E() : c('E') { }

  void f() { std::cout << "E::f, " << c << std::endl; }
  void g() { std::cout << "E::g, " << c << std::endl; }

private:
  char c;
};

class F : public E, public C
{
public:
  F() : c('F') { }

  virtual void f() { std::cout << "F::f, " << c << std::endl; }
  virtual void g() { std::cout << "F::f, " << c << std::endl; }

private:
  char c;
};

class G : public E, virtual public C
{
public:
  G() : c('G') { }

  virtual void f() { std::cout << "G::f, " << c << std::endl; }
  virtual void g() { std::cout << "G::f, " << c << std::endl; }

private:
  char c;
};

void(C::*cf)() = &C::f;
void(C::*cg)() = &C::g;
void(C::*ch)() = &C::h;
void(C::*ci)() = &C::i;
void(D::*df)() = &D::f;
void(D::*dg)() = &D::g;
void(E::*ef)() = &E::f;
void(E::*eg)() = &E::g;

extern void h(E&, F&, G&);

int main()
{
  E e;
  F f;
  G g;

  h(e, f, g);

  return 0;
}

extern void test(E&, C&, C&);

void h(E& e, F& f, G& g)
{
  test(e, f, g);

  unsigned ucf = reinterpret_cast<unsigned&>(cf);
  unsigned ucg = reinterpret_cast<unsigned&>(cg);
  unsigned uch = reinterpret_cast<unsigned&>(ch);
  unsigned uci = reinterpret_cast<unsigned&>(ci);
  unsigned udf = reinterpret_cast<unsigned&>(df);
  unsigned udg = reinterpret_cast<unsigned&>(dg);
  unsigned uef = reinterpret_cast<unsigned&>(ef);
  unsigned ueg = reinterpret_cast<unsigned&>(eg);

  std::cout << std::endl;

  std::cout << ucf << std::endl;
  std::cout << ucg << std::endl;
  std::cout << uch << std::endl;
  std::cout << uci << std::endl;
  std::cout << udf << std::endl;
  std::cout << udg << std::endl;
  std::cout << uef << std::endl;
  std::cout << ueg << std::endl;

  std::cout << std::endl;

  typedef void(C::*Cf)();
  typedef void(D::*Df)();
  typedef void(E::*Ef)();

  cf = reinterpret_cast<Cf&>(ucf);
  cg = reinterpret_cast<Cf&>(ucg);
  ch = reinterpret_cast<Cf&>(uch);
  ci = reinterpret_cast<Cf&>(uci);
  df = reinterpret_cast<Df&>(udf);
  dg = reinterpret_cast<Df&>(udg);
  ef = reinterpret_cast<Ef&>(uef);
  eg = reinterpret_cast<Ef&>(ueg);

  test(e, f, g);
}

void test(E& e, C& f, C& g)
{
  (e.*ef)();
  (e.*eg)();

  (f.*cf)();
  (f.*cg)();
  (f.*ch)();
  (f.*ci)();

  (g.*cf)();
  (g.*cg)();
  (g.*ch)();
  (g.*ci)();

  typedef void(F::*Ff)();
  typedef void(G::*Gf)();

  Ff ff = static_cast<Ff>(cf);
  Ff fg = static_cast<Ff>(cg);
  Ff fh = static_cast<Ff>(ch);
  Ff fi = static_cast<Ff>(ci);

  (static_cast<F&>(f).*ff)();
  (static_cast<F&>(f).*fg)();
  (static_cast<F&>(f).*fh)();
  (static_cast<F&>(f).*fi)();
}

>como test.cpp
Comeau C/C++ 4.3.0.1 (Aug 21 2002 15:45:32) for MS_WINDOWS_x86
Copyright 1988-2002 Comeau Computing.  All rights reserved.
MODE:strict warnings C++

>aout

E::f, E
E::g, E
F::f, F
F::f, F
C::h, C
C::i, C
G::f, G
G::f, G
C::h, C
C::i, C
F::f, F
F::f, F
C::h, C
C::i, C

65536
131072
4294901760
4294901760
65536
131072
4294901760
4294901760

---------------------------
aout.exe - Application Error
---------------------------
The instruction at "0x00010005" referenced memory at "0x3a003a00". The memory could not be "written".

Click on OK to terminate the program
Click on CANCEL to debug the program
---------------------------
OK   Cancel   
---------------------------

>g++ test.cpp

>a
E::f, E
E::g, E
F::f, F
F::f, F
C::h, C
C::i, C
G::f, G
G::f, G
C::h, C
C::i, C
F::f, F
F::f, F
C::h, C
C::i, C

1
5
4222320
4222388
1
5
4222480
4222548

E::f, 

---------------------------
a.exe - Application Error
---------------------------
The instruction at "0x00406e68" referenced memory at "0x00636d77". The memory could not be "read".

Click on OK to terminate the program
Click on CANCEL to debug the program
---------------------------
OK   Cancel   
---------------------------

>cl /GX /vmg test.cpp
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 13.00.9466 for 80x86
Copyright (C) Microsoft Corporation 1984-2001. All rights reserved.

test.cpp
Microsoft (R) Incremental Linker Version 7.00.9466
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:test.exe
test.obj

>test
E::f, E
E::g, E
F::f, F
F::f, F
C::h, C
C::i, C
G::f, G
G::f, G
C::h, C
C::i, C
F::f, F
F::f, F
C::h, C
C::i, C

4203920
4203936
4198400
4198528
4203920
4203936
4198592
4198656

---------------------------
test.exe - Application Error
---------------------------
The instruction at "0x004010cf" referenced memory at "0x0053245f". The memory could not be "read".

Click on OK to terminate the program
Click on CANCEL to debug the program
---------------------------
OK   Cancel   
---------------------------

class C
{
   private:
     void Proc1(char *c);
     void Proc2(void);
}

void C::Proc1(char *c)
{
}

void C::Proc2(void)
{
  int addr;
  unsigned char *buffer;
  void (C::*ptr)(char *) = &C::Proc1;
  addr = (int)ptr; // ошибка type cast
  buffer = (unsigned char*)ptr; // ошибка type cast
}

DV>class C
DV>{
DV>   private:
DV>     void Proc1(char *c);
DV>     void Proc2(void);
DV>}

DV>void C::Proc1(char *c)
DV>{
DV>}

DV>void C::Proc2(void)
DV>{
DV>  int addr;
DV>  unsigned char *buffer;
DV>  void (C::*ptr)(char *) = &C::Proc1;
DV>  addr = (int)ptr; // ошибка type cast
DV>  buffer = (unsigned char*)ptr; // ошибка type cast
DV>}
DV>

union Test
{
  int addr;
  void (C::*ptr)(char *);
};

Test func;
func.ptr = &C::Proc1;
int iVal = func.addr;

union AddressConvertor
{
  struct addr
  {
    unsigned long address;
  }a;
  struct member
  {
    void (C::*ptr)(char*);
  }m;  
};

//<...>
  void (C::*ptr)(char*) = &C::Proc1;
  AddressConvertor convertor;
  convertor.m.ptr = ptr;
  unsigned long addr = convertor.a.address;

  // Нет никой гарантии, что адрес метода будет меньше либо равен sizeof(unsigned long)

DV>> компилятор делает флат-модель кода

extern "C" __declspec( naked ) void StartSecretFunc(void)
{
}

void C::SecretFunc(...)
{
   здесь что-то ....
}

extern "C" __declspec( naked ) void EndSecretFunc(void)
{
}