Overzicht: Een traditionele Windows-bureaubladtoepassing maken (C++)

In deze handleiding wordt uitgelegd hoe je een traditionele Windows-bureaubladtoepassing maakt in Visual Studio. De toepassing die u maakt, maakt gebruik van de Windows-API om Hello, Windows-bureaublad! in een venster weer te geven. U kunt de code die u in dit scenario ontwikkelt als patroon gebruiken om Windows-bureaubladtoepassingen te maken.

De Windows-API (ook wel bekend als de Win32-API, Windows Desktop-API en de klassieke Windows-API) is een op C gebaseerde framework voor het maken van Windows-toepassingen. Het is al tientallen jaren gebruikt om Windows-toepassingen te maken. Meer geavanceerde en eenvoudiger te programmeren frameworks zijn gebouwd op de Windows-API, bijvoorbeeld de MFC-, ATL- en .NET-frameworks. Zelfs de modernste Windows Runtime-code voor UWP- en Store-apps die zijn geschreven in C++/WinRT maakt gebruik van de Windows-API eronder. Zie de Windows API-index voor meer informatie over de Windows-API.

Belangrijk

In de sectie Code bouwen aan het einde van dit artikel ziet u de volledige code. Deze handleiding behandelt de verschillende stukjes code die in een Windows-app worden geplaatst, maar sommige details worden weggelaten in de codefragmenten om je te focussen op de belangrijkste onderdelen. U kunt de volledige code kopiëren en aan het einde in uw project plakken.

Vereiste voorwaarden

• Microsoft Windows 7 of nieuwere versies. We raden Windows 11 of hoger aan voor de beste ontwikkelervaring.

• Visual Studio. Zie Visual Studio installeren voor meer informatie over het downloaden en installeren van Visual Studio. Wanneer u het installatieprogramma uitvoert, moet u ervoor zorgen dat de desktopontwikkeling met de C++ -workload is gecontroleerd. U hoeft zich geen zorgen te maken als u deze workload niet hebt geïnstalleerd toen u Visual Studio hebt geïnstalleerd. U kunt het installatieprogramma opnieuw uitvoeren en het nu installeren.

  

• Basiskennis van het gebruik van Visual Studio IDE. Als u eerder Windows-bureaublad-apps hebt gebruikt, kunt u het waarschijnlijk bijhouden. Zie Visual Studio IDE-functierondleiding voor een inleiding.

• Enige bekendheid met de C++-taal. Maak je geen zorgen, we doen niets te ingewikkeld.

Een Windows-bureaubladproject maken

Volg deze stappen om uw eerste Windows-bureaubladproject te maken. Zoals vermeld aan het begin van dit artikel, is de voltooide code beschikbaar in de sectie Code bouwen aan het einde van de handleiding. Volg de stappen voor het maken van het project, maar wacht met het plakken van de volgende codefragmenten tot het einde, wanneer de volledige applicatiecode wordt gepresenteerd. Sommige details worden weggelaten in de codefragmenten om u te richten op de belangrijkste onderdelen. U kunt de volledige code kopiëren en aan het einde in uw project plakken.

Als u de stappen voor de gewenste versie van Visual Studio wilt zien, gebruikt u de versieselector boven aan de inhoudsopgave op deze pagina.

Een Windows-bureaubladproject maken in Visual Studio

1. Kies bestand>nieuw>project in het hoofdmenu om het dialoogvenster Een nieuw project maken te openen.

2. Stel bovenaan het dialoogvenster Taal in op C++, stel Platform in op Windows en stel Projecttype in op Desktop.

3. Kies in de gefilterde lijst met projecttypen Windows-bureaubladwizard en kies vervolgens, Volgende. Voer op de volgende pagina een naam in voor het project, bijvoorbeeld DesktopApp.

4. Kies de knop Maken om het project te maken.

5. Het dialoogvenster Windows-bureaubladproject wordt nu weergegeven. Zorg ervoor dat u in de vervolgkeuzelijst Toepassingstypebureaubladtoepassing (.exe) selecteert. Aangezien we een Windows-toepassing maken, zal het kiezen van 'Consoletoepassing' resulteren in een project dat niet zal worden gebouwd met de code die we gaan gebruiken. Selecteer vervolgens onder Aanvullende opties de optie Leeg project. Kies OK om het project te maken.

6. Klik in Solution Explorer met de rechtermuisknop op het DesktopApp-project , kies Toevoegen en kies Vervolgens Nieuw item.

   

   De animatie toont het klikken met de rechtermuisknop op de projectnaam in Solution Explorer, het kiezen van Toevoegen in het menu dat wordt weergegeven en kies vervolgens Nieuw item.

