/* 임시 구조체(복합 리터럴)로 "이름 붙은 매개변수"를 만들고,
   구조체 복사가 배열 멤버까지 옮긴다는 사실을 확인한다. */
#include <stdio.h>

/* ── ① 이름으로 넘기는 매개변수 ─────────────────────────── */
struct draw_opts {
    int         width;     /* 0 이면 기본값 80 */
    int         height;    /* 0 이면 기본값 24 */
    bool        grid;
    const char *title;
};

static void draw_(struct draw_opts o)
{
    int w = o.width  ? o.width  : 80;
    int h = o.height ? o.height : 24;
    printf("  %3dx%-3d grid=%-5s title=%s\n", w, h,
           o.grid ? "true" : "false", o.title ? o.title : "(none)");
}
/* 호출자가 중괄호를 적지 않아도 되게 감싼다 */
#define draw(...) draw_((struct draw_opts){ __VA_ARGS__ })

/* ── ② 배열을 값으로 넘기기 ─────────────────────────────── */
struct row { int cell[8]; };          /* 배열을 구조체로 감싸면 값이 된다 */

static int total(struct row r)        /* 사본이 통째로 건너온다 */
{
    int t = 0;
    for (int i = 0; i < 8; i++) t += r.cell[i];
    r.cell[0] = 999;                  /* 사본만 바뀐다 */
    return t;
}

static int total_raw(int cell[8])     /* 배열 매개변수는 포인터로 무너진다 */
{
    int t = 0;
    for (int i = 0; i < 8; i++) t += cell[i];
    cell[0] = 999;                    /* 원본이 바뀐다 */
    return t;
}

int main(void)
{
    puts("passing by name (any order, some may be left out)");
    draw(.title = "chart", .height = 20, .width = 40);
    draw(.grid = true);
    draw();                                     /* 전부 기본값 */

    /* 복합 리터럴은 주소를 얻을 수 있고, 수명은 이 블록의 끝까지다 */
    struct draw_opts *p = &(struct draw_opts){ .width = 5, .title = "temporary" };
    printf("  reaching it through the address of a compound literal: width=%d title=%s\n", p->width, p->title);

    puts("\narrays by value / by pointer");
    struct row r = { .cell = { 1, 2, 3, 4, 5, 6, 7, 8 } };

    /* 호출과 원본 읽기를 반드시 갈라 적는다 - 한 표현식에 섞으면 순서가 없다 */
    int t1 = total(r);
    printf("  by value  : sum %2d,  after the call cell[0] = %d\n", t1, r.cell[0]);
    int t2 = total_raw(r.cell);
    printf("  by pointer: sum %2d,  after the call cell[0] = %d\n", t2, r.cell[0]);

    /* 구조체 대입도 통째 복사다 — 배열 멤버까지 */
    struct row copy = r;
    copy.cell[1] = -1;
    printf("  after changing the assigned copy: original cell[1] = %d, copy cell[1] = %d\n",
           r.cell[1], copy.cell[1]);
    return 0;
}

/* 구조체의 배치 - 패딩, 재배열, 강제 정렬 */
#include <stddef.h>
#include <stdio.h>

struct loose  { char  a; int b; char c; };   /* 작은 것 사이에 큰 것 */
struct tight  { int   b; char a; char c; };  /* 큰 것부터 늘어놓기   */

#pragma pack(push, 1)                         /* 여기서부터 패딩 금지 */
struct packed { char  a; int b; char c; };
#pragma pack(pop)                             /* 원래 규칙으로 복귀   */

struct cacheline { alignas(64) int counter; };  /* 강제로 넓게 정렬 */

struct nested { struct loose inner; int tag; };

static void report(const char *name, size_t size, size_t align,
                   size_t oa, size_t ob, size_t oc)
{
    printf("%-8s size %2zu  align %2zu   offsets a=%zu b=%zu c=%zu\n",
           name, size, align, oa, ob, oc);
}

int main(void)
{
    report("loose",  sizeof(struct loose),  alignof(struct loose),
           offsetof(struct loose, a), offsetof(struct loose, b), offsetof(struct loose, c));
    report("tight",  sizeof(struct tight),  alignof(struct tight),
           offsetof(struct tight, a), offsetof(struct tight, b), offsetof(struct tight, c));
    report("packed", sizeof(struct packed), alignof(struct packed),
           offsetof(struct packed, a), offsetof(struct packed, b), offsetof(struct packed, c));

    printf("\ncacheline size %zu  align %zu\n",
           sizeof(struct cacheline), alignof(struct cacheline));
    printf("nested    size %zu  inner offset %zu  tag offset %zu\n",
           sizeof(struct nested), offsetof(struct nested, inner),
           offsetof(struct nested, tag));

    /* 멤버 세 개의 크기 합과 구조체 크기의 차이 = 패딩 바이트 수 */
    size_t members = sizeof(char) + sizeof(int) + sizeof(char);
    printf("\nloose: members %zu, actual %zu -> padding %zu bytes\n",
           members, sizeof(struct loose), sizeof(struct loose) - members);
    return 0;
}

/* 구조체를 통째로 저장하면 무엇이 함께 나가는가 — 그리고 올바른 직렬화. */
#include <stdint.h>
#include <stdio.h>
#include <string.h>

struct record {
    uint8_t  kind;      /* 1바이트 */
    uint32_t id;        /* 4바이트 — 4의 배수 자리에 놓여야 한다 */
    uint16_t flags;     /* 2바이트 */
};

static void dump(const char *label, const unsigned char *b, size_t n)
{
    printf("  %-16s", label);
    for (size_t i = 0; i < n; i++) printf(" %02X", b[i]);
    printf("   (%zu bytes)\n", n);
}

