C 언어 연산자: 산술, 논리, 그리고 우선순위

연산자는 C의 동사입니다. 값을 받아 새 값을 만들어 냅니다. 40개쯤 있지만 열두어 개가 대부분의 코드를 덮고, 그중 둘은 따로 한 절을 둘 만큼 날카로운 함정을 가지고 있습니다.

산술 연산자

#include <stdio.h>

int main(void) {
    int a = 17, b = 5;

    printf("a + b  = %d\n", a + b);   /* 22 */
    printf("a - b  = %d\n", a - b);   /* 12 */
    printf("a * b  = %d\n", a * b);   /* 85 */
    printf("a / b  = %d\n", a / b);   /* 3  - 정수 나눗셈! */
    printf("a %% b  = %d\n", a % b);  /* 2  - 나머지 */
    printf("-a     = %d\n", -a);      /* 단항 마이너스 */
    return 0;
}

(형식 문자열의 %%는 퍼센트 기호 자체를 출력합니다. % 하나만 쓰면 형식 지정자가 시작됩니다.)

이항 산술 연산자는 + - * / % 다섯 개이고, 부호를 뒤집는 단항 -와 사실상 아무 일도 하지 않는 +가 있습니다.

정수 나눗셈의 함정

정수 둘에 대한 a / b는 정수 나눗셈을 수행하고 나머지를 버립니다. 반올림은 없습니다. 결과는 0 쪽으로 잘립니다.

#include <stdio.h>

int main(void) {
    int total = 7, count = 2;

    printf("7 / 2         = %d\n", total / count);          /* 3 */
    printf("7 / 2.0       = %f\n", total / 2.0);            /* 3.5 */
    printf("(double)7 / 2 = %f\n", (double)total / count);  /* 3.5 */

    double wrong = total / count;      /* 나눗셈이 먼저, 정수로 일어난다 */
    printf("잘못된 평균 = %f\n", wrong);   /* 3.000000 */
    return 0;
}

마지막 경우가 운영 환경까지 살아남는 버그입니다. double에 대입해도 소용없습니다. 대입이 일어나기 전에 total / count 나눗셈은 이미 끝났고 이미 int이기 때문입니다. 해법은 식 안에서 한쪽 피연산자를 부동소수점으로 만드는 것이고, 보통 캐스팅을 씁니다.

관련된 규칙 둘. 정수를 0으로 나누는 것은 미정의 동작이고 보통 프로그램이 죽습니다. 그리고 INT_MIN / -1은 오버플로를 일으킵니다.

나머지 연산자

%는 나머지를 주고 정수에만 동작합니다.

#include <stdio.h>

int main(void) {
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            printf("%d은(는) 짝수\n", i);
        } else {
            printf("%d은(는) 홀수\n", i);
        }
    }

    int seconds = 3725;
    printf("\n%d초 = %d시간 %d분 %d초\n",
           seconds, seconds / 3600, (seconds % 3600) / 60, seconds % 60);
    return 0;
}

짝수 판별에 x % 2 == 0을 쓰고, 인덱스를 배열 안으로 감쌀 때 % n을 쓰는 것이 일상적인 두 쓰임입니다.

음수에서 C의 %는 피제수의 부호를 따릅니다.

#include <stdio.h>

int main(void) {
    printf(" 7 %% 3 = %d\n",  7 % 3);   /*  1 */
    printf("-7 %% 3 = %d\n", -7 % 3);   /* -1, 2가 아니다 */
    printf(" 7 %% -3 = %d\n", 7 % -3);  /*  1 */
    return 0;
}

따라서 x가 음수일 수 있다면 x % 2 == 1은 홀수 판별로 망가진 검사입니다. -7 % 2는 -1입니다. 대신 x % 2 != 0을 쓰세요.

부동소수점 나머지에 %를 쓰면 컴파일 오류입니다. math.h의 fmod()를 쓰세요.

대입과 복합 대입

=는 값을 저장합니다. 복합 형태는 연산과 저장을 합칩니다.

#include <stdio.h>

