52 수식과 연산자

52.1 수학의 수식, C의 수식#

「수식」과 「연산자」는 수학에서 먼저 배운 낱말이다. C가 그 낱말을 빌려 왔지만 뜻은 꽤 달라졌다. 차이를 먼저 분명히 해 두면 이 장의 나머지가 모두 그 차이의 귀결로 읽힌다.

수학에서 수식은 수와 변수와 연산 기호를 규칙에 맞게 엮은 것이고, 하나의 값을 나타낸다. 2 + 3 × 4 는 14를 나타낸다. 연산자는 피연산자를 받아 결과 하나를 내는 함수다 — 덧셈은 실수 둘을 받아 실수 하나를 내는 사상이다. 그리고 수식을 「계산한다」고 해서 세상의 무엇이 바뀌지는 않는다. x + 1 을 백 번 계산해도 x 는 그대로이고, 언제 계산하든 어떤 순서로 계산하든 값은 같다. 그래서 수학에서 x = x + 1 은 틀린 등식이다.

C에서 수식은 같은 모양을 하고 있지만 네 가지가 다르다.

★ 둘째 줄과 넷째 줄이 만나는 자리가 C 수식의 가장 까다로운 곳이다. 수식이 무언가를 바꾸고, 그 바뀌는 시점이 다 정해져 있지 않다면 — 같은 객체를 한 수식 안에서 두 번 바꾸는 코드의 뜻은 무엇이 되는가. 이 장은 그 물음에 표준이 준 답으로 끝난다.

52.2 엄밀한 정의 — 수식, 연산자, 피연산자#

표준은 수식을 이렇게 정의한다.

“ 수식(expression)은 연산자와 피연산자의 나열로서, 값의 계산을 지정하거나, 객체나 함수를 지칭하거나, 부수효과를 일으키거나, 그 몇 가지를 함께 하는 것이다. 연산자의 피연산자들의 값 계산은 그 연산자 결과의 값 계산보다 먼저 순서 지어진다.¹ ”

「또는」으로 이어진 네 갈래가 앞 표의 첫 줄이다. 예를 하나씩 붙이면 이렇다.

정의의 둘째 문장도 짚어 둔다. (a + b) * c 에서 a + b 의 값과 c 의 값이 정해진 뒤에야 곱셈의 값이 정해진다 — 당연해 보이지만, 표준이 연산자와 피연산자 사이에 보장하는 순서는 이것뿐이다. a + b 와 c 가운데 무엇을 먼저 계산할지는 말하지 않는다.

연산자와 피연산자는 표준이 낱말(토큰)을 분류하는 자리에서 정의한다.

“ 구두점(punctuator)은 독자적인 문법적·의미적 뜻이 있는 기호다. 문맥에 따라 수행할 연산(그 결과로 값이나 함수 지시자를 내거나, 부수효과를 일으키거나, 그 몇 가지를 함께 하는)을 지정할 수 있는데, 그 경우 그것을 연산자(operator)라 한다(어떤 문맥에는 다른 꼴의 연산자도 있다). 피연산자(operand)는 연산자가 작용하는 대상이다.² ”

이 정의에서 실용적인 사실이 셋 나온다.

• 같은 기호가 문맥에 따라 연산자이기도 하고 아니기도 하다. f(a, b) 의 쉼표는 인자를 가르는 구분자이고, (a, b) 의 쉼표는 쉼표 연산자다. int *p 의 * 는 선언의 일부이고, *p = 0 의 * 는 간접 연산자다. int x = 1; 의 = 는 초기화의 표시이지 대입 연산자가 아니다. 겉모양이 같다고 같은 규칙이 걸리지 않는다 — 뒤의 시퀀스 포인트 표에서 이 구별이 그대로 차이가 된다.
• 「다른 꼴의 연산자」가 있다. sizeof·alignof 처럼 낱말로 된 연산자, 그리고 ( )(함수 호출)· [ ](첨자)·? :(조건)처럼 짝을 이루는 연산자다.
• 피연산자의 개수로 연산자를 나눈다. 하나를 받으면 단항(-x, !b, *p, &x, sizeof x), 둘이면 이항(a + b, x = y), 셋이면 삼항이다. C의 삼항 연산자는 ? : 하나뿐이다.

