Configurer un environnement de développement Conda/C++ sous Windows

, ,

Voici un aide-mémoire pour compiler le code C++ d’un projet sous Windows.

  • The Script Way (le plus simple)
  • The VS Code Way (<== recommandé)
  • The Visual Studio Way

Pré-requis

Installer Windows
Installer Visual Studio 2019 avec l’option "compilation C++ Desktop" (pas besoin d’autre chose)
Installer miniconda ou anaconda. Pour l’exemple on supposera qu’il est installé sous D:\miniconda3
Installer git
Cloner le projet depuis GitLab. Pour l’exemple, la suite du post supposera qu’il s’agit du projet sw2d.
Créer son environnement Conda depuis un prompt Anaconda.

Pour faire court : PENSEZ À ADAPTER TOUS LES PATHS EN D:\miniconda3\envs\sw2d POUR METTRE CELUI DE L’ENVIRONNEMENT CONDA DE VOTRE PROJET À LA PLACE.

The Script Way (le plus simple)

créer un script bld.bat (nommez-le comme vous voulez) dans le dossier du projet. Dedans, mettez :

@echo off

mkdir build
cd build

set BUILD_CONFIG=Debug
set CONDA_PREFIX=D:\miniconda3\envs\sw2d
set LIBRARY_LIB=%CONDA_PREFIX%\Library\lib
set LIBRARY_PREFIX=%CONDA_PREFIX%\Library

cmake .. -G "Visual Studio 16 2019" ^
-Wno-dev ^
-DCMAKE_INSTALL_PREFIX=%LIBRARY_PREFIX% ^
-DCMAKE_PREFIX_PATH=%LIBRARY_PREFIX% ^
-DCMAKE_INSTALL_RPATH:STRING=%LIBRARY_LIB% ^
-DCMAKE_INSTALL_NAME_DIR=%LIBRARY_LIB%

if errorlevel 1 echo "ERROR"

cmake --build . --config %BUILD_CONFIG% --target install

cd ..

if errorlevel 1 echo "ERROR 2"

Dans le menu Démarrer, ouvrir un Developer Command Prompt
Se rendre dans le dossier du projet et exécuter bld.bat
Votre build, une fois créée et installée, doit se trouver dans D:\miniconda3\envs\sw2d\Library\bin et les exécutables lancés ici doivent marcher.

Notes et particularités :

  • le générateur CMake doit être "Visual Studio 16 2019" dans ce cas, . Il devrait trouver tout seul qu’il s’agit d’une build en 64 bits.
  • le script compile la cible "install" car les exécutables créés sous Windows cherchent leurs dépendances en chemin relatif dans le dossier où elles sont, sans que le PATH n’y change quoi que ce soit. Il faut donc que votre exécutable soit bien installé dans votre environnement Conda avec la cible "install", et l’exécuter depuis cet endroit là.

The VS Code Way (IDE de moyenne taille)

Visual Studio Code "VS Code" a besoin de 2 extensions à installer, et pour chaque projet, il utilise 3 fichiers de configuration en JSON qui vont être créés dans .vscode\.
Les extensions s’installent depuis la barre à gauche:

  • Installer VS Code
  • installer les add-ons de VS Code: CMake Tools (Microsoft) (compiler les projets) , C/C++ (Microsoft) (Configure IntelliSense pour le code C/C++), CMake (twxs) (coloration syntaxique des CMakeLists)
  • Configurer IntelliSense: CTRL+SHIFT+P, taper "config", sélectionner "C/C++: Edit Configuration (JSON)", et modifier:
    [fichier .vscode\c_cpp_properties.json]

    "includePath": [
"${workspaceFolder}/**",
"D:/miniconda3/envs/sw2d/Library/include/**"
],

    Note: CMake et VS Code supportent mieux l’utilisation de / pour écrire les paths, au lieu de \\ (normalement \ mais échappé pour le JSON). Ici, les deux marchent, mais dans la route The Visual Studio Way, utiliser des \\ fait mystérieusement planter CMake.

  • Configurer CMake: CTRL+SHIFT+P, taper "Preferences", sélectionner "Preferences: Open Workspace Settings (JSON)" et entrer ceci :
    [fichier .vscode\settings.json]

    {
"cmake.configureArgs": [
    "-Wno-dev",
    "-DCMAKE_INSTALL_PREFIX=D:/miniconda3/envs/sw2d/Library/",
    "-DCMAKE_PREFIX_PATH=D:/miniconda3/envs/sw2d/Library/",
    "-DCMAKE_INSTALL_RPATH=D:/miniconda3/envs/sw2d/Library/lib",
    "-DCMAKE_INSTALL_NAME_DIR=D:/miniconda3/envs/sw2d/Library/lib"
],
"cmake.configureOnOpen": true
}
  • Configurer le debugger: CTRL+SHIFT+P, taper "launch", sélectionner "Debug: Open launch.json", et l’éditer:
    [fichier .vscode\launch.json]

    {
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
    {
        "name": "(Windows) Launch",
        "type": "cppvsdbg",
        "request": "launch",
        "program": "D:/miniconda3/envs/sw2d/Library/bin/sw2dModeler.exe",
        "args": [],
        "stopAtEntry": false,
        "cwd": "D:/miniconda3/envs/sw2d/Library/bin/",
        "environment": [],
        "externalConsole": false
    }
]
}

