Exemplarische Vorgehensweise: Erstellen einer herkömmlichen Windows-Desktop Anwendung (C++)Walkthrough: Create a traditional Windows Desktop application (C++)

In dieser exemplarischen Vorgehensweise wird gezeigt, wie Sie eine herkömmliche Windows-Desktop Anwendung in Visual Studio erstellen.This walkthrough shows how to create a traditional Windows desktop application in Visual Studio. Die Beispielanwendung, die Sie erstellen, verwendet die Windows-API, um "Hello, Windows Desktop!" anzuzeigen.The example application you'll create uses the Windows API to display "Hello, Windows desktop!" in einem Fenster anzeigt.in a window. Sie können den Code verwenden, den Sie in dieser exemplarischen Vorgehensweise als Muster entwickeln, um andere Windows-Desktopanwendungen zu erstellen.You can use the code that you develop in this walkthrough as a pattern to create other Windows desktop applications.

Die Windows-API (auch als Win32-API, Windows-Desktop-API und Windows-Classic API bezeichnet) ist ein auf C-Sprache basierendes Framework zum Erstellen von Windows-Anwendungen.The Windows API (also known as the Win32 API, Windows Desktop API, and Windows Classic API) is a C-language-based framework for creating Windows applications. Es war seit den 80er Jahren vorhanden und wurde zum Erstellen von Windows-Anwendungen seit Jahrzehnten verwendet.It has been in existence since the 1980s and has been used to create Windows applications for decades. Erweiterte und leichter zu Programmende Frameworks wurden zusätzlich zur Windows-API erstellt.More advanced and easier-to-program frameworks have been built on top of the Windows API. Beispielsweise MFC, ATL, die .NET-Frameworks.For example, MFC, ATL, the .NET frameworks. Auch der modernste Windows-Runtime Code für UWP-und Store-Apps, die in C++ geschrieben sind/WinRT verwendet die Windows-API darunter.Even the most modern Windows Runtime code for UWP and Store apps written in C++/WinRT uses the Windows API underneath. Weitere Informationen zur Windows-API finden Sie unter Windows-API-Index.For more information about the Windows API, see Windows API Index. Es gibt viele Möglichkeiten, Windows-Anwendungen zu erstellen, aber der obige Prozess war der erste.There are many ways to create Windows applications, but the process above was the first.

Important

Aus Gründen der Übersichtlichkeit werden einige Code Anweisungen im Text ausgelassen.For the sake of brevity, some code statements are omitted in the text. Der Abschnitt Build the Code am Ende dieses Dokuments zeigt den gesamten Code.The Build the code section at the end of this document shows the complete code.

VoraussetzungenPrerequisites

  • Ein Computer, auf dem Microsoft Windows 7 oder eine höhere Version ausgeführt wird.A computer that runs Microsoft Windows 7 or later versions. Für ein optimales Entwicklungserlebnis empfehlen wir Windows 10.We recommend Windows 10 for the best development experience.

  • Eine Kopie von Visual Studio.A copy of Visual Studio. Informationen zum Herunterladen und Installieren von Visual Studio finden Sie unter Installieren von Visual Studio.For information on how to download and install Visual Studio, see Install Visual Studio. Wenn Sie das Installationsprogramm ausführen, stellen Sie sicher, dass die Workload Desktopentwicklung mit C++ aktiviert ist.When you run the installer, make sure that the Desktop development with C++ workload is checked. Machen Sie sich keine Sorgen, wenn Sie diese Workload beim Installieren von Visual Studio nicht installiert haben.Don't worry if you didn't install this workload when you installed Visual Studio. Sie können das Installationsprogramm erneut ausführen und die Workload jetzt installieren.You can run the installer again and install it now.

    Desktopentwicklung mit C++Desktop development with C++

  • Grundkenntnisse der Verwendung der Visual Studio-IDE.An understanding of the basics of using the Visual Studio IDE. Wenn Sie bereits früher Windows-Desktop-Apps verwendet haben, dürften keine Verständnisprobleme auftreten.If you've used Windows desktop apps before, you can probably keep up. Eine Einführung finden Sie unter Willkommen in der Visual Studio-IDE.For an introduction, see Visual Studio IDE feature tour.

  • Grundlegende Kenntnisse der Programmiersprache C++.An understanding of enough of the fundamentals of the C++ language to follow along. Keine Sorge: Wir verwenden keine allzu komplizierten Verfahren.Don't worry, we don't do anything too complicated.

