39 배열

39.1 배열이란 무엇인가 — 같은 것이 여럿일 때#

문법보다 먼저, 배열이 왜 있어야 하는지부터 보자.

한 반 학생 서른 명의 시험 점수를 다룬다고 하자. 지금까지 배운 것만으로는 변수를 서른 개 만들어야 한다.

int score1, score2, score3, /* … */ score30;

이렇게 해 놓고 평균을 내려면 score1 + score2 + … + score30 을 손으로 다 적어야 한다. 반복문(33장)이 있어도 소용이 없다 — score1, score2 는 이름이 다를 뿐 서로 아무 관계가 없는 변수라서, 「i 번째 점수」라고 가리킬 방법이 없기 때문이다. 학생이 서른한 명이 되면 코드를 고쳐야 하고, 「17번 학생의 점수」를 입력으로 받아 찾는 일은 아예 할 수 없다.

필요한 것은 이름 하나에 번호를 붙여 부르는 방법이다. 수학이 이미 그렇게 한다. 수열을 ${𝑎}_0,{𝑎}_1,{𝑎}_2,\dots$ 로 적고 「${𝑎}_{𝑖}$」라고 쓰면 $𝑖$ 에 따라 다른 항을 가리킨다. 이름은 $𝑎$ 하나이고, 무엇을 가리키는지는 아래 첨자 $𝑖$ 가 정한다. C의 배열(array)이 바로 그것이다.

int score[30];                /* 정수 서른 개 --- 이름은 score 하나 */
score[16] = 87;               /* 17번째 학생(번호는 0부터) */
for (int i = 0; i < 30; i++)  /* 「i 번째」라고 부를 수 있으니 반복이 된다 */
    total += score[i];

C가 대괄호 안의 수를 첨자(subscript)라 부르는 것도 수학의 아래 첨자에서 왔다. 배열이 주는 것을 정리하면 셋이다.

그리고 C의 배열이 주지 않는 것도 처음부터 알아 두어야 한다. 이 장의 뒷부분과 다음 두 장이 전부 이 목록에서 나온다.

• 배열은 자기 길이를 들고 다니지 않는다. 함수에 넘기는 순간 길이를 잃는다(뒤의 「무너짐」).
• 번호가 범위 안인지 아무도 검사하지 않는다. score[30] 이나 score[-1] 도 컴파일되고 실행된다. 그 결과가 이 장 끝의 「배열에서 나는 사고들」이다.
• 크기는 정해지면 바뀌지 않는다. 실행 중에 늘리려면 46장의 동적 할당이 필요하다.

39.2 엄밀한 정의 — 표준은 배열을 이렇게 적는다#

이제 같은 것을 표준의 말로 정확히 적는다. 배열은 타입의 한 갈래로 정의된다.

“ 배열 타입은 연속으로 할당된(contiguously allocated) 비어 있지 않은 객체 집합을 기술한다 — 원소 타입이라 부르는 특정 멤버 객체 타입의 것들이다. 원소 타입은 배열 타입이 지정될 때 언제나 완전해야 한다. 배열 타입은 원소 타입과 배열 안 원소의 개수로 특징지어진다. 배열 타입은 그 원소 타입에서 파생되었다고 하며, 원소 타입이 T 이면 배열 타입을 「T 의 배열」이라 부르기도 한다.¹ ”

한 문장씩 풀면 배열에 관한 사실 대부분이 여기서 나온다.

「개수가 타입의 일부」라는 줄이 가볍게 보이지만, 뒤에서 여러 번 돌아온다. sizeof 가 배열 전체의 크기를 알려 주는 것도, &a + 1 이 배열 통째를 건너뛰는 것도(41장), 그리고 함수 매개변수에서 그 개수가 사라지는 것도 모두 이 사실을 축으로 돈다.

정의의 「비어 있지 않은」을 어기면 어떻게 되는지 이 책이 컴파일러에게 물어 보았다. 원소가 0개인 배열은 두 컴파일러 모두 확장이라고 짚는다.

gcc:   warning: ISO C forbids zero-size array ‘z’ [-Wpedantic]
clang: warning: zero size arrays are an extension [-Wzero-length-array]

39.3 선언과 초기화#

int a[5]; 를 읽는 법은 69장에서 정식으로 다루지만, 지금은 이것으로 충분하다 — 이름 a 는 「int 다섯 개의 배열」이다. 대괄호 안의 크기는 컴파일할 때 값을 아는 정수 상수식이어야 하고, 0보다 커야 한다. (변수를 쓰면 뒤에서 볼 가변 길이 배열이 된다.)

#include <stdio.h>

int main(void)
{
    int a[5] = {3, 1, 4, 1, 5};
    int sum = 0;

    for (int i = 0; i < 5; i += 1) {
        sum += a[i];
    }
    printf("sum: %d\n", sum);

    printf("a[2] = %d, *(a + 2) = %d\n", a[2], *(a + 2));

    int *p = a;                 /* 배열 이름이 첫 원소의 주소로 무너진다 */
    printf("sizeof a = %zu, sizeof p = %zu\n", sizeof a, sizeof p);
    return 0;
}

sum: 14
a[2] = 4, *(a + 2) = 4
sizeof a = 20, sizeof p = 8

int a[5] = {3, 1, 4, 1, 5}; — 타입, 이름, 칸 수, 그리고 중괄호 초기화. 접근은 a[i]이고 번호는 0부터다(첫 원소가 a[0], 마지막이 a[4]). 0부터 세는 이유는 장 첫머리의 「돌아보기」 문답이 이미 답했다 — a[i]의 정체가 “시작에서 $𝑖$칸 떨어진 곳”이라서, 첫 원소는 떨어진 거리가 0이다.

초기화에는 몇 가지 꼴이 있고, 각각 표준이 정한 규칙이 따로 있다. 한 시연에 모았다.

#include <stdio.h>

#define COUNT(a) (sizeof (a) / sizeof (a)[0])   /* 진짜 배열에만 쓴다 */

static void show(const char *label, const int *v, size_t n)
{
    printf("%-22s", label);
    for (size_t i = 0; i < n; i++)
        printf(" %d", v[i]);
    printf("   (%zu elements)\n", n);
}

