Modern C (Jens Gustedt)（Z-Library）

【One-Line Pitch】 A level-based guide to modern, standardized C that teaches you to write correct, portable code rather than just syntax—best for programmers who already know some C (or another language) and want to understand what the language actually guarantees. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's premise—C has evolved through ISO standards (C89 through C23), and backward compatibility has left many codebases stuck on old idioms. Introduces the four-level structure (Encounter, Acquaintance, Cognition, Experience) and walks through a first complete program to establish vocabulary like statements, function calls, and format specifiers. - **Early (~10%–35%)**: Level 0–1 fundamentals: program structure, control flow (`for`, `break`, `continue`), operators and their evaluation-order traps, and the basics of values, types, and binary representations. Builds the mental model of C as an abstract state machine that compilers may optimize "as if" following. - **Middle (~35%–55%)**: Deeper type theory—integer signedness, sign representations, literal values and their surprising equivalences, enumerations, and Boolean values. This is where the book shifts from "how to write C" to "what C actually promises," including where the standard leaves behavior implementation-defined. - **Late (~55%–80%)**: Level 2 "Cognition"—pointers, the memory model, and the library interface, plus program organization. Excerpts also preview advanced material: initialization, a machine model, text and binary I/O, error checking, and performance topics like inline functions and `restrict`. - **Ending (~80%–100%)**: Level 3 "Experience"—performance measurement and inspection, function-like macros (argument checking, default arguments, variadic lists). The excerpts do not cover the closing chapters in detail. 【Key Takeaways】 - **C is a standardized, evolving language, not K&R C** (Opening): The book consistently tags newer features with the standard revision that introduced them, so you learn which idioms are portable to which compilers—critical for real-world codebases. - **Structure learning in levels, not chapters** (Opening): The Encounter → Acquaintance → Cognition → Experience progression lets you stop at a useful point (e.g., after Level 1 for an algorithms course) or go deep for professional work. - **Evaluation order is a major hazard** (Early): Most operators don't sequence their operands, and function arguments are evaluated in unspecified order. The practical rule: avoid side effects inside expressions and don't rely on `,` as an operator. - **Types have observable binary representations** (Middle): The standard specifies enough about integer and floating-point representation that you can reason about limits, overflow, and precision—and understand why `0.2` isn't exactly `0.2`. - **Signedness and sign representation matter** (Middle): Positive values are represented identically regardless of signedness, but negative values depend on the implementation's chosen sign representation (two's complement now dominant). This explains many portability bugs. - **Define variables close to first use** (Early): Uninitialized pointers are a classic pitfall; combining declaration with initialization is the book's recommended discipline. - **Compilers optimize "as if" following an abstract machine** (Middle): Understanding this model explains why seemingly redundant code can be transformed and why undefined behavior is so dangerous. - **Macros are a power tool with sharp edges** (Ending): Function-like macros enable argument checking, default arguments, and variadic lists—but require careful design to stay safe. 【Reading Tips】 - **Skim Level 0 if you already program in C**; it's a vocabulary refresher. Spend your time on Levels 1–2, where the real conceptual payload (pointers, memory model, type representations) lives. - **Deep-read the "Takeaway" boxes**—they distill the book's rules of thumb and are the fastest way to review after a first pass. - **Treat evaluation order and signedness as hard spots**: work the examples, don't just read them. These are where experienced C programmers still get bitten. - **Use the standard-revision tags as a portability checklist** when adopting newer features in legacy projects. - **Do the challenges** (e.g., Union-Find) to convert reading into practice; the book is designed for active use. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book plus the table of contents; the later chapters on pointers, the memory model, I/O, and macros are only previewed, so their detailed treatment is not summarized here.