int main(void) {
    int x = 10;

    x += 5;   printf("x += 5   -> %d\n", x);   /* 15 */
    x -= 3;   printf("x -= 3   -> %d\n", x);   /* 12 */
    x *= 2;   printf("x *= 2   -> %d\n", x);   /* 24 */
    x /= 4;   printf("x /= 4   -> %d\n", x);   /* 6  */
    x %= 4;   printf("x %%= 4   -> %d\n", x);  /* 2  */
    return 0;
}

x += 5는 x = x + 5를 뜻하지만 x를 한 번만 평가합니다. 대상이 arr[compute_index()] 같은 것일 때 이 차이가 중요합니다.

대입 자체도 대입된 값을 내놓는 식입니다. 그래서 a = b = c = 0이 동작하고(오른쪽에서 왼쪽으로 대입합니다), =와 ==를 헷갈린 실수가 조용히 컴파일되는 것입니다.

증가와 감소

++는 1을 더하고 --는 1을 뺍니다. 각각 전위와 후위 형태가 있습니다.

#include <stdio.h>

int main(void) {
    int i = 5;
    int a = i++;    /* a는 5(이전 값)를 받고, 그다음 i가 6이 된다 */
    printf("후위: a = %d, i = %d\n", a, i);

    int j = 5;
    int b = ++j;    /* j가 먼저 6이 되고, 그다음 b가 6을 받는다 */
    printf("전위: b = %d, j = %d\n", b, j);

    int k = 5;
    k++;            /* 문장 하나로 단독으로 쓰면 ++k와 동일하다 */
    printf("문장: k = %d\n", k);
    return 0;
}

단독 문장으로 쓰면 둘은 바꿔 쓸 수 있고, for 헤더에서 i++를 쓰는 것은 관습 말고는 깊은 이유가 없습니다.

절대 하면 안 되는 것은, 어떤 식 안에서 수정되고 있는 변수를 그 식에서 두 번 이상 쓰는 것입니다.

int i = 5;
int x = i++ + i++;      /* 미정의 동작 */
arr[i] = i++;           /* 미정의 동작 */
printf("%d %d", i++, i);/* 미정의 동작 */

C는 이 부분식들이 평가되는 순서를 정의하지 않으므로, 결과가 단순히 미지정인 것이 아니라 프로그램 전체의 동작이 미정의가 됩니다. 문장을 둘로 나누면 모호함이 사라집니다.

비교 연산자

여섯 개가 있고 모두 int를 만들어 냅니다. 참은 1, 거짓은 0입니다.

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    printf("a == b : %d\n", a == b);   /* 0 */
    printf("a != b : %d\n", a != b);   /* 1 */
    printf("a <  b : %d\n", a <  b);   /* 1 */
    printf("a >  b : %d\n", a >  b);   /* 0 */
    printf("a <= 5 : %d\n", a <= 5);   /* 1 */
    printf("a >= 9 : %d\n", a >= 9);   /* 0 */
    return 0;
}

결과가 전용 불리언 타입이 아니라 평범한 int라는 점은 C를 규정하는 특징입니다. 거기서 따라 나오는 것들, 특히 =와 == 버그는 C의 불리언을 보세요.

C에만 있는 비교 실수가 둘 있습니다. 연쇄 비교는 수학에서 기대하는 대로 동작하지 않습니다. if (1 < x < 10)은 항상 참인데, 1 < x가 0이나 1이 되고 그것이 10과 비교되기 때문입니다. if (x > 1 && x < 10)이라고 쓰세요. 그리고 문자열을 ==로 비교하면 글자가 아니라 포인터를 비교합니다. string.h의 strcmp를 쓰세요.

논리 연산자

#include <stdio.h>

int main(void) {
    int age = 25;
    int has_license = 1;

    if (age >= 18 && has_license) {
        printf("운전 가능\n");
    }

    if (age < 13 || age > 65) {
        printf("할인 요금\n");
    } else {
        printf("정가\n");
    }

    printf("!has_license = %d\n", !has_license);   /* 0 */
    printf("!0 = %d\n", !0);                       /* 1 */
    return 0;
}

&&는 AND, ||는 OR, !는 NOT입니다. 셋 다 0이 아닌 값을 참으로 취급합니다.