static int counter[3];          /* 정적 저장 기간 --- 적지 않아도 0 */

int main(void)
{
    int full[5]    = {3, 1, 4, 1, 5};   /* 다섯 칸을 다 적었다 */
    int part[5]    = {3, 1};            /* 나머지 셋은 0 */
    int sized[]    = {2, 7, 1, 8};      /* 크기를 초기값 개수로 정한다 */
    int marked[6]  = {[4] = 9, [1] = 2};/* 지정 초기화(C99) */
    int empty[4]   = {};                /* C23: 빈 중괄호는 전부 0 */

    puts("[1] initializers");
    show("{3, 1, 4, 1, 5}", full, COUNT(full));
    show("{3, 1}", part, COUNT(part));
    show("[] = {2, 7, 1, 8}", sized, COUNT(sized));
    show("{[4] = 9, [1] = 2}", marked, COUNT(marked));
    show("{}", empty, COUNT(empty));
    show("static, no initializer", counter, COUNT(counter));

    puts("\n[2] the array type knows its size");
    printf("sizeof full    = %zu bytes\n", sizeof full);
    printf("sizeof full[0] = %zu bytes\n", sizeof full[0]);
    printf("COUNT(full)    = %zu\n", COUNT(full));

    puts("\n[3] no whole-array assignment: copy element by element");
    int copy[5];
    for (size_t i = 0; i < COUNT(full); i++)
        copy[i] = full[i];                  /* copy = full; 은 오류다 */
    show("copy of full", copy, COUNT(copy));

    puts("\n[4] the first element shares the array's address");
    printf("(void *)full == (void *)&full[0] : %d\n",
           (void *)full == (void *)&full[0]);
    return 0;
}

[1] initializers
{3, 1, 4, 1, 5}        3 1 4 1 5   (5 elements)
{3, 1}                 3 1 0 0 0   (5 elements)
[] = {2, 7, 1, 8}      2 7 1 8   (4 elements)
{[4] = 9, [1] = 2}     0 2 0 0 9 0   (6 elements)
{}                     0 0 0 0   (4 elements)
static, no initializer 0 0 0   (3 elements)

[2] the array type knows its size
sizeof full    = 20 bytes
sizeof full[0] = 4 bytes
COUNT(full)    = 5

[3] no whole-array assignment: copy element by element
copy of full           3 1 4 1 5   (5 elements)

[4] the first element shares the array's address
(void *)full == (void *)&full[0] : 1

마지막 두 줄의 차이가 중요하다. 함수 안에 int a[4]; 라고만 적으면 그 네 칸에는 그 자리를 앞서 쓰던 누군가가 남긴 값이 들어 있다. 시연이 지역 배열을 초기값 없이 찍지 않은 이유가 그것이다 — 찍어 보는 일 자체가 이 장 끝에서 볼 사고의 한 갈래다. 지역 배열은 언제나 초기화해서 시작한다. 전부 0이면 되는 자리라면 = {} 한 마디로 충분하다.

문자 배열을 문자열 리터럴로 초기화하는 꼴(char s[] = "hi";)도 있다. 그 규칙은 문자열과 함께 43장에서 본다.

39.4 배열로 할 수 없는 것 — 통째로 대입·비교·반환#

다른 언어에서 온 사람이 가장 먼저 부딪히는 벽이 여기 있다. C의 배열은 통째로 다룰 수 없다.

컴파일러가 실제로 하는 말이다.

gcc:   error: assignment to expression with array type
clang: error: array type 'int[3]' is not assignable

gcc:   warning: comparison between two arrays [-Warray-compare]
clang: warning: array comparison always evaluates to false [-Wtautological-compare]

gcc:   error: ‘f’ declared as function returning an array
clang: error: function cannot return array type 'int[3]'

그러면 배열을 복사하려면 어떻게 하는가. 방법은 셋이다. 원소를 하나씩 옮기거나(시연의 셋째 묶음), 표준 라이브러리의 memcpy 로 바이트를 통째로 옮기거나(80장), 배열을 구조체에 넣는다 — 구조체는 통째로 대입할 수 있으므로 안에 든 배열도 함께 복사된다 (47장). 내용을 비교하려면 원소를 하나씩 비교하거나 memcmp 를 쓴다.

39.5 원소 수 세기와 순회#

배열의 원소 수는 타입 안에 있으므로 sizeof 로 꺼낼 수 있다. 전체 크기를 원소 하나의 크기로 나누면 된다.

#define COUNT(a) (sizeof (a) / sizeof (a)[0])

시연의 둘째 묶음이 그 계산이다 — 20바이트 ÷ 4바이트 = 5. 이 매크로 덕분에 크기를 한 곳(선언)에만 적고, 반복문에서는 i < COUNT(a) 로 쓸 수 있다. 크기를 바꿀 때 고칠 자리가 하나로 준다.

★ 다만 진짜 배열에만 쓴다. 함수에 넘겨진 배열은 이미 포인터라서 같은 식이 엉뚱한 값을 낸다 — 이 장의 매개변수 절과 41장가 그 사고를 다룬다. 다음 표준(C2y)의 초안에는 이 일을 하는 연산자 _Countof 가 들어갔다.³ 배열이 아닌 것에는 쓸 수 없도록 되어 있어, 이 매크로의 함정을 언어가 막아 준다.

순회의 관용구는 정해져 있다.

for (size_t i = 0; i < COUNT(a); i++)   /* 0 부터, 개수 「미만」까지 */
    use(a[i]);

세 가지가 모두 의미가 있다. 0에서 시작하는 것은 첫 원소가 0번이라서이고, <(미만)로 끝내는 것은 마지막 원소가 「개수 − 1」번이라서다. 그리고 첨자의 타입으로 size_t 를 쓰는 것은 그것이 크기와 개수를 담는 타입이기 때문이다(36장). 이 셋 중 하나만 어긋나도 이 장 끝의 사고로 이어진다.

39.6 배열과 포인터 — 무너짐의 진실#

첫 시연(arr.c)의 뒷부분이 이 장의 심장이다. C에서 가장 많은 혼란을 낳은 관계 — 배열과 포인터 — 를 정확히 정리한다.

