Partilhar via

Configurar e compilar com predefinições do CMake no Visual Studio

O CMake suporta dois arquivos que permitem aos usuários especificar opções comuns de configuração, compilação e teste e compartilhá-las com outras pessoas: CMakePresets.json e CMakeUserPresets.json. Use esses arquivos para conduzir o CMake no Visual Studio e no Visual Studio Code, em um pipeline de integração contínua (CI) e a partir da linha de comando.

CMakePresets.json é para salvar compilações em todo o projeto. CMakeUserPresets.json é para os desenvolvedores salvarem suas próprias compilações locais. Ambos os arquivos são suportados no Visual Studio 2019 versão 16.10 ou posterior.

Este artigo contém informações sobre CMakePresets.json a integração com o Visual Studio. Aqui estão links úteis:

Recomendamos CMakePresets.json como alternativa ao CMakeSettings.json. O Visual Studio nunca lê de ambos CMakePresets.json e CMakeSettings.json ao mesmo tempo. Para habilitar ou desabilitar CMakePresets.json a integração no Visual Studio, consulte Habilitar CMakePresets.json no Visual Studio 2019.

CMake e CMakePresets.json versões suportadas

As versões suportadas CMakePresets.json e CMakeUserPresets.json de esquema dependem da sua versão do Visual Studio:

  • O Visual Studio 2019 versão 16.10 e posterior oferece suporte às versões 2 e 3 do esquema.
  • O Visual Studio 2022 versão 17.4 preview 1 adiciona suporte para o esquema versão 4.
  • O Visual Studio 2022 versão 17.5 preview 1 adiciona suporte para o esquema versão 5.

Você pode atualizar a versão alterando o "version" campo no objeto raiz. Para obter um exemplo e mais informações, consulte CMakePresets.json formato.

CMake versão 3.20 ou posterior é necessária quando você está invocando CMake com CMakePresets.json a partir da linha de comando. No entanto, o Visual Studio lê e avalia CMakePresets.jsonCMakeUserPresets.json a si mesmo e não invoca o CMake diretamente com a --preset opção. Portanto, o CMake versão 3.20 ou posterior não é estritamente necessário quando você está criando com CMakePresets.json dentro do Visual Studio.

Recomendamos usar pelo menos o CMake versão 3.14 ou posterior.

Habilitar CMakePresets.json a integração no Visual Studio

CMakePresets.json a integração não está habilitada por padrão no Visual Studio. Você pode ativá-lo em Opções de Ferramentas>>CMake>General:

Captura de ecrã a mostrar a opção 'Sempre utilizar CMakePresets.json' selecionada.

Importante

Feche e reabra a pasta no Visual Studio para ativar a integração.

Em algumas versões mais antigas do Visual Studio, Opções de Ferramentas>>O CMake>General tem apenas uma única opção para habilitar CMakePresets.json a integração:

Captura de tela de uma versão mais antiga do Visual Studio. Há uma caixa de seleção chamada

A tabela a seguir indica quando CMakePresets.json é usado em vez de para direcionar a configuração do CMakeSettings.json CMake e compilar no Visual Studio 2022 e Visual Studio 2019 versão 16.10 e posterior. Se nenhum arquivo de configuração estiver presente, as predefinições de configuração padrão serão usadas.

Na tabela,"> habilitadas" significa Usar CMakePresets.json para conduzir o CMake configurar, compilar e testar está selecionado em>>CMake>General.

Arquivos de configuração Opções de ferramentas > desativadas Opções de ferramentas > ativadas
Nenhum arquivo de configuração presente CMakeSettings.json CMakePresets.json
CMakeSettings.json Atualidade CMakeSettings.json CMakePresets.json
CMakePresets.json Atualidade CMakePresets.json CMakePresets.json
Ambos os arquivos de configuração presentes CMakePresets.json CMakePresets.json

Modificar a configuração automática e as notificações de cache

