Hoe stel ik Visual Studio Code in om C++-code te compileren?

Microsoft’s Visual Studio Code-editor is best aardig, maar heeft geen standaardondersteuning voor het bouwen van C++-projecten.

Hoe configureer ik het om dit te doen?

Antwoord 1, autoriteit 100%

Er is een veel eenvoudigere manier om C++-code te compileren en uit te voeren, geen configuratie nodig:

1. Installeer de Code Runner-extensie
2. Open uw C++-codebestand in Teksteditor, gebruik vervolgens de sneltoets Ctrl+Alt+N, of druk op F1en selecteer/typ vervolgens Run Code, of klik met de rechtermuisknop op de teksteditor en klik vervolgens op Run Codein het contextmenu, de code wordt gecompileerd en uitgevoerd, en de uitvoer wordt weergegeven in het uitvoervenster.

Bovendien zou je de configuratie in settings.json kunnen bijwerken met verschillende C++-compilers zoals je wilt, de standaardconfiguratie voor C++ is als volgt:

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

Antwoord 2, autoriteit 57%

De bouwtaken zijn projectspecifiek. Open een map in Visual Studio Code om een nieuw project te maken.

Volg de instructies hieren druk op Ctrl+ Shift+ P, typ Configure Tasks, selecteer het en druk op Enter.

Het bestand Tasks.json wordt geopend. Plak het volgende buildscript in het bestand en sla het op:

{
    "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
                }
            }
        }
    ]
}

Ga nu naar menu Bestand→ Voorkeuren→ Toetsenbordsnelkoppelingenen voeg de volgende toetsbinding toe voor de bouwtaak:

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

Als u nu op F8drukt, wordt de Makefile uitgevoerd en worden fouten onderstreept in de editor.

Antwoord 3, autoriteit 33%

Een voorbeeld van een makefile-taak voor de nieuwe versie 2.0.0 taken.json.

In het onderstaande fragment enkele opmerkingen waarvan ik hoop dat ze nuttig zullen zijn.

{
    "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
                }
            }
        }
    ]
}

Antwoord 4, autoriteit 10%

Hier is hoe ik mijn VS heb geconfigureerd voor C++

Zorg ervoor dat u de juiste paden wijzigt naar waar uw MinGW is geïnstalleerd

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
}

Referentie：

1. C/C++ voor VS-code

2. c_cpp_properties.json-sjabloon

Antwoord 5, autoriteit 8%

Om C++-projecten in VS-code te bouwen/uit te voeren, moet u handmatig het bestand tasks.jsonconfigureren dat zich in de map .vscodein de werkruimtemap bevindt.
Om tasks.jsonte openen, drukt u op ctrl + shift + Pen typt u Taken configurerenen drukt u op enter, je gaat naar tasks.json

Hier geef ik mijn tasks.json-bestand enkele opmerkingen om het bestand begrijpelijker te maken. Het kan worden gebruikt als referentie voor het configureren van tasks.json, i hoop dat het nuttig zal zijn

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"
        },
    ]
}

Nu, met vermelding van rechtstreeks van de vs code taken documentatie

Beschrijving van Type Object:

• Type : het type van het taak. Voor een aangepaste taak kan dit ofwel shell of proces zijn. Als de schaal is opgegeven, wordt de opdracht geïnterpreteerd
  Als een Shell-commando (bijvoorbeeld: bash, cmd of powerShell). Indien
  Proces is opgegeven, de opdracht wordt geïnterpreteerd als een proces om
  uitvoeren.

Het gedrag van de terminal kan worden gecontroleerd met behulp van de
Presentatie onroerend goed in Task.json . Het biedt de volgende eigenschappen:

• onthullen : bedient of het geïntegreerde terminalpaneel naar voren wordt gebracht. Geldige waarden zijn:
  – altijd – het paneel wordt altijd naar voren gebracht. Dit is de standaardinstelling
  – Nooit – De gebruiker moet het terminalpaneel expliciet naar voren brengen met behulp van de
  View & GT; Terminal Command (CTRL + `).
  – SILENT – Het terminalpaneel wordt alleen naar voren gebracht als de uitvoer niet is gescand op fouten en waarschuwingen.

• Focus : bedient of de terminal invoerfocus neemt of niet. Standaard is false.

• Echo : bedient of het geëxecuteerde opdracht in de terminal wordt gewijzigd. Standaard is waar.

• ShowReusemessage : Controleert of de “Terminal wordt hergebruikt door taken, druk op een willekeurige toets om het te sluiten” Bericht.

• -paneel : bedient of het aansluitinstantie wordt gedeeld tussen taakruns. Mogelijke waarden zijn:
  – Gedeeld : de terminal wordt gedeeld en de uitvoer van andere taakruns wordt toegevoegd aan dezelfde terminal.
  – Dedicated : de terminal is gewijd aan een specifieke taak. Als die taak opnieuw wordt uitgevoerd, wordt de terminal opnieuw gebruikt. echter, de
  De uitvoer van een andere taak wordt gepresenteerd in een andere terminal.
  – NIEUW : elke uitvoering van die taak gebruikt een nieuwe schone terminal.

• Wissen: Bediening of de terminal wordt gewist voordat deze taak wordt uitgevoerd. Standaard is false.

Antwoord 6, Autoriteit 6%

Uit frustratie bij het gebrek aan duidelijke documentatie,
Ik heb een Mac-project opgericht op Github die gewoon moet werken (zowel gebouw als debuggen):

vscode-mac-c-example

Houd er rekening mee dat het XCode en de VSCode Microsoft cpptools-extensie vereist.

Ik ben van plan hetzelfde te doen voor Windows en Linux (tenzij Microsoft eerst fatsoenlijke documentatie schrijft…).

Antwoord 7, autoriteit 6%

Allereerst, ga naar extensies (Ctrl + Shift + X) en installeer 2 extensies:

1. Code Runner
2. C/C++

Laad vervolgens de VS-code opnieuw en selecteer een afspeelknop in de rechterbovenhoek van uw programma in de uitvoerterminal. U kunt de uitvoer zien met Ctrl + Alt + N.
Ga naar de gebruikersinstelling om andere functies te wijzigen.

Antwoord 8, autoriteit 4%

Het basisprobleem hier is dat het bouwen en koppelen van een C++-programma sterk afhankelijk is van het bouwsysteem dat wordt gebruikt. U moet de volgende afzonderlijke taken ondersteunen, met behulp van een combinatie van plug-ins en aangepaste code:

1. Algemene C++-taalondersteuning voor de editor. Dit wordt meestal gedaan met behulp van ms-vscode.cpptools, waarvan de meeste mensen verwachten dat ze ook veel andere dingen aankunnen, zoals ondersteuning voor het bouwen. Laat me je wat tijd besparen: dat doet het niet. U zult het echter waarschijnlijk toch willen.

2. Build, Clean en Rebuild Taken. Dit is waar uw keuze van het build-systeem een ​​enorme deal wordt. Je zult plug-ins vinden voor dingen zoals Cmake en Autoconf (God help je), maar als je iets als Meson en Ninja gebruikt, moet je wat helper-scripts schrijven en een aangepast “Task.json” -bestand moeten maken. omgaan met deze. Microsoft heeft alles over dat bestand volledig gewijzigd in de laatste paar versies, tot aan de hoede om te worden genoemd en de plaatsen (ja, plaatsen) die het kan gaan, om niets van volledig te veranderen van het formaat. Erger nog, ze hebben een soort van achterwaartse compatibiliteit gehouden, om de “versie” -toets te gebruiken om op te geven welke variant u wilt. Zie hier details:

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

… maar noteer conflicten met:

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

WAARSCHUWING: In alle onderstaande antwoorden is alles wat begint met een “versie” -tag hieronder 2.0.0 verouderd.

Hier is het dichtstbijzijnde wat ik op dit moment heb. Merk op dat ik het grootste deel van het zware opheffing naar scripts schop, dit geeft me niet echt menu-vermeldingen waarmee ik kan leven, en er is geen goede manier om te selecteren tussen debug en vrijgave zonder alleen maar een andere expliciete vermeldingen te maken hier. Met alles wat zei, hier is wat ik kan verdragen als mijn .VSCODE / TAKS.JSON-bestand op dit 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
                }
            }
        }
    ]
}

Merk op dat dit bestand in theorie zou moeten werken als je het in de root van de werkruimte plaatst, zodat je niet vastzit aan het controleren van bestanden in verborgen mappen (.vscode) in je revisiebeheersysteem. Ik moet dat nog zien werken; test het, maar als het mislukt, zet het dan in .vscode. Hoe dan ook, de IDE zal zeuren als het er toch niet is. (Ja, op dit moment betekent dit dat ik gedwongen ben om .vscode in subversion te controleren, waar ik niet blij mee ben.) Merk op dat mijn buildscripts (niet getoond) eenvoudig een DEBUG-directory maken (of recreëren) met, in mijn geval, meson, en erin bouwen (met, in mijn geval, ninja).

3. Rennen, debuggen, hechten, stoppen. Dit is een andere reeks taken, gedefinieerd in “launch.json”. Of dat waren ze tenminste. Microsoft heeft zo’n hash van de documentatie gemaakt, ik weet het niet eens meer zeker.

Antwoord 9, autoriteit 3%

Als uw project een CMake-configuratie heeft, is het vrij eenvoudig om VSCode in te stellen, b.v. stel tasks.jsonin zoals hieronder:

{
    "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
                }
            }
        }
    ]
}

Hieronder gaat ervan uit dat er een map is buildin de root van de werkruimte met een CMAKE-configuratie.

Er is ook een cmake integratie extensie dat Voegt een opdracht “Cmake-build” toe aan VSCODE.

PS! De problemMatcheris ingesteld voor clang-builds. Om GCC te gebruiken, denk ik dat u fileLocationmoet wijzigen naar relative, maar ik heb dit niet getest.

Antwoord 10, Autoriteit 3%

Hier is hoe ik mijn VS voor C++ heb geconfigureerd met behulp van g ++ compiler en het werkt geweldig inclusief foutopsporingsopties:

TAKS.JSON-bestand

{
    "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"
}

Launch.json-bestand

{
    "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"
        }
    ]
}

Ik heb ook de extensie ‘C/C++ for Visual Studio Code’ geïnstalleerd in VS Code

Antwoord 11, autoriteit 3%

Met een bijgewerkte VS-code kunt u dit op de volgende manier doen:

1. Druk op (Ctrl+P) en typ:

ext install cpptools

2. Open een map (Ctrl+K& Ctrl+O) en maak een nieuw bestand in de map met de extensie .cpp(bijvoorbeeld: hello.cpp):

3. Typ je code in en druk op opslaan.

4. Druk op (Ctrl+Shift+Pen typ, Configure task runneren selecteer vervolgens otheronderaan de lijst.

5. Maak een batchbestand in dezelfde map met de naam build.baten voeg de volgende code toe aan de hoofdtekst van het bestand:

@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. Bewerk het bestand task.jsonals volgt en opslaan:

{
    // 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. Druk op (Ctrl+Shift+Bom de Build-taak uit te voeren. Hierdoor wordt de .objen .exebestanden voor het project.

8. Voor het opsporen van fouten in het project, druk op F5en selecteer C++(Windows).

9. Bewerk in het bestand launch.jsonde volgende regel en opslaanhet bestand:

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

10. Druk op F5.

Antwoord 12, autoriteit 2%

Kan extensie Code Runnergebruiken om code uit te voeren met het afspeelpictogram rechtsboven en met de sneltoets:Ctrl+Alt+Nen om Ctrl+Alt+Maf te breken. Maar standaard toont het alleen de uitvoer van het programma, maar voor het ontvangen van invoer moet u enkele stappen volgen:

Ctrl+,en vervolgens het instellingenmenu en Extensions>Codeconfiguratie uitvoerenscroll naar beneden en zoek Bewerken in settings.jsonklik erop en voeg de volgende code toe:

{
 "code-runner.runInTerminal": true
}

Antwoord 13

U kunt verwijzen naar deze nieuwste kern met een versie 2.0.0-taak voor Visual Studio Code, https://gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454

U kunt elk bestand eenvoudig compileren en uitvoeren zonder de taak bij te werken. Het is generiek en opent ook de terminal voor invoerinvoer.

Antwoord 14

Er is nu een C / C++ taalextensie van Microsoft. U kunt het installeren door naar het “Snel open” ding te gaan (CTRL + P ) en typen:

ext install cpptools

U kunt hierover lezen:

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

Het is erg eenvoudig, vanaf mei 2016.