cmake Tutoriel
Commencer avec cmake

Remarques

Versions

Installation CMake

Rendez -vous sur la page de téléchargement de CMake et obtenez un fichier binaire pour votre système d'exploitation, par exemple Windows, Linux ou Mac OS X. Sous Windows, double-cliquez sur le fichier binaire à installer. Sous Linux, lancez 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 l'application de ligne de commande et 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 paquets disponibles pour installer votre logiciel, le plus notable étant MacPorts ( MacPorts ) et Homebrew ( Homebrew ), vous pouvez également installer CMake via l'un d'eux. Par exemple, dans le cas de MacPorts, tapez ce qui suit

sudo port install cmake  

va installer CMake, tandis que si vous utilisez le gestionnaire de paquets Homebrew, vous devrez taper

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).

Basculer entre les types de construction, par exemple le débogage et la libération

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 d'autres chemins de code.

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

• Debug : généralement une version de débogage classique incluant des informations de débogage, aucune optimisation, etc.
• Version : votre version standard sans informations de débogage et optimisation complète.
• RelWithDebInfo:: Identique à Release , mais avec des informations de débogage.
• MinSizeRel : une version spéciale optimisée pour la taille.

La manière 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 utiliser --config CONFIG (avec cmake --build ) quelle configuration vous voulez construire. Pour ces générateurs, CMake fera de son mieux pour générer une structure de répertoire de construction de sorte que les fichiers provenant de différentes configurations ne se chevauchent pas.

Les générateurs qui ne prennent en charge 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, vous pouvez é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 devrait é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 le redémarrage de CMake. Une génération ultérieure est susceptible de remplacer les fichiers objets produits par la configuration antérieure.

Projet simple "Hello World"

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

main.cpp ( exemple Hello C ++ )

#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 en cours.

2. project(hello_world) lance 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 app cible de génération est créée, qui invoque le compilateur configuré avec quelques indicateurs par défaut pour le paramètre actuel afin de 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 donné . répertoire et génère l'environnement de génération dans le répertoire de travail en cours.

Le cmake --build . commande est une abstraction pour la construction / appel nécessaire.

Ligne de commande (hors source, recommandé)

Pour que votre code source reste propre à tous les artefacts de build, vous devez effectuer des builds "out-of-source".

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

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

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

"Hello World" avec plusieurs fichiers sources

Tout d'abord, nous pouvons spécifier les répertoires des fichiers d'en-tête par include_directories() , puis nous devons spécifier les fichiers sources correspondants de l'exécutable cible par add_executable() , et nous devons être sûrs qu'il existe 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 pour construire notre projet. Ensuite, l' app exécution imprimera

>./app
Hello World!

"Hello World" en bibliothèque

Cet exemple montre comment déployer le programme "Hello World" en tant que bibliothèque et comment le lier aux autres cibles.

Disons que nous avons le même ensemble de fichiers source / en-tête que dans l'exemple http://www.riptutorial.com/cmake/example/22391/-hello-world--with-multiple-source-files . Au lieu de construire à partir de plusieurs fichiers sources, nous pouvons d'abord déployer foo.cpp tant que bibliothèque en utilisant add_library() et en le liant ensuite au programme principal avec target_link_libraries() .

Nous modifions CMakeLists.txt en

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.