Procédure pas à pas : utilisation de MSBuild pour créer un projet Visual C++

Article
12/22/2023

Cette procédure pas à pas montre comment utiliser MSBuild dans une invite de commandes pour générer un projet Visual Studio C++. Vous allez apprendre à créer un fichier projet XML .vcxproj pour une application console Visual C++. Après avoir généré le projet, vous allez découvrir comment personnaliser le processus de build.

Important

N’utilisez pas cette approche si vous envisagez de modifier le fichier projet ultérieurement à l’aide de l’IDE Visual Studio. Si vous créez un .vcxproj fichier manuellement, l’IDE Visual Studio peut ne pas être en mesure de le modifier ou de le charger, en particulier si le projet utilise des caractères génériques dans les éléments du projet. Pour plus d’informations, consultez et structure de fichiers et .vcxproj fichiers et caractères génériques. .props.vcxproj

Cette procédure pas à pas décrit les tâches suivantes :

Création des fichiers sources C++ de votre projet.
Création du fichier projet XML MSBuild.
Génération du projet à l’aide de MSBuild.
Personnalisation du projet à l’aide de MSBuild.

Prérequis

Vous avez besoin de ces prérequis pour effectuer cette procédure pas à pas :

Une copie de Visual Studio 2019 avec la charge de travail Développement Desktop en C++ installée.
Une compréhension générale du système MSBuild.

Remarque

La plupart des instructions de génération de bas niveau sont contenues dans les .targets fichiers définis .props sous le dossier cibles par défaut, stockés dans la propriété $(VCTargetsPath). C’est là que vous trouverez des fichiers tels que Microsoft.Cpp.Common.props. Le chemin d’accès par défaut de ces fichiers dans Visual Studio 2017 est sous %VSINSTALLDIR%Common7\IDE\VC\VCTargets\. Visual Studio 2015 et versions antérieures les ont stockées sous %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\<version>\.

Remarque

La plupart des instructions de génération de bas niveau sont contenues dans les .targets fichiers définis .props sous le dossier cibles par défaut, stockés dans la propriété $(VCTargetsPath). C’est là que vous trouverez des fichiers tels que Microsoft.Cpp.Common.props. Le chemin d’accès par défaut de ces fichiers est sous %VSINSTALLDIR%MSBuild\Microsoft\VC\<version>\. L’élément <version> path est spécifique à la version de Visual Studio. C’est v160 pour Visual Studio 2019. Visual Studio 2017 a stocké ces fichiers sous %VSINSTALLDIR%Common7\IDE\VC\VCTargets\. Visual Studio 2015 et versions antérieures les ont stockées sous %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\<version>\.

Créer les fichiers sources C++

Dans cette procédure pas à pas, vous allez créer un projet constitué d’un fichier source et d’un fichier d’en-tête. Le fichier main.cpp source contient la main fonction de l’application console. Le fichier d’en-tête main.h contient du code pour inclure le fichier d’en-tête <iostream> . Vous pouvez créer ces fichiers C++ à l’aide de Visual Studio ou d’un éditeur de texte comme Visual Studio Code.

Pour créer les fichiers sources C++ de votre projet

Créez un dossier pour votre projet.

Créez un fichier nommé main.cpp et ajoutez ce code au fichier :

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

Créez un fichier nommé main.h et ajoutez ce code au fichier :

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

Création du fichier projet XML MSBuild

Un fichier projet MSBuild est un fichier XML qui contient un élément racine de projet (<Project>). Dans l’exemple de projet que vous allez générer, l’élément <Project> contient sept éléments enfants :

Trois balises de groupe d’éléments (<ItemGroup>) qui spécifient la configuration et la plateforme du projet, le nom du fichier source et le nom du fichier d’en-tête.
Trois balises d’importation (<Import>) qui spécifient l’emplacement des paramètres de Microsoft Visual C++.
Une balise de groupe de propriétés (<PropertyGroup>) qui spécifie les paramètres du projet.

Pour créer le fichier projet MSBuild

Utilisez un éditeur de texte pour créer un fichier projet nommé myproject.vcxproj, puis ajoutez l’élément racine <Project> indiqué ici. (Utilisez ToolsVersion="14.0" si vous utilisez Visual Studio 2015, ToolsVersion="15.0" si vous utilisez Visual Studio 2017 ou ToolsVersion="16.0" si vous utilisez Visual Studio 2019.)
```
<Project DefaultTargets="Build" ToolsVersion="16.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
</Project>
```
Insérez les éléments dans les étapes de procédure suivantes entre les balises racines <Project> .

Ajoutez ces deux <ProjectConfiguration> éléments enfants dans un <ItemGroup> élément. L’élément enfant spécifie les configurations Debug et Release pour un système d’exploitation Windows 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>

Ajoutez un <Import> élément qui spécifie le chemin d’accès des paramètres C++ par défaut pour ce projet :
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.default.props" />
```
Ajoutez un élément de groupe de propriétés (<PropertyGroup>) qui spécifie deux propriétés de projet et <ConfigurationType> <PlatformToolset>. (Utilisez v140 la <PlatformToolset> valeur si vous utilisez Visual Studio 2015, v141 si vous utilisez Visual Studio 2017 ou v142 si vous utilisez Visual Studio 2019.)
```
<PropertyGroup>
  <ConfigurationType>Application</ConfigurationType>
  <PlatformToolset>v142</PlatformToolset>
