Strict aliasing

/* Kieu nao duoc phep truy cap mot doi tuong kieu T: */

T                          /* dung kieu do */
const T, volatile T        /* T co them tu khoa */
signed T, unsigned T       /* ban co dau va khong dau tuong ung */
struct hoac union chua T   /* ke ca long nhieu tang */
char, signed char          /* NGOAI LE: luon hop le */
unsigned char              /* NGOAI LE: luon hop le */

/* MOI kieu khac deu vi pham. */

#include <stdio.h>

int lam_roi(int *pi, float *pf) {
    *pi = 1;
    *pf = 2.0f;

    return *pi;
}

int main(void) {
    int o = 0;

    int kq = lam_roi(&o, (float *)&o);     /* hai con tro, mot o nho */

    printf("ham tra ve : %d\n", kq);
    printf("gia tri that: %d\n", o);

    return 0;
}

__attribute__((noinline)) unsigned doc_bit_sai(float f) {
    return *(unsigned *)&f;                  /* VI PHAM */
}

__attribute__((noinline)) unsigned doc_bit_memcpy(float f) {
    unsigned u;
    memcpy(&u, &f, sizeof u);                /* DUNG */
    return u;
}

__attribute__((noinline)) unsigned doc_bit_union(float f) {
    union { float f; unsigned u; } t = { .f = f };
    return t.u;                              /* DUNG trong C */
}

/* Doc mot goi tin hoac mot ban ghi tu tep: */

unsigned char bo_dem[1024];
fread(bo_dem, 1, sizeof bo_dem, f);

TieuDe *td = (TieuDe *)bo_dem;      /* VI PHAM, va co the lech can chinh */

/* Cach dung: */

TieuDe td;
memcpy(&td, bo_dem, sizeof td);     /* dung ve ca hai mat */

/* Bai 18.5 va Bai 18.8 da noi ve dinh dang tep nhi phan. */

/* Thuat toan can bac hai nguoc noi tieng cua Quake III: */

float Q_rsqrt(float number) {
    long i;
    float x2, y;

    x2 = number * 0.5F;
    y  = number;
    i  = *(long *)&y;                       /* VI PHAM */
    i  = 0x5f3759df - (i >> 1);
    y  = *(float *)&i;                      /* VI PHAM */
    y  = y * (1.5F - (x2 * y * y));

    return y;
}

/* Doan ma nay noi tieng, va no la UB. Ban 1999 chay dung vi
   trinh bien dich luc do khong khai thac quy tac.

   Ban dung: doi hai dong ep kieu thanh memcpy. Hop ngu giong het,
   va ma tro nen hop le. */

/* Mot be nho don gian: */

static unsigned char be[4096];
static size_t da_dung = 0;

void *cap(size_t n) {
    void *p = be + da_dung;
    da_dung += n;
    return p;
}

/* Nguoi dung viet: */
SinhVien *sv = cap(sizeof *sv);
sv->ma = 1;                          /* ghi kieu SinhVien vao mang char */

/* Truong hop nay THUC TE la hop le, vi chuan noi vung nho tra ve
   tu ham cap phat khong co "kieu khai bao": kieu cua no duoc quyet dinh
   boi lan ghi dau tien.

   Nhung mang tinh "be" thi CO kieu khai bao la unsigned char[4096],
   nen viec nay thuoc vung xam. Cach chac chan:

     - dung malloc that
     - hoac khai bao be bang mot union chua moi kieu ban dinh dat vao
     - hoac dung _Alignas(max_align_t) va chap nhan phu thuoc trinh bien dich */

/* So sanh 16 byte bang bon phep so sanh 32 bit: */

int bang_nhau(const char a[16], const char b[16]) {
    const uint32_t *pa = (const uint32_t *)a;    /* VI PHAM va co the lech */
    const uint32_t *pb = (const uint32_t *)b;

    return pa[0] == pb[0] && pa[1] == pb[1]
        && pa[2] == pb[2] && pa[3] == pb[3];
}

/* Cach dung, va nhanh khong kem: */

int bang_nhau(const char a[16], const char b[16]) {
    return memcmp(a, b, 16) == 0;
}

/* memcmp cua glibc voi kich thuoc co dinh duoc noi tuyen thanh
   hai lenh SIMD. Nhanh hon ban viet tay o tren. */