Statements

21

Choosing

if / elseif (n > 0) puts("yes"); else puts("no");The controlling expression is compared against 0; any scalar type works, pointers included.branch on a scalar condition

switchswitch (c) { case 'a': f(); break; default: g(); }The controlling expression is integer-promoted. Only integer constant expressions may be case labels.branch on an integer expression

case / defaultcase 1: case 2: f(); break; default: g();Duplicate case values are a constraint violation. A case label outside any switch is an error; one nested inside an inner block still belongs to the switch. [undefined, unspecified or implementation-defined]a label inside a switch

case A ... Bcase 'a' ... 'z': lower++; break;A GNU extension, not ISO C. Note the spaces around the dots.a range of case values

Looping

whilewhile (*p) p++;The test happens before the first iteration, so the body may run zero times.test, then body

do ... whiledo { n /= 10; } while (n);Runs at least once. The trailing semicolon is required.body, then test

forfor (int i = 0; i < n; i++) sum += a[i];Since C99 the first clause may be a declaration, and that object is scoped to the loop.init, test, advance

breakfor (;;) { if (done) break; }It leaves ONE construct. To leave two nested loops you need a goto or a flag.leave the innermost loop or switch

continuefor (i = 0; i < n; i++) { if (!a[i]) continue; use(a[i]); }In a for loop the advance clause still runs; in a while loop it does not, which is how infinite loops get written.skip to the next iteration

Jumping

gotoif (err) goto cleanup; ... cleanup: free(p);Labels are function-scoped. Jumping INTO the scope of a variable-length array is undefined; jumping forward past an initialisation leaves the object indeterminate.jump to a label in this function

returnreturn n < 0 ? -n : n;Falling off the end of a non-void function and then using the value is undefined behaviour. main is the one exception: it returns 0.leave the function, with a value

label:again: if (retry()) goto again;C23 allows a label at the end of a compound statement; before C23 it had to be followed by a statement.a named point in the function

goto *ptrvoid *t[] = {&&add, &&sub}; goto *t[op];A GNU extension: &&label yields a void*. How fast interpreter dispatch loops are written. [a common extension, not ISO C]computed goto

Blocks and expressions

{ ... }{ int t = a; a = b; b = t; }Declarations inside it are visible only within it, and automatic objects in it are destroyed at the closing brace.a compound statement, and a scope

expr ;x = f(y); puts("hi");The value is discarded. Discarding the result of a function marked warn_unused_result is what -Wunused-result catches.an expression statement

;while (*d++ = *s++) ;A whole loop body, when the work is in the header. Write it on its own line or it reads as a bug.the null statement

({ ... })#define MAX(a,b) ({ \ typeof(a) _a=(a), _b=(b); \ _a > _b ? _a : _b; })A GNU extension: the value of the last expression is the value of the block. The safe way to write a MAX macro. [a common extension, not ISO C]a statement expression

Declarations, which are statements too

int x = 1;for (int i = 0; i < n; i++) { }Legal anywhere a statement is since C99. Before that, only at the top of a block.a declaration with an initialiser

static_assertstatic_assert(sizeof(int) == 4, "need 32-bit int");A keyword in C23; _Static_assert with before it. The message is optional since C23. [new in C23]a compile-time check

typeof / typeof_unqualtypeof(*p) tmp = *p;Standard in C23; __typeof__ is the GNU spelling that works everywhere. The operand is not evaluated. [new in C23]the type of an expression

constexprconstexpr int N = 64; int buf[N];C23. Unlike a const object, it may be used where a constant expression is required. [new in C23]a true compile-time constant object

Keywords

25

Types

voidvoid *p = malloc(n); void f(void);void* converts to and from any object pointer without a cast. f(void) means no parameters — and since C23, f() means the same.no value; or an incomplete type

charchar c = getchar(); unsigned char b = 0xFF;Exactly 1 byte by definition, but plain char is signed on x86 and unsigned on Arm. Say signed char or unsigned char when it matters.the smallest addressable unit

short / int / longlong n = 1L; long long big = 1LL;Only the minimum widths are fixed: short and int at least 16 bits, long at least 32, long long at least 64.the signed integer types

