#include <stdio.h>

void swap_words(uint32_t* arg)
{
    uint16_t* sp = (uint16_t*)arg;
    uint16_t  hi = sp[0];
    uint16_t  lo = sp[1];
    sp[1] = hi;
    sp[0] = lo;
} 

int main()
{
   uint32_t v1 = 0xFFFF0000u;
   uint32_t v2 = 0xFFFF0000u;

   swap_words(&v2);

   printf("%08X %08X\n", v1, v2);
   return 0;
}

gcc -O1 -Wall a.c
./a
FFFF0000 0000FFFF

gcc -O3 -Wall a.c
./a
FFFF0000 FFFF0000

static char mem_pool[max_size];
. . .
int* allocate_int()
{
   . . .
   return (int*)(&mem_pool[index_aligned_to_int]);  // To UB or not to UB? 
}

#include <stdio.h>

void swap_words(uint32_t* arg)
{
    uint16_t* sp = (uint16_t*)(void*)arg;
    uint16_t  hi = sp[0];
    uint16_t  lo = sp[1];
    
    sp[1] = hi;
    sp[0] = lo;
} 

int main()
{
   uint32_t v1 = 0xFFFF0000u;
   uint32_t v2 = 0xFFFF0000u;

   swap_words(&v2);

   printf("%08X %08X\n", v1, v2);
   return 0;
}