규칙: 배열의 이름은 대부분의 문맥에서 “첫 원소의 주소”로 무너진다 (decay). 무너진 뒤에 남는 것과 잃는 것을 나란히 놓으면 이렇다.

그림 39.1 — 배열 a 와 무너진 &a[0] 은 주소는 같고 타입이 다르다 — 그래서 원소가 몇 개인지가 사라진다.

int *p = a;가 합법인 이유다 — a가 &a[0]이라는 포인터 값으로 읽힌 것이다. 그리고 a[i]라는 표기 자체가 사실 *(a + i)와 뜻이 같은 동의어다(표준도 §6.5.3.2 에서 [] 를 「E1[E2] 는 (*((E1)+(E2))) 와 동일하다」로 정의한다) — 포인터에 정수를 더하면 “그 타입 크기만큼 $𝑖$칸 옆”의 주소가 되고(포인터 산술 — 38장의 규칙들이 여기 걸린다), 그것을 역참조한 것이 인덱스 접근이다. 시연의 a[2] == *(a + 2)가 그 확인이다.

39.7 원소와 원소 사이에는 빈자리가 없다#

포인터 산술로 넘어가기 전에 못박아 둘 사실이 하나 있다. 방금 a[i] 를 「시작에서 $𝑖$ 칸 떨어진 곳」이라고 읽었는데, 그 셈이 성립하려면 칸들이 빈틈없이 붙어 있어야 한다. 실제로 그렇다 — 그리고 그것은 관행이 아니라 이 장 첫머리에서 읽은 표준의 정의 자체다. 정의의 「연속으로 할당된」(contiguously allocated)이 그 근거다.

「연속으로 할당된」이 하는 말은 셋이다.

구조체와 다른 점이 여기 있다. 구조체는 멤버 사이에 빈자리가 생길 수 있지만 (48장), 배열은 원소 사이에 빈자리가 없다. 그럼 구조체의 배열은 어떻게 되는가 — 원소 사이에 빈자리가 없어야 하니, 구조체 자신의 크기가 정렬의 배수가 되도록 꼬리에 패딩이 붙는다. 그 이야기는 구조체를 배운 뒤 48장에서 그림과 함께 본다.

39.8 포인터의 덧셈은 보통의 덧셈이 아니다#

방금 a[i]가 *(a + i)라고 했다. 그러면 a + 2는 정확히 무슨 값인가? 주소에 2를 더한 것이라면 “2바이트 옆”이어야 할 텐데, 실제로는 int 두 칸 옆, 곧 8바이트 옆이다. 포인터 산술은 가리키는 타입의 크기를 곱해서 움직인다.

그림 39.2 — 포인터에 더한 +1 이 건너뛰는 폭은 그 포인터가 가리키는 타입의 크기다.

이 규칙을 정확히 적으면 이렇다.

★ 그리고 이 표가 전부다. 포인터가 낄 수 있는 덧셈·뺄셈의 꼴은 넷뿐이고, 나머지는 컴파일러가 반드시 진단해야 하는 오류다. 표준이 그것을 제약으로 못박아 두었다.

“ 덧셈에서는 두 피연산자가 모두 산술 타입이거나, 한쪽이 완전 객체 타입에 대한 포인터이고 다른 쪽이 정수 타입이어야 한다. …

뺄셈에서는 다음 중 하나라야 한다 — 둘 다 산술 타입이거나, 둘 다 호환되는 완전 객체 타입에 대한 포인터이거나, 왼쪽이 완전 객체 타입에 대한 포인터이고 오른쪽이 정수 타입이거나.(§6.5.7) ”

★ 덧셈과 뺄셈의 비대칭을 눈여겨보라. 5 + p 는 되는데 5 - p 는 안 된다. 덧셈은 「한쪽이 포인터」라고만 요구하지만, 뺄셈은 「왼쪽이 포인터」라고 적혀 있기 때문이다. 뜻을 생각하면 당연하다 — 「주소에서 다섯 칸 뒤」는 말이 되지만 「5 에서 주소를 뺀 것」은 말이 되지 않는다.

이 책이 컴파일러에게 물어 확인했다. 네 가지 금지된 꼴이 각각 이렇게 거절된다.

뒤의 둘이 표준 조문의 「완전 객체 타입에 대한 포인터」라는 단서에서 나온다. void 는 완전 타입이 아니고(27장), 함수 타입은 객체 타입이 아니다. 그래서 둘 다 산술의 자격이 없다 — gcc·clang 이 확장으로 1바이트 단위 계산을 봐 주지만 -pedantic-errors 를 켜면 오류가 된다.

즉 포인터에 정수를 더하는 일은 “주소라는 수에 그 수를 더하기”가 아니라 “칸 단위로 세기”다. char *에서만 1이 1바이트이고, int *에서 1은 4바이트, struct point *에서 1은 그 구조체 하나의 크기다.

/* 포인터 산술은 바이트가 아니라 "칸" 단위로 움직인다. */
#include <stddef.h>
#include <stdio.h>

struct point { int x, y; };