Por padrão, o configure Visual Studio invoca automaticamente sempre que o Sistema de Destino ativo ou Configurar alterações predefinidas. Você pode modificar esse comportamento selecionando Nunca executar a etapa de configuração automaticamente em Opções de ferramentas>>CMake>General. Você também pode desativar todas as notificações de cache do CMake (barras de ouro) desmarcando Mostrar notificações de cache do CMake.

Predefinições de configuração padrão

Se nenhum CMakePresets.json arquivo ou CMakeUserPresets.json existir, ou se CMakePresets.json ou CMakeUserPresets.json for inválido, o Visual Studio recorrerá às seguintes predefinições de configuração padrão:

Exemplo do Windows

{
  "name": "windows-default",
  "displayName": "Windows x64 Debug",
  "description": "Sets Ninja generator, compilers, x64 architecture, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "architecture": {
    "value": "x64",
    "strategy": "external"
  },
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Windows" ]
    }
  }
},

Exemplo Linux

{
  "name": "linux-default",
  "displayName": "Linux Debug",
  "description": "Sets Ninja generator, compilers, build and install directory, debug build type",
  "generator": "Ninja",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "cacheVariables": {
    "CMAKE_BUILD_TYPE": "Debug",
    "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
  },
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": [ "Linux" ]
    },
    "microsoft.com/VisualStudioRemoteSettings/CMake/1.0": {
      "sourceDir": "$env{HOME}/.vs/$ms{projectDirName}"
   }
  }
}

Se você tentar abrir ou modificar um CMakePresets.json arquivo que não existe, o Visual Studio criará automaticamente um CMakePresets.json arquivo com o padrão Configurar predefinições na raiz do seu projeto.

Configurar e compilar

Na barra de ferramentas do Visual Studio, há menus suspensos para os Sistemas de Destino, Configurar Predefinições e Criar Predefinições quando CMakePresets.json a integração está habilitada:

Captura de tela mostrando os menus suspensos para o sistema de destino definido como Máquina Local, configuração definida como windows-arm64 e predefinição de compilação como padrão.

Selecione um sistema de destino

A lista suspensa à esquerda indica o Sistema de Destino ativo. É o sistema no qual o CMake é invocado para configurar e construir o projeto. Esta lista suspensa inclui sua máquina local, todas as conexões SSH no Gerenciador de Conexões por nome de host e todas as instalações do Subsistema Windows para Linux (WSL) que o Visual Studio pode encontrar:

Captura de ecrã da lista pendente Sistema de Destino

No exemplo anterior:

  • 192.168.0.5 é um sistema Linux remoto que foi adicionado ao Connection Manager.
  • ubuntu2004 e debian são instalações WSL.

Selecione Gerenciar conexões para abrir o Gerenciador de conexões.

Selecione uma configuração de predefinição

A lista suspensa no meio indica a predefinição de configuração ativa. É o valor que é usado quando o configurePreset CMake é invocado para gerar o sistema de compilação do projeto. Esta lista suspensa inclui a união de Predefinições de Configuração não ocultas definidas em CMakePresets.json e CMakeUserPresets.json.

O Visual Studio usa o valor de no mapa do fornecedor de Configurações do Microsoft Visual Studio para ocultar Configurar Predefinições que não se aplicam ao Sistema de hostOS Destino ativo. Para obter mais informações, consulte a entrada para hostOS na tabela em Visual Studio Settings vendor map.

Selecione Gerenciar configurações para abrir o CMakePresets.json arquivo localizado na raiz do projeto. CMakePresets.json é criado se ainda não existir.

Selecione uma predefinição de compilação

A lista suspensa à direita indica a predefinição de compilação ativa. É o valor usado quando o buildPreset CMake é invocado para construir o projeto. Esta lista suspensa inclui a união de predefinições de compilação não ocultas definidas em CMakePresets.json e CMakeUserPresets.json.

Todas as predefinições de compilação são necessárias para especificar um valor associado configurePreset . O Visual Studio oculta Predefinições de compilação que não se aplicam à predefinição de configuração ativa. Para obter mais informações, consulte a lista de predefinições de compilação.

