C Reference

Getting Started — what C is, the standard editions from K&R to C23, the major compilers, "Hello, World", and compiling with -std=c23 -Wall -Wextra.

Program Structure — declarations vs. definitions, translation units and headers, the translation phases, `main’s signatures, and exit status.

Lexical Structure and Style — character sets, comments, identifiers and reserved names, the C23 keyword list, every literal form, attribute syntax, and the formatting conventions.

Basic Types and Values — the abstract state machine, bool, character and integer types, <stdint.h> and _BitInt, floating-point types, the integer promotions and the conversion traps.

Constants, Enumerations and Initialization — const, enum with C23 fixed underlying types, macros vs. constexpr, compound literals, every initializer form, and static_assert.

Operators and Expressions — arithmetic, integer division, bitwise and shift operators, the precedence table, lvalues, and evaluation order and sequencing.

Control Flow — if/else, switch and fall-through, the three loop forms, break/continue, goto for cleanup, and return.

Functions — prototypes, pass-by-value, array parameters, recursion, static and inline, [[noreturn]], and variadic functions.

Arrays and Strings — array length and sizeof, multidimensional and variable-length arrays, array-to-pointer decay, string literals, and the <string.h> essentials.

Structures, Unions and Type Aliases — struct and designated initialization, typedef, tagged unions, bit-fields, flexible array members, and alignment and padding.

Pointers — address-of and dereference, pointer arithmetic, validity and dangling pointers, nullptr, void *, const and restrict, and function pointers.

Memory Model and Alignment — object representation, type punning, effective types and strict aliasing, and alignas/alignof.

Dynamic Memory Allocation — malloc/calloc/realloc/free, growable arrays, ownership rules, and the classic defects.

Storage Duration, Scope and Linkage — the four storage durations, the scopes, internal vs. external linkage, and thread_local.

Preprocessor and Macros — macro hygiene, include guards, conditional compilation, __has_include, stringification and token pasting, __VA_OPT__, and #embed.

Type-Generic Programming — _Generic selection, <tgmath.h>, typeof/typeof_unqual, and C23 auto.

Standard Library Overview — the C23 header catalogue, the interface conventions, errno discipline, Annex K, feature-test macros, assertions, and program termination.

Numbers and Math — <inttypes.h> format macros, C23 checked arithmetic and bit utilities, <math.h>, <fenv.h>, <complex.h>, and pseudo-random numbers.

Input, Output and Files — streams and FILE, the printf and scanf families, fopen modes, fread/fwrite, positioning, buffering, and EOF vs. error.

Strings and Text Processing — <string.h> and <ctype.h>, numeric conversion, snprintf, locales, UTF-8, and restartable conversions.

Dates and Times — time_t, struct timespec, struct tm, strftime, difftime, and measuring elapsed time.

Error Handling and Program Failure — the catalogue of undefined behavior, state degradation, error codes, cleanup with goto, assertions, and the sanitizers.

Advanced Control Flow — sequencing, goto, setjmp/longjmp and volatile, and signal handlers with async-signal safety.

Performance — measuring first, optimization levels, inline, restrict, the C23 function attributes, profiling, and why undefined behavior is a performance feature.

Threads — <threads.h>, thrd_create/thrd_join, call_once, thread-local storage, mutexes, condition variables and the wait loop, and liveness.

Atomics and Memory Consistency — _Atomic types and <stdatomic.h>, compare-and-exchange, happens-before, the memory orders, fences, and false sharing.

Build and Tooling — compiler invocation and warning flags, Make and CMake, sanitizers and Valgrind, static analysis, clang-format, debuggers, and Doxygen.

Testing — assert-based checks, a minimal harness, Unity / CMocka / Check / Criterion, CTest, and testing UB-sensitive code under sanitizers.

C Standards and C23 — the editions timeline, what C23 added and removed, the compiler support matrix, and writing transitional code.

Cheat Sheet (PDF) — a single-page, printable summary of everything in this section, with a downloadable PDF.