Démarrer avec cmake

Installation de CMake

Rendez-vous sur la page de téléchargement de [CMake][1] et obtenez un binaire pour votre système d’exploitation, par ex. Windows, Linux ou Mac OS X. Sous Windows, double-cliquez sur le binaire à installer. Sous Linux, exécutez le binaire depuis un terminal.

Sous Linux, vous pouvez également installer les packages à partir du gestionnaire de packages de la distribution. Sur Ubuntu 16.04, vous pouvez installer la ligne de commande et l’application graphique avec :

sudo apt-get install cmake
sudo apt-get install cmake-gui

Sur FreeBSD, vous pouvez installer la ligne de commande et l’application graphique basée sur Qt avec :

pkg install cmake
pkg install cmake-gui

Sur Mac OSX, si vous utilisez l’un des gestionnaires de packages disponibles pour installer votre logiciel, les plus notables étant MacPorts ([MacPorts][2]) et Homebrew ([Homebrew][3]), vous pouvez également installer CMake via l’un des leur. Par exemple, dans le cas de MacPorts, en tapant ce qui suit

sudo port install cmake  

installera CMake, tandis que si vous utilisez le gestionnaire de paquets Homebrew, vous taperez

brew install cmake

Une fois que vous avez installé CMake, vous pouvez vérifier facilement en procédant comme suit

cmake --version

Vous devriez voir quelque chose de similaire à ce qui suit

cmake version 3.5.1

CMake suite maintained and supported by Kitware (kitware.com/cmake).

[1] : https://cmake.org/download/ [2] : https://www.macports.org/ [3] : http://brew.sh/

Projet “Hello World” simple

Étant donné un fichier source C++ main.cpp définissant une fonction main(), un fichier CMakeLists.txt d’accompagnement (avec le contenu suivant) demandera à CMake de générer les instructions de construction appropriées pour le système actuel et le compilateur C++ par défaut .

main.cpp (Exemple C++ Hello World)

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
    return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.4)

project(hello_world)

add_executable(app main.cpp)

Voir en direct sur Coliru

  1. cmake_minimum_required(VERSION 2.4) définit une version minimale de CMake requise pour évaluer le script actuel.

  2. project(hello_world) démarre un nouveau projet CMake. Cela déclenchera beaucoup de logique CMake interne, en particulier la détection du compilateur C et C++ par défaut.

  3. Avec add_executable(app main.cpp) une cible de construction app est créée, qui invoquera le compilateur configuré avec quelques drapeaux par défaut pour le paramètre actuel pour compiler une app exécutable à partir du fichier source donné main.cpp.

Ligne de commande (In-Source-Build, non recommandé)

> cmake .
...
> cmake --build .

cmake . fait la détection du compilateur, évalue le CMakeLists.txt dans le répertoire . donné et génère l’environnement de construction dans le répertoire de travail actuel.

La commande cmake --build . est une abstraction pour l’appel build/make nécessaire.

Ligne de commande (Out-of-Source, recommandé)

Pour garder votre code source propre de tout artefact de build, vous devez faire des builds “hors source”.

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

Ou CMake peut également extraire les commandes de base du shell de votre plate-forme à partir de l’exemple ci-dessus :

> cmake -E make_directory build
> cmake -E chdir build cmake .. 
> cmake --build build 

“Hello World” comme bibliothèque

Cet exemple montre comment déployer le programme “Hello World” en tant que bibliothèque et comment le lier à d’autres cibles.

Disons que nous avons le même ensemble de fichiers source/en-tête que dans le * https://www.wikiod.com/fr/docs/cmake/862/getting-started-with-cmake/22391/hello-world-with-multiple-source-files #t=201610310659039267444* exemple. Au lieu de construire à partir de plusieurs fichiers source, nous pouvons d’abord déployer foo.cpp en tant que bibliothèque en utilisant [add_library()][1] et ensuite le lier au programme principal avec [target_link_libraries()][2 ].