Erstellen eines Windows-Desktop ProjektsCreate a Windows desktop project

Führen Sie diese Schritte aus, um Ihr erstes Windows-Desktop Projekt zu erstellen.Follow these steps to create your first Windows desktop project. Im folgenden geben Sie den Code für eine funktionierende Windows-Desktop Anwendung ein.As you go, you'll enter the code for a working Windows desktop application. Um die Dokumentation für Ihre bevorzugte Version von Visual Studio anzuzeigen, verwenden Sie das Auswahlsteuerelement Version.To see the documentation for your preferred version of Visual Studio, use the Version selector control. Es befindet sich am Anfang des Inhaltsverzeichnisses auf dieser Seite.It's found at the top of the table of contents on this page.

So erstellen Sie ein Windows-Desktop Projekt in Visual Studio 2019To create a Windows desktop project in Visual Studio 2019

  1. Klicken Sie im Hauptmenü auf Datei > Neu > Projekt, um das Dialogfeld Neues Projekt erstellen zu öffnen.From the main menu, choose File > New > Project to open the Create a New Project dialog box.

  2. Legen Sie am oberen Rand des Dialog Felds Sprache auf C++, legen Sie Platform auf Windowsfest, und legen Sie Projekttyp auf Desktopfest.At the top of the dialog, set Language to C++, set Platform to Windows, and set Project type to Desktop.

  3. Wählen Sie in der gefilterten Liste der Projekttypen die Option Windows-Desktop-Assistent und dann weiteraus.From the filtered list of project types, choose Windows Desktop Wizard then choose Next. Geben Sie auf der nächsten Seite einen Namen für das Projekt ein, z. b. desktopapp.In the next page, enter a name for the project, for example, DesktopApp.

  4. Klicken Sie auf die Schaltfläche Erstellen, um das Projekt zu erstellen.Choose the Create button to create the project.

  5. Das Dialogfeld Windows-Desktop Projekt wird jetzt angezeigt.The Windows Desktop Project dialog now appears. Wählen Sie unter Anwendungstypdie Option Desktop Anwendung (. exe) aus.Under Application type, select Desktop application (.exe). Wählen Sie unter Zusätzliche Optionendie Option Leeres Projektaus.Under Additional options, select Empty project. Klicken Sie auf OK, um das Projekt zu erstellen.Choose OK to create the project.

  6. Klicken Sie in Projektmappen-Explorermit der rechten Maustaste auf das Projekt desktopapp , wählen Sie Hinzufügenaus, und wählen Sie dann Neues Elementaus.In Solution Explorer, right-click the DesktopApp project, choose Add, and then choose New Item.

    Neues Element zum desktopapp-Projekt hinzufügenAdd new item to DesktopApp Project

  7. Klicken Sie im Dialogfeld Neues Element hinzufügen auf C++-Datei (.cpp).In the Add New Item dialog box, select C++ File (.cpp). Geben Sie im Feld Name einen Namen für die Datei ein, z. b. hellowindowsdesktop. cpp.In the Name box, type a name for the file, for example, HelloWindowsDesktop.cpp. Wählen Sie Hinzufügen aus.Choose Add.

    Cpp-Datei zum desktopapp-Projekt hinzufügenAdd .cpp file to DesktopApp Project

Das Projekt wird jetzt erstellt, und die Quelldatei wird im Editor geöffnet.Your project is now created and your source file is opened in the editor. Fahren Sie fort, indem Sie den Code erstellen.To continue, skip ahead to Create the code.