signed / unsignedunsigned u = 0u - 1u; /* UINT_MAX */Unsigned arithmetic wraps and is defined; signed overflow is undefined behaviour.the signedness qualifiers

float / doubledouble x = 0.1 + 0.2; /* != 0.3 */long double is 80-bit on x86 Linux and plain double on AArch64 macOS — never assume.the floating types

bool / true / falsebool ok = (p != NULL);Real keywords in C23; before that _Bool plus . Any nonzero scalar converts to true. [new in C23]the boolean type

_BitInt(N)_BitInt(24) sample = 0;C23. Useful for hardware registers and bit-exact arithmetic; not subject to integer promotion in the usual way. [new in C23]an integer of exactly N bits

_Complex / _Imaginary#include <complex.h> double complex z = 1 + 2*I;With , spelled complex and I. _Imaginary is optional and rarely implemented.complex arithmetic

struct / union / enumstruct P { int x, y; }; enum C { RED, GREEN };The tag lives in its own namespace, which is why struct foo and a variable foo can coexist.the aggregate and enumerated types

nullptr / nullptr_tchar *p = nullptr;C23. Unlike NULL it has a type, so it cannot be passed as an int through varargs by mistake. [new in C23]the null pointer constant

Storage and linkage

staticstatic int counter; /* file-local */ void f(void) { static int n; n++; }Two unrelated meanings: at file scope it hides the name from other translation units; inside a function it makes the object persist across calls. [undefined, unspecified or implementation-defined]internal linkage, or static storage

externextern int errno; /* header */ int errno; /* one .c */The declaration in a header, the definition in exactly one .c file. Without extern in the header you get multiple-definition errors.declare without defining

autoauto n = 1 + 2; /* C23: int */The default, so it was noise for fifty years. In C23 it also means type inference, like C++.automatic storage

registerregister int i; /* &i is an error */The hint is ignored by every modern compiler. The prohibition is real: you may not take the address of a register object.a hint, and a prohibition

thread_localthread_local int depth = 0;C23 spelling; _Thread_local in C11, __thread as the GNU extension before that. [new in C23]one instance per thread

typedeftypedef struct node Node; typedef int (*cmp)(const void*, const void*);Not a macro: the name obeys scope, and typedef int a[10]; then const a x makes ten const ints, not a const pointer. [new in C23]a name for a type

inlineinline int sq(int x) { return x*x; } extern inline int sq(int); /* one .c */The linkage rule is the hard part: an inline function needs exactly one external definition somewhere, or the link fails at -O0. [new in C23]a suggestion, plus a linkage rule

Qualifiers

constconst char *p; /* p may move */ char *const q; /* *q may change */A promise about the access path, not the object. Casting it away and then writing to a genuinely const object is undefined behaviour. [undefined, unspecified or implementation-defined]this lvalue may not be modified through

volatilevolatile uint32_t *reg = (void*)0x4000; *reg = 1;It stops the compiler eliding or reordering accesses. It says NOTHING about atomicity or about other threads — use _Atomic for those. [undefined, unspecified or implementation-defined]every access is an observable side effect

restrictvoid copy(int *restrict d, const int *restrict s, int n);A promise you make to the optimiser. Break it — pass overlapping buffers to memcpy — and the behaviour is undefined, silently. [undefined, unspecified or implementation-defined]this pointer is the only route to the object

alignas / alignofalignas(64) char line[64]; size_t a = alignof(double);C23 keywords; _Alignas/_Alignof plus in C11. [new in C23]alignment control and query

_Atomic_Atomic int n = 0; n++; /* atomic RMW */With . Plain reads and writes of an _Atomic object are sequentially consistent.atomic access, with a memory order

Operators that are keywords

sizeofsize_t n = sizeof arr / sizeof arr[0];Its operand is not evaluated — sizeof(a[i++]) does not increment i. The result is size_t, which is unsigned. [undefined, unspecified or implementation-defined]the size in bytes, at compile time

_Generic#define abs(x) _Generic((x), \ int: abs, double: fabs)(x)C11. Type-based dispatch at compile time; the unselected branches are not even type-checked in C23. [new in C23]select an expression by type

