CMake, Tests & Tooling for C/C++ Projects [2026 Edition]

Establish a video-by-video workflow by creating a new subdirectory per video, starting from the previous code, and opening the subdirectory as the main project in VS Code.

Create a simple hello world program in c/c++, with a main function that prints hello world to the console, then configure CMake, add an executable, and build in build directory.

Learn how to configure and build C/C++ projects from the command line using cmake -S and -B options, and how cmake --build builds targets in the build directory.

Discover how cmake uses generators to create build files like makefiles, visual studio projects, and ninja. Learn to list and select generators with cmake --help and -G for cross-platform builds.

Create a multi-file c/c++ project structure with header and source files, adding a static library and an executable in cmake, linking the library, and building both targets.

Organize a C/C++ project by creating app and library directories, placing sources and headers, and using per-directory CMakeLists.txt with include directories and subdirectory structure.

Explore two common C and C++ project structures that separate source and include files, and see how CMake targets and include directories organize libraries and headers.

Define and reuse variables with cmake's set function for library and executable names across subdirectories, and control code paths with options turned on or off, like compile_executable.

Explain cmake command line options to choose generators (unix make, msvc), select a Visual Studio version, and define boot types (debug and release) using -D overrides and the set function.

Understand how the CMake cache stores variable values in the build directory, and how editing the cache or reconfiguring options during configure speeds up builds.

Use CMake configure_file to auto generate a config.h from config.h.in, embedding the project name and major, minor, and patch version numbers into the build's include directory.

Learn how to organize a CMake project by defining library sources and headers in variables and using them in add_library for clean builds, with modern practices and avoiding old functions.

Learn how to build a specific target in a CMake project, inspect target dependencies, and choose between CMake builds and make, noting Windows uses a Visual Studio solution.

Use git submodules to integrate external libraries into a c/c++ project, organizing them under an external directory and wiring them into CMake with a custom add git submodule function.

Create a visual dependency graph for three targets—external json library, library, and executable—by generating a dot file with cmake and converting it to a png with graphviz to inspect dependencies.

Learn how cmake fetch_content replaces git submodules by declaring and loading libraries like json, fmt, speed log, cx ops, and catch2 into a project, with versioning and shallow cloning.

Learn to generate html documentation for a C/C++ project using doxygen and the oxygen tool, create docstrings, configure a doxyfile, and add a cmake custom target to build docs.

Add unit tests for the library using catch2, wiring a test executable and cmake setup; expose and fix a zero factorial bug, and enable optional testing for builds.

Update to Catch2 version 3, integrate ctest with cmake, enable testing, discover tests, run ctest, and debug single tests in vscode with gdb, lldb, or msvc.

Identify predefined CMake variables by CMake_ prefix and hover in VS Code. Use CMake current source dir, project source dir, CMake module path, and CMake binary dir to resolve paths.

Analyze the dependency graph to distinguish public versus private linking among executables and libraries, noting a library's private links and its public dependencies like logging, formit, json, and unit tests.

Understand public, private, and interface linking in CMake, where public links add dependencies to a library’s public API, private links hide them, and interface covers header-only libraries.

learn to enable and customize compiler warnings in cmake for c/c++ projects, including per-target options, msvc/clang/gcc flags, and an optional warnings-as-errors mode.

Configure a CMake target by using target compile features, definitions, and options to enable the C++ standard, define preprocessor macros, and set compilation flags.

Explore using sanitizers to detect runtime memory issues and leaks, alongside clang-tidy static linting and compiler warnings, to catch problems early in C/C++ projects with cmake.

Enable ipo and lto in a cmake project by creating lto.cmake and an enable lto option. Check ippo supported to apply interprocedural optimization to targets.

Explore generator expressions in CMake to manage build types with multi-configuration generators like Visual Studio and Ninja, enabling flexible compile options at build time.

Explore CPM, a cmake package manager, and compare it with fetch content. Learn to install and use cpm add package with versioning for libraries like fmt and spdlog.

Install and configure Conan as a C/C++ package manager, generate a CMake toolchain, and manage dependencies from the Conan center, noting pre-built binaries and OS/compiler considerations.

Learn to install external libraries with vcpkg, clone the package into your project’s external directory, define a package.json with dependencies, and use overrides and a built-in baseline to pin versions.

Compare external library options for CMake projects, including git submodules, fetch content, CPM, Conan, and VC package. CPM offers the simplest, most flexible workflow for GitHub or GitLab CMake projects.

Explore the final project template on GitHub, clone or create a new repo, and learn code coverage, Conan package management, GitHub pages docs, Codecov, and GitHub Actions step by step.

Update to cmake scripts enables one-value and multi-value arguments with prefixed variables for clarity, and adds a config safeguard for build type, code coverage notes, and sanitizers.

Clang-tidy is a static linting tool that checks code with predefined checks. Configure it via a .clang-tidy file, integrate with cmake, and run on targets to catch issues early.

Explore clang format and cmake format for consistent code and cmake file styling, install via pip, configure in place reformatting, and integrate with cmake targets and editor extensions.

Publish html docs generated by oxygen to GitHub pages via a workflow that builds on main and uploads to the gh-pages branch, creating a public site at username.github.io/repo.

Compute code coverage while updating unit tests for two new libraries, foo and bar, configure cmake tests, and run separate unit test executables with ctest.

Learn how to compute code coverage locally with gcovr on linux or mac, using wsl for windows, and view html reports plus a summary json.

Set up GitHub actions to run unit tests and collect code coverage across Windows, macOS, and Ubuntu, reporting results in pull requests via a code coverage summary.

Enforce coding guidelines with pre-commit, a Python tool that runs hooks on every commit and pull request, applying clang-format and checks for YAML and JSON formatting and trailing whitespace.

Install your executable or library with a CMake install target, building in a build directory and running install to place files in default system paths.

Learn to debug in VS Code with the cmake tools extension, pass arguments via settings.json and task.json, and navigate build directories for MSVC or Unix.

Learn how to define and use CMake kits in VS Code to select C and C++ compilers (GCC, Clang, MSVC) and manage build directories per kit for cross compiling.

Explore the differences between shared and static libraries, including runtime loading and code duplication versus executable size, and how customer requirements guide the library type.

Demonstrates how to set up a header-only library target in CMake using an interface library. Explains linking the header library to an executable and configuring include directories.

Discover cross compilation and toolchain files in CMake to build for different targets, such as ARM Linux and Windows, from a Linux host.

Learn to link a pre-compiled library in a CMake project using target_link_libraries, by providing a library path and the include directory for headers, with support for static and dynamic libraries.

Create and customize a CMake add_custom_target to run Python scripts or other commands, with working_directory, dependencies, and optional add_dependencies, to generate stats or docs from source files.

Learn to use CMake add custom command to generate outputs only when dependencies change, connect it to add custom target, and avoid unnecessary re-runs.

Execute process runs at configure time to generate or clone header and source files. Use it for mandatory files; for optional targets, prefer add custom target or add custom command.

Learn how to use the CMake GUI to configure and generate a C/C++ project on Windows, choosing generators like Makefiles, Ninja, or Visual Studio.

Open the Visual Studio 2022 Windows project solution from the build directory, navigate targets like all build and configure, then run the main executable or unit tests with clang-tidy.

Explore a C project template with fetch content workflow, optional VCC and Conan package managers, Unity unit testing with test assert equal, and logging and command line parsing libraries.

Rate the course and share what you liked or disliked. Contact me to help update and adapt this course in the future.