#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 };  /* a compound literal */
}

int main(void)
{
    struct point a = { .x = 3, .y = 4 };     /* designated initialisation */
    struct point b = moved(a, 10, -1);

    printf("a = (%d, %d)\n", a.x, a.y);       /* access through a value: . */
    printf("b = (%d, %d)\n", b.x, b.y);

    struct point *p = &b;
    printf("p->x = %d\n", p->x);              /* access through a pointer: -> */

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

/* Why the sum of member sizes is not the struct's size — print the layout. */
#include <stddef.h>
#include <stdio.h>

/* the same members, only the order differs */
struct loose { char  a; int   b; char  c; };   /* a big one between small ones */
struct tight { int   b; char  a; char  c; };   /* biggest first */

int main(void)
{
    printf("sum of 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));

    /* draw the layout: named cells for members, dots for the gaps */
    puts("\ncell 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));

    /* laid out as an array, the difference multiplies */
    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;
}

/* Zeroing a whole struct — { 0 } and C23's { } null out pointer members too. */
#include <stdio.h>
#include <string.h>

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

struct config {
    int          retries;
    char        *path;      /* a pointer member */
    double       ratio;
    struct inner in;        /* which contains another pointer */
    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 of %zu bytes are zero\n", tag, zero, n);
}

int main(void)
{
    struct config a = {0};      /* only the first member is spelled out */
    struct config b = {};       /* C23: empty initializer — whole object */

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

    /* Designated initializers behave the same: what you leave out is
       default-initialized. */
    struct config c = { .retries = 3 };
    dump("{.retries=3}:", &c);

    /* memset writes all-bits-zero, which is not the same promise as "null" —
       the same here, but the standard does not guarantee it. */
    struct config m;
    memset(&m, 0, sizeof m);
    printf("after memset, is path null? %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;
}

/* The flexible array member — C99's way to take header and data in one block. */
#include <stdckdint.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Leave the last member's size empty and it is a flexible array member.
   It is not counted in sizeof — the size is decided when allocating. */
struct msg {
    unsigned kind;
    size_t   len;
    char     data[];      /* <- the flexible array member */
};

/* size = header + data. Skip the overflow check and a big array lands in a small vessel. */
static struct msg *msg_new(unsigned kind, const char *text)
{
    size_t len = strlen(text);
    size_t need;
    /* offsetof(struct msg, data) is more exact than sizeof(struct msg) —
       it does not count the tail padding twice. */
    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("\nallocated = 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);

    /* header and data are one block, so one free */
    free(m);

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

/* Where a flexible array member sits, and how to size it. The two structs have
   exactly the same first three members and differ only in the last one. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* A flexible array member sits at *its own type's* alignment.
   data is uint32_t (align 4), so two bytes are left empty after c. */
struct s1 { uint16_t a; uint32_t b; uint16_t c; uint32_t data[]; };

/* data is char (align 1), so it follows c directly --- no gap. */
struct s2 { uint16_t a; uint32_t b; uint16_t c; char     data[]; };

/* The correct size to allocate: offsetof(type, 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);      /* exactly the size that holds three */
    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.");

    /* allocate for real, and see where the last element ends */
    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;
}

/* What actually happens when a struct with a flexible array member is assigned.
   Nothing stops you --- which is what makes it dangerous. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* the array begins where sizeof ends --- offsetof(12) == sizeof(12) */
struct s1 { uint16_t a; uint32_t b; uint16_t c; uint32_t data[]; };
/* the first two elements reach into 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;
}