Processus de build CMake

Le processus de compilation CMake se divise en plusieurs étapes principales, de la création d'un répertoire de build à l'exécution de la compilation, puis au nettoyage et à la reconfiguration.

L'ensemble du processus tourne autour du fichier de configuration CMakeLists.txt. Après avoir lu la configuration, CMake génère des fichiers de build adaptés à la plateforme actuelle.

Aperçu du processus de compilation

Un processus de compilation CMake complet comprend les cinq étapes clés suivantes, chacune avec son objectif et ses commandes spécifiques.

Étape	Opération	Commande	Description
1	Créer le répertoire de build	`mkdir build && cd build`	Utilisez la méthode Out-of-source pour garder le répertoire source propre
2	Générer les fichiers de build	`cmake ..`	Lire CMakeLists.txt, générer Makefile / Ninja / .sln, etc.
3	Compiler et construire	`cmake --build .`	Exécuter le processus réel de compilation et d'édition de liens
4	Nettoyer les fichiers de build	`cmake --build . --target clean`	Supprimez les fichiers intermédiaires et les fichiers objets générés lors de la compilation
5	Reconfigurer et compiler	`cmake .. && cmake --build .`	Après des modifications de CMakeLists.txt, régénérer et recompiler

CMake 构建流程图

Processus de compilation détaillé

Ce qui suit détaille les opérations spécifiques et les options courantes pour chaque étape.

Créer le répertoire de build

CMake recommande d'utiliserOut-of-source(out-of-source) comme méthode de compilation, c'est-à-dire placer les fichiers de compilation dans un répertoire séparé en dehors du répertoire du code source.

Cette approche garde le répertoire source propre tout en prenant en charge plusieurs configurations de compilation différentes à partir du même code source (comme la coexistence de Debug et Release).

Utilisez toujours la méthode de compilation Out-of-source. Exécuter cmake directement dans le répertoire source polluera la structure du projet, rendant difficile le nettoyage des fichiers intermédiaires générés et peu pratique le changement de type de compilation.

Out-of-source 构建方式示意图

Créer le répertoire de compilation :

# 在项目根目录下创建 build 目录
mkdir build

Entrer dans le répertoire de compilation :

# 切换到构建目录，后续所有 cmake 命令在此执行
cd build

Générer les fichiers de build

Exécutez CMake dans le répertoire de compilation, lisez le CMakeLists.txt dans le répertoire source et générez les fichiers du système de compilation adaptés à la plateforme actuelle.

CMake prend en charge plusieurs générateurs de systèmes de compilation, tels que Unix Makefiles, Ninja, Visual Studio, Xcode, etc.

Utilisation de base — générer les fichiers de compilation par défaut :

# .. 指向包含 CMakeLists.txt 的源代码目录
cmake ..

Spécifier le générateur :

Utilisez-GLe paramètre peut spécifier le type de système de compilation à générer.

# 使用 Ninja 作为构建系统（速度比 Make 更快）
cmake -G "Ninja" ..

Spécifier le type de compilation :

Utilisez-DCMAKE_BUILD_TYPELe paramètre définit le niveau d'optimisation de compilation et les informations de débogage.

# 四种常见的构建类型：Debug / Release / RelWithDebInfo / MinSizeRel
cmake -DCMAKE_BUILD_TYPE=Release ..

Vérifier le résultat de la configuration :

CMake affichera des informations détaillées lors de la configuration, notamment le compilateur détecté, les bibliothèques trouvées, les options définies, etc.

S'il n'y a pas d'erreurs, les fichiers du système de compilation seront générés dans le répertoire de compilation actuel.

