#include <stdio.h>

struct point {
    int x;
    int y;
};

struct point moved(struct point p, int dx, int dy)
{
    return (struct point){ .x = p.x + dx, .y = p.y + dy };  /* 복합 리터럴 */
}

int main(void)
{
    struct point a = { .x = 3, .y = 4 };     /* 지정 초기화 */
    struct point b = moved(a, 10, -1);

    printf("a = (%d, %d)\n", a.x, a.y);       /* 값으로 접근: . */
    printf("b = (%d, %d)\n", b.x, b.y);

    struct point *p = &b;
    printf("p->x = %d\n", p->x);              /* 포인터로 접근: -> */

    printf("sizeof(struct point) = %zu\n", sizeof(struct point));
    return 0;
}

/* 멤버 크기를 더한 값과 구조체의 크기는 왜 다른가 — 배치를 직접 인쇄한다. */
#include <stddef.h>
#include <stdio.h>

/* 같은 멤버, 순서만 다르다 */
struct loose { char  a; int   b; char  c; };   /* 작은 것 사이에 큰 것 */
struct tight { int   b; char  a; char  c; };   /* 큰 것부터 */

int main(void)
{
    printf("sum of the member sizes: %zu + %zu + %zu = %zu bytes\n",
           sizeof(char), sizeof(int), sizeof(char),
           sizeof(char) * 2 + sizeof(int));

    printf("\nstruct loose { char a; int b; char c; }\n");
    printf("  sizeof  = %zu, _Alignof = %zu\n",
           sizeof(struct loose), alignof(struct loose));
    printf("  offsetof(a) = %zu, offsetof(b) = %zu, offsetof(c) = %zu\n",
           offsetof(struct loose, a), offsetof(struct loose, b),
           offsetof(struct loose, c));

    printf("\nstruct tight { int b; char a; char c; }\n");
    printf("  sizeof  = %zu, _Alignof = %zu\n",
           sizeof(struct tight), alignof(struct tight));
    printf("  offsetof(b) = %zu, offsetof(a) = %zu, offsetof(c) = %zu\n",
           offsetof(struct tight, b), offsetof(struct tight, a),
           offsetof(struct tight, c));

    /* 배치를 그림처럼 그려 본다: 멤버가 차지한 칸은 이름으로, 빈자리는 . 으로 */
    puts("\nlayout cell by cell (numbers are offsets, dots are padding):");
    for (size_t i = 0; i < sizeof(struct loose); i++) {
        char mark = '.';
        if (i == offsetof(struct loose, a)) mark = 'a';
        else if (i >= offsetof(struct loose, b)
              && i <  offsetof(struct loose, b) + sizeof(int)) mark = 'b';
        else if (i == offsetof(struct loose, c)) mark = 'c';
        printf("%c", mark);
    }
    printf("   <- loose (%zu bytes)\n", sizeof(struct loose));
    for (size_t i = 0; i < sizeof(struct tight); i++) {
        char mark = '.';
        if (i < sizeof(int)) mark = 'b';
        else if (i == offsetof(struct tight, a)) mark = 'a';
        else if (i == offsetof(struct tight, c)) mark = 'c';
        printf("%c", mark);
    }
    printf("       <- tight (%zu bytes)\n", sizeof(struct tight));

    /* 배열로 늘어놓으면 차이가 곱해진다 */
    printf("\nwith a million elements: loose %zu MiB, tight %zu MiB\n",
           sizeof(struct loose) * 1000000u / (1024 * 1024),
           sizeof(struct tight) * 1000000u / (1024 * 1024));
    return 0;
}

/* 통째로 0으로 — { 0 } 과 C23 의 { } 는 포인터 멤버까지 널로 만든다. */
#include <stdio.h>
#include <string.h>

struct inner { int k; char *note; };

struct config {
    int          retries;
    char        *path;      /* 포인터 멤버 */
    double       ratio;
    struct inner in;        /* 안에 또 포인터가 있다 */
    char         name[4];
};

static void dump(const char *tag, const struct config *c)
{
    printf("%s retries=%d path=%s ratio=%g in.k=%d in.note=%s name[0]=%d\n",
           tag, c->retries,
           c->path == NULL ? "null" : "not null",
           c->ratio, c->in.k,
           c->in.note == NULL ? "null" : "not null",
           c->name[0]);
}

