/* 상수를 적는 방법들 — 표기가 값과 타입을 어떻게 정하는가. */
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <uchar.h>

int main(void)
{
    puts("[integer constants - four bases and digit separators (C23)]");
    printf("  1234        = %d\n", 1234);          /* 10진 */
    printf("  0755        = %d   <- a leading 0 means octal\n", 0755);
    printf("  0xFF        = %d\n", 0xFF);
    printf("  0b1010      = %d   <- binary, new in C23\n", 0b1010);
    printf("  1'000'000   = %d   <- digit separators, new in C23\n", 1'000'000);
    printf("  0b11'10'11'01 = %d\n", 0b11'10'11'01);

    puts("\n[접미어가 타입을 정한다]");
    printf("  sizeof 1    = %zu, sizeof 1L  = %zu, sizeof 1LL = %zu\n",
           sizeof 1, sizeof 1L, sizeof 1LL);
    printf("  sizeof 1U   = %zu, sizeof 1wb = %zu  ← wb 는 C23 의 _BitInt\n",
           sizeof 1U, sizeof 1wb);

    puts("\n[문자 상수 — 접두어가 타입을 정한다]");
    printf("  'a'   크기 %zu, 값 %d      ← C 에서 문자 상수는 int 다\n",
           sizeof 'a', 'a');
    printf("  u8'a' 크기 %zu (char8_t)\n",  sizeof u8'a');
    printf("  u'a'  크기 %zu (char16_t)\n", sizeof u'a');
    printf("  U'a'  크기 %zu (char32_t)\n", sizeof U'a');
    printf("  L'a'  크기 %zu (wchar_t)\n",  sizeof L'a');
    /* 'ab' 같은 다중 문자 상수는 값이 구현 정의라 -Wmultichar 가 경고한다.
       여기서는 경고를 켠 채 두고, 값은 본문의 실측 표로만 보인다. */

    puts("\n[이스케이프 — 8진과 16진]");
    printf("  '\\101' = %d, '\\x41' = %d   ← 둘 다 'A'\n", '\101', '\x41');
    printf("  \"\\x41\" \"1\" = \"%s\"        ← 16진은 가장 긴 열을 먹는다.\n",
           "\x41" "1");
    puts("    그래서 \"\\x411\" 이 아니라 문자열을 쪼개 이어 붙인다.");

    puts("\n[부동소수점 상수]");
    printf("  3.14  1e3=%g  1.=%g  .5=%g\n", 1e3, 1., .5);
    printf("  0x1p-3 = %g            ← 16진 부동소수점. 지수부 p 는 필수다\n", 0x1p-3);
    printf("  sizeof 1.0 = %zu, 1.0f = %zu, 1.0L = %zu\n",
           sizeof 1.0, sizeof 1.0f, sizeof 1.0L);
    printf("  0.1 == 0.1f ? %s   ← 접미어가 다르면 값도 다르다\n",
           (double)0.1f == 0.1 ? "예" : "아니오");

    puts("\n[문자열 리터럴]");
    printf("  sizeof \"abc\" = %zu        ← NUL 이 한 칸 더 붙는다\n", sizeof "abc");
    printf("  \"hello, \" \"world\" = \"%s\"  ← 인접한 것은 하나로 이어진다\n",
           "hello, " "world");
    printf("  \"a\\0b\": strlen = %zu, sizeof = %zu  ← 안에 NUL 을 넣어도 배열은 남는다\n",
           strlen("a\0b"), sizeof "a\0b");
    printf("  sizeof u8\"가\" = %zu, sizeof u\"가\" = %zu, sizeof U\"가\" = %zu\n",
           sizeof u8"\uAC00", sizeof u"\uAC00", sizeof U"\uAC00");
    return 0;
}

/* C23 의 constexpr — 「진짜 상수」가 어디까지 되는가. */
#include <stdio.h>

constexpr int table_size = 4;          /* 파일 스코프: 정적 저장 기간 + 내부 연결 */
constexpr double half = 0.5;
constexpr long long big = 1LL << 40;

int table[table_size];                 /* 배열 크기 — 가변 길이 배열이 아니다 */
static_assert(sizeof table / sizeof table[0] == 4, "table_size is a constant");

constexpr int doubled = table_size * 2;  /* 상수로 상수를 만든다 */

struct limits { int low, high; };
constexpr struct limits range = { 1, 9 };
static_assert(range.high == 9, "a member of a constexpr struct is a constant");

/* 전처리기는 constexpr 을 모른다 — 아래에서 그 사실을 인쇄한다 */
#if table_size == 4
static const char *preproc = "the preprocessor saw table_size == 4";
#else
static const char *preproc = "the preprocessor never saw it: the name became 0";
#endif

static const char *classify(int x)
{
    switch (x) {
    case table_size:  return "exactly the table size";   /* case 라벨 */
    case doubled:     return "twice the table size";
    default:          return "something else";
    }
}

struct packed {
    unsigned flags : table_size;       /* 비트 필드의 폭 */
};

int main(void)
{
    static int copy = table_size + 1;  /* 정적 초기화 */
    enum { same_again = table_size };  /* 열거 상수의 값 */

    printf("[constexpr is a constant expression]\n");
    printf("  array size    : %zu\n", sizeof table / sizeof table[0]);
    printf("  case label    : %s\n", classify(4));
    printf("  case label    : %s\n", classify(8));
    printf("  static init   : %d\n", copy);
    printf("  enum value    : %d\n", (int)same_again);
    printf("  bit-field     : %d bits\n", table_size);
    printf("  struct member : range.high = %d (checked with static_assert)\n",
           range.high);

    printf("\n[it has a type, unlike a macro]\n");
    printf("  half  = %g (double)\n", half);
    printf("  big   = %lld (long long)\n", big);
    printf("  const is implicit: %s\n",
           _Generic(&table_size, const int *: "yes, &table_size is const int *",
                                 int *: "no", default: "?"));

    printf("\n[a block-scope constexpr is an ordinary object with an address]\n");
    constexpr int local = 7;
    const int *p = &local;
    printf("  local = %d, read through a pointer = %d\n", local, *p);

    printf("\n[but the preprocessor runs before any of this]\n");
    printf("  %s\n", preproc);
    printf("  #if and #define live in a different world (chapter 57)\n");

    /* 아래는 전부 컴파일 오류다 — 값이 정확히 표현되어야 하기 때문이다.
           constexpr unsigned int m = -1;      값이 표현 불가
           constexpr float f = 0.1;            double 0.1 은 float 로 정확하지 않다
           constexpr int *q = &copy;           포인터 초기값은 널만 가능
           constexpr const char *s = "abc";    같은 이유로 불가
           constexpr volatile int v = 1;       volatile·restrict·atomic 금지
           constexpr int no_init;              정의이자 초기화여야 한다 */
    return 0;
}

#include <stdio.h>

int main(void)
{
    printf("%d\n", 2 + 3 * 4);    /* 곱셈이 먼저 계산된다 */
    printf("%d\n", (2 + 3) * 4);  /* 괄호가 순서를 명시한다 */
    return 0;
}