Professional CMake A Practical Guide (Craig Scott)（Z-Library）

# Professional CMake: A Practical Guide — Reading Guide ## 【One-Line Pitch】 The definitive hands-on handbook for anyone who writes or maintains CMake build systems, written by a CMake co-maintainer and covering everything from first executable to cross-compiling and packaging. If you've been copy-pasting CMake snippets without truly understanding them, this book will turn you into someone who can design clean, scalable build configurations. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces the philosophy of learning by doing, then walks through a minimal project — managing CMake versions, the `project()` command, and building your first executable and library targets. Establishes the "Recommended Practices" pattern that closes every chapter. - **Early (~9%–25%)**: Covers the core language: variables (normal, environment, and cache), string and list handling, control flow with `foreach()`/`while()`, subdirectories and scope, functions and macros, properties, and CMake policies. This is the foundation everything else builds on. - **Early–Middle (~25%–38%)**: Dives into build configuration in depth — build types (single vs. multi-configuration generators), compiler and linker flags, language standard selection (both direct and feature-based), file manipulation, version details, and library creation including shared library versioning and symbol visibility. - **Middle (~38%–47%)**: Covers toolchains and cross-compiling, Apple platform specifics (frameworks, bundles, code signing), then moves into the "bigger picture" of finding things — files, paths, programs, libraries, and packages via `find_package()` and package registries. - **Middle onward (~47%+)**: Introduces testing with CTest, and the excerpts indicate continued coverage of the broader ecosystem (the table of contents suggests packaging, installation, and exporting targets follow in later chapters). ## 【Key Takeaways】 - **CMake is a build system generator, not a build tool** (Opening): Understanding this distinction — CMake configures, then delegates to Make, Ninja, or Visual Studio — prevents fundamental misconceptions. The book's early chapters make this mental model explicit before any syntax is taught. - **Targets are the central abstraction** (Early): Modern CMake is target-based, not variable-based. Defining executables and libraries as targets and linking them with `target_link_libraries()` propagates usage requirements automatically, which is the key to scalable, maintainable build files. - **Cache variables are the user's interface** (Early): Unlike normal variables, cache variables persist across configure runs and can be set from the command line or GUI tools. Mastering the distinction between normal, cache, and environment variables is essential for writing configurable projects. - **Scope rules are subtle but critical** (Early): Subdirectories create variable scopes, functions create their own, and macros do not. Understanding how values flow (or don't) between scopes prevents a whole class of "why doesn't my variable exist" debugging sessions. - **Properties are metadata attached to targets, directories, and sources** (Early): Properties like compiler flags and include directories can be set at different levels with different inheritance rules. Knowing when to use a property versus a variable is a hallmark of idiomatic CMake. - **Build types differ between single and multi-config generators** (Early–Middle): Makefiles and Ninja are single-configuration (you pick Debug or Release at configure time), while Visual Studio and Xcode are multi-configuration (you pick at build time). This distinction affects how you set flags and structure your project. - **Language standards should be set by feature, not by version number** (Early–Middle): Using `target_compile_features()` with requirements like `cxx_std_11` lets CMake pick the right compiler flags automatically and fails early if the compiler is too old — more robust than hardcoding `-std=c++17`. - **Finding dependencies is a skill in itself** (Middle): The book covers the full spectrum — `find_file()`, `find_path()`, `find_program()`, `find_library()`, and `find_package()` — including package registries and pkg-config integration. This is where real-world projects often get messy, and the guidance here is practical. ## 【Reading Tips】 - **Skim the first two chapters if you've used CMake before**, but don't skip the "Recommended Practices" sections — they contain hard-won community wisdom that even experienced users will find valuable. - **Deep-read Chapters 5–8 (variables, control flow, subdirectories, functions)** — these are the language fundamentals that everything else builds on. Work through the examples interactively; CMake is a tool you learn by running, not just reading. - **Pay special attention to Chapter 20 (Libraries)** if you maintain libraries for others — shared library versioning, symbol visibility, and interface compatibility are topics rarely covered well elsewhere. - **Use the book as a reference, not just a tutorial**: the table of contents is detailed enough that you can jump to specific topics (e.g., "cross-compiling" or "Apple frameworks") when you hit a real problem. - **Keep a CMake project open while reading** — the book explicitly encourages experimentation, and the examples are designed to be tried immediately. ## 【Coverage Limits】 This guide is based on excerpts covering roughly the first half of the book (through testing). Later chapters on packaging, installation, exporting targets, and advanced generator expressions are not covered in detail here. ##