7. Selecteer C++-bestand (.cpp) in het dialoogvenster Nieuw item toevoegen. Typ in het vak Naam bijvoorbeeld een naam voor het bestand HelloWindowsDesktop.cpp. Kies Toevoegen.

   

Uw project is nu gemaakt en het bronbestand wordt geopend in de editor.

De code

Leer vervolgens hoe u de code voor een Windows-bureaubladtoepassing maakt in Visual Studio.

Waar code wordt uitgevoerd in een Windows-bureaubladtoepassing

1. Net zoals elke C-toepassing en C++-toepassing een main functie als uitgangspunt moeten hebben, moet elke Windows-bureaubladtoepassing een WinMain functie hebben. WinMain heeft de volgende syntaxis.

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

   Zie Het WinMain-toegangspunt voor informatie over de parameters en de retourwaarde van deze functie.

   Opmerking

   Wat zijn al die extra woorden, zoals WINAPI, of CALLBACK, of HINSTANCE_In_? De traditionele Windows-API gebruikt typedefs en preprocessormacro's uitgebreid om enkele details van typen en platformspecifieke code weg te nemen, zoals aanroepen van conventies, __declspec declaraties en compilerpragma's. In Visual Studio kunt u de functie Snelle info van IntelliSense gebruiken om te zien wat deze typedefs en macro's definiëren. Beweeg de muisaanwijzer over het gewenste woord of selecteer het en druk op Ctrl+K, Ctrl+I voor een klein pop-upvenster met de definitie. Zie IntelliSense gebruiken voor meer informatie. Parameters en retourtypen gebruiken vaak SAL-aantekeningen om programmeerfouten te ondervangen. Zie SAL-aantekeningen gebruiken om C/C++ codefouten te verminderen voor meer informatie.

2. Windows-desktopapplicaties hebben <windows.h> nodig. U ziet ook vaak #include <tchar.h>. Dat is om het gemakkelijker te maken om een app te schrijven die kan werken met of charwchar_t. De manier waarop het werkt, is dat u in plaats daarvan de TCHAR macro in uw code gebruikt, die uiteindelijk wchar_t wordt omgezet als het UNICODE symbool in uw project is gedefinieerd, anders wordt dit omgezet in char. Als u altijd bouwt met UNICODE ingeschakeld, hebt u dat niet nodig TCHAR en kunt u gewoon rechtstreeks gebruiken wchar_t . Zie Algemene teksttoewijzingen gebruiken voor meer informatie. De volgende code toont deze twee #include instructies boven aan het bestand.

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

3. Naast de WinMain functie moet elke Windows-bureaubladtoepassing ook een vensterprocedurefunctie hebben. Deze functie wordt een WndProcgenoemd, maar u kunt deze elke gewenste naam geven in uw code. WndProc heeft de volgende syntaxis.

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

   In deze functie schrijft u code om berichten af te handelen die de toepassing ontvangt van Windows wanneer er gebeurtenissen optreden. Als een gebruiker bijvoorbeeld een knop OK in uw toepassing kiest, wordt er een bericht naar u verzonden. U schrijft code in een WndProc functie die al het nodige werk uitvoert. Het heet het verwerken van een gebeurtenis. U verwerkt alleen de gebeurtenissen die relevant zijn voor uw toepassing.

   Zie Vensterproceduresvoor meer informatie.

Functionaliteit toevoegen aan de WinMain functie

1. In de WinMain functie moet u enkele basisinformatie over uw hoofdvenster vastleggen. Dat doet u door een structuur van het type WNDCLASSEXin te vullen. De structuur bevat informatie over het venster, zoals het toepassingspictogram, de achtergrondkleur van het venster, de naam die moet worden weergegeven in de titelbalk, onder andere. Belangrijk is dat het een functiepointer bevat naar uw vensterprocedure die de berichten verwerkt die Door Windows naar uw app worden verzonden. In het volgende voorbeeld ziet u een typische WNDCLASSEX structuur:

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

   Zie voor meer informatie over de velden van deze structuur WNDCLASSEX.

2. Zodra u de structuur hebt ingevuld, registreert u deze WNDCLASSEX bij Windows zodat deze weet over uw venster en hoe u berichten naar het venster verzendt. Gebruik de RegisterClassEx functie en geef de structuur van de vensterklasse door als argument. De _T macro wordt gebruikt omdat we het TCHAR type gebruiken volgens de voorgaande discussie over Unicode. De volgende code laat zien hoe u de vensterklasse registreert.

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