</PropertyGroup>
```
Ajoutez un <Import> élément qui spécifie le chemin d’accès des paramètres C++ actuels pour ce projet :
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
```
Ajoutez un <ClCompile> élément enfant dans un <ItemGroup> élément. L’élément enfant spécifie le nom du fichier source C/C++ à compiler :
```
<ItemGroup>
  <ClCompile Include="main.cpp" />
</ItemGroup>
```
Remarque

<ClCompile> est une cible de build et est définie dans le dossier cibles par défaut.
Ajoutez un <ClInclude> élément enfant dans un <ItemGroup> élément. L’élément enfant spécifie le nom du fichier d’en-tête pour le fichier source C/C++ :
```
<ItemGroup>
  <ClInclude Include="main.h" />
</ItemGroup>
```
Ajoutez un <Import> élément qui spécifie le chemin d’accès du fichier qui définit la cible pour ce projet :
```
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Targets" />
```

Fichier projet complet

Ce code montre le fichier projet complet que vous avez créé dans la procédure précédente. (Utiliser ToolsVersion="15.0" pour Visual Studio 2017 ou ToolsVersion="14.0" pour Visual Studio 2015.)

<Project DefaultTargets="Build" ToolsVersion="16.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>

Générer votre projet à l’aide de MSBuild

Entrez cette commande à l’invite de commandes pour générer votre application console :

msbuild myproject.vcxproj /p:configuration=debug

MSBuild crée un dossier pour les fichiers de sortie, puis compile et lie votre projet pour générer le Myproject.exe programme. Une fois le processus de génération terminé, utilisez cette commande pour exécuter l’application à partir du dossier de débogage :

myproject

L’application doit afficher « Hello, from MSBuild ! » dans la fenêtre de console.

Personnalisation de votre projet

MSBuild vous permet d’exécuter des cibles de build prédéfinies, d’appliquer des propriétés définies par l’utilisateur et d’utiliser des outils, des événements et des étapes de build personnalisés. Cette section illustre ces tâches :

Utilisation de MSBuild avec des cibles de build.
Utilisation de MSBuild avec des propriétés de build.
Utilisation de MSBuild avec les outils et le compilateur 64 bits.
Utilisation de MSBuild avec des ensembles d’outils différents.
Ajout de personnalisations MSBuild.

Utilisation de MSBuild avec des cibles de build

Un cible de build est un jeu nommé de commandes prédéfinies ou définies par l’utilisateur qui peuvent être exécutées pendant la génération. Utilisez l’option de ligne de commande cible (/t) pour spécifier une cible de build. Pour l’exemple myproject de projet, la cible prédéfinie clean supprime tous les fichiers du dossier de débogage et crée un fichier journal.

À l’invite de commandes, entrez cette commande pour nettoyer myproject:

msbuild myproject.vcxproj /t:clean

Utilisation de MSBuild avec des propriétés de build

L’option de ligne de commande de propriété (/p) vous permet de remplacer une propriété dans votre fichier de build de projet. Dans l’exemple de projet myproject, la configuration de build Release ou Debug est spécifiée par la propriété Configuration. Le système d’exploitation que vous allez utiliser pour exécuter l’application générée est spécifié par la Platform propriété.

À l’invite de commandes, entrez cette commande pour créer une build de débogage de l’application myproject à exécuter sur Windows 32 bits :

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

Supposez que l’exemple de projet myproject définit aussi une configuration pour Windows 64 bits et une autre configuration pour un système d’exploitation personnalisé nommé myplatform.

À l’invite de commandes, entrez cette commande pour créer une build de mise en production qui s’exécute sur Windows 64 bits :

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

À l’invite de commandes, entrez cette commande pour créer une build de mise en production pour myplatform:

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

Utilisation de MSBuild avec les outils et le compilateur 64 bits

Si vous avez installé Visual Studio sur Windows 64 bits, les outils natifs et croisés 64 bits sont installés par défaut. Vous pouvez configurer MSBuild pour générer votre application à l’aide des outils et du compilateur 64 bits en définissant la propriété PreferredToolArchitecture. Cette propriété n’affecte pas la configuration du projet ou les propriétés de la plateforme. Par défaut, la version 32 bits des outils est utilisée. Pour spécifier la version 64 bits du compilateur et des outils, ajoutez cet élément de groupe de propriétés au Myproject.vcxproj fichier projet après l’élément Microsoft.Cpp.default.props de fichier <Import /> :

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

À l’invite de commandes, entrez cette commande pour utiliser les outils 64 bits pour générer votre application :

msbuild myproject.vcxproj /p:PreferredToolArchitecture=x64

Utilisation de MSBuild avec un ensemble d’outils différent

Si vous disposez des ensembles d’outils et de bibliothèques d’autres versions de Visual C++, MSBuild peut générer des applications pour la version actuelle de Visual C++ ou pour les autres versions installées. Par exemple, si vous avez installé Visual Studio 2012, pour spécifier l’ensemble d’outils Visual C++ 11.0 pour Windows XP, ajoutez cet élément de groupe de propriétés au Myproject.vcxproj fichier projet après l’élément Microsoft.Cpp.props de fichier <Import /> :

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

Pour reconstruire votre projet avec l’ensemble d’outils Windows XP Visual C++ 11.0, entrez cette commande :

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

Ajout de personnalisations MSBuild

MSBuild vous permet de personnaliser votre processus de build de différentes façons. Ces articles montrent comment ajouter des étapes de génération, des outils et des événements personnalisés à votre projet MSBuild :

Partager via