Passo a passo: Usando o MSBuild para criar um projeto C++ do Visual Studio

Este passo a passo demonstra como usar o MSBuild em um prompt de comando para criar um projeto do Visual Studio C++. Você aprenderá como criar um arquivo de projeto baseado em .vcxproj XML para um aplicativo de console C++. Depois de criar o projeto, você aprenderá como personalizar o processo de compilação.

Importante

Não use essa abordagem se você pretende editar o arquivo de projeto posteriormente usando o IDE do Visual Studio. Se você criar um arquivo .vcxproj manualmente, o IDE do Visual Studio pode não ser capaz de editá-lo ou carregá-lo, especialmente se o projeto usa curingas em itens de projeto. Para obter mais informações, consulte .vcxproj e .props estrutura de arquivos e .vcxproj arquivos e caracteres universais.

Este passo a passo ilustra estas tarefas:

• Criando os arquivos de origem C++ para seu projeto.
• Criando o arquivo de projeto XML MSBuild.
• Usando o MSBuild para criar seu projeto.
• Usando o MSBuild para personalizar seu projeto.

Pré-requisitos

Você precisa destes pré-requisitos para concluir este passo a passo:

• Uma cópia do Visual Studio com a carga de trabalho Desenvolvimento para Desktop com C++ instalada.
• Uma compreensão geral do sistema MSBuild.

Observação

A maioria das instruções de compilação de baixo nível estão contidas nos arquivos .targets e .props definidos na pasta de destinos padrão, armazenados na propriedade $(VCTargetsPath). É onde você encontrará arquivos como Microsoft.Cpp.Common.props. O caminho padrão para esses arquivos está em %VSINSTALLDIR%MSBuild\Microsoft\VC\<version>\. O elemento caminho <version> é específico para a versão do Visual Studio. É v160 para o Visual Studio 2019. O Visual Studio 2017 armazenou esses arquivos em %VSINSTALLDIR%Common7\IDE\VC\VCTargets\. O Visual Studio 2015 e versões anteriores os armazenaram em %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\<version>\.

Criar os arquivos de origem C++

Neste passo a passo, você criará um projeto que tenha um arquivo de origem e um arquivo de cabeçalho. O arquivo de origem main.cpp contém a função main para o aplicativo de console. O arquivo de cabeçalho main.h contém código para incluir o arquivo de cabeçalho <iostream>. Você pode criar esses arquivos C++ usando o Visual Studio ou um editor de texto, como o Visual Studio Code.

Para criar os arquivos de origem C++ para seu projeto

1. Crie uma pasta para o seu projeto.

2. Crie um arquivo chamado main.cpp e adicione este código ao arquivo:

   // main.cpp : the application source code.
   #include <iostream>
   #include "main.h"
   int main()
   {
      std::cout << "Hello, from MSBuild!\n";
      return 0;
   }
   

3. Crie um arquivo chamado main.h e adicione este código ao arquivo:

   // main.h: the application header code.
   /* Additional source code to include. */
   

Criando o arquivo de projeto XML MSBuild

Um arquivo de projeto MSBuild é um arquivo XML que contém um elemento raiz do projeto (<Project>). No projeto de exemplo que você criará, o elemento <Project> contém sete elementos filho:

• Três tags de grupo de itens (<ItemGroup>) que especificam a configuração e a plataforma do projeto, o nome do arquivo de origem e o nome do arquivo de cabeçalho.
• Três marcas de importação (<Import>) que especificam o local das configurações do Microsoft C++.
• Uma etiqueta de grupo de propriedades (<PropertyGroup>) que especifica as configurações do projeto.

Para criar o arquivo de projeto MSBuild

1. Use um editor de texto para criar um arquivo de projeto chamado myproject.vcxproje, em seguida, adicione o elemento <Project> raiz mostrado aqui. (Use ToolsVersion="14.0" se você estiver usando o Visual Studio 2015, ToolsVersion="15.0" se estiver usando o Visual Studio 2017, ToolsVersion="16.0" se estiver usando o Visual Studio 2019 ou ToolsVersion="17.0" se estiver usando o Visual Studio 2022.)

   <Project DefaultTargets="Build" ToolsVersion="17.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   </Project>
   

   Insira os elementos nas próximas etapas do procedimento entre as tags raiz <Project>.