int main(void)
{
    char          c[4];
    int           a[8] = {0, 10, 20, 30, 40, 50, 60, 70};
    double        d[4];
    struct point  s[4];

    /* ── ① 같은 +1 인데 움직인 폭이 다르다 ─────────────────────── */
    printf("type          sizeof   (p+1) - p bytes\n");
    printf("char           %2zu       %td\n",
           sizeof c[0], (char *)(c + 1) - (char *)c);
    printf("int            %2zu       %td\n",
           sizeof a[0], (char *)(a + 1) - (char *)a);
    printf("double         %2zu       %td\n",
           sizeof d[0], (char *)(d + 1) - (char *)d);
    printf("struct point   %2zu       %td\n",
           sizeof s[0], (char *)(s + 1) - (char *)s);

    /* 바이트 단위로 움직이려면 문자 포인터로 캐스트한다 */
    int *p = a;
    printf("\np + 1        points at %d\n", *(p + 1));
    printf("(char*)p + 1 is the second byte of a[0] (dereference it and you get a piece of the representation, not a value)\n");

    /* ── ② 포인터 뺄셈은 원소 개수를 준다 ──────────────────────── */
    ptrdiff_t gap = &a[4] - &a[1];
    printf("\n&a[4] - &a[1]        = %td  (elements, not bytes)\n", gap);
    printf("counted in bytes     = %td\n",
           (char *)&a[4] - (char *)&a[1]);

    /* ── ③ 첨자는 산술의 동의어다 ──────────────────────────────── */
    printf("\na[3] = %d, *(a + 3) = %d, *(3 + a) = %d, 3[a] = %d\n",
           a[3], *(a + 3), *(3 + a), 3[a]);

    /* ── ④ 마지막 다음 자리는 만들어도 되지만 따라가면 안 된다 ─── */
    int *end = a + 8;                 /* one-past-the-end — 합법 */
    printf("\nelements up to one-past-the-end: %td (never dereferenced)\n", end - a);

    int count = 0;
    for (int *q = a; q != end; q++)   /* 표준 관용구: != end 로 멈춘다 */
        count += (*q != 0);
    printf("nonzero elements: %d\n", count);
    return 0;
}

type          sizeof   (p+1) - p bytes
char            1       1
int             4       4
double          8       8
struct point    8       8

p + 1        points at 10
(char*)p + 1 is the second byte of a[0] (dereference it and you get a piece of the representation, not a value)

&a[4] - &a[1]        = 3  (elements, not bytes)
counted in bytes     = 12

a[3] = 30, *(a + 3) = 30, *(3 + a) = 30, 3[a] = 30

elements up to one-past-the-end: 8 (never dereferenced)
nonzero elements: 7

출력의 첫 묶음이 규칙의 전부를 보여 준다. 같은 + 1인데 주소가 움직인 폭이 타입마다 다르고, 그 폭은 정확히 sizeof와 같다. 그래서 (char *)p + 1과 p + 1은 서로 다른 자리를 가리킨다 — 바이트 단위로 움직이고 싶을 때 문자 포인터로 캐스트하는 관용구(103장의 뷰가 그렇게 한다)가 여기서 나온다.

두 번째 묶음은 뺄셈이다. &a[4] - &a[1]이 3이지 12가 아니라는 것 — 포인터 뺄셈은 바이트가 아니라 원소 개수를 준다. 그리고 그 결과의 타입이 ptrdiff_t인 이유도 여기 있다: 앞 포인터에서 뒤 포인터를 빼면 음수가 나올 수 있으므로 부호 있는 타입이어야 한다.

39.8.1 포인터 곁의 세 정수 타입 — ptrdiff_t·intptr_t·uintptr_t#

포인터 곁에는 정수 타입이 셋 붙어 다닌다. 이름이 비슷해 섞어 쓰기 쉬운데, 셋은 서로 다른 질문에 답한다.

★ 갈라 쓰는 규칙은 간단하다.

ptrdiff_t 는 뺄셈의 결과 타입이다. q - p 가 그 타입이고, 부호가 있는 이유는 앞에서 본 대로 앞 포인터에서 뒤 포인터를 빼면 음수가 나오기 때문이다. 크기를 담는 size_t 와 헷갈리지 않는다 — 「몇 개인가」는 size_t, 「얼마나 떨어졌는가」는 ptrdiff_t (36장). 서식도 다르다: %zu 와 %td.

intptr_t·uintptr_t 는 뺄셈과 아무 상관이 없다. 이 둘이 약속하는 것은 오직 왕복이다 — 「유효한 void * 를 이 타입에 담았다가 되돌리면 원래와 같게 비교된다」. 그 이상은 없다. 그래서 이 타입으로 옮긴 값에 산술을 하고 되돌리는 것은 약속 밖이고, 38장의 프로버넌스가 걸리는 자리다.

ptrdiff_t d1 = q - p;                              /* 원소 단위, 계약 안 */
uintptr_t d2 = (uintptr_t)q - (uintptr_t)p;        /* 바이트 단위, 계약 밖의 문턱 */

39.8.2 어디까지 허용되는가 — 산술의 계약#

포인터 산술에는 38장의 프로버넌스가 그대로 걸린다. 규칙을 실무 문장으로 줄이면 이렇다.

“만들기만 해도 계약 밖”이 낯설게 들리지만, 이것이 루프의 끝 조건을 쓰는 법을 바꾼다. p < a + n(또는 p != a + n)은 마지막 다음 주소와 견줄 뿐이라 안전하지만, p < a + n + 1은 그보다 한 칸 더 나간 주소를 계산하므로 계약 밖이다. p <= a + n 도 안 된다 — 몸통이 마지막 다음 자리를 읽고, 이어지는 p++ 가 a + n + 1 을 만든다. 뒤에서 앞으로 훑는 루프를 for (p = a + n - 1; p >= a - 1; p--)처럼 쓰는 것도 같은 이유로 위험하다 — a - 1은 배열 앞의 주소이고, 그것을 계산하는 순간 이미 계약 밖이다.

for (int *p = a + n - 1; p >= a - 1; p--)   /* a - 1 을 만든다 — 계약 밖 */
    ...

for (size_t i = n; i-- > 0; )    /* i 가 0 일 때 종료 — 주소를 만들지 않는다 */
    use(a[i]);

39.9 매개변수의 배열은 배열이 아니다#

함수 매개변수 자리에서는 규칙이 하나 더 있다. 배열로 선언해도 컴파일러가 포인터로 바꿔 버린다. 그래서 다음 셋은 컴파일러에게 완전히 같은 선언이다.

void f(int *a);
void f(int a[]);
void f(int a[10]);   /* 10 은 문서일 뿐, 검사하지 않는다 */

여러 겹 배열이라면 가장 바깥(왼쪽 첫) 차원만 벗겨진다. 안쪽 차원은 타입의 일부로 남는다.

void g(int m[3][4]);   /*  실제 타입은  int (*m)[4]  */
void h(int c[2][3][4]);/*  실제 타입은  int (*c)[3][4] */

이 사실이 눈에 보이는 자리가 셋이다.

#include <stdio.h>

