20 수식과 상수 — 값이 되는 것

20.1 리터럴 — 소스에 적는 값

리터럴은 이미 여러 번 만났다. 헬로 월드의 0이 정수 리터럴이고, "안녕, 세상!\n"은 문자열 리터럴이다 — 따옴표 안의 글자들이 “글자 그대로” 값이 된다. 정수 리터럴에 소수점을 붙이면(3.5) 8장의 부동소수점 값이 된다.

20.2 상수를 적는 법 — 한눈에 보기

앞 절에서 리터럴을 만났으니, 이 자리에서 소스에 값을 적는 표기를 한 번에 모아 둔다. 표준은 이것을 어휘 요소 조항(§6.4.4, §6.4.5)에 흩어 두었고, 실무에서 헷갈리는 것은 거의 언제나 접두어·접미어·이스케이프 셋이다.

이 절은 참조용이다. 지금 전부 외울 필요는 없고, 「그런 표기가 있다」는 지도만 얻어 두었다가 필요할 때 돌아오면 된다. 시연도 그런 뜻으로 읽는다 — 출력을 훑어 보며 표기와 결과를 눈으로 잇는 정도면 충분하다.

/* 상수를 적는 방법들 — 표기가 값과 타입을 어떻게 정하는가. */
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <uchar.h>

