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


222

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ć?


12
Istnieje wiele odpowiedzi na kompilowanie kodu C ++ pod Linuksem, ale co z Windows?
Charles Milette

5
Takie podstawowe rzeczy, a jednak nie ma pomocnego zasobu, aby to zrobić w systemie Windows. I ms cpptools rozszerzenie, nie mów o tym. Myślę, że to tylko po to, by zwiększyć frustrację. Nic nie robi.
Kshitij

Czy ktoś znalazł rozwiązanie? Jestem w stanie skompilować, ale nie debugować C / C ++ na VSCode. W tym artykule opisano, że debugowanie jest obsługiwane tylko w systemie Linux. Niedawno stworzyłem ten wątek dla tego samego.
Doceni

Odpowiedzi:


133

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

4
Moje okno wyników jest zablokowane running blablabla. Bez pytania, nic. Jak w ogóle zatrzymać kod?
Hichigaya Hachiman

11
Aby zatrzymać działanie kodu, użyj Ctrl+Alt+M. Aby użyć stdin do odczytu danych, możesz przejść do File-> Preference->, Settingsaby ustawić "code-runner.runInTerminal": true. Aby uzyskać więcej informacji, możesz odnieść się do github.com/formulahendry/vscode-code-runner/issues/91
Jun Han

1
Uruchomienie w oknie wyjściowym uniemożliwia wejście terminala. runInTerminal wydaje się konieczne ...
Andrew Wolfe,

Otrzymuję błąd - „błąd: pusta nazwa pliku w #include”
gaurav

9
Musisz ujawnić, że jesteś autorem promowanego rozszerzenia.
Codebling,

86

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 PlikPreferencjeSkró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.


8
OSTRZEŻENIE - format tego pliku zmienił się i nie jest już poprawny. Zobacz: go.microsoft.com/fwlink/?LinkId=733558
punkt przerwania

Kluczem domyślnym jest ctrl+alt+bzadanie kompilacji.
niebezpieczne89

Czy istnieje polecenie lub powiązanie, które przejdzie do następnego / poprzedniego błędu w terminalu ? Mam sytuację, w której okienko „Problemy” zawiera szereg nieistotnych problemów (ponieważ VS Code tak naprawdę nie wie, jak zbudować mój projekt - i będzie zbyt zaangażowany, aby go uczyć), ale mój „Terminal” jest pełen przydatnych błędów po kompilacji. Potrzebuję tylko skrótu klawiaturowego, aby przejść do następnego błędu w „Terminalu” ...
Dan L

47

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

2
Wciąż aktualne w listopadzie 2018 r. Dzięki!
TheIntern

W jakim katalogu to umieściłeś? Katalog główny „.vs” lub „.vscode”? Podobno katalog główny obszaru roboczego jest jedyną zalecaną lokalizacją, jeśli plik przechodzi także kontrolę wersji (co zdecydowanie zalecam), ale nie mogłem tego uruchomić.
punkt przerwania

Z tego co wiem, jedyne aktualne miejsce w tym momencie to .vscode. W przypadku kontroli wersji git jedną z możliwości jest użycie .gitignoretakiego wzoru !.vscode/tasks.json.
attdona

14

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


13
być może chcesz też trochę wyjaśnić, co robią twoje ustawienia, a nie tylko kopiować rzeczy wklejane
uitty400

2
trudno mi wyjaśnić moje ustawienia.
Li Kui,

Pamiętaj, aby zmienić odpowiednie ścieżki do miejsca, w którym zainstalowano MinGW.
Anthony Lei

Możesz także dołączyć podfoldery rekurencyjnie do / ** zamiast powtarzania różnych podfolderów w"C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include"
Lorenz

10

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.

9

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ę ...).


8

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. wprowadź opis zdjęcia tutaj


To powtórzenie wcześniejszych odpowiedzi.
JDługosz

5

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.


5

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


Jestem w stanie skompilować, ale nie debugować C / C ++ na VSCode. W tym artykule opisano, że debugowanie jest obsługiwane tylko w systemie Linux. Niedawno stworzyłem ten wątek dla tego samego.
Doceni

5

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).

  1. 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.

Oto przykład pliku build-scripts / build-debug.sh. Idealnie byłoby to odziedziczyć kontekst kompilacji (debugowanie, wydanie, profilowanie itp.), Ale nie mogę zrozumieć, w jaki sposób Code to zarządza, nawet jeśli ma taką koncepcję. Wybacz formatowanie; idź, StackOverflow, idź. #! / bin / bash if [! -d „DEBUG”]; to mkdir DEBUG meson DEBUG fi cd DEBUG ninja jeśli [$? -eq 0]; następnie wyjść 0 jeszcze wyjść $? fi
punkt przerwania

Och, jeszcze raz: naciśnij CTRL-SHIFT-B po tym, jak to jest na miejscu, aby podciągnąć zadania kompilacji. Naprawdę wolałbym mieć pełne menu główne, ale jeszcze nie wymyśliłem, jak to zrobić.
punkt przerwania

4

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.


Używam najnowszego VSC. Zgubiłeś mnie w kroku 4. Konfiguracja modułu uruchamiającego zadania jest niedostępna.
Louis


2

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 }


Ctrl + powiększa dla mnie
MM

to ctrl przecinek, a nie ctrl plus, aby otworzyć ustawienia
Ashley Fernandes

1

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.


2
Jest to odpowiedź tylko z linkiem granicznym . Powinieneś rozszerzyć swoją odpowiedź, aby zawierała tutaj tyle informacji, i użyj linku tylko w celach informacyjnych.
jhpratt
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.