Partilhar via

Suporte de pasta aberta para sistemas de compilação C++ no Visual Studio

O recurso Abrir pasta está disponível no Visual Studio 2017 e posterior.

No Visual Studio 2017 e posterior, o recurso "Abrir pasta" permite abrir uma pasta de arquivos de origem e iniciar imediatamente a codificação com suporte para IntelliSense, navegação, refatoração, depuração e assim por diante. À medida que você edita, cria, move ou exclui arquivos, o Visual Studio controla as alterações automaticamente e atualiza continuamente seu índice IntelliSense. Nenhum .sln ou .vcxproj arquivos são carregados; Se necessário, você pode especificar tarefas personalizadas, bem como criar e iniciar parâmetros por meio de arquivos .json simples. Esse recurso permite que você integre qualquer sistema de compilação de terceiros no Visual Studio. Para obter informações gerais sobre Open Folder, consulte Desenvolver código no Visual Studio sem projetos ou soluções.

CMake e Qt

CMake é integrado no IDE do Visual Studio como um componente da carga de trabalho do C++ para ambiente de trabalho. O fluxo de trabalho do CMake não é idêntico ao fluxo de trabalho descrito neste artigo. Se você estiver usando o CMake, consulte Projetos CMake no Visual Studio. Você também pode usar o CMake para criar projetos Qt ou pode usar a extensão Qt Visual Studio para Visual Studio 2015 ou Visual Studio 2017.

Outros sistemas de construção

Para usar o IDE do Visual Studio com um sistema de compilação ou conjunto de ferramentas de compilador que não é diretamente suportado no menu principal, selecione Arquivo | Aberto | Pasta ou pressione Ctrl + Shift + Alt + O. Navegue até a pasta que contém os arquivos de código-fonte. Para criar o projeto, configurar o IntelliSense e definir parâmetros de depuração, adicione três arquivos JSON:

Ficheiro Descrição
CppProperties.json Especifique informações de configuração personalizadas para navegação. Crie esse arquivo, se necessário, na pasta raiz do projeto. (Não usado em projetos CMake.)
tasks.vs.json Especifique comandos de compilação personalizados. Acessado por meio do item de menu de contexto do Gerenciador de SoluçõesConfigurar Tarefas.
launch.vs.json Especifique argumentos de linha de comando para o depurador. Acedido através do item de menu de contexto do Gerenciador de SoluçõesConfigurações de Depuração e Lançamento.

Configurar a navegação de código com CppProperties.json

Para que o IntelliSense e o comportamento de navegação, como Ir para Definição , funcionem corretamente, o Visual Studio precisa saber qual compilador você está usando, onde estão os cabeçalhos do sistema e onde quaisquer arquivos de inclusão adicionais estão localizados se eles não estiverem diretamente na pasta que você abriu (a pasta do espaço de trabalho). Para especificar uma configuração, você pode escolher Gerenciar configurações na lista suspensa na barra de ferramentas principal:

Menu suspenso de configuração na barra de ferramentas mostrando a seleção de Gerir configurações.

O Visual Studio oferece as seguintes configurações padrão:

Adicionar configuração à caixa de diálogo CppProperties, mostrando a lista de configurações padrão: x86-Debug, x86-Release, x64-Debug, x64-Release e assim por diante.

Se, por exemplo, você escolher x64-Debug, o Visual Studio criará um arquivo chamado CppProperties.json na pasta raiz do projeto:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "msvc_x64"
      ],
      "name": "x64-Debug",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "defines": [
        "WIN32",
        "_DEBUG",
        "UNICODE",
        "_UNICODE"
      ],
      "intelliSenseMode": "windows-msvc-x64"
    }
  ]
}

Essa configuração herda as variáveis de ambiente do Visual Studio x64 Developer Command Prompt. Uma dessas variáveis é INCLUDE e você pode consultá-la aqui usando a ${env.INCLUDE} macro. A includePath propriedade informa ao Visual Studio onde procurar todas as fontes necessárias para o IntelliSense. Nesse caso, ele diz "procure em todos os diretórios especificados pela variável de ambiente INCLUDE e também em todos os diretórios na estrutura de pastas de trabalho atual". A name propriedade é o nome que aparecerá na lista suspensa e pode ser o que você mesmo desejar. A defines propriedade fornece dicas para o IntelliSense quando encontra blocos de compilação condicionais. A intelliSenseMode propriedade fornece algumas dicas adicionais com base no tipo de compilador. Várias opções estão disponíveis para MSVC, GCC e Clang.