true / falsebool done = false;C23 keywords of type bool; macros expanding to 1 and 0 before that. [new in C23]the boolean constants

Operators & Precedence

27

Highest — postfix

a[i] f() . ->p->x == (*p).xa[i] is defined as *(a+i), which is why 3["abc"] compiles.subscript, call, member, member through pointer

i++ i--x = i++; /* x = old i */The value is the OLD one.postfix increment: use, then change

(T){...}f(&(struct P){1, 2});C99. It is an lvalue with automatic storage in a function, static at file scope.compound literal

Unary

++i --ix = ++i; /* x = new i */The value is the NEW one.prefix: change, then use

+  -  ~  !~0u == UINT_MAX !x == (x == 0)Unary + is not a no-op: it applies the integer promotions.plus, negate, bitwise not, logical not

*  &int *p = &x; *p = 5;Dereferencing a null, dangling or misaligned pointer is undefined behaviour, not a crash you can rely on. [undefined, unspecified or implementation-defined]dereference, address-of

(T)expr(double)n / dCasting a pointer to a wider-aligned type and dereferencing it is undefined even if the address happens to be aligned.cast

sizeof alignofsizeof(int) alignof(max_align_t)Both are compile-time except sizeof of a VLA.size, alignment

Binary, in precedence order

* / %7 / 2 == 3 -7 % 2 == -1Division or remainder by zero is undefined. INT_MIN / -1 overflows and is also undefined. [undefined, unspecified or implementation-defined]multiply, divide, remainder

+ -p + 1 /* next element */Pointer arithmetic is in units of the pointed-to type, and only within one object plus one past its end.add, subtract

<<  >>1u << 31 n >> 3Shifting by the width or more, or by a negative amount, is undefined. Right-shifting a negative value is implementation-defined. [undefined, unspecified or implementation-defined]shift left, shift right

<  >  <=  >=if (a <= b) ...Comparing pointers into different objects is undefined; only equality is defined there.relational

== !=if (p != NULL) ...Comparing a float with == is almost always a bug; compare against a tolerance.equality

&if ((flags & MASK) != 0)Lower precedence than ==, which is the classic bug: (x & 1 == 0) parses as x & (1 == 0).bitwise and

^a ^= b; b ^= a; a ^= b;bitwise exclusive or

|flags |= O_APPEND;Also lower precedence than the comparisons. Parenthesise.bitwise or

&&if (p && p->next)The right side is not evaluated if the left is 0, and there is a sequence point between them.logical and, short-circuiting

||if (!p || p->n == 0)Same, when the left is nonzero.logical or, short-circuiting

c ? a : bmax = a > b ? a : b;Exactly one arm is evaluated. The common type of the arms is worked out by the usual conversions.conditional

Assignment and comma

= += -= *= /= %=x += 1;The left operand is evaluated only once in a compound assignment — the reason a[f()] += 1 is safe and a[f()] = a[f()] + 1 is not.assign and compound-assign

&=  |=  ^=  <<=  >>=flags &= ~MASK;bitwise compound assignment

,for (i = 0, j = n; i < j; i++, j--)Evaluates left, discards it, yields right. There IS a sequence point. Not the comma in an argument list.the comma operator

The precedence traps

*p++*p++ == *(p++) (*p)++ /* different */Postfix binds tighter than unary *. (*p)++ increments what it points at. [undefined, unspecified or implementation-defined]increments p, not *p

&x[i]&a[3] == a + 3Subscript binds tighter than &.the address of the element

x & 1 == 0(x & 1) == 0 /* what you meant */Equality binds tighter than the bitwise operators. This is the single most common C precedence bug.parses as x & (1 == 0)

-1 >> 1(unsigned)-1 >> 1 /* defined */Arithmetic shift on every real compiler, but the standard does not require it.implementation-defined

*p.f(*p).f == p->fThe member operators bind tighter than the dereference. Use p->f.parses as *(p.f)

Types & Limits

31

What is actually guaranteed

CHAR_BITbits in a byte — at least 8

sizeof(char) == 1by definition, always

