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

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie eine herkömmliche Windows-Desktopanwendung in Visual Studio erstellen. Die von Ihnen erstellte Anwendung verwendet die Windows-API, um "Hallo, Windows Desktop!" in einem Fenster anzuzeigen. 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. Beispielsweise MFC, ATL, .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.

Wichtig

Im Abschnitt Erstellen des Codes am Ende dieses Dokuments wird der vollständige Code gezeigt. Diese exemplarische Vorgehensweise deckt die verschiedenen Codeteile ab, die in eine Windows-Anwendung gehören. Sie werden jedoch nicht nach und nach codieren, da einige Details in den Codeschnipseln weggelassen wurden, um sich auf die wichtigsten Teile zu konzentrieren. Sie können den vollständigen Code kopieren und am Ende in Ihr Projekt einfügen.

Voraussetzungen

• Ein Computer, auf dem Microsoft Windows 7 oder eine höhere Version ausgeführt wird. Für ein optimales Entwicklungserlebnis empfehlen wir Windows 11 oder höher.

• Eine Kopie von 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++ aktiviert 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 die Workload jetzt installieren.

  

• Grundlegendes Verständnis der Verwendung der Visual Studio-IDE. Wenn Sie bereits früher Windows-Desktop-Apps verwendet haben, dürften keine Verständnisprobleme auftreten. Eine Einführung finden Sie unter Willkommen in der Visual Studio-IDE.

• Grundlegende Kenntnisse der Programmiersprache 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. Gemäß der Notiz am Anfang dieser exemplarischen Vorgehensweise ist der abgeschlossene Code im Abschnitt Code erstellen am Ende der exemplarischen Vorgehensweise verfügbar. Fahren Sie fort, und führen Sie die Schritte aus, um das Projekt zu erstellen, aber halten Sie das Einfügen der folgenden Codeabschnitte bis zum Ende, wenn der vollständige Anwendungscode angezeigt wird. Einige Details werden in den Codeausschnitten weggelassen, um sich auf die wichtigsten Teile zu konzentrieren. Sie können den vollständigen Code kopieren und am Ende in Ihr Projekt einfügen.

Um die Erläuterung zu vereinfachen. Um die Dokumentation für Ihre bevorzugte Version von Visual Studio anzuzeigen, verwenden Sie das Auswahlsteuerelement Version. Es befindet sich am Anfang des Inhaltsverzeichnisses auf dieser Seite.

So erstellen Sie ein Windows-Desktopprojekt in Visual Studio

1. Klicken Sie im Hauptmenü auf Datei>Neu>Projekt, um das Dialogfeld Neues Projekt erstellen zu öffnen.

2. Legen Sie oben im Dialogfeld die Sprache auf C++, die Plattform auf Windows und den Projekttyp auf Desktop fest.

3. Wählen Sie aus der gefilterten Projekttypliste Windows-Desktopassistent aus, und klicken Sie auf Weiter. Geben Sie auf der nächsten Seite einen Namen für das Projekt ein, z. B. DesktopApp.

4. Klicken Sie auf die Schaltfläche Erstellen, um das Projekt zu erstellen.

5. Der Windows-Desktopprojekt-Assistent wird angezeigt. Stellen Sie im Dropdownmenü Anwendungstyp sicher, dass Sie Desktopanwendung (.exe) auswählen. Da wir eine Windows-Anwendung erstellen, führt die Auswahl der Konsolenanwendung zu einem Projekt, das aufgrund des verwendeten Codes nicht erstellt wird. Wählen Sie unter Zusätzliche Optionen die Option Leeres Projekt aus. Klicken Sie auf OK, um das Projekt zu erstellen.

6. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das DesktopApp-Projekt, wählen Sie Hinzufügen und dann Neues Element aus.

   

   Die Animation zeigt, wie du im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen klickst, im angezeigten Menü „Hinzufügen“ und dann „Neues Element“ wählst.

7. Klicken Sie im Dialogfeld Neues Element hinzufügen auf C++-Datei (.cpp). Geben Sie im Feld Name" einen Namen für die Datei ein, wie z. B.HelloWindowsDesktop.cpp. Wählen Sie Hinzufügen aus.

   