static void bytes(const char *tag, const void *p, size_t n)
{
    const unsigned char *b = p;
    size_t zero = 0;
    for (size_t i = 0; i < n; i++)
        zero += (b[i] == 0);
    printf("%s %zu bytes, %zu of them zero\n", tag, n, zero);
}

int main(void)
{
    struct config a = {0};      /* 첫 멤버만 명시, 나머지는 기본 초기화 */
    struct config b = {};       /* C23: 빈 초기자 — 객체 전체가 기본 초기화 */

    dump("{0} :", &a);
    dump("{ } :", &b);

    /* 지정 초기화도 마찬가지다 — 적지 않은 멤버는 기본 초기화된다 */
    struct config c = { .retries = 3 };
    dump("{.retries=3}:", &c);

    /* memset 은 '모든 비트 0' 이지 '널'이 아니다 — 이 구현에서는 같지만
       표준이 같다고 보장하지 않는다. */
    struct config m;
    memset(&m, 0, sizeof m);
    printf("is path null after memset: %s (on this implementation)\n",
           m.path == NULL ? "yes" : "no");

    printf("\nsizeof(struct config) = %zu, sum of member sizes = %zu - the difference is padding\n",
           sizeof(struct config),
           sizeof(int) + sizeof(char *) + sizeof(double)
           + sizeof(struct inner) + 4);
    bytes("{0} :", &a, sizeof a);
    bytes("{ } :", &b, sizeof b);
    return 0;
}

/* 유연 배열 멤버 — 머리와 데이터를 한 덩어리로 잡는 C99 의 장치. */
#include <stdckdint.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 마지막 멤버의 크기를 비워 두면 '유연 배열 멤버'다.
   sizeof 에는 이 멤버가 들어가지 않는다 — 크기는 잡을 때 정한다. */
struct msg {
    unsigned kind;
    size_t   len;
    char     data[];      /* ← 유연 배열 멤버 */
};

/* 잡을 크기 = 머리 + 데이터. 넘침 검사를 빠뜨리면 작은 그릇에 큰 배열이 된다. */
static struct msg *msg_new(unsigned kind, const char *text)
{
    size_t len = strlen(text);
    size_t need;
    /* offsetof(struct msg, data) 가 sizeof(struct msg) 보다 정확하다 —
       꼬리 패딩을 두 번 세지 않는다. */
    if (ckd_add(&need, offsetof(struct msg, data), len)) return nullptr;

    struct msg *m = malloc(need);
    if (!m) return nullptr;
    m->kind = kind;
    m->len  = len;
    memcpy(m->data, text, len);
    return m;
}

int main(void)
{
    printf("sizeof(struct msg)          = %zu  <- data is not counted\n",
           sizeof(struct msg));
    printf("offsetof(struct msg, data)  = %zu\n", offsetof(struct msg, data));
    printf("alignof(struct msg)         = %zu\n", alignof(struct msg));

    const char *text = "hello, world!";
    struct msg *m = msg_new(7, text);
    if (!m) { perror("malloc"); return 1; }

    printf("\nsize reserved = offsetof(data) + %zu = %zu bytes\n",
           m->len, offsetof(struct msg, data) + m->len);
    printf("kind = %u, len = %zu, data = \"%.*s\"\n",
           m->kind, m->len, (int)m->len, m->data);

    /* 머리와 데이터가 한 덩어리라 free 도 한 번이다 */
    free(m);

    puts("\ndifference from the old practice:");
    puts("  char data[1];  <- the 'struct hack'. The size arithmetic is off by one,");
    puts("                   and it read past the array, outside the contract.");
    puts("  char data[];   <- what C99 made official. Inside the contract.");
    return 0;
}

/* 유연 배열 멤버의 자리와 크기 셈 --- 앞 멤버가 같아도 마지막 멤버의 타입이
   자리를 바꾼다. 두 구조체는 앞의 셋이 완전히 같고 마지막만 다르다. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* 유연 배열 멤버는 *자기 타입의 정렬*에 맞춰 앉는다.
   data 가 uint32_t(정렬 4)이므로 c 뒤에 빈자리 2바이트가 생긴다. */
struct s1 { uint16_t a; uint32_t b; uint16_t c; uint32_t data[]; };

/* data 가 char(정렬 1)이므로 c 바로 뒤에 붙는다 --- 빈자리가 없다. */
struct s2 { uint16_t a; uint32_t b; uint16_t c; char     data[]; };