/* 세 선언은 컴파일러에게 완전히 같은 것이다: 전부 int * 다.
   (매개변수 이름에 직접 sizeof 를 쓰면 gcc 가 경고하므로,
    같은 타입의 지역 변수로 한 번 받아 크기를 잰다) */
static void by_ptr(int *a)     { int *p = a; printf("  int *a      : sizeof = %zu\n", sizeof p); }
static void by_arr(int a[])    { int *p = a; printf("  int a[]     : sizeof = %zu\n", sizeof p); }
static void by_size(int a[10]) { int *p = a; printf("  int a[10]   : sizeof = %zu\n", sizeof p); }

/* 매개변수는 그냥 포인터 변수라서 다른 주소를 대입할 수도 있다 */
static int second_of(int a[10])
{
    a = a + 1;          /* 배열이라면 불가능하다 — 배열 이름에는 대입할 수 없다 */
    return a[0];
}

/* 2차원: 벗겨지는 것은 가장 바깥(왼쪽 첫) 차원뿐이다.
   int m[3][4]  ->  int (*m)[4] */
static void by_2d(int m[3][4])
{
    int (*p)[4] = m;    /* 매개변수의 진짜 타입이 이것이다 */
    printf("  int m[3][4] : sizeof = %zu (a pointer), sizeof p[0] = %zu (one row)\n",
           sizeof p, sizeof p[0]);
    printf("                m[1][2] = %d\n", m[1][2]);
}

int main(void)
{
    int arr[10] = {0,1,2,3,4,5,6,7,8,9};
    int grid[3][4] = { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} };

    printf("at the caller (a real array):\n");
    printf("  int arr[10]    : sizeof = %zu\n", sizeof arr);
    printf("  int grid[3][4] : sizeof = %zu, sizeof grid[0] = %zu\n",
           sizeof grid, sizeof grid[0]);

    printf("inside the function (all pointers):\n");
    by_ptr(arr);
    by_arr(arr);
    by_size(arr);
    by_2d(grid);

    printf("assigning to the parameter: second_of(arr) = %d\n", second_of(arr));
    printf("the original is untouched : arr[0] = %d\n", arr[0]);
    return 0;
}

at the caller (a real array):
  int arr[10]    : sizeof = 40
  int grid[3][4] : sizeof = 48, sizeof grid[0] = 16
inside the function (all pointers):
  int *a      : sizeof = 8
  int a[]     : sizeof = 8
  int a[10]   : sizeof = 8
  int m[3][4] : sizeof = 8 (a pointer), sizeof p[0] = 16 (one row)
                m[1][2] = 6
assigning to the parameter: second_of(arr) = 1
the original is untouched : arr[0] = 0

① sizeof의 값이 다르다. 호출자 쪽 arr는 진짜 배열이라 40바이트 (int 10개)이지만, 함수 안에서는 8바이트 — 포인터 하나의 크기다. 그래서 sizeof a / sizeof a[0]으로 원소 개수를 세는 관용구는 함수 안에서 통하지 않는다. 개수는 따로 받아야 한다.

gcc는 이 실수를 실제로 짚어 준다. 예제를 처음 쓸 때 받은 진단이다.

error: ‘sizeof’ on array function parameter ‘a’ will return size of ‘int *’
       [-Werror=sizeof-array-argument]
note: declared here

② 매개변수에는 대입할 수 있다. 배열 이름은 대입의 왼쪽에 올 수 없지만, 매개변수는 그냥 포인터 변수라 a = a + 1이 된다. 예제의 second_of가 그것으로, 매개변수를 옮겨 놓고 a[0]을 읽으니 원본의 둘째 원소가 나왔다 — 그리고 호출자의 arr는 아무 영향도 받지 않았다(34장의 값 복사 규칙 그대로다).

③ 2차원 배열 매개변수에는 크기 정보가 절반만 남는다. sizeof p는 8(포인터)인데 sizeof p[0]은 16 — 즉 “행 하나”의 크기는 살아 있다. 안쪽 차원이 타입에 남아 있기 때문이고, 그래서 m[1][2] 같은 접근이 제대로 계산된다. 반대로 말하면 안쪽 차원의 크기는 반드시 적어야 한다 — int m[][]는 컴파일되지 않는다.

39.10 크기가 실행 중에 정해지는 배열 — VLA#

지금까지의 배열은 크기가 컴파일 시간에 정해졌다. C99는 여기에 하나를 보탰다 — 가변 길이 배열(variable length array, VLA)이다. 크기 자리에 상수가 아닌 변수를 쓸 수 있다.

#include <stdio.h>

/* [static N]: "여기에 최소 N개짜리 배열이 온다"는 약속.
   함수 매개변수의 배열 선언자에서만 쓸 수 있다. */
static int sum3(const int a[static 3])
{
    return a[0] + a[1] + a[2];
}

/* 가변 길이 배열(VLA)을 매개변수로: 크기를 앞에서 받아 뒤에서 쓴다 */
static int sum_n(size_t n, const int a[n])
{
    int s = 0;
    for (size_t i = 0; i < n; i++) s += a[i];
    return s;
}

/* 2차원 VLA 매개변수 — 손으로 인덱스를 계산하지 않아도 된다 */
static int trace(size_t n, const int m[n][n])
{
    int s = 0;
    for (size_t i = 0; i < n; i++) s += m[i][i];
    return s;
}

int main(void)
{
    int fixed[3] = {1, 2, 3};
    printf("sum3        = %d\n", sum3(fixed));

    size_t n = 4;
    int local[n];                    /* 지역 VLA: 크기가 실행 중에 정해진다 */
    for (size_t i = 0; i < n; i++) local[i] = (int)(i * i);

    printf("sizeof local = %zu bytes (= %zu ints)\n", sizeof local, sizeof local / sizeof local[0]);
    printf("sum_n       = %d\n", sum_n(n, local));

    int grid[3][3] = { {1,2,3}, {4,5,6}, {7,8,9} };
    printf("trace       = %d\n", trace(3, grid));
    return 0;
}

sum3        = 6
sizeof local = 16 bytes (= 4 ints)
sum_n       = 14
trace       = 15