Se não houver predefinições de compilação associadas à predefinição de configuração ativa, o Visual Studio listará a predefinição de compilação padrão. A predefinição de compilação padrão é equivalente a passar cmake --build sem outros argumentos da linha de comando.

Configurar

Visual Studio tenta configurar automaticamente o projeto quando deteta que o cache CMake está desatualizado. Para invocar manualmente a configuração, selecione Project>Configure <project-name> no menu principal. É o mesmo que executar cmake --preset <configurePreset> a partir da linha de comando, onde <configurePreset> é o nome da predefinição de configuração ativa.

Para desativar a geração automática de cache, consulte Configuração automática e notificações de cache.

Construir

Para construir o projeto inteiro, selecione Build>Build All no menu principal. É o mesmo que executar cmake --build --preset <buildPreset> a partir da linha de comando, onde <buildPreset> é o nome da predefinição de compilação ativa.

Para criar um único destino, alterne para a Visualização de Destinos CMake no Gerenciador de Soluções. Em seguida, clique com o botão direito do mouse em qualquer destino e selecione Construir no menu de atalho.

Observação

O Visual Studio 2019 não oferece suporte buildPresets.targets à opção de criar um subconjunto de destinos especificados no CMakePresets.json.

Executar CTest

CMakePresets.json suporta duas opções de menu no Visual Studio 2019:

  • Teste>Run CTests for <project-name> invoca CTest e executa todos os testes associados ao ativo Configure Preset e Build Preset, sem outros argumentos passados para CTest.
  • Teste>Run Test Preset for <configurePreset> expande para mostrar todas as Predefinições de Teste associadas à Predefinição de Configuração ativa. Selecionar uma única predefinição de teste é o mesmo que executar ctest --preset <testPreset> a partir da linha de comando, onde <testPreset> é o nome da predefinição de teste selecionada. Esta opção não estará disponível se nenhuma predefinição de teste for definida para a predefinição de configuração ativa.

No Visual Studio 2019, o Test Explorer não está integrado ao CMakePresets.json.

Adicionar novas predefinições

No Visual Studio 2019, todos os comandos e modelos predefinidos modificam CMakePresets.jsono . Você pode adicionar novas predefinições de nível de usuário editando CMakeUserPresets.jsondiretamente o .

Use uma barra (/) para caminhos dentro CMakePresets.json e CMakeUserPresets.json.

Adicionar novas predefinições de configuração

Para adicionar uma nova Configuração Predefinida ao , no CMakePresets.jsonGerenciador de Soluções, clique com CMakePresets.json o botão direito do mouse em Modo de Exibição de Pasta e selecione Adicionar Configuração no menu de atalho. A caixa de diálogo para selecionar um modelo Configurar predefinição aparece:

Captura de tela da caixa de diálogo Adicionar configuração predefinida ao arquivo JSON. Ele contém entradas como Linux Debug, macOS Debug, x64 Debug, e assim por diante.

Selecione o modelo de depuração x64 do Windows para configurar em sistemas Windows. Selecione o modelo de depuração do Linux para configurar em sistemas WSL e Linux remotos. Para obter mais informações sobre como editar CMakePresets.json, consulte Editar predefinições.

O modelo selecionado é adicionado ao CMakePresets.json se existir. Caso contrário, o modelo será copiado para um novo CMakePresets.json arquivo.

Adicionar novas predefinições de compilação e predefinições de teste

O Visual Studio 2019 não oferece modelos para novas predefinições de compilação e predefinições de teste. Você pode adicionar predefinições de compilação e predefinições de teste editando CMakePresets.jsondiretamente . Para obter mais informações, consulte a lista de predefinições de compilação, a lista de predefinições de teste ou um arquivo de exemploCMakePresets.json.

Editar predefinições

