Bien démarrer avec CMake

Introduction

CMake est aujourd’hui l’un des outils les plus utilisés pour gérer la compilation de projets logiciels, en particulier en C et C++. Longtemps perçu comme complexe, il est pourtant devenu incontournable dans les environnements professionnels modernes. Son objectif principal est de rendre la compilation portable, reproductible et maintenable, quel que soit le système d’exploitation ou le compilateur utilisé.

Cet article s’adresse aux développeurs débutants à intermédiaires qui souhaitent comprendre CMake de manière progressive et concrète. Nous allons poser les bases, expliquer son intérêt réel, entrer dans son fonctionnement technique et illustrer son usage à travers des exemples simples et réalistes.

Présentation générale de CMake

CMake n’est pas un compilateur, mais un générateur de systèmes de build. Pour mieux comprendre son rôle, une analogie simple et parlante consiste à comparer la chaîne de compilation à un orchestre.

Dans cette analogie, CMake joue le rôle du compositeur. Il écrit la partition du projet : quelles sont les cibles à produire, quels fichiers doivent être compilés, dans quel ordre logique et avec quelles dépendances. Il ne compile rien lui-même, mais décrit précisément comment la compilation doit se dérouler.

Les systèmes de build comme Make ou Ninja peuvent alors être vus comme des chefs d’orchestre. Ils lisent la partition générée par CMake et orchestrent l’exécution concrète des différentes tâches, en optimisant l’ordre, le parallélisme et les reconstructions incrémentales.

Enfin, les compilateurs et outils comme Clang, GCC ou le linker sont les musiciens. Ce sont eux qui exécutent réellement le travail : compilation du code source, édition de liens et génération des binaires.

Concrètement, vous décrivez votre projet dans des fichiers texte appelés CMakeLists.txt, en utilisant le langage CMake. À partir de ces fichiers, CMake génère les scripts de build adaptés à votre environnement. Cette approche permet d’écrire une seule configuration de build pour Windows, Linux ou macOS, sans avoir à maintenir plusieurs scripts distincts.

CMake est particulièrement apprécié pour sa large adoption, son intégration avec les IDE modernes et sa capacité à gérer des projets de taille importante avec de nombreuses dépendances.

Pourquoi CMake est devenu incontournable

La complexité des projets logiciels a fortement augmenté ces dernières années. Multiplication des plateformes, diversité des compilateurs, intégration continue et dépendances externes sont devenues la norme. Dans ce contexte, gérer manuellement la compilation devient rapidement fragile.

CMake apporte une réponse structurée à ces problématiques. Il permet de standardiser la manière de compiler un projet, de décrire clairement ses dépendances et de garantir que le même code sera construit de façon cohérente sur différentes machines. Pour un développeur, cela signifie moins de temps passé à résoudre des problèmes de compilation et plus de temps consacré au code lui-même.

Son adoption massive dans l’écosystème open source et industriel en fait également un atout professionnel. Savoir lire et écrire des fichiers CMake est aujourd’hui une compétence largement attendue dans les projets C++ modernes.

Fonctionnement technique et bases essentielles

Le cœur de CMake repose sur le fichier CMakeLists.txt, placé à la racine du projet. Ce fichier décrit le nom du projet, le langage utilisé, les sources à compiler et les cibles à produire.

Voici un exemple minimal pour un projet C++ simple :

cmake_minimum_required(VERSION 3.15)

project(MonProjet LANGUAGES CXX)

add_executable(mon_programme
    main.cpp
)

cmake_minimum_required(VERSION 3.15)

project(MonProjet LANGUAGES CXX)

add_executable(mon_programme
    main.cpp
)

Dans cet exemple, la première ligne indique la version minimale de CMake requise. La commande project définit le nom du projet et le langage principal. Enfin, add_executable décrit une cible exécutable et la liste des fichiers source associés.

Une fois ce fichier écrit, le processus de build se fait en deux étapes distinctes. La première consiste à générer les fichiers de build dans un répertoire dédié, souvent nommé build. La seconde étape lance la compilation via l’outil généré.

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

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

Cette séparation entre le code source et les fichiers générés est une pratique fondamentale avec CMake. Elle évite de polluer le dépôt de code et facilite le nettoyage ou la reconstruction complète du projet.

Cas d’usage concrets et bonnes pratiques

Dans un projet réel, CMake sert rarement uniquement à compiler un fichier unique. Il est souvent utilisé pour structurer un projet en modules, créer des bibliothèques et gérer des dépendances externes.

Par exemple, il est courant de définir une bibliothèque interne, puis de l’utiliser dans un exécutable :

add_library(mylib
    src/mylib.cpp
    include/mylib.h
)

target_include_directories(mylib PUBLIC include)

add_executable(app main.cpp)

target_link_libraries(app PRIVATE mylib)

add_library(mylib
    src/mylib.cpp
    include/mylib.h
)

target_include_directories(mylib PUBLIC include)

add_executable(app main.cpp)

target_link_libraries(app PRIVATE mylib)

Ce type de configuration rend le projet plus modulaire et plus lisible. Chaque cible décrit explicitement ce dont elle dépend, ce qui améliore la maintenabilité à long terme.

CMake est également très utilisé dans les pipelines d’intégration continue. Sa capacité à fonctionner de manière identique sur différentes plateformes en fait un outil fiable pour automatiser les builds et les tests.

CMake face aux autres outils de build

Pour bien comprendre la place de CMake, il est utile de le comparer à d’autres outils couramment utilisés dans l’écosystème C et C++. Certains sont plus anciens, d’autres plus récents, avec des philosophies différentes.

Make repose principalement sur des Makefiles écrits à la main. Il est très puissant mais peu portable et devient difficile à maintenir dès que le projet grossit. CMake, au contraire, génère automatiquement ces fichiers et masque une grande partie de cette complexité.

Meson est un outil plus moderne, pensé pour être simple et rapide, avec une syntaxe souvent jugée plus lisible. En revanche, son écosystème reste plus restreint et son adoption industrielle est encore inférieure à celle de CMake.

Bazel vise les très grands projets avec des besoins forts en reproductibilité et en performances de build. Il est cependant plus complexe à prendre en main et moins adapté aux projets classiques ou de taille moyenne.

Le tableau ci-dessous résume les principales différences.

Limitations, pièges et erreurs fréquentes

Malgré ses avantages, CMake peut être déroutant au début. L’une des erreurs les plus courantes est de copier des configurations obsolètes trouvées sur internet, basées sur d’anciennes versions de CMake. Le langage a beaucoup évolué et certaines pratiques ne sont plus recommandées aujourd’hui.

Un autre piège fréquent consiste à utiliser des variables globales de manière excessive, ce qui rend les fichiers CMake difficiles à comprendre et à maintenir. Les approches modernes privilégient une gestion par cible, plus explicite et plus robuste.

Enfin, il est important de garder à l’esprit que CMake n’est pas un outil magique. Une mauvaise organisation du projet ou une structure de code fragile ne seront pas corrigées par CMake. Il reste un outil au service de bonnes pratiques de développement.

Conclusion

CMake est un outil puissant qui répond aux besoins concrets des projets logiciels modernes. Bien qu’il puisse sembler complexe au premier abord, son apprentissage progressif apporte rapidement des bénéfices tangibles en termes de portabilité, de fiabilité et de maintenabilité.

Pour un développeur novice à intermédiaire, maîtriser les bases de CMake est un investissement durable. En comprenant ses principes fondamentaux et en adoptant des pratiques modernes, il devient un allié précieux pour structurer et faire évoluer ses projets sur le long terme.