두 가지 쓰임이 있다. 첫째는 지역 변수로서의 VLA(int local[n];)로, 크기가 실행 중에 정해지는 배열이 스택 위에 잡힌다. sizeof가 실행 중에 계산되는 것도 이때가 유일하다 — 예제에서 sizeof local이 16을 돌려준 것이 그 증거다. 둘째는 매개변수로서의 VLA(const int a[n], const int m[n][n])로, 이쪽이 훨씬 유용하다. 특히 2차원 이상에서 쓸모가 크다 — m[i][j]를 그대로 쓸 수 있어, 손으로 m[i * n + j]를 계산하지 않아도 된다.

다만 지역 VLA는 실무에서 권하지 않는 쪽으로 굳어졌다.

• 크기를 통제하지 못하면 스택이 넘친다. 입력에서 온 수를 그대로 크기로 쓰면 공격자가 스택을 무너뜨릴 수 있고, 이 붕괴는 검사할 방법도 없다.
• 실패를 알릴 방법이 없다. malloc은 널을 돌려주기라도 하지만(46장), VLA는 자리가 없으면 그냥 무너진다.
• 표준에서도 지위가 흔들렸다. C99에서 필수였다가 C11에서 선택 기능이 되었다(__STDC_NO_VLA__가 정의되어 있으면 없는 구현이다). MSVC는 지원하지 않는다.
• 리눅스 커널은 2018년에 VLA를 코드베이스에서 전부 걷어냈다⁴ — 스택 사용량 예측과 성능이 이유였다.

정리하면 매개변수 자리의 VLA 표기는 쓸 만하고, 지역 VLA는 피한다. 크기가 실행 중에 정해지는 배열이 필요하면 46장의 동적 할당이 정공법이다.

39.11 매개변수의 [static N] — “최소 이만큼은 온다”#

배열 매개변수에만 쓰는 특이한 문법이 하나 더 있다.

int sum3(const int a[static 3]);   /* a 는 원소 3개 이상을 가리킨다 */

여기서 static은 저장 기간(45장)과 아무 관계가 없다. 뜻은 “이 인자로 넘어오는 포인터는 원소가 적어도 N개인 배열을 가리킨다”는 계약이다. 얻는 것은 둘이다 — 컴파일러가 그 전제로 최적화할 수 있고(미리 읽어 두기 같은), 널이나 짧은 배열을 넘기는 코드를 경고로 짚어 줄 수 있다.

두 가지를 기억하면 된다.

• 쓸 수 있는 자리는 함수 매개변수의 배열 선언자뿐이다. 지역 변수나 구조체 멤버 선언에는 쓸 수 없다. 그리고 여러 겹 배열이라면 가장 바깥 차원에만 붙는다.
• 계약을 어기면 계약 밖이다. sum3(nullptr)이나 원소 2개짜리를 넘기는 것은 정의되지 않은 동작이다 — 검사가 아니라 약속이라는 뜻이다.

39.11.1 [static 1] — “널이 아니다”를 문법으로 적는 법#

가장 자주 쓰이는 꼴은 크기 1이다.

void use(int a[static 1]);   /* a 는 유효한 객체 하나를 가리킨다 */

원소가 적어도 하나 있는 배열을 가리킨다는 말은, 곧 널 포인터가 아니고 가리키는 객체가 유효하다는 말이다. 주석으로 “널을 넘기지 마시오”라고 적는 대신 선언 자체에 적는 셈이다. 그래서 이 표기는 “널이 아님”을 기계가 읽을 수 있는 형태로 옮기는 관용구로 쓰인다.

실제로 도구가 이것을 읽는다. 이 책을 쓰며 확인한 GCC 15의 동작이다.

static int sum1(int a[static 1]) { return a[0]; }
...
(void)sum1(NULL);

warning: argument 1 null where non-null expected [-Wnonnull]
note: in a call to function ‘sum1’ declared ‘nonnull’

“nonnull로 선언된”이라는 말이 핵심이다 — 컴파일러는 [static 1]을 널 금지 속성으로 번역해 이해한다. 크기가 1보다 크면 길이까지 본다. 원소 2개짜리를 const int a[static 3] 매개변수에 넘기면 GCC는 이렇게 말한다.

warning: ‘sum3’ reading 12 bytes from a region of size 8 [-Wstringop-overread]

다만 검사가 아니라 약속이다. 널인지 실행 중에 확인해 주는 코드가 끼어드는 것이 아니고, 컴파일러가 눈으로 볼 수 있는 자리(상수 널, 크기가 알려진 배열) 에서만 짚어 준다. 포인터가 여러 함수를 거쳐 흘러온 경우에는 대개 아무 말도 못 한다. 계약을 어긴 호출은 그냥 정의되지 않은 동작이다.

39.11.2 같은 대괄호 안의 한정자 — 그것은 포인터의 한정자다#

static이 아니라 한정자를 넣는 꼴도 있다.

void f(int a[const 4]);      /* == void f(int *const a); */
void g(int a[restrict 4]);   /* == void g(int *restrict a); */

여기서 const는 가리키는 원소가 아니라 포인터 자신에 붙는다. a는 함수 안에서 다른 곳을 가리키도록 바꿀 수 없다는 뜻이지, a[0]을 못 쓴다는 뜻이 아니다. 원소를 보호하려면 const int a[4]처럼 대괄호 밖에 적어야 한다.

static 과 한정자를 한 대괄호 안에 함께 쓸 수도 있다. 표준 문법은 [static 한정자들 N]과 [한정자들 static N]을 모두 허용하므로 int a[const static 1]과 int a[static const 1]이 둘 다 유효하다 — “널이 아닌 유효한 객체를 가리키며, 그 포인터는 바뀌지 않는다”는 뜻이다.

39.12 경계 — 생사의 규칙#

배열의 안전 수칙은 단 하나이고, 타협이 없다 — 유효한 번호는 0부터 칸수−1까지다. a[5](다섯 칸짜리에서)를 읽거나 쓰는 것은 계약 밖이고, 그 칸은 남의 기억이다 — 이웃 변수일 수도, 45장에서 볼 함수 호출의 장부일 수도 있다. 읽으면 쓰레기이고, 쓰면 남의 데이터가 조용히 부서진다 — 배열 경계 침범(buffer overrun)은 C 역사상 가장 많은 사고와 보안 취약점을 낳은 단일 원인이다(이 장의 다음 절들이 배열만으로 설명되는 사고들이고, 문자열이 끼는 사고는 43–44장에서 이어진다).

