/* 표로 잇는 상속: 파생 표가 기반 표를 첫 멤버로 품는다.
   - square 는 칸 하나(area)를 덮어쓰고 describe 는 shape 의 것을 물려받는다.
   - circle 은 describe 를 덮어쓰되 기반의 것을 먼저 부르고(상위 호출),
     circle 코드만 닿는 자기 칸(radius)을 더한다. */
#include <stdio.h>

struct shape;
struct shape_ops {
    double (*area)(const struct shape *);
    void   (*describe)(const struct shape *);
};
struct shape { const struct shape_ops *ops; const char *name; };

static void shape_describe(const struct shape *s)          /* 기반의 행동 */
{
    printf("%-7s area %6.2f", s->name, s->ops->area(s));
}

/* square: 평범한 파생 --- 칸 하나만 바꾸고 나머지는 기반의 것을 적는다 */
struct square { struct shape base; double side; };
static double square_area(const struct shape *s)
{
    const struct square *q = (const struct square *)s;      /* base 가 첫 멤버다 */
    return q->side * q->side;
}
static const struct shape_ops square_ops = {
    .area = square_area, .describe = shape_describe,
};

/* circle: 기반 표를 품고 칸 하나를 더한 파생 표 */
struct circle;
struct circle_ops {
    struct shape_ops base;                                  /* 반드시 첫 자리 */
    double (*radius)(const struct circle *);
};
struct circle { struct shape base; double r; };

static double circle_area(const struct shape *s)
{
    const struct circle *c = (const struct circle *)s;
    return 3.0 * c->r * c->r;
}
static double circle_radius(const struct circle *c) { return c->r; }
static void circle_describe(const struct shape *s)
{
    shape_describe(s);                                      /* 상위 호출: 기반 먼저 */
    const struct circle_ops *ops = (const struct circle_ops *)s->ops;
    printf("  radius %.1f", ops->radius((const struct circle *)s));
}
static const struct circle_ops circle_ops = {
    .base = { .area = circle_area, .describe = circle_describe },
    .radius = circle_radius,
};

int main(void)
{
    struct square sq = { { &square_ops, "square" }, 2 };
    struct circle ci = { { &circle_ops.base, "circle" }, 1.5 };
    const struct shape *all[] = { &sq.base, &ci.base };

    for (size_t i = 0; i < sizeof all / sizeof all[0]; i++) {
        all[i]->ops->describe(all[i]);   /* 부르는 쪽은 shape 만 본다 */
        putchar('\n');
    }
    printf("circle's table starts with the shape table: %s\n",
           (const void *)&circle_ops == (const void *)&circle_ops.base ? "yes" : "no");
    return 0;
}

/* C 의 오버로딩: _Generic 은 식의 타입으로 갈래를 고른다 --- 컴파일 때.
   그것이 보는 타입이 늘 사람이 생각한 타입은 아니다. */
#include <stdint.h>
#include <stdio.h>

#define type_name(x) _Generic((x),                          \
    char: "char", signed char: "signed char", unsigned char: "unsigned char", \
    short: "short", unsigned short: "unsigned short",        \
    int: "int", unsigned: "unsigned", long: "long", unsigned long: "unsigned long", \
    long long: "long long", unsigned long long: "unsigned long long", \
    float: "float", double: "double", long double: "long double", \
    char *: "char *", const char *: "const char *", int *: "int *", \
    default: "(something else)")

/* 타입으로 오버로딩한 「print」 --- 모든 갈래가 호출마다 컴파일되어야 한다 */
static void print_int(long long v)    { printf("%lld", v); }
static void print_uint(unsigned long long v) { printf("%llu", v); }
static void print_dbl(double v)       { printf("%g", v); }
static void print_str(const char *s)  { printf("\"%s\"", s); }
#define print(x) _Generic((x),                                          \
    int: print_int, long: print_int, long long: print_int,               \
    unsigned: print_uint, unsigned long: print_uint, unsigned long long: print_uint, \
    float: print_dbl, double: print_dbl,                                 \
    char *: print_str, const char *: print_str)(x)

int main(void)
{
    char c = 'a';
    uint8_t byte = 200;
    const int ci = 5;
    int arr[3] = { 0 };

    /* C 에서 문자 상수는 int 다 */
    printf("%-16s -> %s\n", "'a'",        type_name('a'));
    printf("%-16s -> %s\n", "c (a char)", type_name(c));
    printf("%-16s -> %s\n", "c + 1",      type_name(c + 1));   /* 진급된다 */
    printf("%-16s -> %s\n", "byte",       type_name(byte));    /* uint8_t 는 typedef 다 */
    printf("%-16s -> %s\n", "ci (const)", type_name(ci));      /* 한정자가 떨어진다 */
    printf("%-16s -> %s\n", "arr",        type_name(arr));     /* 배열이 무너진다 */
    /* const char * 가 아니라 char * */
    printf("%-16s -> %s\n", "\"text\"",   type_name("text"));
    printf("%-16s -> %s\n", "1.0f * 2",   type_name(1.0f * 2));

    printf("\nprint: ");
    print(42); printf(", "); print(3u); printf(", ");
    print(2.5); printf(", "); print("hi");
    printf("\n");
    /* print(c) 는 컴파일되지 않는다: char 갈래가 없다. 빠진 갈래가 오류라는 것은
       좋은 소식이고, `c + 1` 이 조용히 int 갈래로 간다는 것은 나쁜 소식이다. */
    return 0;
}

/* 자기 크기를 지니고 다니는 구조체 --- Windows API 의 cbSize 방식.
   라이브러리 판 2 가 끝에 멤버를 하나 더했다. 판 1 로 컴파일한 프로그램도 그대로 돈다 ---
   라이브러리는 부른 쪽이 말한 바이트만큼만 읽는다. */
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

/* 판 1 헤더에 있던 것 */
struct win_opts_v1 { uint32_t size; int32_t width, height; };
/* 판 2 헤더: 끝에 멤버 하나 더, 다른 것은 움직이지 않았다 */
struct win_opts    { uint32_t size; int32_t width, height; int32_t dpi; };

static_assert(offsetof(struct win_opts, height) == offsetof(struct win_opts_v1, height),
              "old members must stay where they were");

/* 라이브러리(판 2) */
static bool win_open(const void *opts)
{
    uint32_t size;
    memcpy(&size, opts, sizeof size);        /* 첫 멤버는 언제나 크기 */
    struct win_opts o = { .dpi = 96 };       /* 부른 쪽에 없는 것은 기본값으로 */
    if (size == sizeof(struct win_opts_v1) || size == sizeof(struct win_opts))
        memcpy(&o, opts, size);              /* 부른 쪽이 가진 것보다 더 읽지 않는다 */
    else {
        printf("  size %u: not a version this library knows --- refused\n",
               (unsigned)size);
        return false;
    }
    printf("  size %2u: %d x %d at %d dpi\n", (unsigned)size, o.width, o.height, o.dpi);
    return true;
}

int main(void)
{
    puts("an old program (built with the version-1 header):");
    struct win_opts_v1 old = { .size = sizeof old, .width = 640, .height = 480 };
    win_open(&old);

    puts("a new program:");
    struct win_opts now = { .size = sizeof now, .width = 1920, .height = 1080,
                            .dpi = 144 };
    win_open(&now);

    puts("a program that forgot to fill in the size:");
    struct win_opts careless = { .width = 800, .height = 600 };   /* 크기는 0 */
    win_open(&careless);
    return 0;
}