int main(void)
{
    puts("[integer constants - four bases and digit separators (C23)]");
    printf("  1234        = %d\n", 1234);          /* 10진 */
    printf("  0755        = %d   <- a leading 0 means octal\n", 0755);
    printf("  0xFF        = %d\n", 0xFF);
    printf("  0b1010      = %d   <- binary, new in C23\n", 0b1010);
    printf("  1'000'000   = %d   <- digit separators, new in C23\n", 1'000'000);
    printf("  0b11'10'11'01 = %d\n", 0b11'10'11'01);

    puts("\n[접미어가 타입을 정한다]");
    printf("  sizeof 1    = %zu, sizeof 1L  = %zu, sizeof 1LL = %zu\n",
           sizeof 1, sizeof 1L, sizeof 1LL);
    printf("  sizeof 1U   = %zu, sizeof 1wb = %zu  ← wb 는 C23 의 _BitInt\n",
           sizeof 1U, sizeof 1wb);

    puts("\n[문자 상수 — 접두어가 타입을 정한다]");
    printf("  'a'   크기 %zu, 값 %d      ← C 에서 문자 상수는 int 다\n",
           sizeof 'a', 'a');
    printf("  u8'a' 크기 %zu (char8_t)\n",  sizeof u8'a');
    printf("  u'a'  크기 %zu (char16_t)\n", sizeof u'a');
    printf("  U'a'  크기 %zu (char32_t)\n", sizeof U'a');
    printf("  L'a'  크기 %zu (wchar_t)\n",  sizeof L'a');
    /* 'ab' 같은 다중 문자 상수는 값이 구현 정의라 -Wmultichar 가 경고한다.
       여기서는 경고를 켠 채 두고, 값은 본문의 실측 표로만 보인다. */

    puts("\n[이스케이프 — 8진과 16진]");
    printf("  '\\101' = %d, '\\x41' = %d   ← 둘 다 'A'\n", '\101', '\x41');
    printf("  \"\\x41\" \"1\" = \"%s\"        ← 16진은 가장 긴 열을 먹는다.\n",
           "\x41" "1");
    puts("    그래서 \"\\x411\" 이 아니라 문자열을 쪼개 이어 붙인다.");

    puts("\n[부동소수점 상수]");
    printf("  3.14  1e3=%g  1.=%g  .5=%g\n", 1e3, 1., .5);
    printf("  0x1p-3 = %g            ← 16진 부동소수점. 지수부 p 는 필수다\n", 0x1p-3);
    printf("  sizeof 1.0 = %zu, 1.0f = %zu, 1.0L = %zu\n",
           sizeof 1.0, sizeof 1.0f, sizeof 1.0L);
    printf("  0.1 == 0.1f ? %s   ← 접미어가 다르면 값도 다르다\n",
           (double)0.1f == 0.1 ? "예" : "아니오");

    puts("\n[문자열 리터럴]");
    printf("  sizeof \"abc\" = %zu        ← NUL 이 한 칸 더 붙는다\n", sizeof "abc");
    printf("  \"hello, \" \"world\" = \"%s\"  ← 인접한 것은 하나로 이어진다\n",
           "hello, " "world");
    printf("  \"a\\0b\": strlen = %zu, sizeof = %zu  ← 안에 NUL 을 넣어도 배열은 남는다\n",
           strlen("a\0b"), sizeof "a\0b");
    printf("  sizeof u8\"가\" = %zu, sizeof u\"가\" = %zu, sizeof U\"가\" = %zu\n",
           sizeof u8"\uAC00", sizeof u"\uAC00", sizeof U"\uAC00");
    return 0;
}

[integer constants - four bases and digit separators (C23)]
  1234        = 1234
  0755        = 493   <- a leading 0 means octal
  0xFF        = 255
  0b1010      = 10   <- binary, new in C23
  1'000'000   = 1000000   <- digit separators, new in C23
  0b11'10'11'01 = 237

[접미어가 타입을 정한다]
  sizeof 1    = 4, sizeof 1L  = 8, sizeof 1LL = 8
  sizeof 1U   = 4, sizeof 1wb = 1  ← wb 는 C23 의 _BitInt

[문자 상수 — 접두어가 타입을 정한다]
  'a'   크기 4, 값 97      ← C 에서 문자 상수는 int 다
  u8'a' 크기 1 (char8_t)
  u'a'  크기 2 (char16_t)
  U'a'  크기 4 (char32_t)
  L'a'  크기 4 (wchar_t)

[이스케이프 — 8진과 16진]
  '\101' = 65, '\x41' = 65   ← 둘 다 'A'
  "\x41" "1" = "A1"        ← 16진은 가장 긴 열을 먹는다.
    그래서 "\x411" 이 아니라 문자열을 쪼개 이어 붙인다.

[부동소수점 상수]
  3.14  1e3=1000  1.=1  .5=0.5
  0x1p-3 = 0.125            ← 16진 부동소수점. 지수부 p 는 필수다
  sizeof 1.0 = 8, 1.0f = 4, 1.0L = 16
  0.1 == 0.1f ? 아니오   ← 접미어가 다르면 값도 다르다

[문자열 리터럴]
  sizeof "abc" = 4        ← NUL 이 한 칸 더 붙는다
  "hello, " "world" = "hello, world"  ← 인접한 것은 하나로 이어진다
  "a\0b": strlen = 1, sizeof = 4  ← 안에 NUL 을 넣어도 배열은 남는다
  sizeof u8"가" = 4, sizeof u"가" = 4, sizeof U"가" = 8

20.3 정수 상수 (§6.4.4.1)

뒤에 붙는 글자 — 접미어 — 도 있다. 10L, 1U, 3ULL 처럼 쓰는데, 이것은 값이 아니라 타입을 바꾸는 표시다.

지금은 「접미어가 타입을 바꾼다」는 사실만 알아 두면 된다. 여기 나온 타입 이름들과, 접미어가 없을 때 컴파일러가 어떤 타입을 고르는지의 정확한 규칙은 27장에서 정수를 정식으로 배운 뒤 「정수 상수의 타입」 절에서 다룬다. 미리 한 가지만 — 같은 값을 십진으로 적느냐 16진으로 적느냐에 따라 타입이 달라질 수 있다.

20.4 C23 의 자리 구분자 '

긴 수를 읽기 좋게 끊는 표기가 C23 에 들어왔다. 값에는 아무 영향이 없다 — 표준의 말대로 상수의 값을 정할 때 무시된다.

표준이 직접 든 예가 함정까지 함께 보여 준다. 실측으로 확인하면 이렇다.

마지막 줄이 이 표기의 유일한 위험이다. 구분자는 숫자와 숫자 사이에서만 구분자이고, 맨 앞에 오면 작은따옴표 — 즉 문자 상수의 시작 — 으로 읽힌다.

20.5 문자 상수 (§6.4.4.4)

타입 이름들은 9장에서 문자 집합을, 27장에서 정수를 배운 뒤라야 온전히 읽힌다 — 지금은 접두어가 타입을 정한다는 것만 보면 된다.

이스케이프는 다음이 전부다(§6.4.4.4).

"\x411"      /* 'A'(0x41) 뒤에 '1' 이 아니라, 0x411 을 요구한 것 */

20.6 부동소수점 상수 (§6.4.4.3)

십진 형태는 소수점이 있거나 지수부가 있거나 둘 중 하나를 갖춰야 한다. 그래서 1., .5, 1e3 이 모두 유효하고 1 은 정수 상수다.

부동소수점에도 접미어가 있다(타입의 정체는 8장과 50장에서 본다).

16진 부동소수점(C99)도 있다 — 0x1p-3 은 정확히 0.125 다.

접미어가 값까지 바꾼다는 것도 짚어 둔다. 실측에서 (double)0.1f == 0.1 은 거짓이다 — 0.1f 는 float 눈금 위의 가장 가까운 값이고, 0.1 은 double 눈금 위의 가장 가까운 값이라 서로 다른 수다(8·50장).

20.7 문자열 리터럴 (§6.4.5)

네 가지 성질을 함께 기억한다.

1. 끝에 NUL 이 붙는다. sizeof "abc" 는 3이 아니라 4다.
2. 인접한 것은 하나로 이어진다(번역 단계 6). "hello, " "world" 는 한 문자열이다. 긴 문자열을 줄로 나눠 적는 정석이고, 위의 \x 함정을 푸는 방법이기도 하다. 단 접두어가 섞이면 안 된다 — u"a" U"b" 는 컴파일 오류다(제약 위반).
3. 안에 NUL 을 넣어도 배열은 잘리지 않는다. "a\0b" 는 strlen 이 1, sizeof 는 4다 — 문자열 함수가 멈출 뿐 데이터는 다 있다.
4. 수정하면 정의되지 않은 동작이다. 실측하면 대개 실행 중에 죽는다(읽기 전용 구역에 놓이기 때문이다). 그래서 문자열 리터럴은 const char * 로 받는다.

20.8 상수처럼 보이는 것들

마지막 두 줄의 구별이 실무에서 값을 한다. 매크로는 타입도 스코프도 없고(57장), const int 는 C 에서 상수 수식이 아니다 — C++ 와 갈리는 자리다. 다만 「못 쓴다」가 아니라 어디서 못 쓰는가가 정확한 말이라, 실측으로 갈라 둔다.

즉 진짜 상수 수식이 필요한 자리에서 걸린다. C23 의 constexpr 이 그 자리를 메우려고 들어왔다.

20.9 수식 — 계산되어 값이 되는 것

리터럴을 연산자로 엮으면 수식(expression)이 된다. 2 + 3 * 4 처럼. 수식의 정의는 한 문장이면 된다 — 계산되어(평가되어) 값이 되는 것. 이 “값이 된다”는 성질이 수식의 전부이자, 앞으로 C를 읽는 눈의 절반이다. 코드의 어느 자리에 값이 필요하든, 그 자리에는 수식이 올 수 있다 — 리터럴 하나도 가장 단순한 수식이다.

이 장의 연산자는 넷뿐이다 — 더하기 +, 빼기 -, 곱하기 *, 그리고 괄호 ( ). 이 책의 나선형 원칙대로, 나머지 연산자들은 필요해지는 장에서 하나씩 합류한다(비교는 30장, 나눗셈은 28장 — 나눗셈이 뒤로 미뤄진 이유는 잠시 뒤에).

시연이다. 아래 예제의 %d는 “이 자리에 정수 값을 십진법으로 찍어라” 라는 표시로, 정식 설명은 22장에서 한다 — 지금은 계산 결과를 눈으로 확인하는 창으로만 쓴다.

#include <stdio.h>

int main(void)
{
    printf("%d\n", 2 + 3 * 4);    /* 곱셈이 먼저 계산된다 */
    printf("%d\n", (2 + 3) * 4);  /* 괄호가 순서를 명시한다 */
    return 0;
}

14
20

20.10 순서 — 우선순위, 그리고 괄호라는 관행

위 시연의 첫 줄이 14인 것은 곱셈이 덧셈보다 먼저 계산됐기 때문이다. 수학 시간의 관례 그대로이고, C는 이런 “누가 먼저인가”의 서열 — 우선순위(precedence) — 을 모든 연산자에 정해 두었다.

여기서 이 책의 권고를 미리 밝힌다. 우선순위 표를 외우지 말고, 괄호를 써라. C의 연산자는 수십 개이고 서열표는 15줄이 넘는다 — 그것을 다 외운 사람들끼리도 헷갈려서 사고가 난다. 둘째 줄처럼 괄호로 순서를 명시하면 외울 것도, 오해할 것도 없다. 전체 서열표는 부록에 참고 자료로 두고, 본문은 “산술은 수학 관례대로, 그 밖에는 괄호”로 간다.

20.11 미리 심는 주의 하나 — 계산의 시간 순서는 다를 수 있다

우선순위에 관해, 지금은 씨앗만 심어 둘 주의가 하나 있다. 우선순위는 “누가 누구의 재료인가”라는 묶기의 규칙이지, 기계가 시간상 무엇을 먼저 계산하는가가 아니다 — 이를테면 덧셈의 왼쪽 재료와 오른쪽 재료 중 어느 쪽을 먼저 계산할지는 표준이 정해 두지 않았고, 컴파일러마다 다를 수 있다. 2 + 3 같은 수식에서야 아무래도 좋지만, 재료의 계산이 출력 같은 흔적을 남기는 경우에는 그 흔적의 순서가 달라질 수 있다는 뜻이다.

다만 안심할 것 — 문장과 문장 사이의 순서는 철석같이 보장된다. 19장의 “위에서 아래로 한 문장씩”은 계약이다. 흔들릴 수 있는 것은 한 문장 안쪽뿐이고, 그 안쪽의 정확한 규칙(부수효과, 시퀀스 포인트라는 개념)은 재료가 더 갖춰진 뒤 33장에서 정면으로 다룬다. 지금의 실전 수칙은 하나면 된다: 순서가 중요한 일들은 한 문장에 욱여넣지 말고 문장을 나눈다.

정리하면 — 소스에 값을 적는 표기가 리터럴이고, 계산되어 값이 되는 것이 수식이며, 묶는 순서는 산술 관례와 괄호로 다스리되 한 문장 안의 계산 시간 순서는 달라질 수 있다. 다음 장에서는 값을 소비하고 생산하는 가장 중요한 장치 — 함수를 부르는 법 — 를 익힌다. 헬로 월드의 심장 printf(...)가 드디어 정면으로 다뤄진다.