C in a Nutshell The Definitive Reference (Peter Prinz, Tony Crawford)（Z-Library）

【One-Line Pitch】 A rigorous, example-driven reference to the C language, its standard library, and the GNU toolchain, updated for C11. Best suited to experienced C or C++ programmers who need precise answers about how a feature or library function is *required* to behave, not a gentle first course in programming. 【Book Arc】 - **Opening (~0%–10%)**: Sets the frame — the book's three-part structure (language, standard library, GNU tools) and the C11 baseline, then moves into language basics: character sets, multibyte vs. wide characters, and the full taxonomy of integer types and literals. - **Early (~10%–30%)**: Builds the core mechanics of the language: implicit and explicit type conversions, the usual arithmetic conversions, expressions and operators, `sizeof`/`_Alignof`, and control flow including `switch` fall-through and jump statements. - **Middle (~30%–50%)**: Moves into program structure and data modeling — functions and call-by-reference via pointers, multidimensional arrays and matrices, pointer qualification rules, then structures, unions, bit-fields, and initialization (including C99 designated initializers). - **Late (~50%–80%)**: The reference core: memory management, input/output, and the standard library organized by header, with per-function behavior and typical usage examples. (Excerpts do not cover this range in detail.) - **Ending (~80%–100%)**: The toolchain section — building with GNU Make, compiling from source, debugging with GDB, and using these tools inside the Eclipse IDE. (Excerpts do not cover this range in detail.) 【Key Takeaways】 - **The book is a reference first, a tutorial second** (Opening): it is organized so you can look up an unfamiliar function or construct and immediately see its required behavior plus a worked example, rather than reading linearly. - **C11 is the baseline, not an afterthought** (Opening): multithreading, type-generic macros, `_Bool`/`stdbool.h`, `char16_t`/`char32_t`, and new conversion functions like `c16rtomb()` are treated as part of the language you are expected to know. - **Type conversion rules are the hidden source of most C bugs** (Early): the usual arithmetic conversions, integer promotion, and the signed/unsigned trap (e.g., comparing a negative `int` against an `unsigned` limit) are explained in detail because they silently change program meaning. - **`char` is not portable by default** (Opening): whether plain `char` is signed or unsigned is implementation-defined, so code that depends on values below 0 or above 127 should use `signed char` or `unsigned char` explicitly. - **Pointers carry qualification, and the compiler enforces it** (Middle): converting `int*` to `const int*` is implicit, but going the other way requires an explicit cast — a rule that shapes how you design read-only interfaces. - **Arrays and functions are more entangled than they look** (Middle/Early): a function parameter declared as an array is really a pointer, so `sizeof` inside the function yields a pointer size; multidimensional arrays are arrays of arrays, which is why matrices index row-then-column. - **Initialization has precise, sometimes surprising defaults** (Middle): partial initializers zero the remaining members, static-duration objects are zero-initialized, and C99 designated initializers (`.member`) let you target specific fields. - **`switch` is a jump table, not a branch chain** (Early): labels are just jump destinations, so execution falls through unless you `break`; variables declared inside a case should be wrapped in a nested block. 【Reading Tips】 - Treat it as a lookup companion: keep it beside you while coding and jump to the function or construct you need, rather than reading cover to cover. - Deep-read the type conversion and pointer-qualification chapters early — they explain the majority of subtle C defects and pay off across everything else. - Skim the integer-type and literal tables on a first pass, then return when you hit a portability or overflow question. - If you already know C++ but not C's corners, focus on the differences: `_Bool`, implicit conversions, array/pointer decay, and the C11 additions. - Use the GNU tools section as a hands-on lab — build and debug a small program with Make and GDB instead of only reading about them. 【Coverage Limits】 This guide is synthesized from stratified excerpts concentrated in the opening through middle of the book; the standard-library reference and GNU toolchain sections are described from the book's own overview rather than from detailed excerpt content, so specifics there are not covered here.