이들은 단락 평가를 합니다. &&는 한쪽이 거짓이 되는 순간 멈추고, ||는 한쪽이 참이 되는 순간 멈춥니다. 나머지는 아예 평가되지 않으며, 이는 최적화에 그치지 않고 안전을 위해 기댈 수 있는 보장입니다.

#include <stdio.h>

int is_safe(int *p) {
    /* p가 NULL이면 *p는 절대 평가되지 않는다 - &&가 먼저 멈춘다. */
    return p != NULL && *p > 0;
}

int main(void) {
    int value = 7;
    printf("진짜 포인터로: %d\n", is_safe(&value));
    printf("NULL로:        %d\n", is_safe(NULL));
    return 0;
}

두 검사의 순서를 바꾸면 NULL 호출이 널 포인터를 역참조하고 죽습니다. 먼저 지키고 나서 쓰세요. && 사슬의 순서는 논리의 일부입니다.

조건 연산자

C의 유일한 삼항 연산자는 두 값 중 하나를 고릅니다.

#include <stdio.h>

int main(void) {
    int a = 12, b = 30;

    int max = (a > b) ? a : b;
    printf("최댓값 = %d\n", max);

    printf("항목 %d개%s\n", a, (a == 1) ? "" : " (복수)");
    return 0;
}

조건 ? 참일_때_값 : 거짓일_때_값입니다. 식이므로 if 문이 들어갈 수 없는 자리 - printf 인자 안, 초기화자 안 - 에도 들어갑니다. 짧게 유지하세요. 중첩된 조건 연산자는 금세 읽을 수 없게 됩니다.

비트 연산자, 짧게

이들은 정수의 개별 비트에 동작합니다.

#include <stdio.h>

int main(void) {
    unsigned int a = 12;   /* 이진수로 1100 */
    unsigned int b = 10;   /* 1010 */

    printf("a & b  = %u\n", a & b);    /* 8  - 1000, AND */
    printf("a | b  = %u\n", a | b);    /* 14 - 1110, OR  */
    printf("a ^ b  = %u\n", a ^ b);    /* 6  - 0110, XOR */
    printf("~a     = %u\n", ~a);       /* NOT - 모든 비트를 뒤집는다 */
    printf("a << 2 = %u\n", a << 2);   /* 48 - 위로 이동, 4를 곱한다 */
    printf("a >> 2 = %u\n", a >> 2);   /* 3  - 아래로 이동, 4로 나눈다 */
    return 0;
}

플래그, 마스크, 하드웨어 레지스터에 쓰입니다. 주의할 점 둘. &와 |는 &&, ||가 아닙니다(단락 평가를 하지 않고 비트 단위로 동작합니다). 그리고 부호 있는 값을 시프트하거나 타입의 폭보다 많이 시프트하는 것은 미정의입니다. 비트 작업에는 부호 없는 타입을 쓰세요.

우선순위

괄호가 없는 식에서 무엇이 무엇에 묶이는지는 이 표가 결정합니다. 우선순위가 높은 것부터입니다.

실질적인 결과는 이렇습니다.

a + b * c       /* a + (b * c)를 뜻한다 */
a < b == c < d  /* (a < b) == (c < d)를 뜻한다 - 의도한 경우는 드물다 */
x & 1 == 0      /* x & (1 == 0), 즉 x & 0을 뜻한다 - 고전적인 버그 */
*p++            /* *(p++)를 뜻한다 - p를 역참조하고, 그다음 전진시킨다 */

세 번째 줄은 외워 둘 만합니다. ==가 &보다 강하게 묶이므로 비트마스크 검사에는 괄호가 필요합니다. (x & 1) == 0처럼요.

열다섯 단계를 다 기억하는 사람은 없고, 그럴 필요도 없습니다. *가 +를 이기고, 비교가 &&를 이기고 &&가 ||를 이긴다는 것만 익히고, 나머지는 전부 괄호를 치세요.

if ((flags & MASK) != 0 && (count > 0 || force)) { ... }

이 줄에는 없어도 되는 괄호가 있고, 그 덕분에 더 좋습니다.