Wie richte ich Visual Studio Code zum Kompilieren von C ++ - Code ein?

Der Visual Studio Code- Editor von Microsoft ist recht nett, unterstützt jedoch standardmäßig keine C ++ - Projekte.

Wie konfiguriere ich es dafür?

Es gibt eine viel einfachere Möglichkeit, C ++ - Code zu kompilieren und auszuführen, ohne dass eine Konfiguration erforderlich ist:

1. Installieren Sie die Code Runner-Erweiterung
2. Öffnen Sie Ihre C ++ - Codedatei im Texteditor, verwenden Sie die Verknüpfung Ctrl+Alt+Noder drücken Sie F1und wählen / tippen Sie Run Codeoder klicken Sie mit der rechten Maustaste auf den Texteditor und klicken Sie dann Run Codein das Kontextmenü. Der Code wird kompiliert und ausgeführt, und die Ausgabe wird im angezeigt Ausgabefenster.

Darüber hinaus können Sie die Konfiguration in settings.json mit verschiedenen C ++ - Compilern aktualisieren. Die Standardkonfiguration für C ++ lautet wie folgt:

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

Die Build-Aufgaben sind projektspezifisch. Öffnen Sie zum Erstellen eines neuen Projekts ein Verzeichnis in Visual Studio Code.

Folgen Sie den Anweisungen hier , drücken Sie Ctrl+ Shift+ P, geben Sie ein Configure Tasks, wählen Sie es aus und drücken Sie Enter.

Die Datei task.json wird geöffnet. Fügen Sie das folgende Build-Skript in die Datei ein und speichern Sie es:

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

Gehen Sie nun zum Menü Datei → Einstellungen → Tastaturkürzel und fügen Sie die folgende Tastenkombination für die Erstellungsaufgabe hinzu:

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

Wenn Sie jetzt drücken, wird F8das Makefile ausgeführt und Fehler werden im Editor unterstrichen.

Ein Beispiel für eine Makefile-Aufgabe für die neue Version 2.0.0 task.json.

Im Snippet unten einige Kommentare hoffe ich, dass sie nützlich sein werden.

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

So habe ich meinen VS für C ++ konfiguriert

Stellen Sie sicher, dass Sie die entsprechenden Pfade dahin ändern, wo Ihr MinGW installiert ist

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

task.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
}

Referenz:

1. C / C ++ für VS-Code

2. Vorlage c_cpp_properties.json

Um C ++ - Projekte in VS-Code zu erstellen / auszuführen, müssen Sie die Datei task.json manuell konfigurieren , die sich im Ordner .vscode im Arbeitsbereich befindet. Um offene tasks.json , drücken Sie Strg + Shift + P , und geben Sie konfigurieren Aufgaben und drücken Sie eingeben , wird es Sie nehmen tasks.json

Hier versorge ich meine Datei functions.json mit einigen Kommentaren, um die Datei verständlicher zu machen. Sie kann als Referenz für die Konfiguration von task.json verwendet werden. Ich hoffe, sie wird nützlich sein

task.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"
        },

    ]
}

Jetzt direkt aus der Dokumentation der VS-Code-Aufgaben

Beschreibung der Art Eigenschaft:

• Typ : Der Typ der Aufgabe. Bei einer benutzerdefinierten Aufgabe kann dies entweder eine Shell oder ein Prozess sein. Wenn eine Shell angegeben ist, wird der Befehl als Shell-Befehl interpretiert (z. B. bash, cmd oder PowerShell). Wenn ein Prozess angegeben ist, wird der Befehl als auszuführender Prozess interpretiert.

Das Verhalten des Terminals kann mithilfe der Präsentationseigenschaft in task.json gesteuert werden . Es bietet die folgenden Eigenschaften:

• enthüllen : Steuert, ob das integrierte Terminalfeld nach vorne gebracht wird. Gültige Werte sind:

  • immer - Das Panel wird immer nach vorne gebracht. Dies ist die Standardeinstellung
  • Nie - Der Benutzer muss das Terminalfeld mit dem Befehl Ansicht> Terminal (Strg + `) explizit nach vorne bringen.
  • geräuschlos - Das Terminalpanel wird nur dann nach vorne gebracht, wenn der Ausgang nicht auf Fehler und Warnungen überprüft wird.

• Fokus : Steuert, ob das Terminal den Eingabefokus übernimmt oder nicht. Standard ist falsch.

• echo : Steuert, ob der ausgeführte Befehl im Terminal wiedergegeben wird. Standard ist wahr.
• showReuseMessage : Steuert, ob die Meldung "Terminal wird von Aufgaben wiederverwendet, drücken Sie eine beliebige Taste, um es zu schließen" angezeigt wird.
• panel : Steuert, ob die Terminalinstanz von Taskläufen gemeinsam genutzt wird. Mögliche Werte sind:
  • freigegeben : Das Terminal wird freigegeben und die Ausgabe anderer Taskläufe wird demselben Terminal hinzugefügt.
  • dediziert : Das Terminal ist einer bestimmten Aufgabe gewidmet. Wenn diese Aufgabe erneut ausgeführt wird, wird das Terminal wiederverwendet. Die Ausgabe einer anderen Aufgabe wird jedoch in einem anderen Terminal dargestellt.
  • neu : Bei jeder Ausführung dieser Aufgabe wird ein neues sauberes Terminal verwendet.
• clear: Steuert, ob das Terminal gelöscht wird, bevor diese Task ausgeführt wird. Standard ist falsch.

Aus Frustration über den Mangel an klarer Dokumentation habe ich ein Mac-Projekt auf Github erstellt, das einfach funktionieren sollte (sowohl beim Erstellen als auch beim Debuggen):

vscode-mac-c-Beispiel

Beachten Sie, dass XCode und die VSCode Microsoft cpptools-Erweiterung erforderlich sind.

Ich habe vor, dasselbe für Windows und Linux zu tun (es sei denn, Microsoft schreibt zuerst eine anständige Dokumentation ...).

Gehen Sie zunächst zu den Erweiterungen (Strg + Umschalt + X) und installieren Sie 2 Erweiterungen:

1. Code Runner
2. C / C ++

Laden Sie dann den VS-Code neu und wählen Sie eine Wiedergabetaste oben in der rechten Ecke, die Ihr Programm im Ausgangsanschluss ausführt. Sie können die Ausgabe mit Strg + Alt + N sehen. Um andere Funktionen zu ändern, gehen Sie zur Benutzereinstellung.

Wenn Ihr Projekt eine CMake-Konfiguration hat, ist es ziemlich einfach, VSCode einzurichten, z. B. tasks.jsonwie folgt einzurichten :

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

Dies setzt voraus, dass sich buildim Stammverzeichnis des Arbeitsbereichs ein Ordner mit einer CMake-Konfiguration befindet.

Es gibt auch eine CMake-Integrationserweiterung , die VScode den Befehl "CMake build" hinzufügt.

PS! Das problemMatcherist für clang-builds eingerichtet. So verwenden GCC Ich glaube , Sie ändern müssen fileLocationzu relative, aber ich habe nicht getestet.

So habe ich mein VS für C ++ mit dem g ++ - Compiler konfiguriert und es funktioniert hervorragend, einschließlich Debugging-Optionen:

task.json-Datei

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

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

Ich habe auch die Erweiterung 'C / C ++ für Visual Studio Code' in VS Code installiert

Das Grundproblem hierbei ist, dass das Erstellen und Verknüpfen eines C ++ - Programms stark vom verwendeten Buildsystem abhängt. Sie müssen die folgenden unterschiedlichen Aufgaben mit einer Kombination aus Plugins und benutzerdefiniertem Code unterstützen:

1. Allgemeine C ++ - Sprachunterstützung für den Editor. Dies geschieht normalerweise mit ms-vscode.cpptools, von denen die meisten Leute erwarten, dass sie auch viele andere Dinge wie die Build-Unterstützung erledigen. Lass mich dir etwas Zeit sparen: das tut es nicht. Sie werden es jedoch wahrscheinlich trotzdem wollen.

2. Erstellen, bereinigen und neu erstellen von Aufgaben. Hier wird Ihre Wahl des Build-Systems zu einer großen Sache. Sie werden Plugins für Dinge wie CMake und Autoconf finden (Gott helfe Ihnen), aber wenn Sie etwas wie Meson und Ninja verwenden, müssen Sie einige Hilfsskripte schreiben und eine benutzerdefinierte "task.json" -Datei konfigurieren handhaben diese. Microsoft hat in den letzten Versionen alles an dieser Datei komplett geändert, bis hin zu dem, was sie heißen soll und den Orten (ja, Orten), an denen sie sich befinden kann, ganz zu schweigen von einer vollständigen Änderung des Formats. Schlimmer noch, sie haben SORT OF die Abwärtskompatibilität beibehalten, um sicherzugehen, dass Sie mit dem Schlüssel "version" angeben, welche Variante Sie möchten. Details finden Sie hier:

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

... aber beachten Sie Konflikte mit:

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

WARNUNG: IN ALLEN ANTWORTEN UNTEN IST ALLES, WAS MIT EINEM "VERSION" -TAG UNTER 2.0.0 BEGINNT, OBSOLET.

Hier ist das Nächste, was ich im Moment habe. Beachten Sie, dass ich die meisten Probleme mit Skripten habe. Dadurch bekomme ich keine Menüeinträge, mit denen ich leben kann, und es gibt keine gute Möglichkeit, zwischen Debug und Release zu wählen, ohne nur drei weitere explizite Einträge vorzunehmen Hier. Nach alledem kann ich Folgendes als meine .vscode / task.json-Datei im Moment tolerieren:

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

}}

Beachten Sie, dass diese Datei theoretisch funktionieren soll, wenn Sie sie in das Arbeitsbereichsstammverzeichnis einfügen, damit Sie nicht in Dateien in versteckten Verzeichnissen (.vscode) in Ihrem Revisionskontrollsystem nachsehen müssen. Ich habe noch nicht gesehen, dass das tatsächlich funktioniert. Testen Sie es, aber wenn es fehlschlägt, geben Sie es in .vscode ein. In jedem Fall wird die IDE meckern, wenn sie sowieso nicht da ist. (Ja, im Moment bedeutet dies, dass ich gezwungen war, .vscode in Subversion einzuchecken, worüber ich nicht glücklich bin.) Beachten Sie, dass meine Build-Skripte (nicht gezeigt) einfach ein DEBUG-Verzeichnis mit (in) erstellen (oder neu erstellen) Mein Fall, Meson, und darin bauen (mit, in meinem Fall, Ninja).

3. Ausführen, debuggen, anhängen, anhalten. Dies sind weitere Aufgaben, die in "launch.json" definiert sind. Zumindest waren sie es früher. Microsoft hat einen solchen Hash aus der Dokumentation gemacht, ich bin mir nicht einmal mehr sicher.

Mit einem aktualisierten VS-Code können Sie dies folgendermaßen tun:

1. Drücken Sie ( Ctrl+ P) und geben Sie Folgendes ein:

   ext install cpptools
   

2. Öffnen Sie einen Ordner ( Ctrl+ K& Ctrl+ O) und erstellen Sie eine neue Datei im Ordner mit der Erweiterung .cpp (Beispiel: hello.cpp ):

3. Geben Sie Ihren Code ein und klicken Sie auf Speichern.

4. Drücken Sie ( Ctrl+ Shift+ Pund geben Sie ein Configure task runnerund wählen Sie dann otheram Ende der Liste aus.

5. Erstellen Sie eine Batchdatei im selben Ordner mit dem Namen build.bat und fügen Sie den folgenden Code in den Hauptteil der Datei ein:

   @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. Bearbeiten Sie die Datei task.json wie folgt und speichern Sie sie :

   {
   // 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+ Shift+ BBuild - Task ausgeführt werden soll. Dies wird die erstellen OBJ und Exe - Dateien für das Projekt.

8. Für das Projekt debuggen, Hit F5und wählen Sie C ++ (Windows) .

9. In launch.json Datei, bearbeiten Sie die folgende Zeile und speichert die Datei:

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

10. Hit F5.

Sie können auf diese neueste Version mit einer Versionsaufgabe 2.0.0für Visual Studio Code verweisen : https://gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454

Sie können jede Datei einfach kompilieren und ausführen, ohne die Aufgabe zu aktualisieren. Es ist generisch und öffnet auch das Terminal für Eingabeeinträge.

Kann Extension Code Runner verwenden , um Code mit dem Wiedergabesymbol oben rechts und per Tastenkombination auszuführen: Ctrl+Alt+Nund abzubrechen Ctrl+Alt+M. Standardmäßig wird jedoch nur die Ausgabe des Programms angezeigt. Um jedoch Eingaben zu erhalten, müssen Sie einige Schritte ausführen:

Strg + und dann das Einstellungsmenü werden geöffnet und Erweiterungen> Codekonfiguration ausführen. Scrollen Sie in den Attributen nach unten und suchen Sie Bearbeiten in settings.json. Klicken Sie darauf und fügen Sie den folgenden Code hinzu:

{ "code-runner.runInTerminal": true }

Es gibt jetzt eine C / C ++ - Spracherweiterung von Microsoft. Sie können es installieren, indem Sie auf "Schnell öffnen" ( Ctrl+ p) gehen und Folgendes eingeben:

ext install cpptools

Sie können hier darüber lesen:

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

Ab Mai 2016 ist es sehr einfach.