경계에 관해 표준이 특별히 허락한 자리가 딱 하나 있다 — 38장에서 예고한 한 칸 지난 자리(a + 5)의 “주소를 만드는 것”까지는 합법이다(따라 가지만 않으면). 순회 관용구가 그 위에 서 있다:

for (int *it = a; it != a + 5; it += 1) { /* *it 사용 */ }

C는 왜 경계를 검사하지 않는가. 첨자 하나마다 「0 이상, 개수 미만인가」를 묻는 비교가 들어가면 가장 안쪽 루프가 그만큼 무거워지고, 무엇보다 물어볼 개수를 언어가 모른다 — 배열은 함수 경계를 넘는 순간 길이를 잃기 때문이다(앞의 매개변수 절). 검사는 그래서 프로그래머와 도구의 몫으로 남았다. 다음 절들이 그 몫을 놓쳤을 때의 모습이다.

39.13 배열에서 나는 사고들 — 보안과 기억의 문제#

배열만으로 일어나는 사고를 다섯 갈래로 나눈다. 갈래마다 무엇이 부서지는지가 다르다.

★ 다섯 갈래 모두 컴파일되고, 대개 실행도 된다. 시험에서 멀쩡하던 프로그램이 특정 입력에서만 무너지는 이유가 그것이다. 갈래마다 컴파일러와 새니타이저(18장)가 어디까지 알아채는지를 이 책이 직접 돌려 확인했다(gcc 14, clang 19, x86-64 리눅스).

39.13.1 ① 한 칸 넘침 — <= 하나#

가장 흔한 꼴은 끝 조건 하나가 틀린 것이다.

int a[5] = {3, 1, 4, 1, 5};
for (int i = 0; i <= 5; i++)   /* 「이하」 --- a[5] 까지 읽는다 */
    sum += a[i];

울타리 기둥 문제(fencepost error)라는 별명이 있다. 10미터 울타리에 1미터 간격으로 기둥을 세우면 기둥은 열 개가 아니라 열한 개다 — 칸의 수와 경계의 수는 하나 차이가 난다. 배열에서는 「원소 다섯 개」와 「경계 0~5」가 그 차이다.

이 코드를 그냥 컴파일해 돌리면 아무 일 없이 14 를 찍었다. a[5] 자리에 우연히 0이 있었을 뿐이다. 같은 코드에 대해 도구들은 이렇게 말한다.

gcc -O2 -Wall:
  warning: iteration 5 invokes undefined behavior [-Waggressive-loop-optimizations]
  note: within this loop

gcc -fsanitize=address, 실행:
  ERROR: AddressSanitizer: stack-buffer-overflow on address …
  READ of size 4 at … thread T0
    #0 … in main …:7
    This frame has 1 object(s):
      [32, 52) 'a' (line 4) <== Memory access at offset 52 overflows this variable

ASan의 마지막 줄을 읽어 보자. a 는 프레임 안의 32번째 바이트부터 52번째 바이트 앞까지 (20바이트, int 다섯)를 차지하는데, 접근은 52번째 바이트에서 일어났다 — 정확히 한 칸 너머다. 경고는 최적화(-O1 이상)를 켜야 나왔고 clang 19는 이 꼴에 경고하지 않았다. 경고에 기대지 말고 끝 조건을 < 개수 로 적는 습관과 ASan을 함께 쓰는 이유다.

39.13.2 ② 쓰기 넘침 — 이웃을 덮는다#

넘쳐 쓴 바이트는 사라지지 않는다. 그 자리에 있던 다른 것을 덮는다. 진짜 넘침은 계약 밖이라 결과를 시연으로 보일 수 없으므로, 큰 배열 하나를 「이름 8바이트 + 권한 표시 4바이트」라는 두 변수처럼 나눠 쓰는 모형을 만들었다. 모형 안의 모든 접근은 한 배열 안에서 일어나므로 계약 안이다.

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

/* 진짜 넘침은 계약 밖이라 시연할 수 없다. 그래서 큰 배열 하나를
   「이름 8칸 + 권한 표시 4칸」의 두 변수처럼 나눠 쓰는 모형을 만든다.
   아래의 모든 접근은 frame 안에서 일어나므로 계약 안이다. */
enum { NAME = 8, FLAG = 4 };
static unsigned char frame[NAME + FLAG];

static int flag(void)
{
    int f;
    memcpy(&f, frame + NAME, sizeof f);
    return f;
}

/* 길이를 묻지 않고 받은 만큼 쓰는 복사 --- strcpy 와 같은 꼴 */
static void copy_unchecked(unsigned char *dst, const char *src)
{
    while (*src)
        *dst++ = (unsigned char)*src++;
}

/* 그릇의 크기를 함께 받는 복사 */
static size_t copy_checked(unsigned char *dst, size_t cap, const char *src)
{
    size_t n = 0;
    while (src[n] && n < cap) {
        dst[n] = (unsigned char)src[n];
        n++;
    }
    return n;
}

int main(void)
{
    puts("[1] a short name stays inside its 8 bytes");
    memset(frame, 0, sizeof frame);
    copy_unchecked(frame, "kim");
    printf("flag = %d\n", flag());

    puts("\n[2] a long name runs into the neighbour");
    memset(frame, 0, sizeof frame);
    copy_unchecked(frame, "abcdefgh\x01");
    printf("flag = %d   <- nobody wrote to flag on purpose\n", flag());

    puts("\n[3] the same input, copied with the capacity");
    memset(frame, 0, sizeof frame);
    size_t n = copy_checked(frame, NAME, "abcdefgh\x01");
    printf("copied %zu bytes, flag = %d\n", n, flag());
    return 0;
}

[1] a short name stays inside its 8 bytes
flag = 0

[2] a long name runs into the neighbour
flag = 1   <- nobody wrote to flag on purpose

[3] the same input, copied with the capacity
copied 8 bytes, flag = 0