Si une erreur se produit lors de la configuration (comme l'impossibilité de trouver une bibliothèque spécifiée), CMake s'interrompt et affiche un message d'erreur. Après avoir résolu l'erreur, réexécutez la commande cmake pour continuer.

Compiler et construire

Une fois les fichiers de compilation générés, le processus réel de compilation et d'édition de liens peut être exécuté.

Différents systèmes de compilation utilisent différentes commandes de compilation ; vous pouvez également utiliser la commande de compilation générique fournie par CMake.

Méthode recommandée — utiliser la commande de compilation générique de CMake :

# 无论底层使用哪种构建系统，该命令都能正确编译
cmake --build .

Construire une cible spécifique :

# 只编译指定的目标（如某个可执行文件或库）
cmake --build . --target MyExecutable

Utilisation du système de compilation Makefile :

# 编译所有目标
make

# 使用多核并行编译（-j 参数指定并行任务数）
make -j$(nproc)

# 编译特定目标
make MyExecutable

Utilisation du système de compilation Ninja :

# Ninja 自动并行编译，无需手动指定 -j
ninja

# 编译特定目标
ninja MyExecutable

Utilisation de Visual Studio :

Si un fichier de projet Visual Studio est généré, vous pouvez ouvrir le fichier de solution.sln, puis sélectionner Build Solution dans l'IDE.

# 也可以使用 MSBuild 命令行工具编译
msbuild MyProject.sln /p:Configuration=Release

Nettoyer les fichiers de build

Les fichiers intermédiaires (.o, .obj, etc.) et les fichiers objets générés pendant le processus de compilation peuvent être supprimés via l'opération clean pour libérer de l'espace disque.

Utilisez la commande clean générique de CMake :

cmake --build . --target clean

Utilisation de Makefile :

make clean

Utilisation de Ninja :

ninja clean

Nettoyage manuel :

# 删除构建目录中的所有文件，保留源代码目录不变
rm -rf build/*

La façon la plus simple et la plus complète de nettoyer est de supprimer tout le répertoire de build, puis de le recréer et d'exécuter cmake. C'est plus fiable que d'exécuter clean seul, car la cible clean peut ne pas être définie correctement.

Reconfigurer et compiler

Après avoir modifié le fichier CMakeLists.txt ou ajusté les paramètres du projet, vous devez réexécuter la configuration CMake et recompiler.

Reconfigurer :

# CMake 会自动检测变更的文件，只重新生成受影响的部分
cmake ..

Recompiler :

# 编译系统会自动识别哪些源文件发生了变更，只重新编译改动的部分
cmake --build .

Dans la plupart des cas, après avoir modifié CMakeLists.txt, vous pouvez simplement exécuter cmake --build . Le système de compilation détectera automatiquement les modifications de CMakeLists.txt et relancera l'étape de configuration de cmake.

Comparaison des systèmes de compilation

CMake peut générer plusieurs types de fichiers de système de compilation. Ci-dessous une comparaison des trois systèmes de compilation les plus couramment utilisés.

Système de compilation	Plateformes applicables	Compilation parallèle	Fonctionnalités
Unix Makefiles	Linux / macOS	Spécification manuelle requise`-j`	Compatibilité la plus large ; intégré à presque tous les systèmes Unix
Ninja	Multiplateforme	Parallélisation automatique	Vitesse accrue, particulièrement adaptée à la compilation incrémentielle et aux grands projets
Visual Studio	Windows	Gestion automatique de l'IDE	Intégration poussée avec l'IDE VS, avec prise en charge du débogage et de la configuration graphiques

Notes

Utilisez toujours une compilation hors source.Exécuter cmake dans le répertoire source génère de nombreux fichiers intermédiaires et pollue le contrôle de version. Ajouter le répertoire de build à .gitignore est une bonne pratique.

Préférez la commande cmake --build .Cette commande est un point d'entrée de compilation universel multiplateforme, et fonctionne correctement que le système sous-jacent soit Make, Ninja ou MSBuild. Elle est particulièrement recommandée dans les scripts et les environnements CI.

Le type de compilation affecte les performances et l'expérience de débogage.Le mode Debug inclut les symboles de débogage et aucune optimisation, ce qui convient au développement ; le mode Release active les optimisations et supprime les informations de débogage, ce qui convient au déploiement en production. N'utilisez pas le mode Debug pour tester les performances, et n'utilisez pas le mode Release pour déboguer du code.

Lorsque vous rencontrez d'étranges erreurs de build, supprimez le répertoire de build et recommencez.Le cache de CMake peut parfois conserver des informations de configuration obsolètes, ce qui conduit à des erreurs difficiles à diagnostiquer. Supprimer tout le répertoire de build et réexécuter cmake est le moyen le plus rapide de résoudre le problème.

Autres extensions