So erstellen Sie ein Windows-Desktop Projekt in Visual Studio 2017To create a Windows desktop project in Visual Studio 2017

  1. Wählen Sie im Menü Datei die Option Neu und anschließend Projekt aus.On the File menu, choose New and then choose Project.

  2. Erweitern Sie im Dialogfeld Neues Projekt im linken Bereich den Knoten installiert > Visual C++, und wählen Sie dann Windows-Desktopaus.In the New Project dialog box, in the left pane, expand Installed > Visual C++, then select Windows Desktop. Wählen Sie im mittleren Bereich die Option Windows-Desktop-Assistentaus.In the middle pane, select Windows Desktop Wizard.

    Geben Sie im Feld Name einen Namen für das Projekt ein, z. b. desktopapp.In the Name box, type a name for the project, for example, DesktopApp. Klicken Sie auf OK.Choose OK.

    Benennen des desktopapp-ProjektsName the DesktopApp project

  3. Wählen Sie im Dialogfeld Windows-Desktop Projekt unter Anwendungstypdie Option Windows-Anwendung (. exe) aus.In the Windows Desktop Project dialog, under Application type, select Windows application (.exe). Wählen Sie unter Zusätzliche Optionendie Option Leeres Projektaus.Under Additional options, select Empty project. Vergewissern Sie sich, dass der Vorkompilierte Header nicht ausgewähltMake sure Precompiled Header isn't selected. Klicken Sie auf OK, um das Projekt zu erstellen.Choose OK to create the project.

  4. Klicken Sie in Projektmappen-Explorermit der rechten Maustaste auf das Projekt desktopapp , wählen Sie Hinzufügenaus, und wählen Sie dann Neues Elementaus.In Solution Explorer, right-click the DesktopApp project, choose Add, and then choose New Item.

    Neues Element zum desktopapp-Projekt hinzufügenAdd new item to DesktopApp Project

  5. Klicken Sie im Dialogfeld Neues Element hinzufügen auf C++-Datei (.cpp).In the Add New Item dialog box, select C++ File (.cpp). Geben Sie im Feld Name einen Namen für die Datei ein, z. b. hellowindowsdesktop. cpp.In the Name box, type a name for the file, for example, HelloWindowsDesktop.cpp. Wählen Sie Hinzufügen aus.Choose Add.

    Cpp-Datei zum desktopapp-Projekt hinzufügenAdd .cpp file to DesktopApp Project

Das Projekt wird jetzt erstellt, und die Quelldatei wird im Editor geöffnet.Your project is now created and your source file is opened in the editor. Fahren Sie fort, indem Sie den Code erstellen.To continue, skip ahead to Create the code.

