Wat is CMake? Een C++-serverproject bouwen

Als je ooit hebt geprobeerd een C++-serverproject met meerdere bestanden handmatig te compileren met g++, dan weet je hoe snel de commandoregel een nachtmerrie wordt: tientallen .cpp-bestanden, include-paden, externe libraries en een project dat bij elke wijziging volledig opnieuw compileert. Precies hier komt de vraag wat is CMake om de hoek kijken. CMake is een platformonafhankelijke build-systeemgenerator waarmee je in één receptbestand beschrijft hoe je project wordt gebouwd. In dit artikel zetten we CMake vanaf nul op aan de hand van een game-/chatserver als voorbeeld.

Wat is CMake en waarom heb je het nodig?

CMake is op zichzelf geen compiler. Het leest het CMakeLists.txt-bestand dat je schrijft en genereert de echte buildbestanden die bij je systeem passen: meestal Makefile's op Linux, Visual Studio-projecten op Windows, of Ninja-bestanden als je dat liever hebt. Met andere woorden, CMake is een "meta build-systeem": je schrijft één recept en het werkt op elk platform.

• Portabiliteit: dezelfde CMakeLists.txt draait op je Linux-VPS én op de Windows-machine waarop je ontwikkelt.
• Afhankelijkheidsbeheer: CMake houdt bij welk bestand van welk ander afhangt en compileert alleen de gewijzigde bestanden opnieuw.
• Libraries koppelen: libraries zoals pthread, OpenSSL of Boost haal je met één regel binnen.

Serverprojecten hebben precies deze drie behoeften: veel bestanden, externe libraries en de mogelijkheid om in verschillende omgevingen te bouwen. Daarom is CMake praktisch de standaard voor elke serieuze C++-server.

Voorbeeld van de projectstructuur

Stel dat we een eenvoudige TCP-server schrijven. Laten we de bestanden in logische mappen verdelen; dat is belangrijk voor zowel de leesbaarheid als de CMake-configuratie.

server/
├── CMakeLists.txt
├── include/
│   └── server/
│       ├── Server.hpp
│       └── Connection.hpp
├── src/
│   ├── main.cpp
│   ├── Server.cpp
│   └── Connection.cpp
└── build/        (de build-uitvoer komt hier)

Headers onder include/ en bronbestanden onder src/ houden is een gangbare indeling. De map build/ is voor de tijdelijke bestanden die CMake genereert en wordt meestal toegevoegd aan .gitignore.

Je eerste CMakeLists.txt

Laten we nu een CMakeLists.txt in de hoofdmap schrijven. Ik loop elke regel langs en leg uit wat die doet.

cmake_minimum_required(VERSION 3.16)
project(GameServer VERSION 1.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(server
    src/main.cpp
    src/Server.cpp
    src/Connection.cpp
)

target_include_directories(server PRIVATE include)

Regel voor regel:

• cmake_minimum_required: bepaalt de laagste CMake-versie die je wilt ondersteunen. 3.16 is een redelijke basis voor moderne functies.
• project(...): definieert de projectnaam, versie en taal (CXX = C++).
• set(CMAKE_CXX_STANDARD 17): gebruikt de C++17-standaard. Met STANDARD_REQUIRED ON mislukt de build als die standaard niet beschikbaar is, in plaats van stilletjes terug te vallen.
• add_executable: maakt een uitvoerbaar target met de naam server en vertelt CMake uit welke bronnen het gebouwd moet worden.
• target_include_directories: vertelt de compiler om headers onder include/ te zoeken. PRIVATE betekent dat deze instelling alleen bij dit target hoort.

Het project bouwen: out-of-source builds

De aanbevolen manier om met CMake te bouwen is de buildbestanden gescheiden te houden van de bronboom. We werken daarom in een aparte map build/:

mkdir build
cd build
cmake ..
cmake --build .

Het commando cmake .. leest de CMakeLists.txt in de bovenliggende map en genereert het build-systeem (deze stap heet configure). Vervolgens voert cmake --build . de gegenereerde Makefile of het Ninja-bestand uit om de daadwerkelijke compilatie te doen. Dit commando is platformonafhankelijk en draagbaarder dan rechtstreeks make aanroepen. Het resultaat is een uitvoerbaar bestand met de naam server in build/.

Libraries koppelen en opsplitsen in modules

Servers staan zelden op zichzelf. Vaak hebben ze threads (pthread), encryptie (OpenSSL) of andere libraries nodig. CMake lost dit op met find_package en target_link_libraries:

find_package(Threads REQUIRED)
target_link_libraries(server PRIVATE Threads::Threads)

find_package(Threads REQUIRED) lokaliseert de threading-library van het systeem; dankzij REQUIRED stopt de configure-stap als die niet gevonden wordt. Daarna koppelen we het target Threads::Threads aan server. Dit is de "moderne CMake"-aanpak: je koppelt libraries als targets in plaats van als kale namen, zodat include-paden en compilervlaggen automatisch meekomen.

Naarmate je project groeit, is het zinvol een deel van de code in een aparte library onder te brengen. Je kunt bijvoorbeeld de netwerklaag tot een herbruikbare library maken:

add_library(netcore
    src/Server.cpp
    src/Connection.cpp
)
target_include_directories(netcore PUBLIC include)

add_executable(server src/main.cpp)
target_link_libraries(server PRIVATE netcore Threads::Threads)

Hier is netcore een library-target, en dankzij PUBLIC include erft alles wat eraan koppelt automatisch het include/-pad. Dit is een krachtig patroon dat herhaling in grote projecten voorkomt.

Debug, Release en praktische tips

Tijdens het ontwikkelen van de server wil je debug-informatie; bij het uitbrengen wil je optimalisatie. CMake beheert dit via build-types:

cmake -DCMAKE_BUILD_TYPE=Release ..

Debug voegt symbolen toe en schakelt optimalisatie uit; Release zet optimalisaties zoals -O2 aan. Een paar praktische tips:

• Zet waarschuwingen aan: target_compile_options(server PRIVATE -Wall -Wextra) vangt verborgen bugs vroeg op.
• Voeg de map build/ altijd toe aan .gitignore; commit gegenereerde bestanden nooit naar versiebeheer.
• Gebruik Ninja voor snellere builds: cmake -G Ninja .. is een wijziging van één regel maar veel sneller bij parallel compileren.

Veelgestelde vragen

Wat is het verschil tussen CMake en Make?

Make is een directe build-tool die Makefile's uitvoert. CMake genereert die Makefiles (of andere formaten zoals Ninja en Visual Studio-projecten) voor je. CMake werkt dus op een hoger, platformonafhankelijk niveau, terwijl Make de uitvoer verwerkt die het produceert.

Moet ik elk bestand afzonderlijk in add_executable vermelden?

Ja, dat is de betrouwbaarste manier. Hoewel je bestanden automatisch kunt verzamelen met file(GLOB ...), merkt CMake mogelijk niet wanneer je een nieuw bestand toevoegt. Bronnen expliciet opsommen is de aanbevolen aanpak.

Moet ik de build-map onder versiebeheer plaatsen?

Nee. build/ bevat volledig gegenereerde, machinespecifieke bestanden. Voeg het toe aan .gitignore; iedereen kan het op zijn eigen machine opnieuw genereren met cmake ...

Heb je een degelijke build-opzet nodig voor je serverproject? Of het nu gaat om een CMake-configuratie vanaf nul of om een bestaand C++-project aan de praat krijgen, we lossen het samen op. Neem contact met me op.