35 대입과 부수효과

35.1 대입은 문장이 아니라 수식이다#

x = 1은 명령처럼 보이지만 수식이다 — 값을 낳는다. 그 값은 “왼쪽 타입으로 변환된, 대입된 값”이고, 그래서 다른 수식 안에 넣을 수 있다.

/* 대입이 하는 두 가지 — 값을 내놓는 일과 객체를 바꾸는 일. */
#include <stdio.h>

static int calls;

static int where(void)      /* 좌변의 자리를 정하는 계산도 '평가'된다 */
{
    calls++;
    printf("  where() called - it picks the slot on the left\n");
    return 1;
}

static int what(void)
{
    calls++;
    printf("  what() called - it makes the value on the right\n");
    return 42;
}

int main(void)
{
    int a[3] = {0, 0, 0};

    /* ── ① 대입은 수식이다 — 값을 낳는다 ────────────────────── */
    int x, y;
    x = (y = 7) + 1;                  /* y = 7 이라는 수식의 값은 7 */
    printf("x = (y = 7) + 1  ->  x=%d y=%d\n", x, y);

    int p, q, r;
    p = q = r = 5;                    /* 오른쪽 결합 — r 부터 채워진다 */
    printf("p = q = r = 5    ->  p=%d q=%d r=%d\n", p, q, r);

    /* ── ② 좌변도 평가된다 ──────────────────────────────────── */
    puts("\nrunning a[where()] = what(); :");
    calls = 0;
    a[where()] = what();
    printf("  both functions ran (%d calls), a[1]=%d\n", calls, a[1]);
    puts("  which one runs first is unspecified by the standard.");

    /* ── ③ 복합 대입은 왼쪽을 한 번만 평가한다 ──────────────── */
    puts("\nrunning a[where()] += 1; :");
    calls = 0;
    a[where()] += 1;
    printf("  where() call count: %d (spelled out as a[where()] = a[where()] + 1 it would be 2)\n",
           calls);
    printf("  a[1] = %d\n", a[1]);

    /* ── ④ 대입은 왼쪽 타입으로 '변환된 값'을 내놓는다 ──────── */
    char c;
    int wide = 321;
    int back = (c = (char)wide);      /* 좁혔다가 다시 넓히면 원래 값이 아니다 */
    printf("\nchar c = (char)321 -> c=%d, value of (c = ...) = %d\n", c, back);

    double d;
    int truncated = (int)(d = 3.9);   /* 실수 → 정수는 0 쪽으로 버린다 */
    printf("d = 3.9 -> d=%.1f, (int)d = %d\n", d, truncated);

    /* ── ⑤ 부수효과는 문장을 나눈다 ─────────────────────────── */
    int i = 0;
    a[i] = 10;
    i++;                              /* 한 수식에 섞지 않는다 */
    a[i] = 20;
    printf("\nthe safe form: a[0]=%d a[1]=%d i=%d\n", a[0], a[1], i);
    return 0;
}

x = (y = 7) + 1  ->  x=8 y=7
p = q = r = 5    ->  p=5 q=5 r=5

running a[where()] = what(); :
  where() called - it picks the slot on the left
  what() called - it makes the value on the right
  both functions ran (2 calls), a[1]=42
  which one runs first is unspecified by the standard.

running a[where()] += 1; :
  where() called - it picks the slot on the left
  where() call count: 1 (spelled out as a[where()] = a[where()] + 1 it would be 2)
  a[1] = 43

char c = (char)321 -> c=65, value of (c = ...) = 65
d = 3.9 -> d=3.9, (int)d = 3

the safe form: a[0]=10 a[1]=20 i=1

출력의 첫 두 줄이 그 확인이다. x = (y = 7) + 1에서 (y = 7)이라는 수식의 값은 7이고, 거기에 1을 더해 x는 8이 된다. p = q = r = 5가 셋 다 5로 만드는 것도 같은 원리다 — 대입은 오른쪽 결합이라 p = (q = (r = 5))로 묶이고, 안쪽 대입의 값이 바깥으로 전달된다.

한 가지는 못박아 두자. 대입의 결과는 좌변값이 아니다. (a = b) = c는 컴파일되지 않는다. C++와 다른 점이고, “대입은 값을 낳지만 자리를 낳지는 않는다”고 기억하면 된다.

35.2 대입이 하는 일은 셋이다#

대입 E1 = E2 를 표준의 어휘로 갈라 보면 세 가지 평가다. 둘이 아니다 — 왼쪽도 계산되기 때문이다.

1. 왼쪽의 값 계산 — E1 을 평가해 어느 객체에 쓸 것인지를 정한다. 표준은 좌값(lvalue) 수식의 값 계산에 「가리켜진 객체의 정체를 정하는 일」이 포함된다고 못박는다(§5.1.2.3).
2. 오른쪽의 값 계산 — E2 를 평가하고, 그 값을 대입 수식의 타입으로 변환한다(§6.5.17.2p2).¹
3. 저장이라는 부수효과 — 그 값을 앞에서 정한 자리에 써넣는다.

셋으로 갈라야 하는 까닭은 그 사이의 순서가 저마다 다르기 때문이다.