$ gcc -O3 -Wall a.c
a.c: In function `main':
a.c:20: warning: unsigned int format, uint32_t arg (arg 2)
a.c:20: warning: unsigned int format, uint32_t arg (arg 3)

$ ./a
FFFF0000 FFFF0000

void swap_words(uint32_t* arg)
{
    uint16_t* sp = (uint16_t*)(*(void**)&arg);
    uint16_t  hi = sp[0];
    uint16_t  lo = sp[1];
    
    sp[1] = hi;
    sp[0] = lo;
}

void swap_words(uint32_t* arg)
{
    uint16_t* sp = reinterpret_cast<uint16_t*>(arg);
    uint16_t  lo = sp[1];
    sp[1] = sp[0];
    sp[0] = lo;
}

I>void swap_words(uint32_t* arg)
I>{
I>    uint16_t* sp = reinterpret_cast<uint16_t*>(arg);
I>    uint16_t  lo = sp[1];
I>    sp[1] = sp[0];
I>    sp[0] = lo;
I>} 
I>

void swap_words(uint32_t* arg)
{
    union { uint16_t sp[2]; uint32_t v; } u;
    u.v = *arg;
    uint16_t  hi = u.sp[0];
    uint16_t  lo = u.sp[1];

    u.sp[1] = hi;
    u.sp[0] = lo;
    *arg = u.v;
}

void swap_words(uint32_t* arg)
{
    uint16_t  hi = (uint16_t) ((*arg & 0xFFFF0000u)>>16);
    uint16_t  lo = (uint16_t) ((*arg & 0x0000FFFFu));

    *arg = hi | (lo << 16);
}

void swap_words(uint32_t* arg)
{
    union { uint32_t v; uint16_t sp[2]; } u = {*arg};
    std::swap(u.sp[0], u.sp[1]);
    *arg = u.v;
}

#include <stdio.h>

typedef unsigned __int16 uint16_t;
typedef unsigned __int32 uint32_t;

void swap_words1(uint32_t* arg)
{
    uint16_t* sp = (uint16_t*)arg;
    uint16_t  hi = sp[0];
    uint16_t  lo = sp[1];
    sp[1] = hi;
    sp[0] = lo;
} 

void swap_words2(uint32_t* arg)
{
    uint16_t  hi = (uint16_t) ((*arg & 0xFFFF0000u)>>16);
    uint16_t  lo = (uint16_t) ((*arg & 0x0000FFFFu));

    *arg = hi | (lo << 16);
} 

void swap_words3(uint32_t* arg)
{
    union { uint16_t sp[2]; uint32_t v; } u;
    u.v = *arg;
    uint16_t  hi = u.sp[0];
    uint16_t  lo = u.sp[1];

    u.sp[1] = hi;
    u.sp[0] = lo;
    *arg = u.v;
}

int main()
{
   uint32_t v = 0xFFFF0000u;
   int i = 0;

   for ( i = 0; i != 10000000; ++i )
       swap_words1(&v);

   for ( i = 0; i != 10000000; ++i )
       swap_words2(&v);

   for ( i = 0; i != 10000000; ++i )
       swap_words3(&v);


   printf("%08X\n", v);
   return 0;
}

Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls ns/call ns/call name
54.17 0.26 0.26 10000000 26.00 26.00 swap_words3
25.00 0.38 0.12 10000000 12.00 12.00 swap_words1
10.42 0.43 0.05 10000000 5.00 5.00 swap_words2
10.42 0.48 0.05 main

Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls ns/call ns/call name
41.67 0.05 0.05 10000000 5.00 5.00 swap_words2
25.00 0.08 0.03 10000000 3.00 3.00 swap_words3
16.67 0.10 0.02 10000000 2.00 2.00 swap_words1
16.67 0.12 0.02 main

Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls ns/call ns/call name
46.15 0.12 0.12 main
19.23 0.17 0.05 10000000 5.00 5.00 swap_words2
19.23 0.22 0.05 10000000 5.00 5.00 swap_words3
15.38 0.26 0.04 10000000 4.00 4.00 swap_words1

void swap_words3(uint32_t* arg)
{
    union { unsigned short sp[2]; unsigned int v; } u;

    unsigned short  hi;
    unsigned short  lo;

    u.v = *arg;
    hi = u.sp[0];
    lo = u.sp[1];

    u.sp[1] = hi;
    u.sp[0] = lo;
    *arg = u.v;
}

;;;             swap_words1(&v);
  00036 0f b7 54 24 08   movzx edx, WORD PTR [esp+8]            ;.\test.cpp:44.4
  0003b 0f b7 4c 24 0a   movzx ecx, WORD PTR [esp+10]           ;.\test.cpp:44.4
  00040 66 89 54 24 0a   mov WORD PTR [esp+10], dx              ;.\test.cpp:44.4
  00045 66 89 4c 24 08   mov WORD PTR [esp+8], cx               ;.\test.cpp:44.4

;;;             swap_words2(&v);
  0006c 8b 54 24 08      mov edx, DWORD PTR [esp+8]             ;.\test.cpp:53.16
$LN33:
  00070 8b da            mov ebx, edx                           ;.\test.cpp:53.4
  00072 81 e3 00 00 ff 
        ff               and ebx, -65536                        ;.\test.cpp:53.4
  00078 c1 eb 10         shr ebx, 16                            ;.\test.cpp:53.4
  0007b c1 e2 10         shl edx, 16                            ;.\test.cpp:53.4
  0007e 0b da            or ebx, edx                            ;.\test.cpp:53.4
$LN35:
  00080 89 5c 24 08      mov DWORD PTR [esp+8], ebx             ;.\test.cpp:53.16

;;;             swap_words3(&v);
  000a6 c1 44 24 08 10   rol DWORD PTR [esp+8], 16              ;.\test.cpp:62.4

An object shall have its stored value accessed only by an lvalue that has one of the following types: 36
— the declared type of the object,
— a qualified version of the declared type of the object,
— a type that is the signed or unsigned type corresponding to the declared type of the object,
— a type that is the signed or unsigned type corresponding to a qualified version of the declared type of the object,
— an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or
— a character type.

---

36 The intent of this list is to specify those circumstances in which an object may or may not be aliased.

E>Насколько я понимаю, в C++ стандарте такого ограничения нет. Тем не менее, GCC 3.4.4 для C++ генерирует такой же проблемный код, как и для C

5.17/8 If the value being stored in an object is accessed from another object that overlaps in any way the storage of the first object, then the overlap shall be exact and the two objects shall have the same type, otherwise the behavior is undefined.

MS>    uint16_t  hi = sp[0];

MS>static char mem_pool[max_size];
MS>. . .
MS>int* allocate_int()
MS>{
MS>   . . .
MS>   return (int*)(&mem_pool[index_aligned_to_int]);  // To UB or not to UB? 
MS>}

struct header;

header* ptr;

assert((uint64)ptr == (uint64)(uint32)ptr);

.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %dx, 2(%eax)
    movw    %cx, (%eax)
    popl    %ebp
    ret
    .size

    .p2align 4,,15
.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %cx, (%eax)
    movw    %dx, 2(%eax)
    popl    %ebp
    ret

    .file    "a.c"
    .text
.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %dx, 2(%eax)
    movw    %cx, (%eax)
    popl    %ebp
    ret
    .size    swap_words, .-swap_words
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string    "%08X %08X\n"
    .text
.globl main
    .type    main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl    -4(%ecx)
    pushl    %ebp
    movl    %esp, %ebp
    pushl    %ecx
    subl    $36, %esp
    movl    $-65536, -8(%ebp)
    leal    -8(%ebp), %eax
    movl    %eax, (%esp)
    call    swap_words
    movl    -8(%ebp), %eax
    movl    %eax, 8(%esp)
    movl    $-65536, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    movl    $0, %eax
    addl    $36, %esp
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size    main, .-main
    .ident    "GCC: (GNU) 4.1.2 20061115 (prerelease) (SUSE Linux)"
    .section    .note.GNU-stack,"",@progbits

    .file    "a.c"
    .text
    .p2align 4,,15
.globl swap_words
    .type    swap_words, @function
swap_words:
    pushl    %ebp
    movl    %esp, %ebp
    movl    8(%ebp), %eax
    movzwl    2(%eax), %ecx
    movzwl    (%eax), %edx
    movw    %cx, (%eax)
    movw    %dx, 2(%eax)
    popl    %ebp
    ret
    .size    swap_words, .-swap_words
    .section    .rodata.str1.1,"aMS",@progbits,1
.LC0:
    .string    "%08X %08X\n"
    .text
    .p2align 4,,15
.globl main
    .type    main, @function
main:
    leal    4(%esp), %ecx
    andl    $-16, %esp
    pushl    -4(%ecx)
    pushl    %ebp
    movl    %esp, %ebp
    pushl    %ecx
    subl    $36, %esp
    movzwl    -6(%ebp), %edx
    movzwl    -8(%ebp), %eax
    movl    $-65536, -8(%ebp)
    movw    %dx, -8(%ebp)
    movw    %ax, -6(%ebp)
    movl    $-65536, 8(%esp)
    movl    $-65536, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf
    addl    $36, %esp
    xorl    %eax, %eax
    popl    %ecx
    popl    %ebp
    leal    -4(%ecx), %esp
    ret
    .size    main, .-main
    .ident    "GCC: (GNU) 4.1.2 20061115 (prerelease) (SUSE Linux)"
    .section    .note.GNU-stack,"",@progbits

/* main.cpp */ 

#include <stdio.h>

// assume unsigned is 32 bit

unsigned SwapHalf(unsigned val)
 {
  return (val<<16)|(val>>16);
 }
 
void SwapHalf(unsigned *var)
 {
  *var=SwapHalf(*var);
 }
 
/* main() */   

int main()
 {
  unsigned val=0xABBABEDA;
  
  SwapHalf(&val);
  
  printf("%.8X\n",val);
 
  return 0;
 }

?SwapHalf@@YAXPAI@Z PROC                ; SwapHalf, COMDAT

; 14   :   *var=SwapHalf(*var);

    mov    eax, DWORD PTR _var$[esp-4]
    mov    ecx, DWORD PTR [eax]
    rol    ecx, 16                    ; 00000010H
    mov    DWORD PTR [eax], ecx

; 15   :  }

    ret    0
?SwapHalf@@YAXPAI@Z ENDP                ; SwapHalf

B>void swap_words(uint32_t* arg)
B>{
B>    union { uint32_t v; uint16_t sp[2]; } u = {*arg};
B>    std::swap(u.sp[0], u.sp[1]);
B>    *arg = u.v;
B>}
B>

Pay special attention to code like this:

union a_union {
int i;
double d;
};

int f() {
a_union t;
t.d = 3.0;
return t.i;
}

The practice of reading from a different union member than the one
most recently written to (called “type-punning”) is common. Even with
‘-fstrict-aliasing’, type-punning is allowed, provided the memory is
accessed through the union type. So, the code above will work as expected.
However, this code might not:

int f() {
a_union t;
int* ip;
t.d = 3.0;
ip = &t.i;
return *ip;
}

If a program attempts to access the stored value of an object through an lvalue of other than one of the following
types the behavior is undefined (48):
— the dynamic type of the object,
— a cv-qualified version of 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 members (including,
recursively, a 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.
__________________
(48) The intent of this list is to specify those circumstances in which an object may or may not be aliased

static bool is_not_valid_check_sum(const uint8_t* rec, size_t rec_len)
{
    if (rec_len < 3)
        return true;

    const uint8_t* sz_end = rec + rec_len - sizeof(uint16_t);
    uint16_t sum = 0;

    for (; rec < sz_end; ++rec)
        sum += *rec;

    return sum != *reinterpret_cast<const uint16_t *>(sz_end);
}

А>    return sum != *reinterpret_cast<const uint16_t *>(sz_end);
А>}
А>

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>


void hex_print(uint8_t *buf, size_t size);

int main()
{

    

    uint8_t buf1[16], buf2[16], buf3[16];
    uint32_t val;
    uint16_t val16;
    
    memset(buf1, 0, sizeof(buf1));
    memset(buf2, 0, sizeof(buf2));
    memset(buf3, 0, sizeof(buf3));

    val = 0x11223344;
    val16 = 0x7799;
        
    *((uint32_t *)&buf1[0]) = val;
    *((uint32_t *)&buf2[2]) = val;
    *((uint32_t *)&buf3[1]) = val;
    
    *((uint16_t *)&buf1[8]) = val16;
    *((uint16_t *)&buf2[10]) = val16;
    *((uint16_t *)&buf3[9]) = val16;
    
    
    printf("buf1[0] = <%#X>, buf2[2] = <%#X>, buf3[1] = <%#X>\n",
        *((uint32_t *)&buf1[0]),
        *((uint32_t *)&buf2[2]),
        *((uint32_t *)&buf3[1])
    );
    
    printf("buf1[8] = <%#X>, buf2[10] = <%#X>, buf3[9] = <%#X>\n",
        *((uint16_t *)&buf1[8]),
        *((uint16_t *)&buf2[10]),
        *((uint16_t *)&buf3[9])
    );

    for(int i = 0; i < 16; i++){
        printf("%02i|", i);
    }
    printf("\n");

    hex_print(buf1, 16);
    hex_print(buf2, 16);
    hex_print(buf3, 16);
    
    return 0;
}

void hex_print(uint8_t *buf, size_t size)
{
    while(size-- > 0){
        printf("%02X ", *(buf++));
    }
    printf("\n");
}

А>>    return sum != *reinterpret_cast<const uint16_t *>(sz_end);
А>>}
А>>

uint16_t valid_sum;
memcpy(&valid_sum, sz_end, sizeof(valid_sum));
return sum != valid_sum;

А>uint16_t valid_sum;
А>memcpy(&valid_sum, sz_end, sizeof(valid_sum));
А>return sum != valid_sum;
А>

#include <stdint.h>

#define SET_BUF8_VAL16(BUF_UINT8T__, VAL_UINT16T__) \
    { \
        (BUF_UINT8T__)[0] = ((uint8_t *)&(VAL_UINT16T__))[0]; \
        (BUF_UINT8T__)[1] = ((uint8_t *)&(VAL_UINT16T__))[1]; \
    }

#define SET_VAL16_BUF8(VAL_UINT16T__, BUF_UINT8T__) \
    { \
        ((uint8_t *)&(VAL_UINT16T__))[0] = (BUF_UINT8T__)[0]; \
        ((uint8_t *)&(VAL_UINT16T__))[1] = (BUF_UINT8T__)[1]; \
    }
#define SET_BUF8_VAL32(BUF_UINT8T__, VAL_UINT32T__) \
    { \
        (BUF_UINT8T__)[0] = ((uint8_t *)&(VAL_UINT32T__))[0]; \
        (BUF_UINT8T__)[1] = ((uint8_t *)&(VAL_UINT32T__))[1]; \
        (BUF_UINT8T__)[2] = ((uint8_t *)&(VAL_UINT32T__))[2]; \
        (BUF_UINT8T__)[3] = ((uint8_t *)&(VAL_UINT32T__))[3]; \
    }

#define SET_VAL32_BUF8(VAL_UINT32T__, BUF_UINT8T__) \
    { \
        ((uint8_t *)&(VAL_UINT32T__))[0] = (BUF_UINT8T__)[0]; \
        ((uint8_t *)&(VAL_UINT32T__))[1] = (BUF_UINT8T__)[1]; \
        ((uint8_t *)&(VAL_UINT32T__))[2] = (BUF_UINT8T__)[2]; \
        ((uint8_t *)&(VAL_UINT32T__))[3] = (BUF_UINT8T__)[3]; \
    }

uint16_t valid_sum = sz_end | (sz_end << 8);
return sum != valid_sum;

#include <vector>
typedef std::vector<uint8_t> BufferType;
typedef uint32_t CrcType; // обязательно беззнаковый, иначе получим вопросы знакорасширения типов.

CrcType Crc8Mod2CheckSum::calc(BufferType& rBuf, bool crc_included_fl)
{
    CrcType cs = 0xFF;

    if (crc_included_fl){
        BufferType::iterator it_end = rBuf.end() - getCrcLen();
    }
    
    for (BufferType::iterator it = rBuf.begin(); it != it_end; ++it){
        cs ^= *it;
    }

    cs &= 0xFF;

    return cs;
}

uint32_t GetLong(BufferType::iterator& it)
{
    uint32_t retval = 0;

    ///\bug проверить валидность итератора
    for (int shift = 24; shift >= 0; shift -= 8){
        retval |= *it << shift;
        ++it;
    }

    return __le32_to_cpu(retval);
}

struct {
  unsigned some_number;
  Foo foo;
} data;

struct Foo {
  unsigned SomeData;
};

struct DataBuf {
  unsigned char Byte;
  Foo foo;
};

R>Это обе засады в С++. Но тем не менее — очень разные вещи

return (int*)(&mem_pool[index_aligned_to_int]);  // To UB or not to UB?

int a=...;
unsigned *b=(unsigned *)(void *)&a;

printf("%u\n",*b);

int a=...;
short *b=(short *)(void *)&a;

printf("%u\n",*b);

int a;
char *c=(char *)(void *)&a;

c[0]=...;
c[1]=...;
c[2]=...;
c[3]=...;

printf("%d\n",a);

/* main.cpp */ 

#include <stdio.h>

typedef unsigned long long uint64;

/* CPUClock() */ 

__declspec(naked) uint64 CPUClock()
 {
  __asm {
           rdtsc
           ret
        }
 }
 
unsigned SwapHalf(unsigned val)
 {
  return (val<<16)|(val>>16);
 }
 
/* test1()  */  

void test1()
 {
  static volatile unsigned val=0x11112222;
 
  val=SwapHalf(val);
 }
 
/* test2() */  

void test2()
 {
  static volatile unsigned short val[2]={0x1111,0x2222};
  
  unsigned short temp=val[1];
  
  val[1]=val[0];
  val[0]=temp;
 }
 
/* Run<func>() */ 

template <void (*func)()> 
void Run(const char *name)
 {
  uint64 result=uint64(-1);
 
  for(unsigned n=1000; n ;n--)
    {
     uint64 start=CPUClock();
     
     for(unsigned k=1000; k ;k--) func();
     
     uint64 stop=CPUClock();
     
     stop-=start;
     
     if( stop<result ) result=stop;
    }
    
  printf("%s result = %llu\n",name,result);  
 }
 
/* Run2() */  

void Run2()
 {
  uint64 result=uint64(-1);
 
  for(unsigned n=1000; n ;n--)
    {
     uint64 start=CPUClock();
     
     static volatile unsigned short val[2]={0x1111,0x2222};
     
     __asm {
                mov ecx, 1000
            L:    
                sub ecx,1
                
                mov dx, WORD PTR val[0]
                mov ax, WORD PTR val[2]
                mov WORD PTR val[2], dx
                mov WORD PTR val[0], ax
                
                jne L
           }
     
     uint64 stop=CPUClock();
     
     stop-=start;
     
     if( stop<result ) result=stop;
    }
    
  printf("asm swap result = %llu\n",result);  
 }
 
/* main() */   

int main()
 {
  Run<&test1>("rot16");
  Run<&test1>("rot16");
  Run<&test2>("swap");
  Run<&test2>("swap");
  
  Run2();
  Run2();
 
  return 0;
 }

    call    ?CPUClock@@YA_KXZ            ; CPUClock
    mov    esi, eax
    mov    edi, edx

; 53   :      
; 54   :      for(unsigned k=1000; k ;k--) func();

    mov    ecx, 1000                ; 000003e8H
    npad    15
$LL4@Run@2:
    sub    ecx, 1
    mov    ax, WORD PTR ?val@?1??test2@@YAXXZ@4RCGC+2
    mov    dx, WORD PTR ?val@?1??test2@@YAXXZ@4RCGC
    movzx    eax, ax
    mov    WORD PTR ?val@?1??test2@@YAXXZ@4RCGC+2, dx
    mov    WORD PTR ?val@?1??test2@@YAXXZ@4RCGC, ax
    jne    SHORT $LL4@Run@2

; 55   :      
; 56   :      uint64 stop=CPUClock();

    call    ?CPUClock@@YA_KXZ            ; CPUClock

    call    ?CPUClock@@YA_KXZ            ; CPUClock
    mov    esi, eax
    mov    edi, edx

; 53   :      
; 54   :      for(unsigned k=1000; k ;k--) func();

    mov    ecx, 1000                ; 000003e8H
$LL4@Run:
    mov    eax, DWORD PTR ?val@?1??test1@@YAXXZ@4IC
    rol    eax, 16                    ; 00000010H
    sub    ecx, 1
    mov    DWORD PTR ?val@?1??test1@@YAXXZ@4IC, eax
    jne    SHORT $LL4@Run

; 55   :      
; 56   :      uint64 stop=CPUClock();

    call    ?CPUClock@@YA_KXZ            ; CPUClock

    call    ?CPUClock@@YA_KXZ            ; CPUClock
    mov    esi, eax
    mov    edi, edx

; 75   :      
; 76   :      static volatile unsigned short val[2]={0x1111,0x2222};
; 77   :      
; 78   :      __asm {
; 79   :                 mov ecx, 1000

    mov    ecx, 1000                ; 000003e8H
$L$1444:

; 80   :             L:    
; 81   :                 sub ecx,1

    sub    ecx, 1

; 82   :                 
; 83   :                 mov dx, WORD PTR val[0]

    mov    dx, WORD PTR ?val@?3??Run2@@YAXXZ@4RCGC

; 84   :                 mov ax, WORD PTR val[2]

    mov    ax, WORD PTR ?val@?3??Run2@@YAXXZ@4RCGC+2

; 85   :                 mov WORD PTR val[2], dx

    mov    WORD PTR ?val@?3??Run2@@YAXXZ@4RCGC+2, dx

; 86   :                 mov WORD PTR val[0], ax

    mov    WORD PTR ?val@?3??Run2@@YAXXZ@4RCGC, ax

; 87   :                 
; 88   :                 jne L

    jne    SHORT $L$1444

; 89   :            }
; 90   :      
; 91   :      uint64 stop=CPUClock();

    call    ?CPUClock@@YA_KXZ            ; CPUClock

rot16 result = 6132
rot16 result = 6132
swap result = 6264
swap result = 6276
asm swap result = 6036
asm swap result = 6048
Для продолжения нажмите любую клавишу . . .

#include <stdio.h>
#include <stdint.h>


#pragma pack(push, 2)
union un32
{
    uint32_t u32;
    struct
    {
        uint16_t u16_low;
        uint16_t u16_high;
    } u16x2;
};
#pragma pack(pop)

void swap_words(uint32_t* arg)
{
    union un32 *pu = (union un32*)arg;
    uint16_t  hi = pu->u16x2.u16_high;
    uint16_t  lo = pu->u16x2.u16_low;
    pu->u16x2.u16_low  = hi;
    pu->u16x2.u16_high = lo;
}

int main()
{
   uint32_t v1 = 0xFFFF0000u;
   uint32_t v2 = 0xFFFF0000u;

   swap_words(&v2);

   printf("%08X %08X\n", v1, v2);
   return 0;
}

typedef struct
{
   int type;
} BaseObject;

typedef struct
{
   int type;

   int foo;
} DerivedObject;

enum
{
  OBJTYPE_UNDEFINED,
  OBJTYPE_DERIVED,
  /* ... */
};

...

void incFoo( BaseObject * d )
{
   if( d->type == OBJTYPE_DERIVED )
   {
       DerivedObject * alias = (DerivedObject *)d;
       ++ alias->foo;
   }
}

...
/* somewhere in code */
BaseObject b;

b.type = OBJTYPE_UNDEFINED;
incFoo( &b ); /* crash? */

/* ... */
DerivedObject d;

d.type = OBJTYPE_DERIVED;
d.foo = 0;
incFoo( (BaseObject *)&d ); /* crash? */

§6.2.6.1/5 Certain object representations need not represent a value of the object type. If the stored
value of an object has such a representation and is read by an lvalue expression that does
not have character type, the behavior is undefined. If such a representation is produced
by a side effect that modifies all or any part of the object by an lvalue expression that
does not have character type, the behavior is undefined.41) Such a representation is called
a trap representation.

7 An object shall have its stored value accessed only by an lvalue expression that has one of the following types:
— a type compatible with the effective type of the object,
— a qualified version of a type compatible with the effective type of the object,
— a type that is the signed or unsigned type corresponding to the effective type of the object,
— a type that is the signed or unsigned type corresponding to a qualified version of the effective type of the object,
— an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or
— a character type.

volatile double x=1.0;
char* p=(char*)&x;