A documentação oficial do CMake é o melhor recurso para editar Predefinições de Configuração, Predefinições de Compilação e Predefinições de Teste. As informações a seguir são um subconjunto da documentação do CMake que é especialmente relevante para desenvolvedores do Visual Studio.

Selecione seus compiladores

Você pode definir compiladores C e C++ usando environment.CC e environment.CXX em uma configuração predefinida. Para obter mais informações, consulte CC/CXX.

Use os exemplos a seguir para criar com cl.exe e clang-cl.exe do Visual Studio. As ferramentas C++ Clang para componentes do Windows devem ser instaladas para você criar com clang-clo .

Construa com cl.exe:

"environment": {
  "CC": "cl",
  "CXX": "cl"
},
"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
},

Construa com clang:

"environment": {
  "CC": "clang-cl",
  "CXX": "clang-cl"
},
"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
},

"vendor": {
  "microsoft.com/VisualStudioSettings/CMake/1.0": {
    "intelliSenseMode": "windows-clang-x64"
  }
}

Se você usar um ou Visual Studio 16 2019Visual Studio 17 2022 como gerador, poderá usar a toolset configuração predefinida para especificar o conjunto de ClangCL ferramentas:

"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}",
},

"toolset": "ClangCL",

"vendor": {
  "microsoft.com/VisualStudioSettings/CMake/1.0": {
    "intelliSenseMode": "windows-clang-x64"
  }
}

Para obter mais informações sobre geradores que suportam a toolset especificação, consulte CMAKE_GENERATOR_TOOLSET a documentação do CMake.

Importante

No Visual Studio 2019, você deve especificar explicitamente um modo Clang IntelliSense quando estiver criando com clang ou clang-cl.

Para reproduzir essas compilações fora do Visual Studio, consulte Executar CMake a partir da linha de comando ou de um pipeline de CI.

Para compilar no Linux ou sem as Ferramentas de Compilação do Microsoft C++ (MSVC), especifique o nome de um compilador em sua PATH instância ou uma variável de ambiente que avalie o caminho completo de um compilador. Os caminhos completos são desencorajados para que o arquivo possa permanecer compartilhável. Uma predefinição criada com o GCC versão 8 pode ter esta aparência:

"environment": {
  "CC": "gcc-8",
  "CXX": "g++-8"
},
"cacheVariables": {
  "CMAKE_BUILD_TYPE": "Debug",
  "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
},

Você também pode definir compiladores com um arquivo de cadeia de ferramentas CMake. Os arquivos da cadeia de ferramentas podem ser definidos com cacheVariables.CMAKE_TOOLCHAIN_FILE, o que equivale a passar -D CMAKE_TOOLCHAIN_FILE=<value> para o CMake a partir da linha de comando. Um arquivo de cadeia de ferramentas CMake é mais frequentemente usado para compilação cruzada. Para obter mais informações sobre como criar arquivos da cadeia de ferramentas do CMake, consulte Cadeias de ferramentas do CMake.

Selecione o seu gerador

Os modelos Windows e Linux Configure Preset especificam Ninja como o gerador padrão. Outros geradores comuns são os Visual Studio Generators no Windows e Unix Makefiles no Linux e macOS. Você pode especificar um novo gerador com a generator opção em Configurar predefinição. É equivalente a passar -G para o CMake a partir da linha de comando.

Defina architecture.strategy e toolset.strategy para set quando você estiver criando com um Visual Studio Generator. Para obter mais informações, consulte Geradores CMake.

Selecione o seu tipo de configuração

Você pode definir o tipo de configuração (Debug ou Release) para geradores de configuração única usando cacheVariables.CMAKE_BUILD_TYPE. É equivalente a passar -D CMAKE_BUILD_TYPE=<value> para o CMake a partir da linha de comando. Para obter mais informações, consulte CMAKE_BUILD_TYPE.

Selecione sua arquitetura de destino e host ao criar com as Ferramentas de Compilação do Microsoft C++