「순서 없음」은 「둘 중 하나가 먼저인데 어느 쪽인지 모른다」가 아니다. 그보다 세다 — 표준은 A 가 B 보다 먼저도 뒤도 아닐 수 있다고 말한다(§5.1.2.4p3). 그래서 두 계산이 뒤섞여 일어나도 규격에 맞는다. 「어느 쪽이 먼저인지만 모른다」에 해당하는 말은 따로 있다 — 부정 순서(indeterminately sequenced) 이고, 함수 호출의 본문이 그 관계에 놓인다(§6.5.3.3p8). 그래서 f() 와 g() 의 호출끼리는 뒤섞이지 않지만, 함수를 부르지 않는 두 계산은 뒤섞일 수 있다.

여기에 §6.5.1p2 의 규칙이 얹히면 계약이 완성된다.

35.3 좌변도 평가된다#

초보자가 가장 자주 놓치는 사실이다. =의 왼쪽은 “값”이 아니라 어디에 쓸지를 정하는 계산이고, 그 계산도 실행된다.

예제의 둘째 묶음이 그 확인이다. a[where()] = what();을 실행하면 where()와 what()이 둘 다 불린다. 좌변은 “그 자리를 어떻게 찾는가”를 계산하고, 우변은 “무엇을 쓸 것인가”를 계산한다.

그러면 어느 쪽이 먼저 계산되는가. 표준은 정하지 않는다. 컴파일러는 우변을 먼저 계산해도 되고 좌변을 먼저 계산해도 된다. 여기서는 두 계산이 모두 함수 호출이라 서로 뒤섞이지는 않는다 — 앞 절에서 본 부정 순서다. 순서만 모를 뿐 한쪽이 끝나야 다른 쪽이 시작한다. 함수 호출이 아닌 두 계산이라면 그런 보호도 없다(순서 없음). 어느 쪽이든 두 계산에 부수효과가 있으면 결과가 달라질 수 있고, 그것이 다음 절의 함정이다.

35.4 복합 대입 — 왼쪽을 한 번만 평가한다#

E1 op= E2는 E1 = E1 op E2와 같지 않다. 표준은 “E1을 한 번만 평가한다”는 것만 다르다고 말하는데, 이 한 줄의 차이가 실무에서 크다.

예제의 셋째 묶음을 보라. a[where()] += 1;에서 where()는 한 번만 불린다. 풀어 쓴 a[where()] = a[where()] + 1;이었다면 두 번 불려, 두 개의 다른 칸을 읽고 쓰는 사고가 났을 것이다.

복합 대입의 종류는 열 가지다 — += -= *= /= %= <<= >>= &= ^= |=. 각 연산의 회색지대는 그대로 따라온다는 점을 잊지 말자. x /= 0은 여전히 계약 밖이고, x <<= 40도 그렇다(29장).

35.5 어디서부터 계약 밖인가#

이제 유명한 수식들을 판정할 수 있다. 아래 코드는 실행 결과를 싣지 않는다 — 계약 밖 수식의 결과를 인쇄하면 “이 컴파일러에서는 이렇게 나온다”는 잘못된 지식을 남기기 때문이다(54장의 원칙).

int i = 0, a[4] = {0};

i = i++;              /* 계약 밖 — i 를 두 번 바꾼다 */
a[i] = i++;           /* 계약 밖 — 바꾸면서, 자리를 정하려고 읽는다 */
i = ++i + i++;        /* 계약 밖 — 두 번 바꾼다 */
a[i++] = i;           /* 계약 밖 — 같은 이유 */
printf("%d %d", i++, i++);  /* 계약 밖 — 인자 사이에 시퀀스 포인트가 없다 */

반면 다음은 정상이다.

i = i + 1;            /* 읽기는 새 값을 정하기 위한 것 */
a[i] = i;             /* 바꾸는 객체는 a[i] 하나, i 는 읽기만 한다 */
i++, i++;             /* 쉼표 *연산자* 사이에는 시퀀스 포인트가 있다 */
x = (i++) && (i++);   /* && 사이에도 있다 */
f(i++);               /* 인자가 하나면 겹치지 않는다 */

a[i] = ++i + i++;        /* 계약 밖. "무슨 값이 나오는가"를 묻는 것 자체가 틀렸다 */

int t = i + 1;            /* 의도가 무엇이었든, 먼저 값을 정하고 */
i = t + 1;                /* 그다음 객체를 바꾼다 */
a[i] = t;

35.6 대입에 숨는 변환#

대입은 우변의 값을 왼쪽 타입으로 변환해서 넣는다. 30장의 변환 규칙이 여기서 조용히 적용되고, 조용하다는 점이 위험하다.

예제의 넷째 묶음이 그것이다. c = (char)321에서 값은 잘려 65가 되고, 대입 수식의 값도 그 65다 — 넣은 값이 아니라 들어간 값이 나온다. d = 3.9 뒤에 (int)d가 3인 것도 같은 이야기다(0을 향해 버린다, 29장).

-Wconversion을 켜면 이런 자리를 컴파일러가 짚어 준다. 경고가 많이 나오는 옵션이라 프로젝트 전체에 켜기는 부담스럽지만, 새 코드에는 켜 두는 것이 좋은 습관이다.

제6부가 끝났다 — 타입의 갈래를 펴고 값을 벼리고(27–30장), 흐름을 다스리고 (31–33장), 함수와 대입의 의미까지 갖췄다(34–35장). 다음 부는 이 책의 두 번째 산, 기억이다. 3장의 사물함 복도로 돌아가, 이번에는 C의 문법으로 그 복도를 걷는다.