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!" 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 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 sind, 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. Es wird empfohlen Windows 10 oder höher zu verwenden, um die beste Entwicklungserfahrung zu bieten.

  • 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

  1. Klicken Sie im Hauptmenü auf DateiNeuProjekt, 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 Desktopfest.

  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 Anwendungstypdie Option Desktopanwendung (.exe) aus. Wählen Sie unter Zusätzliche Optionendie Option Leeres Projektaus. Klicken Sie auf OK, um das Projekt zu erstellen.

  6. Klicken Projektmappen-Explorermit der rechten Maustaste auf das DesktopApp-Projekt, wählen Sie Hinzufügenund 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

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 installiertVisual C++ , und wählen Sie dann Windows Desktop 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 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.Screenshot des Dialogfelds "New Project" (Neues Project) in Visual Studio 2017 mit installierter Visual C plus ausgewählter Option "Windows Desktop", hervorgehobener Option "Assistent für im Textfeld Name

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

  4. Klicken Projektmappen-Explorermit der rechten Maustaste auf das DesktopApp-Projekt, wählen Sie Hinzufügenund dann Neues Element aus.

    Short video showing the user adding a new item to DesktopApp Project in Visual Studio 2017.Kurzes Video, in dem der Benutzer im Jahr ein neues Element zu DesktopApp Project hinzugefügt Visual Studio wird.

  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.Screenshot des Dialogfelds "Neues Element hinzufügen" in Visual Studio 2017 mit ausgewählter Option 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 New Project (Neue Vorlage) im linken Bereich installierte Vorlagen Visual 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.Screenshot des Dialogfelds "New Project" in Visual Studio 2015 mit installierten Vorlagen Visual C plus Win32, hervorgehobener Option im Textfeld Name.

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

    Create DesktopApp in Win32 Application Wizard Overview page.Übersichtsseite des Assistenten zum Erstellen einer

  4. Wählen Sie auf Einstellungen Seite Anwendungstyp unter Anwendungstypdie Option Windows aus. Deaktivieren Sie unter ZusätzlicheOptionen die Option Vorkompilierte Kopfzeile,und wählen Sie dann Leeres Projekt aus. Klicken Sie auf Fertig stellen, um das Projekt zu erstellen.

  5. Klicken Projektmappen-Explorermit der rechten Maustaste auf das DesktopApp-Projekt, wählen Sie Hinzufügenund 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 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.Screenshot des Dialogfelds "Neues Element hinzufügen" in Visual Studio 2015 mit ausgewählter Option 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. Wie jede C-Anwendung und jede C++-Anwendung eine Funktion als Ausgangspunkt haben 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 CALLBACKHINSTANCE_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 die IntelliSense-Funktion "QuickInfo" verwenden, um zu sehen, was diese Typedefs und Makros definieren. Zeigen Sie mit der Maus auf das gewünschte Wort, 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 in aufgelöst wchar_t wird, wenn das UNICODE-Symbol in Ihrem Projekt definiert ist, andernfalls wird es in char aufgelöst. Wenn Sie immer unicode-fähig erstellen, benötigen Sie TCHAR nicht und können einfach wchar_t direkt 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 beliebig 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, um Nachrichten zu verarbeiten, die die Anwendung von Windows empfängt, 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 Ihre Funktion schreiben, der WndProc die gewünschten Aufgaben ü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 WinMainauf. Die -Struktur enthält Informationen über das Fenster: das Anwendungssymbol, die Hintergrundfarbe des Fensters, den Namen, der in der Titelleiste angezeigt werden soll, unter anderem. Wichtig: Sie enthält einen Funktionszeiger auf Ihre Fensterprozedur. 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 das WNDCLASSEX mit Windows, damit es über Ihr Fenster informiert ist und 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 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 HWND zurück, bei dem es sich um ein Handle für ein Fenster handelt. Ein Handle ähnelt einem Zeiger, der Windows verwendet, um geöffnete Fenster nachzuverfolgen. Weitere Informationen finden Sie unter Windows-Datentypen.

  4. An diesem Punkt wurde das Fenster erstellt, aber wir müssen Windows anzuweisen, es sichtbar zu machen. Dies ist dies, 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 verarbeitet noch nicht die Nachrichten, 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 sendet. Wenn die Anwendung eine Nachricht empfängt, wird sie von dieser Schleife zur Behandlung an Ihre WndProc 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 die WM_PAINT 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 entfernt. Ihre Anwendung weiß nicht, wann diese Ereignisse auftreten. Nur Windows wissen, weshalb sie Ihre App mit einer WM_PAINT Meldung benachrichtigt. Wenn das Fenster zum ersten Mal angezeigt wird, muss es aktualisiert werden.

    Rufen Sie zur Behandlung einer WM_PAINT -Nachricht zuerst WM_PAINTauf, 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 endenden Aufruf 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 und , um die Zeichnung im EndPaint Clientbereich vorzubereiten und abzuschließen. 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. Beispielsweise 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 bereits angekündigt, finden Sie hier den vollständigen Code für die funktionierende Anwendung.

So erstellen Sie dieses Beispiel

  1. Löschen Sie sämtlichen Code, den Sie in HelloWindowsDesktop.cpp eingegeben haben, im Editor. Kopieren Sie diesen Beispielcode, und fügen Sie ihn in HelloWindowsDesktop.cppein:

    // 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 Visual Studio angezeigt werden.

    Animation, die die Schritte zum Erstellen der DesktopApp-Project zeigt.

  3. Drücken Sie F5, um die Anwendung auszuführen. In der oberen linken Ecke der Anzeige sollte ein Fenster mit dem Text "Hello, Windows desktop!" 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