Exemplarische Vorgehensweise: Erstellen einer herkömmlichen Windows-Desktopanwendung (C++)

In dieser exemplarischen Vorgehensweise wird erläutert, wie Sie eine herkömmliche Windows-Desktopanwendung in Visual Studio erstellen. Die von Ihnen erstellte Anwendung verwendet die Windows-API zum Anzeigen von Hello, Windows Desktop! in einem Fenster. Sie können den Code verwenden, den Sie in dieser exemplarischen Vorgehensweise als Muster entwickeln, um andere Windows-Desktopanwendungen zu erstellen.

Die Windows-API (auch als Win32-API, Windows-Desktop-API und Windows Classic-API bezeichnet) ist ein C-sprachbasiertes Framework zum Erstellen von Windows-Anwendungen. Es wurde seit Jahrzehnten verwendet, um Windows-Anwendungen zu erstellen. Erweiterte und einfachere Programmierframeworks basieren auf der Windows-API, z. B. den MFC-, ATL- und .NET-Frameworks. Selbst der modernste Windows-Runtime-Code für UWP- und Store-Apps, die in C++/WinRT geschrieben wurden, verwendet die Windows-API darunter. Weitere Informationen zur Windows-API finden Sie unter Windows-API-Index.

Voraussetzungen

• Microsoft Windows 7 oder höhere Versionen. Für ein optimales Entwicklungserlebnis empfehlen wir Windows 11 oder höher.

• Visual Studio. Informationen zum Herunterladen und Installieren von Visual Studio finden Sie unter Installieren von Visual Studio. Wenn Sie das Installationsprogramm ausführen, stellen Sie sicher, dass die Workload Desktopentwicklung mit C++ ausgewählt ist. Machen Sie sich keine Sorgen, wenn Sie diese Workload beim Installieren von Visual Studio nicht installiert haben. Sie können das Installationsprogramm erneut ausführen und es jetzt installieren.

  

• Grundlegende Kenntnisse zur Verwendung der Visual Studio-IDE. Wenn Sie schon einmal Windows-Desktop-Apps verwendet haben, kommen Sie wahrscheinlich gut mit. Eine Einführung finden Sie unter Willkommen in der Visual Studio-IDE.

• Einige Kenntnisse in der Sprache C++. Keine Sorge: Wir verwenden keine allzu komplizierten Verfahren.

Erstellen eines Windows-Desktop-Projekts

Führen Sie die folgenden Schritte aus, um Ihr erstes Windows-Desktop-Projekt zu erstellen. Fügen Sie die einzelnen Codeausschnitte nicht nach und nach ein. Nachdem Sie das Projekt erstellt haben, verwenden Sie die vollständige Quelle im Code erstellen.

Um die Schritte für Ihre bevorzugte Version von Visual Studio anzuzeigen, verwenden Sie die Versionsauswahl oben im Inhaltsverzeichnis auf dieser Seite.

Der Code

Erfahren Sie als Nächstes, wie Sie den Code für eine Windows-Desktopanwendung in Visual Studio erstellen.

Wie das Programm zusammenpasst

Eine herkömmliche Windows Desktopanwendung verwendet mehrere Setupcodeelemente, bevor ein Fenster angezeigt werden kann:

Die folgenden Auszüge konzentrieren sich jeweils auf einen Teil des Programms. Die vollständige Quelle kombiniert die Teile in der richtigen Reihenfolge.

Wo Code in einer Windows-Desktopanwendung gestartet wird

1. Ebenso wie jede C- und C++-Anwendung als Ausgangspunkt eine main -Funktion benötigen, muss jede Windows-Desktopanwendung über eine WinMain-Funktion verfügen. WinMain besitzt die folgende Syntax.

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

   Informationen zu den Parametern und Rückgabewerten dieser Funktion finden Sie unter WinMain-Einstiegspunkt.

   Hinweis

   Was sind all diese zusätzlichen Wörter, z. B. WINAPI oder CALLBACK oder HINSTANCE oder _In_? Die herkömmliche Windows-API verwendet Typedefs und Präprozessormakros umfassend, um einige der Details von Typen und plattformspezifischem Code, z. B. Aufrufen von Konventionen, __declspec Deklarationen und Compiler-Pragmen, abstrahieren zu können. In Visual Studio können Sie mithilfe des IntelliSense-Features Quick Info anzeigen lassen, was diese Typedefs und Makros definieren. Bewegen Sie den Mauszeiger über das gewünschte Wort oder markieren Sie es und drücken Sie STRG+K, STRG+I, um ein kleines Pop-up-Fenster anzuzeigen, in dem die Definition angezeigt wird. Weitere Informationen finden Sie unter Verwenden von IntelliSense. Parameter und Rückgabetypen verwenden häufig SAL-Anmerkungen, um Programmierfehler abzufangen. Weitere Informationen finden Sie unter Verwenden von SAL-Anmerkungen zum Reduzieren von C/C++-Codefehlern.