둘째 묶음이 핵심이다. 아홉 바이트짜리 이름이 8바이트 그릇을 넘쳐 권한 표시의 첫 바이트에 0x01 을 썼고, 아무도 일부러 건드리지 않은 flag 가 1이 되었다(작은 끝 순서라 첫 바이트가 값의 아래 자리다 — 3장). 길이를 묻지 않는 복사 함수가 하는 일은 「받은 만큼 쓴다」뿐이고, 그릇의 크기는 그 함수의 시야에 없다. 셋째 묶음처럼 크기를 함께 받으면 같은 입력에서도 그릇 밖으로 나가지 않는다.

실제 프로그램에서 배열 바로 뒤에 무엇이 있는지는 컴파일러가 정한다. 지역 배열이라면 다른 지역 변수, 컴파일러가 심어 둔 카나리(canary, 넘침을 알아채려 심은 값), 그리고 더 멀리에는 함수가 끝나면 돌아갈 주소가 있다. 마지막 것을 덮을 수 있으면 공격자는 입력만으로 프로그램이 어디로 돌아갈지를 정한다 — 그 그림은 스택을 배운 뒤 45장에서 보고, 그 공격과 방어의 역사는 44장에서 이어진다.

39.13.3 ③ 읽기 넘침 — 새어 나가는 기억#

넘쳐 읽기만 하면 아무것도 부서지지 않는다. 그래서 더 오래 숨는다. 잃는 것은 데이터의 온전함이 아니라 비밀이다 — 배열 너머에 있던 값이 출력으로 실려 나간다.

39.13.4 ④ 음수 첨자 — 반쪽짜리 검사#

검사를 했는데도 뚫리는 꼴이 있다.

int table[8];
void set(int i, int v)
{
    if (i < 8)          /* 위쪽만 막았다 */
        table[i] = v;
}

i 가 부호 있는 정수이므로 -1 이 들어오면 -1 < 8 은 참이고, table[-1], 곧 배열 바로 앞의 4바이트에 쓴다. 입력을 atoi 같은 것으로 받아 그대로 넘기면 공격자가 고를 수 있는 값이다. 이 책이 -1 을 넣어 돌려 보았다.

gcc -fsanitize=address, 실행:      ok          ← 아무것도 잡지 못했다
gcc -fsanitize=bounds,  실행:
  runtime error: index -1 out of bounds for type 'int [8]'

★ ASan이 놓쳤다. ASan은 전역 배열의 뒤쪽에 독을 칠한 칸(redzone)을 붙이고 그 칸을 밟는지 보는데, 이 배열의 바로 앞은 독이 칠해지지 않은 다른 정상 기억이었다. 뒤로 넘치는 것은 잘 잡지만, 앞으로 넘쳐 다른 정상 기억에 닿으면 놓친다. 반면 UBSan의 -fsanitize=bounds 는 배열의 타입(int [8])을 알고 첨자를 직접 비교하므로 잡았다. 두 도구는 보는 것이 다르다 — 둘 다 켜 두는 이유다.

처방은 둘 중 하나다. 양쪽을 다 검사하거나(if (i >= 0 && i < 8)), 첨자를 부호 없는 size_t 로 받는다. 후자라면 -1 은 아주 큰 수가 되어 i < 8 하나로 걸러진다. 다만 부호 있는 값이 부호 없는 타입으로 바뀌는 자리에서 생기는 다른 함정은 30장에서 보았다 — 변환이 일어나는 자리를 알고 쓰는 것이 전제다.

39.13.5 ⑤ 초기화하지 않은 배열 — 남이 쓰던 기억#

앞의 초기화 표에서 지역 배열은 초기값을 적지 않으면 불확정이라고 했다. 그 칸에는 같은 자리를 먼저 쓰던 함수가 남긴 바이트가 그대로 있다. 그 배열을 다 채우지 않은 채 파일에 쓰거나 네트워크로 보내면, 남이 쓰던 값 — 때로는 비밀번호나 키의 조각 — 이 함께 나간다. 운영체제 커널이 사용자에게 돌려주는 구조체·배열에서 이런 정보 누출이 해마다 보고되는 이유다.

컴파일러가 얼마나 알아채는지 시험했다.

마지막 줄이 실무의 모습이다. 채우는 함수가 다른 파일에 있으면 컴파일러는 그 함수가 무엇을 채우는지 볼 수 없다. 그래서 습관이 먼저다 — 지역 배열은 = {} 로 시작한다. 안전망도 있다. gcc 12 이후와 clang에서 -ftrivial-auto-var-init=zero 를 주면 초기화하지 않은 지역 변수를 컴파일러가 0으로 채운다. 리눅스 커널이 이 장치를 설정 하나로 켤 수 있게 해 둔 것도 이런 누출을 통째로 막기 위해서다. 다만 0이 맞는 값이라는 보장은 없으므로 버그를 숨기는 장치이지 고치는 장치가 아니다.

39.14 방어의 층 — 무엇을 켜고 무엇을 습관으로 삼는가#

다섯 갈래를 막는 수단은 하나가 아니라 여러 층이다. 한 층이 놓친 것을 다음 층이 잡는다.

★ 표의 위쪽일수록 비용이 적고, 아래쪽일수록 늦게 잡는다. 컴파일 경고와 새니타이저는 시험에서 지나간 경로만 보고, 배포 빌드의 안전망은 공격을 멈출 뿐 버그를 고치지 않는다. 그래서 가장 확실한 층은 맨 위의 습관이다 — 그 습관을 부품으로 굳히는 것이 이 책 13부의 일이다.

연속된 기억을 다루게 됐다. 무너짐을 배웠으니 「배열과 포인터는 결국 같은 것인가」가 궁금할 텐데, 그 물음은 41장에서 규칙으로 닫는다 — 다차원까지 본 뒤라야 전체 그림이 그려지기 때문이다. 다음 장은 배열을 겹쳐 쌓는다 — 원소가 다시 배열인 경우, 곧 다차원 배열(multidimensional array)이다. 여기서 배운 “한 걸음은 원소 하나”가 그대로 적용되는데, 그 원소가 행 전체인 것이다.