/* 잡을 크기의 올바른 식: offsetof(구조체, data) + n * sizeof(data[0]) */
#define NEED(type, member, n) (offsetof(type, member) + (n) * sizeof(((type *)0)->member[0]))

static void layout(const char *name, size_t a, size_t b, size_t c,
                   size_t data, size_t size, size_t align, size_t elem)
{
    printf("  %s: a=%zu b=%zu c=%zu data=%zu | sizeof=%zu alignof=%zu"
           " sizeof(data[0])=%zu\n", name, a, b, c, data, size, align, elem);
    printf("      padding before data: %zu byte(s)\n", data - (c + sizeof(uint16_t)));
}

int main(void)
{
    puts("(1) the same three members, a different last member");
    layout("s1", offsetof(struct s1, a), offsetof(struct s1, b),
           offsetof(struct s1, c), offsetof(struct s1, data),
           sizeof(struct s1), alignof(struct s1), sizeof(((struct s1 *)0)->data[0]));
    layout("s2", offsetof(struct s2, a), offsetof(struct s2, b),
           offsetof(struct s2, c), offsetof(struct s2, data),
           sizeof(struct s2), alignof(struct s2), sizeof(((struct s2 *)0)->data[0]));

    puts("\n  the flexible array member sits at its own type's alignment:");
    puts("    s1: data is uint32_t (align 4) -> two bytes of padding appear before it");
    puts("    s2: data is char     (align 1) -> it follows c directly, no padding");
    puts("  both structs have the same sizeof, and it says nothing about where data is.");

    puts("\n(2) how many bytes to allocate for n elements");
    puts("      n | s1: offsetof rule | sizeof rule | s2: offsetof rule | sizeof rule");
    for (size_t n = 0; n <= 3; n++)
        printf("     %2zu | %17zu | %11zu | %17zu | %11zu\n", n,
               NEED(struct s1, data, n), sizeof(struct s1) + n * 4,
               NEED(struct s2, data, n), sizeof(struct s2) + n * 1);
    puts("  for s1 the two rules agree by accident (offsetof == sizeof == 12).");
    puts("  for s2 they never agree: the sizeof rule counts the tail padding twice.");

    puts("\n(3) the same arithmetic, run backwards: how many elements are in a buffer?");
    size_t buf = NEED(struct s2, data, 3);      /* 세 원소가 정확히 들어가는 크기 */
    printf("  a %zu-byte s2 record holds exactly 3 elements\n", buf);
    printf("  offsetof rule: (%zu - %zu) / 1 = %zu   <- right\n",
           buf, offsetof(struct s2, data), buf - offsetof(struct s2, data));
    printf("  sizeof   rule: (%zu - %zu) / 1 = %zu   <- two elements lost\n",
           buf, sizeof(struct s2), buf - sizeof(struct s2));

    puts("\n(4) is an empty record well formed?");
    printf("  an empty s2 record is %zu bytes on the wire\n", NEED(struct s2, data, 0));
    printf("  \"len >= offsetof(data)\" -> %s   <- right\n",
           NEED(struct s2, data, 0) >= offsetof(struct s2, data) ? "accepted" : "REJECTED");
    printf("  \"len >= sizeof(struct)\" -> %s  <- a valid record thrown away\n",
           NEED(struct s2, data, 0) >= sizeof(struct s2) ? "accepted" : "REJECTED");

    puts("\n(5) the price of the exact fit");
    printf("  s2 with one element needs %zu bytes, but sizeof(struct s2) is %zu\n",
           NEED(struct s2, data, 1), sizeof(struct s2));
    puts("  so the object is smaller than its own type: *a = *b, memcpy(a, b, sizeof *a),");
    puts("  or passing it by value would run past the end of the allocation.");
    puts("  a struct with a flexible array member is copied field by field, never whole.");

    /* 실제로 잡아 보고, 마지막 원소가 어디서 끝나는지 눈으로 확인한다 */
    size_t n = 3;
    struct s2 *r = malloc(NEED(struct s2, data, n));
    if (!r) { perror("malloc"); return 1; }
    r->a = 1; r->b = 2; r->c = 3;
    for (size_t i = 0; i < n; i++) r->data[i] = (char)('A' + i);
    printf("\n  allocated %zu bytes; data[%zu] ends at offset %zu; data = %.3s\n",
           NEED(struct s2, data, n), n - 1,
           offsetof(struct s2, data) + n * sizeof r->data[0], r->data);
    free(r);
    return 0;
}