Observação

Se o Visual Studio parece estar ignorando as configurações no CppProperties.json, tente adicionar uma exceção ao seu arquivo .gitignore como esta: !/CppProperties.json.

Configuração padrão para MinGW-w64

Se você adicionar a configuração MinGW-W64, o JSON terá a seguinte aparência:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "mingw_64"
      ],
      "name": "Mingw64",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "intelliSenseMode": "linux-gcc-x64",
      "environments": [
        {
          "MINGW64_ROOT": "C:\\msys64\\mingw64",
          "BIN_ROOT": "${env.MINGW64_ROOT}\\bin",
          "FLAVOR": "x86_64-w64-mingw32",
          "TOOLSET_VERSION": "9.1.0",
          "PATH": "${env.BIN_ROOT};${env.MINGW64_ROOT}\\..\\usr\\local\\bin;${env.MINGW64_ROOT}\\..\\usr\\bin;${env.MINGW64_ROOT}\\..\\bin;${env.PATH}",
          "INCLUDE": "${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION};${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\tr1;${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\${env.FLAVOR}",
          "environment": "mingw_64"
        }
      ]
    }
  ]
}

Observe o environments bloco. Ele define propriedades que se comportam como variáveis de ambiente e estão disponíveis não apenas no arquivo CppProperties.json , mas também nos outros arquivos de configuração task.vs.json e launch.vs.json. A Mingw64 configuração herda o mingw_w64 ambiente e usa sua INCLUDE propriedade para especificar o valor de includePath. Você pode adicionar outros caminhos a essa propriedade de matriz conforme necessário.

A intelliSenseMode propriedade é definida como um valor apropriado para GCC. Para obter mais informações sobre todas essas propriedades, consulte Referência de esquema CppProperties.

Quando tudo estiver funcionando corretamente, você verá o IntelliSense nos cabeçalhos do GCC quando passar o mouse sobre um tipo:

Captura de tela de um pop-up do GCC IntelliSense mostrando a documentação do cabeçalho.

Ativar o diagnóstico do IntelliSense

Se não estiver a ver o IntelliSense esperado, pode resolver problemas acedendo a Ferramentas>Opções>Editor de Texto>C/C++>Avançado e selecionando Ativar Registo para true. Para começar, tente definir Nível de Log como 5 e Filtros de Log como 8.

Caixa de diálogo das Opções, mostrando as definições de registo de diagnóstico.

A saída é canalizada para a janela de saída e é visível quando você escolhe *Mostrar saída de: Visual C++ Log. A saída contém, entre outras coisas, a lista de caminhos de inclusão reais que o IntelliSense está tentando usar. Se os caminhos não corresponderem aos da CppProperties.json, tente fechar a pasta e excluir a subpasta .vs que contém dados de navegação em cache.

Definir tarefas de compilação com tasks.vs.json

Você pode automatizar scripts de compilação ou quaisquer outras operações externas nos arquivos que você tem em seu espaço de trabalho atual executando-os como tarefas diretamente no IDE. Você pode configurar uma nova tarefa clicando com o botão direito do mouse em um arquivo ou pasta e selecionando Configurar tarefas.

Menu de atalho do Gerenciador de Soluções mostrando o comando Configurar Tarefas.

Isso cria (ou abre) o arquivo tasks.vs.json na pasta .vs que o Visual Studio cria na pasta raiz do projeto. Você pode definir qualquer tarefa arbitrária nesse arquivo e, em seguida, invocá-la no menu de contexto Gerenciador de Soluções . Para continuar o exemplo do GCC, o trecho a seguir mostra um arquivo tasks.vs.json completo com como única tarefa que invoca o g++.exe para criar um projeto. Suponha que o projeto contém um único arquivo chamado hello.cpp.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "build hello",
      "appliesTo": "/",
      "type": "default",
      "command": "g++",
      "args": [
        "-g",
        "-o",
        "hello",
        "hello.cpp"
      ]
    }
  ]
}