수식은 되풀이해 쌓인다. 가장 작은 수식 — 표준이 일차 수식(primary expression)이라 부르는 식별자·상수·문자열 리터럴·괄호로 싼 수식 — 이 잎이 되고, 연산자가 수식들을 피연산자로 받아 더 큰 수식을 만든다. a + b * c 는 b * c 라는 수식을 피연산자로 받는 덧셈이다. 그래서 수식은 나무 모양이고, 그 나무의 모양을 정하는 것이 우선순위와 결합이다(표준의 말로 「연산자와 피연산자의 묶음은 문법이 정한다」, §6.5.1p3). 그리고 다른 수식의 일부가 아닌 가장 바깥의 수식 — 문장 x = a + b; 의 x = a + b 전체 — 을 완전 수식(full expression)이라 한다(§6.8.1p4). 이 낱말이 시퀀스 포인트에서 다시 나온다.

52.3 부수효과 — 값 말고 일어나는 일#

수학의 수식과 C의 수식을 가르는 결정적인 낱말이 부수효과(side effect)다. 표준의 정의는 이렇다.

“ volatile 객체에 접근하는 것, 객체를 수정하는 것, 파일을 수정하는 것, 또는 그런 일 가운데 하나를 하는 함수를 부르는 것은 모두 부수효과이고, 실행 환경의 상태를 바꾸는 일이다. 수식의 평가는 일반적으로 값 계산과 부수효과의 시작을 함께 포함한다.³ ”

목록은 넷이다. 이 책에서 이미 만난 것들로 바꾸면 이렇다.

C의 연산자 가운데 스스로 부수효과를 일으키는 것은 셋뿐이다 — 대입(= 과 복합 대입), 증감(++·--), 함수 호출. 연산자가 아닌 예외가 하나 있다. 표의 셋째 줄대로 volatile 객체의 값을 읽는 것 자체가 부수효과이므로, volatile int *reg 에서 *reg 를 읽기만 하는 수식도 부수효과를 품는다. 나머지 연산자(+, *, <, &&, ?: …)는 수학의 연산자처럼 값만 계산한다. 다만 그 피연산자 안에 부수효과가 있으면 수식 전체는 부수효과를 품는다.

#include <stdio.h>

static int calls;

static bool hit(bool v)          /* 불릴 때마다 calls 를 바꾼다 --- 부수 효과 */
{
    calls++;
    return v;
}

int main(void)
{
    puts("[1] an expression has a value, and may also do something");
    int x = 0;
    int v = (x = 5) + 1;        /* 대입식의 값은 5, 그리고 x 가 바뀐다 */
    printf("v = %d, x = %d\n", v, x);

    int i = 3;
    int post = i++;             /* 값은 3, 효과는 i 를 4 로 */
    int pre  = ++i;             /* 값은 5, 효과는 i 를 5 로 */
    printf("post = %d, pre = %d, i = %d\n", post, pre, i);

    puts("\n[2] && skips its right side --- and the side effects in it");
    calls = 0;
    bool r = hit(false) && hit(true);
    printf("result %d, hit() called %d time(s)\n", r, calls);
    calls = 0;
    r = hit(true) || hit(false);
    printf("result %d, hit() called %d time(s)\n", r, calls);

    puts("\n[3] the comma operator: left, then right; value of the right");
    int c = (calls = 0, calls + 10);
    printf("c = %d\n", c);

    puts("\n[4] one change per object between sequence points");
    int k = 0;
    k++, k++;                   /* 쉼표 연산자 --- 사이에 시퀀스 포인트 */
    k++;                        /* 완전 수식이 끝날 때마다 시퀀스 포인트 */
    k++;
    printf("k = %d\n", k);
    return 0;
}

[1] an expression has a value, and may also do something
v = 6, x = 5
post = 3, pre = 5, i = 5

[2] && skips its right side --- and the side effects in it
result 0, hit() called 1 time(s)
result 1, hit() called 1 time(s)

[3] the comma operator: left, then right; value of the right
c = 10

[4] one change per object between sequence points
k = 4

