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?
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?
Respostas:
Existe uma maneira muito mais fácil de compilar e executar o código C ++, sem configuração necessária:
Ctrl+Alt+N
, pressione F1
e selecione / digite Run Code
, ou clique com o botão direito do mouse no Editor de Texto e, em seguida, clique Run Code
no 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"
}
running blablabla
. Nenhum aviso, nada. Como faço para parar o código em execução?
Ctrl+Alt+M
. Para usar stdin para ler dados, você pode ir para File
-> Preference
-> Settings
para definir "code-runner.runInTerminal": true
. Para obter mais detalhes, consulte github.com/formulahendry/vscode-code-runner/issues/91
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 Arquivo → Preferências → Atalhos 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.
ctrl+alt+b
para a tarefa de construção.
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
}
}
}
]
}
.vscode
. Para o controle de revisão git, uma possibilidade é usar para .gitignore
um padrão como !.vscode/tasks.json
.
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:
"C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include"
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.
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):
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 ...).
Primeiro, vá para extensões (Ctrl + Shift + X) e instale 2 extensões:
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.
Se o seu projeto tem uma configuração do CMake, é bastante simples instalar o VSCode, por exemplo, tasks.json
como 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 problemMatcher
está configurado para clang
-builds. Para usar o GCC, acredito que você precisa mudar fileLocation
para relative
, mas não testei isso.
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
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:
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.
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).
Com um código VS atualizado, você pode fazê-lo da seguinte maneira:
Clique ( Ctrl+ P) e digite:
ext install cpptools
Abra uma pasta ( Ctrl+ K& Ctrl+ O) e crie um novo arquivo dentro da pasta com a extensão .cpp (ex: hello.cpp ):
Digite seu código e clique em salvar.
Pressione ( Ctrl+ Shift+ Pe digite e, em Configure task runner
seguida, selecione other
na parte inferior da lista.
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%
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"
}
Pressione ( Ctrl+ Shift+ Bpara executar a tarefa Compilar. Isso criará os arquivos .obj e .exe para o projeto.
Para depurar o projeto, F5pressione e selecione C ++ (Windows) .
No arquivo launch.json , edite a seguinte linha e salve o arquivo:
"program": "${workspaceRoot}/hello.exe",
Hit F5.
Você pode fazer referência a esta lista mais recente com uma 2.0.0
tarefa de versão para o Visual Studio Code, https://gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454
Você pode facilmente compilar e executar cada arquivo sem atualizar a tarefa. É genérico e também abre o terminal para entradas de entrada.
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+N
e 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
}
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.