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

Il existe un moyen beaucoup plus facile de compiler et d'exécuter du code c++, aucune configuration nécessaire:

1. installez l'Extension Code Runner
2. Ouvrez votre code C++ fichier dans l'Éditeur de Texte, puis utilisez le raccourci Ctrl+Alt+N, ou appuyez sur la touche F1, puis sélectionner/type Run Code, ou cliquez-droit sur l'Éditeur de Texte, puis cliquez sur Run Code dans le menu contextuel, le code sera compilé et exécuté, et le résultat sera affiché dans la Fenêtre de Sortie.

De plus, vous pouvez mettre à jour la configuration dans les paramètres.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"
}

Un exemple de tâche makefile pour les nouvelles tâches 2.0.0.version json.

Dans l'extrait ci-dessous quelques commentaires, j'espère qu'ils 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
                }
            }
        }
    ]
}

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 y a un dossier build à la racine de l'espace de travail avec une configuration CMake.

Il y a aussi une extension d'intégration CMake {[13] } qui ajoute une commande" cmake build " à VScode.

PS! Le {[3] } est configuré pour clang - builds. Pour utiliser GCC, je crois que vous devez changer fileLocation en relative, mais je n'ai pas testé cela.

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:

Tâches.fichier 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"
}

Lancement.fichier 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 aussi l'extension' C/C++ for Visual Studio Code ' installée dans VS Code

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

Vscode-mac-c-exemple

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

Je prévois de faire la même chose pour Windows et linux (sauf si Microsoft écrit d'abord une documentation décente...).

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

1. Hit (Ctrl+P) et le type:

   ext install cpptools
   

2. Ouvrir un dossier (Ctrl+K & Ctrl+O) et créer un nouveau fichier dans le dossier avec l'extension .rpc (ex: bonjour.rpc):

3. Tapez votre code et appuyez sur Enregistrer.

4. Hit (Ctrl+Maj+P et le type, Configure task runner puis sélectionnez other, au bas de la liste.

5. Créer un fichier de commandes dans le même dossier avec le nom construire.chauve-souris et inclure 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 la tâche .json fichier comme suit et enregistrer:

   {
   // 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. Hit (Ctrl+Maj+B pour exécuter en tâche de génération. Cela va créer le .obj et .exe fichiers pour le projet.

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

9. Dans lancement.json fichier, modifiez la ligne suivante et enregistrer le fichier:

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

10. Appuyez Sur F5 .

Il y a maintenant une extension de langage C/C++ de Microsoft. Vous pouvez l'installer grâce à l'option "ouvrez rapide" chose (Ctrl+p) et taper:

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, à partir de mai 2016.

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

de lancement.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++"　　                  
           }
   ]
}

les tâches.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. C_cpp_properties.modèle json

Vous pouvez faire référence à ce dernier élément ayant une tâche de version 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. Il est générique et ouvre également le terminal pour les entrées d'entrée.