Jak skonfigurować program Visual Studio Code do kompilowania kodu C ++?

Edytor Visual Studio Code firmy Microsoft jest całkiem niezły, ale nie ma domyślnej obsługi przy tworzeniu projektów w C ++.

Jak to skonfigurować?

Jest o wiele łatwiejszy sposób na kompilację i uruchomienie kodu C ++, nie wymaga konfiguracji:

1. Zainstaluj rozszerzenie Code Runner
2. Otwórz plik kodu C ++ w edytorze tekstu, a następnie użyj skrótu Ctrl+Alt+Nlub naciśnij, F1a następnie wybierz / wpisz Run Codelub kliknij prawym przyciskiem myszy edytor tekstu, a następnie kliknij Run Codemenu kontekstowe, kod zostanie skompilowany i uruchomiony, a wyniki zostaną wyświetlone w Okno wyjściowe.

Ponadto możesz zaktualizować config w settings.json przy użyciu różnych kompilatorów C ++, jak chcesz, domyślna konfiguracja dla C ++ jest następująca:

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

Zadania kompilacji są specyficzne dla projektu. Aby utworzyć nowy projekt, otwórz katalog w programie Visual Studio Code.

Postępując zgodnie z instrukcjami tutaj , naciśnij Ctrl+ Shift+ P, wpisz Configure Tasks, wybierz go i naciśnijEnter .

Plik tasks.json zostanie otwarty. Wklej następujący skrypt kompilacji do pliku i zapisz go:

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

Teraz przejdź do menu Plik → Preferencje → Skróty klawiaturowe i dodaj następujące powiązanie klawiszy dla zadania kompilacji:

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

Teraz, kiedy naciśniesz, F8Makefile zostanie wykonany, a błędy zostaną podkreślone w edytorze.

Przykład zadania makefile dla nowej wersji 2.0.0 tasks.json.

W poniższym fragmencie mam nadzieję, że będą one przydatne.

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

Oto jak skonfigurowałem mój VS dla C ++

Pamiętaj, aby zmienić odpowiednie ścieżki do miejsca, w którym zainstalowano 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
}

Odniesienie:

1. C / C ++ dla VS Code

2. Szablon c_cpp_properties.json

Aby zbudować / uruchomić projekty C ++ w kodzie VS, musisz ręcznie skonfigurować plik tasks.json , który znajduje się w folderze .vscode w folderze obszaru roboczego. Aby otworzyć tasks.json , naciśnij ctrl + shift + P i wpisz Konfiguruj zadania , a następnie naciśnij enter , przejdziesz do tasks.json

Oto mój komentarz do pliku tasks.json, aby plik był bardziej zrozumiały. Można go użyć jako odniesienia do konfiguracji zadanias.json. Mam nadzieję, że będzie on przydatny

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

    ]
}

Teraz, stwierdzając bezpośrednio z dokumentacji zadań kodu VS

opis właściwości typu :

• typ : typ zadania. W przypadku zadania niestandardowego może to być powłoka lub proces. Jeśli podano powłokę, polecenie jest interpretowane jako polecenie powłoki (na przykład: bash, cmd lub PowerShell). Jeśli określono proces, polecenie jest interpretowane jako proces do wykonania.

Zachowaniem terminala można sterować za pomocą właściwości prezentacji w pliku tasks.json . Oferuje następujące właściwości:

