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 Beispielanwendung, die Sie erstellen, verwendet die Windows-API, um "Hello, 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 bekannt als Win32-API, Windows Desktop-API und Windows Klassische API) ist ein C-language-basiertes Framework zum Erstellen Windows Anwendungen. Es ist seit den 1980er Jahren vorhanden und wird verwendet, um Windows Anwendungen seit Jahrzehnten zu erstellen. Erweiterte und einfachere Programmframeworks wurden auf der Windows-API erstellt. Beispielsweise MFC, ATL, die .NET Frameworks. Selbst der modernste Windows-Runtime Code für UWP und Store Apps, die in C++/WinRT geschrieben wurden, verwendet die Windows-API unter. Weitere Informationen zur Windows-API finden Sie unter Windows API Index. Es gibt viele Möglichkeiten, Windows Anwendungen zu erstellen, aber der obige Prozess war der erste.

Wichtig

Im Text werden einige Codeanweisungen im Text ausgelassen. Der Codeabschnitt am Ende dieses Dokuments zeigt den vollständigen Code.

Voraussetzungen

  • Ein Computer, auf dem Microsoft Windows 7 oder eine höhere Version ausgeführt wird. Wir empfehlen Windows 10 oder höher für die beste Entwicklungserfahrung.

  • 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.

    Detail of the Desktop development with C++ workload in the Visual Studio Installer.

  • Grundkenntnisse 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 Desktopprojekts

Führen Sie die folgenden Schritte aus, um Ihr erstes Windows Desktopprojekt zu erstellen. Wie Sie gehen, geben Sie den Code für eine funktionierende Windows Desktopanwendung ein. 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 "Sprache auf C++" fest, legen Sie "Plattform auf Windows" fest, und legen Sie Project Typ auf Desktop fest.

  3. Wählen Sie aus der gefilterten Liste der Projekttypen die Option "Windows Desktop-Assistent" aus, und wählen Sie dann "Weiter" aus. 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. Das Dialogfeld Windows Desktop Project wird jetzt angezeigt. Wählen Sie unter "Anwendungstyp" Die Desktopanwendung (.exe) aus. Wählen Sie unter Zusätzliche Optionendie Option Leeres Projektaus. Klicken Sie auf OK, um das Projekt zu erstellen.

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

    Short video showing the user adding a new item to DesktopApp Project in Visual Studio 2019.

  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, z. B. HelloWindowsDesktop.cpp. Wählen Sie Hinzufügen aus.

    Screenshot of the Add New Item dialog box in Visual Studio 2019 with Installed > Visual C plus plus selected and the C plus plus File option highlighted.

Ihr Projekt wird jetzt erstellt und Die Quelldatei wird im Editor geöffnet. Um fortzufahren, wechseln Sie zum Erstellen des Codes.

So erstellen Sie ein Windows Desktopprojekt in Visual Studio 2017

  1. Wählen Sie im Menü Datei die Option Neu und anschließend Projekt aus.

  2. Erweitern Sie im Dialogfeld "Neue Project" im linken Bereich "InstallierteVisual>C++", und wählen Sie dann Windows Desktop aus. Wählen Sie im mittleren Bereich Windows Desktop-Assistenten aus.

    Geben Sie im Feld "Name " einen Namen für das Projekt ein, z. B. DesktopApp. Klicken Sie auf OK.

    Screenshot of the New Project dialog box in Visual Studio 2017 with Installed > Visual C plus plus > Windows Desktop selected, the Windows Desktop Wizard option highlighted, and DesktopApp typed in the Name text box.

  3. Wählen Sie im Dialogfeld Windows Desktop Project unter AnwendungstypWindows Anwendung (.exe) aus. Wählen Sie unter Zusätzliche Optionendie Option Leeres Projektaus. Stellen Sie sicher, dass vorkompilierte Kopfzeile nicht ausgewählt ist. Klicken Sie auf OK, um das Projekt zu erstellen.

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

    Short video showing the user adding a new item to DesktopApp Project in Visual Studio 2017.

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

    Screenshot of the Add New Item dialog box in Visual Studio 2017 with Installed > Visual C plus plus selected and the C plus plus File option highlighted.

Ihr Projekt wird jetzt erstellt und Die Quelldatei wird im Editor geöffnet. Um fortzufahren, wechseln Sie zum Erstellen des Codes.

