82 From macro to keyword — bool, nullptr and their companions

82.1 What was promoted

/* What was promoted to a keyword in C23 — and what changed */
#include <stdio.h>

/* before the promotion these lines demanded <stdbool.h>, <stdalign.h>, <assert.h> */
static_assert(sizeof(int) >= 4, "this code assumes an int of 32 bits or more");

/* nullptr has a type of its own (nullptr_t) — it is neither 0 nor (void *)0 */
static void take_ptr(int *p) { printf("  pointer: %s\n", p ? "has a value" : "null"); }

/* the place where the difference between NULL and nullptr shows in variadic arguments */
static void print_all(const char *first, ...)
{
    printf("  %s ...\n", first);
}

int main(void)
{
    bool ready = true;                 /* a real keyword, neither _Bool nor a macro */
    printf("sizeof bool = %zu, true = %d, false = %d\n", sizeof(bool), true, false);
    printf("ready = %d, !ready = %d\n", ready, !ready);

    /* bool narrows every non-zero value to 1 — a property an int cannot imitate */
    bool  b = 42;
    int   i = 42;
    printf("bool b = 42 -> %d,  int i = 42 -> %d\n", b, i);

    int   x  = 7;
    int  *p  = &x;
    int  *np = nullptr;
    take_ptr(p);
    take_ptr(np);
    printf("nullptr compared with nullptr: %d,  with a pointer: %d\n", nullptr == nullptr, p == nullptr);

    /* typeof: it writes down a nameless type as it is */
    typeof(x) y = x * 2;
    printf("typeof(x) y = %d\n", y);

    /* constexpr: a real constant — usable as an array size and as a switch label */
    constexpr int LANES = 4;
    int lane[LANES];
    printf("constexpr LANES = %d, elements in the array = %zu\n", LANES, sizeof lane / sizeof lane[0]);

    print_all("pass nullptr in variadic arguments", nullptr);
    return 0;
}

sizeof bool = 1, true = 1, false = 0
ready = 1, !ready = 0
bool b = 42 -> 1,  int i = 42 -> 42
  pointer: has a value
  pointer: null
nullptr compared with nullptr: 1,  with a pointer: 0
typeof(x) y = 14
constexpr LANES = 4, elements in the array = 4
  pass nullptr in variadic arguments ...

We organise it in one table. On the left is the shape up to C17, on the right C23.

The headers still exist and including them is harmless — the principle that the standard does not break old code (chapter 64′s gets story) was kept here too. But newly written code has no reason to include them.

82.2 bool — what does it prevent

C long had no true-false type. It was imitated with int, and every project had typedef int BOOL; and #define TRUE 1 rolling about. C99 brought in _Bool and <stdbool.h> attached a pretty name to it, and C23 raised that to a keyword.

What differs between bool and int is not the name but the conversion rule.

• Every nonzero value is narrowed to 1. The example’s bool b = 42; printing 1 is that. int i = 42 is 42 as it stands.
• So comparing two truths is true. The classic bug of the int-imitation days vanishes here.

int a = isupper('A');      /* any nonzero value, depending on the implementation */
int b = isupper('B');
if (a == b) { … }          /* both are true, yet the values may differ and it be false */
if (a == 1) { … }          /* worse */

bool a = isupper('A');     /* normalised to 1 here */
bool b = isupper('B');
if (a == b) { … }          /* safe */

Two remaining traps of bool. First, using bool in a bit-field works fine even with a width of 1, but the layout is implementation-defined (chapter 46). Second, an array of bool uses one byte per element — it is not compressed into bits like C++‘s vector<bool>. To compress into bits, write the masks by hand (chapter 28) or use the tools of <stdbit.h>.

82.3 nullptr — not a renaming

Chapter 6 distinguished the null triplets. NULL is a macro, and its definition is 0 or ((void *)0) depending on the implementation. This freedom bore real accidents.

