50 수식과 연산자

50.1 수식이 가진 네 가지#

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

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

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

50.2 우선순위와 결합#

위쪽이 더 강하게 묶는다. 결합 방향은 같은 세기의 연산자가 나란히 있을 때 어느 쪽부터 묶느냐다 — a - b - c가 (a - b) - c인 것은 왼쪽 결합이기 때문이고, a = b = 0이 a = (b = 0)인 것은 오른쪽 결합이기 때문이다.

50.3 자주 미끄러지는 자리들#

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

// 우선순위·결합성·짧은 회로를 눈으로 확인한다.
// 표를 외우는 대신, 괄호를 넣은 것과 안 넣은 것을 나란히 찍어 본다.
#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장).

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

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

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

50.4.1 표준이 정한 계약#

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

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

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

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

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

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

오늘의 컴파일러에서는 어떤가. 재어 보면 답이 분명하다.

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

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

50.5 연산자별 계약#

이제 갈래별로 하나씩 본다. 각 표는 다섯 칸이다.

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

50.6 후위 연산자#

50.7 단항 연산자#

50.8 산술 연산자#

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

50.9 시프트 연산자#

50.10 관계·상등 연산자#

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

50.11 비트·논리 연산자#

50.12 조건·대입·쉼표#

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

우선순위는 묶는 규칙이지 평가의 시간 순서가 아니다(14·34장). 순서가 보장되는 자리는 다음 다섯뿐이다.

• &&의 왼쪽과 오른쪽 사이
• ||의 왼쪽과 오른쪽 사이
• ?:의 조건과 고른 가지 사이
• 쉼표 연산자의 왼쪽과 오른쪽 사이
• 함수 호출에서 인자들의 평가와 본체 실행 사이(인자들끼리의 순서는 미지정)

그 밖에는 아무 순서도 보장되지 않는다.

C11 이후 표준은 이 규칙을 “시퀀스 포인트” 대신 sequenced-before라는 관계로 다시 적었지만, 실무의 결론은 같다 — 한 수식 안에서 같은 객체를 두 번 건드리지 않는다. gcc의 -Wsequence-point가 흔한 경우를 잡아 주지만 전부는 아니다.

50.14 회색지대 총람#

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

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

50.14.2 미지정(unspecified)#

50.14.3 구현 정의(implementation-defined)#

50.15 연산자가 아닌 것들#

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

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