Mettre en place un système de build avec CMake et VSCodium

Cet article fait partie d’une série sur les outils DevOps open source pour le développement C/C++. Si vous construisez votre projet dès le départ sur une chaîne d’outils puissante, vous bénéficierez d’un développement plus rapide et plus sûr. En dehors de cela, il vous sera plus facile d’impliquer d’autres personnes dans votre projet. Dans cet article, je vais préparer un système de build C/C++ basé sur Cfaire et VSCodium. Comme d’habitude, l’exemple de code associé est disponible sur GitHub.

J’ai testé les étapes décrites dans cet article. C’est une solution pour toutes les plateformes.

Pourquoi CMake ?

CMake est un générateur de système de build qui crée le Makefile pour votre projet. Ce qui semble simple à première vue peut être assez complexe au deuxième coup d’œil. À haute altitude, vous définissez les différentes parties de votre projet (exécutables, bibliothèques), les options de compilation (norme C/C++, optimisations, architecture), les dépendances (en-tête, bibliothèques) et la structure du projet au niveau du fichier. Ces informations sont mises à la disposition de CMake dans le fichier CMakeLists.txt en utilisant un langage de description spécial. Lorsque CMake traite ce fichier, il détecte automatiquement les compilateurs installés sur vos systèmes et crée un Makefile fonctionnel.

De plus, la configuration décrite dans le CMakeLists.txt peut être lu par de nombreux éditeurs comme QtCreator, VSCodium/VSCode ou Visual Studio.

Exemple de programme

Notre exemple de programme est un simple outil de ligne de commande : il prend un entier comme argument et génère des nombres mélangés de manière aléatoire dans la plage allant de un à la valeur d’entrée fournie.

$ ./Producer 10
3 8 2 7 9 1 5 10 6 4 

Dans le main() fonction de notre exécutable, nous traitons simplement le paramètre d’entrée et sortons du programme si aucune valeur (ou une valeur qui ne peut pas être traitée) n’est fournie.

producteur.cpp

int main(int argc, char** argv){
    if (argc != 2) {
        std::cerr << "Enter the number of elements as argument" << std::endl;
        return -1;
    }
    int range = 0;
    
    try{
        range = std::stoi(argv[1]);
    }catch (const std::invalid_argument&){
        std::cerr << "Error: Cannot parse "" << argv[1] << "" ";
        return -1;
    }
    catch (const std::out_of_range&) {
        std::cerr << "Error: " << argv[1] << " is out of range";
        return -1;
    }
    if (range <= 0) {
        std::cerr << "Error: Zero or negative number provided: " << argv[1];
        return -1;
    }
    std::stringstream data;
    std::cout << Generator::generate(data, range).rdbuf();
}

Le travail proprement dit se fait dans le Générateur, qui est compilé et lié en tant que bibliothèque statique à notre Producer exécutable.

Générateur.cpp

std::stringstream &Generator::generate(std::stringstream &stream, const int range) {

    std::vector<int> data(range);

    std::iota(data.begin(), data.end(), 1);
    std::random_device rd;
    std::mt19937 g(rd());
    std::shuffle(data.begin(), data.end(), g);
    for (const auto n : data) {
        stream << std::to_string(n) << " ";
    }
    return stream;
}

La fonction generate fait référence à un std::stringstream et un entier comme argument. Basé sur la valeur m de l’entier range, un vecteur d’entiers compris entre 1 et m est fait et ensuite mélangé. Les valeurs du vecteur mélangé sont ensuite converties en une chaîne et poussées dans le stringstream. La fonction renvoie la même stringstream référence comme passé en argument.

CMakeLists.txt de niveau supérieur

Le haut niveau CMakeLists.txt est le point d’entrée de notre projet. Il peut y avoir plusieurs CMakeLists.txt fichiers dans des sous-répertoires (par exemple, des bibliothèques ou d’autres exécutables associés au projet). Nous commençons par passer pas à pas au plus haut niveau CMakeLists.txt.

Les premières lignes nous renseignent sur la version de CMake, qui est nécessaire pour traiter le fichier, le nom du projet et ses versions, ainsi que le standard C++ prévu.

cmake_minimum_required(VERSION 3.14)
project(CPP_Testing_Sample VERSION 1.0)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED True)

Nous disons à CMake de regarder dans le sous-répertoire Generator avec la ligne suivante. Ce sous-répertoire contient toutes les informations pour construire le Generator bibliothèque et contient un CMakeLists.txt pour le sien. Nous y viendrons sous peu.

add_subdirectory(Generator)

Venons-en maintenant à une particularité absolue : Modules CMake. Le chargement de modules peut étendre les fonctionnalités de CMake. Dans notre projet, nous chargeons le module Récupérer le contenu, ce qui nous permet de télécharger des ressources externes, dans notre cas GoogleTest lorsque CMake est exécuté.