Ihr Projekt wird jetzt erstellt, und die Quelldatei wird im Editor geöffnet.

Der Code

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

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-QuickInfo-Features sehen, welche Typen und Makros definiert sind. Zeigen Sie mit der Maus auf das interessante Wort, oder markieren Sie es, und drücken Sie STRG+K, STRG+I für ein kleines Popupfenster, das die Definition enthält. 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>. Sie werden auch #include <tchar.h> häufig sehen. Das erleichtert das Schreiben einer App, die mit einem char oder anderen wchar_tarbeiten kann. Die Funktionsweise besteht darin, dass Sie stattdessen das TCHAR Makro in Ihrem Code verwenden, das letztendlich wchar_t aufgelöst wird, wenn das UNICODE Symbol in Ihrem Projekt definiert ist, andernfalls wird es aufgelöst zu char. Wenn Sie immer mit UNICODE aktiviert sind, benötigen Sie TCHAR nicht und können einfach direkt wchar_t verwenden. Weitere Informationen finden Sie unter Verwendung von generischen Textzuordnungen. Der folgende Code zeigt die beiden folgenden #include Anweisungen am Anfang der Datei.

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

3. Neben der WinMain-Funktion muss jede Windows-Desktopanwendung auch über eine Fensterprozedurfunktion verfügen. Diese Funktion heißt WndProc, aber Sie können sie in Ihrem Code so nennen, wie Sie möchten. 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

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, und anderes. 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 der obigen Struktur finden Sie unter WNDCLASSEX.

2. Sobald Sie die Struktur WNDCLASSEX ausgefüllt haben, registrieren Sie sie bei Windows, so dass Windows über Ihr Fenster Bescheid weiß und weiß, wie es Nachrichten an es senden kann. Verwenden Sie die RegisterClassEx-Funktion, und übergeben Sie die Fensterklassenstruktur als Argument. Das _T Makro wird verwendet, da wir den TCHAR Typ gemäß der Diskussion zu Unicode oben verwenden. 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. Als Nächstes erstellen Sie ein Fenster mit der CreateWindowEx Funktion.

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

   Diese Funktion gibt einen HWND zurück, der ein Ziehpunkt für ein Fenster ist. Ein Ziehpunkt ähnelt einem 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 CreateWindow
   // 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 Meldung empfängt, wird die Meldung von der Schleife zur Behandlung an die WndProc-Funktion weitergeleitet. 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, 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;
   }
   

Behandeln von 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 dem Fenster verschiebt und es wieder weg verschiebt. Sie empfängt diese Meldung, wenn Das Fenster zum ersten Mal angezeigt wird, sodass Sie die Anwendungsbenutzeroberfläche anzeigen können. Ihre Anwendung findet diese Ereignisse beim Senden von Windows heraus. 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 wird der Code zwischen BeginPaint() und EndPaint() in dem Fenster angezeigt Hello, Windows desktop!, dass 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, _tcslen(greeting));
      // 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. Sie verwenden es beim Zeichnen im Fenster, um auf den Clientbereich zu verweisen. Verwenden Sie die BeginPaint-Funktionen, EndPaint um die Zeichnung im Clientbereich vorzubereiten und abzuschließen. BeginPaint gibt einen Handle an den Anzeigegerätekontext zurück, der zum Zeichnen im Clientbereich verwendet wird; EndPaint beendet die Paint-Anforderung und gibt den Gerätekontext frei.

2. Eine Anwendung behandelt in der Regel viele andere Nachrichten. Wird beispielsweise gesendet, WM_CREATE 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, _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;
   }
   

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 in HelloWindowsDesktop.cpp im Editor. Kopieren Sie diesen Beispielcode, und fügen Sie ihn in HelloWindowsDesktop.cpp ein:

   // 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. 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 "Hallo, Windows Desktop!" sollte angezeigt werden.

   

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

Weitere Informationen

Windows C++-Desktopanwendungstypen