2. Windows-Desktopprogramme erfordern <windows.h>. Es kommt außerdem häufig zu #include <tchar.h>. Das erleichtert das Schreiben einer App, die entweder mit char oder mit wchar_t funktionieren kann. Die Funktionsweise besteht darin, dass Sie stattdessen das TCHAR Makro in Ihrem Code verwenden. TCHAR wird zu wchar_t aufgelöst, wenn Ihr Projekt das Symbol UNICODE definiert; andernfalls wird es zu char aufgelöst. Wenn Sie immer mit aktivierter UNICODE-Unterstützung kompilieren, benötigen Sie TCHAR nicht und können stattdessen einfach direkt wchar_t verwenden. Weitere Informationen finden Sie unter Verwendung von generischen Textzuordnungen. Der folgende Code zeigt diese beiden #include Anweisungen oben in der Datei.

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

3. Neben der WinMain-Funktion muss jede Windows-Desktopanwendung auch über eine Fensterprozedurfunktion verfügen. In dieser Anleitung wird die Funktion WndProc genannt, aber Sie können ihr in Ihrem Code einen beliebigen Namen geben. WndProc besitzt die folgende Syntax.

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

   In dieser Funktion schreiben Sie Code zur Verarbeitung von Nachrichten, die die Anwendung von Windows empfängt, wenn Ereignisse auftreten. Wenn ein Benutzer beispielsweise eine Schaltfläche "OK" in Ihrer Anwendung auswählt, sendet Windows eine Nachricht an Sie. Sie schreiben Code in einer WndProc Funktion, die die entsprechenden Aufgaben ausführt. Das wird Verarbeitung eines Ereignisses genannt. Sie verarbeiten nur die Ereignisse, die für Ihre Anwendung relevant sind.

   Weitere Informationen finden Sie unter Window Procedures.

Hinzufügen von Funktionen zur WinMain Funktion

Vor WinMain deklarieren Sie die Werte und die Fensterprozedur, die von anderen Teilen des Programms verwendet werden. Diese Deklarationen werden vor der WinMain vollständigen Quelle angezeigt:

// 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. In der WinMain Funktion müssen Sie einige grundlegende Informationen zu Ihrem Hauptfenster erfassen. Dazu füllen Sie eine Struktur des Typs WNDCLASSEX aus. Die Struktur enthält Informationen zum Fenster, z. B. das Anwendungssymbol, die Hintergrundfarbe des Fensters, den Namen, der in der Titelleiste angezeigt werden soll, unter anderem. Wichtig ist, dass sie einen Funktionszeiger auf Ihre Fensterprozedur enthält, die die von Windows an Ihre App gesendeten Nachrichten verarbeitet. Das folgende Beispiel zeigt eine typische WNDCLASSEX-Struktur:

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

   Informationen zu den Feldern dieser Struktur finden Sie unter WNDCLASSEX.

2. Nachdem Sie die WNDCLASSEX Struktur ausgefüllt haben, registrieren Sie sie mit Windows, damit sie über Ihr Fenster informiert ist und wie Nachrichten an sie gesendet werden. Verwenden Sie die RegisterClassEx-Funktion, und übergeben Sie die Fensterklassenstruktur als Argument. Das Makro _T sorgt dafür, dass das Zeichenfolgenliteral dem von TCHAR ausgewählten Zeichentyp entspricht, wie in der vorangehenden Erläuterung zu Unicode beschrieben. Der folgende Code zeigt, wie die Fensterklasse registriert wird.

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

3. Erstellen Sie ein Fenster mithilfe der CreateWindowEx Funktion.

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

   Diese Funktion gibt ein HWND zurück, das ein Fensterhandle ist. Ein Handle ist so etwas wie ein Zeiger. Windows verwendet es, um die von Ihnen erstellten Fenster nachzuverfolgen. Weitere Informationen finden Sie unter Windows-Datentypen.

4. An diesem Punkt wurde das Fenster erstellt, aber wir müssen Windows dennoch mitteilen, dass es sichtbar gemacht wird. Dies ist die Funktionsweise dieses Codes:

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

   Das angezeigte Fenster ist nur ein leeres Rechteck, da Sie die WndProc Funktion noch nicht implementiert haben. Die Anwendung behandelt noch nicht die Nachrichten, die Windows jetzt an sie sendet.

