class IObject
{ 
public :
           IObject ( void ) {};
virtual ~IObject ( void ) {};
};

class TestCall :
    public IObject
    
{

private :
    int     m_i;
    float   m_f;

public :

             TestCall ( void ) { m_i = 999; m_f = 1.7777f; }
    virtual ~TestCall ( void ) {}

public :

    int __stdcall test_call_method ( int i, float f )
    {
        this->m_i = i;
        this->m_f = f;

        return m_i;
    }

};

///
int main ( int, char *[] )
{
    TestCall          test_call;
    IObject    *test_call_obj = &test_call;
    void             *v_func        = NULL;

    union
    {
        int ( __stdcall TestCall::*cFunc ) ( int, float );
        void *voidFunc;
    }; cFunc = ( &TestCall::test_call_method );
    v_func = voidFunc;


    for ( int i = 0; i < 10000; i++ )
    {
        union 
        { 
            int ( __stdcall IObject::*Method )( int, float );  
            void  *void_func; 
        }; void_func = v_func;
        int ret = ( ( test_call_obj )->* ( Method ) ) ( i, 7.999f );
        std::cout << " call method \"test_call_method\" ret = "  << ret << std::endl;
    }

    return 0;
}

        union 
        { 
            int ( __stdcall IObject::*Method )( int, float );  
            void  *void_func; 
        };

        union 
        { 
            int ( __stdcall IObject::*Method )( int, float );  
            void  *void_func; 
        };

Х>        union 
Х>        { 
Х>            int ( __stdcall IObject::*Method )( int, float );  
Х>            void  *void_func; 
Х>        };
Х>

    char *test = "test\0";
    union
    {
        char **buf; /// это int ( __stdcall IObject::*Method )( int, float ); 
        void *addr; /// void  *void_func; 
    }; 
    buf = &test;

cFunc = &TestCall::test_call_method; // тут ты записал в cFunc 
v_func = voidFunc;                   // а тут ты читаешь из voidFunc

...
cFunc = ( &TestCall::test_call_method ); // пишем в union::cFunc указатель на функцию-член - ок, она большая.
v_func = voidFunc; // а вот здесь мы копируем только часть этого указателя в указатель на воид.
...
for ( int i = 0; i < 10000; i++ )
{
...
 void_func = v_func; // копируем неполный указатель в другой union...
 int ret = ( ( test_call_obj )->* ( Method ) ) ( i, 7.999f ); // ... и пытаемся использовать указатель на функцию-член.
 // В этом месте часть указателя в поле Method будет содержать неинициализированные данные.
...
}

Y>    char *test = "test\0";
Y>    union
Y>    {
Y>        char **buf; /// это НЕ МОЖЕТ быть int ( __stdcall IObject::*Method )( int, float ); 
Y>        void *addr; /// void  *void_func; 
Y>    }; 
Y>    buf = &test;
Y>

Y>void f() {
Y>union { int a; const char* p; };
Y>a = 1;
Y>p = "Jennifer";
Y>}

J>И где ты в этом примере видишь запеись в один член, а чтение из другого?

void f() 
{
    union { int a; const char* p; };
    a = 1;
    p = "Jennifer\0";
    
    char buf[100];
    memcpy( &a, p, strlen("Jennifer\0") )

   *buf = *p;
}

void f() 
{
    union 
    { 
        int a; 
        const char* p; 
    };
    a = 1;
    p = "Jennifer";
    /// то a уже не можем быть равна 1

    char buf[100];
    memcpy( &a, p, strlen("Jennifer\0") )

    ///*buf == *p;
}

Y>>void f() 
Y>>{
Y>>    union 
Y>>    { 
Y>>        int a; 
Y>>        const char* p; 
Y>>    };
Y>>    a = 1;
Y>>    p = "Jennifer";
Y>>    /// то a уже не можем быть равна 1
Y>>}
Y>>

union
{
    int a;
    std::string str;
    MyClass     m_class;
}
      <- тут вызывается конструктор std::string перед str.append( "test" );
str.append( "test" );

   char *str = NULL;
   memcpy( str, "test\0", strlen( "test\0") );

union
{
    int a;
    std::string str;
    MyClass     m_class;
}
      <- тут вызывается конструктор std::string перед str.append( "test" );
str.append( "test" );

      <- тут вызывается деструктор std::string
a = 1;

struct MyClass
{
     char *buf;

     MyClass() { buf = new char[ 1000 ]; }
    ~MyClass() { delete [] buf;          }

void test( char *str, int len ) { memcpy( buf, str, len ); }
};

union
{
    int a;
    std::string str;
    MyClass     m_class;
}
       <- тут вызывается конструктор MyClass 
m_class.test( "test\0", strlen("test\0") );
       <- тут вызывается деструктор MyClass 
a = 1;