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

Cette procédure pas à pas explique 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 frameworks plus avancés et plus faciles à programmer ont été basés sur l’API Windows, par exemple, les frameworks MFC, ATL et .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

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

• 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 compréhension de base de l’utilisation de l’IDE 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.

• Vous connaissez bien le langage C++. 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. Ne collez pas les extraits de code individuels au fur et à mesure. Après avoir créé le projet, utilisez la source complète dans Générer le code.

Pour afficher les étapes de votre version préférée de Visual Studio, utilisez le sélecteur de version situé en haut de la table des matières de cette page.

Le code

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

Comment le programme s’adapte-t-il ?

Une application de bureau Windows traditionnelle utilise plusieurs éléments de code de configuration avant de pouvoir afficher une fenêtre :

Les extraits suivants se concentrent sur une partie du programme à la fois. La source complète combine les parties dans l’ordre approprié.

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 voyez é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 elle fonctionne est que vous utilisez plutôt la TCHAR macro dans votre code. TCHAR se résout en wchar_t lorsque votre projet définit le symbole UNICODE ; sinon, se résout en 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 présente ces deux instructions #include en haut 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 procédure pas à pas nomme la fonction WndProc, mais vous pouvez lui donner le nom de votre choix 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é. Cela s'appelle gérer 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 WinMain

Avant WinMain, déclarez les valeurs et la procédure de fenêtre que les autres parties du programme utilisent. Ces déclarations s’affichent avant WinMain dans la source complète :

// 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;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

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 cette structure, consultez WNDCLASSEX.

2. Une fois que vous avez rempli la structure, inscrivez-la WNDCLASSEX auprès de Windows afin qu’elle sache à propos de votre fenêtre et comment y envoyer des messages. Utilisez la fonction RegisterClassEx et transmettez la structure de la classe de fenêtre en tant qu’argument. La macro _T fait correspondre le littéral de chaîne au type de caractère sélectionné par TCHAR, comme décrit dans le passage précédent sur Unicode. 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. Créez une fenêtre à l’aide de la CreateWindowEx fonction.

   // 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, height)
   // NULL: the parent of this window
   // NULL: this application doesn't 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 un handle de fenêtre. Un handle s'apparente à 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 CreateWindowEx
   // 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, height)
      // NULL: the parent of this window
      // NULL: this application doesn't 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;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindowEx
      // 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
      // End application-specific layout section.
   
      EndPaint(hWnd, &ps);
      break;
   }
   

   Dans le code précédent, HDC est un descripteur d’un contexte de périphérique associé à la zone cliente de la fenêtre. Lorsque vous dessinez dans la fenêtre, utilisez cette poignée pour faire référence à la zone cliente. Utilisez les fonctions BeginPaint et EndPaint pour préparer et terminer le dessin dans la zone cliente. BeginPaint retourne un handle au contexte d’appareil d’affichage utilisé pour dessiner dans la zone cliente ; EndPaint met fin à la demande 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
         // 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 <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, height)
      // NULL: the parent of this window
      // NULL: this application doesn't 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;
      }
   
      // The parameters to ShowWindow explained:
      // hWnd: the value returned from CreateWindowEx
      // 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, static_cast<int>(_tcslen(greeting))); // TextOut expects an int here but _tcslen returns a size_t. Thus the cast.
         // 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, Windows desktop! doit apparaître.

   

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

Voir aussi

• Types d’applications de bureau Windows C++