An introduction to the build pipeline, and how we can orchestrate it manually

Before working with CMake, it's useful to understand the tools it orchestrates. This lesson guides you through setting up a C++ toolchain.

Building C++ Programs

Walking through the steps of the C++ compilation process, from source code to machine code.

The Compilation Pipeline

The linker's role in the build process, how it resolves symbols to combine object files, and how to troubleshoot common errors.

Object Files and the Linking Process

The difference between static and dynamic libraries, how to create them, and the trade-offs between them.

Static and Shared Libraries

The C++ Build Process

Recommended approaches for managing large projects and the libraries that they depend on

Learn how to structure your C++ projects for scalability and maintainability, from basic directory layouts to managing multiple modules.

Organizing a C++ Project

Learn to manage third-party libraries in C++, covering include/library paths, static vs. shared libraries, versioning, and platform differences.

Managing Libraries and Dependencies

An introduction to traditional build tools like Makefiles and IDE projects, highlighting the maintenance, scalability, and cross-platform challenges that result

Automated Build Systems and Their Limitations

Project Structure and Dependency Management

Setting up CMake and creating your first project

An introduction to CMake, the cross-platform, open-source meta-build system that solves the core challenges of C++ project management.

Why CMake?

A step-by-step guide to installing CMake. We'll explore command-line, GUI, and IDE workflows, and how to configure your compiler.

Setting Up a CMake Environment

Creating the bare minimum `CMakeLists.txt` file and build up to a project with an executable and a library, learning the fundamental commands along the way.

Writing a CMakeLists File

Learn the two-stage process of building a CMake project. This lesson covers configuring, generating, building, running, and troubleshooting common errors.

Building and Running CMake Projects

Learn how to organize large C++ projects in CMake using subdirectories and the `add_subdirectory()` command to create modular, maintainable builds.

CMake Project Structure and Subdirectories

Introducing CMake

Exploring CMake's programming features, caching mechanisms, and interactions with the file system

A primer on the fundamental building blocks of the CMake language: variables, string interpolation, and logging messages.

CMake Variables and Logging

Discover the CMake Cache, the mechanism for storing persistent user-configurable options, and learn how to create and manage cached variables.

The CMake Cache

Exploring CMake's command syntax and its list data type, including how to create, manipulate, and use lists in your projects.

CMake Commands, Arguments, and Lists

Transform your static build descriptions into dynamic scripts with CMake's control flow commands, if() and foreach().

CMake Conditionals and Loops

Exploring CMake's `file()` command, covering how to read, write, copy, and glob files, and how to manipulate paths.

Working with the File System

Learn to create reusable logic with CMake functions and macros, and how to organize them into modules for clean, scalable build systems.

Modularizing CMake Code

CMake Language and Fundamentals

Learn more about targets, and how their properties and links are the foundation of modern CMake

Learn to work with target properties - understanding their purpose, setting and updating them, and retrieving them when your build requires it

Target Properties

Learn about target types, and how the `PUBLIC`, `PRIVATE`, and `INTERFACE` keywords control how properties are shared.

Relationships Between Targets

Discover how CMake's `target_link_libraries()` command builds a dependency graph, and how it uses this graph to automatically manage transitive dependencies and link order.

Indirect Relationships and the Dependency Graph

Learn to use abstract target types like `INTERFACE`, `ALIAS`, and `IMPORTED` to model complex project needs, organize build properties, and integrate pre-compiled binaries.

Using `INTERFACE`, `ALIAS`, and `IMPORTED` Libraries

Adding support for user-configurable library types and an initial introduction to target installation.

Using Shared Libraries

Targets and Dependencies

Learn how to manage multiple build configurations within the same project, and how to create scripts that adapt to the environment

Learn how CMake manages different build configurations like Debug and Release, the difference between generator types, and how to apply settings conditionally using modern techniques.

Build Configurations (Debug, Release, etc.)

Learn the tools and patterns needed to write portable CMakeLists.txt files that work seamlessly across platforms and compilers

Cross-Platform Configurations

Learn to write architecture-aware CMake scripts for 32/64-bit systems and Apple's Universal Binaries (Intel/ARM).

Handling Different Architectures

Learn to build for different operating systems and architectures using CMake's cross-compilation support and toolchain files.

Cross-Compilation and Toolchain Files

Platforms and Build Configurations

Learn how to add external libraries to our build, and how to create our own packages for others to use

Learn to find and use pre-installed libraries with `find_package()`, understanding Module vs. Config mode and the power of imported targets

