Configurar um projeto Linux CMake no Visual Studio

O suporte ao Linux está disponível no Visual Studio 2017 e posterior. Para ver a documentação dessas versões, defina a lista suspensa Versão localizada acima do sumário como Visual Studio 2017 ou Visual Studio 2019.

Este tópico descreve como adicionar uma configuração do Linux a um projeto CMake destinado a um sistema Linux remoto ou ao Subsistema Windows para Linux (WSL). Ele continua a série que começou com Criar um projeto Linux CMake no Visual Studio. Se você estiver usando o MSBuild, em vez disso, consulte Configurar um projeto MSBuild do Linux no Visual Studio

Adicionar uma configuração do Linux

Uma configuração pode ser usada para direcionar diferentes plataformas (Windows, WSL, um sistema remoto) com o mesmo código-fonte. Uma configuração também é usada para definir seus compiladores, passar variáveis de ambiente e personalizar como o CMake é invocado. O arquivo CMakeSettings.json especifica algumas ou todas as propriedades listadas em Personalizar configurações do CMake, além de outras propriedades que controlam as configurações de compilação na máquina Linux remota.

Para alterar as configurações padrão do CMake no Visual Studio 2017, escolha CMake>Change CMake Settings>CMakeLists.txt no menu principal. Ou, clique com o botão direito do mouse em CMakeLists.txt no Gerenciador de Soluções e escolha Alterar Configurações do CMake. Em seguida, o Visual Studio cria um novo arquivo deCMakeSettings.json na pasta raiz do projeto. Para fazer alterações, abra o arquivo e modifique-o diretamente. Para obter mais informações, consulte Personalizar configurações do CMake.

A configuração padrão para Linux-Debug no Visual Studio 2017 (e Visual Studio 2019 versão 16.0) tem esta aparência:

{
  "configurations": [
    {
      "name": "Linux-Debug",
      "generator": "Unix Makefiles",
      "remoteMachineName": "${defaultRemoteMachineName}",
      "configurationType": "Debug",
      "remoteCMakeListsRoot": "/var/tmp/src/${workspaceHash}/${name}",
      "cmakeExecutable": "/usr/local/bin/cmake",
      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
      "remoteBuildRoot": "/var/tmp/build/${workspaceHash}/build/${name}",
      "remoteInstallRoot": "/var/tmp/build/${workspaceHash}/install/${name}",
      "remoteCopySources": true,
      "remoteCopySourcesOutputVerbosity": "Normal",
      "remoteCopySourcesConcurrentCopies": "10",
      "remoteCopySourcesMethod": "rsync",
      "remoteCopySourcesExclusionList": [
        ".vs",
        ".git"
      ],
      "rsyncCommandArgs": "-t --delete --delete-excluded",
      "remoteCopyBuildOutput": false,
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
      "inheritEnvironments": [
        "linux_x64"
      ]
    }
  ]
}

Para alterar as configurações padrão do CMake no Visual Studio 2019 ou posterior, na barra de ferramentas principal, abra a lista suspensa Configuração e escolha Gerenciar configurações.

Este comando abre o CMake Settings Editor, que você pode usar para editar o arquivo CMakeSettings.json na pasta raiz do projeto. Você também pode abrir o arquivo com o editor JSON clicando no botão Editar JSON no canto superior direito da caixa de diálogo Configurações do CMake . Para obter mais informações, consulte Personalizar configurações do CMake.

A configuração de Linux-Debug padrão no Visual Studio 2019 versão 16.1 e posterior tem esta aparência:

{
  "configurations": [
    {
      "name": "Linux-GCC-Debug",
      "generator": "Ninja",
      "configurationType": "Debug",
      "cmakeExecutable": "cmake",
      "remoteCopySourcesExclusionList": [ ".vs", ".git", "out" ],
      "cmakeCommandArgs": "",
      "buildCommandArgs": "",
      "ctestCommandArgs": "",
      "inheritEnvironments": [ "linux_x64" ],
      "remoteMachineName": "${defaultRemoteMachineName}",
      "remoteCMakeListsRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/src",
      "remoteBuildRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/build/${name}",
      "remoteInstallRoot": "$HOME/.vs/${projectDirName}/${workspaceHash}/out/install/${name}",
      "remoteCopySources": true,
      "rsyncCommandArgs": "-t --delete --delete-excluded",
      "remoteCopyBuildOutput": false,
      "remoteCopySourcesMethod": "rsync",
      "variables": []
    }
  ]
}

