product iamge

CMake Best Practices: Discover proven techniques for creating and maintaining programming projects with CMake

This document was uploaded by one of our users. The uploader already confirmed that they had the permission to publish it. If you are author/publisher or own the copyright of this documents, please report to us by using this DMCA report form.

Download
Search on Amazon

Simply click on the Download Book button.

Yes, Book downloads on Ebookily are 100% Free.

Sometimes the book is free on Amazon As well, so go ahead and hit "Search on Amazon"

Explore a compendium of creating and maintaining CMake projects without any overhead using tips, tricks, and techniques to empower your workflow

Key Features

  • Understand what CMake is, how it works, and how to interact with it
  • Discover how to properly create and maintain well-structured CMake projects
  • Explore tools and techniques to get the most out of your CMake project

Book Description

CMake is a powerful tool used to perform a wide variety of tasks, so finding a good starting point for learning CMake is difficult. This book cuts to the core and covers the most common tasks that can be accomplished with CMake without taking an academic approach. While the CMake documentation is comprehensive, it is often hard to find good examples of how things fit together, especially since there are lots of dirty hacks and obsolete solutions available on the internet. This book focuses on helping you to tie things together and create clean and maintainable projects with CMake.

You'll not only get to grips with the basics but also work through real-world examples of structuring large and complex maintainable projects and creating builds that run in any programming environment. You'll understand the steps to integrate and automate various tools for improving the overall software quality, such as testing frameworks, fuzzes, and automatic generation of documentation. And since writing code is only half of the work, the book also guides you in creating installers and packaging and distributing your software. All this is tailored to modern development workflows that make heavy use of CI/CD infrastructure.

By the end of this CMake book, you'll be able to set up and maintain complex software projects using CMake in the best way possible.

What you will learn

  • Get to grips with architecting a well-structured CMake project
  • Modularize and reuse CMake code across projects
  • Integrate various tools for static analysis, linting, formatting, and documentation into a CMake project
  • Get hands-on with performing cross-platform builds
  • Discover how you can easily use different toolchains with CMake
  • Get started with crafting a well-defined and portable build environment for your project

Who This Book Is For

This book is for software engineers and build system maintainers working with C or C++ on a regular basis and trying to use CMake to better effect for their everyday tasks. Basic C++ and general programming knowledge will help you to better understand the examples covered in the book.

Table of Contents

  1. Kickstarting CMake
  2. Accessing CMake in Best Ways
  3. Creating a CMake Project
  4. Packaging, Deploying and Installing a CMake Project Effortlessly
  5. Integrating Third- Party Libraries and Dependency Management
  6. Automatically Generating Documentation with CMake
  7. Seamless Integration of Code Quality Tools with CMake
  8. Executing Custom Tasks with CMake
  9. Creating Reproducible Build Environments
  10. Handling Distributed Repositories and Dependencies in a Super-build
  11. Automated Fuzzing with CMake
  12. Cross-Platform-Compiling Custom Toolchains
  13. Reusing CMake Code
  14. Optimizing and Maintaining CMake Projects
  15. Migrating to CMake
  16. Contributing to CMake and Further Reading Material

Author(s): Dominik Berner, Mustafa Kemal Gilor
Edition: 1
Publisher: Packt Publishing
Year: 2022

Language: English
Pages: 343
Tags: CMake; Cross-Platform Compiling; Custom Toolchains; Software Building; Superbuild; Software Packaging; Migration to CMake