Finding Dependencies using `find_package()`

Learn how to make your libraries consumable by other projects using CMake by turning your build-tree into a distributable install-tree.

Creating a Consumable Package

Learn how to consume a CMake package you've installed, completing the producer-consumer cycle. We'll cover using `find_package()` and how to point CMake to your library's location

Using Installed Packages

Learn how to create self-contained, reproducible builds by fetching dependencies from source using `FetchContent()` and `ExternalProject_Add()`.

Fetching External Dependencies

Creating and Consuming Packages

Integrating the vcpkg and Conan package managers to handle external dependencies

Learn to manage C++ dependencies effortlessly with the vcpkg package manager and its seamless CMake integration using toolchain files and manifests.

Integrating CMake and vcpkg

Learn the day-to-day commands for managing dependencies with vcpkg and how to guarantee reproducible builds using baselines and version overrides

vcpkg Commands and Versioning

Combine vcpkg with CMake's cross-compilation capabilities. Learn to use triplets to target different architectures and chain-load toolchain files

Cross-Compiling with vcpkg

Discover Conan, the binary-first C++ package manager, and learn how to integrate it with CMake using profiles and lockfiles for fast, reproducible builds.

Using Conan with CMake

Learn to cross-compile C++ projects with Conan, using build and host profiles to manage dependencies for different platforms.

Cross-Compilation with Conan

Package Managers

Introducing presets, allowing us to simplify our workflow and share common configurations across our team

Learn the fundamentals of CMake Presets. This lesson introduces `CMakePresets.json` to simplify complex build commands.

CMake Presets

Learn to structure your CMake presets with inheritance and customize them for your local environment using `CMakeUserPresets.json`.

User Presets and Inheritance

Learn to make your CMake presets portable by using environment variables and conditional logic to adapt to different machine configurations.

Environment Variables and Conditional Presets

Learn how to extend the build process beyond simple compilation by integrating external tools and custom commands

Learn how to use generator expressions `$<...>` for build-time conditional logic.

Generator Expressions and Conditional Logic

Learn how to attach commands to specific points in a target's build lifecycle using `add_custom_command(TARGET)` for tasks like post-build file copying.

Integrating Tools with `add_custom_command()`

Learn to integrate code generators like Protobuf into your build process using `add_custom_command()`, creating automated file-level dependencies in CMake.

Generating Files with Protobuf and `add_custom_command()`

Custom Commands

An introduction to automating common workflow chores by creating custom targets

Learn to create standalone, non-code targets using add_custom_target() for utility tasks like code formatting and documentation generation.

Custom Targets and Build Utilities

Using the Clang-Format tool to automatically enforce a consistent coding style, and integrating it into our build using a custom CMake target

Using Clang-Format

An introduction to file sets and the `target_sources()` command, allowing us to manage our header files in a more controlled way

Using File Sets

A step-by-step guide to integrating Doxygen into your CMake build process for automated C++ documentation.

Generating Documentation with Doxygen

Custom Targets

Integrate automated tests into a CMake project using CTest, GoogleTest, and GoogleMock

Learn the fundamentals of automated testing in C++ with CTest. Create your first test suite, register tests with `add_test()`, and run them with the `ctest` command.

Automated Testing and CTest

Learn to refactor manual C++ tests into a professional test suite using the GoogleTest framework, managed by vcpkg and integrated with CTest.

Integrating GoogleTest with CMake

Learn to use a wide range of assertions, write data-driven parameterized tests, and isolate dependencies with Google Mock.

Assertions and Parameterized Tests

Learn how to isolate dependencies that our project uses, and then how to replace those dependencies at test time using Google Mock.

Dependency Injection and Mocking

Learn the standard pattern for testing application logic by refactoring it into a linkable library

Testing Executables

Move beyond individual tests to manage a full test suite. Learn to organize tests, run tests in parallel, filter by labels, and measure our code coverage

Managing a Test Suite

Automated Testing

Using static and dynamic analysis in CMake projects to automatically detect memory bugs, performance issues, and problematic code

Learn to find memory bugs at runtime by integrating AddressSanitizer (ASan) into a CMake project

Using AddressSanitizer (ASan)

Adding benchmarks to our build to measure the performance of our code, and track how it changes over time

Using Google Benchmark

Integrating Clang-Tidy to enforce good practices and find bugs before we even compile

Using Clang-Tidy

Automated Analysis

