Procédure pas à pas : Créer une application Windows Desktop traditionnelle (C++)

Ce guide montre comment créer une application de bureau Windows traditionnelle dans Visual Studio. L’application que vous créez utilise l’API Windows pour afficher « Hello, bureau Windows ! » dans une fenêtre. Vous pouvez utiliser le code que vous développez dans cette procédure pas à pas comme modèle pour créer des applications de bureau Windows.

L’API Windows (également connue sous le nom d’API Win32, d’API Windows Desktop et d’API Windows Classique) est une infrastructure de travail basé sur le langage C pour la création d’applications Windows. Il a été utilisé pour créer des applications Windows depuis des décennies. Des infrastructures plus avancées et plus faciles à programmer ont été basées sur l’API Windows. Par exemple, MFC, ATL, les infrastructures .NET. Même le code Windows Runtime le plus moderne pour les applications UWP et Store écrites en C++/WinRT utilise l’API Windows. Pour plus d’informations sur l’API Windows, voir Index de l’API Windows.

Prérequis

• Un ordinateur qui exécute Microsoft Windows 7 ou versions ultérieures. Nous recommandons Windows 11 ou une version ultérieure pour une meilleure expérience de développement.

• Une copie de Visual Studio. Pour plus d’informations sur le téléchargement et l’installation de Visual Studio, consultez Installer Visual Studio. Lorsque vous exécutez le programme d’installation, assurez-vous que la charge de travail développement Desktop en C++ est activée. Ne vous inquiétez pas si vous n’avez pas installé cette charge de travail en même temps que Visual Studio. Vous pouvez réexécuter le programme d’installation et l’installer maintenant.

  

• Une connaissance de base de l’utilisation de l’environnement de développement intégré (IDE) de Visual Studio. Si vous avez déjà utilisé des applications de bureau Windows, vous n’aurez probablement aucun mal à suivre. Pour une introduction, consultez Visite guidée des fonctionnalités de l’IDE Visual Studio.

• Une compréhension de suffisamment de notions de base du langage C++ pour pouvoir suivre. Ne vous inquiétez pas, nous ne faisons rien de bien compliqué.

Créer un projet de bureau Windows

Suivez les étapes suivantes pour créer votre premier projet de bureau Windows. Conformément à la remarque au début de cette procédure pas à pas, le code terminé est disponible dans la section Générer le code à la fin de la procédure pas à pas. Suivez les étapes de la création du projet, mais ne collez les sections de code suivantes qu’à la fin, lorsque le code complet de l’application est présenté. Certains détails sont omis dans les extraits de code afin de se concentrer sur les parties les plus importantes. Vous pouvez copier le code complet et le coller dans votre projet à la fin.

Pour simplifier l’explication. Pour consulter la documentation sur votre version préférée de Visual Studio, utilisez le contrôle de sélection de Version . Il se trouve en haut de la table des matières de cette page.

Code

Ensuite, vous apprendrez à créer le code d’une application de bureau Windows dans Visual Studio.

Où le code commence à s’exécuter dans une application de bureau Windows

1. Tout comme chaque application C et C++ doit avoir une mainfonction comme point de départ, chaque application de bureau Windows doit avoir une WinMain fonction. La syntaxe deWinMain est la suivante.

   int WINAPI WinMain(
      _In_ HINSTANCE hInstance,
      _In_opt_ HINSTANCE hPrevInstance,
      _In_ LPSTR     lpCmdLine,
      _In_ int       nCmdShow
   );
   

   Pour plus d’informations sur les paramètres et la valeur de retour de cette fonction, consultez Point d’entrée WinMain.

   Remarque

   Quels sont tous ces mots supplémentaires, tels que WINAPI, ou CALLBACK, ou HINSTANCE, ou _In_ ? L’API Windows traditionnelle utilise largement les typedefs et les macros de préprocesseur pour faire abstraction de certains détails des types et du code spécifique à la plate-forme, tels que les conventions d’appel, les déclarations __declspec et les pragmas du compilateur. Dans Visual Studio, vous pouvez utiliser la fonctionnalité d’informations rapides IntelliSense pour voir ce que ces typesdefs et macros définissent. Placez votre souris sur le mot d’intérêt ou sélectionnez-le, puis appuyez sur Ctrl+K, Ctrl+J pour une petite fenêtre contextuelle qui contient la définition. Pour plus d’informations, consultez Utilisation d’IntelliSense. Les paramètres et les types de retour utilisent souvent annotations SAL pour vous aider à intercepter les erreurs de programmation. Pour plus d’informations, voir Utilisation des annotations SAL pour réduire les défauts du code C/C++.

