Como configuro o Visual Studio Code para compilar o código C ++?


222

O editor de código do Visual Studio da Microsoft é bastante bom, mas não possui suporte padrão para a criação de projetos em C ++.

Como faço para configurá-lo para fazer isso?


12
Existem muitas respostas para compilar o código C ++ no Linux, mas e o Windows?
Charles Milette 14/01

5
Coisas tão básicas e ainda não há recurso útil para fazer isso no Windows. E a extensão ms cpptools, não fale sobre isso. Eu acho que é apenas para adicionar à sua frustração. Não faz nada.
21417 Kshitij

Alguém encontrou solução? Eu sou capaz de compilar, mas não depurar C / C ++ no VSCode. Este artigo diz que a depuração é suportada apenas no linux. Também recentemente criei esta discussão para o mesmo. Vai apreciar qualquer ajuda ...
Mahesha999

Respostas:


133

Existe uma maneira muito mais fácil de compilar e executar o código C ++, sem configuração necessária:

  1. Instale a extensão do Code Runner
  2. Abra seu arquivo de código C ++ no Editor de Texto, use o atalho Ctrl+Alt+N, pressione F1e selecione / digite Run Code, ou clique com o botão direito do mouse no Editor de Texto e, em seguida, clique Run Codeno menu de contexto, o código será compilado e executado e a saída será mostrada no Janela de saída.

Além disso, você pode atualizar a configuração em settings.json usando diferentes compiladores C ++ como desejar, a configuração padrão para C ++ é a seguinte:

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

4
A janela Minha Saída está bloqueada running blablabla. Nenhum aviso, nada. Como faço para parar o código em execução?
Hichigaya Hachiman

11
Para interromper a execução do código, use Ctrl+Alt+M. Para usar stdin para ler dados, você pode ir para File-> Preference-> Settingspara definir "code-runner.runInTerminal": true. Para obter mais detalhes, consulte github.com/formulahendry/vscode-code-runner/issues/91
Jun Han

1
A execução na janela de saída impede a entrada do terminal. runInTerminal parece necessário ...
Andrew Wolfe

Obtendo um erro - "erro: nome de arquivo vazio em #include"
gaurav

9
Você deve divulgar que é o autor da extensão que está promovendo.
Codebling

86

As tarefas de construção são específicas do projeto. Para criar um novo projeto, abra um diretório no Visual Studio Code.

Seguindo as instruções aqui , pressione Ctrl+ Shift+ P, digite Configure Tasks, selecione-o e pressione Enter.

O arquivo tasks.json será aberto. Cole o seguinte script de compilação no arquivo e salve-o:

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

Agora vá para o menu ArquivoPreferênciasAtalhos de teclado e adicione a seguinte associação de teclas para a tarefa de construção:

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

Agora, quando você pressionar, F8o Makefile será executado e os erros serão sublinhados no editor.


8
AVISO - o formato deste arquivo foi alterado e isso não está mais correto. Consulte: go.microsoft.com/fwlink/?LinkId=733558
ponto de interrupção

A chave padrão é ctrl+alt+bpara a tarefa de construção.
danger89

Existe um comando ou ligação que irá pular para o erro seguinte / anterior no terminal ? Eu tenho uma situação em que o painel "Problemas" tem um monte de problemas irrelevantes (porque o VS Code realmente não sabe como criar meu projeto - e será muito complicado para ensiná-lo), mas meu "Terminal" é cheio de erros úteis após uma compilação. Eu só preciso de um atalho de teclado para pular para o próximo erro no "Terminal" ...
Dan L

47

Um exemplo de tarefa makefile para a nova versão 2.0.0 tasks.json.

No trecho abaixo, alguns comentários, espero que sejam úteis.

{
    "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
Ainda atualizado em novembro de 2018. Obrigado!
TheIntern

Em que diretório você colocou isso? A raiz ".vs" ou ".vscode"? Supostamente, a raiz da área de trabalho é o único local recomendado se o arquivo também estiver entrando no controle de revisão (o que eu recomendo fortemente), mas não consegui fazê-lo funcionar.
breakpoint

Pelo que sei, o único lugar válido no momento é .vscode. Para o controle de revisão git, uma possibilidade é usar para .gitignoreum padrão como !.vscode/tasks.json.
attdona

14

Aqui está como eu configurei meu VS para C ++

Certifique-se de alterar os caminhos apropriados para onde o seu MinGW instalou

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
}

Referência:

  1. C / C ++ para código VS

  2. modelo c_cpp_properties.json


13
talvez você também quiser explicar um pouco o que suas configurações estão fazendo e não apenas copiar e colar coisas
uitty400

2
é difícil explicar minhas configurações.
Li Kui

Certifique-se de alterar os caminhos apropriados para onde o seu MinGW está instalado.
Anthony Lei

Você também pode incluir subpastas recursivamente com / ** em vez de repetir várias subpastas em"C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include"
Lorenz

10

