35 객체, 주소, 포인터

35.1 세 가지 표기 — 선언, &, *

포인터 문법은 세 조각이 전부다.

선언 — int *p;는 “int의 주소를 담는 변수 p”를 선언한다. 읽는 요령은 뒤에서부터다: “p는 포인터인데(*p), 가리키는 곳에 int가 있다”.

주소 얻기 — &n은 “n의 주소”라는 값이다. 25장의 sscanf(..., &n) 에서 스쳐 본 그 &가 드디어 정식 이름을 얻었다 — n이라는 사물함의 번호표를 떼어 주는 연산자다.

역참조 — *p는 “p에 적힌 주소로 찾아가서 그 칸”이라는 뜻이다. 읽는 자리에 있으면 그 칸의 값을 읽고, 대입의 왼쪽에 있으면 그 칸에 쓴다. 선언의 *와 수식의 *(역참조), 그리고 곱셈의 *가 같은 글자를 쓰는 것은 C의 악명 높은 절약 정신이다 — 자리로 구별하는 수밖에 없다.

시연으로 세 조각을 한 번에 본다. 33장의 숙제 — 함수가 원본을 바꾸는 정공법 — 까지 포함이다.

#include <stdio.h>

void set_to(int *target, int value)
{
    *target = value;            /* 주소를 따라가 원본에 쓴다 */
}

int main(void)
{
    int n = 1;
    int *p = &n;                /* p는 n의 주소를 담는다 */

    printf("n at first: %d\n", n);
    printf("p == &n ? %d\n", p == &n);

    *p = 55;                    /* 역참조: p가 가리키는 곳(= n)에 쓴다 */
    printf("n after *p = 55: %d\n", n);

    set_to(&n, 99);             /* 29장의 숙제 — 함수가 원본을 바꾼다 */
    printf("n after set_to: %d\n", n);
    return 0;
}

n at first: 1
p == &n ? 1
n after *p = 55: 55
n after set_to: 99

set_to(&n, 99)의 동선을 정확히 읽어 두면 포인터의 절반이 끝난다 — ① &n(주소라는 값)이 매개변수 target에 복사되고(33장의 값 복사 규칙은 그대로다!), ② 함수 안에서 *target = value가 그 주소로 찾아가 원본 칸에 쓴다. 값 복사의 세계는 하나도 깨지지 않았다 — 복사된 것이 주소였을 뿐이다.

35.2 sizeof — 그릇의 크기를 묻다

미뤄 둔 마지막 외상 — sizeof는 타입이나 대상의 바이트 크기를 내놓는 연산자다(값은 size_t 타입 — 크기 전용 부호 없는 정수이고, 서식은 %zu다). 25장의 fgets(line, sizeof line, stdin)이 이제 완전히 읽힌다: “line이라는 그릇의 바이트 수를 fgets에게 알려 준다”. 함수가 아니라 연산자라서 대부분 컴파일 시점에 값이 정해지고, sizeof(int)처럼 타입에도, sizeof line처럼 대상에도 쓸 수 있다.

35.2.1 sizeof 가 내놓는 타입 — size_t

sizeof 의 결과 타입이 size_t 라는 것은 곁가지가 아니라 계약이다. 이 타입 하나를 정확히 알아 두면 뒤의 여러 장에서 만날 함정이 미리 막힌다.

★ 가장 자주 무는 것은 「부호가 없다」는 성질이다. 부호 있는 정수와 견주면 통상 산술 변환이 부호 있는 쪽을 부호 없는 쪽으로 끌어올린다(29장) — 그래서 다음이 성립한다.

int n = -1;
if (n < sizeof arr) { … }     /* 참일 것 같지만 *거짓*이다 */

이 책이 직접 확인했다 — -1 < sizeof arr 의 값은 0이었고, GCC 는 -Wsign-compare 로 「부호가 다른 정수식의 비교」라고 경고한다. -1 이 거대한 양수로 바뀌었기 때문이다. 41장에서 볼 역순 루프의 무한 반복도 뿌리가 같다.

35.3 주소는 어떤 수인가 — 이름·크기·순서

포인터를 “그냥 수”로 볼 수 없다는 말을 여러 번 했다. 그러면 어떤 수인가. 수를 쓰는 방식을 셋으로 갈라 보면 답이 선명해진다.