Você pode definir a arquitetura de destino (x64, Win32, ARM64 ou ARM) usando architecture.value. É equivalente a passar -A para o CMake a partir da linha de comando. Para obter mais informações, consulte Seleção de plataforma.

Observação

Atualmente, os geradores do Visual Studio esperam que a sintaxe do Win32 e os geradores de linha de comando (como Ninja) esperem a sintaxe x86 quando você estiver criando para x86.

Você pode definir a arquitetura do host (x64 ou x86) e o conjunto de ferramentas usando toolset.valueo . É equivalente a passar -T para o CMake a partir da linha de comando. Para obter mais informações, consulte Seleção de conjunto de ferramentas.

Os architecture.strategy valores e toolset.strategy informam ao CMake como lidar com os campos de arquitetura e conjunto de ferramentas. set significa que CMake define o respetivo valor e external significa que CMake não definirá o respetivo valor.

Recomendamos usar set com geradores IDE como o Visual Studio Generator. Use external com geradores de linha de comando como Ninja. Esses valores permitem que fornecedores como o Visual Studio forneçam o ambiente necessário antes que o CMake seja invocado. Para obter mais informações sobre os campos de arquitetura e conjunto de ferramentas, consulte a lista de Configurar predefinições.

Se não quiser originar um ambiente, você pode definir architecture.strategy como external e architecture.value para unspecified. Você pode achar útil não criar um ambiente por qualquer um destes motivos:

  • Você usa um conjunto de ferramentas diferente de MSVC.
  • Você usa uma cadeia de ferramentas personalizada, como em cenários incorporados.
  • Você não precisa de um ambiente específico para construir.

Para obter uma lista completa dos geradores IDE que suportam o campo arquitetura, consulte CMAKE_GENERATOR_PLATFORM. Para obter uma lista completa dos geradores IDE que suportam o campo do conjunto de ferramentas, consulte CMAKE_GENERATOR_TOOLSET.

Use os exemplos a seguir para direcionar ARM64 com o gerador Ninja ou para direcionar Win32 (x86) com o gerador Visual Studio 16 2019:

"generator": "Ninja",
"architecture": {
    "strategy": "external",
    "value": "arm64"
},

"generator": "Visual Studio 16 2019",
"architecture": {
    "strategy": "set",
     "value": "Win32"
},

Definir e referenciar variáveis de ambiente

Você pode definir variáveis de ambiente usando o mapa de ambiente. As variáveis de ambiente são herdadas através do inherits campo, mas você pode substituí-las como quiser.

O ambiente de uma predefinição é a união do seu próprio ambiente e do ambiente de todos os seus pais. Se várias inherits predefinições fornecerem valores conflitantes para a mesma variável, a predefinição anterior na inherits lista será preferida. Você pode desdefinir uma variável herdada de outra predefinição definindo-a como null.

As variáveis de ambiente definidas em uma Configuração de Predefinição também fluem automaticamente para Predefinições de compilação e Predefinições de teste associadas, a menos que inheritConfigureEnvironment esteja definida como false. Para obter mais informações, consulte a lista de Configurar predefinições.

Você pode fazer referência a variáveis de ambiente usando a $env{<variable-name>} sintaxe e $penv{<variable-name>} . Para obter mais informações, consulte Expansão de macro.

Configurar o IntelliSense para um compilador cruzado

Por padrão, o Visual Studio usa o modo IntelliSense que corresponde ao conjunto de ferramentas especificado e à arquitetura de destino. Se você estiver compilando cruzadamente, talvez seja necessário especificar manualmente o modo IntelliSense correto usando a intelliSenseMode opção no mapa do fornecedor Configurações do Visual Studio. Para obter mais informações, consulte a entrada para intelliSenseMode na tabela em Visual Studio Settings vendor map.

Configurar e construir em um sistema remoto ou no Subsistema Windows para Linux

