Comment configurer Visual Studio Code pour compiler du code C ++?

L' éditeur de code Visual Studio de Microsoft est assez agréable, mais il ne prend pas en charge par défaut la construction de projets C ++.

Comment le configurer pour ce faire?

Il existe un moyen beaucoup plus simple de compiler et d'exécuter du code C ++, aucune configuration n'est requise:

1. Installer l' extension Code Runner
2. Ouvrez votre fichier de code C ++ dans l'éditeur de texte, puis utilisez le raccourci Ctrl+Alt+N, ou appuyez sur F1puis sélectionnez / tapez Run Code, ou cliquez avec le bouton droit sur l'éditeur de texte, puis cliquez Run Codedans le menu contextuel, le code sera compilé et exécuté, et la sortie sera affichée dans le Fenêtre de sortie.

De plus, vous pouvez mettre à jour la configuration dans settings.json en utilisant différents compilateurs C ++ comme vous le souhaitez, la configuration par défaut pour C ++ est la suivante:

"code-runner.executorMap": {
    "cpp": "g++ $fullFileName && ./a.out"
}

Les tâches de génération sont spécifiques au projet. Pour créer un nouveau projet, ouvrez un répertoire dans Visual Studio Code.

En suivant les instructions ici , appuyez sur Ctrl+ Shift+ P, tapez Configure Tasks, sélectionnez-le et appuyez sur Enter.

Le fichier tasks.json sera ouvert. Collez le script de génération suivant dans le fichier et enregistrez-le:

{
    "version": "0.1.0",
    "command": "make",
    "isShellCommand": true,
    "tasks": [
        {
            "taskName": "Makefile",

            // Make this the default build command.
            "isBuildCommand": true,

            // Show the output window only if unrecognized errors occur.
            "showOutput": "always",

            // Pass 'all' as the build target
            "args": ["all"],

            // Use the standard less compilation problem matcher.
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": ["relative", "${workspaceRoot}"],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Maintenant, allez dans le menu Fichier → Préférences → Raccourcis clavier et ajoutez la liaison de touches suivante pour la tâche de génération:

// Place your key bindings in this file to overwrite the defaults
[
    { "key": "f8",          "command": "workbench.action.tasks.build" }
]

Maintenant, lorsque vous appuyez sur F8le Makefile sera exécuté et les erreurs seront soulignées dans l'éditeur.

Un exemple de tâche makefile pour la nouvelle version 2.0.0 tasks.json.

Dans l'extrait ci-dessous, j'espère qu'ils vous seront utiles.

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "<TASK_NAME>",
            "type": "shell",
            "command": "make",
            // use options.cwd property if the Makefile is not in the project root ${workspaceRoot} dir
            "options": {
                "cwd": "${workspaceRoot}/<DIR_WITH_MAKEFILE>"
            },
            // start the build without prompting for task selection, use "group": "build" otherwise
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": false,
                "panel": "shared"
            },
            // arg passing example: in this case is executed make QUIET=0
            "args": ["QUIET=0"],
            // Use the standard less compilation problem matcher.
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": ["absolute"],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Voici comment j'ai configuré mon VS pour C ++

Assurez-vous de changer les chemins d'accès appropriés à l'endroit où votre MinGW est installé

launch.json

{
   "version": "0.2.0",
   "configurations": [
       {
           "name": "C++ Launch (GDB)",                
           "type": "cppdbg",                         
           "request": "launch",                        
           "targetArchitecture": "x86",                
           "program": "${workspaceRoot}\\${fileBasename}.exe",                 
           "miDebuggerPath":"C:\\mingw-w64\\bin\\gdb.exe", 
           "args": [],     
           "stopAtEntry": false,                  
           "cwd": "${workspaceRoot}",                  
           "externalConsole": true,                  
           "preLaunchTask": "g++"　　                  
           }
   ]
}

tasks.json

{
    "version": "0.1.0",
    "command": "g++",
    "args": ["-g","-std=c++11","${file}","-o","${workspaceRoot}\\${fileBasename}.exe"],
    "problemMatcher": {
        "owner": "cpp",
        "fileLocation": ["relative", "${workspaceRoot}"],
        "pattern": {
            "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
            "file": 1,
            "line": 2,
            "column": 3,
            "severity": 4,
            "message": 5
        }
    }
}

c_cpp_properties.json

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceRoot}",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/x86_64-w64-mingw32",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/backward",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/tr1",
                "C:/mingw-w64/x86_64-w64-mingw32/include"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "__GNUC__=6",
                "__cdecl=__attribute__((__cdecl__))"
            ],
            "intelliSenseMode": "msvc-x64",
            "browse": {
                "path": [
                    "${workspaceRoot}",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/x86_64-w64-mingw32",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/backward",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/tr1",
                    "C:/mingw-w64/x86_64-w64-mingw32/include"
                ]
            },
            "limitSymbolsToIncludedHeaders": true,
            "databaseFilename": ""
        }
    ],
    "version": 3
}