5. Um die Nachrichten zu verarbeiten, fügen wir zunächst eine sogenannte Nachrichtenschleife hinzu, die auf die von Windows gesendeten Nachrichten wartet. Wenn die Anwendung eine Nachricht empfängt, leitet diese Schleife sie zur Verarbeitung an Ihre WndProc Funktion weiter. Die Nachrichtenschleife ähnelt dem folgenden Code:

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

   Weitere Informationen zu den Strukturen und Funktionen in der Nachrichtenschleife finden Sie unter MSG, GetMessage, TranslateMessage und DispatchMessage.

   Eine einfache WinMain-Funktion, die das Hauptfenster der Anwendung erstellt und Nachrichten überwacht, die Windows Ihrer App sendet, würde dem folgenden Code ähneln:

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

Behandeln Sie Nachrichten in der WndProc-Funktion

1. Um Nachrichten zu behandeln, die die Anwendung empfängt, implementieren Sie eine switch-Anweisung in Ihrer WndProc-Funktion.

   Eine wichtige Nachricht, die verarbeitet werden soll, ist WM_PAINT. Die Anwendung empfängt eine WM_PAINT-Nachricht, wenn ein Teil des angezeigten Fenster aktualisiert werden muss. Das Ereignis kann auftreten, wenn ein Benutzer ein Fenster vor Ihr Fenster schiebt und dieses anschließend wieder wegbewegt. Diese Meldung wird beim ersten Anzeigen Ihres Fensters empfangen, sodass Sie die Benutzeroberfläche Ihrer Anwendung anzeigen können. Ihre Anwendung erfährt von diesen Ereignissen, wenn Windows sie sendet. Wenn das Fenster erstmals angezeigt wird, muss es vollständig aktualisiert werden.

   Um eine WM_PAINT Nachricht zu verarbeiten, rufen Sie BeginPaint zuerst auf, und behandeln Sie dann alle Logik, um den Text, die Schaltflächen und andere Steuerelemente im Fenster anzulegen. Rufen Sie dann EndPaint auf. Für diese Anwendung zeigt der Code zwischen BeginPaint() und EndPaint()Hello, Windows desktop! in dem Fenster an, das Sie in WinMain() erstellt haben. Im folgenden Code zeigt die TextOut-Funktion den Text an der angegebenen Position im Fenster an.

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

   Im vorherigen Code HDC handelt es sich um ein Handle zu einem Gerätekontext, der dem Clientbereich des Fensters zugeordnet ist. Wenn Sie im Fenster zeichnen, verwenden Sie dieses Handle, um auf den Clientbereich zu verweisen. Verwenden Sie die Funktionen BeginPaint und EndPaint, um die Zeichnung im Clientbereich vorzubereiten und abzuschließen. BeginPaint gibt ein Handle für den Gerätekontext der Anzeige zurück, das zum Zeichnen im Clientbereich verwendet wird; EndPaint beendet die Zeichenanforderung und gibt den Gerätekontext frei.

2. Eine Anwendung behandelt in der Regel viele andere Nachrichten. Beispielsweise wird WM_CREATE gesendet, wenn ein Fenster zum ersten Mal erstellt wird, und WM_DESTROY, wenn das Fenster geschlossen wird. Der folgende Code zeigt eine grundlegende, jedoch vollständige WndProc -Funktion:

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

Erstellen des Codes

Wie versprochen, folgt der vollständige Code für die funktionierende Anwendung.

So erstellen Sie dieses Beispiel

1. Löschen Sie den gesamten Code im HelloWindowsDesktop.cpp Editor. Kopieren Sie diesen Beispielcode, und fügen Sie ihn in 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. Wählen Sie im Menü Erstellen die Option Projektmappe erstellen. Die Ergebnisse der Kompilierung werden im Ausgabefenster in Visual Studio angezeigt.

   

   Die Animation zeigt, dass Sie auf die Schaltfläche "Alle speichern" klicken und dann im Hauptmenü "Erstellen > Lösung erstellen" auswählen.

3. Drücken Sie F5, um die Anwendung auszuführen. Ein Fenster mit dem Text Hello, Windows desktop! sollte angezeigt werden.

   

Herzlichen Glückwunsch! Sie haben eine herkömmliche Windows-Desktopanwendung erstellt.

Siehe auch

• Windows C++-Desktopanwendungstypen