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

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?

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

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.

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

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

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

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

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.

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.

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:

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

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

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.

Você pode fazer referência a esta lista mais recente com uma 2.0.0tarefa 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+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 }

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.