/* 타입 한정자 넷을 한자리에서 확인한다.
   요점은 「한정판은 같은 타입의 다른 판일 뿐, 크기도 정렬도 바뀌지 않는다」이다. */
#include <stdio.h>
#include <stdalign.h>

struct big { char a[9]; };

int main(void)
{
    puts("① a qualifier changes neither size nor alignment");
    printf("  int            : %zu / %zu\n", sizeof(int), alignof(int));
    printf("  const int      : %zu / %zu\n", sizeof(const int), alignof(const int));
    printf("  volatile int   : %zu / %zu\n", sizeof(volatile int), alignof(volatile int));
    printf("  struct big     : %zu / %zu\n", sizeof(struct big), alignof(struct big));
    printf("  _Atomic big    : %zu / %zu   <- unchanged in this implementation\n",
           sizeof(_Atomic struct big), alignof(_Atomic struct big));

    puts("\n② order is free, and they can be combined");
    const volatile int a = 1;
    volatile const int b = 2;      /* 위와 완전히 같은 타입 */
    printf("  const volatile int a = %d,  volatile const int b = %d\n", a, b);

    puts("\n③ _Atomic has two faces");
    _Atomic int   c = 3;           /* 한정자로 쓴 꼴 */
    _Atomic(int)  d = 4;           /* 타입 지정자로 쓴 꼴 — 같은 타입이다 */
    printf("  _Atomic int c = %d,  _Atomic(int) d = %d\n", c, d);
    /* typedef int A[3];  _Atomic A x;   <- 배열에는 붙일 수 없다: 컴파일 오류 */

    puts("\n④ const only says 「not through this name」");
    int  x  = 10;
    const int *p = &x;             /* p 로는 못 바꾼다 */
    x = 20;                        /* 그러나 x 로는 바꿀 수 있다 */
    printf("  changing x directly gives *p = %d  <- const is a promise about the path, not the value\n", *p);
    /* *p = 30;  <- 오류: assignment of read-only location */

    puts("\n⑤ you may add a qualifier, but you may not silently drop one");
    const int ci = 7;
    const int *q = &ci;            /* 붙이기: 된다 */
    printf("  int * -> const int * passes; the reverse warns (-Wdiscarded-qualifiers), *q = %d\n", *q);
    /* int *bad = &ci;  <- 경고: initialization discards 'const' qualifier */

    return 0;
}

/* <stdint.h> 의 세 갈래와 uint8_t 의 함정. */
#include <inttypes.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>

int main(void)
{
    puts("[three families - they demand different things]");
    printf("  %-16s %-6s %s\n", "type", "size", "what it guarantees");
    printf("  %-16s %-6zu %s\n", "uint8_t",       sizeof(uint8_t),
           "exactly 8 bits, no padding (optional)");
    printf("  %-16s %-6zu %s\n", "uint_least8_t", sizeof(uint_least8_t),
           "smallest type with at least 8 bits (required)");
    printf("  %-16s %-6zu %s\n", "uint_fast8_t",  sizeof(uint_fast8_t),
           "usually the fastest with at least 8 bits (required)");
    printf("  %-16s %-6zu %s\n", "uint_least32_t", sizeof(uint_least32_t), "at least 32 bits");
    printf("  %-16s %-6zu %s\n", "uint_fast32_t",  sizeof(uint_fast32_t),  "at least 32 bits, speed first");
    printf("  %-16s %-6zu %s\n", "uintmax_t",      sizeof(uintmax_t),      "the widest integer (required)");
    printf("  %-16s %-6zu %s\n", "uintptr_t",      sizeof(uintptr_t),      "round-trips a void* (optional)");

    puts("\n[trap 1: uint8_t is usually unsigned char, so it leaks out as a character]");
    uint8_t age = 65;
    printf("  as %%u: %u\n", age);
    printf("  as %%c: %c   <- you get 'A', not 65\n", age);
    printf("  putchar(age) is the same trap\n");

    puts("\n[trap 2: arithmetic promotes to int - this is not 8-bit arithmetic]");
    uint8_t a = 200, b = 100;
    printf("  a + b        = %d   <- computed as int, so 300 (it did not wrap)\n", a + b);
    printf("  (uint8_t)(a+b) = %u   <- it wraps only when stored back\n", (uint8_t)(a + b));
    printf("  sizeof(a + b) = %zu  <- the result is 4 bytes\n", sizeof(a + b));

    puts("\n[trap 3: they are only aliases, so the format macros must follow]");
    printf("  with PRIu8: %" PRIu8 "\n", age);
    printf("  UINT8_C(200) is %u, UINT8_MAX is %u\n", UINT8_C(200), UINT8_MAX);

    puts("\n[which one, when]");
    puts("  protocol, file format, register -> exact width (uint32_t)");
    puts("  portability first, width at least -> minimum width (uint_least16_t)");
    puts("  loop counter, local arithmetic    -> fastest width (uint_fast32_t)");
    puts("  size, index, byte count           -> size_t (<stddef.h>)");
    return 0;
}