Com CMakePresets.json suporte no Visual Studio, você pode facilmente configurar e criar seu projeto em sistemas Windows, WSL e remotos. As etapas para configurar e criar seu projeto no Windows, em um sistema remoto ou no WSL são as mesmas. No entanto, alguns comportamentos são específicos para o desenvolvimento remoto.

${sourceDir} Comportamento em cenários de cópia remota

Em cenários locais (incluindo WSL1), ${sourceDir} avalia o caminho para o diretório de origem do projeto que está aberto no Visual Studio. Em cenários de cópia remota, ${sourceDir} avalia o caminho para o diretório de origem do projeto no Sistema de Destino e não o diretório de origem do projeto na máquina local.

O valor de no mapa do fornecedor de Configurações remotas do Visual Studio determina o diretório de origem do projeto no Sistema de sourceDir Destino (padrão para $env{HOME}/.vs/$ms{projectDirName}). Para obter mais informações, consulte a entrada para sourceDir na tabela em Visual Studio Settings vendor map.

Pasta local para saída remota

Os cenários de cópia remota exigem um diretório local para copiar alguns arquivos remotos, como arquivos de resposta da API de arquivo CMake ou arquivos de compilação, se copyBuildOutput no mapa do fornecedor de Configurações remotas do Visual Studio estiver definido como true. Esses arquivos são copiados automaticamente para o <local-source-directory>/out/<remote-connection-ID>/build/${presetName}.

Invocando a mesma predefinição de configuração no Windows e WSL1

Você verá um erro se tentar usar a mesma predefinição de configuração no Windows e no WSL1. O Windows e o WSL1 usam o sistema de arquivos do Windows, então o CMake tentará usar o mesmo diretório de saída (binaryDir) para as árvores de compilação do Windows e do WSL1.

Se você quiser usar a mesma configuração de predefinição com o Windows e o conjunto de ferramentas WSL1, crie uma segunda configuração de predefinição que herde da predefinição original e especifique um novo binaryDir valor. No exemplo a seguir, windows-preset pode ser usado no Windows e base-preset pode ser usado no WSL1:

{
  "name": "windows-preset",
  "inherits": "base-preset",
  "binaryDir": "${sourceDir}/out/build/${presetName}",
  "vendor": {
    "microsoft.com/VisualStudioSettings/CMake/1.0": {
      "hostOS": "Windows"
    }
  }
}

Observação

No Visual Studio 2019, apenas o conjunto de ferramentas WSL1 é suportado. Você verá esse comportamento sempre que invocar configure no Windows e no WSL.

Habilite a integração com vcpkg

O Vcpkg ajuda você a gerenciar bibliotecas C e C++ no Windows, Linux e macOS. Um arquivo vcpkg toolchain (vcpkg.cmake) deve ser passado para o CMake para habilitar a integração vcpkg. Para obter mais informações, consulte a documentação do vcpkg.

O Visual Studio não passa mais o arquivo da cadeia de ferramentas vcpkg para o CMake automaticamente quando CMakePresets.json a integração está habilitada. Essa alteração elimina o comportamento específico do Visual Studio e garante que você possa reproduzir sua compilação a partir da linha de comando.

Em vez disso, defina o caminho usando vcpkg.cmake a VCPKG_ROOT variável de ambiente em CMakePresets.json:

"cacheVariables": {
   "CMAKE_TOOLCHAIN_FILE": {
      "value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
       "type": "FILEPATH"
    }
 },

VCPKG_ROOT Deve ser definido como a raiz da sua instalação VCPKG. Para obter mais informações, consulte Variáveis de ambiente vcpkg.

Se você já estiver usando um arquivo da cadeia de ferramentas CMake e quiser habilitar a integração vcpkg, consulte Usando vários arquivos da cadeia de ferramentas. Siga estas instruções para usar um arquivo de cadeia de ferramentas externo com um projeto usando vcpkg.

Substituição variável em launch.vs.json e tasks.vs.json