Nous modifions CMakeLists.txt pour

cmake_minimum_required(VERSION 2.4)

project(hello_world)

include_directories(${PROJECT_SOURCE_DIR})
add_library(applib foo.cpp)
add_executable(app main.cpp)
target_link_libraries(app applib)

et en suivant les mêmes étapes, nous obtiendrons le même résultat.

[1] : https://cmake.org/cmake/help/v3.0/command/add_library.html [2] : https://cmake.org/cmake/help/v3.0/command/target_link_libraries.html

Basculer entre les types de construction, par ex. déboguer et publier

CMake connaît plusieurs types de construction, qui influencent généralement les paramètres par défaut du compilateur et de l’éditeur de liens (tels que les informations de débogage en cours de création) ou les chemins de code alternatifs.

Par défaut, CMake est capable de gérer les types de build suivants :

Débogage : généralement une version de débogage classique comprenant des informations de débogage, aucune optimisation, etc.

  • Release : votre build de version typique sans informations de débogage et avec une optimisation complète.
  • RelWithDebInfo : : identique à Release, mais avec des informations de débogage.
  • MinSizeRel : Une version spéciale Release optimisée pour la taille.

La façon dont les configurations sont gérées dépend du générateur utilisé.

Certains générateurs (comme Visual Studio) prennent en charge plusieurs configurations. CMake générera toutes les configurations en même temps et vous pourrez sélectionner dans l’IDE ou en utilisant --config CONFIG (avec cmake --build) la configuration que vous souhaitez créer. Pour ces générateurs, CMake fera de son mieux pour générer une structure de répertoires de construction telle que les fichiers de différentes configurations ne se chevauchent pas.

Les générateurs qui ne supportent qu’une seule configuration (comme les Makefiles Unix) fonctionnent différemment. Ici, la configuration actuellement active est déterminée par la valeur de la variable CMake CMAKE_BUILD_TYPE.

Par exemple, pour choisir un type de construction différent, on pourrait émettre les commandes de ligne de commande suivantes :

cmake -DCMAKE_BUILD_TYPE=Debug path/to/source
cmake -DCMAKE_BUILD_TYPE=Release path/to/source

Un script CMake doit éviter de définir le CMAKE_BUILD_TYPE lui-même, car il est généralement considéré comme la responsabilité de l’utilisateur de le faire.

Pour les générateurs à configuration unique, la commutation de la configuration nécessite de réexécuter CMake. Une génération ultérieure est susceptible d’écraser les fichiers objets produits par la configuration précédente.

“Hello World” avec plusieurs fichiers sources

Nous pouvons d’abord spécifier les répertoires des fichiers d’en-tête par [include_directories()][1], puis nous devons spécifier les fichiers source correspondants de l’exécutable cible par [add_executable()][2], et être sûr qu’il y a exactement une fonction main() dans les fichiers source.

Voici un exemple simple, tous les fichiers sont supposés placés dans le répertoire PROJECT_SOURCE_DIR.

main.cpp

#include "foo.h"

int main()
{
    foo();
    return 0;
}

foo.h

void foo();

foo.cpp

#include <iostream>
#include "foo.h"

void foo()
{
    std::cout << "Hello World!\n";
}

CMakeLists.txt

cmake_minimum_required(VERSION 2.4)

project(hello_world)

include_directories(${PROJECT_SOURCE_DIR})
add_executable(app main.cpp foo.cpp)  # be sure there's exactly one main() function in the source files

Nous pouvons suivre la même procédure dans l’[exemple ci-dessus][3] pour construire notre projet. Ensuite, l’exécution de app imprimera

>./app
Hello World!

[1] : https://cmake.org/cmake/help/v3.0/command/include_directories.html [2] : https://cmake.org/cmake/help/v3.0/command/add_executable.html [3] : https://www.wikiod.com/fr/docs/cmake/862/introduction-to-cmake/7501/simple-hello-world-project