21 Expressions and constants — the things that become values

21.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 7.

21.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

21.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 28 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.

21.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.

21.5 Character constants (§6.4.4.5)#

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

The escapes are exactly these (§6.4.4.5).

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

21.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 7 and 52).

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 7 and 52).

21.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 *.

21.8 Things that look like constants#

The last two rows pay off in practice. A macro has neither type nor scope (chapter 61), 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 — which is the next section.

21.9 constexpr — the real constant C23 brought in#

For a long time C had four things worth calling a “constant”, and all four fell short somewhere.

constexpr is the word that came in to fill the blanks in that table — a value with a type, a name and a scope, which is also a constant expression.

/* C23's constexpr - how far a "real constant" goes. */
#include <stdio.h>

constexpr int table_size = 4;          /* file scope: static storage duration, internal linkage */
constexpr double half = 0.5;
constexpr long long big = 1LL << 40;

int table[table_size];                 /* an array size - and not a variable length array */
static_assert(sizeof table / sizeof table[0] == 4, "table_size is a constant");

constexpr int doubled = table_size * 2;  /* a constant built from a constant */

struct limits { int low, high; };
constexpr struct limits range = { 1, 9 };
static_assert(range.high == 9, "a member of a constexpr struct is a constant");

/* the preprocessor knows nothing of constexpr - the program prints that fact */
#if table_size == 4
static const char *preproc = "the preprocessor saw table_size == 4";
#else
static const char *preproc = "the preprocessor never saw it: the name became 0";
#endif

static const char *classify(int x)
{
    switch (x) {
    case table_size:  return "exactly the table size";   /* a case label */
    case doubled:     return "twice the table size";
    default:          return "something else";
    }
}

struct packed {
    unsigned flags : table_size;       /* the width of a bit-field */
};

int main(void)
{
    static int copy = table_size + 1;  /* static initialization */
    enum { same_again = table_size };  /* the value of an enumeration constant */

    printf("[constexpr is a constant expression]\n");
    printf("  array size    : %zu\n", sizeof table / sizeof table[0]);
    printf("  case label    : %s\n", classify(4));
    printf("  case label    : %s\n", classify(8));
    printf("  static init   : %d\n", copy);
    printf("  enum value    : %d\n", (int)same_again);
    printf("  bit-field     : %d bits\n", table_size);
    printf("  struct member : range.high = %d (checked with static_assert)\n",
           range.high);

    printf("\n[it has a type, unlike a macro]\n");
    printf("  half  = %g (double)\n", half);
    printf("  big   = %lld (long long)\n", big);
    printf("  const is implicit: %s\n",
           _Generic(&table_size, const int *: "yes, &table_size is const int *",
                                 int *: "no", default: "?"));

    printf("\n[a block-scope constexpr is an ordinary object with an address]\n");
    constexpr int local = 7;
    const int *p = &local;
    printf("  local = %d, read through a pointer = %d\n", local, *p);

    printf("\n[but the preprocessor runs before any of this]\n");
    printf("  %s\n", preproc);
    printf("  #if and #define live in a different world (chapter 57)\n");

    /* every line below is a compile error - the value must be exactly representable.
           constexpr unsigned int m = -1;      the value does not fit
           constexpr float f = 0.1;            0.1 as a double is not exact as a float
           constexpr int *q = &copy;           a pointer initializer must be null
           constexpr const char *s = "abc";    the same reason
           constexpr volatile int v = 1;       volatile, restrict and atomic are banned
           constexpr int no_init;              it must be a definition with an initializer */
    return 0;
}

[constexpr is a constant expression]
  array size    : 4
  case label    : exactly the table size
  case label    : twice the table size
  static init   : 5
  enum value    : 4
  bit-field     : 4 bits
  struct member : range.high = 9 (checked with static_assert)

[it has a type, unlike a macro]
  half  = 0.5 (double)
  big   = 1099511627776 (long long)
  const is implicit: yes, &table_size is const int *

[a block-scope constexpr is an ordinary object with an address]
  local = 7, read through a pointer = 7

[but the preprocessor runs before any of this]
  the preprocessor never saw it: the name became 0
  #if and #define live in a different world (chapter 57)

21.9.1 What it is you are writing#

constexpr goes where a storage-class specifier goes (the seven words of that slot are gathered in chapter 45). Its meaning is one sentence of the standard — “an object declared with a storage-class specifier constexpr has its value permanently fixed at translation time; if not yet present, a const-qualification is implicitly added to the object’s type. The declared identifier is considered a constant expression.”¹

So it works in every place the demonstration showed.

Three things to remember about the grammar. 1. It must be a definition, with an initializer. constexpr int n; is an error (“constexpr requires an initialized data declaration”). 2. The initializer must be a constant expression. 3. The only storage-class specifiers it may be combined with are auto, register and static, so extern constexpr and thread_local constexpr are errors.

21.9.2 How it differs from const#

21.9.3 The value has to fit exactly#

constexpr carries one constraint that no other declaration does: the value of the initializer shall be exactly representable in the target type, with no change of value.² A value that an ordinary initialization would have quietly truncated is caught here.

The last two rows are what the measurement bought. A constraint violation requires a diagnostic but does not dictate its shape, so gcc’s warning does not break the rules. Still, unless warnings are raised to errors (-Werror), a quietly truncated value becomes a constant — which is where the habit of building with -Wall -Wextra pays (chapter 16).

Pointers carry a stronger constraint — they must be null.

constexpr int *p = nullptr;              /* OK */
constexpr const char *s = "abc";         /* error: "constexpr pointer initializer is not null" */
constexpr char s2[] = "abc";             /* OK — take it as an array */

Trying to name a string constant with constexpr is the wall everybody meets on day one. The answer is to declare an array instead of a pointer.

21.9.4 What happens at file scope#

constexpr is often put where a macro used to be, so whether it may go in a header becomes a practical question straight away. The standard’s answer: a constexpr object at file scope has static storage duration, and its identifier has internal linkage (like static). Every translation unit that sees the same textual definition gets its own object, so a header definition does not collide (chapter 56).

Inside a block it is an ordinary local object — automatic storage duration, and its address can be taken. The demonstration’s &local confirms it. It is a “constant” and yet an object, which is where it parts from a macro.

21.10 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 31, division in chapter 29 — 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 23 — 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

21.11 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.”

21.12 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 20′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 34, 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.