No Visual Studio 2019 versão 16.6 ou posterior, o Ninja é o gerador padrão para configurações direcionadas a um sistema remoto ou WSL, em oposição ao Unix Makefiles. Para obter mais informações, consulte este post no blog da equipe C++.

Para obter mais informações sobre essas configurações, consulte CMakeSettings.json referência.

Quando fazes um build:

• Se você estiver visando um sistema remoto, o Visual Studio escolhe o primeiro sistema remoto na lista em Opções de Ferramentas>>Cross Platform>Connection Manager por padrão para destinos remotos.
• Se nenhuma conexão remota for encontrada, você será solicitado a criar uma. Para obter mais informações, consulte Conectar-se ao seu computador Linux remoto.

Escolha um destino Linux

Quando abres uma pasta de projeto CMake, o Visual Studio analisa o ficheiro CMakeLists.txt e especifica um alvo Windows de x86-Debug. Para direcionar um sistema Linux remoto, você alterará as configurações do projeto com base no seu compilador Linux. Por exemplo, se você estiver usando o GCC no Linux e compilando com informações de depuração, escolha: Linux-GCC-Debug ou Linux-GCC-Release.

Se você especificar um destino Linux remoto, sua fonte será copiada para o sistema remoto.

Depois de selecionar um destino, o CMake é executado automaticamente no sistema Linux para gerar o cache CMake para o seu projeto:

Subsistema Windows de destino para Linux

Se você estiver visando o Subsistema Windows para Linux (WSL), não precisará adicionar uma conexão remota.

Para selecionar o WSL, seleccione Gerenciar Configurações no menu suspenso na barra de ferramentas principal.

A janela CMakeSettings.json é exibida.

Caixa de diálogo de configurações do CMake com o botão "adicionar" realçado, que adiciona a configuração selecionada, neste caso, "Linux-GCC-debug".

Pressione Add Configuration (o botão verde '+') e escolha Linux-GCC-Debug ou Linux-GCC-Release se estiver usando GCC. Use as variantes Clang se estiver usando o conjunto de ferramentas Clang/LLVM. Pressione Select (Selecionar ) e, em seguida, Ctrl+S para salvar a configuração.

Visual Studio 2019 versão 16.1 Quando você segmenta o WSL, o Visual Studio não precisa copiar arquivos de origem e manter duas cópias síncronas da árvore de compilação porque o compilador no Linux tem acesso direto aos arquivos de origem no sistema de arquivos do Windows montado.

IntelliSense

O IntelliSense C++ preciso requer acesso aos cabeçalhos C++ referenciados pelos arquivos de origem C++. O Visual Studio usa automaticamente os cabeçalhos referenciados por um projeto CMake, do Linux ao Windows, para fornecer uma experiência de IntelliSense de fidelidade completa. Para obter mais informações, consulte IntelliSense para cabeçalhos remotos.

Configuração de localidade

As configurações de idioma do Visual Studio não são propagadas para destinos Linux porque o Visual Studio não gerencia nem configura pacotes instalados. As mensagens mostradas na janela Saída, como erros de compilação, são mostradas usando o idioma e a localidade do destino Linux. Você precisará configurar seus destinos Linux para a localidade desejada.

Mais configurações

Use as configurações a seguir para executar comandos no sistema Linux antes e depois da construção e antes da geração do CMake. Os valores podem ser qualquer comando válido no sistema remoto. A saída é canalizada de volta para o Visual Studio.

{
      "remotePrebuildCommand": "",
      "remotePreGenerateCommand": "",
      "remotePostbuildCommand": "",
}

Próximos passos

Configurar sessões de depuração do CMake

Ver também

Trabalhando com propriedades do projeto
Personalizar as configurações do CMake
Referência de configuração predefinida do CMake