So erstellen Sie ein Windows-Desktop Projekt in Visual Studio 2015To create a Windows desktop project in Visual Studio 2015

  1. Wählen Sie im Menü Datei die Option Neu und anschließend Projekt aus.On the File menu, choose New and then choose Project.

  2. Erweitern Sie im Dialogfeld Neues Projekt im linken Bereich installierte > Vorlagen > Visual C++, und wählen Sie dann Win32aus.In the New Project dialog box, in the left pane, expand Installed > Templates > Visual C++, and then select Win32. Wählen Sie im mittleren Bereich Win32-Projektaus.In the middle pane, select Win32 Project.

    Geben Sie im Feld Name einen Namen für das Projekt ein, z. b. desktopapp.In the Name box, type a name for the project, for example, DesktopApp. Klicken Sie auf OK.Choose OK.

    Benennen des desktopapp-ProjektsName the DesktopApp project

  3. Wählen Sie auf der Seite Übersicht des Win32-Anwendungs-Assistentendie Option weiteraus.On the Overview page of the Win32 Application Wizard, choose Next.

    Übersicht über das Erstellen von Desktop-Apps im Win32-Anwendungs-AssistentenCreate DesktopApp in Win32 Application Wizard Overview

  4. Wählen Sie auf der Seite Anwendungseinstellungen unter Anwendungstypdie Option Windows-Anwendungaus.On the Application Settings page, under Application type, select Windows application. Deaktivieren Sie unter zusätzliche Optionen die Option vorkompilierter Header, und wählen Sie dann leeres Projektaus.Under Additional options, uncheck Precompiled header, then select Empty project. Klicken Sie auf Fertig stellen, um das Projekt zu erstellen.Choose Finish to create the project.

  5. Klicken Sie in Projektmappen-Explorermit der rechten Maustaste auf das Projekt desktopapp, wählen Sie Hinzufügenaus, und wählen Sie dann Neues Elementaus.In Solution Explorer, right-click the DesktopApp project, choose Add, and then choose New Item.

    Neues Element zum desktopapp-Projekt hinzufügenAdd new item to DesktopApp Project

  6. Klicken Sie im Dialogfeld Neues Element hinzufügen auf C++-Datei (.cpp).In the Add New Item dialog box, select C++ File (.cpp). Geben Sie im Feld Name einen Namen für die Datei ein, z. b. hellowindowsdesktop. cpp.In the Name box, type a name for the file, for example, HelloWindowsDesktop.cpp. Wählen Sie Hinzufügen aus.Choose Add.

    Cpp-Datei zum desktopapp-Projekt hinzufügenAdd .cpp file to DesktopApp Project

Das Projekt wird jetzt erstellt, und die Quelldatei wird im Editor geöffnet.Your project is now created and your source file is opened in the editor.

Erstellen des CodesCreate the code

Als Nächstes erfahren Sie, wie Sie den Code für eine Windows-Desktop Anwendung in Visual Studio erstellen.Next, you'll learn how to create the code for a Windows desktop application in Visual Studio.