include(FetchContent)
FetchContent_Declare(
  googletest
  URL https://github.com/google/googletest/archive/bb9216085fbbf193408653ced9e73c61e7766e80.zip
)
FetchContent_MakeAvailable(googletest)

Dans la partie suivante, nous faisons ce que nous ferions habituellement dans un Makefile ordinaire : spécifiez le binaire à construire, les fichiers source associés, les bibliothèques auxquelles il convient de lier et les répertoires dans lesquels le compilateur peut trouver les fichiers d’en-tête.

add_executable(Producer Producer.cpp)
target_link_libraries(Producer PUBLIC Generator)
target_include_directories(Producer PUBLIC "${PROJECT_BINARY_DIR}")

Avec l’instruction suivante, nous obtenons CMake pour créer un fichier dans le dossier de construction appelé compile_commands.json. Ce fichier expose les options de compilation pour chaque fichier du projet. Chargé dans VSCodium, ce fichier indique à la fonctionnalité IntelliSense où trouver les fichiers d’en-tête (voir Documentation).

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

La dernière partie définit les tests pour notre projet. Le projet utilise le framework GoogleTest précédemment chargé. L’ensemble du sujet des tests unitaires fera partie d’un article séparé.

enable_testing()
add_executable(unit_test unit_test.cpp)
target_link_libraries(unit_test gtest_main)
include(GoogleTest)
gtest_discover_tests(unit_test)

Niveau bibliothèque CMakeLists.txt

Maintenant, nous regardons le CMakeLists.txt fichier dans le sous-répertoire Generator contenant la bibliothèque éponyme. Cette CMakeLists.txt est beaucoup plus court et, outre les commandes liées aux tests unitaires, il ne contient que deux instructions.

add_library(Generator STATIC Generator.cpp Generator.h)
target_include_directories(Generator INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

Avec add_library(...) nous définissons une nouvelle cible de build : le static Generator bibliothèque. Avec la déclaration target_include_directories(...), nous ajoutons le sous-répertoire actuel au chemin de recherche des fichiers d’en-tête pour les autres cibles de construction. Nous spécifions également que la portée de cette propriété est de type INTERFACE: cela signifie que la propriété n’affectera que les cibles de construction liées à cette bibliothèque, pas la bibliothèque elle-même.

Démarrer avec VSCodium

Avec les informations disponibles dans le CMakeLists.txt, les IDE comme VSCodium peuvent configurer le système de build en conséquence. Si vous n’avez pas encore d’expérience avec VSCodium ou VS Code, cet exemple de projet est un bon point de départ. D’abord, allez à leur site Internet et téléchargez le dernier package d’installation pour votre système. Ouvrez VSCodium et accédez au Rallonges languette.

Pour générer, déboguer et tester correctement le projet, recherchez les extensions suivantes et installez-les.

Si ce n’est déjà fait, clonez le dépôt en cliquant sur Cloner le référentiel Git sur la page de démarrage.

Ou manuellement en tapant :

git clone https://github.com/hANSIc99/cpp_testing_sample.git

Ensuite, vérifiez l’étiquette devops_1 soit en tapant :

git checkout tags/devops_1

Ou en cliquant sur le principale bouton de branche (boîte rouge) et en sélectionnant la balise dans le menu déroulant (boîte jaune).

Une fois que vous avez ouvert le dossier racine du référentiel dans VSCodium, le CMake Tools les extensions détectent le CMakeLists.txt et analysez immédiatement votre système à la recherche de compilateurs appropriés. Vous pouvez maintenant cliquer sur le Construire en bas de l’écran (boîte rouge) pour démarrer le processus de construction. Vous pouvez également changer de compilateur en cliquant sur la zone en bas (case jaune), qui affiche le compilateur actuellement actif.

Pour commencer à déboguer le Producer exécutable, cliquez sur le symbole du débogueur (case jaune) et choisissez Producteur de débogage (case verte) dans le menu déroulant.

Comme mentionné précédemment, le Producer exécutable attend le nombre d’éléments comme argument de ligne de commande. L’argument de ligne de commande peut être spécifié dans le fichier .vscode/launch.json.

D’accord, vous êtes maintenant en mesure de générer et de déboguer le projet.

Conclusion

Grâce à CMake, les étapes ci-dessus devraient fonctionner quel que soit le système d’exploitation que vous utilisez. Surtout avec les extensions liées à CMake, VSCodium devient un IDE puissant. Je n’ai pas mentionné l’intégration Git de VSCodium car vous pouvez déjà trouver de nombreuses ressources sur le web. J’espère que vous voyez que fournir une configuration CMake appropriée permet aux autres de créer, d’utiliser et de contribuer beaucoup plus facilement à votre projet. Dans un prochain article, je me pencherai sur les tests unitaires et l’utilitaire de test de CMake ctest.