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. Die Beispielanwendung, die Sie erstellen, verwendet die Windows-API, um "Hello, Windows desktop!" anzuzeigen. in einem Fenster anzeigt. 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 Windows Anwendungen. Sie gibt es seit den 1980er Jahren und wird seit Jahrzehnten zum Erstellen Windows Anwendungen verwendet. Erweiterte und einfacher zu programmierende Frameworks wurden auf der Grundlage 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 darunter. Weitere Informationen zur Windows-API finden Sie unter Windows API-Index. Es gibt viele Möglichkeiten zum Erstellen Windows Anwendungen, aber der oben genannte Prozess war der erste.

Wichtig

Aus Gründen der Kürze werden einige Code-Anweisungen im Text weggelassen. Der Abschnitt Code erstellen 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. Für ein optimales Entwicklungserlebnis empfehlen wir Windows 10.

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

    Details zur Workload Desktopentwicklung mit C++ im 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. Im Folgenden geben Sie den Code für eine funktionierende Windows 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 Windows Desktopprojekt in Visual Studio 2019

  1. Wählen Sie im Hauptmenü Datei > Neu > Projekt aus, 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 Desktop fest.

  3. Wählen Sie in der gefilterten Liste der Projekttypen Windows Desktop-Assistenten und 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 Windows Desktop Project wird jetzt angezeigt. Wählen Sie unter Anwendungstyp die Option Desktopanwendung (.exe) aus. Wählen Sie unter Zusätzliche Optionen die Option Leeres Projekt aus. Klicken Sie auf OK, um das Projekt zu erstellen.

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

    Kurzes Video, in dem der Benutzer im Jahr 2019 ein neues Element zu DesktopApp Project hinzugefügt Visual Studio wird.

  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 des Dialogfelds "Neues Element hinzufügen" in Visual Studio 2019 mit installierter > Visual C plus plus und hervorgehobener Option "C plus plus Datei".

Ihr Projekt wird jetzt erstellt, und Ihre Quelldatei wird im Editor geöffnet. Fahren Sie mit Erstellen des Codes fort, um fortzufahren.

So erstellen Sie 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 Project dialogfeld New Project im linken Bereich installiert Visual C++ , und wählen Sie dann desktop > Windows aus. Wählen Sie im mittleren Bereich die Option Windows Desktop-Assistent aus.

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

    Screenshot des Dialogfelds "Neuer Project" in Visual Studio 2017 mit installierter > Visual C plus ausgewählter Option "> Windows Desktop", hervorgehobener Option "Assistent für Windows-Desktop" und "DesktopApp" im Textfeld Name.

  3. Wählen Sie Windows Desktop Project unter Anwendungstyp die Option Windows (.exe) aus. Wählen Sie unter Zusätzliche Optionen die Option Leeres Projekt aus. Stellen Sie sicher, dass Der vorkompilierte Header nicht ausgewählt ist. Klicken Sie auf OK, um das Projekt zu erstellen.

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

    Kurzes Video, das zeigt, wie der Benutzer desktopApp Project 2017 Visual Studio ein neues Element hinzufügung.

  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: Dialogfeld "Neues Element hinzufügen" in Visual Studio 2017 mit ausgewählter Option "Installiert > Visual C plus plus" und hervorgehobener Option "C plus Datei".

Ihr Projekt wird jetzt erstellt, und Ihre Quelldatei wird im Editor geöffnet. Fahren Sie mit Erstellen des Codes fort, um fortzufahren.

So erstellen Sie 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 Project Dialogfeld Neue Vorlage im linken Bereich installierte Vorlagen Visual C++ , und wählen Sie dann > > Win32 aus. Wählen Sie im mittleren Bereich Win32-Projekt aus.

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

    Screenshot des Dialogfelds "New Project" in Visual Studio 2015 mit installierten >-Vorlagen > Visual C plus plus > Win32, hervorgehobener Option "Win32 Project" und "DesktopApp" im Textfeld Name.

  3. Klicken Sie auf der Seite Übersicht des Win32-Anwendungs-Assistenten auf Weiter.

    Übersichtsseite des Assistenten zum Erstellen einer DesktopApp in Win32-Anwendungen.

  4. Wählen Sie auf Einstellungen Seite Anwendungstyp unter Anwendungstyp die Option Windows aus. Deaktivieren Sie unter Zusätzliche Optionen die Option Vorkompilierten Header, und wählen Sie dann Leeres Projekt aus. Klicken Sie auf Fertig stellen, um das Projekt zu erstellen.

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

    Kurzes Video, das zeigt, wie der Benutzer desktopApp Project 2015 Visual Studio ein neues Element hinzufügung.

  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: Dialogfeld "Neues Element hinzufügen" in Visual Studio 2015 mit ausgewählter Option "Installiert > Visual C plus plus" und hervorgehobener Option "C plus Datei".

Ihr Projekt wird jetzt erstellt, und Ihre 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.