첫 묶음이 「값」과 「효과」를 갈라 보여 준다. (x = 5) + 1 에서 대입식의 값은 5이고 그래서 v 는 6이 되었으며, 그와 별도로 x 를 5로 바꾸는 효과가 일어났다. i++ 의 값은 바꾸기 전의 3, ++i 의 값은 바꾼 뒤의 5다. 둘째 묶음은 &&·|| 가 오른쪽을 평가하지 않으면 그 안의 부수효과(여기서는 calls 를 늘리는 함수 호출)도 일어나지 않는다는 것을 보인다. 셋째 묶음의 쉼표 연산자는 왼쪽을 평가한 뒤 그 값을 버리고 오른쪽의 값을 낸다.

정의의 마지막 문장 「부수효과의 시작」에 주목하자. 평가는 부수효과를 시작할 뿐이고, 그것이 언제 끝나는지는 다른 규칙이 정한다. x = 5 의 값 5는 지금 정해져도, x 의 메모리에 5가 실제로 써지는 순간은 그 뒤 어딘가일 수 있다. 이 틈이 이 장 뒤쪽 「평가 순서와 시퀀스 포인트」의 출발점이다.

52.4 수식이 가진 네 가지#

C의 수식은 언제나 네 가지를 함께 가진다. 이 넷을 갈라 놓고 보는 습관이 이 장의 전부라 해도 좋다.

값 범주라는 낱말이 낯설 텐데, 실은 이미 쓰고 있었다. 대입의 왼쪽에 올 수 있는 것이 좌변값이고(35장), &를 붙일 수 있는 것도 좌변값이다(36장). 배열 이름은 좌변값이지만 대입의 왼쪽에는 올 수 없는 특수한 경우다(39장).

수식의 잎사귀인 상수를 적는 표기 — 진법·접두어·접미어·이스케이프·문자열 리터럴 — 는 21장 「상수를 적는 모든 방법」에 한자리로 모아 두었고, 정수 상수의 타입이 정해지는 규칙은 28장에 있다. 이 장은 그 잎사귀를 엮는 연산자를 다룬다.

52.5 우선순위와 결합#

아래 표는 연산자 묶음을 우선순위가 높은 것부터 늘어놓았다 — 위쪽 줄의 연산자일수록 더 강하게 묶는다. 결합 방향은 같은 세기의 연산자가 나란히 있을 때 어느 쪽부터 묶느냐다 — a - b - c가 (a - b) - c인 것은 왼쪽 결합이기 때문이고, a = b = 0이 a = (b = 0)인 것은 오른쪽 결합이기 때문이다.

52.6 우선순위 때문에 자주 미끄러지는 자리들#

표는 표일 뿐이다. 같은 것을 돌려 보면 훨씬 빨리 손에 붙는다 — 아래 시연은 괄호를 넣은 것과 안 넣은 것을 나란히 찍는다.

// 우선순위·결합성·짧은 회로를 눈으로 확인한다.
// 표를 외우는 대신, 괄호를 넣은 것과 안 넣은 것을 나란히 찍어 본다.
#include <stdio.h>

static int calls = 0;

static int loud(int value)          // 불릴 때마다 흔적을 남긴다
{
    calls += 1;
    return value;
}

int main(void)
{
    int x = 6;

    puts("1. precedence --- what binds tighter");
    printf("  2 + 3 * 4      = %d   (same as 2 + (3 * 4))\n", 2 + 3 * 4);
    printf("  (2 + 3) * 4    = %d\n", (2 + 3) * 4);
    printf("  1 << 2 + 3     = %d   (same as 1 << (2 + 3): + binds tighter than <<)\n",
           1 << (2 + 3));

    puts("2. the classic trap --- == binds tighter than &");
    printf("  x & 1 == 0     is read as x & (1 == 0) = %d\n", x & (1 == 0));
    printf("  what was meant: (x & 1) == 0         = %d\n", (x & 1) == 0);

    puts("3. associativity --- which side groups first");
    printf("  10 - 4 - 3     = %d   (left to right: (10 - 4) - 3)\n", 10 - 4 - 3);
    int a, b;
    a = b = 5;                      // 대입은 오른쪽부터 묶인다
    printf("  a = b = 5      gives a=%d b=%d   (right to left)\n", a, b);

    puts("4. comparison does not chain the way mathematics does");
    printf("  1 < 2 < 3      = %d   ((1 < 2) is 1, and 1 < 3 is true)\n", (1 < 2) < 3);
    printf("  3 > 2 > 1      = %d   ((3 > 2) is 1, and 1 > 1 is false)\n", (3 > 2) > 1);

    puts("5. short circuit --- the right side may never run");
    calls = 0;
    if (0 && loud(1))
        puts("  not reached");
    printf("  after 0 && loud(1): loud() was called %d time(s)\n", calls);
    calls = 0;
    if (1 || loud(1))
        (void)0;
    printf("  after 1 || loud(1): loud() was called %d time(s)\n", calls);
    return 0;
}