/* 유연 배열 멤버가 있는 구조체를 대입하면 무슨 일이 나는가.
   막히지는 않는다 --- 그래서 더 위험하다. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 배열이 sizeof 바깥에서 시작한다 --- offsetof(12) == sizeof(12) */
struct s1 { uint16_t a; uint32_t b; uint16_t c; uint32_t data[]; };
/* 배열의 앞 두 원소가 sizeof 안에 걸쳐 있다 --- offsetof(10) < sizeof(12) */
struct s2 { uint16_t a; uint32_t b; uint16_t c; char data[]; };

#define NEED(n) (offsetof(struct s2, data) + (n) * sizeof(char))

static struct s2 *make(size_t n, char fill)
{
    struct s2 *p = calloc(1, NEED(n) > sizeof(struct s2) ? NEED(n) : sizeof(struct s2));
    if (!p) { perror("calloc"); exit(1); }
    memset(p->data, fill, n);
    return p;
}

int main(void)
{
    size_t n = 3;
    puts("how many elements fall inside sizeof? that is what decides everything:");
    printf("  s1: offsetof(data)=%zu sizeof=%zu -> %zu element(s) inside\n",
           offsetof(struct s1, data), sizeof(struct s1),
           (sizeof(struct s1) - offsetof(struct s1, data)) / sizeof(uint32_t));
    printf("  s2: offsetof(data)=%zu sizeof=%zu -> %zu element(s) inside\n",
           offsetof(struct s2, data), sizeof(struct s2),
           sizeof(struct s2) - offsetof(struct s2, data));

    puts("\n(0) assigning an s1: the array begins where sizeof ends");
    struct s1 *x = calloc(1, offsetof(struct s1, data) + n * sizeof(uint32_t));
    struct s1 *y = calloc(1, offsetof(struct s1, data) + n * sizeof(uint32_t));
    if (!x || !y) { perror("calloc"); return 1; }
    x->a = 1; y->a = 9;
    for (size_t i = 0; i < n; i++) { x->data[i] = 100 + (uint32_t)i;
                                     y->data[i] = 900 + (uint32_t)i; }
    *y = *x;
    printf("  y after *y = *x: a=%u data=%u %u %u   <- the array was left alone\n",
           y->a, y->data[0], y->data[1], y->data[2]);
    free(x); free(y);

    printf("\nnow s2, where two elements fall inside sizeof.\n");
    printf("three elements need %zu bytes\n", NEED(n));

    struct s2 *src = make(n, '?'), *dst = make(n, '.');
    src->a = 1; src->b = 2; src->c = 3;
    memcpy(src->data, "ABC", n);

    puts("\n(1) plain struct assignment: *dst = *src");
    *dst = *src;
    printf("  members : a=%u b=%u c=%u   <- copied\n", dst->a, dst->b, dst->c);
    printf("  data    : %.3s              <- source was ABC, destination was ...\n", dst->data);
    puts("  the standard says only the named members are copied, and array elements");
    puts("  inside the first sizeof bytes get an indeterminate representation");
    puts("  (C23 6.7.3.2 p28) -- they may or may not match the source. Never rely on it.");

    puts("\n(2) the same mistake spelled with memcpy: memcpy(dst, src, sizeof *dst)");
    struct s2 *dst2 = make(n, '.');
    memcpy(dst2, src, sizeof *dst2);
    printf("  data    : %.3s              <- the same half copy, for the same reason\n",
           dst2->data);

    puts("\n(3) the correct byte copy: memcpy(dst, src, offsetof(...) + n * sizeof(data[0]))");
    struct s2 *dst3 = make(n, '.');
    memcpy(dst3, src, NEED(n));
    printf("  members : a=%u b=%u c=%u\n", dst3->a, dst3->b, dst3->c);
    printf("  data    : %.3s              <- all of it\n", dst3->data);

    puts("\n(4) and one more trap: an object smaller than its own type");
    printf("  one element needs %zu bytes, but sizeof(struct s2) is %zu\n",
           NEED(1), sizeof(struct s2));
    puts("  a struct assignment there would touch bytes past the end of the allocation");
    puts("  -- undefined behaviour, and ASan reports it as a heap-buffer-overflow.");

    free(src); free(dst); free(dst2); free(dst3);
    return 0;
}