2. Adicione estes dois elementos filho <ProjectConfiguration> num elemento <ItemGroup>. O elemento filho especifica as configurações de depuração e lançamento para um sistema operacional Windows de 32 bits:

   <ItemGroup>
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|Win32">
       <Configuration>Release</Configuration>
       <Platform>Win32</Platform>
     </ProjectConfiguration>
   </ItemGroup>
   

3. Adicione um elemento <Import> que especifica o caminho das configurações padrão do C++ para este projeto:

   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
   

4. Adicione um elemento de grupo de propriedades (<PropertyGroup>) que especifica duas propriedades do projeto, <ConfigurationType> e <PlatformToolset>. (Use v140 como o valor <PlatformToolset> se estiver usando o Visual Studio 2015, v141 se estiver usando o Visual Studio 2017 v142 se estiver usando o Visual Studio 2019 ou v143 se estiver usando o Visual Studio 2022.)

   <PropertyGroup>
     <ConfigurationType>Application</ConfigurationType>
     <PlatformToolset>v143</PlatformToolset>
   </PropertyGroup>
   

5. Adicione um elemento <Import> que especifica o caminho das configurações C++ atuais para este projeto:

   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   

6. Adicione um elemento filho <ClCompile> em um elemento <ItemGroup>. O elemento filho especifica o nome do arquivo de origem C/C++ a ser compilado:

   <ItemGroup>
     <ClCompile Include="main.cpp" />
   </ItemGroup>
   

   Observação

   <ClCompile> é um destino de compilação e está definido na pasta de destinos padrão.

7. Adicione um elemento filho <ClInclude> em um elemento <ItemGroup>. O elemento filho especifica o nome do arquivo de cabeçalho para o arquivo de origem C/C++:

   <ItemGroup>
     <ClInclude Include="main.h" />
   </ItemGroup>
   

8. Adicione um elemento <Import> que especifica o caminho do arquivo que define o destino para este projeto:

   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Targets" />
   

Ficheiro de Projeto Completo

Este código mostra o arquivo de projeto completo que você criou no procedimento anterior. (Use ToolsVersion=16.0 for Visual Studio 2019, ToolsVersion="15.0" para Visual Studio 2017 ou ToolsVersion="14.0" para Visual Studio 2015.)

<Project DefaultTargets="Build" ToolsVersion="17.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <ProjectConfiguration Include="Debug|Win32">
      <Configuration>Debug</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
    <ProjectConfiguration Include="Release|Win32">
      <Configuration>Release</Configuration>
      <Platform>Win32</Platform>
    </ProjectConfiguration>
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
  <PropertyGroup>
    <ConfigurationType>Application</ConfigurationType>
    <PlatformToolset>v142</PlatformToolset>
  </PropertyGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
  <ItemGroup>
    <ClCompile Include="main.cpp" />
  </ItemGroup>
  <ItemGroup>
    <ClInclude Include="main.h" />
  </ItemGroup>
  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Targets" />
</Project>

Usando o MSBuild para criar seu projeto

Digite este comando no prompt de comando para criar seu aplicativo de console:

msbuild myproject.vcxproj /p:configuration=debug

MSBuild cria uma pasta para os arquivos de saída e, em seguida, compila e vincula seu projeto para gerar o programa Myproject.exe. Após a conclusão do processo de compilação, use este comando para executar o aplicativo a partir da pasta de depuração:

myproject

O aplicativo deve exibir "Olá, do MSBuild!" na janela do console.

Personalizando seu projeto

O MSBuild permite executar destinos de compilação predefinidos, aplicar propriedades definidas pelo usuário e usar ferramentas, eventos e etapas de compilação personalizados. Esta seção ilustra essas tarefas:

• Usando o MSBuild com objetivos de compilação.
• Usando MSBuild com propriedades de compilação.
• Usando MSBuild com o compilador de 64 bits e ferramentas.
• Usando o MSBuild com diferentes conjuntos de ferramentas.
• Adicionando personalizações do MSBuild.