1. precedence --- what binds tighter
  2 + 3 * 4      = 14   (same as 2 + (3 * 4))
  (2 + 3) * 4    = 20
  1 << 2 + 3     = 32   (same as 1 << (2 + 3): + binds tighter than <<)
2. the classic trap --- == binds tighter than &
  x & 1 == 0     is read as x & (1 == 0) = 0
  what was meant: (x & 1) == 0         = 1
3. associativity --- which side groups first
  10 - 4 - 3     = 3   (left to right: (10 - 4) - 3)
  a = b = 5      gives a=5 b=5   (right to left)
4. comparison does not chain the way mathematics does
  1 < 2 < 3      = 1   ((1 < 2) is 1, and 1 < 3 is true)
  3 > 2 > 1      = 0   ((3 > 2) is 1, and 1 > 1 is false)
5. short circuit --- the right side may never run
  after 0 && loud(1): loud() was called 0 time(s)
  after 1 || loud(1): loud() was called 0 time(s)

넷째 묶음을 눈여겨보라. 1 < 2 < 3 은 참인데 3 > 2 > 1 은 거짓이다. 수학의 버릇대로 읽으면 둘 다 참이어야 하지만, C 는 왼쪽부터 둘씩 묶으며 비교의 결과를 0 또는 1이라는 수로 바꾸어 다음 비교에 넘긴다. 다섯째 묶음은 && 와 || 의 단락 평가다 — 왼쪽만으로 답이 정해지면 오른쪽은 아예 평가되지 않는다. 그래서 오른쪽에 「반드시 해야 하는 일」을 두면 그 일이 조용히 사라진다(33장).

특히 시연 앞 표의 첫 줄(a & b == c)은 C의 유명한 설계 흠으로 꼽힌다 — 비트 연산자가 비교 연산자보다 약하게 묶이는 것은 초기 C가 &&·||를 갖기 전의 흔적이다. 그래서 비트 검사에는 괄호가 사실상 필수다. 표준도 각주에서 a<b<c가 수학과 다르게 읽힌다는 것을 따로 짚어 둔다.

52.7 전위와 후위 — 같은 일을 하고 다른 값을 준다#

++와 --는 앞에 붙일 수도 뒤에 붙일 수도 있다. 앞에 붙인 전위와 뒤에 붙인 후위, 두 꼴의 차이를 정확히 아는 것이 C 수식을 읽는 힘의 상당 부분이라, 여기서 한자리에 모아 본다.

52.7.1 표준이 정한 계약#

차이는 오직 「수식이 내놓는 값」 하나뿐이다. 객체가 바뀌는 결과는 완전히 같다. 그래서 값을 쓰지 않는 자리 — for 의 세 번째 칸, 문장 하나로 쓰는 i++; — 에서는 둘이 뜻까지 완전히 같다.

52.7.2 값이 정해지는 때와 메모리가 바뀌는 때#

여기가 이 절의 핵심이다. x++ 에서 「값이 정해지는 사건」과 「메모리가 바뀌는 사건」은 다른 사건이고, 표준은 그 둘의 순서만 정한다.

읽는 법이 중요하다. 표준은 상대 순서만 못박았지 시각을 못박지 않았다.

i = i++ + 1;                 /* 계약 밖 — 정의되지 않은 동작 */
a[i] = i++;                  /* 계약 밖 */
printf("%d %d\n", i++, i++); /* 계약 밖 */

52.7.3 「전위가 빠르다」는 이야기의 진실#