Référence:

1. C / C ++ pour VS Code

2. modèle c_cpp_properties.json

Pour créer / exécuter des projets C ++ en code VS, vous devez manuellement configurer le fichier tasks.json qui se trouve dans le dossier .vscode du dossier de l'espace de travail. Pour ouvrir tasks.json , appuyez sur ctrl + Maj + P , et tapez Configurer les tâches , puis appuyez sur Entrée , cela vous amènera à tasks.json

Ici, je fournis mon fichier tasks.json avec quelques commentaires pour le rendre plus compréhensible, il peut être utilisé comme référence pour la configuration de tasks.json , j'espère qu'il sera utile

tasks.json

{
    "version": "2.0.0",

    "tasks": [

        {
            "label": "build & run",     //It's name of the task , you can have several tasks 
            "type": "shell",    //type can be either 'shell' or 'process' , more details will be given below
            "command": "g++",   
            "args": [
                "-g",   //gnu debugging flag , only necessary if you want to perform debugging on file  
                "${file}",  //${file} gives full path of the file
                "-o",   
                "${workspaceFolder}\\build\\${fileBasenameNoExtension}",    //output file name
                "&&",   //to join building and running of the file
                "${workspaceFolder}\\build\\${fileBasenameNoExtension}"
            ],
            "group": {
                "kind": "build",    //defines to which group the task belongs
                "isDefault": true
            },
            "presentation": {   //Explained in detail below
                "echo": false,
                "reveal": "always",
                "focus": true,
                "panel": "shared",
                "clear": false,
                "showReuseMessage": false
            },
            "problemMatcher": "$gcc"
        },

    ]
}

Maintenant, indiquant directement à partir de la documentation des tâches de code VS

description de la propriété type :

• type : type de la tâche. Pour une tâche personnalisée, il peut s'agir d'un shell ou d'un processus. Si shell est spécifié, la commande est interprétée comme une commande shell (par exemple: bash, cmd ou PowerShell). Si process est spécifié, la commande est interprétée comme un processus à exécuter.

Le comportement du terminal peut être contrôlé à l'aide de la propriété de présentation dans tasks.json . Il offre les propriétés suivantes:

