cmakeCommencer avec cmake


Remarques

CMake est un outil de définition et de gestion des versions de code, principalement pour C ++.

CMake est un outil multi-plateforme. L'idée est d'avoir une définition unique de la façon dont le projet est construit, ce qui se traduit par des définitions de construction spécifiques pour toute plate-forme prise en charge.

Cela se fait en associant différents systèmes de compilation spécifiques à la plate-forme; CMake est une étape intermédiaire qui génère des entrées de génération pour différentes plates-formes spécifiques. Sous Linux, CMake génère des Makefiles; sous Windows, il peut générer des projets Visual Studio, etc.

Le comportement de CMakeLists.txt est défini dans les fichiers CMakeLists.txt - un dans chaque répertoire du code source. Le fichier CMakeLists de CMakeLists répertoire définit ce que le buildsystem doit faire dans ce répertoire spécifique. Il définit également les sous-répertoires que CMake doit également gérer.

Les actions typiques incluent:

  • Construisez une bibliothèque ou un exécutable à partir de certains des fichiers source de ce répertoire.
  • Ajoutez un chemin de fichier au chemin d'inclusion utilisé lors de la génération.
  • Définissez les variables que le buildsystem utilisera dans ce répertoire et dans ses sous-répertoires.
  • Générez un fichier en fonction de la configuration de construction spécifique.
  • Recherchez une bibliothèque qui se trouve quelque part dans l'arborescence source.

Les fichiers CMakeLists finaux peuvent être très clairs et simples, car leur portée est tellement limitée. Chacun ne gère que la quantité de construction présente dans le répertoire en cours.

Pour les ressources officielles sur CMake, consultez la documentation et le didacticiel de CMake.

Versions

Version Date de sortie
3.9 2017-07-18
3.8 2017-04-10
3.7 2016-11-11
3.6 2016-07-07
3.5 2016-03-08
3.4 2015-11-12
3.3 2015-07-23
3.2 2015-03-10
3.1 2014-12-17
3.0 2014-06-10
2.8.12.1 2013-11-08
2.8.12 2013-10-11
2.8.11 2013-05-16
2.8.10.2 2012-11-27
2.8.10.1 2012-11-07
2.8.10 2012-10-31
2.8.9 2012-08-09
2.8.8 2012-04-18
2.8.7 2011-12-30
2.8.6 2011-12-30
2.8.5 2011-07-08
2.8.4 2011-02-16
2.8.3 2010-11-03
2.8.2 2010-06-28
2.8.1 2010-03-17
2.8 2009-11-13
2.6 2008-05-05

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

"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!
 

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

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 
 

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.