CMakePresets.json suporta a substituição de variáveis em launch.vs.json e tasks.vs.json. Aqui estão algumas considerações:

  • As variáveis de ambiente definidas na configuração ativa Predefinição fluem automaticamente para launch.vs.json e tasks.vs.json configurações. Você pode desdefinir variáveis de ambiente individuais em launch.vs.json e tasks.vs.json definindo-as como null. O exemplo a seguir define a variável DEBUG_LOGGING_LEVEL como null em launch.vs.json: "env": { "DEBUG_LOGGING_LEVEL": null }.

  • Os valores-chave definidos na configuração predefinida ativa estão disponíveis para consumo na launch.vs.json sintaxe e tasks.vs.json com a sintaxe ${cmake.<KEY-NAME>}. Por exemplo, use ${cmake.binaryDir} para fazer referência ao diretório de saída da predefinição de configuração ativa.

  • As variáveis de ambiente individuais definidas no mapa de ambiente da configuração predefinida ativa estão disponíveis para consumo na launch.vs.json sintaxe tasks.vs.jsone ${env.<VARIABLE-NAME>} por meio dela.

Atualize seus launch.vs.json e task.vs.json arquivos para fazer referência CMakePresets.json à sintaxe em vez da CMakeSettings.json sintaxe. As macros que fazem referência à sintaxe antiga CMakeSettings.json quando CMakePresets.json é o arquivo de configuração ativo estão programadas para substituição em uma versão futura. Por exemplo, faça referência ao diretório de saída do Ative Configure Preset com ${cmake.binaryDir} em vez de ${cmake.buildRoot}, porque CMakePresets.json usa a binaryDir sintaxe.

Solucionar problemas

Se as coisas não estiverem funcionando conforme o esperado, você pode tentar algumas etapas de solução de problemas.

Se um ou CMakePresets.jsonCMakeUserPresets.json for inválido, o Visual Studio recorrerá ao seu comportamento padrão e mostrará apenas as predefinições de configuração padrão. O Visual Studio IntelliSense pode ajudá-lo a detetar muitos desses erros JSON, mas ele não saberá se você está fazendo referência a uma predefinição com inherits ou configurePreset pelo nome errado.

Para verificar se os arquivos predefinidos são válidos, execute cmake --list-presets a partir da linha de comando na raiz do diretório do projeto. (CMake 3.20 ou posterior é necessário.) Se um dos arquivos for inválido, você verá o seguinte erro:

CMake Error: Could not read presets from
C:/Users/<user>/source/repos/<project-name>: JSON parse error

Outras etapas de solução de problemas incluem:

  • Exclua o cache e reconfigure o projeto (CMake: Delete Cache e Project>Configure <project-name>).
  • Feche e reabra a pasta no Visual Studio (File>Close Folder).
  • Exclua a .vs pasta na raiz do seu projeto.

Se você identificou um problema, a melhor maneira de relatá-lo é selecionando o botão Enviar Comentários no canto superior direito do Visual Studio.

Habilitar o registro em log para conexões remotas

Você pode habilitar o registro em log para conexões remotas se estiver tendo problemas para conectar ou copiar arquivos para um sistema remoto. Para obter mais informações, consulte Registro em log para conexões remotas.

Ativar AddressSanitizer para Windows e Linux

O Visual Studio suporta AddressSanitizer (ASAN), um detetor de erros de memória de tempo de execução C e C++, para desenvolvimento Windows e Linux. A addressSanitizerEnabled opção em CMakeSettings.json habilita AddressSanitizer. CMakePresets.json não suporta esse comportamento.

Em vez disso, habilite e desative o AddressSanitizer definindo o compilador necessário e os sinalizadores do vinculador você mesmo. Defini-los remove o comportamento específico do Visual Studio e garante que o mesmo CMakePresets.json arquivo possa reproduzir sua compilação a partir da linha de comando.

Você pode adicionar o seguinte exemplo para CMakeLists.txt habilitar ou desabilitar o AddressSanitizer para um destino:

option(ASAN_ENABLED "Build this target with AddressSanitizer" ON)