2. Les programmes de bureau Windows nécessitent <windows.h>. Vous verrez également fréquemment #include <tchar.h>. C’est pour faciliter l’écriture d’une application qui peut fonctionner avec char ou wchar_t. La façon dont il fonctionne est que vous utilisez plutôt la macro TCHAR dans votre code, qui se résout finalement à wchar_t si le symbole UNICODE est défini dans votre projet, sinon il se résout à char. Si vous générez toujours avec UNICODE activé, vous n’avez pas besoin de TCHAR et pouvez simplement utiliser wchar_t directement. Pour plus d’informations, consultez Utilisation de mappages de texte générique. Le code suivant montre ces deux instructions #include au début du fichier.

   #include <windows.h>
   #include <tchar.h>
   

3. Avec la fonction WinMain, chaque application de bureau Windows doit avoir une fonction de procédure de fenêtre. Cette fonction est appelée WndProc, mais vous pouvez lui donner le nom que vous aimez dans votre code. La syntaxe deWndProc est la suivante.

   LRESULT CALLBACK WndProc(
      _In_ HWND   hWnd,
      _In_ UINT   message,
      _In_ WPARAM wParam,
      _In_ LPARAM lParam
   );
   

   Dans cette fonction, vous écrivez du code pour gérer les messages que l’application reçoit de Windows quand événements se produisent. Par exemple, si un(e) utilisateur(-trice) choisit un bouton OK dans votre application, Windows vous envoie un message. Vous écrivez du code à l’intérieur d’une fonction WndProc qui effectue le travail approprié. Elle est appelée gestion un événement. Vous ne traitez que les événements pertinents pour votre application.

   Pour plus d’informations, consultez Window Procedures.

Ajouter une fonctionnalité à la fonction de langageWinMain

1. Dans cette fonction WinMain, vous devez capturer quelques informations de base sur votre fenêtre principale. Pour ce faire, remplissez une structure de type WNDCLASSEX. La structure contient des informations sur la fenêtre telles que l’icône de l’application, la couleur d’arrière-plan de la fenêtre, le nom à afficher dans la barre de titre, entre autres. Il est important de noter qu’il contient un pointeur de fonction vers votre procédure de fenêtre qui gère les messages que Windows envoie à votre application. L’exemple suivant montre une structure typique WNDCLASSEX :

   WNDCLASSEX wcex;
   
   wcex.cbSize         = sizeof(WNDCLASSEX);
   wcex.style          = CS_HREDRAW | CS_VREDRAW;
   wcex.lpfnWndProc    = WndProc;
   wcex.cbClsExtra     = 0;
   wcex.cbWndExtra     = 0;
   wcex.hInstance      = hInstance;
   wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
   wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
   wcex.lpszMenuName   = NULL;
   wcex.lpszClassName  = szWindowClass;
   wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   

   Pour plus d’informations sur les champs de la structure ci-dessus, voir WNDCLASSEX.