3. Maak een venster met behulp van de CreateWindowEx functie.

   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, height)
   // 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;
   }
   

   Deze functie retourneert een HWND, een ingang naar een venster. Een handgreep lijkt enigszins op een aanwijzer. Windows gebruikt dit om de vensters bij te houden die u maakt. Zie Windows-gegevenstypen voor meer informatie.

4. Op dit moment is het venster gemaakt, maar we moeten Windows nog vertellen om het zichtbaar te maken. Dat is wat deze code doet:

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

   Het weergegeven venster is slechts een lege rechthoek omdat u de WndProc functie nog niet hebt geïmplementeerd. De toepassing verwerkt nog niet de berichten die windows naar de toepassing verzendt.

5. Om de berichten te verwerken, voegen we eerst een zogenaamde berichtenlus toe om te luisteren naar de berichten die Door Windows worden verzonden. Wanneer de toepassing een bericht ontvangt, verzendt deze lus deze naar uw WndProc functie die moet worden verwerkt. De berichtlus lijkt op de volgende code:

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

   Zie , MSGGetMessage en voor meer informatie over de structuren en functies in de berichtenlus DispatchMessage.

   Een basisfunctie WinMain waarmee het hoofdvenster van de toepassing wordt gemaakt en luistert naar berichten die door Windows uw app worden verzonden, lijkt op de volgende code:

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

Berichten in de WndProc functie verwerken

1. Als u berichten wilt verwerken die door de toepassing worden ontvangen, implementeert u een switch instructie in uw WndProc functie.

   Een belangrijk bericht dat moet worden verwerkt, is WM_PAINT. De toepassing ontvangt een WM_PAINT bericht wanneer een deel van het weergegeven venster moet worden bijgewerkt. De gebeurtenis kan optreden wanneer een gebruiker een venster voor uw venster verplaatst en deze weer weg verplaatst. Het ontvangt dit bericht de eerste keer dat uw venster wordt weergegeven, zodat u de gebruikersinterface van uw toepassing kunt weergeven. Uw toepassing vindt informatie over deze gebeurtenissen wanneer Windows deze verzendt. Wanneer het venster voor het eerst wordt weergegeven, moet het allemaal worden bijgewerkt.

   Als u een WM_PAINT bericht wilt afhandelen, roept u eerst aan BeginPainten verwerkt u vervolgens alle logica om de tekst, knoppen en andere besturingselementen in het venster in te delen. Roep vervolgens EndPaintaan. Voor deze toepassing wordt de code tussen BeginPaint() en EndPaint() weergegeven in het venster dat u hebt gemaakt in Hello, Windows desktop! met WinMain(). In de volgende code geeft de TextOut functie de tekst weer op de opgegeven locatie in het venster.

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

   In de voorgaande code HDC is een ingang voor een apparaatcontext die is gekoppeld aan het clientgebied van het venster. Wanneer u in het venster tekent, gebruikt u dit om naar het clientgebied te verwijzen. Gebruik de BeginPaint en EndPaint functies om de tekening in het clientgebied voor te bereiden en te voltooien. BeginPaint retourneert een verwijzing naar de weergaveapparaatcontext die wordt gebruikt voor tekenen in het clientgebied; EndPaint beëindigt de tekenaanroep en geeft de apparaatcontext vrij.

2. Een toepassing verwerkt doorgaans veel andere berichten. Wordt bijvoorbeeld WM_CREATE verzonden wanneer een venster voor het eerst wordt gemaakt en WM_DESTROY wanneer het venster wordt gesloten. De volgende code toont een eenvoudige maar volledige WndProc functie:

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

De code bouwen

Zoals beloofd, volgt de volledige code voor de werkende toepassing.

Om dit voorbeeld te bouwen

1. Verwijder alle code in HelloWindowsDesktop.cpp in de editor. Kopieer deze voorbeeldcode en plak deze in 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, height)
      // 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;
      }
   
      // 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, _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. Kies Build Solution in het menu Build. De resultaten van de compilatie worden weergegeven in het venster Uitvoer in Visual Studio.

   

   In de animatie ziet u dat u op de knop Alles opslaan klikt en vervolgens Build > Build Solution kiest in het hoofdmenu.

3. Druk op F5 om de toepassing uit te voeren. Er moet een venster met de tekst Hello, Windows desktop! worden weergegeven.

   

Gefeliciteerd! U hebt een traditionele Windows-bureaubladtoepassing gebouwd.

Zie ook

• Typen Windows C++-bureaubladtoepassingen