Tutoriel CMake

CMake est un outil de construction de projet, comparable à make et Makefile présentés en cours. Il est plus moderne et de plus haut niveau : un en sens on pourrait dire que c'est un outil pour générer des Makefile. En ce sens, CMake part de plus loin et nécessite une étape supplémentaire avant la compilation : celle de générer le matériel qui permettra de lancer la compilation (comme par exemple générer un Makefile). Il utilise pour cela un fichier CMakeLists.txt.

Détaillons tout ça en repartant de l'exercice 2 de la série 1 (compilation de deux versions du calcul de la factorielle).

À noter que CMake est un outil puissant (donc complexe) dont nous n'apprendrons ici qu'à utiliser que les bases les plus fondamentales. Pour pousser l'apprentissage plus loin, vous pouvez consulter la documentation officielle.

Un nouveau projet de plusieurs fichiers

Le point de départ est d'avoir un répertoire associé à votre « projet ». Par « projet » on entend l'ensemble des fichiers allant ensemble pour faire un exécutable.

Commencez donc par créer un nouveau répertoire, p.ex. fact_cmake et copiez y les fichiers nécessaires :

mkdir fact_cmake
cp factmain.cc factorielleRecursive.cc factorielleIterative.cc demander_nombre.cc demander_nombre.h factorielle.h fact_cmake

Ouvrez ensuite ces fichiers (ceux du nouveau « projet », pas les anciens utilisés pour make) dans Geany ou dans QtCreator. Si vous utilisez ce dernier, ouvrez les fichiers sans les intégrer à un projet en faisant simplement:

Open File or Project

puis ouvrez directement le fichier concerné (donc sans passer par la création d'un projet). Faites alors abstraction du message indiquant que ces fichiers ne sont intégrés à aucun projet. Nous y remédierons un peu plus tard.

Pour pouvoir utiliser CMake pour compiler votre nouveau «projet», il faut créer un fichier CMakeLists.txt à la racine du répertoire de votre projet. Créez donc un tel fichier CMakeLists.txt, vide pour le moment (par exemple à à l'aide de l'éditeur Geany ou dans QtCreator en utilisant New File or Project > General > Empty file).
Il est impératif que ce fichier soit ainsi nommé.

Ajoutez ensuite dans ce fichier les lignes suivantes:

cmake_minimum_required(VERSION 3.5)
project(TEST_COMPILATION_SEPAREE)
  
set(CMAKE_CXX_STANDARD 11) # ou 17, 20 ou 23

# set(CMAKE_BUILD_TYPE Debug)

set(CMAKE_CXX_FLAGS "-Wall")

include_directories(${PROJECT_SOURCE_DIR})

file(GLOB PROJECT_SHARED_SOURCES
     "${PROJECT_SOURCE_DIR}/demander_nombre.cc"
     "${PROJECT_SOURCE_DIR}/demander_nombre.h"
     "${PROJECT_SOURCE_DIR}/factorielle.h"
)

add_executable (factorielleRecursive ${PROJECT_SOURCE_DIR}/factmain.cc
 ${PROJECT_SOURCE_DIR}/factorielleRecursive.cc
 ${PROJECT_SHARED_SOURCES}
)
add_executable (factorielleIterative ${PROJECT_SOURCE_DIR}/factmain.cc
 ${PROJECT_SOURCE_DIR}/factorielleIterative.cc
 ${PROJECT_SHARED_SOURCES}
)

Quelques explications:

• project(TEST_COMPILATION_SEPAREE) (facultatif), permet de donner un nom au projet pour lequel on souhaite construire des exécutables.
• set(CMAKE_CXX_STANDARD 11) indique que l'on veut compiler sous la norme C++11 (c'est la même chose que -std=c+11 dans la commande de compilation manuelle). Vous pouvez bien sûr l'adapter à votre choix.
• set(CMAKE_BUILD_TYPE Debug) indique que l'on veut compiler en mode «debug» (c'est la même chose que -g dans la commande de compilation manuelle). On peut commenter/décommenter cette ligne en ajoutant/supprimant le caractère # au début de cette ligne.
• set(CMAKE_CXX_FLAGS "-Wall") permet de spécifier des options de compilations particulières (par exemple ici on veut que le compilateur signale tous les «warning»). Vous pouvez bien sûr l'adapter à vos choix.
• include_directories(${PROJECT_SOURCE_DIR}) permet d'inclure le répertoire racine du projet (celui où se trouve le fichier CMakeLists.txt) dans les chemins où le compilateur fait sa recherche des fichiers à compiler.

