# CMake kursen uppdaterad

26 november 2023 | https://www.ribomation.se/blog/2023/cmake-kursen-uppdaterad/

CMake är ett av de mest populära byggnations-verktyget för C/C++ applikationer. Det är enkelt att hantera komplexa byggnationer med många bibliotek.

Bibliotek som länkas till en applikation kan vara i många former, såsom archive (`.a`), shared-object (`.so`) och header-only. Förutom att vara en del av aktuellt projekt, så kan bibliotek länkas från redan installerade eller laddas ned automatiskt från en git repo eller webb-server.

Den här kursen lär dig allt du behöver veta för att snabbt komma igång med att skriva egna CMake script för byggnation av C++ och C applikationer. Kursen är nu uppdaterad för CMake version 3.28 och innehåller ett nyskrivet kapitel om presets.

Här kan du se innehållsförteckningen

#### Background

*   Why CMake was created
*   Properties of CMake
*   Compilers
*   Build tools
*   Build tool generators

### Application Build

#### Compilation & Linkage

*   Using GCC
*   Pre-processor
*   Front-End compilation
*   AST and RTL
*   Back-end compilation
*   Assembler
*   Linker
*   Loader
*   Useful compiler flags
*   Linking libraries
*   Creating static libraries
*   Creating shared libraries
*   Executing with shared libraries

#### Archives

*   What is an archive
*   Creating a static archive file (`*.a`)
*   Naming conventions of archive files
*   Creating a dynamically linked archive file (`*.so`)

#### Brief about Makefiles

*   What is make
*   Structure of a Makefile
*   Targets
*   Actions
*   Dependencies
*   Rules
*   Ninja instead of Make

### CMake Fundamentals

#### Installation of CMake

*   Installation via a package manager
*   Installation on Windows
*   Installation via TAR.GZ archive
*   Compiling from sources
*   CMake executables
*   CMake command-line help
*   CMake documentation

#### CMake Syntax

*   Structure of CMakeLists.txt
*   CMake stages
*   Comments
*   Command syntax
*   Text strings
*   Quoted vs. unquotes strings
*   Value lists
*   Variables
*   Conditional blocks
*   Looping blocks
*   CMake scopes
*   Subdirectories and includes
*   CMake GUI

#### Control Structures

*   Conditional blocks
*   Operators
*   Loops
*   Generator expressions
*   Functions

### Executables

#### Building Executables

*   Creating a CMake project
*   Build steps and commands
*   Programming language
*   Language standard
*   Compiler options
*   Linking standard libraries

#### Build Variants

*   Debug vs. Release build
*   C++ vs. C sources
*   GCC vs. CLang compiler
*   Make vs. Ninja builder
*   Linux vs. Windows build

### Libraries

#### Building Libraries

*   Building a static library
*   Where to find the \*.a file
*   Propagating header files to an executable

#### Building Header-Only Libraries

*   Defining a header-only library

#### Building Dynamic Libraries

*   Building a shared library
*   Where to find the \*.so file

#### Other Library Types

*   Defining an object library
*   Using an imported library

#### Linking External Libraries

*   What is an external library
*   Finding libraries
*   Configuration variables

#### Linking Remote Libraries

*   What is a remote library
*   Downloading and linking a remote library
*   Understanding FetchContent
*   Fetching a GIT library
*   Fetching a TAR.GZ file

### Tests & Docs

#### Configuring and Running Tests

*   How cmake perceives a test
*   Using CTest
*   Configuring a simple test
*   Configuring a test based on a header-only testing framework (Catch2)
*   Configuring a test based on a linked testing framework (Google Test)
*   Fetching and using a remote test framework

#### Generating API documentation using `doxygen`

*   What is `doxygen`
*   Invoking doxygen from CMake
*   Configure tool properties
*   How to generate fancy docs with custom CSS, tree-view and images

### Writing CMake Scripts

#### Running External Programs

*   Custom targets
*   Running the generated executable
*   Running arbitrary scripts and programs
*   Generating API documentation using doxygen

#### Working with Files

*   Finding things in the file system
*   Extracting path components
*   The versatile `file()` command
*   Copy a set of files to a directory
*   Writing files
*   Reading files
*   HTTP(S) operations, i.e., GET and PUT

#### Generating Sources

*   Copying files
*   Variable substitution
*   Managing application version
*   Assembling build info

#### Recursive CMake

*   How to structure a large C/C++ project
*   Top-level CMakeLists.txt
*   Dependencies
*   Subsystems
*   Tests

#### Cross-Compilation

*   What is cross-compilation
*   Toolchain identifier
*   What is `sysroot`
*   What is a multi-lib
*   Using CMake for cross-compilation
*   Toolchain file
*   How to build applications for several toolchains (_i.e._, platforms)

#### Presets

*   What are CMake presets
*   Understanding the preset JSON format
*   Top-level JSON properties
*   Common structure of all presets objects
*   Configure `configurePresents`
*   Configure `buildPresents`
*   Preset macros
*   Preset inheritance
*   Preset conditions