Automating the entire development lifecycle using Git for souce control, GitHub Actions for cloud builds, and CPack to create distributable packages and installers.

An introduction to Git, the version control system that underpins modern collaborative software development and automated build pipelines.

Source Control with Git

Learn how to automate your build and test process with Continuous Integration (CI) and a build server. This lesson provides a guide to creating a GitHub Actions workflow for a CMake project.

Build Servers and Continuous Integration

Learn to package your C++ projects using CMake's CPack. This lesson covers creating developer ZIP archives and professional Windows MSI installers with components.

Packaging with CPack

Learn to automate the packaging process by integrating CPack with a multi-platform GitHub Actions workflow

Packaging with GitHub Actions

Learn to automate the creation of a professional Windows installer by integrating CPack, the WiX Toolset, and a multi-platform GitHub Actions workflow.

Creating Installers with CPack and GitHub Actions

Learn to automate the release process using a GitHub Actions workflow that builds, packages, and publishes artifacts to a GitHub Release

Deployment with GitHub Releases

Continuous Integration and Packaging

If you have a basic grasp of C++ but find the build process intimidating, this course is for you. We assume you know the language, but not how to manage large projects.

Manage complex, cross-platform builds using industry-standard tools. Create scalable build systems that automate the entire development lifecycle.

This course is a comprehensive deep-dive into the entire C++ build ecosystem, centered around the power and flexibility of modern CMake. We leave no stone unturned.

Start with a foundational understanding of compilers, linkers, static vs. shared libraries, and object files.

The Full Build Pipeline

Learn every aspect of the CMake language, from variables and control flow to functions, modules, and generator expressions.

Complete CMake Language Mastery

Master the modern target-centric paradigm, including properties, usage requirements, and abstract targets.

Advanced Target Management

Explore every method for handling dependencies, from `find_package` and `FetchContent` to vcpkg and Conan, including versioning and cross-compilation.

In-Depth Dependency Management

Integrate a full suite of professional tools for testing (CTest, GoogleTest), analysis (ASan, Clang-Tidy), and packaging (CPack).

Total Workflow Automation

Build a fully automated deployment pipeline that takes your code from a Git push to a published GitHub Release with multi-platform installers.

End-to-End CI/CD and Deployment

What You'll Learn

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

Intro to C++ Programming

If you're completely new to programming or want a thorough introduction, consider starting with our free introductory course:

New to Programming?

Managing C++ Projects Using CMake

We've now established a solid foundation in the CMake language. We know how to use variables to store data, how to create persistent options with the cache, and how to manage collections of files using lists.


So far, our `CMakeLists.txt` files have been straightforward sequences of commands, executed from top to bottom. But what if we need our build script to be smarter? What if we want it to make decisions, like "only add this source file if we're building on Windows," or to perform repetitive tasks, like "apply this compiler flag to every target in this list"?


To do this, we need to introduce **control flow**. In this lesson, we'll explore the two most important control flow structures in CMake:

- **Conditionals** using the `if()`/`elseif()`/`else()`/`endif()` commands to execute blocks of code selectively.
- **Loops** using the `foreach()`/`endforeach()` commands to iterate over lists and perform actions on each item.

These commands are what will elevate your `CMakeLists.txt` from a static description to a dynamic, intelligent script.


## Conditional Logic with `if()`


The `if()` command is the cornerstone of decision-making in CMake. It allows you to execute a block of commands only if a certain condition is true. The basic structure looks like this:


```c++
#<cmake>
if(CONDITION)
  # Commands to execute if CONDITION is true
endif()
```


There is a a wide variety of conditions it can evaluate. Let's explore the most common ones.


### Evaluating Variables and Constants


The simplest condition is just a variable or a constant. CMake has a specific set of values it considers to be "true" or "false".

- **True**: `1`, `ON`, `YES`, `TRUE`, `Y`, or any non-zero number.
- **False**: `0`, `OFF`, `NO`, `FALSE`, `N`, `IGNORE`, `NOTFOUND`, an empty string, or a string ending in `NOTFOUND`.

Let's revisit the `SAY_GOODBYE` option we created in the last lesson. Our `app/CMakeLists.txt` already uses some `if()` blocks to check this option:


<CodeFile path="app/CMakeLists.txt">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)

option(
  SAY_GOODBYE
  "Should the program say goodbye before exiting"
  OFF
)

set(GREETER_SOURCES src/main.cpp)

if(SAY_GOODBYE) #<h>
  message(STATUS "Adding goodbye.cpp and SAY_GOODBYE definition")
  list(APPEND GREETER_SOURCES src/goodbye.cpp)
