Création d'applications Win32 (C++)

Mise à jour : novembre 2007

L'API Win32 (également appelée API Windows) est une infrastructure basée sur le langage C destinée à la création d'applications Windows et qui existe depuis Windows 1.0. Pour obtenir une documentation complète sur cette API, consultez API Windows.

Dans cette procédure, nous allons créer une application Win32 simple affichant « Hello, World » dans une fenêtre. Les étapes de la procédure sont identiques pour toutes les applications Win32. Après avoir complété cette procédure, vous pouvez utiliser le code que vous avez créé ici comme squelette pour créer toute autre application Win32.

Composants requis

Cette rubrique suppose que vous comprenez les notions de base du langage C++. Si vous commencez juste dans l'apprentissage de C++, nous vous recommandons de consulter le guide « C++ Beginner's Guide » (en anglais) écrit par Herb Schildt, disponible en ligne à l'adresse https://go.microsoft.com/fwlink/?LinkId=115303.

Pour une présentation vidéo, consultez la page Video How to: Creating Win32 Applications (C++) (Vidéo : Création d'une application Win32 (C++)).

Pour créer un nouveau projet Win32

1. Dans le menu Fichier, cliquez sur Nouveau, puis sur Projet....

2. Sélectionnez Win32 dans le nœud Visual C++ du volet Types de projets, puis sélectionnez Projet Win32 dans le volet Modèles.

   Tapez un nom pour le projet, tel que win32app. Vous pouvez accepter l'emplacement par défaut, taper un emplacement, ou naviguer jusqu'au répertoire où vous souhaitez enregistrer le projet.

3. Dans l'Assistant Application Win32, sélectionnez Suivant.

4. Dans l'Assistant Application Win32, sous Type d'application sélectionnez Applications Windows. Sous Options supplémentaires sélectionnez Projet vide. Laissez les options restantes telles qu'elles sont. Cliquez sur Terminer pour créer le projet.

5. Ajoutez un fichier C++ au projet en sélectionnant Ajouter un nouvel élément... dans le menu Projet. Dans la boîte de dialogue Ajouter un nouvel élément, sélectionnez Fichier C++ (.cpp). Tapez un nom pour le fichier, tel que GT_HelloWorldWin32.cppet cliquez sur Ajouter.

Pour démarrer une application Win32

1. Comme vous le savez, chaque application C et C++ doit avoir une fonction main. Cette fonction est le point de départ pour l'application. De même, chaque application doit avoir une fonction WinMain dans une application Win32. La syntaxe de WinMain est la suivante :

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

   Pour une explication des paramètres et de la valeur de retour de cette fonction, consultez Fonction WinMain.

2. En plus de WinMain, chaque application Win32 doit également avoir une deuxième fonction appelée généralement WndProc, qui représente la procédure de fenêtre. La syntaxe de WndProc est la suivante :

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

   Le but de cette fonction est de gérer tous les messages que votre application reçoit du système d'exploitation. Quand est-ce que votre application reçoit des messages du système d'exploitation ? Tout le temps ! Par exemple, imaginez que nous avons créé une boîte de dialogue contenant un bouton OK. Lorsque l'utilisateur clique sur ce bouton, le système d'exploitation envoie un message à notre application qui nous permet de savoir qu'un utilisateur a appuyé sur ce bouton. La fonction WndProc est chargée de répondre à cet événement. Dans notre exemple, la réponse appropriée peut être de fermer la boîte de dialogue.

   Pour plus d'informations, consultez Procédures de fenêtre.

Pour ajouter des fonctionnalités à WinMain

1. Commencez par créer à l'intérieur de la fonction WinMain une structure de classe de fenêtre de type WNDCLASSEX. Cette structure contient des informations concernant votre 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, le nom de fonction de la procédure de la fenêtre, et ainsi de suite. Voici une structure WNDCLASSEX classique :

       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(hInstance, MAKEINTRESOURCE(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, MAKEINTRESOURCE(IDI_APPLICATION));
   

   Pour obtenir une explication des champs de cette structure, consultez WNDCLASSEX.

2. Vous avez créé votre classe de fenêtre, il vous faut donc maintenant l'enregistrer. Utilisez la fonction RegisterClassEx et passez la structure de la classe de fenêtre en tant qu'argument :

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

3. Maintenant que vous avez enregistré votre classe, il est temps de créer une fenêtre. Utilisez la fonction CreateWindow comme suit :

   static TCHAR szWindowClass[] = _T("win32app");
   static TCHAR szTitle[] = _T("Win32 Guided Tour Application");
   // The parameters to CreateWindow explained:
   // 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 = CreateWindow(
       szWindowClass,
       szTitle,
       WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, CW_USEDEFAULT,
       500, 100,
       NULL,
       NULL,
       hInstance,
       NULL
   );
   if (!hWnd)
   {
       MessageBox(NULL,
           _T("Call to CreateWindow failed!"),
           _T("Win32 Guided Tour"),
           NULL);
   
       return 1;
   }
   

   Cette fonction retourne un HWND, qui est un handle à une fenêtre. Pour plus d'informations, consultez Types de données Windows.

4. Maintenant que nous avons créé la fenêtre, nous pouvons l'afficher à l'écran à l'aide du code suivant :

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

   Pour le moment, cette fenêtre ne s'affiche pas beaucoup, parce que nous n'avons pas encore implémenté la fonction WndProc.

5. La dernière étape de WinMain est la boucle de message. Le but de cette boucle est d'écouter les messages que le système d'exploitation envoie. Lorsque l'application reçoit un message, le message est distribué à la fonction WndProc pour le gérer. La boucle de message ressemble à ceci :

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

   Pour plus d'informations sur les structures et fonctions utilisées dans la boucle de message, consultez MSG, GetMessage, TranslateMessage et DispatchMessage.

6. Les étapes que vous venez de compléter sont communes à la plupart des applications Win32. À ce stade, votre fonction WinMain doit ressembler à ceci :

   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(hInstance, MAKEINTRESOURCE(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, MAKEINTRESOURCE(IDI_APPLICATION));
   
       if (!RegisterClassEx(&wcex))
       {
           MessageBox(NULL,
               _T("Call to RegisterClassEx failed!"),
               _T("Win32 Guided Tour"),
               NULL);
   
           return 1;
       }
   
       hInst = hInstance; // Store instance handle in our global variable
   
       // The parameters to CreateWindow explained:
       // 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 = CreateWindow(
           szWindowClass,
           szTitle,
           WS_OVERLAPPEDWINDOW,
           CW_USEDEFAULT, CW_USEDEFAULT,
           500, 100,
           NULL,
           NULL,
           hInstance,
           NULL
       );
   
       if (!hWnd)
       {
           MessageBox(NULL,
               _T("Call to CreateWindow failed!"),
               _T("Win32 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;
   }
   

Pour ajouter des fonctionnalités à WndProc

1. Le but de la fonction WndProc est de gérer des messages que votre application reçoit. Pour implémenter cela, il faut utiliser généralement une fonction de commutateur.

   Le premier message que nous allons gérer est le message WM_PAINT. Votre application reçoit ce message lorsqu'une partie de la fenêtre de votre application doit être mise à jour. Lorsqu'une fenêtre est créée pour la première fois, la fenêtre entière doit être mise à jour et ce message est passé pour indiquer cela.

   La première chose que vous devez faire lorsque vous gérez un message WM_PAINT est d'appeler BeginPaint et la dernière chose à faire est d'appeler EndPaint. Entre ces deux appels de fonction, vous devez gérer toute la logique pour disposer le texte, les boutons et les autres contrôles de votre fenêtre. Pour cette application, nous affichons la chaîne « Hello, World » dans la fenêtre. Pour afficher le texte, utilisez la fonction TextOut, comme indiqué ici :

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

2. Votre application gérera en général de nombreux autres messages, tels que WM_CREATE et WM_DESTROY. Une fonction WndProc simple mais complète suit :

   LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
   {
       PAINTSTRUCT ps;
       HDC hdc;
       TCHAR greeting[] = _T("Hello, World!");
   
       switch (message)
       {
       case WM_PAINT:
           hdc = BeginPaint(hWnd, &ps);
   
           // Here your application is laid out.
           // For this introduction, we just print out "Hello, World!"
           // 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;
   }
   

Exemple

Description

Après avoir terminé toutes les étapes, votre code doit ressembler à ce qui suit. Pour générer l'application, sélectionnez Générer la solution dans le menu Générer. Si votre application compile sans erreur, vous pouvez lancer l'application en appuyant sur F5. Une fenêtre simple avec le texte « Hello, World » sera affichée à l'écran près de l'angle supérieur gauche.

Code

// GT_HelloWorldWin32.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("win32app");

// The string that appears in the application's title bar.
static TCHAR szTitle[] = _T("Win32 Guided Tour Application");

HINSTANCE hInst;

// Forward declarations of functions included in this code module:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

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(hInstance, MAKEINTRESOURCE(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, MAKEINTRESOURCE(IDI_APPLICATION));

    if (!RegisterClassEx(&wcex))
    {
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Win32 Guided Tour"),
            NULL);

        return 1;
    }

    hInst = hInstance; // Store instance handle in our global variable

    // The parameters to CreateWindow explained:
    // 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 = CreateWindow(
        szWindowClass,
        szTitle,
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        500, 100,
        NULL,
        NULL,
        hInstance,
        NULL
    );

    if (!hWnd)
    {
        MessageBox(NULL,
            _T("Call to CreateWindow failed!"),
            _T("Win32 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, World!");

    switch (message)
    {
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);

        // Here your application is laid out.
        // For this introduction, we just print out "Hello, World!"
        // 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;
}

Étapes suivantes

Précédent :Création d'applications Windows (C++) | Suivant :Création d'une application Windows Forms à l'aide du .NET Framework (C++)

Voir aussi

Tâches

Création d'applications Windows (C++)