오늘의 컴파일러에서는 어떤가. 이 x86-64 기계의 gcc 14 와 clang 19 로 재어 보면 답이 분명하다.

읽어 낼 것은 둘이다. 첫째, C 의 스칼라에 대해서는 속도 차이가 없다. 값을 쓰지 않으면 컴파일러가 같은 코드를 낸다. 둘째, 값을 쓰는 자리에서 차이가 나더라도 그것은 「후위가 느리다」가 아니라 「두 코드가 다른 계산을 한다」는 뜻이다 — 하나는 옛 값을, 하나는 새 값을 필요로 하니까.

52.7.4 C++ 에서는 두 가지가 달라진다#

52.8 연산자별 계약#

이제 연산자의 계약을 우선순위 표의 묶음별로 하나씩 본다. 각 표는 다섯 칸이다.

• 피연산자 — 표준이 요구하는 것. 어기면 컴파일러가 진단해야 한다(제약 위반).
• 결과 — 값의 타입, 그리고 좌변값인지.
• 회색지대 — 56장의 세 낱말로 구분한다. UB(undefined behaviour)는 정의되지 않은 동작, 미지정은 몇 갈래 중 하나이되 어느 쪽인지 정해지지 않은 것, 구현 정의는 구현이 정해 문서로 밝히는 것.
• 자세히 — 그 연산자를 서사로 다룬 장.

52.9 후위 연산자#

52.10 단항 연산자#

52.11 산술 연산자#

정수 나눗셈은 0을 향해 버린다(C99 이후 확정). 그래서 몫이 표현 가능한 한 (a/b)*b + a%b == a가 성립한다.

52.12 시프트 연산자#

52.13 관계·상등 연산자#

두 연산자군은 계약이 다르다. 상등 비교는 서로 다른 객체 사이에도 허용되지만 크기 비교는 같은 배열 안에서만 뜻이 있다. 배열이 아닌 객체는 “길이 1짜리 배열”처럼 취급된다. 실수에서 +0.0과 -0.0은 같다고 비교된다(54장).

52.14 비트·논리 연산자#

52.15 조건·대입·쉼표#

52.16 평가 순서와 시퀀스 포인트#

앞에서 두 가지를 보았다. 수식의 평가는 부수효과를 시작할 뿐이고(앞의 「부수효과」 절), 우선순위는 묶는 규칙이지 평가의 시간 순서가 아니다(14·34장). 그러면 부수효과는 언제 끝났다고 믿을 수 있는가. 이 절이 그 답이다 — 이 책이 21장에서 씨앗을 심고 34장와 35장에서 조각씩 다룬 것을 여기서 정식으로 닫는다.

52.16.1 세 가지 관계 — 먼저, 순서 없음, 어느 쪽인지 모름#

C11 이후의 표준은 평가들 사이의 순서를 관계로 적는다.

“ 먼저 순서 지어짐(sequenced before)은 한 스레드가 실행하는 평가들 사이의 비대칭적이고 추이적인 쌍별 관계로, 그 평가들 사이에 부분 순서를 만든다. 두 평가 A와 B에 대해 A가 B보다 먼저 순서 지어지면, A의 실행은 B의 실행보다 앞서야 한다. … A가 B보다 먼저도 뒤도 아니게 순서 지어지면 A와 B는 순서 없음(unsequenced)이다. A가 B보다 먼저이거나 뒤이되 어느 쪽인지 미지정이면 A와 B는 부정 순서(indeterminately sequenced)다.⁴ ”

핵심은 「순서 없음」이 셋 가운데 가장 약한 관계라는 데 있다. 「둘 중 하나가 먼저인데 어느 것인지 모른다」가 아니다 — 기계가 A를 반쯤 하고 B를 하고 A의 나머지를 해도 규격에 맞는다. 함수 호출의 몸통만은 예외적으로 쪼개지지 않는다. 부르는 쪽의 다른 평가와 부정 순서로 놓이므로(§6.5.3.3p8), 두 함수의 몸통이 뒤섞이지는 않는다.

52.16.2 시퀀스 포인트 — 「여기까지는 다 끝났다」#