endif() #<h>

add_executable(GreeterApp ${GREETER_SOURCES})
target_compile_features(GreeterApp PUBLIC cxx_std_20)
target_link_libraries(GreeterApp GreeterLib)

if(SAY_GOODBYE)#<h>
  message(STATUS "Defining SAY_GOODBYE")
  target_compile_definitions(GreeterLib PUBLIC SAY_GOODBYE)
endif()#<h>
```


</CodeFile>


When a user configures the project with `-DSAY_GOODBYE=ON`, the variable `SAY_GOODBYE` holds the value `ON`. The `if(SAY_GOODBYE)` condition evaluates to true, and the commands inside the block are executed. If `SAY_GOODBYE` is `OFF`, the condition is false, and the block is skipped.


### Comparing `if(VAR)` vs. `if(DEFINED VAR)`


There's a subtle but important distinction between checking a variable's value and checking its existence.

- `if(VAR)` checks if the _value_ of `VAR` is a "true" constant. If `VAR` is a "false" constant or not defined at all, this condition is false.
- `if(DEFINED VAR)` checks only if a variable with the name `VAR` exists. It doesn't care what the value is - if the variable exists, this condition will be true.

You should use `if(DEFINED VAR)` when you need to know if a variable has been set at all, regardless of its value. For boolean options, `if(VAR)` is more direct.


### Using `elseif()` and `else()`


For more complex logic, you can extend `if()` with `elseif()` and `else()` blocks, just like in C++.


```c++
#<cmake>
if(CONDITION_A)
  # Do stuff for A
elseif(CONDITION_B)
  # Do stuff for B
else()
  # Do stuff if neither A nor B is true
endif()
```


<Pw>


## Comparisons and Logic


The `if()` command can also perform comparisons and use logical operators.


### Numeric Comparison


`EQUAL`, `LESS`, `LESS_EQUAL`, `GREATER`, and `GREATER_EQUAL` interpret our variable as a number, and then behaves in the same way as the C++ operators `==`, `<`, `<=`, `>`, and `>=`.


### String Comparison


Variations of these operators that perform string-based comparisons are available in the form of `STREQUAL`, `STRLESS`, `STRLESS_EQUAL`, `STRGREATER`, and `STRGREATER_EQUAL`.  These perform lexographic (alphabetic) comparisons - for example, `"Apple" STRLESS "Banana"` is true, as "Apple" is before "Banana" alphabetically.


### Version Comparison


For strings representing versions, such as "2.1.9" and "3.2", the operators `VERSION_EQUAL`, `VERSION_LESS`, `VERSION_LESS_EQUAL`, `VERSION_GREATER`, and `VERSION_GREATER_EQUAL` are available. `"2.9" VERSION_LESS "2.10"` is true, as "2.9" is an older version than "2.10".


### Logical Operators, Parentheses, and Inversion


We have the usual suite of boolean tools for creating compound expressions:

- `AND` and `OR` can be used to combine booleans to create more complex expressions
- We can use `()` for grouping expressions to control the order of operations
- The `NOT` keyword behaves in the same way as the C++ `!` operator, inverting a true expression to be false, or false to be true.

Here's a more complex example that combines a few of these techniques:


```c++
#<cmake>
set(MODE "Debug")
set(OPTIMIZATION_LEVEL 2)

if((MODE STREQUAL "Debug") AND (OPTIMIZATION_LEVEL LESS 3))
  message(STATUS "Debug mode with low optimization.")
endif()
```


## Practical Example: Platform-Specific Code


One of the most common uses of `if()` is to handle platform differences. CMake provides several variables that identify the operating system, such as `WIN32`, `APPLE`, and `UNIX`.


Let's imagine our `GreeterLib` needs a platform-specific implementation file to get some system information. Our project structure might look like this:


```plain text
//<nh>
greeter/
├─ include/
│  └─ greeter/
│     └─ Greeter.h
├─ src/
│  ├─ Greeter.cpp
│  ├─ platform_win.cpp
│  └─ platform_nix.cpp
└─ CMakeLists.txt
```


Our `greeter/CMakeLists.txt` can use `if()` to select the correct source file at configure time:


<CodeFile path="greeter/CMakeLists.txt" status="Updated">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)

# Start with the common source files
set(LIB_SOURCES src/Greeter.cpp)#<h>

# Conditionally add the platform-specific file
if(WIN32) #<h>
  message(STATUS "Using platform_win.cpp")  #<h>
  list(APPEND LIB_SOURCES src/platform_win.cpp) #<h>
else() #<h>
  message(STATUS "Using platform_nix.cpp")  #<h>
  list(APPEND LIB_SOURCES src/platform_nix.cpp) #<h>
endif() #<h>

add_library(GreeterLib ${LIB_SOURCES})#<h>

target_include_directories(GreeterLib PUBLIC
  ${CMAKE_CURRENT_SOURCE_DIR}/include
)

target_compile_features(GreeterLib PUBLIC cxx_std_20)
```