Voici la Toolbox de VS Code :

1 – Git Branch
2 – Build Type pour CMake
3 – Build Toolkit, doit comporter la mention "amd64" (un build toolkit sans support 64 bits ne fonctionnera pas, n’importe quel autre fonctionnera)
4 – Cible de CMake, doit être "install" (lire ci-dessus pourquoi)
5 – Bouton pour lancer la build
6 – Bouton pour lancer l’exécution / debugging de l’exécutable. Note : ce bouton peut ne pas apparaitre, mais il suffit de lancer depuis la barre de menu de VS Code "Run -> Start Debugging (F5)" pour démarrer le debugging. Ce bouton apparaitra alors pour les prochains debuggings.

Ciblez "install", buildez (icone roue dentée en (5) ), débugguez en lançant la configuration de Debug. (bouton 6, ou menu "Run -> Start Debugging (F5)", ou touche F5)

Notes et particularités :

  • le générateur CMake peut être sélectionné parmi une liste, mais il faut en prendre un avec support amd64.
  • le script compile la cible "install" car les exécutables créés sous Windows cherchent leurs dépendances en chemin relatif dans le dossier où elles sont, sans que le PATH n’y change quoi que ce soit. Il faut donc que votre exécutable soit bien installé dans votre environnement Conda avec la cible "install", et l’exécuter depuis cet endroit là. C’est pour cela qu’il faut créer un fichier launch.json spécifique, et ne pas simplement lancer le produit de la build avec les boutons à droite du bouton 4.

The Visual Studio Way (IDE complet)

Ouvrir Visual Studio, ouvrir votre projet avec "Ouvrir Dossier". Visual Studio va tenter de configurer le projet via CMake, et va planter (forcément, puisqu’il ne sait pas où chercher les dépendances).

Dans la barre de menus, Projet -> Paramétrer CMake

Vous pouvez utiliser l’interface graphique pour configurer CMake mais ça n’est pas très pratique. Cliquez plutôt sur le petit bouton "Modifier JSON" à droite.

Copier ce JSON et adaptez les paths pour votr environnement Conda:

{
    "configurations": [
        {
            "name": "x64-Release",
            "generator": "Visual Studio 16 2019 Win64",
            "configurationType": "Release",
            "buildRoot": "${projectDir}/out/build/${name}",
            "installRoot": "D:/miniconda3/envs/sw2d/Library/",
            "cmakeCommandArgs": "",
            "buildCommandArgs": "",
            "ctestCommandArgs": "",
            "inheritEnvironments": [
                "msvc_x64_x64"
            ],
            "intelliSenseMode": "windows-msvc-x64",
            "variables": [
                {
                    "name": "sw2d_CMAKE_INSTALL_DIR",
                    "value": "D:/miniconda3/envs/sw2d/Library/",
                    "type": "STRING"
                },
                {
                    "name": "CMAKE_PREFIX_PATH",
                    "value": "D:/miniconda3/envs/sw2d/Library/",
                    "type": "STRING"
                },
                {
                    "name": "CMAKE_INSTALL_RPATH",
                    "value": "D:/miniconda3/envs/sw2d/Library/lib/",
                    "type": "STRING"
                },
                {
                    "name": "CMAKE_INSTALL_NAME_DIR",
                    "value": "D:/miniconda3/envs/sw2d/Library/lib/",
                    "type": "STRING"
                }
            ]
        }
    ]
}

Une fois sauvegardé et fermé, regénérez le cache CMake en faisant Projet -> Générer le cache pour sw2d.

Dans le haut de la fenêtre, déroulez le menu des cibles de debugging et sélectionnez la cible que vous voulez exécuter. Sélectionnez celle avec (install), les autres ne fonctionneront pas (parce que Windows.).

En cliquant sur la cible choisie après l’avoir sélectionnée dans la barre Standard, la build doit commencer, et le debugging sera lancé immédiatement après.

Notes et particularités :

  • dans le CMakeSettings.json, le générateur CMake doit être "Visual Studio 16 2019 Win64". Ne pas mettre "Win64" lève une erreur.
  • dans les variables de CMakeSettings.json, la variable CMAKE_INSTALL_PREFIX ne doit pas être spécifiée (contrairement aux cas précédents), car elle est gérée par "installRoot", et la spécifier lève une erreur "variable spécifiée deux fois".
  • Attention : j’ai remarqué que le fichier CMakeSettings.json ne prend que des paths écrits façon Unix avec des barres /, et pas des \\. Quand bien même on est sous Windows, et que les paths s’écrivent avec des \\, CMakeSettings a des soucis quand les paths sont écrits avec \\.
  • Attention : j’ai remarqué que toute approximation ou erreur dans un fichier de configuration comme CMakeSettings.json peut empêcher Visual Studio d’ouvrir votre projet ! J’ai eu ce souci plusieurs fois, et je ne sais pas trop comment ou pourquoi. Dans ce cas de figure, le plus simple est de supprimer simplement le dossier .vs et le fichier CMakeSettings.json et de rouvrir le dossier, et de refaire la configuration du fichier CMakeSettings.json Je soupçonne que le support de CMake soit un peu approximatif.

[FIN]

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.