주소는 이 셋 중 하나가 아니라 셋 다이면서 어느 것도 온전히 아니다.

- 이름수로서: 주소의 가장 기본적인 쓰임이다. &x는 x라는 객체의 별명이고, 두 주소가 같은지 다른지는 언제나 물을 수 있다(그래서 ==·!=는 서로 다른 객체 사이에도 허용된다, 부록 A). 사물함 번호가 하는 일이 정확히 이것이다. - 순서수로서: 한 배열 안에서는 앞뒤가 뜻을 가진다. &a[1] < &a[2]는 참이고, 그래서 정렬·탐색·경계 검사가 성립한다. 그러나 배열이 다르면 앞뒤를 물을 수 없다 — 크기 비교가 계약 밖인 이유가 이것이다(부록 A). 순서가 있는 것은 주소 전체가 아니라 한 객체 안에서다. - 집합수로서: 두 주소의 차이는 개수를 센다 — 그런데 바이트가 아니라 원소를 센다(38장). &a[4] - &a[1]이 3인 것은 “사이에 원소가 셋”이라는 뜻이다. 그리고 이 뺄셈 역시 같은 배열 안에서만 뜻이 있다.

정리하면 이렇다. 주소는 이름수로 늘 쓸 수 있고, 순서수와 집합수로는 한 객체 안에서만 쓸 수 있다. C의 포인터 규칙이 낯설게 느껴지는 이유의 절반이 여기 있다 — 우리는 수를 셋 다 되는 것으로 배웠는데, 주소는 문맥에 따라 셋 중 무엇이 되는지가 달라진다.

그림 35.1 — 포인터 값 하나에 붙어 다니는 세 가지. 주소만 같아도 같은 포인터가 아니다.

35.3.1 왜 하필 정수였나

객체의 별명을 나타내는 방법이 정수뿐이었던 것은 아니다. 이름표(문자열), 표의 색인, 손잡이(handle) 같은 방법도 있고 실제로 그런 언어와 운영체제가 있었다. C가 정수를 고른 이유는 단순하다 — 기계가 이미 그렇게 하고 있었기 때문이다. 4·5장에서 본 대로 기계어의 주소는 수이고, 주소에 수를 더하면 이웃 칸이 되며, CPU에는 “기준 주소 + 인덱스 × 크기”를 한 번에 계산하는 회로가 있다. 정수를 고르면 배열·문자열·구조체 접근이 전부 공짜로 따라온다.

그 선택이 C의 힘이자 위험이 됐다. 힘은 표현력이다 — 별도의 문법 없이 배열이 생기고(38장), 기억을 통째로 다루는 코드를 짤 수 있다(88장). 위험은 그 수를 아무 수처럼 다룰 수 있다는 착시다.

35.3.2 추상화는 시간이 갈수록 두꺼워졌다

포인터가 처음부터 지금처럼 까다로운 개념은 아니었다. 초기의 C에서 포인터는 기계어 주소를 거의 그대로 옮긴 것이었고, “주소를 정수로 바꿔 만지고 되돌리는” 코드가 관행이었다. 그때의 기계는 단순했다 — 기억은 한 층이고, 명령은 적힌 순서대로 실행되며, 컴파일러는 사람이 쓴 것을 크게 바꾸지 않았다.

그 뒤로 아래층이 두꺼워졌다.

• 기억이 여러 층으로 갈렸다(11장) — 레지스터·캐시·DRAM, 그리고 그 위에 가상 주소와 쪽 표. 프로그램이 보는 번호는 이미 번역을 거친 번호다.
• 실행이 겹쳐 돌기 시작했다(12장) — 파이프라인, 순서를 바꿔 하는 실행, 분기 예측. “적힌 순서대로”는 더 이상 사실이 아니다.
• 컴파일러가 편집자가 됐다(13장) — 관찰 가능한 동작만 지키면 코드를 통째로 다시 쓴다. 그 재작성의 근거가 되는 전제 가운데 하나가 “이 포인터는 저 객체를 건드리지 않는다”이다.

이 세 층이 두꺼워질수록, 언어가 포인터에 요구하는 것도 늘었다. 컴파일러가 “서로 다른 객체는 서로를 건드리지 않는다”를 전제로 재배열하려면, 프로그램이 그 전제를 어기지 않는다는 약속이 필요하다. 그래서 포인터는 점점 번호에서 멀어지고 계약을 가진 위치값으로 다듬어져 왔다 — 정렬 규칙(37장), 출처 (프로버넌스, 37장), 배열 밖 주소를 만들지 말라는 규칙(38장)이 모두 그 방향의 조항이다.