if(ASAN_ENABLED)
  if(MSVC)
    target_compile_options(<target> PUBLIC /fsanitize=address)
  else()
    target_compile_options(<target> PUBLIC -fsanitize=address <additional-options>)
    target_link_options(<target> PUBLIC -fsanitize=address)
  endif()
endif()

A <additional-options> parte lista outros sinalizadores de compilação, como "-fno-omit-frame-pointer". Para obter mais informações sobre AddressSanitizer para Linux, consulte Usando AddressSanitizer. Para obter mais informações sobre como usar o AddressSanitizer com MSVC, consulte Usar AddressSanitizer em um prompt de comando do desenvolvedor.

Passe sinalizadores de tempo de execução para AddressSanitizer usando o ASAN_OPTIONS campo em launch.vs.json. ASAN_OPTIONS padrão para detect_leaks=0 quando nenhuma outra opção de tempo de execução é especificada porque o LeakSanitizer não é suportado no Visual Studio.

Execute o CMake a partir da linha de comando ou de um pipeline de CI

Você pode usar o mesmo CMakePresets.json e CMakeUserPresets.json arquivos para invocar CMake no Visual Studio e a partir da linha de comando. A documentação CMake e CTest são os melhores recursos para invocar CMake e CTest com --preset. CMake versão 3.20 ou posterior é necessária.

Fornecendo o ambiente ao criar com geradores de linha de comando no Windows

Cabe ao usuário configurar o ambiente antes que o CMake seja invocado na construção com um gerador de linha de comando. Se você estiver criando com o Ninja e as Ferramentas de Compilação do Microsoft C++ no Windows, defina o ambiente antes que o CMake seja chamado para gerar o sistema de compilação. Você pode fazê-lo ligando vcvarsall.bat com o architecture argumento. O architecture argumento especifica a arquitetura de host e destino a ser usada. Para obter mais informações, consulte vcvarsall sintaxe. Se você compilar no Linux ou no Windows com um Visual Studio Generator, não precisará executar esta etapa.

É a mesma etapa que o Visual Studio leva para você quando o IDE invoca o CMake. O Visual Studio analisa a configuração predefinida ativa para a arquitetura de host e destino especificada por toolset e architecture. Em seguida, o Visual Studio origina o ambiente especificado de vcvarsall.bat. Quando você cria a partir da linha de comando do Windows com Ninja, você precisará dar esse passo sozinho.

vcvarsall.bat é instalado com as ferramentas de compilação para Visual Studio. Por padrão, vcvarsall.bat é instalado no C:\Program Files (x86)\Microsoft Visual Studio\2019\<edition>\VC\Auxiliary\Build. Você pode adicionar vcvarsall.bat se PATH usar o fluxo de trabalho de linha de comando com frequência.

Exemplo de fluxo de trabalho de linha de comando

Você pode usar os seguintes comandos para configurar e construir um projeto CMake que usa Ninja para direcionar ARM64 com ferramentas de compilação x64. CMake versão 3.20 ou posterior é necessária. Execute estes comandos a partir do diretório onde o CMakePresets.json arquivo está localizado:

/path/to/vcvarsall.bat x64_arm64 
cmake --list-presets=all .
cmake --preset <configurePreset-name>
cmake --build --preset <buildPreset-name>

Arquivo de exemplo CMakePresets.json

O CMakePresets.json arquivo no box2d-lite contém exemplos de Configurar Predefinições, Predefinições de Compilação e Predefinições de Teste. Para obter mais informações sobre este exemplo, consulte a apresentação An Introduction to CMakePresets.json. Você pode ver outro exemplo no projeto DirectXTK , que mostra muitos destinos de compilação em sua configurePresets seção.

Próximos passos

Saiba mais sobre como configurar e depurar projetos CMake no Visual Studio:

Projetos CMake no Visual Studio
Personalizar as configurações de compilação do CMake
Configurar sessões de depuração do CMake
Referência de configuração predefinida do CMake

  • Last updated on