Scott Craig / Скотт Крейг - Professional CMake: A Practical Guide, 21st Edition / Профессиональный CMake: Практическое руководство, 21-е издание [2025, PDF/EPUB, ENG]

Примеры страниц (скриншоты)

Оглавление

Professional CMake: A Practical Guide
Preface
Acknowledgments
I: Getting Started
1. Introduction
2. Setting Up A Project
2.1. In-source Builds
2.2. Out-of-source Builds
2.3. Generating Project Files
2.4. Running The Build Tool
2.5. Recommended Practices
3. A Minimal Project
3.1. Managing CMake Versions
3.2. The project() Command
3.3. Building A Basic Executable
3.4. Commenting
3.5. Recommended Practices
4. Building Simple Targets
4.1. Executables
4.2. Defining Libraries
4.3. Linking Targets
4.4. Linking Non-targets
4.5. Old-style CMake
4.6. Recommended Practices
5. Basic Testing And Deployment
5.1. Testing
5.2. Installing
5.3. Packaging
5.4. Recommended Practices
II: Fundamentals
6. Variables
6.1. Variable Basics
6.2. Environment Variables
6.3. Cache Variables
6.4. Scope Blocks
6.5. Printing Variable Values
6.6. String Handling
6.7. Lists
6.8. Math
6.9. Recommended Practices
7. Flow Control
7.1. The if() Command
7.2. Looping
7.3. Recommended Practices
8. Using Subdirectories
8.1. add_subdirectory()
8.2. include()
8.3. Project-relative Variables
8.4. Ending Processing Early
8.5. Recommended Practices
9. Functions And Macros
9.1. The Basics
9.2. Argument Handling Essentials
9.3. Keyword Arguments
9.4. Returning Values
9.5. Overriding Commands
9.6. Special Variables For Functions
9.7. Other Ways Of Invoking CMake Code
9.8. Problems With Argument Handling
9.9. Recommended Practices
10. Properties
10.1. General Property Commands
10.2. Global Properties
10.3. Directory Properties
10.4. Target Properties
10.5. Source Properties
10.6. Cache Variable Properties
10.7. Test Properties
10.8. Installed File Properties
10.9. Recommended Practices
11. Generator Expressions
11.1. Simple Boolean Logic
11.2. Target Details
11.3. General Information
11.4. Path Expressions
11.5. List Expressions
11.6. Utility Expressions
11.7. Recommended Practices
12. Modules
12.1. Checking Existence And Support
12.2. Other Modules
12.3. Recommended Practices
13. Policies
13.1. Policy Control By Version
13.2. Policy Control By Version Range
13.3. Controlling Individual Policies
13.4. Policy Scope
13.5. Overriding Policy Defaults And Warnings
13.6. Policy Removal
13.7. Recommended Practices
14. Debugging And Diagnostics
14.1. Log Messages
14.2. Color Diagnostics
14.3. Print Helpers
14.4. Tracing Variable Access
14.5. Debugging Generator Expressions
14.6. Profiling CMake Calls
14.7. Discarding Previous Results
14.8. Interactive Debugging
14.9. Recommended Practices
15. Build Type
15.1. Build Type Basics
15.2. Common Errors
15.3. Custom Build Types
15.4. Recommended Practices
16. Compiler And Linker Essentials
16.1. Target Properties
16.2. Target Property Commands
16.3. Target Property Contexts
16.4. Directory Properties And Commands
16.5. De-duplicating Options
16.6. Compiler And Linker Variables
16.7. Language-specific Compiler Flags
16.8. Compiler Option Abstractions
16.9. Recommended Practices
III: Builds In Depth
17. Language Requirements
17.1. Setting The Language Standard Directly
17.2. Setting The Language Standard By Feature
Requirements
17.3. Requirements For C++20 Modules
17.4. Recommended Practices
18. Advanced Linking
18.1. Require Targets For Linking
18.2. Customize How Libraries Are Linked
18.3. Propagating Up Direct Link Dependencies
18.4. Recommended Practices
19. Target Types
19.1. Executables
19.2. Libraries
19.3. Promoting Imported Targets
19.4. Recommended Practices
20. Custom Tasks
20.1. Custom Targets
20.2. Adding Build Steps To An Existing Target
20.3. Commands That Generate Files
20.4. Configure Time Tasks
20.5. Platform Independent Commands
20.6. Combining The Different Approaches
20.7. Recommended Practices
21. Working With Files
21.1. Manipulating Paths
21.2. Copying Files
21.3. Reading And Writing Files Directly
21.4. File System Manipulation
21.5. File Globbing
21.6. Downloading And Uploading
21.7. Recommended Practices
22. Specifying Version Details
22.1. Project Version
22.2. Source Code Access To Version Details
22.3. Source Control Commits
22.4. Recommended Practices
23. Libraries
23.1. Build Basics
23.2. Linking Static Libraries
23.3. Shared Library Versioning
23.4. Interface Compatibility
23.5. Symbol Visibility
23.6. Mixing Static And Shared Libraries
23.7. Recommended Practices
24. Toolchains And Cross Compiling
24.1. Toolchain Files
24.2. Defining The Target System
24.3. Tool Selection
24.4. System Roots
24.5. Compiler Checks
24.6. Examples
24.7. Android
24.8. Recommended Practices
25. Apple Features
25.1. CMake Generator Selection
25.2. Application Bundles
25.3. Frameworks
25.4. Loadable Bundles
25.5. Build Settings
25.6. Signing And Capabilities
25.7. Creating And Exporting Archives
25.8. Universal Binaries
25.9. XCFrameworks
25.10. Linking Frameworks
25.11. Embedding Frameworks And Other Things
25.12. Limitations
25.13. Recommended Practices
26. Build Performance
26.1. Unity Builds
26.2. Precompiled Headers
26.3. Build Parallelism
26.4. Optimizing Build Dependencies
26.5. Compiler Caches
26.6. Debug-related Improvements
26.7. Alternative Linkers
26.8. Recommended Practices
IV: Testing And Analysis
27. Testing Fundamentals
27.1. Defining And Executing A Simple Test
27.2. Test Environment
27.3. Pass / Fail Criteria And Other Result Types
27.4. Test Grouping And Selection
27.5. Cross-compiling, Emulators, And Launchers
27.6. JUnit Output
27.7. Recommended Practices
28. Test Resources And Constraints
28.1. Simple Test Dependencies
28.2. Test Fixtures
28.3. Parallel Execution
28.4. Simple Resource Constraints
28.5. Resource Groups
28.6. Recommended Practices
29. Build And Test Mode
29.1. Using Build And Test Mode
29.2. Use Cases
29.3. Alternatives
29.4. Recommended Practices
30. Test Frameworks
30.1. GoogleTest
30.2. Catch2
30.3. doctest
30.4. Recommended Practices
31. CDash Integration
31.1. Key CDash Concepts
31.2. Executing Pipelines And Actions
31.3. CTest Configuration
31.4. Test Measurements And Results
31.5. Output Control
31.6. Recommended Practices
32. Static Code Analysis
32.1. clang-tidy
32.2. cppcheck
32.3. cpplint
32.4. Include What You Use
32.5. Potential Problems With Co-compilation
32.6. File Sets Header Verification
32.7. Disabling Checks For Some Files
32.8. Recommended Practices
33. Dynamic Code Analysis
33.1. Sanitizers
33.2. Code Coverage
33.3. Recommended Practices
V: Deployment And Dependencies
34. Finding Things
34.1. Finding Files And Paths
34.2. Finding Programs
34.3. Finding Libraries
34.4. Finding Packages
34.5. Ignoring Search Paths
34.6. Debugging find_… () Calls
34.7. Recommended Practices
35. Installing
35.1. Directory Layout
35.2. Installing Project Targets
35.3. Installing Exports
35.4. Installing Imported Targets
35.5. Installing Files
35.6. Installing C++20 Modules
35.7. Custom Install Logic
35.8. Installing Dependencies
35.9. Writing A Config Package File
35.10. Executing An Install
35.11. Recommended Practices
36. Packaging
36.1. Packaging Basics
36.2. Components
36.3. Multi Configuration Packages
36.4. Recommended Practices
37. Package Generators
37.1. Simple Archives
37.2. Qt Installer Framework (IFW)
37.3. WIX
37.4. NSIS
37.5. Inno Setup
37.6. DragNDrop
37.7. productbuild
37.8. RPM
37.9. DEB
37.10. FreeBSD
37.11. Cygwin
37.12. NuGet
37.13. External
37.14. Recommended Practices
38. ExternalProject
38.1. High Level Overview
38.2. Directory Layout
38.3. Built-in Steps
38.4. Step Management
38.5. Miscellaneous Features
38.6. Common Issues
38.7. ExternalData
38.8. Recommended Practices
39. FetchContent
39.1. Comparison With ExternalProject
39.2. Basic Usage
39.3. Resolving Dependencies
39.4. Avoiding Sub-builds For Population
39.5. Integration With find_package()
39.6. Developer Overrides
39.7. Other Uses For FetchContent
39.8. Restrictions
39.9. Recommended Practices
40. Making Projects Consumable
40.1. Use Project-specific Names
40.2. Don’t Assume A Top Level Build
40.3. Avoid Hard-coding Developer Choices
40.4. Avoid Package Variables If Possible
40.5. Use Appropriate Methods To Obtain
Dependencies
40.6. Recommended Practices
41. Dependency Providers
41.1. Top Level Setup Injection Point
41.2. Dependency Provider Implementation
41.3. Recommended Practices
VI: Project Organization
42. Presets
42.1. High Level Structure
42.2. Configure Presets
42.3. Build Presets
42.4. Test Presets
42.5. Package Presets
42.6. Workflow Presets
42.7. Recommended Practices
43. Project Structure
43.1. Superbuild Structure
43.2. Non-superbuild Structure
43.3. Common Top Level Subdirectories
43.4. IDE Projects
43.5. Defining Targets
43.6. Cleaning Files
43.7. Re-running CMake On File Changes
43.8. Injecting Files Into Projects
43.9. Recommended Practices
VII: Special Topics
44. Debugging Executables
44.1. Working Directory
44.2. Environment Variables
44.3. Finding Windows DLLs At Runtime
44.4. Command Line Arguments
44.5. PDB Generation
44.6. Recommended Practices
45. Working With Qt
45.1. Making Qt Available To The Project
45.2. Standard Project Setup
45.3. Command And Target Names
45.4. Defining Targets
45.5. Autogen
45.6. Translations
45.7. Deployment
45.8. Recommended Practices
Appendix A: Full Compiler Cache Example
Appendix B: Sanitizers Example
Appendix C: Timer Dependency Provider