So erstellen Sie ein Windows Desktopprojekt in Visual Studio 2015

  1. Wählen Sie im Menü Datei die Option Neu und anschließend Projekt aus.

  2. Erweitern Sie im Dialogfeld "Neues Project" im linken Bereich "InstalledTemplatesVisual>>C++", und wählen Sie dann "Win32" aus. Wählen Sie im mittleren Bereich Win32-Projektaus.

    Geben Sie im Feld "Name " einen Namen für das Projekt ein, z. B. DesktopApp. Klicken Sie auf OK.

    Screenshot of the New Project dialog box in Visual Studio 2015 with Installed > Templates > Visual C plus plus > Win32 selected, the Win32 Project option highlighted, and DesktopApp typed in the Name text box.

  3. Wählen Sie auf der Seite "Übersicht " des Win32-Anwendungs-Assistentendie Option "Weiter" aus.

    Create DesktopApp in Win32 Application Wizard Overview page.

  4. Wählen Sie auf der Seite "Anwendung Einstellungen" unter "Anwendungstyp" Windows Anwendung aus. Deaktivieren Sie unter "Zusätzliche Optionen" die Option "Vorkompilierte Kopfzeile", und wählen Sie dann "Projekt leer" aus. Klicken Sie auf Fertig stellen, um das Projekt zu erstellen.

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

    Short video showing the user adding a new item to DesktopApp Project in Visual Studio 2015.

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

    Screenshot of the Add New Item dialog box in Visual Studio 2015 with Installed > Visual C plus plus selected and the C plus plus File option highlighted.

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

Erstellen des Codes

Als Nächstes erfahren Sie, wie Sie den Code für eine Windows Desktopanwendung in Visual Studio erstellen.

So beginnen Sie eine Windows-Desktopanwendung

  1. Genauso wie jede C-Anwendung und C++-Anwendung eine main Funktion als Ausgangspunkt haben muss, 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ückgabewert dieser Funktion finden Sie im WinMain-Einstiegspunkt.

    Hinweis

    Was sind alle diese zusätzlichen Wörter, zWINAPI. B. , oder , oder CALLBACKHINSTANCE?_In_ Die traditionelle Windows-API verwendet Typdefs und Preprocessor-Makros umfassend, um einige der Details von Typen und plattformspezifischem Code zu abstrahieren, z. B. Aufrufkonventionen, __declspec Deklarationen und Compiler pragmas. In Visual Studio können Sie das IntelliSense Quick Info-Feature verwenden, um zu sehen, welche Typen und Makros diese Typen und Makros definieren. Zeigen Sie mit der Maus auf das Wort des Interesses, oder wählen Sie es aus, und drücken Sie STRGK, STRGI++ 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 zu erfassen. Weitere Informationen finden Sie unter Verwenden von SAL-Anmerkungen zum Reduzieren von C/C++-Codefehlern.

  2. Windows Desktopprogramme erfordern <windows.h>. <tchar.h>definiert das TCHAR Makro, das letztendlich wchar_t aufgelöst wird, wenn das UNICODE-Symbol in Ihrem Projekt definiert ist, andernfalls wird es aufgelöst.char Wenn Sie immer mit UNICODE aktiviert sind, benötigen Sie TCHAR nicht und können sie einfach direkt verwenden wchar_t .

    #include <windows.h>
    #include <tchar.h>
    
  3. Zusammen mit der WinMain Funktion muss jede Windows Desktopanwendung auch über eine Fensterprozedurfunktion verfügen. Diese Funktion wird in der Regel benannt WndProc, aber Sie können sie so benennen, 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 zum Behandeln von Nachrichten, die die Anwendung von Windows empfängt, wenn Ereignisse auftreten. Wenn ein Benutzer z. B. eine OK-Schaltfläche in Ihrer Anwendung auswäht, sendet Windows eine Nachricht an Sie, und Sie können Code in Ihrer WndProc Funktion schreiben, die die entsprechende Arbeit ausführt. Es wird als Behandlung eines Ereignisses bezeichnet. Sie behandeln nur die Ereignisse, die für Ihre Anwendung relevant sind.

    Weitere Informationen finden Sie unter Window Procedures.

