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

static int add(int a, int b) { return a + b; }
static int mul(int a, int b) { return a * b; }

/* 함수 포인터를 받는 함수 — 콜백의 기본형 */
static int apply(int (*op)(int, int), int a, int b) { return op(a, b); }

int main(void)
{
    /* ① 함수 이름은 값으로 쓰이는 순간 포인터로 무너진다 */
    int (*p)(int, int) = add;     /* & 없이도 된다 */
    int (*q)(int, int) = &add;    /* & 를 붙여도 같다 */
    printf("add == &add : %s\n", p == q ? "same" : "different");

    /* ② 별표를 아무리 붙여도 결과는 같다 — 역참조가 다시 무너지기 때문 */
    printf("p(2,3)=%d  (*p)(2,3)=%d  (***p)(2,3)=%d  (*******p)(2,3)=%d\n",
           p(2, 3), (*p)(2, 3), (***p)(2, 3), (*******p)(2, 3));

    /* ③ 반면 & 는 한 번만 쓸 수 있다: &&add 는 문법 오류다
          (&add 는 값일 뿐, 그 값의 주소를 다시 얻을 수는 없다) */

    /* ④ 디스패치 표 — switch 대신 배열로 고르기 */
    struct { const char *name; int (*fn)(int, int); } table[] = {
        { "add", add }, { "mul", mul },
    };
    for (size_t i = 0; i < sizeof table / sizeof table[0]; i++)
        printf("%s(6,7) = %d\n", table[i].name, apply(table[i].fn, 6, 7));

    /* ⑤ 함수 포인터의 크기는 데이터 포인터와 같다는 보장이 없다 */
    printf("sizeof(void*)=%zu, sizeof(int(*)(int,int))=%zu\n",
           sizeof(void *), sizeof(int (*)(int, int)));

    /* ⑥ qsort 의 비교자도 함수 포인터다 */
    int v[] = { 5, 2, 9, 1 };
    int cmp(const void *a, const void *b);   /* 아래에 정의 */
    qsort(v, 4, sizeof v[0], cmp);
    printf("sorted: %d %d %d %d\n", v[0], v[1], v[2], v[3]);
    return 0;
}

int cmp(const void *a, const void *b)
{
    int x = *(const int *)a, y = *(const int *)b;
    return (x > y) - (x < y);
}

/* 함수 포인터를 인쇄하는 법 — %p 에 넘길 수 없는 값을 다루는 세 가지 길. */
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

static int add(int a, int b) { return a + b; }
static int sub(int a, int b) { return a - b; }
static int mul(int a, int b) { return a * b; }

typedef int (*binop)(int, int);

/* ── 길 ①: 바이트로 떠서 16진수로 ────────────────────────────
   함수 포인터를 void* 로 캐스트하는 것은 표준 밖이다. memcpy 로 바이트를
   옮기는 것은 어디서나 계약 안이다 — 크기만 맞으면 된다. */
static void fmt_funcptr(char *out, size_t cap, binop f)
{
    unsigned char raw[sizeof f];
    memcpy(raw, &f, sizeof raw);

    size_t k = 0;
    k += (size_t)snprintf(out + k, cap - k, "0x");
    for (size_t i = sizeof raw; i-- > 0 && k + 2 < cap; )
        k += (size_t)snprintf(out + k, cap - k, "%02X", raw[i]);
}

/* ── 길 ②: 이름표를 함께 들고 다닌다 (실무의 정답) ───────────── */
struct named_op {
    const char *name;
    binop       fn;
};

static const struct named_op ops[] = {
    { "add", add }, { "sub", sub }, { "mul", mul },
};

static const char *name_of(binop f)
{
    for (size_t i = 0; i < sizeof ops / sizeof *ops; i++)
        if (ops[i].fn == f) return ops[i].name;      /* 함수 포인터 비교는 합법 */
    return "(unknown function)";
}