/* ── 올바른 방법: 바이트 순서를 내가 정한다 ─────────────────────
   고정 폭 타입을 하나씩, 정해진 순서(여기서는 빅 엔디안)로 적는다.
   패딩이 끼어들 자리가 없고, 어느 기계에서 읽어도 같은 뜻이 된다. */
static size_t put_u8(unsigned char *p, uint8_t v)  { p[0] = v; return 1; }
static size_t put_u16(unsigned char *p, uint16_t v)
{ p[0] = (unsigned char)(v >> 8); p[1] = (unsigned char)v; return 2; }
static size_t put_u32(unsigned char *p, uint32_t v)
{
    p[0] = (unsigned char)(v >> 24); p[1] = (unsigned char)(v >> 16);
    p[2] = (unsigned char)(v >> 8);  p[3] = (unsigned char)v;
    return 4;
}

static size_t encode(unsigned char *out, const struct record *r)
{
    size_t n = 0;
    n += put_u8(out + n, r->kind);
    n += put_u32(out + n, r->id);
    n += put_u16(out + n, r->flags);
    return n;
}

static int decode(const unsigned char *in, size_t len, struct record *r)
{
    if (len < 7) return 0;                       /* 길이부터 검증한다 */
    r->kind  = in[0];
    r->id    = (uint32_t)in[1] << 24 | (uint32_t)in[2] << 16
             | (uint32_t)in[3] << 8  | (uint32_t)in[4];
    r->flags = (uint16_t)((uint16_t)in[5] << 8 | in[6]);
    return 1;
}

int main(void)
{
    printf("struct record: sizeof = %zu (members add up to %zu)\n\n",
           sizeof(struct record),
           sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint16_t));

    /* 이 자리를 쓰던 값이 남아 있는 상황을 흉내 낸다 —
       스택의 구조체는 실제로 이렇게 '앞사람의 쓰레기' 위에 놓인다. */
    struct record r;
    memset(&r, 0xAA, sizeof r);      /* 자리를 더럽혀 두고 */
    r.kind = 1; r.id = 0x01020304; r.flags = 0x0506;   /* 멤버만 채운다 */

    puts("[dumping it whole]");
    dump("bytes", (const unsigned char *)&r, sizeof r);
    puts("  -> where you see AA is padding. Nobody set those bytes, and out they go.");
    puts("    (faked here, but in reality uninitialized bytes leak just like this)");

    puts("\n[serializing field by field]");
    unsigned char buf[16];
    size_t n = encode(buf, &r);
    dump("bytes", buf, n);
    puts("  -> no padding, and the order is mine to choose (big endian here).");

    struct record back;
    if (decode(buf, n, &back))
        printf("  reading it back: kind=%u id=0x%08X flags=0x%04X - %s\n",
               back.kind, back.id, back.flags,
               (back.kind == r.kind && back.id == r.id && back.flags == r.flags)
               ? "same as the original" : "different");

    puts("\n[same values - so why is comparing the whole thing dangerous]");
    struct record a, b;
    memset(&a, 0x00, sizeof a);
    memset(&b, 0xFF, sizeof b);      /* 패딩만 다르게 */
    a.kind = b.kind = 1; a.id = b.id = 42; a.flags = b.flags = 7;
    printf("  every member is equal. memcmp = %d  <- nonzero means 'different'\n",
           memcmp(&a, &b, sizeof a) != 0 ? 1 : 0);
    puts("  which is why structs are compared member by member.");
    return 0;
}

/* 익명 멤버와 container_of — 멤버의 주소에서 바깥 구조체를 되찾는다. */
#include <stddef.h>
#include <stdio.h>

/* 침습적 목록의 고리. 이 자체로는 아무 뜻이 없다 — 남의 구조체에 박힌다. */
struct link { struct link *next; };

/* C11 의 익명 멤버: 이름 없는 구조체·공용체의 멤버를 바깥에서 바로 쓴다 */
struct tagged {
    unsigned kind;
    union {                       /* ← 이름이 없다 */
        int    i;
        double d;
    };
};

struct task {
    const char  *name;
    int          priority;
    struct link  node;            /* 목록에 매달리는 고리 */
};

/* 멤버의 주소 − 그 멤버의 오프셋 = 바깥 구조체의 주소.
   리눅스 커널의 container_of 가 이 한 줄이다. */
#define CONTAINER_OF(ptr, type, member) \
    ((type *)(void *)((char *)(ptr) - offsetof(type, member)))

int main(void)
{
    puts("[anonymous members]");
    struct tagged t = { .kind = 1, .i = 42 };
    printf("  t.kind = %u, t.i = %d   <- written t.i, not t.u.i\n",
           t.kind, t.i);
    printf("  sizeof(struct tagged) = %zu\n", sizeof t);

    puts("\n[container_of]");
    struct task a = { .name = "compile", .priority = 3 };
    struct task b = { .name = "link",    .priority = 1 };
    a.node.next = &b.node;
    b.node.next = nullptr;

    /* 목록은 고리만 안다. 고리에서 작업을 되찾는다. */
    printf("  offsetof(struct task, node) = %zu\n", offsetof(struct task, node));
    struct task *expect[] = { &a, &b };
    size_t i = 0;
    for (struct link *p = &a.node; p; p = p->next, i++) {
        struct task *task = CONTAINER_OF(p, struct task, node);
        printf("  task recovered from the link: \"%s\" (priority %d) - same address as the original: %s\n",
               task->name, task->priority, task == expect[i] ? "yes" : "no");
    }

    puts("\n  the link knows nothing about the data, so the same list code fits any struct");
    puts("  - the intrusive list of part 12 stands on this one line.");
    return 0;
}