• file(GLOB PROJECT_SHARED_SOURCES
       "${PROJECT_SOURCE_DIR}/demander_nombre.cc"
       "${PROJECT_SOURCE_DIR}/demander_nombre.h"
       "${PROJECT_SOURCE_DIR}/factorielle.h"
  )
  

  définit une variable PROJECT_SHARED_SOURCES (vous êtes libre de choisir le nom) qui décrit où se localisent les fichiers à compiler pour produire les exécutables.
  Dans ce projet particulier, j'ai choisi de ne mettre que les fichiers communs partagés par les deux exécutables que l'on veut construire, mais vous pouvez y mettre ce que vous souhaitez (en utilisant p.ex. "${PROJECT_SOURCE_DIR}/*.cc" pour un projet où ce serait pertinent), ou même définir plusieurs variables différentes suivant la complexité de votre projet et ce que vous souhaitez faire (quel(s) groupe(s) de fichiers).
• Les deux séquences qui suivent (add_executable) permettent de définir des « cibles » à construire, et de leur associer la liste des fichiers à compiler, puis à lier ensemble. Cela permet de produire plusieurs exécutables dans un même projet. Le nom des cibles peut, bien sûr, être choisi librement.
  Observez aussi comment j'y ai fait usage de la variable PROJECT_SHARED_SOURCES définie plus haut.
• À noter que l'on peut ajouter des lignes target_link_libraries(nom_exec nom_lib) pour de lier vos exécutables à des librairies externes (comme p.ex. l'équivalent du -lm dans le cas de compilation avec la librairie mathématique. Ce n'est pas le cas ici, mais si p.ex. on faisait un exécutable machin_truc qui nécessite la bibliothèque mathématique, on ajouterait :

       target_link_libraries(machin_truc m)
  

  (oui, juste m pour le nom de la bibliothèque : c'est le m de -lm).

Voilà, nous sommes maintenant prêts à lancer notre compilation/édition de lien au moyen de CMake !

Construction des cibles à la main

Comme pour make, il n'est pas nécessaire d'utiliser un EDI comme Qt Creator pour lancer la compilation et l'exécution des cibles au moyen de CMake. On peut très bien le faire « à la main » (si vous utilisez Qt Creator, voir la section suivante). Tapez simplement (dans le terminal, mis dans le bon répertoire:

      cmake .
   

Note: le . (point) de la commande ci-dessus désigne un répertoire : le répertoire courant; mais on peut, bien sûr, mettre un autre nom de répertoire si le fichier CMakeLists.txt est ailleurs : c'est le nom du répertoire où ce trouve ce fichier qu'il faut donner à cmake

Voyez que cmake a en effet construit un Makefile (que vous pouvez aller voir, juste pour voir la différence entre les bases minimales vues en cours et ce qu'un vrai Makefile de pro contient !)

Vous pouvez ensuite, à votre guise, lancer l'une ou l'autre ou les deux des cibles exécutables:

    make factorielleRecursive

    make factorielleIterative

    make

qui fait les deux (bien sûr si une des deux cibles a déjà été faite et est à jour, cela ne va pas la refaire).

Note: À noter que la commande make n'existe pas telle quelle dans l'installation MinGW sous Windows. Dans cet environnement, la commande s'appelle en effet mingw32-make.
Si vous compilez « à la main » depuis un terminal Windows, il faut donc taper mingw32-make au lieu de taper make.
Une autre solution, plus simple mais plus intrusive (= à refaire si vous mettez à jour ou réinstallez le compilateur) est de changer le nom de cet exécutable mingw32-make simplement en make. Pour cela, allez dans C:\MinGW\bin et là-bas renommez le fichier mingw32-make.exe simplement make..exe

Construction des cibles dans QtCreator

Si vous utilisez Qt Creator, vous pouvez maintenant créer un projet QtCreator de façon analogue à ce qui est décrit ici. Vous verrez que la commande de «build» (petit marteau) permet de créer les deux cibles, que vous pouvez tour à tour choisir pour les exécuter.

Pour conclure cette introduction

Cmake permet de faire bien d'avantage que ce qui est décrit ici. Comme indiqué en introduction, vous pouvez investiguer la documentation officielle pour pousser vos compétences sur cet outil plus loin si vous le souhaitez (et en avez le temps !!).