• Révéler : contrôle si le panneau Terminal intégré est mis en avant. Les valeurs valides sont:

  • toujours - Le panneau est toujours mis en avant. C'est la valeur par défaut
  • jamais - L'utilisateur doit explicitement mettre le panneau de terminaux en avant à l'aide de la commande Affichage> Terminal (Ctrl + `).
  • Silencieux - Le panneau de connexion n'est amené à l'avant que si la sortie n'est pas analysée pour détecter les erreurs et les avertissements.

• focus : contrôle si le terminal prend ou non le focus d'entrée. La valeur par défaut est fausse.

• echo : contrôle si la commande exécutée est répercutée dans le terminal. La valeur par défaut est vraie.
• showReuseMessage : contrôle s'il faut afficher le message "Le terminal sera réutilisé par les tâches, appuyez sur n'importe quelle touche pour le fermer".
• panneau : contrôle si l'instance de terminal est partagée entre les exécutions de tâches. Les valeurs possibles sont:
  • shared : le terminal est partagé et la sortie des autres exécutions de tâche est ajoutée au même terminal.
  • dédié : le terminal est dédié à une tâche spécifique. Si cette tâche est exécutée à nouveau, le terminal est réutilisé. Cependant, la sortie d'une tâche différente est présentée dans un terminal différent.
  • nouveau : chaque exécution de cette tâche utilise un nouveau terminal propre.
• clear: contrôle si le terminal est effacé avant l'exécution de cette tâche. La valeur par défaut est fausse.

Par frustration face au manque de documentation claire, j'ai créé un projet Mac sur github qui devrait fonctionner (à la fois pour la construction et le débogage):

exemple de vscode-mac-c

Notez qu'il nécessite XCode et l'extension VSCode Microsoft cpptools.

J'ai l'intention de faire de même pour Windows et Linux (sauf si Microsoft écrit d'abord une documentation décente ...).

Tout d'abord, allez sur les extensions (Ctrl + Shift + X) et installez 2 extensions:

1. Code Runner
2. C / C ++

Ensuite, rechargez le code VS et sélectionnez un bouton de lecture en haut à droite de votre programme dans le terminal de sortie. Vous pouvez voir la sortie par Ctrl + Alt + N. Pour modifier d'autres fonctionnalités, passez aux paramètres utilisateur.

Si votre projet a une configuration CMake, il est assez simple de configurer VSCode, par exemple, tasks.jsoncomme ci-dessous:

{
    "version": "0.1.0",
    "command": "sh",
    "isShellCommand": true,
    "args": ["-c"],
    "showOutput": "always",
    "suppressTaskName": true,
    "options": {
        "cwd": "${workspaceRoot}/build"
    },
    "tasks": [
        {
            "taskName": "cmake",
            "args": ["cmake ."]
        },
        {
            "taskName": "make",
            "args" : ["make"],
            "isBuildCommand": true,
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": "absolute",
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Cela suppose qu'il existe un dossier buildà la racine de l'espace de travail avec une configuration CMake.

Il existe également une extension d'intégration CMake qui ajoute une commande "CMake build" à VScode.

PS! Le problemMatcherest configuré pour clang-builds. Pour utiliser GCC, je pense que vous devez passer fileLocationà relative, mais je n'ai pas testé cela.

Voici comment j'ai configuré mon VS pour C ++ à l'aide du compilateur g ++ et cela fonctionne très bien, y compris les options de débogage:

fichier tasks.json

{
    "version": "0.1.0",
    "command": "g++",
    "isShellCommand": true,
    // compiles and links with debugger information
    "args": ["-g", "-o", "hello.exe", "hello.cpp"],
    // without debugger information
    // "args": ["-o", "hello.exe", "hello.cpp"],
    "showOutput": "always"
}

fichier launch.json

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "C++ Launch (Windows)",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceRoot}/hello.exe",
            "MIMode": "gdb",
            "miDebuggerPath": "C:\\MinGw\\bin\\gdb.exe",
            "stopAtEntry": false,
            "cwd": "${workspaceRoot}",
            "externalConsole": false,
            "visualizerFile": "${workspaceRoot}/my.natvis"
        }
    ]
}

J'ai également l'extension 'C / C ++ pour Visual Studio Code' installée dans VS Code

Le problème de base ici est que la construction et la liaison d'un programme C ++ dépendent fortement du système de construction utilisé. Vous devrez prendre en charge les tâches distinctes suivantes, en utilisant une combinaison de plug-ins et de code personnalisé:

1. Prise en charge générale du langage C ++ pour l'éditeur. Cela se fait généralement à l'aide de ms-vscode.cpptools, que la plupart des gens s'attendent à gérer également beaucoup d'autres choses, comme le support de build. Permettez-moi de vous faire gagner du temps: ce n'est pas le cas. Cependant, vous le voudrez probablement de toute façon.

2. Générez, nettoyez et reconstruisez des tâches. C'est là que votre choix de système de construction devient une énorme affaire. Vous trouverez des plugins pour des choses comme CMake et Autoconf (Dieu vous aide), mais si vous utilisez quelque chose comme Meson et Ninja, vous devrez écrire des scripts d'aide et configurer un fichier "tasks.json" personnalisé pour gérer ces. Microsoft a totalement changé tout ce qui concerne ce fichier au cours des dernières versions, jusqu'à ce qu'il est censé être appelé et les endroits (oui, placeS) où il peut aller, sans parler de changer complètement le format. Pire, ils ont SORT OF gardé la compatibilité descendante, pour être sûr d'utiliser la clé "version" pour spécifier la variante que vous voulez. Voir les détails ici:

https://code.visualstudio.com/docs/editor/tasks

... mais notez les conflits avec:

https://code.visualstudio.com/docs/languages/cpp

AVERTISSEMENT: DANS TOUTES LES RÉPONSES CI-DESSOUS, TOUT CE QUI COMMENCE AVEC UN ÉTIQUETTE DE "VERSION" CI-DESSOUS 2.0.0 EST OBSOLÈTE.

Voici la chose la plus proche que j'ai en ce moment. Notez que je lance la plupart des tâches lourdes vers les scripts, cela ne me donne pas vraiment d'entrées de menu avec lesquelles je peux vivre, et il n'y a pas de bon moyen de choisir entre le débogage et la publication sans simplement faire trois autres entrées explicites dans ici. Cela dit, voici ce que je peux tolérer en tant que fichier .vscode / tasks.json pour le moment:

{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
    {
        "label": "build project",
        "type": "shell",
        "command": "buildscripts/build-debug.sh",
        "args": [],

        "group": {
            "kind": "build",
            "isDefault": true
        },
        "presentation": {
            // Reveal the output only if unrecognized errors occur.
            "echo": true,
            "focus": false,
            "reveal": "always",
            "panel": "shared"
        },

        // Use the standard MS compiler pattern to detect errors, warnings and infos
        "options": {
            "cwd": "${workspaceRoot}"
        },
        "problemMatcher": {
            "owner": "cpp",
            "fileLocation": ["relative", "${workspaceRoot}/DEBUG"],
            "pattern": {
                "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                "file": 1,
                "line": 2,
                "column": 3,
                "severity": 4,
                "message": 5
            }
        }
    },
    {
        "label": "rebuild project",
        "type": "shell",
        "command": "buildscripts/rebuild-debug.sh",
        "args": [],
        "group": {
            "kind": "build",
            "isDefault": true
        },
        "presentation": {
            // Reveal the output only if unrecognized errors occur.
            "echo": true,
            "focus": false,
            "reveal": "always",
            "panel": "shared"
        },

        // Use the standard MS compiler pattern to detect errors, warnings and infos
        "options": {
            "cwd": "${workspaceRoot}"
        },
        "problemMatcher": {
            "owner": "cpp",
            "fileLocation": ["relative", "${workspaceRoot}/DEBUG"],
            "pattern": {
                "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                "file": 1,
                "line": 2,
                "column": 3,
                "severity": 4,
                "message": 5
            }
        }
    },
    {
        "label": "clean project",
        "type": "shell",
        "command": "buildscripts/clean-debug.sh",
        "args": [],

        "group": {
            "kind": "build",
            "isDefault": true
        },
        "presentation": {
            // Reveal the output only if unrecognized errors occur.
            "echo": true,
            "focus": false,
            "reveal": "always",
            "panel": "shared"
        },

        // Use the standard MS compiler pattern to detect errors, warnings and infos
        "options": {
            "cwd": "${workspaceRoot}"
        },
        "problemMatcher": {
            "owner": "cpp",
            "fileLocation": ["relative", "${workspaceRoot}/DEBUG"],
            "pattern": {
                "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                "file": 1,
                "line": 2,
                "column": 3,
                "severity": 4,
                "message": 5
            }
        }
    }
]

}

Notez que, en théorie, ce fichier est censé fonctionner si vous le placez à la racine de l'espace de travail, de sorte que vous n'êtes pas bloqué en vérifiant les fichiers dans des répertoires cachés (.vscode) dans votre système de contrôle de révision. Je n'ai pas encore vu que cela fonctionne réellement; testez-le, mais s'il échoue, mettez-le en .vscode. Quoi qu'il en soit, l'IDE chienne s'il n'est pas là de toute façon. (Oui, pour le moment, cela signifie que j'ai été obligé de vérifier .vscode en subversion, ce dont je ne suis pas content.) Notez que mes scripts de construction (non affichés) créent simplement (ou recréent) un répertoire DEBUG en utilisant, dans mon cas, meson, et construire à l'intérieur (en utilisant, dans mon cas, ninja).

3. Exécutez, déboguez, attachez, arrêtez. Il s'agit d'un autre ensemble de tâches, défini dans "launch.json". Ou du moins ils l'étaient. Microsoft a fait un tel hachage de la documentation, je n'en suis même plus sûr.

Avec un code VS mis à jour, vous pouvez le faire de la manière suivante:

1. Appuyez sur ( Ctrl+ P) et tapez:

   ext install cpptools
   

2. Ouvrez un dossier ( Ctrl+ K& Ctrl+ O) et créez un nouveau fichier dans le dossier avec l'extension .cpp (ex: hello.cpp ):

3. Tapez votre code et appuyez sur Enregistrer.

4. Appuyez sur ( Ctrl+ Shift+ Pet tapez, Configure task runnerpuis sélectionnez otheren bas de la liste.

5. Créez un fichier de commandes dans le même dossier avec le nom build.bat et incluez le code suivant dans le corps du fichier:

   @echo off
   call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x64     
   set compilerflags=/Od /Zi /EHsc
   set linkerflags=/OUT:hello.exe
   cl.exe %compilerflags% hello.cpp /link %linkerflags%
   

6. Modifiez le fichier task.json comme suit et enregistrez-le :

   {
   // See https://go.microsoft.com/fwlink/?LinkId=733558
   // for the documentation about the tasks.json format
   "version": "0.1.0",
   "command": "build.bat",
   "isShellCommand": true,
   //"args": ["Hello World"],
   "showOutput": "always"
   }
   

7. Appuyez sur ( Ctrl+ Shift+ Bpour exécuter la tâche de génération . Cela créera les fichiers .obj et .exe pour le projet.

8. Pour déboguer le projet, F5appuyez sur et sélectionnez C ++ (Windows) .

9. Dans le fichier launch.json , modifiez la ligne suivante et enregistrez le fichier:

   "program": "${workspaceRoot}/hello.exe",
   

10. Frappez F5.

Vous pouvez faire référence à ce dernier élément essentiel ayant une 2.0.0tâche de version pour Visual Studio Code, https://gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454

Vous pouvez facilement compiler et exécuter chaque fichier sans mettre à jour la tâche. Il est générique et ouvre également le terminal pour les entrées d'entrée.

Peut utiliser Extension Code Runner pour exécuter du code avec l'icône de lecture en haut à droite et par la touche de raccourci: Ctrl+Alt+Net pour abandonner Ctrl+Alt+M. Mais par défaut, il affiche uniquement la sortie du programme, mais pour recevoir des entrées, vous devez suivre certaines étapes:

Ctrl +, puis le menu des paramètres s'ouvre et Extensions> Exécuter la configuration du code faites défiler ses attributs et recherchez Modifier dans settings.json, cliquez dessus et ajoutez le code suivant:

{ "code-runner.runInTerminal": true }

Il y a maintenant une extension de langage C / C ++ de Microsoft. Vous pouvez l'installer en allant dans la case "ouverture rapide" ( Ctrl+ p) et en tapant:

ext install cpptools

Vous pouvez lire à ce sujet ici:

https://blogs.msdn.microsoft.com/vcblog/2016/03/31/cc-extension-for-visual-studio-code/

C'est très basique, depuis mai 2016.