short >= 16 bitsand int >= 16 bits

long >= 32 bitsand long long >= 64

plain char signednessimplementation-defined

sizeof(void*) vs sizeof(int)unrelated

sizeof(struct) >= sum of memberspadding is permitted

The fixed-width types — <stdint.h>

int8_t … int64_texactly that many bits, two’s complement

uint8_t … uint64_tthe unsigned forms

int_least8_t / int_fast8_tat least / fastest at least

intptr_t / uintptr_tan integer that can hold a pointer

intmax_t / uintmax_tthe widest integer type

size_tthe type of sizeof — unsigned

ptrdiff_tthe type of a pointer difference — signed

SIZE_MAX / SIZE_C(x)the limit, and a constant of that type

PRId64 / PRIu32 / SCNx16the printf and scanf macros

<limits.h> and <float.h>

CHAR_MIN / CHAR_MAXthe range of plain char

SCHAR_MIN / UCHAR_MAXthe explicit forms

INT_MIN / INT_MAX / UINT_MAXint and unsigned int

LONG_MAX / LLONG_MAXthe wider signed types

DBL_EPSILONthe gap between 1.0 and the next double

DBL_MIN / DBL_MAXthe smallest normal and the largest finite

DBL_DIG / DBL_DECIMAL_DIGdigits you can trust: 15 / 17

FLT_EVAL_METHODwhat precision intermediates use

Conversion rules, in order

integer promotionanything narrower than int becomes int

usual arithmetic conversionsthe narrower operand converts to the wider

signed → unsignedwell defined: modulo 2^N

unsigned → signedimplementation-defined if it does not fit

float → integertruncates toward zero; UB if out of range

array → pointerdecays to a pointer to its first element

function → pointerdecays, everywhere but sizeof and &

Declarations

23

Reading one

the spiral ruleint *a[10]; /* array of pointers */ int (*b)[10]; /* pointer to array */Right binds tighter: [] and () beat *. When in doubt, parenthesise, or run cdecl.start at the name, go right, then left

int (*f)(void)int (*fp)(int, int) = add; int r = fp(1, 2);Without the parentheses it is a function returning int*.pointer to function returning int

int *f(void)int *make(void);function returning pointer to int

char *argv[]int main(int argc, char *argv[])As a parameter it is really char**; the array bound is discarded.array of pointers to char

int (*a[5])(void)int (*ops[5])(void) = { f, g };The shape a dispatch table takes.array of 5 pointers to function

typedef, to stop the paintypedef int (*op)(int, int); op table[4];One typedef turns every declaration above into something readable.name the intermediate type

Where const goes

const char *pconst char *p = "hi"; p = "bye"; /* ok */ p[0] = 'H'; /* err */p may be reassigned; *p may not be written. Same as char const *p.pointer to const char

char *const pchar *const p = buf; p[0] = 'H'; /* ok */ p = other; /* err */p may not be reassigned; *p may be written.const pointer to char

const char *const pconst char *const msg = "hi";Read it right to left and it says exactly that.both

casting const away*(char *)cp = 'x'; /* UB if const */Only if the underlying object was not itself defined const. [undefined, unspecified or implementation-defined]legal to do, undefined to then write

Initialisation

= {0}struct P p = {0}; int a[100] = {0};Any omitted member is zero-initialised, so {0} zeroes everything.zero-initialise the whole object

= {}struct P p = {};Same effect, and it works for a struct whose first member is itself a struct. [new in C23]the C23 empty initialiser

= { .x = 1, .y = 2 }struct P p = { .y = 2 }; /* x = 0 */C99. Order-independent, and everything unnamed is zeroed.designated initialisers

= { [3] = 7 }int a[] = { [9] = 1 }; /* 10 ints */The array is sized by the highest index used.designated array initialisers

no initialiser, automatic storageint x; /* garbage */ static int y; /* 0 */Reading it is undefined behaviour. Static and thread storage are zeroed for you. [undefined, unspecified or implementation-defined]the value is indeterminate

char s[] = "hi"char a[] = "hi"; /* writable */ char *b = "hi"; /* not */Whereas char *s = "hi" points at a string literal you may not write to.a modifiable copy, 3 bytes