So beginnen Sie eine Windows-Desktopanwendung

  1. Ebenso wie jede C-Anwendung und jede C++-Anwendung über eine Funktion als Ausgangspunkt verfügen muss, muss jede Windows-Desktopanwendung main über eine -Funktion WinMain 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 dem Rückgabewert dieser Funktion finden Sie unter WinMain-Einstiegspunkt.

    Hinweis

    Was sind all diese zusätzlichen Wörter, z. B. WINAPI , oder , oder CALLBACK HINSTANCE _In_ ? Die herkömmliche Windows-API verwendet typedefs und Präprozessormakros umfassend, um einige Details von Typen und plattformspezifischem Code zu abstrahieren, z. B. Aufrufkonventionen, Deklarationen und __declspec Compiler-Pragmas. In Visual Studio können Sie das IntelliSense-Feature QuickInfo verwenden, um zu sehen, was diese Typedefs und Makros definieren. Bewegen Sie den Mauszeiger über das Wort, oder wählen Sie es aus, 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 zu erkennen. 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 Makro, das letztendlich in auflöset, wenn das UNICODE-Symbol in Ihrem Projekt definiert TCHAR wchar_t ist, andernfalls wird es in char auflösen. Wenn Sie immer mit aktivierter UNICODE erstellen, benötigen Sie TCHAR nicht und können einfach direkt wchar_t verwenden.

    #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 in der Regel WndProc , aber Sie können sie nach Benamen benennen. 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 Handhabung von Nachrichten, die die Anwendung von Windows, wenn Ereignisse auftreten. Wenn ein Benutzer z. B. eine Schaltfläche OK in Ihrer Anwendung auswählt, sendet Windows eine Nachricht an Sie, und Sie können Code in Ihrer Funktion schreiben, der die entsprechende Arbeit WndProc übernimmt. Dies 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 über das Fenster: das Anwendungssymbol, die Hintergrundfarbe des Fensters, den Namen, der unter anderem in der Titelleiste angezeigt werden soll. Wichtig ist, dass sie 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 oben genannten Struktur finden Sie unter WNDCLASSEX.

  2. Registrieren Sie das Windows, damit es über Ihr Fenster und die Art und Weise weiß, WNDCLASSEX wie Nachrichten an das Fenster gesendet werden. Verwenden Sie die RegisterClassEx -Funktion, und übergeben Sie die Fensterklassenstruktur als Argument. Das _T Makro wird verwendet, da wir den -Typ TCHAR 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 HWND zurück, der ein Handle für ein Fenster ist. Ein Handle ist in etwa wie ein Zeiger, Windows verwendet, um offene Fenster nachverfolgung zu behalten. Weitere Informationen finden Sie unter Windows-Datentypen.

  4. An diesem Punkt wurde das Fenster erstellt, aber wir müssen weiterhin Windows, um es sichtbar zu machen. Dies ist das, was dieser Code tut:

    // 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 enthält nicht viel Inhalt, da Sie die Funktion noch nicht implementiert WndProc haben. Anders ausgedrückt: Die Anwendung geht noch nicht mit den Nachrichten um, die Windows jetzt an sie sendet.

  5. Um die Nachrichten zu verarbeiten, fügen wir zunächst eine Nachrichtenschleife hinzu, um auf die Nachrichten zu lauschen, die Windows senden. Wenn die Anwendung eine Nachricht empfängt, wird sie von dieser Schleife zur WndProc Handhabung an Ihre Funktion gesendet. 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 Zu behandelnde Meldung ist die WM_PAINT Nachricht. Die Anwendung empfängt WM_PAINT die Meldung, wenn ein Teil des angezeigten Fensters aktualisiert werden muss. Das Ereignis kann auftreten, wenn ein Benutzer ein Fenster vor Ihrem Fenster verschiebt und es dann wieder zurück verschiebt. Ihre Anwendung weiß nicht, wann diese Ereignisse auftreten. Nur Windows wissen, sodass Ihre App mit einer Nachricht benachrichtigt WM_PAINT wird. Wenn das Fenster zum ersten Mal angezeigt wird, muss es alle 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 Startaufruf und dem Endaufruf die Zeichenfolge "Hello, Windows desktop!" an. im Fenster. 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 Funktionen und , um die Zeichnung im Clientbereich vorzubereiten BeginPaint und zu EndPaint vervollständigen. BeginPaint gibt ein Handle für den Anzeigegerätekontext zurück, der zum Zeichnen im Clientbereich verwendet wird. EndPaint beendet die Farbanforderung und gibt den Gerätekontext frei.

  2. Eine Anwendung verarbeitet in der Regel viele andere Nachrichten. Geben Sie beispielsweise WM_CREATE, wann 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 bereits angekündigt, finden Sie hier den vollständigen 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 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");
    
    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 Fenster Ausgabe in der Visual Studio.

    Animation mit den Schritten zum Erstellen des DesktopApp-Project.

  3. Drücken Sie F5, um die Anwendung auszuführen. Ein Fenster mit dem Text "Hello, Windows desktop!" sollte in der oberen linken Ecke der Anzeige angezeigt werden.

    Screenshot der ausgeführten DesktopApp-Project.

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

Siehe auch

Windows Desktopanwendungen