Cover
Title Page
Copyright and Credits
Contributors
Table of Contents
Preface
Part 1: The Basics
Chapter 1: Kickstarting CMake
Technical requirements
CMake in a nutshell
Installing CMake
Building CMake from source
Building your first project
A minimal CMakeLists.txt file
Understanding the CMake build process
Source folders and build folders
Writing CMake files
The CMake language – a 10,000-feet overview
Different toolchains and build types
Build types
Maintaining good build configurations with presets
Summary
Further reading
Questions
Chapter 2: Accessing CMake in Best Ways
Technical requirements
Using CMake via a command-line interface
Learning the basics of the CMake CLI
Advanced configuration using CMake-GUI and ccmake
Learning how to use ccmake (CMake curses GUI)
Using CMake via cmake-gui
Tweaking environment variables
Evaluating regular expressions with CMake
Using CMake in Visual Studio, Visual Studio Code, and Qt Creator
Visual Studio
Visual Studio Code
Qt Creator
Summary
Questions
Further reading
Chapter 3: Creating a CMake Project
Technical requirements
Setting up a project
Working with nested projects
Creating a "hello world" executable
Creating a simple library
Naming libraries
Symbol visibility in shared libraries
Interface or header-only libraries
Bringing it together – using your libraries
Setting compiler and linker options
Library aliases
Summary
Questions
Part 2: Practical CMake – Getting Your Hands Dirty with CMake
Chapter 4: Packaging, Deploying, and Installing a CMake Project
Prerequisites
Making CMake targets installable
The install() command
Supplying configuration information for others using your project
Entering the CMake package world – Config-file packages
Creating an installable package with CPack
Summary
Questions
Chapter 5: Integrating Third-Party Libraries and Dependency Management
Technical requirements
Finding files, programs, and paths with CMake
Finding files and paths
Finding programs
Finding libraries
Using third-party libraries in your CMake project
Writing your own find module
Using package managers with CMake
Getting dependencies from Conan
Using vcpkg for dependency management
Getting the dependencies as source code
Downloading dependencies as the source using pure CMake
Summary
Questions
Chapter 6: Automatically Generating Documentation with CMake
Technical requirements
Generating documentation from your code
Understanding what Doxygen is
Using Doxygen with CMake
Embedding custom UML diagrams into documentation
Packaging and distributing documentation with CPack
Creating dependency graphs of CMake targets
Summary
Questions
Chapter 7: Seamlessly Integrating Code Quality Tools with CMake
Technical requirements
Defining, discovering, and running tests
Automatically discovering tests
Advanced ways to determine test success or failure
Handling timeouts and repeating tests
Writing test fixtures
Running tests in parallel and managing test resources
Generating code coverage reports
Generating coverage reports using Clang or GCC
Creating coverage reports for MSVC
Sanitizing your code
Static code analysis using CMake
Creating custom build types for quality tools
Summary
Questions
Chapter 8: Executing Custom Tasks with CMake
Technical requirements
Using external programs with CMake
Executing custom tasks at build time
Adding custom tasks to existing targets
Generating files with custom tasks
Executing custom tasks at configuration time
Copying and modifying files
Using CMake for platform-independent commands
Executing CMake files as scripts
Summary
Questions
Chapter 9: Creating Reproducible Build Environments
Technical requirements
Using CMake presets
Inheriting from presets
Conditions for presets
Using build containers with CMake
Using sysroots to isolate build environments
Summary
Questions
Chapter 10: Handling Big Projects and Distributed Repositories in a Superbuild
Technical requirements
Requirements and prerequisites for a super-build
Building across multiple code repositories
The recommended way – FetchContent
The legacy way – ExternalProject_Add
Bonus – using the Qt 6 framework with a super-build
Ensuring version consistency in a super-build
Summary
Questions
Chapter 11: Automated Fuzzing with CMake
Technical requirements
A quick glance into fuzzing in CMake projects
Integrating AFL++/libFuzzer into your project
Using libFuzzer in your CMake project
Using AFL++ in your CMake project
Summary
Questions
Part 3: Mastering the Details
Chapter 12: Cross-Platform Compiling and Custom Toolchains
Technical requirements
Using existing cross-platform toolchain files
Creating toolchain files
Defining the target system
Selecting the build tools
Setting the sysroot
Cross-compiling for Android
Cross-compiling for iOS, tvOS, or watchOS
Testing cross-compiled binaries
Testing a toolchain for supported features
Common checks for toolchain and language features
Summary
Questions
Chapter 13: Reusing CMake Code
Technical requirements
What is a CMake module?
Fundamental building blocks of modules – functions and macros
Functions
Macros
Writing your first very own CMake module
Case study – dealing with project metadata files
Recommendations for sharing CMake modules between projects
Summary
Questions
Chapter 14: Optimizing and Maintaining CMake Projects
Technical requirements
Keeping a CMake project maintainable
Profiling a CMake build
Optimizing build performance
Using unity builds
Precompiled headers
Using a compiler cache (ccache) to speed up rebuilds
Summary
Questions
Chapter 15: Migrating to CMake
Technical requirements
High-level migration strategies
Migrating small projects
Migrating large projects to CMake
Integrating legacy projects when migrating top down
Summary
Questions
Chapter 16: Contributing to CMake and Further Reading Material
Prerequisites
Where to find the CMake community
Stack Overflow
Reddit (r/cmake)
The CMake Discourse forum
The Kitware CMake GitLab repository
Contributing to CMake
Recommended books and blogs
Summary
Assessments
Index
Other Books You May Enjoy