Structs, unions, enums

struct tag { ... };the tag namespace is separate

struct { int n; int a[]; }a flexible array member

unionone object, several readings

bitfieldsint x : 3;

anonymous struct / unionmembers promoted to the enclosing scope

enum with a fixed typeenum E : unsigned char { ... }

offsetof(T, m)the byte offset of a member

The Preprocessor

23

Directives

#include "f.h" / <f.h>#include <stdio.h> #include "config.h"The angle form searches only the system list, which is why a header of your own found with <> is a build-system bug.quoted searches locally first

#define / #undef#define MAX(a,b) ((a) > (b) ? (a) : (b))A function-like macro is only that if the ( follows the name with no space.define and remove a macro

#if / #elif / #else / #endif#if defined(__linux__) && !defined(NDEBUG)The expression is integer only: no sizeof, no floats, no enums. Undefined identifiers become 0.conditional compilation

#ifdef / #ifndef#ifndef HDR_H #define HDR_H ... #endifThe include-guard idiom, and the wrong tool for anything with two conditions.shorthand for defined()

#elifdef / #elifndef#ifdef A #elifdef B #endifNew in C23; nothing else changed about conditionals. [new in C23]the C23 shorthands

#error / #warning#if CHAR_BIT != 8 #error "need 8-bit bytes" #endif#warning was a universal extension long before C23 standardised it.stop, or complain

#pragma#pragma once #pragma pack(push, 1)An unrecognised pragma is ignored, which is why -Wunknown-pragmas exists.implementation-defined instruction

#line#line 42 "input.y"What generated code emits so errors point at the real source.reset the line number and file name

#embedconst unsigned char logo[] = { #embed "logo.png" };C23. Replaces the xxd-and-generate-a-header dance entirely. [new in C23]include a binary file as bytes

Operators inside a macro

#x#define STR_(x) #x #define STR(x) STR_(x) STR(__LINE__) /* "42" */It stringifies the argument BEFORE expansion, so you need a second level of macro to expand it first.stringify the argument

a##b#define CAT_(a,b) a##b #define CAT(a,b) CAT_(a,b)Same two-level rule. The result must be a single valid token.paste two tokens together

__VA_ARGS__#define LOG(f, ...) \ printf(f, __VA_ARGS__)C99. At least one argument was required until C23.the variadic arguments

__VA_OPT__(x)#define LOG(f, ...) \ printf(f __VA_OPT__(,) __VA_ARGS__)C23 (a GNU extension long before). Solves the trailing-comma problem properly. [new in C23]x only if there were variadic args

do { ... } while (0)#define SWAP(a,b) do { \ int t=(a); (a)=(b); (b)=t; \ } while (0)Makes the macro safe as the body of an if without braces, and forces the trailing semicolon.the multi-statement macro wrapper

Predefined, and required

__FILE__ / __LINE__printf("%s:%d\n", __FILE__, __LINE__);assert is built out of these two.the current file and line

__func__printf("in %s\n", __func__);C99. Not a macro — it is a static const char array the compiler declares.the enclosing function’s name

__DATE__ / __TIME__when it was compiled

__STDC__1 in a conforming implementation

__STDC_VERSION__#if __STDC_VERSION__ >= 202311L199901L, 201112L, 201710L, 202311L for C23.the standard, as a number

__STDC_HOSTED__1 hosted, 0 freestanding

NDEBUGturns assert into nothing

__has_include(<x.h>)#if __has_include(<threads.h>)C23, and a Clang extension for years before.is this header available?

__has_c_attribute(x)is this [[attribute]] available?

Standard Attributes

13

C23 [[...]] attributes

[[deprecated]][[deprecated("use g")]] void f(void);Optional message: [[deprecated("use g()")]]. [new in C23]warn when this is used

[[nodiscard]][[nodiscard]] int open_it(void);The standard spelling of GNU warn_unused_result. Optional message. [new in C23]warn when the result is thrown away

[[maybe_unused]]void cb([[maybe_unused]] void *ctx);For a parameter kept to match a callback signature. [new in C23]do not warn if this is unused