int main(void)
{
    printf("sizeof(function pointer) = %zu, sizeof(void *) = %zu\n\n",
           sizeof(binop), sizeof(void *));

    puts("[road 1] print the bytes - portable, but a riddle to a human");
    char buf[2 + 2 * sizeof(binop) + 1];
    fmt_funcptr(buf, sizeof buf, add);
    printf("  length of the address string for add: %zu characters (the value differs per run, so it is not shown)\n",
           strlen(buf));
    printf("  does it start with \"0x\": %s\n", strncmp(buf, "0x", 2) == 0 ? "yes" : "no");

    puts("\n[road 2] print the label - this is what belongs in a log");
    binop chosen[] = { mul, add, sub };
    for (size_t i = 0; i < sizeof chosen / sizeof *chosen; i++)
        printf("  call %zu: %s(7, 3) = %d\n",
               i, name_of(chosen[i]), chosen[i](7, 3));

    puts("\n[comparing function pointers is inside the contract]");
    binop f = add, g = add, h = sub;
    printf("  same function, so equal: %s\n", f == g ? "yes" : "no");
    printf("  different function, so unequal: %s\n", f != h ? "yes" : "no");
    puts("  so 'which function is this' can be answered without printing an address.");

    puts("\n[what not to do]");
    puts("  printf(\"%p\", f);          <- passing a function pointer to %p: outside the contract");
    puts("  printf(\"%p\", (void *)f);  <- outside ISO C (POSIX allows it). -Wpedantic catches it");
    puts("  printf(\"%p\", (void *)&f); <- compiles, but that is *the address of the variable*, not what you wanted");
    return 0;
}

#include <stdio.h>
#include <string.h>

/* C 에서 손으로 만드는 객체지향: 가상 함수 표(vtable)를 자료와 분리한다.
   GTK 의 GObject 가 쓰는 방식과 같은 뼈대다. */

struct shape;                       /* 앞선 선언 */

/* ① 가상 함수 표 — 타입마다 하나만 존재한다 (인스턴스마다가 아니다) */
struct shape_vtable {
    const char *name;
    double (*area)(const struct shape *self);
    void   (*describe)(const struct shape *self);
};

/* ② 기반 "클래스": 모든 객체의 첫 멤버가 표를 가리킨다 */
struct shape {
    const struct shape_vtable *vt;
};

/* ③ 파생 "클래스": 기반을 첫 멤버로 두면 포인터를 서로 변환할 수 있다 */
struct circle { struct shape base; double r; };
struct rect   { struct shape base; double w, h; };

static double circle_area(const struct shape *s)
{
    const struct circle *c = (const struct circle *)s;   /* 첫 멤버라 주소가 같다 */
    return 3.14159265358979 * c->r * c->r;
}
static double rect_area(const struct shape *s)
{
    const struct rect *r = (const struct rect *)s;
    return r->w * r->h;
}
static void generic_describe(const struct shape *s)
{
    printf("  %-6s area %.2f\n", s->vt->name, s->vt->area(s));
}

/* ④ 표는 상수이고 타입마다 하나 — 인스턴스는 포인터만 갖는다 */
static const struct shape_vtable circle_vt = { "circle",   circle_area, generic_describe };
static const struct shape_vtable rect_vt   = { "rect", rect_area,   generic_describe };

static struct circle make_circle(double r) { return (struct circle){ { &circle_vt }, r }; }
static struct rect   make_rect(double w, double h) { return (struct rect){ { &rect_vt }, w, h }; }

int main(void)
{
    struct circle c = make_circle(2.0);
    struct rect   r = make_rect(3.0, 4.0);

    /* ⑤ 같은 코드가 서로 다른 타입을 다룬다 — 다형성 */
    const struct shape *objs[] = { &c.base, &r.base };
    for (size_t i = 0; i < sizeof objs / sizeof objs[0]; i++)
        objs[i]->vt->describe(objs[i]);

    /* ⑥ 비용을 눈으로 본다 */
    printf("object size: circle=%zu, rect=%zu (including the %zu-byte table pointer)\n",
           sizeof(struct circle), sizeof(struct rect), sizeof(void *));
    printf("table size : %zu (one per type, no more)\n", sizeof(struct shape_vtable));
    return 0;
}