시퀀스 포인트(sequence point)는 위의 관계를 한꺼번에 세우는 지점이다. 표준의 말로, A와 B의 평가 사이에 시퀀스 포인트가 있으면 A에 딸린 모든 값 계산과 부수효과가 B에 딸린 모든 값 계산과 부수효과보다 먼저 순서 지어진다(§5.1.2.4p3). 즉 그 지점을 지나면 앞의 부수효과는 전부 끝났다.

표준이 꼽는 시퀀스 포인트는 이것이 전부다(부속서 C).

시퀀스 포인트가 아닌 순서도 몇 가지 있다. 앞에서 읽은 「피연산자의 값 계산 → 연산자 결과의 값 계산」(§6.5.1p1), 대입에서 「양쪽의 값 계산 → 저장」(§6.5.17.1p3, 35장), 후위 증감에서 「결과의 값 계산 → 저장」(§6.5.3.5p2)이 그렇다. 이것들은 특정한 두 사건의 순서만 정할 뿐, 그 사이에 다른 부수효과가 끝났다고 보장하지 않는다.

52.16.3 계약 밖이 되는 규칙 — 한 객체에 순서 없는 두 접근#

이제 규칙의 핵심 문장이다.

“ 스칼라 객체에 대한 부수효과가, 같은 스칼라 객체에 대한 다른 부수효과나 같은 스칼라 객체의 값을 쓰는 값 계산과 순서 없음이면, 동작은 정의되지 않는다.⁵ ”

계약 밖이 되는 꼴은 둘이다. 같은 객체를 순서 없이 두 번 바꾸거나, 바꾸면서 순서 없이 그 값을 읽는 것이다. 앞의 관계표로 판정하면 이렇다.

미지정과 UB의 차이가 실물로 보인다. 이 책이 같은 코드를 두 컴파일러로 돌렸다.

static int f(void) { puts("f"); return 1; }
static int g(void) { puts("g"); return 2; }
printf("args %d %d\n", f(), g());     /* 미지정 */
printf("%d %d\n", i, i++);            /* UB, i 는 3 */

첫 줄은 미지정이라 둘 다 옳다. 어느 순서로 부르든 각 함수는 온전히 한 번씩 불렸다. 둘째 줄은 UB라 어느 쪽도 「옳은 답」이 아니다 — 같은 소스가 컴파일러마다 다른 수를 찍었고, 다른 판이나 다른 최적화 수준에서는 또 다를 수 있다.

도구는 흔한 꼴을 잡는다. 위 코드에 두 컴파일러가 한 말이다.

gcc:   warning: operation on ‘i’ may be undefined [-Wsequence-point]
clang: warning: unsequenced modification and access to 'i' [-Wunsequenced]
clang: warning: unsequenced modification and access to 'i' [-Wunsequenced]

다만 포인터 둘이 같은 객체를 가리키는 경우(*p = (*q)++ 에서 p == q)처럼 같은 객체인지가 실행 중에야 정해지는 꼴은 어느 쪽도 잡지 못한다. 그래서 실전 규칙은 34장의 그것 그대로다 — 한 완전 수식 안에서 한 객체는 한 번만 바꾸고, 바꾸는 객체를 같은 수식의 다른 자리에서 읽지 않는다. 순서가 중요하면 문장을 나눈다. 문장의 끝이 가장 확실한 시퀀스 포인트다.

52.17 회색지대 총람#

56장의 세 낱말로 연산자 관련 항목만 모았다. 전체 목록은 표준의 부속서 J에 있다.

52.17.1 정의되지 않은 동작(UB)#

52.17.2 미지정(unspecified)#

52.17.3 구현 정의(implementation-defined)#

52.18 연산자가 아닌 것들#

문법에서 같은 글자를 쓰지만 연산자가 아닌 것들이 있다.

연산자를 계약으로 읽는 눈이 갖춰졌다. 다음 장은 그 연산자들 가운데 비트 쪽을 실제로 부리는 법이다(53장) — 관용구와 함정, 그리고 C23 이 그 관용구들에 붙인 이름. 그다음부터는 계약이 가장 미묘해지는 자리들로 들어간다 — 근사의 수학(54장), 실패를 다루는 법(55장), 그리고 계약을 어겼을 때 무슨 일이 일어나는가(56장)다.