So beginnen Sie eine Windows-DesktopanwendungTo start a Windows desktop application

  1. Ebenso wie jede C-Anwendung und C++-Anwendung über eine main Funktion als Ausgangspunkt verfügen muss, muss jede Windows-Desktop Anwendung über eine WinMain Funktion verfügen.Just as every C application and C++ application must have a main function as its starting point, every Windows desktop application must have a WinMain function. WinMain besitzt die folgende Syntax.WinMain has the following syntax.

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

    Informationen zu den Parametern und Rückgabe Werten dieser Funktion finden Sie unter WinMain Entry Point.For information about the parameters and return value of this function, see WinMain entry point.

    Note

    Was sind diese zusätzlichen Wörter, wie z. b. CALLBACK , oder HINSTANCE _In_ ?What are all those extra words, such as CALLBACK, or HINSTANCE, or _In_? Die herkömmliche Windows-API verwendet häufig Typedefs-und Präprozessormakros, um einige Details von Typen und Platt Form spezifischem Code, z. b. Aufruf Konventionen, __declspec Deklarationen und compilerpragmas, zu abstrahieren.The traditional Windows API uses typedefs and preprocessor macros extensively to abstract away some of the details of types and platform-specific code, such as calling conventions, __declspec declarations, and compiler pragmas. In Visual Studio können Sie die Funktion "IntelliSense Quick Info " verwenden, um zu sehen, was diese Typedefs und Makros definieren.In Visual Studio, you can use the IntelliSense Quick Info feature to see what these typedefs and macros define. Zeigen Sie mit der Maus auf das gewünschte Wort, oder wählen Sie es aus, und drücken Sie STRG + K, STRG + I für ein kleines Popup Fenster, das die Definition enthält.Hover your mouse over the word of interest, or select it and press Ctrl+K, Ctrl+I for a small pop-up window that contains the definition. Weitere Informationen finden Sie unter Verwenden von IntelliSense.For more information, see Using IntelliSense. Parameter und Rückgabe Typen verwenden oftmals SAL -Anmerkungen, um Programmierfehler zu erfassen.Parameters and return types often use SAL Annotations to help you catch programming errors. Weitere Informationen finden Sie unter Verwenden von Sal-Anmerkungen zum Reduzieren von C/C++-Code Fehlern.For more information, see Using SAL Annotations to Reduce C/C++ Code Defects.

  2. Für Windows-Desktop Programme ist < Windows. h> erforderlich.Windows desktop programs require <windows.h>. <Tchar. h> definiert das TCHAR Makro, das letztendlich in wchar_t aufgelöst wird, wenn das Unicode-Symbol im Projekt definiert ist. andernfalls wird es in charaufgelöst.<tchar.h> defines the TCHAR macro, which resolves ultimately to wchar_t if the UNICODE symbol is defined in your project, otherwise it resolves to char. Wenn Sie immer mit aktiviertem Unicode erstellen, benötigen Sie keinen TCHAR und können nur wchar_t direkt verwenden.If you always build with UNICODE enabled, you don't need TCHAR and can just use wchar_t directly.

    #include <windows.h>
    #include <tchar.h>
    
  3. Zusammen mit der WinMain -Funktion muss jede Windows-Desktop Anwendung auch über eine Fenster Prozedur Funktion verfügen.Along with the WinMain function, every Windows desktop application must also have a window-procedure function. Diese Funktion wird in der Regel mit dem WndProc Namen benannt, Sie können Sie aber beliebig benennen.This function is typically named WndProc, but you can name it whatever you like. WndProc besitzt die folgende Syntax.WndProc has the following syntax.

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

    In dieser Funktion schreiben Sie Code zum Verarbeiten von Nachrichten , die von Windows bei Auftreten von Ereignissen von Windows empfangen werden.In this function, you write code to handle messages that the application receives from Windows when events occur. Wenn ein Benutzer beispielsweise eine OK-Schaltfläche in der Anwendung auswählt, sendet Windows eine Meldung an Sie, und Sie können Code in Ihrer WndProc Funktion schreiben, der die entsprechenden Aufgaben erledigt.For example, if a user chooses an OK button in your application, Windows will send a message to you and you can write code inside your WndProc function that does whatever work is appropriate. Sie wird als Behandlung eines Ereignisses bezeichnet.It's called handling an event. Die Ereignisse, die für Ihre Anwendung relevant sind, werden nur behandelt.You only handle the events that are relevant for your application.

    Weitere Informationen finden Sie unter Window Procedures.For more information, see Window Procedures.