Para criar / executar projetos C ++ no código VS, é necessário configurar manualmente o arquivo task.json que está na pasta .vscode na pasta da área de trabalho. Para abrir o tasks.json , pressione ctrl + shift + P e digite Configure tasks e pressione enter . Isso levará você a tasks.json

Aqui estou fornecendo alguns comentários ao meu arquivo task.json para torná-lo mais compreensível. Ele pode ser usado como referência para a configuração do task.json , espero que seja útil

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

    ]
}

Agora, declarando diretamente da documentação das tarefas de código VS

descrição da propriedade type :

  • tipo : o tipo da tarefa. Para uma tarefa personalizada, isso pode ser shell ou processo. Se o shell for especificado, o comando será interpretado como um comando do shell (por exemplo: bash, cmd ou PowerShell). Se processo for especificado, o comando será interpretado como um processo a ser executado.

O comportamento do terminal pode ser controlado usando a propriedade de apresentação em tasks.json . Oferece as seguintes propriedades:

  • revelar : controla se o painel Terminal integrado é trazido para a frente. Os valores válidos são:

    • always - O painel é sempre trazido para a frente. Esse é o padrão
    • nunca - O usuário deve trazer explicitamente o painel do terminal para a frente usando o comando Exibir> Terminal (Ctrl + `).
    • silencioso - O painel do terminal é trazido para a frente apenas se a saída não for verificada quanto a erros e avisos.
  • foco : controla se o terminal está recebendo o foco de entrada ou não. O padrão é falso.

  • echo : controla se o comando executado é ecoado no terminal. O padrão é verdadeiro.
  • showReuseMessage : controla se a mensagem "Terminal será reutilizada por tarefas, pressione qualquer tecla para fechá-la".
  • painel : controla se a instância do terminal é compartilhada entre as execuções da tarefa. Os valores possíveis são:
    • shared : O terminal é compartilhado e a saída de outras tarefas é adicionada ao mesmo terminal.
    • dedicado : O terminal é dedicado a uma tarefa específica. Se essa tarefa for executada novamente, o terminal será reutilizado. No entanto, a saída de uma tarefa diferente é apresentada em um terminal diferente.
    • novo : toda execução dessa tarefa está usando um novo terminal limpo.
  • clear: controla se o terminal é limpo antes que esta tarefa seja executada. O padrão é falso.

9

Frustrado com a falta de documentação clara, criei um projeto Mac no github que deve funcionar (tanto na construção quanto na depuração):

vscode-mac-c-exemplo

Observe que ele requer o XCode e a extensão cpptools do Microsoft VSCode.

Eu pretendo fazer o mesmo no Windows e no Linux (a menos que a Microsoft escreva a documentação decente primeiro ...).


8

Primeiro, vá para extensões (Ctrl + Shift + X) e instale 2 extensões:

  1. Code Runner
  2. C / C ++

Em seguida, recarregue o código VS e selecione um botão de reprodução no canto superior direito do seu programa no terminal de saída. Você pode ver a saída pressionando Ctrl + Alt + N. Para alterar outros recursos, vá para a configuração do usuário. insira a descrição da imagem aqui


Esta é uma repetição de respostas anteriores.
JDługosz

5

Se o seu projeto tem uma configuração do CMake, é bastante simples instalar o VSCode, por exemplo, tasks.jsoncomo abaixo:

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

Isso pressupõe que haja uma pasta build na raiz da área de trabalho com uma configuração do CMake.

Há também uma extensão de integração do CMake que adiciona um comando "CMake build" ao VScode.

PS! O problemMatcherestá configurado para clang-builds. Para usar o GCC, acredito que você precisa mudar fileLocationpara relative, mas não testei isso.


5

Aqui está como eu configurei meu VS para C ++ usando o compilador g ++ e ele funciona muito bem, incluindo opções de depuração:

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

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

Também tenho a extensão 'C / C ++ para Visual Studio Code' instalada no VS Code


Eu sou capaz de compilar, mas não depurar C / C ++ no VSCode. Este artigo diz que a depuração é suportada apenas no linux. Também recentemente criei esta discussão para o mesmo. Vai apreciar qualquer ajuda ...
Mahesha999

5

O problema básico aqui é que criar e vincular um programa C ++ depende muito do sistema de compilação em uso. Você precisará dar suporte às seguintes tarefas distintas, usando alguma combinação de plug-ins e código personalizado:

  1. Suporte geral à linguagem C ++ para o editor. Isso geralmente é feito usando o ms-vscode.cpptools, que a maioria das pessoas espera também lidar com muitas outras coisas, como suporte à compilação. Deixe-me poupar algum tempo: isso não acontece. No entanto, você provavelmente vai querer de qualquer maneira.

  2. Crie, limpe e reconstrua tarefas. É aqui que a sua escolha do sistema de compilação se torna um grande negócio. Você encontrará plugins para coisas como CMake e Autoconf (se Deus o ajudar), mas se você estiver usando algo como Meson e Ninja, precisará escrever alguns scripts auxiliares e configurar um arquivo "tasks.json" personalizado para lidar com isso. A Microsoft mudou totalmente tudo sobre esse arquivo nas últimas versões, até o que deveria ser chamado e os locais (sim, locais), para não falar em mudar completamente o formato. Pior ainda, eles mantiveram a compatibilidade com versões anteriores, para ter certeza de usar a chave "version" para especificar qual variante você deseja. Veja detalhes aqui:

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

... mas observe que entra em conflito com:

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

AVISO: EM TODAS AS RESPOSTAS ABAIXO, QUALQUER COISA QUE COMEÇA COM UMA MARCA "VERSION" ABAIXO 2.0.0 É OBSOLETA.

Aqui está a coisa mais próxima que eu tenho no momento. Observe que eu passo a maior parte do trabalho pesado para scripts, isso realmente não me dá nenhuma entrada de menu com a qual eu possa conviver, e não há nenhuma maneira boa de selecionar entre depuração e lançamento sem fazer mais três entradas explícitas em aqui. Com tudo isso dito, aqui está o que eu posso tolerar como meu arquivo .vscode / tasks.json no momento:

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

}

Observe que, em teoria, esse arquivo deve funcionar se você o colocar na raiz da área de trabalho, para não ficar preso na verificação de arquivos em diretórios ocultos (.vscode) no seu sistema de controle de revisão. Ainda tenho que ver que realmente funciona; teste, mas se falhar, coloque-o em .vscode. De qualquer forma, o IDE vai ficar ruim se não estiver lá. (Sim, no momento, isso significa que fui forçado a verificar .vscode no subversion, o que não me agrada.) Observe que meus scripts de construção (não mostrados) simplesmente criam (ou recriam) um diretório DEBUG usando, em meu caso, meson, e construir dentro dele (usando, no meu caso, ninja).

  1. Executar, depurar, anexar, parar. Esse é outro conjunto de tarefas, definido em "launch.json". Ou pelo menos eles costumavam ser. A Microsoft fez tal hash da documentação, nem tenho mais certeza.

Aqui está o arquivo build-scripts / build-debug.sh, como exemplo. Idealmente, eles herdariam o contexto de construção (depuração, lançamento, criação de perfil etc.), mas não consigo descobrir como o Code gerencia isso, se é que ele tem o conceito. Perdoe a formatação; StackOverflow, vá. #! / bin / bash se [! -d "DEBUG"]; então mkdir DEBUG meson DEBUG fi cd DEBUG ninja se [$? -eq 0]; então saia 0 e saia $? fi
breakpoint

Ah, novamente: pressione CTRL-SHIFT-B depois que ele estiver no local para executar as tarefas de compilação. Eu realmente prefiro um menu principal adequado, mas ainda não descobri como fazer isso.
breakpoint

4

Com um código VS atualizado, você pode fazê-lo da seguinte maneira:

  1. Clique ( Ctrl+ P) e digite:

    ext install cpptools
    
  2. Abra uma pasta ( Ctrl+ K& Ctrl+ O) e crie um novo arquivo dentro da pasta com a extensão .cpp (ex: hello.cpp ):

  3. Digite seu código e clique em salvar.

  4. Pressione ( Ctrl+ Shift+ Pe digite e, em Configure task runnerseguida, selecione otherna parte inferior da lista.

  5. Crie um arquivo em lotes na mesma pasta com o nome build.bat e inclua o seguinte código no corpo do arquivo:

    @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. Edite o arquivo task.json da seguinte maneira e salve-o :

    {
    // 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. Pressione ( Ctrl+ Shift+ Bpara executar a tarefa Compilar. Isso criará os arquivos .obj e .exe para o projeto.

  8. Para depurar o projeto, F5pressione e selecione C ++ (Windows) .

  9. No arquivo launch.json , edite a seguinte linha e salve o arquivo:

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


Estou usando o VSC mais recente. Você me perdeu na etapa 4. Configurar o corredor de tarefas não está disponível.
Louis


2

Pode usar o Extension Code Runner para executar o código com o ícone de reprodução no canto superior direito e a tecla de atalho: Ctrl+Alt+Ne para abortar Ctrl+Alt+M. Mas, por padrão, ele mostra apenas a saída do programa, mas para receber entrada, você precisa seguir algumas etapas:

Ctrl + e , em seguida, o menu Configurações é aberto e Extensões> Configuração do Código de Execução, role seus atributos e encontre Editar em settings.json, clique nele e adicione o seguinte código:

{ "code-runner.runInTerminal": true }


Ctrl + aumenta o zoom para mim
MM

é ctrl vírgula e não ctrl plus para abrir as configurações
Ashley Fernandes

1

Agora há uma extensão de linguagem C / C ++ da Microsoft. Você pode instalá-lo acessando a opção "abertura rápida" ( Ctrl+ p) e digitando:

ext install cpptools

Você pode ler sobre isso aqui:

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

É muito básico, a partir de maio de 2016.


2
Esta é uma resposta apenas para links limítrofes . Você deve expandir sua resposta para incluir o máximo de informações aqui e usar o link apenas para referência.
Jhpratt 11/11
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.