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

class C:public A,public B
{
public:
    void Test(){
        cout<<"a:"<<a<<"  b:"<<b;
    }
};

int main(int argc, char* argv[])
{
    typedef void (B::*pClassB_Func)();
    C TestC;    //Итак, имеем класс C - наследник A+B
    TestC.a=1;  //Это поле от A
    TestC.b=2;  //Это поле от B
    pClassB_Func pf=static_cast<pClassB_Func>(C::Test); //Указатель на функцию  void C::Test()

    //Вот это, казалось бы безобидный вариант. Но неправильный
    B * pB=&TestC;
    (pB->*pf)();
    //Вот это очень ужасный на вид, но РАБОЧИЙ вариант
    pB=static_cast<B*>((void*)&TestC);
    (pB->*pf)();

    return 0;
}

RF>> pClassB_Func pf=static_cast<pClassB_Func>(C::Test); //Указатель на функцию  void C::Test()

pClassB_Func pf=static_cast<pClassB_Func>(&C::Test);

RF>>    //Вот это, казалось бы безобидный вариант. Но неправильный
RF>>    B * pB=&TestC;
RF>>    (pB->*pf)();

RF>>    //Вот это очень ужасный на вид, но РАБОЧИЙ вариант
RF>>    pB=static_cast<B*>((void*)&TestC);
RF>>    (pB->*pf)();

RF>>> pClassB_Func pf=static_cast<pClassB_Func>(C::Test); //Указатель на функцию  void C::Test()

АТ>pClassB_Func pf=static_cast<pClassB_Func>(&C::Test);

RF>>>    //Вот это, казалось бы безобидный вариант. Но неправильный
RF>>>    B * pB=&TestC;
RF>>>    (pB->*pf)();
АТ>

RF>>>    //Вот это очень ужасный на вид, но РАБОЧИЙ вариант
RF>>>    pB=static_cast<B*>((void*)&TestC);
RF>>>    (pB->*pf)();
АТ>

typedef void (B::*pClassB_Func)();
  // вызов функции класса B (про C нигде не сказано)

pClassB_Func pf=static_cast<pClassB_Func>(C::Test);
  // взяли адрес некой функции и громко крикнули, что это - член класса B

B * pB=&TestC;
  // привели тип (со смещением, разумеется)

(pB->*pf)();
  // где здесь сказано про С?!

void TestC_B_Thunk(B* ThisB)
{
  C* ThisC = (C*)((void*)ThisB + C::offset_of_B);
  return ThisC->TestC();
}

asm
{
@@TestC_B_Thunk:
  add [sp+4], C::offset_of_B
  jmp C::TestC
}

К>>void TestC_B_Thunk(B* ThisB)
К>>{
К>>  C* ThisC = (C*)((void*)ThisB + C::offset_of_B);
К>>  return ThisC->TestC();
К>>}

TITLE: Casting pointer to member functions

PROBLEM: Randy Chapman <chapman@u.washington.edu>

I am trying to get some old (1991) code working, and it appears that
current versions of C++ break it :(

The basic juist of the problem is that I have a pointer type that is
a pointer to a member function of class A.  I want to assign to
that variable (a member of class A, via a SetCallback()),
a member function pointer of class B (same paramters, etc).
Compiler (g++) gives me a casting error:

> cat foo.C

class A;

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

class A {
  Aptr foo;
public:
        void SetFoo(char *event, Aptr fooP) { foo = fooP; }
};

class B: protected A {
        void junk();
        B() { SetFoo("SomeOddThing",junk); }
};

> gcc foo.C
foo.C: In method `B::B()':
foo.C:14: type `B' is not a base type for type `A'
foo.C:14:    in pointer to member function conversion


RESPONSE: clamage@Eng.Sun.COM (Steve Clamage), 7 Jun 95

First, you have a syntax error. The call to SetFoo should look like
        B() { SetFoo("SomeOddThing", &B::junk); }

Second, casting among pointer-to-member-function works backwards from
ordinary casts. Normally, you can cast a derived to a base, since a
derived is a base (loosely speaking).

But with pointer-to-member-function, the reverse is the case. A
pointer to a Derived member function cannot be used where a pointer
to Base member function is expected. The Base::*ptr will be used
in conjunction with Base object, and a member of class Derived
will expect to operate on a Derived object. In general, this will
lead to disaster. (E.g., the Derived member function stores into data
which is part of a Derived object, but isn't part of a Base object.)
That's why it isn't allowed.

TITLE: Casting pointer to member functions

PROBLEM: Randy Chapman <chapman@u.washington.edu>

I am trying to get some old (1991) code working, and it appears that
current versions of C++ break it :(

The basic juist of the problem is that I have a pointer type that is
a pointer to a member function of class A.  I want to assign to
that variable (a member of class A, via a SetCallback()),
a member function pointer of class B (same paramters, etc).
Compiler (g++) gives me a casting error:

> cat foo.C

class A;

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

class A {
  Aptr foo;
public:
        void SetFoo(char *event, Aptr fooP) { foo = fooP; }
};

class B: protected A {
        void junk();
        B() { SetFoo("SomeOddThing",junk); }
};

> gcc foo.C
foo.C: In method `B::B()':
foo.C:14: type `B' is not a base type for type `A'
foo.C:14:    in pointer to member function conversion


RESPONSE: clamage@Eng.Sun.COM (Steve Clamage), 7 Jun 95

First, you have a syntax error. The call to SetFoo should look like
        B() { SetFoo("SomeOddThing", &B::junk); }

Second, casting among pointer-to-member-function works backwards from
ordinary casts. Normally, you can cast a derived to a base, since a
derived is a base (loosely speaking).

But with pointer-to-member-function, the reverse is the case. A
pointer to a Derived member function cannot be used where a pointer
to Base member function is expected. The Base::*ptr will be used
in conjunction with Base object, and a member of class Derived
will expect to operate on a Derived object. In general, this will
lead to disaster. (E.g., the Derived member function stores into data
which is part of a Derived object, but isn't part of a Base object.)
That's why it isn't allowed.

А>Выдержки из "C++ Tip-of-the-Day":
А>[code]
А>RESPONSE: clamage@Eng.Sun.COM (Steve Clamage), 7 Jun 95

А>First, you have a syntax error. The call to SetFoo should look like
А>        B() { SetFoo("SomeOddThing", &B::junk); }

А>Second, casting among pointer-to-member-function works backwards from
А>ordinary casts. Normally, you can cast a derived to a base, since a
А>derived is a base (loosely speaking).
А>But with pointer-to-member-function, the reverse is the case. A
А>pointer to a Derived member function cannot be used where a pointer
А>to Base member function is expected.

A>The Base::*ptr will be used
А>in conjunction with Base object, and a member of class Derived
А>will expect to operate on a Derived object.

A>In general, this will
А>lead to disaster.

A>(E.g., the Derived member function stores into data
А>which is part of a Derived object, but isn't part of a Base object.)
А>That's why it isn't allowed.

B() { SetFoo("SomeOddThing", static_cast<Aptr>(&B::junk)); }

In general, this will lead to disaster.

В общем случае, это приведет к беде.