Accident 1 — the size goes out of step in variadic arguments. A variadic function does not know the arguments’ types and so reads the bits as they came (chapter 58). On an implementation where NULL is defined as 0, writing execl("/bin/ls", "ls", NULL) sends an int 0, and on a machine where pointers are 8 bytes the upper 4 bytes remain as rubbish. The function, failing to recognise the end of the list, runs away. That is why old code had to write (char *)0. nullptr is always of pointer size, so it does not have this problem.

Accident 2 — whether it is an integer or a pointer blurs. On an implementation where NULL is 0, foo(NULL) is indistinguishable from passing the integer 0. In code that branches by type with _Generic (chapter 58), this ambiguity becomes an accident as it stands. nullptr has a type of its own called nullptr_t, so the branch is clear.

Accident 3 — going out of step with C++. C++ brought in nullptr first, in 2011, for the same reasons. There were places in headers crossing the two languages (chapter 54) where NULL’s meaning divided, and C23′s adopting the same word narrowed that gap.

A few rules to pin down. nullptr converts to any object pointer type and to a function pointer too (chapter 59). Two nullptrs, and a nullptr and any pointer, can be compared with == and !=. Converted to bool it is false. But it cannot be compared with an integer and does not convert to an integer — nullptr == 0 is subject to diagnosis. The language has, in effect, cut the old intuition that “a null pointer is the same thing as the integer 0”.

82.4 The remaining promotions and the new words

static_assert — checks a condition at compile time and, if it is broken, translation fails. The example’s first line is that. It differs in character from the run-time assert (chapter 75) — this one is a tool asking “does this code hold on this machine”, used for pinning assumptions about type sizes, alignment and struct layout into the code. In C23 the message may be omitted.

alignas, alignof — the words for handling in the language the alignment seen in chapter 6. They are used to lay things out to fit a cache line (chapter 11′s avoidance of false sharing) or to meet an alignment the hardware requires.

thread_local — makes a variable that exists separately per strand. It is a tool for avoiding the problem of sharing seen in chapter 80 by not sharing. errno is in fact implemented this way (chapter 75).

constexpr — as seen in the example, it makes a real constant. A const int is not a constant expression and so could not be used for an array size or a case label (chapter 23), and that place was long the part of #define. constexpr reclaims that place with a typed name — this chapter’s theme of macros being promoted into the language is repeated here too.

typeof — takes an expression’s type down as it is. What had been used as a GCC extension for over thirty years became standard. It is especially handy when declaring a temporary variable inside a macro.

82.5 How to move existing code over

There is no need to change it all at once. Fix an order and there is almost no risk.

1. First settle the compiler edition. Check whether -std=c23 (or c2x) can be used, and whether it works on all the target platforms. If even one does not, go to the shell strategy of number 5 below.
2. Clear away your own BOOL, TRUE, FALSE. Delete the project header’s typedef int BOOL; and change it to bool. While doing so, look together for places that were comparing values (the counterexample above) — it is rather a place where bugs come to light.
3. Change NULL to nullptr. Mechanical substitution finishes most of it, but check two places by hand. Variadic calls (a real bug is mended here), and code that used NULL like the integer 0 (a compile error arises here — which is a good thing).
4. Take _Static_assert, _Alignas and _Thread_local to the names without underscores. They are different notations for the same thing, so there is no risk. Then tidy away the now unnecessary <stdbool.h> and <stdalign.h> includes.

5. If old editions must be supported too, put the shells in one place. The same as what was done in chapter 81.

   #if __STDC_VERSION__ < 202311L
   #  include <stdbool.h>
   #  define nullptr ((void *)0)      /* not a complete substitute — see the caution below */
   #  define static_assert _Static_assert
   #endif

   This nullptr shell cannot imitate the type as well. In code doing _Generic branching or type checking it may behave differently from expectations, so if there is such code it is right to raise the edition rather than use the shell.

Across thirteen chapters we have walked the terrain of the standard library and the newest standard. We have seen what the standard promises and what it does not, where it is slippery and why.

The two remaining chapters of this part go one layer down. The place chapter 45 passed over saying only “it is expensive” — what layout a program’s memory is laid out on in an operating system and in an embedded chip respectively (chapter 83), and what an allocator actually does in the heap region of that layout (chapter 84). Those two chapters become the ground for understanding the next part’s design.