[[fallthrough]]case 1: f(); [[fallthrough]]; case 2:A comment no longer counts under -Wimplicit-fallthrough=5. [new in C23]this switch case falls through deliberately

[[noreturn]][[noreturn]] void die(const char *m);Replaces C11’s _Noreturn, which is deprecated. [new in C23]this function does not return

[[unsequenced]][[unsequenced]] int sq(int x);Lets the compiler cache the result across calls. [new in C23]pure: no state, same answer every time

[[reproducible]]effectively pure, but may read state

The GNU forms they replaced

__attribute__((deprecated))the pre-C23 spelling

__attribute__((warn_unused_result))became [[nodiscard]]

__attribute__((unused))became [[maybe_unused]]

__attribute__((noreturn))became [[noreturn]]

__attribute__((cleanup(f)))void closep(FILE **f){ if(*f) fclose(*f); } __attribute__((cleanup(closep))) FILE *f = fopen(p, "r");Runs f when the variable leaves scope — the closest C gets to RAII, and still an extension. [a common extension, not ISO C]no standard equivalent

__attribute__((format(printf,1,2)))no standard equivalent

Undefined Behaviour

28

Arithmetic

signed integer overflowif (ckd_add(&r, a, b)) overflow();Which is why `if (x + 1 < x)` is deleted. Use __builtin_add_overflow or the C23 ckd_* functions. [undefined, unspecified or implementation-defined]the optimiser assumes it cannot happen

division or remainder by zeroundefined, not a signal you may catch

INT_MIN / -1overflows, so undefined

shift by >= the widthundefined

shift of a negative valueleft shift undefined; right implementation-defined

conversion of an out-of-range floatundefined

Memory and pointers

dereferencing NULLundefined

reading uninitialised memoryundefined, and unstable

use after free, double freeundefined

out-of-bounds accessundefined

pointer arithmetic outside an objectundefined even without dereferencing

comparing unrelated pointers with < >undefined

misaligned access through a pointerundefined

strict aliasing violationfloat f; uint32_t u; memcpy(&u, &f, sizeof u);Accessing an object through a pointer to an unrelated type. memcpy is the portable fix; a union works in C. [undefined, unspecified or implementation-defined]undefined

modifying a string literalundefined

overlapping memcpyundefined — restrict was the promise

Sequencing and objects

i = i++two unsequenced modifications

f(i++, i++)argument evaluation is unsequenced

returning a pointer to a localthe object is gone at the return

falling off a non-void functionundefined if the caller uses the value

a data raceundefined

infinite loop with no side effectsundefined

What to do about it

-fsanitize=undefinedcatches most of the arithmetic ones at run time

-fsanitize=addresscatches the memory ones

-fwrapvmakes signed overflow wrap, defined

-fno-strict-aliasingstops the compiler using type-based aliasing

memcpy for type punningalways correct, always optimised away

unsigned for anything that may wrapwrapping is defined for unsigned

Strings & Memory

32

<string.h> — the memory half

memcpy(d, s, n)copy n bytes; must not overlap

memmove(d, s, n)copy n bytes; overlap is fine

memset(p, c, n)fill with a byte value

memcmp(a, b, n)compare bytes; returns sign

memchr(p, c, n)find a byte

memset_explicit(p, c, n)a memset the optimiser may not remove

memccpy(d, s, c, n)copy up to and including c

<string.h> — the string half

strlen(s)length, not counting the NUL

strcpy(d, s)copy, including the NUL

strncpy(d, s, n)NOT a safe strcpy

strlcpy(d, s, n)truncating copy that always terminates

snprintf(d, n, "%s", s)the portable safe copy

strcmp / strncmpcompare; returns sign

strchr / strrchrfind a character, first / last

strstr(h, n)find a substring

strspn / strcspnlength of the prefix in / not in a set

strtok(s, d)destructive, and holds static state

strdup / strndupallocate a copy

strerror(errno)the message for an errno value

<stdlib.h> — memory and conversion

malloc(n)n bytes, uninitialised

calloc(n, sz)n*sz bytes, zeroed

realloc(p, n)resize; may move the block

free(p)release it; free(NULL) is fine