2. Une fois la structure WNDCLASSEX remplie, vous l’enregistrez auprès de Windows afin qu’il connaisse votre fenêtre et sache comment lui envoyer des messages. Utilisez la fonction RegisterClassEx et transmettez la structure de la classe de fenêtre en tant qu’argument. La macro _T est utilisée, car nous utilisons le type TCHAR conformément à la discussion sur Unicode ci-dessus. Le code suivant montre comment inscrire la classe de fenêtre.

   if (!RegisterClassEx(&wcex))
   {
      MessageBox(NULL,
         _T("Call to RegisterClassEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);
   
      return 1;
   }
   

3. Ensuite, vous créez une fenêtre à l’aide de la fonction CreateWindowEx.

   static TCHAR szWindowClass[] = _T("DesktopApp");
   static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
   
   // The parameters to CreateWindowEx explained:
   // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
   // szWindowClass: the name of the application
   // szTitle: the text that appears in the title bar
   // WS_OVERLAPPEDWINDOW: the type of window to create
   // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
   // 500, 100: initial size (width, length)
   // NULL: the parent of this window
   // NULL: this application does not have a menu bar
   // hInstance: the first parameter from WinMain
   // NULL: not used in this application
   HWND hWnd = CreateWindowEx(
   WS_EX_OVERLAPPEDWINDOW,
      szWindowClass,
      szTitle,
      WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, CW_USEDEFAULT,
      500, 100,
      NULL,
      NULL,
      hInstance,
      NULL
   );
   if (!hWnd)
   {
      MessageBox(NULL,
         _T("Call to CreateWindowEx failed!"),
         _T("Windows Desktop Guided Tour"),
         NULL);
   
      return 1;
   }
   

   Cette fonction retourne un HWND, qui est une poignée de fenêtre. Une poignée est un peu comme un pointeur. Windows l’utilise pour suivre les fenêtres que vous créez. Pour plus d'informations, consultez Types de données Windows.

4. À ce stade, la fenêtre a été créée, mais nous devons toujours indiquer à Windows de le rendre visible. C’est ce que fait ce code :

   // The parameters to ShowWindow explained:
   // hWnd: the value returned from CreateWindow
   // nCmdShow: the fourth parameter from WinMain
   ShowWindow(hWnd,
      nCmdShow);
   UpdateWindow(hWnd);
   

   La fenêtre affichée n’est qu’un rectangle vide, car vous n’avez pas encore implémenté la fonction WndProc. L’application ne traite pas encore les messages que Windows lui envoie maintenant.

5. Pour gérer les messages, nous ajoutons d’abord ce qu’on appelle une boucle de message pour écouter les messages envoyés par Windows. Lorsque l’application reçoit un message, cette boucle le transmet à votre fonction WndProc pour qu’elle le traite. La boucle de message ressemble au code suivant :

   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }
   
   return (int) msg.wParam;
   

   Pour plus d’informations sur les structures et les fonctions de la boucle de message, voir MSG, GetMessage, TranslateMessage, et DispatchMessage.

   Une fonction de base WinMain qui crée la fenêtre principale de l’application et écoute les messages que Windows envoie à votre application ressemble au code suivant :

   int WINAPI WinMain(HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPSTR lpCmdLine,
                      int nCmdShow)
   {
      WNDCLASSEX wcex;
   
      wcex.cbSize = sizeof(WNDCLASSEX);
      wcex.style          = CS_HREDRAW | CS_VREDRAW;
      wcex.lpfnWndProc    = WndProc;
      wcex.cbClsExtra     = 0;
      wcex.cbWndExtra     = 0;
      wcex.hInstance      = hInstance;
      wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
      wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
      wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
      wcex.lpszMenuName   = NULL;
      wcex.lpszClassName  = szWindowClass;
      wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   
      if (!RegisterClassEx(&wcex))
      {
         MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // Store instance handle in our global variable
      hInst = hInstance;
   
      // The parameters to CreateWindowEx explained:
      // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
      // szWindowClass: the name of the application
      // szTitle: the text that appears in the title bar
      // WS_OVERLAPPEDWINDOW: the type of window to create
      // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
      // 500, 100: initial size (width, length)
      // NULL: the parent of this window
      // NULL: this application dows not have a menu bar
      // hInstance: the first parameter from WinMain
      // NULL: not used in this application
      HWND hWnd = CreateWindowEx(
         WS_EX_OVERLAPPEDWINDOW,
         szWindowClass,
         szTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         500, 100,
         NULL,
         NULL,
         hInstance,
         NULL
      );
   
      if (!hWnd)
      {
         MessageBox(NULL,
            _T("Call to CreateWindow failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindow
      // nCmdShow: the fourth parameter from WinMain
      ShowWindow(hWnd, nCmdShow);
      UpdateWindow(hWnd);
   
      // Main message loop:
      MSG msg;
      while (GetMessage(&msg, NULL, 0, 0))
      {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }
   
      return (int) msg.wParam;
   }
   

Gérer les messages dans la fonction WndProc

1. Pour gérer les messages que l’application reçoit, vous implémentez une instruction switch dans votre fonction WndProc.

   Un message important à gérer est WM_PAINT. L’application reçoit ce message WM_PAINT quand une partie de sa fenêtre affichée doit être mise à jour. L’événement peut se produire lorsqu’un(e) utilisateur(-trice) déplace une fenêtre devant la vôtre, puis la déplace à nouveau. Il reçoit ce message lors du premier affichage de votre fenêtre, ce qui vous permet d’afficher l’interface utilisateur de votre application. Votre application découvre ces événements quand Windows les envoie. Lors de l’affichage initial de la fenêtre, tout son contenu doit être mis à jour.

   Pour gérer un message WM_PAINT, il faut d’abord appeler BeginPaint, puis gérer toute la logique de disposition du texte, des boutons et des autres contrôles dans la fenêtre. Appelez ensuite EndPaint. Pour cette application, le code entre BeginPaint() et EndPaint() affiche Hello, Windows desktop! dans la fenêtre que vous avez créée dans WinMain(). Dans le code suivant, la fonction TextOut affiche le texte à l’emplacement spécifié dans la fenêtre.

   PAINTSTRUCT ps;
   HDC hdc;
   TCHAR greeting[] = _T("Hello, Windows desktop!");
   
   switch (message)
   {
   case WM_PAINT:
      hdc = BeginPaint(hWnd, &ps);
   
      // Here your application is laid out.
      // For this introduction, we just print out "Hello, Windows desktop!"
      // in the top left corner.
      TextOut(hdc,
         5, 5,
         greeting, _tcslen(greeting));
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   Dans le code précédent, HDC est une poignée vers un contexte d’appareil associé à la zone cliente de la fenêtre. Vous l’utilisez lors du dessin dans la fenêtre pour faire référence à sa zone cliente. Utilisez les fonctions BeginPaint et EndPaint pour préparer et terminer le dessin dans la zone cliente. BeginPaint retourne une poignée au contexte d’appareil d’affichage utilisé pour dessiner dans la zone cliente; EndPaint met fin à la requête de peinture et libère le contexte de l’appareil.

2. Une application gère généralement de nombreux autres messages. Par exemple, WM_CREATE est envoyé lorsqu’une fenêtre est créée pour la première fois et WM_DESTROY lorsque la fenêtre est fermée. Le code suivant illustre une fonction WndProc de base, mais complète :

   LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
   {
      PAINTSTRUCT ps;
      HDC hdc;
      TCHAR greeting[] = _T("Hello, Windows desktop!");
   
      switch (message)
      {
      case WM_PAINT:
         hdc = BeginPaint(hWnd, &ps);
   
         // Here your application is laid out.
         // For this introduction, we just print out "Hello, Windows desktop!"
         // in the top left corner.
         TextOut(hdc,
            5, 5,
            greeting, _tcslen(greeting));
         // End application specific layout section.
   
         EndPaint(hWnd, &ps);
         break;
      case WM_DESTROY:
         PostQuitMessage(0);
         break;
      default:
         return DefWindowProc(hWnd, message, wParam, lParam);
         break;
      }
   
      return 0;
   }
   

Générer le code

Comme promis, le code complet de l’application de travail suit.

Pour générer cet exemple

1. Supprimez tout le code dans HelloWindowsDesktop.cpp dans l’éditeur. Copiez cet exemple de code et collez-le dans HelloWindowsDesktop.cpp :

   // HelloWindowsDesktop.cpp
   // compile with: /D_UNICODE /DUNICODE /DWIN32 /D_WINDOWS /c
   
   #include <windows.h>
   #include <stdlib.h>
   #include <string.h>
   #include <tchar.h>
   
   // Global variables
   
   // The main window class name.
   static TCHAR szWindowClass[] = _T("DesktopApp");
   
   // The string that appears in the application's title bar.
   static TCHAR szTitle[] = _T("Windows Desktop Guided Tour Application");
   
   // Stored instance handle for use in Win32 API calls such as FindResource
   HINSTANCE hInst;
   
   // Forward declarations of functions included in this code module:
   LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
   
   int WINAPI WinMain(
      _In_ HINSTANCE hInstance,
      _In_opt_ HINSTANCE hPrevInstance,
      _In_ LPSTR     lpCmdLine,
      _In_ int       nCmdShow
   )
   {
      WNDCLASSEX wcex;
   
      wcex.cbSize = sizeof(WNDCLASSEX);
      wcex.style          = CS_HREDRAW | CS_VREDRAW;
      wcex.lpfnWndProc    = WndProc;
      wcex.cbClsExtra     = 0;
      wcex.cbWndExtra     = 0;
      wcex.hInstance      = hInstance;
      wcex.hIcon          = LoadIcon(wcex.hInstance, IDI_APPLICATION);
      wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
      wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
      wcex.lpszMenuName   = NULL;
      wcex.lpszClassName  = szWindowClass;
      wcex.hIconSm        = LoadIcon(wcex.hInstance, IDI_APPLICATION);
   
      if (!RegisterClassEx(&wcex))
      {
         MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // Store instance handle in our global variable
      hInst = hInstance;
   
      // The parameters to CreateWindowEx explained:
      // WS_EX_OVERLAPPEDWINDOW : An optional extended window style.
      // szWindowClass: the name of the application
      // szTitle: the text that appears in the title bar
      // WS_OVERLAPPEDWINDOW: the type of window to create
      // CW_USEDEFAULT, CW_USEDEFAULT: initial position (x, y)
      // 500, 100: initial size (width, length)
      // NULL: the parent of this window
      // NULL: this application does not have a menu bar
      // hInstance: the first parameter from WinMain
      // NULL: not used in this application
      HWND hWnd = CreateWindowEx(
         WS_EX_OVERLAPPEDWINDOW,
         szWindowClass,
         szTitle,
         WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, CW_USEDEFAULT,
         500, 100,
         NULL,
         NULL,
         hInstance,
         NULL
      );
   
      if (!hWnd)
      {
         MessageBox(NULL,
            _T("Call to CreateWindow failed!"),
            _T("Windows Desktop Guided Tour"),
            NULL);
   
         return 1;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindow
      // nCmdShow: the fourth parameter from WinMain
      ShowWindow(hWnd,
         nCmdShow);
      UpdateWindow(hWnd);
   
      // Main message loop:
      MSG msg;
      while (GetMessage(&msg, NULL, 0, 0))
      {
         TranslateMessage(&msg);
         DispatchMessage(&msg);
      }
   
      return (int) msg.wParam;
   }
   
   //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
   //
   //  PURPOSE:  Processes messages for the main window.
   //
   //  WM_PAINT    - Paint the main window
   //  WM_DESTROY  - post a quit message and return
   LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
   {
      PAINTSTRUCT ps;
      HDC hdc;
      TCHAR greeting[] = _T("Hello, Windows desktop!");
   
      switch (message)
      {
      case WM_PAINT:
         hdc = BeginPaint(hWnd, &ps);
   
         // Here your application is laid out.
         // For this introduction, we just print out "Hello, Windows desktop!"
         // in the top left corner.
         TextOut(hdc,
            5, 5,
            greeting, _tcslen(greeting));
         // End application-specific layout section.
   
         EndPaint(hWnd, &ps);
         break;
      case WM_DESTROY:
         PostQuitMessage(0);
         break;
      default:
         return DefWindowProc(hWnd, message, wParam, lParam);
         break;
      }
   
      return 0;
   }
   

2. Dans le menu Générer , choisissez Générer la solution. Les résultats de la compilation apparaissent dans la fenêtre Sortie dans Visual Studio.

   

   L’animation montre que l’on clique sur le bouton Enregistrer tout, puis que l’on choisit Construire > Construire une solution dans le menu principal.

3. Pour exécuter l'application, appuyez sur F5. Une fenêtre avec le texte « Hello, Bureau Windows ! » doit apparaître.

   

Félicitations ! Vous avez créé une application de bureau Windows traditionnelle.

Voir aussi

Types d’applications de bureau Windows C++