</CodeFile>


```c++
//<ti>
cmake ..
```


```c++
//<o>
-- Using platform_win.cpp
-- Configuring done (0.1s)
-- Generating done (0.1s)
-- Build files have been written to: D:/projects/cmake/build
```


This is the essence of writing portable build scripts. You describe the components you need for each platform, and `if()` lets you assemble them correctly. When you configure this project on Windows, `WIN32` is true, and `platform_win.cpp` is added. On Linux or macOS, `WIN32` is false, and `platform_nix.cpp` is added instead.


## Checking List Membership with `IN_LIST`


A particularly useful comparison operator is `IN_LIST`. It provides a clean and readable way to check if a specific item is present within a list. This is often more convenient than using `list(FIND)` and checking the index.


The syntax is straightforward:


```c++
#<cmake>
if(<item> IN_LIST <list_variable>)
  # ...
endif()
```


Let's see a quick example:


```c++
#<cmake>
set(ADMIN_USERS "alice" "bob" "charlie")
set(CURRENT_USER "bob")

if(CURRENT_USER IN_LIST ADMIN_USERS)
  message(STATUS "User '${CURRENT_USER}' has admin privileges.")
else()
  message(STATUS "User '${CURRENT_USER}' is a standard user.")
endif()
```


When configured, this script will check if the value of `CURRENT_USER` exists in the `ADMIN_USERS` list and print the appropriate message.


```c++
//<o>
-- User 'bob' has admin privileges.
```


## Looping with `foreach()`


While `if()` lets us make decisions, `foreach()` lets us perform repetitive tasks. It's the primary looping construct in CMake and is almost always used to iterate over the elements of a list.


### Basic Syntax


The most common form of the `foreach()` loop is:


```c++
#<cmake>
foreach(loop_variable IN LISTS list_variable)
  # Commands to execute for each item
  # Use ${loop_variable} to access the current item
endforeach()
```


Let's see it in action with a simple list of strings:


```c++
#<cmake>
set(FRUITS Apples Bananas Cherries)

foreach(fruit IN LISTS FRUITS)
  message(STATUS "I am eating ${fruit}!")
endforeach()
```


When you run this, CMake will execute the `message()` command three times, each time with the `fruit` variable set to the next item in the `FRUITS` list.


```c++
//<o>
-- I am eating Apples!
-- I am eating Bananas!
-- I am eating Cherries!
```


### Multiple Lists


As the `IN LISTS` syntax might suggest, we can provide multiple lists to this construct:


```c++
#<cmake>
set(FRUITS Apples Bananas Cherries)
set(VEGETABLES Onions Carrots)#<h>

foreach(food IN LISTS FRUITS VEGETABLES)#<h>
  message(STATUS "I am eating ${food}!")
endforeach()
```


## Practical Example: Applying Settings to Multiple Targets


