Utiliser CMake pour compiler un projet

CMake peut être utilisé à travers l'invite de commande (ou terminal). Il suffit de taper :

cmake -G générateur

« générateur » correspond à l'un des générateurs proposés par CMake. Vous devez prendre celui correspondant à l'environnement avec lequel vous voulez compiler.

cmake --help

Si tout se passe correctement, les fichiers pour compiler le projet ont été générés. Sinon, lisez ce que CMake a affiché pour voir où il a bloqué et tentez de corriger suivant les messages.

CMake peut aussi être utilisé à travers une interface graphique.

La première étape est de remplir les chemins « Where is the code source » (Où se trouve le source code) et « Where to build the binaries » (Où compiler les binaires). Pour le premier, vous devez indiquer le dossier contenant le CMakeList.txt, le second doit indiquer où les fichiers générés seront placés. Ce répertoire sera l'emplacement de travail de votre compilateur ou EDI.

Ensuite, vous pouvez cliquer sur le bouton « Configure » pour lancer la configuration de CMake. Immédiatement (et aussi, car c'est votre premier lancement), il vous demandera le générateur à utiliser.

En validant la fenêtre de configuration, CMake va lancer la configuration du projet. Certains projets nécessitent de spécifier des chemins vers les bibliothèques, ou encore, des options de construction. Autant que possible, le CMakeLists.txt devrait être construit pour que CMake soit indépendant. Lorsque la configuration ne peut se finir sans un apport supplémentaire de la part de l'utilisateur, le bouton « Generate » restera grisé et l'interface permettra l'édition des variables utilisées dans le fichier CMakeLists.txt.

Finalement, une fois la configuration finie, il suffit de cliquer sur le bouton « Generate » pour générer les fichiers permettant la compilation ou l'ouverture du projet dans un EDI.

Comme nous l'avons vu, le fichier CMakeLists.txt est la pièce maîtresse pour compiler notre projet. Ce fichier décrit comment compiler le projet et permet donc à CMake de générer les scripts de compilation pour construire le projet.

I-E-1-a. Syntaxe▲

I-E-1-b. Composition▲

I-E-1-c. Exemple sur un projet simple▲

.
├── CMakeLists.txt
├── hello.c
├── hello.h
└── main.c

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités
cmake_minimum_required(VERSION 3.0)

# Notre projet est étiqueté hello
project(hello)

# Crée des variables avec les fichiers à compiler
set(SRCS
    main.c
    hello.c
    )
    
set(HEADERS
    hello.h
    )

# On indique que l'on veut un exécutable "hello" compilé à partir des fichiers décrits par les variables SRCS et HEADERS
add_executable(hello ${SRCS} ${HEADERS})

I-E-1-d. Exemple sur un projet avec une bibliothèque en sous-projet▲

.
├── CMakeLists.txt
├── libhello
│   ├── CMakeLists.txt
│   ├── hello.c
│   └── hello.h
└── main.c

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités
cmake_minimum_required(VERSION 3.0)

# Notre projet est étiqueté libhello
project(libhello)

# Crée des variables avec les fichiers à compiler
set(SRCS
    hello.c
    )
    
set(HEADERS
    hello.h
    )

add_library(hello ${SRCS} ${HEADERS})

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités
cmake_minimum_required(VERSION 3.0)

# Notre projet est étiqueté hello
project(hello)

# On inclut notre bibliothèque dans le processus de CMake
add_subdirectory(libhello)

# Crée des variables avec les fichiers à compiler
set(SRCS
    main.c
    )
    
# Notre exécutable
add_executable(main ${SRCS})

# Et pour que l'exécutable fonctionne, il faut lui indiquer la bibliothèque dont il dépend
target_link_libraries(main hello)

I-E-1-e. Exemple sur un projet avec une bibliothèque externe▲

.
├── CMakeLists.txt
└── main.c

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités
cmake_minimum_required(VERSION 3.0)

# Notre projet est étiqueté hello
project(helloSDL)

# Crée des variables avec les fichiers à compiler
set(SRCS
    main.c
    )
    
# Notre exécutable
add_executable(main ${SRCS})

# Recherche la dépendance externe
find_package (PNG)
if (PNG_FOUND)
  # Une fois la dépendance trouvée, nous l'incluons au projet
  target_include_directories(main PUBLIC ${PNG_INCLUDE_DIR})
  target_link_libraries (main ${PNG_LIBRARY})
else ()
  # Sinon, nous affichons un message
  message(FATAL_ERROR "libpng not found")
endif ()

I-E-1-f. En vrac▲

# Cette ligne doit être placée après les add_executable/add_library
target_compile_features(hello PUBLIC cxx_nullptr)

install(TARGETS hello RUNTIME DESTINATION .)

install(FILES fichier DESTINATION .)

install(DIRECTORY source DESTINATION .)

#define VERSION_MAJOR "@HELLO_VERSION_MAJOR@"

project(hello VERSION 1.0.1)

configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/version.h.in ${CMAKE_CURRENT_SOURCE_DIR}/version.h)

