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>