So fügen Sie der WinMain-Funktion Funktionen hinzu

  1. In der WinMain Funktion füllen Sie eine Struktur vom Typ WNDCLASSEX auf. Die Struktur enthält Informationen zum Fenster: das Anwendungssymbol, die Hintergrundfarbe des Fensters, den Namen, der in der Titelleiste angezeigt werden soll, unter anderem. Wichtig ist, dass es einen Funktionszeiger auf Ihre Fensterprozedur enthält. 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. Registrieren Sie sich mit WNDCLASSEX Windows, damit sie über Ihr Fenster weiß und wie Nachrichten an sie gesendet werden. Verwenden Sie die RegisterClassEx -Funktion, und übergeben Sie die Fensterklassenstruktur als Argument. Das _T Makro wird verwendet, da wir den TCHAR Typ verwenden.

    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. Verwenden Sie die 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 HWNDHandle für ein Fenster zurück. Ein Handle ist etwas wie ein Zeiger, der Windows verwendet, um offene Fenster nachzuverfolgen. Weitere Informationen finden Sie unter Windows-Datentypen.

  4. An diesem Punkt wurde das Fenster erstellt, aber wir müssen Windows mitteilen, um es sichtbar zu machen. Das macht dieser Code:

    // 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 verfügt nicht über viel Inhalt, da Sie die WndProc Funktion noch nicht implementiert haben. Anders ausgedrückt: Die Anwendung behandelt noch nicht die Nachrichten, die Windows jetzt an sie senden.

  5. Um die Nachrichten zu behandeln, fügen wir zunächst eine Nachrichtenschleife hinzu, um auf die Nachrichten zu hören, die Windows gesendet werden. Wenn die Anwendung eine Nachricht empfängt, wird sie von dieser Schleife an die WndProc zu behandelnde Funktion verteilt. Die Nachrichtenschleife ähnelt dem folgenden 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.

    An diesem Punkt sollte die WinMain -Funktion in etwa dem folgenden Code entsprechen.

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

So fügen Sie der WndProc-Funktion Funktionen hinzu

  1. Damit die WndProc -Funktion die Nachrichten behandeln kann, die von der Anwendung empfangen werden, implementieren Sie eine switch-Anweisung.

    Eine wichtige Nachricht, die behandelt werden soll, ist die WM_PAINT Nachricht. Die Anwendung empfängt die WM_PAINT Nachricht, wenn ein Teil des angezeigten Fensters aktualisiert werden muss. Das Ereignis kann auftreten, wenn ein Benutzer ein Fenster vor dem Fenster verschiebt, dann wird es wieder entfernt. Ihre Anwendung weiß nicht, wann diese Ereignisse auftreten. Nur Windows weiß, sodass sie Ihre App mit einer WM_PAINT Nachricht benachrichtigt. Wenn das Fenster zuerst angezeigt wird, muss alles aktualisiert werden.

    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. Für die Anwendung zeigt die Logik zwischen dem Anfangsaufruf und dem Endaufruf die Zeichenfolge "Hello, Windows Desktop!" im Fenster an. Im folgenden Code wird die TextOut-Funktion verwendet, um die Zeichenfolge anzuzeigen.

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

    HDC im Code ist ein Handle für einen Gerätekontext, der zum Zeichnen im Clientbereich des Fensters verwendet wird. 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 für die Zeichnung 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. Beispielsweise WM_CREATE , wenn ein Fenster zuerst 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, ist hier der vollständige Code für die funktionierende Anwendung.

So erstellen Sie dieses Beispiel

  1. Löschen Sie den code, den Sie in HelloWindowsDesktop.cpp im Editor eingegeben haben. Kopieren Sie diesen Beispielcode, und fügen Sie ihn dann 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 sollten im Ausgabefenster in Visual Studio angezeigt werden.

    Animation showing the steps to build the DesktopApp Project.

  3. Drücken Sie F5, um die Anwendung auszuführen. Ein Fenster, das den Text "Hello, Windows Desktop!" enthält, sollte in der oberen linken Ecke der Anzeige angezeigt werden.

    Screenshot of the running DesktopApp Project.

Herzlichen Glückwunsch! Sie haben diese exemplarische Vorgehensweise abgeschlossen und eine herkömmliche Windows Desktopanwendung erstellt.

Siehe auch

Windows Desktopanwendungen