aligned_alloc(a, n)aligned allocation

free_sized(p, n)free, telling it the size

atoi(s)no error reporting at all

strtol(s, &end, base)the one that reports errors

strtod / strtofthe same, for floating point

qsort(base, n, sz, cmp)sort, unstable

bsearch(k, base, n, sz, cmp)binary search a sorted array

abort / exit / atexitend the program

getenv(name)read the environment

Input & Output

40

<stdio.h> — streams

fopen(path, "rb")open a stream

fclose(f)close, flushing first

fread(p, sz, n, f)read n items of sz bytes

fwrite(p, sz, n, f)the mirror image

fgets(buf, n, f)read a line, safely

gets(s)removed from the language

getline(&p, &n, f)read a line, allocating as needed

fseek / ftell / rewindposition a stream

fflush(f)push buffered output out

setvbuf(f, NULL, _IONBF, 0)change the buffering

feof / ferror / clearerrwhy the last call stopped

remove / rename / tmpfilefilesystem operations

printf conversions

%d %isigned int

%u %o %x %Xunsigned: decimal, octal, hex

%f %Ffixed point, 6 decimals by default

%e %Escientific

%g %Gthe shorter of %e and %f

%a %Ahexadecimal float

%sa NUL-terminated string

%cone character

%pa pointer

%%a literal percent sign

%nwrite the count so far through a pointer

Length modifiers and flags

%hhd %hdsigned char, short

%ld %lldlong, long long

%zusize_t

%tdptrdiff_t

%jdintmax_t

%Lflong double

%" PRId64 "a fixed-width type

%-10s %10sleft / right justify in a field

%08.3fzero-pad to 8, 3 decimals

%+d % dalways sign; space for positive

%#x %#oalternate form: 0x, 0 prefix

%*d %.*swidth or precision from an argument

scanf, and why not to

scanf("%d", &n)leaves the bad input in the buffer

scanf("%s", buf)unbounded, like gets

fgets + strtolthe replacement

sscanf(line, "%d %d", &a, &b)parse from a string

%[^\n]a scanset: everything but newline

Maths & Time

24

<math.h> — the ones with sharp edges

fabs / fmin / fmaxabsolute value, minimum, maximum

sqrt / cbrt / hypotroots; hypot avoids overflow

pow(x, y)x to the y

exp / log / log2 / log10exponential and logarithms

sin / cos / tan / atan2trigonometry, in radians

floor / ceil / round / truncthe four roundings

fmod / remainderfloating remainder, two definitions

isnan / isinf / isfiniteclassify a value

NaN comparisonsevery comparison with NaN is false

nextafter(x, y)the next representable value

fma(x, y, z)x*y+z with one rounding

ckd_add / ckd_sub / ckd_mulchecked integer arithmetic

<time.h>

time(NULL)seconds since the epoch

clock_gettime(CLOCK_MONOTONIC, &ts)the one to measure elapsed time with

timespec_get(&ts, TIME_UTC)the ISO C spelling

clock()processor time, in CLOCKS_PER_SEC

localtime_r / gmtime_rbroken-down time, reentrantly

strftime(buf, n, "%F %T", tm)format a time

mktime(&tm)broken-down time back to time_t

difftime(a, b)the difference, as a double

<ctype.h>, and the trap in it

isalpha / isdigit / isspace …isspace((unsigned char)*p)The argument must be representable as unsigned char or be EOF. Passing a plain char that is negative is undefined behaviour. [undefined, unspecified or implementation-defined]classify a character

tolower / toupperconvert case

isprint / isgraph / ispunctprintable, printable-not-space, punctuation

isxdigita hexadecimal digit

Threads & Atomics

24

<threads.h> — C11, and often absent

thrd_create(&t, fn, arg)start a thread

thrd_join(t, &res)wait for it, collect the result

thrd_detach(t)never join it; it cleans itself up

mtx_init / mtx_lock / mtx_unlocka mutex

cnd_wait / cnd_signal / cnd_broadcasta condition variable

call_once(&flag, fn)run exactly once, ever

tss_create / tss_get / tss_setthread-specific storage

