20 Expressions and constants — the things that become values

20.1 Literals — values written in source

We have met literals several times already. The 0 of hello world is an integer literal, and "Hello, world!\n" is a string literal — the characters inside the quotation marks become a value “as they are.” Add a decimal point to an integer literal (3.5) and it becomes a floating-point value from chapter 8.

20.2 Writing constants — all of them at a glance

Having met literals in the previous section, this is the place to gather every notation for writing a value in source at once. The standard scatters them through its lexical clauses (§6.4.4, §6.4.5), and what trips people in practice is nearly always one of three things: a prefix, a suffix or an escape.

This section is for reference. There is no need to memorise it now — take away the sense that these notations exist, and come back when you need them. Read the listing in that spirit too: skimming the output and matching notation to result is enough.

/* 상수를 적는 방법들 — 표기가 값과 타입을 어떻게 정하는가. */
#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 Integer constants (§6.4.4.1)

Letters can follow too — a suffix, as in 10L, 1U, 3ULL. It marks not the value but the type.

For now, that a suffix changes the type is all you need. The type names above, and the exact rule for which type the compiler picks when there is no suffix, come in chapter 27 once integers have been met properly, in “The type of an integer constant”. One thing in advance — writing the same value in decimal or in hexadecimal can give it a different type.

20.4 The C23 digit separator '

A notation for breaking up long numbers arrived in C23. It has no effect on the value — in the standard’s words it is ignored when determining the value of the constant.

The standard’s own example shows the traps along with the feature. Measured:

The last row is this notation’s one danger. A separator is a separator only between two digits; at the front it is read as a single quote — the start of a character constant.

20.5 Character constants (§6.4.4.4)

The type names read fully only after chapter 9′s character sets and chapter 27′s integers — for now just see that the prefix settles the type.

The escapes are exactly these (§6.4.4.4).

"\x411"      /* not 'A'(0x41) then '1', but a request for 0x411 */

20.6 Floating constants (§6.4.4.3)

The decimal form must have either a decimal point or an exponent part. So 1., .5 and 1e3 are all valid, while 1 is an integer constant.

Floating constants take suffixes too (what the types are comes in chapters 8 and 50).

There are also hexadecimal floating constants (C99) — 0x1p-3 is exactly 0.125.

Worth noting too that the suffix changes the value. Measured, (double)0.1f == 0.1 is false — 0.1f is the nearest value on the float grid and 0.1 the nearest on the double grid, and those are different numbers (chapters 8 and 50).

20.7 String literals (§6.4.5)

Four properties go together.

1. A NUL is appended. sizeof "abc" is not 3 but 4.
2. Adjacent literals join into one (translation phase 6). "hello, " "world" is one string. It is the standard way to split a long string across lines, and the way out of the \x trap above. But the prefixes must not be mixed — u"a" U"b" is a compile error (a constraint violation).
3. A NUL inside does not cut the array short. "a\0b" has strlen 1 and sizeof 4 — the string functions stop, the data is all there.
4. Modifying one is undefined behaviour. Measured, it usually dies at run time (it is placed in a read-only section). So take string literals as const char *.

20.8 Things that look like constants

The last two rows pay off in practice. A macro has neither type nor scope (chapter 57), and a const int is not a constant expression in C — the place where C and C++ part. But “cannot be used” is less accurate than where it cannot be, so here it is, measured.

That is, it fails wherever a real constant expression is required. C23′s constexpr came in to fill that place.

20.9 Expressions — the things that are evaluated into values

Weave literals together with operators and you have an expression, as in 2 + 3 * 4. The definition takes one sentence — that which is calculated (evaluated) into a value. This property of “becoming a value” is the whole of an expression, and half of the eye for reading C from here on. Wherever a value is needed in code, an expression may go there — a single literal is the simplest expression of all.

This chapter has only four operators — plus +, minus -, times *, and parentheses ( ). Following this book’s spiral principle, the remaining operators join in the chapters where they become necessary (comparison in chapter 30, division in chapter 28 — why division was put off, in a moment).

Here is the demonstration. The %d in the example below is a mark meaning “print an integer value here in decimal”; its formal explanation is in chapter 22 — for now it is only a window for seeing results.

#include <stdio.h>

int main(void)
{
    printf("%d\n", 2 + 3 * 4);    /* the multiplication is computed first */
    printf("%d\n", (2 + 3) * 4);  /* the parentheses state the order */
    return 0;
}

14
20

20.10 Order — precedence, and the practice of parentheses

The first line of the demonstration is 14 because the multiplication was calculated before the addition. Exactly the convention of the mathematics lesson, and C has fixed such a ranking of “who goes first” — precedence — for every operator.

Here we state this book’s recommendation in advance. Do not memorise the precedence table; use parentheses. C has dozens of operators and the ranking table runs to more than fifteen rows — even people who have memorised it all get confused and cause accidents. Make the order explicit with parentheses, as in the second line, and there is nothing to memorise and nothing to misread. The full table is in the appendix as reference material; the text goes with “arithmetic by the mathematical convention, parentheses everywhere else.”

20.11 One caution planted early — the order in time may differ

About precedence there is one caution to plant as a seed. Precedence is a rule of binding — who is whose material — not of what the machine calculates first in time. Which of the left and right materials of an addition is calculated first, for instance, is not fixed by the standard and may differ between compilers. In an expression like 2 + 3 it does not matter at all, but when calculating a material leaves a trace such as output, the order of those traces may differ.

Be reassured on one point, though — the order between statements is guaranteed absolutely. Chapter 19′s “one statement at a time, top to bottom” is a contract. What can waver is only the inside of a single statement, and the exact rules there (side effects, the notion of sequence points) are faced head on in chapter 33, once more material is in place. For now one practical rule suffices: do not cram order-sensitive work into one statement; split the statements.

To summarise — a notation writing a value in source is a literal, that which is evaluated into a value is an expression, and the order of binding is governed by arithmetic convention and parentheses, while the order in time inside one statement may differ. In the next chapter we learn the most important device that consumes and produces values — how to call a function. Hello world’s heart, printf(...), is finally treated head on.