So fügen Sie der WinMain-Funktion Funktionen hinzuTo add functionality to the WinMain function

  1. In der- WinMain Funktion füllen Sie eine Struktur des Typs WNDCLASSEX.In the WinMain function, you populate a structure of type WNDCLASSEX. Die Struktur enthält Informationen über das Fenster: das Anwendungssymbol, die Hintergrundfarbe des Fensters, den Namen, der in der Titelleiste angezeigt werden soll.The structure contains information about the window: the application icon, the background color of the window, the name to display in the title bar, among other things. Wichtig ist, dass Sie einen Funktionszeiger auf die Fenster Prozedur enthält.Importantly, it contains a function pointer to your window procedure. Das folgende Beispiel zeigt eine typische WNDCLASSEX -Struktur.The following example shows a typical WNDCLASSEX structure.

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

    Weitere Informationen zu den Feldern der obigen Struktur finden Sie unter WNDCLASSEX.For information about the fields of the structure above, see WNDCLASSEX.

  2. Registrieren WNDCLASSEX Sie die bei Windows, damit Sie über Ihr Fenster informiert ist und wie Sie Nachrichten an das Fenster senden können.Register the WNDCLASSEX with Windows so that it knows about your window and how to send messages to it. Verwenden Sie die RegisterClassEx -Funktion, und übergeben Sie die Fensterklassenstruktur als Argument.Use the RegisterClassEx function and pass the window class structure as an argument. Das- _T Makro wird verwendet, da der-Typ verwendet wird TCHAR .The _T macro is used because we use the TCHAR type.

    if (!RegisterClassEx(&wcex))
    {
       MessageBox(NULL,
          _T("Call to RegisterClassEx failed!"),
          _T("Windows Desktop Guided Tour"),
          NULL);
    
       return 1;
    }
    
  3. Sie können nun ein Fenster erstellen.Now you can create a window. Verwenden Sie die CreateWindow -Funktion.Use the CreateWindow function.

    static TCHAR szWindowClass[] = _T("DesktopApp");
    static TCHAR szTitle[] = _T("Windows Desktop 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 does 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("Windows Desktop Guided Tour"),
          NULL);
    
       return 1;
    }
    

    Diese Funktion gibt einen zurück HWND , der ein Handle für ein Fenster ist.This function returns an HWND, which is a handle to a window. Ein Handle ähnelt einem Zeiger, den Windows verwendet, um geöffnete Fenster nachzuverfolgen.A handle is somewhat like a pointer that Windows uses to keep track of open windows. Weitere Informationen finden Sie unter Windows-Datentypen.For more information, see Windows Data Types.

  4. An diesem Punkt wurde das Fenster erstellt, aber wir müssen Windows darauf hinweisen, das Fenster sichtbar zu machen.At this point, the window has been created, but we still need to tell Windows to make it visible. Dies ist der folgende Code:That's what this code does:

    // 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 hat nicht viel Inhalt, weil Sie die Funktion noch nicht implementiert haben WndProc .The displayed window doesn't have much content because you haven't yet implemented the WndProc function. Anders ausgedrückt: die Anwendung verarbeitet die Nachrichten, die von Windows jetzt gesendet werden, noch nicht.In other words, the application isn't yet handling the messages that Windows is now sending to it.

  5. Zum Verarbeiten der Nachrichten fügen wir zuerst eine Nachrichten Schleife hinzu, um auf die von Windows gesendeten Nachrichten zu lauschen.To handle the messages, we first add a message loop to listen for the messages that Windows sends. Wenn die Anwendung eine Nachricht empfängt, sendet diese Schleife Sie an die WndProc Funktion, die behandelt werden soll.When the application receives a message, this loop dispatches it to your WndProc function to be handled. Die Nachrichtenschleife ähnelt dem folgenden Code.The message loop resembles the following code.

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

    Weitere Informationen über die in der Nachrichtenschleife verwendeten Strukturen und Funktionen finden Sie unter MSG, GetMessage, TranslateMessageund DispatchMessage.For more information about the structures and functions in the message loop, see MSG, GetMessage, TranslateMessage, and DispatchMessage.

    An diesem Punkt sollte die WinMain -Funktion in etwa dem folgenden Code entsprechen.At this point, the WinMain function should resemble the following 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(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 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("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;
    }
    

So fügen Sie der WndProc-Funktion Funktionen hinzuTo add functionality to the WndProc function

  1. Damit die WndProc -Funktion die Nachrichten behandeln kann, die von der Anwendung empfangen werden, implementieren Sie eine switch-Anweisung.To enable the WndProc function to handle the messages that the application receives, implement a switch statement.

    Eine wichtige zu behandelnde Nachricht ist die WM_PAINT Nachricht.One important message to handle is the WM_PAINT message. Die Anwendung empfängt die WM_PAINT Meldung, wenn ein Teil des angezeigten Fensters aktualisiert werden muss.The application receives the WM_PAINT message when part of its displayed window must be updated. Das Ereignis kann auftreten, wenn ein Benutzer ein Fenster vor dem Fenster bewegt und dann wieder entfernt.The event can occur when a user moves a window in front of your window, then moves it away again. Ihre Anwendung weiß nicht, wann diese Ereignisse eintreten.Your application doesn't know when these events occur. Nur Windows weiß, damit Ihre APP mit einer Meldung benachrichtigt wird WM_PAINT .Only Windows knows, so it notifies your app with a WM_PAINT message. Wenn das Fenster zum ersten Mal angezeigt wird, müssen alle Updates aktualisiert werden.When the window is first displayed, all of it must be updated.

    Rufen Sie zur Behandlung einer WM_PAINT -Nachricht zuerst BeginPaintauf, behandeln Sie anschließend die gesamte Logik, um das Layout von Text, Schaltflächen und anderen Steuerelementen im Fenster zu behandeln, und rufen Sie anschließend EndPaintauf.To handle a WM_PAINT message, first call BeginPaint, then handle all the logic to lay out the text, buttons, and other controls in the window, and then call EndPaint. Für die Anwendung wird in der Logik zwischen dem Anfangs-und dem Endbefehl die Zeichenfolge "Hello, Windows Desktop!" angezeigt.For the application, the logic between the beginning call and the ending call displays the string "Hello, Windows desktop!" im Fenster.in the window. Im folgenden Code wird die TextOut -Funktion verwendet, um die Zeichenfolge anzuzeigen.In the following code, the TextOut function is used to display the string.

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

    HDCim Code ist ein Handle für einen Gerätekontext, der zum Zeichnen im Client Bereich des Fensters verwendet wird.HDC in the code is a handle to a device context, which is used to draw in the window's client area. Verwenden BeginPaint Sie die EndPaint Funktionen und, um die Zeichnung im Client Bereich vorzubereiten und abzuschließen.Use the BeginPaint and EndPaint functions to prepare for and complete the drawing in the client area. BeginPaintGibt ein Handle für den Anzeigegeräte Kontext zurück, der zum Zeichnen im Client Bereich verwendet wird. EndPaintbeendet die Zeichnungs Anforderung und gibt den Gerätekontext frei.BeginPaint returns a handle to the display device context used for drawing in the client area; EndPaint ends the paint request and releases the device context.

  2. Eine Anwendung verarbeitet in der Regel viele andere Nachrichten.An application typically handles many other messages. Beispielsweise WM_CREATE , wenn ein Fenster erstmalig erstellt wird, und WM_DESTROY , wenn das Fenster geschlossen wird.For example, WM_CREATE when a window is first created, and WM_DESTROY when the window is closed. Der folgende Code zeigt eine grundlegende, jedoch vollständige WndProc -Funktion.The following code shows a basic but complete WndProc function.

    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 CodesBuild the code

Wie bereits versprochen, ist hier der gesamte Code für die funktionierende Anwendung aufgeführt.As promised, here's the complete code for the working application.

So erstellen Sie dieses BeispielTo build this example

  1. Löschen Sie den Code, den Sie in " hellowindowsdesktop. cpp " im Editor eingegeben haben.Delete any code you've entered in HelloWindowsDesktop.cpp in the editor. Kopieren Sie den folgenden Beispielcode, und fügen Sie ihn in " hellowindowsdesktop. cpp" ein:Copy this example code and then paste it into 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");
    
    HINSTANCE hInst;
    
    // Forward declarations of functions included in this code module:
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    
    int CALLBACK 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(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 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 does 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("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.On the Build menu, choose Build Solution. Die Ergebnisse der Kompilierung sollten im Fenster Ausgabe in Visual Studio angezeigt werden.The results of the compilation should appear in the Output window in Visual Studio.

    Erstellen des desktopapp-ProjektsBuild the DesktopApp Project

  3. Drücken Sie F5, um die Anwendung auszuführen.To run the application, press F5. Ein Fenster, das den Text "Hello, Windows Desktop!" enthält.A window that contains the text "Hello, Windows desktop!" sollte in der oberen linken Ecke der Anzeige angezeigt werden.should appear in the upper-left corner of the display.

    Ausführen des desktopapp-ProjektsRun the DesktopApp Project

Herzlichen Glückwunsch!Congratulations! Sie haben diese exemplarische Vorgehensweise abgeschlossen und eine herkömmliche Windows-Desktop Anwendung erstellt.You've completed this walkthrough and built a traditional Windows desktop application.

Weitere InformationenSee also

Windows-Desktop AnwendungenWindows Desktop Applications