35.4 주소를 인쇄하는 법

디버깅에서 가장 먼저 하는 일이 「이 포인터가 어디를 가리키나」를 눈으로 보는 것이다. 그런데 이 흔한 일에도 계약이 있다.

/* 주소를 사람이 읽는 형태로 — %p 의 계약과 그 대안들.
   ★ 주소 자체는 실행마다 달라지므로(ASLR) 이 시연은 '값'이 아니라
      '성질'만 인쇄한다. 지면에 실린 출력이 매번 같아야 하기 때문이다. */
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    int n = 42;

    /* ① %p 에 넘길 수 있는 것은 void* (그리고 C23 부터 문자 타입 포인터)뿐이다.
          다른 포인터는 캐스트한다 — 습관으로 삼는 편이 낫다. */
    puts("[the contract of %p]");
    printf("  a null pointer through %%p: %p   <- the shape of the output is up to the implementation\n",
           (void *)nullptr);
    puts("  other addresses vary per run, so they are not printed here.");

    /* ② 같은 주소를 두 가지로 찍어 문자열이 같은지 견준다 */
    char a[64], b[64];
    snprintf(a, sizeof a, "%p", (void *)&n);
    snprintf(b, sizeof b, "%#" PRIxPTR, (uintptr_t)(void *)&n);
    printf("\n[do %%p and PRIxPTR print the same characters?]\n");
    printf("  on this implementation: %s\n", strcmp(a, b) == 0 ? "same" : "different");
    printf("  same number of characters: %s (the address value is not shown)\n",
           strlen(a) == strlen(b) ? "yes" : "no");

    /* ③ 왕복이 보장되는 것은 void* ↔ uintptr_t 다 */
    uintptr_t u = (uintptr_t)(void *)&n;
    printf("\n[uintptr_t round trip]\n");
    printf("  is the restored pointer the same as the original: %s\n",
           (void *)u == (void *)&n ? "yes - the standard promises it" : "no");

    /* ④ 폭을 고정하면 로그가 가지런해진다 (자리는 0 으로 채운다) */
    char line[80];
    snprintf(line, sizeof line, "obj=0x%016" PRIxPTR, u);
    printf("\n[building one log line]\n");
    printf("  length of the line built: %zu characters (constant, whatever the address)\n",
           strlen(line));

    /* ⑤ 배치를 견줄 때는 같은 배열 안에서 뺀다 — 서로 다른 객체끼리는 계약 밖 */
    int arr[3];
    printf("\n[comparing the layout]\n");
    printf("  arr[0]->arr[1] distance: %td bytes (legal, same array)\n",
           (char *)&arr[1] - (char *)&arr[0]);
    printf("  same as sizeof(int): %s\n",
           (size_t)((char *)&arr[1] - (char *)&arr[0]) == sizeof(int) ? "yes" : "no");

    /* ⑥ 사람이 볼 로그에는 주소보다 이름·순번이 낫다 */
    puts("\n[a label instead of an address]");
    static const struct { const char *name; const void *at; } table[] = {
        { "n", nullptr }, { "arr", nullptr },
    };
    for (size_t i = 0; i < sizeof table / sizeof *table; i++)
        printf("  #%zu %-4s <- this is the name the log keeps\n", i, table[i].name);
    puts("  an address means something only within that run. The next run gives another number.");
    return 0;
}

[the contract of %p]
  a null pointer through %p: (nil)   <- the shape of the output is up to the implementation
  other addresses vary per run, so they are not printed here.

[do %p and PRIxPTR print the same characters?]
  on this implementation: same
  same number of characters: yes (the address value is not shown)

[uintptr_t round trip]
  is the restored pointer the same as the original: yes - the standard promises it

[building one log line]
  length of the line built: 22 characters (constant, whatever the address)

[comparing the layout]
  arr[0]->arr[1] distance: 4 bytes (legal, same array)
  same as sizeof(int): yes

[a label instead of an address]
  #0 n    <- this is the name the log keeps
  #1 arr  <- this is the name the log keeps
  an address means something only within that run. The next run gives another number.

35.4.1 %p 의 정확한 계약