A great use case for `foreach()` is to apply a common configuration to multiple targets without repeating yourself. This follows the DRY (Don't Repeat Yourself) principle and makes your build scripts much more maintainable.


In the following example, we define a `TARGETS_TO_UPDATE` list with the names of targets we want to apply some common configuration to.  We apply this configuration using a `foreach()` block:


<CodeFile path="CMakeLists.txt" status="Updated">


```c++
#<cmake>
cmake_minimum_required(VERSION 3.16)

project(Greeter VERSION "1.0")

add_subdirectory(app)
add_subdirectory(greeter)

# Define a list of all targets in our project
set(TARGETS_TO_UPDATE #<h>
  GreeterLib #<h>
  GreeterApp #<h>
) #<h>

# Loop over the list and apply common settings
foreach(target IN LISTS TARGETS_TO_UPDATE) #<h>
  message(STATUS "Applying common settings to ${target}") #<h>
  target_compile_features(${target} PUBLIC cxx_std_20) #<h>
endforeach() #<h>
```


</CodeFile>


```c++
//<o>
-- Applying common settings to GreeterLib
-- Applying common settings to GreeterApp
```


With this structure, if we add a new target to our project, we only need to add its name to the `TARGETS_TO_UPDATE` list. It will automatically receive all the common settings, ensuring consistency and saving us from copy-pasting code.


A small flaw here is that we need to know the names of our targets (`GreeterLib` and `GreeterApp`) even though those are set in the deeper `CMakeList.txt` files we're loading using `add_subdirectory()`.


We'll soon learn techniques that will unlock better ways of doing this.


## Other `foreach()` Variants


While iterating over lists is the most common use case, `foreach()` has other forms that can be useful for different scenarios.


### Iterating an Inline List


This variant allows you to iterate directly over a set of items provided as arguments to the command, without needing to create a list variable first. It's useful for short, hardcoded collections.


```c++
#<cmake>
# No list variable is created beforehand
foreach(fruit IN ITEMS "Apple" "Banana" "Cherry")
  message(STATUS "Fruit of the day: ${fruit}")
endforeach()
```


This is functionally equivalent to creating a list first (`set(FRUITS "A" "B" "C")`) but can be more concise for simple cases.


```c++
//<o>
-- Fruit of the day: Apple
-- Fruit of the day: Banana
-- Fruit of the day: Cherry
```


### Iterating from `0` to `stop`


This `foreach(i RANGE n)` form iterates over integers from `0` up to (and including) the `stop` value.  It's a convenient way to create a classic `for` loop.  Our variable (which we've called `i`, in this example) adopts the current iteration number:


```c++
#<cmake>
# Loop from 0 to 4
foreach(i RANGE 4)
  message(STATUS "Creating temporary file: temp_${i}.txt")
endforeach()
```


This will execute the loop body five times, with the `i` variable taking on the values 0, 1, 2, 3, and 4.


```c++
//<o>
-- Creating temporary file: temp_0.txt
-- Creating temporary file: temp_1.txt
-- Creating temporary file: temp_2.txt
-- Creating temporary file: temp_3.txt
-- Creating temporary file: temp_4.txt
```


### Iterating from `start` to `stop`


The `foreach(i RANGE start stop step)` syntax is the most flexible range-based loop, allowing you to specify a starting value and an ending value.  We can optionally provide a step value to set how much our variable should be incremented on each iteration, or we can omit that argument to use the default value of `1`.


```c++
#<cmake>
# Loop from 2 to 10, incrementing by 2 each time
foreach(num RANGE 2 10 2)
  message(STATUS "Even number: ${num}")
endforeach()
```


This loop will execute with `num` having the values 2, 4, 6, 8, and 10.


```c++
//<o>
-- Even number: 2
-- Even number: 4
-- Even number: 6
-- Even number: 8
-- Even number: 10
```


## Summary


Control flow commands transform your `CMakeLists.txt` from a simple declaration into a powerful script. They allow you to handle complexity, reduce redundancy, and create builds that can adapt to different environments and configurations.

- **Conditionals with** **`if()`**: The `if()` , `elseif()`, `else()`, and `endif()` blocks are our primary tool for decision-making. You can test variables, compare strings and numbers, and check for platform-specific details like `if(WIN32)`.
- **Loops with** **`foreach()`**: The `foreach()` and `endforeach()` block lets you iterate over items in a list. It's perfect for applying the same commands to multiple targets or files, keeping your scripts clean and maintainable.

You now have the core language tools to write sophisticated build scripts. You can create variables, manage persistent options with the cache, group data in lists, and control the flow of execution with conditionals and loops.


<Preview>


### Working with the File System


Our scripts often need to interact directly with the file system - finding files, reading their contents, or creating new ones. The next lesson will introduce the `file()` command, which provides a whole suite of tools for file and directory manipulation.
</Preview>


</Pw>

`if()` Command Documentation

`foreach()` Command Documentation

System detection in CMake

Managing Libraries and External Dependencies

Learn to write dynamic and intelligent build scripts with CMake's control flow structures. This guide covers conditional logic with if/else/endif and looping over lists with foreach/endforeach, including practical examples for platform-specific code.

CMake Control Flow: A Guide to Conditionals and Loops

Comparing `if(VAR)` vs. `if(DEFINED VAR)`

Logical Operators, Parentheses, and Inversion

Practical Example: Platform-Specific Code

Practical Example: Applying Settings to Multiple Targets

CMake Conditionals and Loops

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Managing C++ Projects Using CMake