web-dev-qa-db-fra.com

Comment configurer le code Visual Studio pour compiler le code C ++?

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

Comment est-ce que je le configure pour faire ceci?

visual-studio-codevscode-tasks
180
user3703887

Les tâches de construction 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 construction 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 au menu Fichier → Préférences → Raccourcis clavier , et ajoutez la liaison de clé suivante pour la tâche de construction:

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

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

77
user3703887

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

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

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

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

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

Dans l'extrait ci-dessous, quelques commentaires, 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
                }
            }
        }
    ]
}
37
attdona

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

Assurez-vous de modifier les chemins appropriés vers l'emplacement d'installation de votre MinGW.

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 le code VS

  2. modèle c_cpp_properties.json

9
Li Kui

Frustré par le manque de documentation claire, j'ai créé un projet Mac sur github qui devrait fonctionner (création et débogage):

vscode-mac-c-example

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

Je prévois de faire de même pour Windows et Linux (à moins que Microsoft n’écrive d’abord une documentation digne de ce nom ...).

8
peegee123

Voici comment j'ai configuré mon VS pour C++ en utilisant le 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

5
Vlad Bezden

Si votre projet a une configuration CMake, il est assez simple de configurer VSCode, par exemple. setup tasks.json comme 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 y a aussi une extension d'intégration CMake qui ajoute une commande "CMake build" à VScode.

PS! La problemMatcher est configurée pour les constructions clang-. Pour utiliser GCC, je pense que vous devez changer fileLocation en relative, mais je n'ai pas testé cela.

5
larsmoa

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

  1. Frappé (Ctrl+P) et type:

    ext install cpptools

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

  3. Tapez votre code et cliquez sur Enregistrer.

  4. Frappé (Ctrl+Shift+P et tapez Configure task runner puis sélectionnez other en bas de la liste.

  5. Créez un fichier de commandes dans le même dossier portant 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. Editez le fichier task.json comme suit et sauvegardez-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. Frappé (Ctrl+Shift+B exécuter la tâche de construction. Cela créera les fichiers . Obj et . Exe pour le projet.

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

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

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

  10. Frappé F5.

4
Poornamith

Il existe maintenant une extension du langage C/C++ de Microsoft. Vous pouvez l'installer en allant dans le menu "quick open" (Ctrl+p) et en tapant:

ext install cpptools

Vous pouvez lire à ce sujet ici:

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

C'est très basique, à partir de mai 2016.

3
Eliot

Vous pouvez faire référence à ce dernier Gist ayant une tâche 2.0.0 pour le code Visual Studio, https://Gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454

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

2
Akansh Gulati

Le problème fondamental 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 plugins 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, ce que la plupart des gens s'attendent à gérer également, entre autres choses, comme la prise en charge de la construction. Laissez-moi vous faire gagner du temps: ce n'est pas le cas. Cependant, vous le voudrez probablement quand même.

  2. Construire, nettoyer et reconstruire des tâches. C'est là que votre choix de système de construction devient une affaire énorme. 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é gérer ces. Microsoft a totalement changé tout ce qui concerne ce fichier au cours des dernières versions, jusqu’à ce qu’il soit censé être appelé et aux endroits (oui, endroits) où il peut aller, sans parler du changement complet de format. Pire encore, ils ont SORT OF gardé la compatibilité ascendante, pour être sûr d'utiliser la clé "version" pour spécifier la variante souhaitée. 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 QUI COMMENCE AVEC UNE ÉTIQUETTE "VERSION" CI-DESSOUS 2.0.0 IS OBSOLETE.

Voici la chose la plus proche que j'ai pour le moment. Notez que j’adopte le plus gros du travail des scripts, cela ne me donne pas vraiment d’entrées de menu avec lesquelles je peux vivre, et il n’existe aucun moyen de choisir entre le débogage et la publication sans simplement entrer 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 qu'en théorie, ce fichier est censé fonctionner si vous le placez dans la racine de l'espace de travail, de sorte que vous ne colliez pas à la vérification des 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, le IDE va chier s'il n'y est pas. (Oui, pour le moment, cela signifie que j'ai été obligé de vérifier .vscode dans Subversion, ce qui ne me fait pas plaisir.) 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).

  1. Exécuter, déboguer, attacher, arrêter. Ce sont un autre ensemble de tâches, défini dans "launch.json". Ou du moins ils étaient. Microsoft a fait un tel hash de la documentation, je n'en suis même plus sûr.
2
breakpoint

Pour construire/exécuter des projets C++ en code VS, vous devez manuellement configurer le dossier tasks.json qui se trouve dans le dossier . Vscode dans dossier de l'espace de travail. Pour ouvrir tasks.json , appuyez sur ctrl + maj + P et tapez Configurer les tâches , et appuyez sur entrez , cela vous mènera à tasks.json

Ici, je fournis à mon tasks.json fichier avec des commentaires pour le rendre plus compréhensible. Il peut être utilisé comme référence pour configurer tasks.json , j'espère que cela vous 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 depuis le documentation des tâches du code VS

description de type propriété:

  • type: le type de la tâche. Pour une tâche personnalisée, cela peut être Shell ou 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é presentation dans tasks.json . Il offre les propriétés suivantes:

  • révéler: Contrôle si le panneau de terminal intégré est amené au premier plan. Les valeurs valides sont:

    • always - Le panneau est toujours présenté au premier plan. C'est la valeur par défaut
    • never - L'utilisateur doit explicitement placer le panneau de terminaux au premier plan à l'aide de la commande Affichage> Terminal (Ctrl + `).
    • silent - Le panneau de terminaux est mis au premier plan uniquement si la sortie n'est pas analysée à la recherche d'erreurs et d'avertissements.

  • focus: contrôle si le terminal effectue la mise au point ou non. La valeur par défaut est false.

  • echo: Contrôle si la commande exécutée est répercutée dans le terminal. Le défaut est vrai.
  • showReuseMessage: Contrôle si le message "Le terminal sera réutilisé par les tâches, appuyez sur n’importe quelle touche pour le fermer".
  • panel: 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 tâches exécutées 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.
    • new : 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 false.
2
joker007