표준(§7.23.6.1)이 정한 것은 두 줄이다.

두 줄에서 실무 규칙 둘이 곧바로 나온다.

첫째, 다른 포인터는 캐스트한다. printf("%p", &n)처럼 int *를 그대로 넘기는 것은 계약 밖이다. 가변 인자에는 타입 검사가 없고(58장), 포인터끼리 표현이 같다는 보장도 없기 때문이다 — 표준은 void *와 문자 포인터가 같은 표현·정렬을 갖는다고만 말하고, 다른 타입 포인터들은 그렇지 않을 수 있다고 분명히 적어 두었다(§6.2.5p33).

printf("%p", (void *)p);      /* 이렇게 */
printf("%p", p);              /* 이렇게 말고 */

둘째, 출력 모양에 기대지 않는다. 시연이 널 포인터를 찍은 결과가 그 증거다 — 이 구현은 (nil)이라 쓴다. 0x 접두사도, 자릿수도, 대소문자도 구현마다 다르다. 그러니 %p의 출력을 다시 파싱하는 코드를 쓰면 안 된다.

35.4.2 문자열로 만들어야 할 때 — uintptr_t와 PRIxPTR

로그 버퍼에 담거나 폭을 맞춰 정렬하려면 %p로는 부족하다. 이때 쓰는 것이 <stdint.h>의 uintptr_t와 <inttypes.h>의 PRIxPTR다.

uintptr_t u = (uintptr_t)(void *)p;
snprintf(line, sizeof line, "obj=0x%016" PRIxPTR, u);

표준이 uintptr_t에 준 약속은 정확히 이것이다 — 어떤 유효한 void *든 이 타입으로 바꿨다가 되돌리면 원래 포인터와 같다(§7.22.1.4). 시연이 그 왕복을 확인한다.

두 가지를 알아 두어야 한다. uintptr_t는 선택 사항이라 없는 구현이 있을 수 있고(그런 기계는 오늘날 드물다), 왕복이 보장되는 것은 void *에 대해서만이다 — 함수 포인터는 이 문장 밖이다(59장).

35.4.3 그런데 — 주소를 정말 찍어야 하는가

이 절의 마지막이 가장 중요하다. 주소는 그 실행 안에서만 뜻이 있다.

오늘날의 운영체제는 프로그램을 띄울 때마다 주소 배치를 무작위로 바꾼다 (ASLR). 그래서 어제의 로그에 남은 0x7ffd…는 오늘의 실행에서 아무 의미가 없다. 게다가 그 값이 밖으로 나가면 기억이 어떻게 배치되어 있는지를 알려 주는 실마리가 된다 — 공격자가 가장 먼저 찾는 것이 그것이다.

35.5 포인터의 크기는 하나가 아니다

앞의 문답에서 “이 기계에서는 8바이트”라고 조심스럽게 말한 이유를 여기서 푼다. 널리 퍼진 통념은 이렇다 — “포인터는 그냥 주소니까, 한 기계 안에서는 전부 같은 크기다.” 오늘 우리가 쓰는 x86-64 리눅스에서는 맞는 말이고, 그래서 이 통념은 좀처럼 반박당하지 않는다. 그러나 C 표준은 그렇게 약속한 적이 없고, 현실의 기계들도 그 통념을 여러 번 배신했다.

표준이 실제로 약속하는 것은 훨씬 좁다.

• void *와 문자 타입 포인터(char *·signed char *·unsigned char *)는 서로 같은 표현과 정렬 요구를 가진다. 이 넷은 한 묶음이다.
• 구조체 포인터끼리는 서로 같은 표현을 가진다. 공용체 포인터끼리도 그렇다.
• 그 밖에는 아무 약속도 없다. int *와 double *이 같은 크기여야 한다는 규칙은 없고, 객체 포인터와 함수 포인터가 같은 표현이어야 한다는 규칙도 없다.

왜 이렇게 헐겁게 정했는가 — 실제로 다른 기계들이 있었기 때문이다.

과거형으로만 말할 이야기도 아니다.

포인터의 개념이 갖춰졌다. 다음 장은 이 부의 첫 안전 수칙 — “아무 데도 가리키지 않음”을 다루는 법이다. 6장에서 얼굴만 익힌 널 삼형제를, 이번에는 문법과 실무 규칙으로 정식 취급한다.