#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int count = 5;
    int *scores = malloc(count * sizeof *scores);   /* 창고에서 빌린다 */

    if (scores == nullptr) {                        /* 빌리기는 실패할 수 있다 */
        printf("allocation failed\n");
        return 1;
    }

    int sum = 0;
    for (int i = 0; i < count; i += 1) {
        scores[i] = (i + 1) * 10;
        sum += scores[i];
    }
    printf("total: %d\n", sum);

    free(scores);                                   /* 빌린 것은 돌려준다 */
    return 0;
}

/* malloc 을 적는 세 가지 표기 — 무엇이 다른가. */
#include <stdio.h>
#include <stdlib.h>

struct node { int id; double weight; };

int main(void)
{
    /* ── 권장 표기: 타입 이름이 한 번도 안 나온다 ── */
    struct node *a = malloc(4 * sizeof *a);
    if (!a) return 1;

    /* ── C++ 호환을 노린 표기: 타입 이름이 두 번 ── */
    struct node *b = (struct node *)malloc(4 * sizeof(struct node));
    if (!b) { free(a); return 1; }

    /* ── 절충: 캐스트는 붙이되 크기는 대상에서 가져온다 ── */
    struct node *c = (struct node *)malloc(4 * sizeof *c);
    if (!c) { free(a); free(b); return 1; }

    printf("all three reserve the same size: %zu, %zu, %zu bytes\n",
           4 * sizeof *a, 4 * sizeof(struct node), 4 * sizeof *c);

    puts("\n[sizeof *p does not read p - an unevaluated operand]");
    struct node *nul = NULL;
    printf("  even with p null, sizeof *p works out to %zu\n", sizeof *nul);
    puts("  the size comes from the *type*, not from the value.");

    puts("\n[write the name twice and the two can drift apart]");
    puts("  struct node *p = (struct node *)malloc(n * sizeof(struct gadget));");
    puts("  ^ the type name is in two places, so it is possible to fix only one.");
    puts("  written as sizeof *p, that mistake *cannot be written*.");

    puts("\n[a risk both spellings carry - overflow in the multiplication]");
    size_t huge = (size_t)-1 / sizeof(struct node) + 1;
    printf("  huge * sizeof *a wraps around to %zu\n", (size_t)(huge * sizeof *a));
    puts("  -> malloc can then succeed with a 'tiny' size. Check the count first, or");
    puts("     use calloc(count, size), which checks the multiplication itself.");

    free(a); free(b); free(c);
    return 0;
}

/* malloc 이 돌려주는 주소의 정렬, 그리고 빌리고 돌려주는 값 */
#include <stdint.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define N 300000

static double seconds_since(struct timespec t0)
{
    struct timespec t1;
    timespec_get(&t1, TIME_UTC);
    return (double)(t1.tv_sec - t0.tv_sec) + (double)(t1.tv_nsec - t0.tv_nsec) / 1e9;
}

static void *volatile sink;      /* 최적화가 할당을 지우지 못하게 붙잡는다 */

