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.

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

B* b = &TestC;

B* b = static_cast<B*>((void*)&TestC)

class A {};
class B : public A {};
...
A* pa = new B(); // standard conversion - upcast
B* pb = static_cast<B*>(pa); // static_cast, perfectly legal, downcast

class A { public: void foo(); };
class B : public A { public: int bar(int); };

void (B::*p1)() = &A::foo; // standard conversion
int (A::*p2)(int) = static_cast<int (A::*)(int)>(&B::bar); // static_cast, perfectly legal

B* b = static_cast<B*>((void*)&TestC)

#pragma pointers_to_members(full_generality, multiple_inheritance)

К>class A { int m_a; public: A(): m_a(1) {} };

К>class B { int m_b; public: B(): m_b(2) {} };

К>class C: public A, public B
К>{
К>int m_c;
К>public:
К>  C(): m_c(3) {}
К>  void fnc(void) { assert(m_c == 3); };
К>};

К>class D { int m_d; public: D(): m_d(4) {} };

К>class E: public E, public C { int m_e; public: E(): m_e(5) {} };

class E: public D, public C ...

К>typedef void (B::*PFNB)(void);

К>E e;

К>B* pb = &e; // pb == { here=(void*)&e + sizeof(D) + sizeof(A); origin=&e }

Здесь: 'pb' указывает на базовый подобъект типа 'B' в составе объекта 'е'.

К>PFNB pfnb = (PFNB)(C::fnc);

PFNB pfnb = (PFNB)(&C::fnc);

[entry = &C::fnc, offset = 0]

[entry = &C::fnc, offset = -4]

(pb->*pfnb)(); // как вот здесь pb будет приведен именно к C, а не к E ?

(pb->>*pfnb)(); // как вот здесь pb будет приведен именно к C, а не к E ?
АТ>

(py->*px)();

If the result of .* or ->* is a function, then that result can be used only as the operand for the function call operator (). [Example:
(ptr_to_obj>*ptr_to_mfct)(10); calls the member function denoted by ptr_to_mfct for the object pointed to by ptr_to_obj. ] The
result of a .* expression is an lvalue only if its first operand is an lvalue and its second operand is a pointer to data member. The result of an ->* expression is an lvalue only if its second operand is a pointer to data member. If the second operand is the null pointer to member value (4.11), the behavior is undefined.

struct A{
    int a;
};
struct B{
    int b;
};

struct C:public A, public B
{
    int c;
};

int main()
{
    C TestC;    
    TestC.a=1; TestC.b=2; TestC.c=3; 
    B* pB=&TestC;
    int B::* pmb = static_cast<int B::*>(&C::c);
    cout << endl << pB->*pmb << endl; 
    return 0;
}

B* b = static_cast<B*>((void*)&TestC)

void copy(char* dst, char* src) { strcpy(dst, src); }

char sz1[] = "hello";
const char sz2[] = "world";
char sz3[100];

const char* lpsz1 = sz1;
const char* lpsz2 = sz2;

strcpy(sz3, const_cast<char*>(lpsz1)); // OK, данные неконстантны
strcpy(sz3, const_cast<char*>(lpsz2)); // OK, данные константны, но нет попытки модификации

const_cast<char*>(lpsz1)[3] = 'A'; // OK, данные неконстантны
const_cast<char*>(lpsz2)[3] = 'A'; // ОШИБКА!!! Попытка модификации константных данных

PI>If the result of .* or ->* is a function, then that result can be used only as the operand for the function call operator (). [Example:
(ptr_to_obj>>*ptr_to_mfct)(10); calls the member function denoted by ptr_to_mfct for the object pointed to by ptr_to_obj. ] The
PI>result of a .* expression is an lvalue only if its first operand is an lvalue and its second operand is a pointer to data member. The result of an ->* expression is an lvalue only if its second operand is a pointer to data member. If the second operand is the null pointer to member value (4.11), the behavior is undefined.
PI>

B* b = static_cast<B*>((void*)&TestC)

АТ>#pragma pointers_to_members(full_generality, multiple_inheritance)
АТ>

C/C++ Preprocessor Reference

pointers_to_membersSee Also
Pragma Directives
C++ Specific

#pragma pointers_to_members( pointer-declaration, [most-general-representation] )
Specifies whether a pointer to a class member can be declared before its associated class definition and is used to control the pointer size and the code required to interpret the pointer. You can place a pointers_to_members pragma in your source file as an alternative to using the /vmx compiler options or the inheritance keywords.

The pointer-declaration argument specifies whether you have declared a pointer to a member before or after the associated function definition. The pointer-declaration argument is one of the following two symbols:

Argument Comments
full_generality Generates safe, sometimes nonoptimal code. You use full_generality if any pointer to a member is declared before the associated class definition. This argument always uses the pointer representation specified by the most-general-representation argument. Equivalent to /vmg.
best_case Generates safe, optimal code using best-case representation for all pointers to members. Requires defining the class before declaring a pointer to a member of the class. The default is best_case.

The most-general-representation argument specifies the smallest pointer representation that the compiler can safely use to reference any pointer to a member of a class in a translation unit. The argument can be one of the following:

Argument Comments
single_inheritance The most general representation is single-inheritance, pointer to a member function. Causes an error if the inheritance model of a class definition for which a pointer to a member is declared is ever either multiple or virtual.
multiple_inheritance The most general representation is multiple-inheritance, pointer to a member function. Causes an error if the inheritance model of a class definition for which a pointer to a member is declared is virtual.
virtual_inheritance The most general representation is virtual-inheritance, pointer to a member function. Never causes an error. This is the default argument when #pragma pointers_to_members(full_generality) is used.

Example
// Specify single-inheritance only
#pragma pointers_to_members( full_generality, single_inheritance )
END C++ Specific

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

АТ>>#pragma pointers_to_members(full_generality, multiple_inheritance)
АТ>>

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

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

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

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