pthread_* insteadwhat everything actually uses

<stdatomic.h>

_Atomic int n;an atomic object

atomic_load / atomic_storeexplicit access

atomic_load_explicit(&n, memory_order_relaxed)access with a chosen ordering

atomic_fetch_add / _sub / _or / _andread-modify-write

atomic_compare_exchange_weak(&p, &e, d)CAS, in a loop

atomic_flag_test_and_setthe one lock-free type guaranteed

atomic_is_lock_free(&x)ask whether it really is

atomic_thread_fence(order)a standalone barrier

The memory orders, from weakest

memory_order_relaxedatomic, no ordering at all

memory_order_consumeordering through data dependency

memory_order_acquirelater reads may not move before this load

memory_order_releaseearlier writes may not move after this store

memory_order_acq_relboth, for a read-modify-write

memory_order_seq_cstone total order across all threads

a data raceundefined behaviour, not a wrong answer

volatile is not atomicit orders nothing between threads

Standard Headers

36

Freestanding (available everywhere)

<stddef.h>size_t ptrdiff_t NULL offsetof

<stdint.h>int32_t uintptr_t INT64_MAX

<limits.h>INT_MAX CHAR_BIT

<stdbool.h>bool true false

<stdalign.h>alignas alignof

<stdarg.h>va_list va_start va_arg

<float.h>DBL_EPSILON FLT_EVAL_METHOD

<stdatomic.h>_Atomic and the memory orders

<stdnoreturn.h>noreturn

Hosted

<stdio.h>FILE printf fopen

<stdlib.h>malloc strtol qsort exit

<string.h>memcpy strlen strcmp

<math.h>sqrt fma isnan

<tgmath.h>type-generic maths

<errno.h>errno and the E constants

<assert.h>assert static_assert

<time.h>clock_gettime strftime

<ctype.h>isalpha tolower

<inttypes.h>PRId64 SCNu32 strtoimax

<signal.h>signal raise sig_atomic_t

<setjmp.h>setjmp longjmp

<locale.h>setlocale

<threads.h>thrd_create mtx_t

<complex.h>complex I cabs

<fenv.h>fesetround feclearexcept

<uchar.h>char16_t char32_t

<wchar.h> <wctype.h>wide characters

POSIX, in constant use

<unistd.h>read write close fork getopt

<fcntl.h>open O_RDONLY

<sys/stat.h>stat mkdir chmod

<sys/mman.h>mmap munmap

<pthread.h>the actual threading API

<dlfcn.h>dlopen dlsym dlerror

<sys/socket.h> <netdb.h>sockets and getaddrinfo

<poll.h>poll

<endian.h>htobe64 and friends

C23 at a Glance

33

New keywords and spellings

bool true falsenow keywords

nullptr / nullptr_ta typed null pointer constant

constexpra true compile-time constant object

typeof(x) / typeof_unqual(x)the GNU extension, standardised

autotype inference from the initialiser

static_assert(c, "msg")a keyword now

alignas / alignofwithout the underscores

thread_localwithout the underscore

_BitInt(N)exact-width integer of any width

New syntax

[[nodiscard]] [[maybe_unused]]standard attribute syntax

[[gnu::always_inline]]vendor-namespaced attributes

0b1010 and 1'000'000binary literals and digit separators

#embed "file"embed a binary file

__VA_OPT__(,)conditional variadic expansion

struct s v = {};the empty initialiser

enum e : unsigned char { ... }an enum with a fixed underlying type

f()now means f(void)

New library

<stdbit.h>portable bit operations

<stdckdint.h>checked arithmetic

unreachable()in <stddef.h>

memset_explicit()a memset the optimiser may not remove

strdup / strndupfinally standard

memccpy / strdupimported from POSIX

timespec_getres()clock resolution

printf %bbinary conversion

Removed or deprecated

K&R function definitionsremoved

Trigraphsremoved

Implicit intlong gone, now firmly an error

Implicit function declarationsnow an error

_Noreturn / <stdnoreturn.h>deprecated

<iso646.h>deprecated

ATOMIC_VAR_INITremoved

Non-two's-complement signed integersremoved from the standard