int main(void)
{
    /* ── ① 정렬: 무엇을 담을지 모르므로 가장 엄격한 정렬로 준다 ── */
    printf("alignment of max_align_t = %zu bytes\n", alignof(max_align_t));

    size_t misaligned = 0;
    void *p[8];
    for (int i = 0; i < 8; i++) {
        p[i] = malloc(1);                    /* 1바이트만 요청해도 */
        if ((uintptr_t)p[i] % alignof(max_align_t) != 0) misaligned++;
    }
    printf("of 8 one-byte requests, ones breaking the default alignment: %zu\n", misaligned);
    printf("address gap between two neighbouring blocks: %td bytes (though 1 was asked for)\n",
           (char *)p[1] - (char *)p[0]);
    for (int i = 0; i < 8; i++) free(p[i]);

    /* ── ② 값: 같은 일을 세 방식으로 ── */
    struct timespec t0;
    unsigned long long acc = 0;

    timespec_get(&t0, TIME_UTC);
    for (int i = 0; i < N; i++) {           /* 매번 빌리고 돌려준다 */
        char *b = malloc(64);
        if (!b) return 1;
        b[0] = (char)i;
        acc += (unsigned char)b[0];
        sink = b;
        free(b);
    }
    double t_alloc = seconds_since(t0);

    char *reused = malloc(64);
    if (!reused) return 1;
    timespec_get(&t0, TIME_UTC);
    for (int i = 0; i < N; i++) {           /* 한 번 빌려 계속 쓴다 */
        reused[0] = (char)i;
        acc += (unsigned char)reused[0];
        sink = reused;
    }
    double t_reuse = seconds_since(t0);
    free(reused);

    timespec_get(&t0, TIME_UTC);
    for (int i = 0; i < N; i++) {           /* 아예 스택에 둔다 */
        char b[64];
        b[0] = (char)i;
        acc += (unsigned char)b[0];
        sink = b;
    }
    double t_stack = seconds_since(t0);

    printf("\n%d iterations\n", N);
    printf("  malloc + free every time : %7.4f s  (%5.1f ns each)\n", t_alloc, t_alloc / N * 1e9);
    printf("  borrow once and reuse    : %7.4f s  (%5.1f ns each)\n", t_reuse, t_reuse / N * 1e9);
    printf("  a stack array            : %7.4f s  (%5.1f ns each)\n", t_stack, t_stack / N * 1e9);
    printf("\n(total %llu - a value we use so the work is not optimized away)\n", acc);
    return 0;
}

/* 1차원으로 할당해 2차원으로 쓰기 — 실무에서 가장 흔한 형태.
   첨자 계산을 손으로 하지 않고 매크로 한 줄에 가둔다. */
#include <stdckdint.h>
#include <stdio.h>
#include <stdlib.h>

/* 첨자 매크로: 인자를 모두 괄호로 감싸고(57장), 곱을 size_t 로 올린다.
   i 와 j 를 두 번 평가하지 않으므로 부수효과가 있는 인자도 안전하다. */
#define AT(p, cols, i, j)  ((p)[(size_t)(i) * (size_t)(cols) + (size_t)(j)])

/* 크기 계산은 넘칠 수 있다 — 넘치면 할당을 시도하지 않는다(52·80장). */
static int *alloc_grid(size_t rows, size_t cols)
{
    size_t cells, bytes;
    if (ckd_mul(&cells, rows, cols))          return NULL;
    if (ckd_mul(&bytes, cells, sizeof(int)))  return NULL;
    return malloc(bytes);
}

int main(void)
{
    const size_t rows = 3, cols = 4;
    int *g = alloc_grid(rows, cols);
    if (!g) { puts("allocation failed"); return 1; }

    /* ── ① 채우기와 읽기 — 첨자는 매크로 하나로 ─────────────── */
    for (size_t i = 0; i < rows; i++)
        for (size_t j = 0; j < cols; j++)
            AT(g, cols, i, j) = (int)(i * 10 + j);

    printf("a 3x4 stored row-major:\n");
    for (size_t i = 0; i < rows; i++) {
        printf("  ");
        for (size_t j = 0; j < cols; j++)
            printf("%3d", AT(g, cols, i, j));
        printf("\n");
    }

    /* ── ② 기억은 한 줄로 이어져 있다 ───────────────────────── */
    printf("\nwalking the same memory as one dimension: ");
    for (size_t k = 0; k < rows * cols; k++)
        printf(k ? " %d" : "%d", g[k]);
    printf("\n(the same layout as a real 2-D array int m[3][4] - row-major)\n");

    /* ── ③ 흔한 사고: 행과 열을 바꿔 쓰기 ───────────────────── */
    printf("\nAT(g, cols, 1, 2) = %d   (row 2, third element)\n", AT(g, cols, 1, 2));
    printf("AT(g, cols, 2, 1) = %d   (row 3, second element - a different cell)\n", AT(g, cols, 2, 1));

    /* ── ④ 넘치는 크기 요청은 거절된다 ──────────────────────── */
    int *huge = alloc_grid((size_t)-1 / 2, 8);
    printf("\nan absurd size request: %s\n", huge ? "allocated" : "the multiplication overflowed, refused");
    free(huge);

    free(g);
    return 0;
}