• pokaż : Kontroluje, czy panel terminala zintegrowanego ma być wysunięty na przód. Prawidłowe wartości to:

  • zawsze - panel jest zawsze wysunięty na przód. To jest domyślne
  • nigdy - użytkownik musi wyraźnie przesunąć panel terminala na przód za pomocą polecenia Widok> Terminal (Ctrl + `).
  • cichy - Panel zacisków jest wysunięty na przód tylko wtedy, gdy wyjście nie jest skanowane w poszukiwaniu błędów i ostrzeżeń.

• focus : Kontroluje, czy terminal przyjmuje fokus wejściowy, czy nie. Wartość domyślna to false.

• Echo : Kontroluje, czy wykonywane polecenie jest odbijane echem w terminalu. Domyślnie jest to prawda.
• showReuseMessage : Kontroluje, czy wyświetlać komunikat „Terminal będzie ponownie wykorzystywany przez zadania, naciśnij dowolny klawisz, aby go zamknąć”.
• płyta : Kontroluje, czy instancja terminala jest współużytkowana między uruchomieniami zadania. Możliwe wartości to:
  • shared : Terminal jest współdzielony, a wyniki innych uruchomień zadań są dodawane do tego samego terminala.
  • dedykowany : Terminal jest dedykowany do konkretnego zadania. Jeśli to zadanie zostanie wykonane ponownie, terminal zostanie ponownie użyty. Jednak dane wyjściowe innego zadania są prezentowane w innym terminalu.
  • nowy : Każde wykonanie tego zadania wymaga nowego, czystego terminala.
• wyczyść: kontroluje, czy terminal jest czyszczony przed uruchomieniem tego zadania. Wartość domyślna to false.

Z frustracji z powodu braku przejrzystej dokumentacji stworzyłem projekt Mac na github, który powinien działać (zarówno budowanie, jak i debugowanie):

vscode-mac-c-example

Zauważ, że wymaga XCode i rozszerzenia cpptools Microsoft VSCode.

Mam zamiar zrobić to samo dla systemu Windows i Linux (chyba że Microsoft najpierw napisze przyzwoitą dokumentację ...).

Przede wszystkim, goto rozszerzenia (Ctrl + Shift + X) i zainstaluj 2 rozszerzenia:

1. Code Runner
2. C / C ++

Następnie ponownie załaduj kod VS i wybierz przycisk odtwarzania w prawym górnym rogu, który program uruchamia w terminalu wyjściowym. Możesz zobaczyć dane wyjściowe za pomocą Ctrl + Alt + N. Aby zmienić inne funkcje, musisz zmienić ustawienia użytkownika.

Jeśli twój projekt ma konfigurację CMake, konfiguracja VSCode jest dość prosta, np. Konfiguracja tasks.jsonjak poniżej:

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

Zakłada się, że w katalogu buildgłównym obszaru roboczego znajduje się folder z konfiguracją CMake.

Istnieje również rozszerzenie integracji CMake, które dodaje komendę „CMake build” do VScode.

PS! problemMatcherJest ustawiony na clang-builds. Aby użyć GCC wierzę trzeba zmienić fileLocationsię relative, ale nie testowałem tego.

Oto jak skonfigurowałem VS dla C ++ przy użyciu kompilatora g ++ i działa świetnie, włączając opcje debugowania:

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

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

Mam również rozszerzenie „C / C ++ for Visual Studio Code” zainstalowane w VS Code

Podstawowym problemem jest to, że budowanie i łączenie programu C ++ zależy w dużym stopniu od używanego systemu kompilacji. Będziesz musiał obsługiwać następujące odrębne zadania przy użyciu kombinacji wtyczek i niestandardowego kodu:

1. Ogólna obsługa języka C ++ dla edytora. Zwykle odbywa się to przy użyciu ms-vscode.cpptools, które większość ludzi spodziewa się również obsługi wielu innych rzeczy, takich jak obsługa kompilacji. Pozwól mi zaoszczędzić trochę czasu: nie. Jednak prawdopodobnie i tak będziesz tego chciał.

2. Buduj, czyszcz i przebuduj zadania. Tutaj wybór systemu kompilacji staje się ogromną sprawą. Znajdziesz wtyczki do rzeczy takich jak CMake i Autoconf (niech Bóg ci pomoże), ale jeśli używasz czegoś takiego jak Meson i Ninja, będziesz musiał napisać kilka skryptów pomocniczych i skonfigurować niestandardowy plik „tasks.json”, aby radzić sobie z nimi. Microsoft całkowicie zmienił wszystko w tym pliku w ostatnich kilku wersjach, aż do tego, jak ma się nazywać i miejsc (tak, miejsc), do których może się udać, nie mówiąc już o całkowitej zmianie formatu. Co gorsza, SORT OF zachowali zgodność z poprzednimi wersjami, aby upewnić się, że używasz klucza „wersja”, aby określić, który wariant chcesz. Zobacz szczegóły tutaj:

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

... ale uwaga jest w konflikcie z:

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

OSTRZEŻENIE: WSZYSTKIE PONIŻSZE ODPOWIEDZI, WSZYSTKO, CO ZACZYNA SIĘ Z TAGIEM „WERSJA” PONIŻEJ 2.0.0, JEST OBSOLETOWANE.

Oto najbliższa rzecz, jaką mam w tej chwili. Zauważ, że wykonuję większość prac związanych ze skryptami, to tak naprawdę nie daje mi żadnych pozycji menu, z którymi mógłbym żyć, i nie ma żadnego dobrego sposobu na wybór między debugowaniem a wydaniem bez wprowadzania kolejnych trzech wyraźnych pozycji w tutaj. Biorąc to wszystko pod uwagę, oto, co mogę obecnie tolerować jako mój plik .vscode / tasks.json:

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

}

Zauważ, że teoretycznie ten plik powinien działać, jeśli umieścisz go w katalogu głównym obszaru roboczego, aby nie utknąć podczas sprawdzania plików w ukrytych katalogach (.vscode) w systemie kontroli wersji. Jeszcze nie widziałem, żeby to rzeczywiście działało; przetestuj go, ale jeśli się nie powiedzie, umieść go w .vscode. Tak czy inaczej, IDE suka, jeśli i tak jej nie ma. (Tak, w tej chwili oznacza to, że jestem zmuszony sprawdzić .vscode do subversion, co mnie nie cieszy). Zauważ, że moje skrypty budowania (nie pokazano) po prostu tworzą (lub odtwarzają) katalog DEBUG za pomocą, w mój przypadek, mezon i wbudowane w niego (używając, w moim przypadku, ninja).

3. Uruchom, debuguj, dołącz, zatrzymaj. To kolejny zestaw zadań zdefiniowanych w „launch.json”. A przynajmniej kiedyś. Microsoft dokonał takiego skrótu dokumentacji, nie jestem nawet pewien.

Za pomocą zaktualizowanego kodu VS możesz to zrobić w następujący sposób:

1. Naciśnij ( Ctrl+ P) i wpisz:

   ext install cpptools
   

2. Otwórz folder ( Ctrl+ Ki Ctrl+ O) i utwórz nowy plik w folderze z rozszerzeniem .cpp (np .: hello.cpp ):

3. Wpisz swój kod i naciśnij Zapisz.

4. Naciśnij ( Ctrl+ Shift+ Pi wpisz, Configure task runnera następnie wybierz otherna dole listy.

5. Utwórz plik wsadowy w tym samym folderze o nazwie build.bat i dołącz następujący kod do treści pliku:

   @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. Edycja task.json plik w następujący sposób i zapisać go :

   {
   // 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. Naciśnij ( Ctrl+ Shift+, Baby uruchomić kompilację. Spowoduje to utworzenie plików .obj i .exe dla projektu.

8. Aby debugować projekt, F5kliknij i wybierz C ++ (Windows) .

9. W pliku launch.json edytuj następujący wiersz i zapisz plik:

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

10. Hit F5.

Możesz odwołać się do tej najnowszej wersji, która ma 2.0.0zadanie wersji dla Visual Studio Code, https://gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454

Możesz łatwo skompilować i uruchomić każdy plik bez aktualizacji zadania. Jest ogólny, a także otwiera terminal dla wpisów wejściowych.

Można użyć programu Extension Code Runner do uruchomienia kodu z ikoną odtwarzania u góry Prawy przycisk skrótu: Ctrl+Alt+Ni do przerwania Ctrl+Alt+M. Ale domyślnie pokazuje tylko wyjście programu, ale aby otrzymać dane wejściowe, musisz wykonać kilka kroków:

Ctrl +, a następnie otworzy się menu ustawień i Rozszerzenia> Uruchom konfigurację kodu przewiń w dół jego atrybuty i znajdź Edytuj w ustawieniach.json kliknij na niego i dodaj następujący kod:

{ "code-runner.runInTerminal": true }

Istnieje teraz rozszerzenie języka C / C ++ od Microsoft. Możesz go zainstalować, przechodząc do „szybkiego otwierania” ( Ctrl+ p) i wpisując:

ext install cpptools

Możesz przeczytać o tym tutaj:

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

To bardzo podstawowe, od maja 2016 r.