O arquivo JSON é colocado na subpasta .vs . Para ver essa pasta, clique no botão Mostrar Todos os Arquivos na parte superior do Gerenciador de Soluções. Você pode executar esta tarefa clicando com o botão direito do mouse no nó raiz no Gerenciador de Soluções e escolhendo compilar 'hello'. Quando a tarefa for concluída, você verá um novo arquivo hello.exe no Gerenciador de Soluções.

Você pode definir muitos tipos de tarefas. O exemplo a seguir mostra um arquivotasks.vs.json que define uma única tarefa. taskLabel Define o nome que aparece no menu de contexto. appliesTo define em quais arquivos o comando pode ser executado. A command propriedade refere-se à variável de ambiente COMSPEC, que identifica o caminho para o console (cmd.exe no Windows). Você também pode fazer referência a variáveis de ambiente declaradas em CppProperties.json ou CMakeSettings.json. A args propriedade especifica a linha de comando a ser invocada. A ${file} macro recupera o arquivo selecionado no Gerenciador de Soluções. O exemplo a seguir exibirá o nome do arquivo .cpp selecionado no momento.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "Echo filename",
      "appliesTo": "*.cpp",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": ["echo ${file}"]
    }
  ]
}

Depois de salvar tasks.vs.json, você pode clicar com o botão direito do mouse em qualquer arquivo .cpp na pasta, escolher Echo filename no menu de contexto e ver o nome do arquivo exibido na janela Saída.

Para obter mais informações, consulte Tasks.vs.json referência de esquema.

Configurar parâmetros de depuração com launch.vs.json

Para personalizar os argumentos de linha de comando e as instruções de depuração do programa, clique com o botão direito do mouse no executável no Gerenciador de Soluções e selecione Depurar e Iniciar Configurações. Isso abrirá um arquivo launch.vs.json existente ou, se não existir, criará um novo arquivo com um conjunto de configurações mínimas de inicialização. Primeiro, você pode escolher o tipo de sessão de depuração que deseja configurar. Para depurar um projeto MinGw-w64, escolhemos C/C++ Launch for MinGW/Cygwin (gdb). Isso cria uma configuração de inicialização para usar gdb.exe com algumas suposições instruídas sobre valores padrão. Um desses valores padrão é MINGW_PREFIX. Você pode substituir o caminho literal (como mostrado abaixo) ou pode definir uma MINGW_PREFIX propriedade em CppProperties.json:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "cppdbg",
      "name": "hello.exe",
      "project": "hello.exe",
      "cwd": "${workspaceRoot}",
      "program": "${debugInfo.target}",
      "MIMode": "gdb",
      "miDebuggerPath": "c:\\msys64\\usr\\bin\\gdb.exe",
      "externalConsole": true
    }
  ]
}

Para iniciar a depuração, escolha o executável no menu de depuração e clique na seta verde.

Lista suspensa de destino de depuração da barra de ferramentas, mostrando a seta verde para iniciar o depurador.

Você deve ver a caixa de diálogo Inicializando Depurador e, em seguida, uma janela de console externo que está executando o seu programa.

Para obter mais informações, consulte launch.vs.json referência de esquema.

Iniciando outros executáveis

Você pode definir as configurações de inicialização para qualquer executável no seu computador. O exemplo a seguir inicia 7za e especifica argumentos adicionais, adicionando-os args à matriz JSON:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CPP\\7zip\\Bundles\\Alone\\O\\7za.exe",
      "name": "7za.exe list content of helloworld.zip",
      "args": [ "l", "d:\\sources\\helloworld.zip" ]
    }
  ]
}

Quando você salva esse arquivo, a nova configuração aparece no menu suspenso Debug Target e você pode selecioná-la para iniciar o depurador. Você pode criar quantas configurações de depuração quiser, para qualquer número de executáveis. Se você pressionar F5 agora, o depurador será iniciado e atingirá qualquer ponto de interrupção que você já tenha definido. Todas as janelas familiares do depurador e suas funcionalidades estão agora disponíveis.

  • Last updated on