CMake vous permet de vérifier la présence de la bibliothèque et d'obtenir les fichiers à lier à votre projet avec la fonction find_package() :

find_package(Qt5 COMPONENTS Widgets OpenGL)

Dans cet exemple, nous souhaitons obtenir les modules « Widgets » et « OpenGL ». Par la suite, vous devrez utiliser « Qt5::Widgets » et « Qt5::OpenGL » pour lier les bibliothèques de Qt à votre projet.

Une seconde syntaxe permet d'écrire :

find_package(Qt5Widgets)

Elle ne présente pas de différence avec la première.

Une des particularités de la compilation d'un projet Qt est son utilisation du moc. CMake propose un mécanisme très simple pour définir lorsqu'un projet nécessite l'utilisation du moc :

# Indique d'utiliser moc lorsque nécessaire.
set(CMAKE_AUTOMOC ON)
# Indique de chercher les entêtes dans les répertoires de compilation.
# Cela est nécessaire, car les fichiers du moc seront générés dans ces dossiers.
set(CMAKE_INCLUDE_CURRENT_DIR ON)

Les fichiers d'interface utilisateur (.ui) de Qt doivent être transformés avant de pouvoir les inclure dans le binaire. Pour ce faire il faut utiliser la fonction qt5_wrap_ui() :

set(UIS interface1.ui interface2.ui)

qt5_wrap_ui(UIS_HDRS ${UIS})

Finalement, la variable UIS_HDRS doit être passée en argument de la fonction add_executable() lors de la création du binaire.

De la même manière que les fichiers d'interface utilisateur, les fichiers de ressources doivent être traités avant de pouvoir être intégrés. La fonction est qt5_add_resources :

set(RESSOURCE hello-qt.qrc)

qt5_add_resources(RESSOURCE_HDR RESSOURCE)

Finalement, la variable RESSOURCE_HDR devra être passée en argument de la fonction add_executable() lors de la création du binaire.

La création du binaire se fait comme dans tout autre projet. Il ne faut simplement pas oublier les fichiers générés par le traitement des fichiers d'interface utilisateur (.ui) ou de ressources (.qrc) :

add_executable(hello-qt ${SRCS} ${HDRS} ${UIS_HDRS} ${RESSOURCE_HDR})
target_link_libraries(hello-qt Qt::Widgets Qt::OpenGL)

Il est conseillé d'indiquer une version minimale 3.X avec la fonction cmake_minimum_required(). Il peut encore être toléré de voir une version préalable 2.8, mais en règle générale, pour un nouveau projet, il vaut mieux utiliser la version la plus récente.

I-G-1-a. Version minimale pour Qt▲

Lors de la création du CMakeLists.txt ne faites pas la supposition que votre projet sera toujours à la racine. Il est possible que le projet soit inclus à son tour dans un autre projet.
Pour la même raison, ne modifiez pas les variables globales.

Tout comme pour la compilation, nous allons utiliser le fichier CMakeLists.txt pour décrire à CPack comment empaqueter le projet.

Nous reprenons le deuxième projet et lui rajoutons la configuration nécessaire pour en produire un paquet (ou installateur pour Windows).

Le fichier CMakeLists.txt de la bibliothèque :

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités
cmake_minimum_required(VERSION 3.0)

# Notre projet est étiqueté libhello
project(libhello)

# Crée des variables avec les fichiers à compiler
set(SRCS
    hello.c
    )
    
set(HEADERS
    hello.h
    )

add_library(hello ${SRCS} ${HEADERS})

# La bibliothèque peut être soit une bibliothèque statique, soit dynamique, donc on précise où installer pour les deux cas
install(TARGETS hello LIBRARY DESTINATION lib
                      ARCHIVE DESTINATION lib)

Et le CMakeLists.txt pour le projet principal :

# Nous voulons un cmake "récent" pour utiliser les dernières fonctionnalités
cmake_minimum_required(VERSION 3.0)

# Notre projet est étiqueté hello
project(hello)

# On inclut notre bibliothèque dans le processus de CMake
add_subdirectory(libhello)

# Crée des variables avec les fichiers à compiler
set(SRCS
    main.c
    )
    
# Notre exécutable
add_executable(main ${SRCS})

# Et pour que l'exécutable fonctionne, il faut lui indiquer la bibliothèque dont il dépend
target_link_libraries(main hello)

# Indique que l'on installe l'exécutable dans un dossier bin
install (TARGETS main DESTINATION bin)

# Section CPack
include (CPack)

Pour faire notre paquet, nous avons simplement indiqué comment installer notre programme avec la fonction install(). Ensuite, pour pouvoir empaqueter le projet, nous avons invoqué CPack.

CPack utilise les appels à la fonction install() pour savoir quels sont les fichiers à inclure dans le paquet.

Pour améliorer la configuration de votre installateur, vous pouvez utiliser de nombreuses variables décrites dans la documentation officielle. Voici un court exemple d'utilisation :

SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "CMake demo")
SET(CPACK_PACKAGE_VENDOR "LittleWhite")
SET(CPACK_PACKAGE_EXECUTABLES "Hello" "Hello")

Vous pouvez récupérer le projet ici.