Usando o MSBuild com destinos de compilação

Um alvo de compilação é um conjunto nomeado de comandos predefinidos ou definidos pelo utilizador que podem ser executados durante a compilação. Use a opção de linha de comando de destino (/t) para especificar um destino de compilação. Para o projeto de exemplo myproject, o destino clean predefinido exclui todos os arquivos na pasta de depuração e cria um novo arquivo de log.

No prompt de comando, digite este comando para limpar myproject:

msbuild myproject.vcxproj /t:clean

Usando o MSBuild com propriedades de compilação

A opção de linha de comando da propriedade (/p) permite que você substitua uma propriedade no arquivo de compilação do projeto. No projeto de exemplo myproject, a configuração de compilação de versão ou depuração é especificada pela propriedade Configuration. O sistema operacional que você usará para executar o aplicativo compilado é especificado pela propriedade Platform.

No prompt de comando, digite este comando para criar uma compilação de depuração do aplicativo myproject para ser executado no Windows de 32 bits:

msbuild myproject.vcxproj /p:configuration=debug /p:platform=win32

Suponha que o projeto de exemplo myproject também define uma configuração para o Windows de 64 bits e outra configuração para um sistema operacional personalizado chamado myplatform.

No prompt de comando, digite este comando para criar uma compilação de versão que seja executada no Windows de 64 bits:

msbuild myproject.vcxproj /p:configuration=release /p:platform=x64

No prompt de comando, digite este comando para criar uma compilação de versão para myplatform:

msbuild myproject.vcxproj /p:configuration=release /p:platform=myplatform

Usando o MSBuild com o compilador e as ferramentas de 64 bits

Se você tiver instalado o Visual Studio no Windows de 64 bits, as ferramentas nativas e cruzadas x64 de 64 bits serão instaladas por padrão. Você pode configurar o MSBuild para usar o compilador de 64 bits e as ferramentas para criar seu aplicativo definindo a propriedade PreferredToolArchitecture. Esta propriedade não afeta a configuração do projeto ou as propriedades da plataforma. Por padrão, a versão de 32 bits das ferramentas é usada. Para especificar a versão de 64 bits do compilador e das ferramentas, adicione este elemento de grupo de propriedades ao arquivo de projeto Myproject.vcxproj após o arquivo Microsoft.Cpp.default.props<Import /> elemento:

<PropertyGroup>
    <PreferredToolArchitecture>x64</PreferredToolArchitecture>
</PropertyGroup>

No prompt de comando, digite este comando para usar as ferramentas de 64 bits para criar seu aplicativo:

msbuild myproject.vcxproj /p:PreferredToolArchitecture=x64

Usando o MSBuild com um conjunto de ferramentas diferente

Se você tiver os conjuntos de ferramentas e bibliotecas para outras versões do Microsoft C++ (MSVC) instalado, MSBuild pode criar aplicativos para a versão atual do MSVC ou para as outras versões instaladas. Por exemplo, se você tiver instalado o Visual Studio 2012, para especificar o conjunto de ferramentas do Visual C++ 11.0 para Windows XP, adicione este elemento de grupo de propriedades ao arquivo de projeto Myproject.vcxproj após o arquivo Microsoft.Cpp.props<Import /> elemento:

<PropertyGroup>
    <PlatformToolset>v110_xp</PlatformToolset>
</PropertyGroup>

Para reconstruir seu projeto com o conjunto de ferramentas do Visual C++ 11.0 Windows XP, digite este comando:

msbuild myproject.vcxproj /p:PlatformToolset=v110_xp /t:rebuild

Adicionando personalizações do MSBuild

MSBuild fornece várias maneiras de personalizar seu processo de compilação. Estes artigos mostram como adicionar etapas de compilação personalizadas, ferramentas e eventos ao seu projeto MSBuild:

• Como: Adicionar uma etapa de compilação personalizada para projetos do MSBuild
• Como: Adicionar ferramentas de compilação personalizadas para projetos do MSBuild
• Como: Usar eventos de compilação em projetos do MSBuild

Ver também

• vcpkg em projetos MSBuild
• Tutorial: Instalar e usar pacotes com o MSBuild no Visual Studio