/* 저장 클래스 지정자가 정하는 것을 눈으로 확인한다.
   한 선언에 이 자리는 하나뿐이라는 규칙과, 그 유일한 예외도 함께 본다. */
#include <stdio.h>

static int file_only = 1;          /* 내부 연결 — 이 파일 안에서만 보인다 */
extern int shared;                 /* 예고만 — 실물은 아래에 있다 */
int        shared = 2;             /* 정의 */
thread_local int per_thread = 3;   /* 갈래마다 따로 */

static int bump(void)
{
    static int calls = 0;          /* 정적 저장 기간 — 호출 사이에 살아남는다 */
    return ++calls;
}

int main(void)
{
    auto int local = 4;            /* C17 까지의 뜻: 자동 저장 기간(기본값) */
    register int hot = 5;          /* 옛 부탁. 주소는 못 얻는다 */
    constexpr int fixed = 6;       /* C23 — 컴파일 시간 상수 */
    static_assert(fixed == 6, "constexpr is a constant expression");

    printf("file_only=%d shared=%d per_thread=%d local=%d hot=%d fixed=%d\n",
           file_only, shared, per_thread, local, hot, fixed);
    /* 한 문장에 여러 번 부르면 평가 순서가 미지정이라 순서가 뒤집힌다(34장).
       그래서 한 줄에 하나씩 부른다. */
    int b1 = bump(), b2 = bump(), b3 = bump();
    printf("bump() three times: %d %d %d   <- a static local survives\n", b1, b2, b3);

    /* static extern int bad;   <- 오류: multiple storage classes            */
    /* int *p = &hot;           <- 오류: address of register variable        */
    /* auto constexpr int c=1;  <- 오류: 'auto' used with 'constexpr'        */
    static thread_local int ok = 7;   /* 이 조합만 예외로 허용된다 */
    printf("static thread_local ok=%d\n", ok);
    return 0;
}

#include <stdio.h>

int next_ticket(void)
{
    static int issued = 0;      /* 정적 수명: 호출 사이에도 살아남는다 */
    issued += 1;
    return issued;
}

int fresh_count(void)
{
    int n = 0;                  /* 자동 수명: 호출마다 새로 태어난다 */
    n += 1;
    return n;
}

int main(void)
{
    /* 부수효과 있는 호출은 문장을 나눈다 — 29장의 수칙 그대로 */
    int t1 = next_ticket();
    int t2 = next_ticket();
    int t3 = next_ticket();
    printf("next_ticket: %d %d %d\n", t1, t2, t3);

    int f1 = fresh_count();
    int f2 = fresh_count();
    int f3 = fresh_count();
    printf("fresh_count: %d %d %d\n", f1, f2, f3);
    return 0;
}

/* 프로그램의 기억이 실제로 어디에 놓이는지 주소로 확인한다.
   (구체적 값은 기계·운영체제·실행마다 다르다. 보아야 할 것은 *구역의 순서*다.) */
#include <stdio.h>
#include <stdlib.h>

const char  ro_text[]  = "read-only";   /* 상수 — 대개 읽기 전용 구역 */
int         initialized = 7;             /* 값이 있는 전역 — data      */
int         zeroed;                      /* 값이 없는 전역 — bss       */

static void deeper(int depth, char *outer)
{
    char here;                            /* 이 프레임의 지역 변수 */
    if (depth == 0) {
        printf("  a local one frame deeper : %p\n", (void *)&here);
        printf("  difference from the outer frame     : %+ld bytes\n",
               (long)(&here - outer));
        printf("  => the stack grows toward %s addresses\n",
               (&here < outer) ? "lower" : "higher");
        return;
    }
    deeper(depth - 1, outer);
}

int main(void)
{
    static int  static_local;             /* 지역이지만 정적 저장 기간 */
    int         automatic = 1;            /* 자동 저장 기간 — 스택     */
    void       *heap1 = malloc(64);
    void       *heap2 = malloc(64);

    printf("code (function main)      : %p\n", (void *)(void (*)(void))main);
    printf("read-only string          : %p\n", (void *)ro_text);
    printf("global (initialized, data): %p\n", (void *)&initialized);
    printf("global (zero, bss)        : %p\n", (void *)&zeroed);
    printf("static inside a function  : %p\n", (void *)&static_local);
    printf("heap (malloc 1)           : %p\n", heap1);
    printf("heap (malloc 2)           : %p\n", heap2);
    printf("stack (a local)           : %p\n", (void *)&automatic);
    printf("\ngap between the two heap blocks: %+ld bytes\n", (long)((char *)heap2 - (char *)heap1));
    printf("distance from stack to heap    : about %.1f TiB (a 64-bit address space is that wide)\n\n",
           ((double)((char *)&automatic - (char *)heap1)) / (1024.0 * 1024.0 * 1024.0 * 1024.0));

    char anchor;                          /* 스택 방향을 재는 기준점 */
    deeper(1, &anchor);

    free(heap1);
    free(heap2);
    return 0;
}