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

union
{
бомба,
картофелина
}

3.10/10
If a program attempts to access the stored value of an object through a glvalue of other than one of the
following types the behavior is undefined:
— the dynamic type of the object,
— a cv-qualified version of the dynamic type of the object,
— a type similar (as defined in 4.4) to the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to the dynamic type of the object,
— a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type
of the object,
— an aggregate or union type that includes one of the aforementioned types among its elements or nonstatic
data members (including, recursively, an element or non-static data member of a subaggregate
or contained union),
— a type that is a (possibly cv-qualified) base class type of the dynamic type of the object,
— a char or unsigned char type.

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

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;

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 ); // пишем в 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>

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

bool IsLittleEndianCPU()
{
   union {
      int a;
      char b[sizeof(int)];
  } u;
  u.a = 1;
  return u.b[0] != 0;
}

Y>>Кто — то ошибку заметил Rusted, улыбнулся и понял что хотели сказать...

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

9.5 Unions [class.union]
1 In a union, at most one of the non-static data members can be active at any time, that is, the value of at
most one of the non-static data members can be stored in a union at any time.

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

9.5 Unions [class.union]
1 In a union, at most one of the non-static data members can be active at any time, that is, the value of at
most one of the non-static data members can be stored in a union at any time.

union __u_t
    {
       static int  s_a; ///     static member
              int  a;   /// non-static member
              char c;   /// non-static member
    } obj;
   int __u_t::s_a = 10;
   obj.a= 100;
   obj.c='c';
 /// И для меня сие означает что нельзя рассчитывать на то что a=100;

#include <iostream>
using namespace std;
  
int main()
{

    union {
       float a;
       int b;
    } u;

    u.a = 100.0;
    cout << "u.b=" << u.b << endl;
    // эквивалентный метод доступа - через касты по сырому указателю
    cout << "casts=" << *reinterpret_cast<int*>(reinterpret_cast<void*>(&u.a)) << endl;
}

    union {
       float a;
       int b;
    } u;

    u.a = 100.0; // положили бомбу
    int v = u.b; // ... а достаем как картошку. Но по факту там бомба