Lernprogramm: Debuggen von C++-Code mit Visual Studio

In diesem Lernprogramm debuggen Sie eine C++-Anwendung mit dem Visual Studio-Debugger. Wenn Sie eine Anwendung debuggen, führen Sie ihre App in der Regel mit dem angefügten Debugger aus. Der Debugger bietet viele Möglichkeiten, um zu untersuchen, was Der Code während der Programmausführung tut. Sie können Ihren Code schrittweise durchlaufen, die in Variablen gespeicherten Werte betrachten und Überwachungen für Variablen einrichten, um zu sehen, wann sich Werte ändern. Der Debugger hilft Ihnen, den Ausführungspfad Ihres Codes zu untersuchen und zu bestätigen, dass eine Verzweigung Ihres Codes ausgeführt wird.

In diesem Tutorial führen Sie Folgendes durch:

Starten des Debuggers und Anhalten an Haltepunkten
Erfahren Sie Befehle, um Code im Debugger schrittweise zu durchlaufen.
Variablen in Datentipps und Debuggerfenstern überprüfen
Überprüfen der Aufrufliste
Festlegen von Befehlszeilenargumenten für Ihre Anwendung

Wenn Sie mit dem Debuggen noch nicht fertig sind, sollten Sie Debugging für absolute Anfänger lesen,, bevor Sie dieses Lernprogramm starten. Wenn Sie einen Überblick über die Debuggerfunktionen wünschen, siehe Erster Blick auf den Debugger.

Voraussetzungen

Visual Studio 2022 Version 17.12 oder höher mit installierter Desktopentwicklung mit C++- Workload.
- Um Visual Studio kostenlos zu installieren, wechseln Sie zur Visual Studio-Downloads Seite.
- Wenn Sie Visual Studio kostenlos installieren möchten, wechseln Sie zur Seite Versions- und Buildverlauf, um mehr zu erfahren.
- Wenn Sie bereits über Visual Studio verfügen, können Sie die Workload aus der Interaktiven Entwicklungsumgebung (Interactive Development Environment, IDE) installieren:
  1. Wählen Sie Werkzeuge>Werkzeuge und Funktionen abrufen.
  2. Wählen Sie im Visual Studio-Installer die Registerkarte Workloads aus.
  3. Wählen Sie die Desktop-Entwicklung mit C++ Workload, und wählen Sie dann Ändern Sie.
  4. Folgen Sie den Anweisungen, und schließen Sie die Installation ab.
In diesem Lernprogramm wird eine C++-Demoanwendung verwendet, und die Screenshots stellen die C++-Syntax dar. Die meisten gezeigten Features gelten auch für C#, Visual Basic, F#, Python, JavaScript und andere Sprachen, die von Visual Studio unterstützt werden. Es gibt einige Einschränkungen, die Sie beachten sollten:
- F#: Die Bearbeiten und fortsetzen Funktion nicht unterstützt.
- F# und JavaScript: Die Autos Fenster wird nicht unterstützt.

Erstellen eines Projekts

Führen Sie die folgenden Schritte aus, um ein C++-Konsolenanwendungsprojekt in Visual Studio zu erstellen. Der Projekttyp stellt alle Vorlagendateien bereit, die Sie benötigen, um schnell loszulegen:

Im Visual Studio Starten Fenster (Datei>Fenster starten), wählen Sie Erstellen Sie ein neues Projekt:
Legen Sie den Filter Sprache auf C++- fest, und legen Sie den Filter Platform auf Windowsfest.
In der Suche Feld, geben Sie Konsoleund wählen Sie die Konsolen-App Vorlage in der Liste der Ergebnisse:

Anmerkung

Wenn die Vorlage Konsolen-App- nicht angezeigt wird, können Sie sie aus dem Fenster Erstellen eines neuen Projekts installieren. Finden Sie die Sie finden nicht, wonach Sie suchen? Abschnitt, der auf die Suchergebnisse folgt, und wählen Sie Installieren weiterer Werkzeuge und Funktionen. Wählen Sie im Visual Studio Installer die Desktopentwicklung mit C++- Workload aus, und aktualisieren Sie Ihre Installation. Weitere Informationen finden Sie im Abschnitt Voraussetzungen.
Wählen Sie Weiter aus, um mit der Konfigurationsseite fortzufahren.
Geben Sie get-started-debugging den Projektnamen und den Projektmappennamen für Ihre neue App ein. Wählen Sie den Standard Standort oder wechseln Sie zu einem anderen Pfad in Ihrer Umgebung.
Wählen Sie Erstellen um das neue Node.js-Projekt zu erstellen.

Visual Studio erstellt Ihr neues Projekt und öffnet die Projekthierarchie im Projektmappen-Explorer. Die get-started-debugging.cpp Datei ist im Code-Editor geöffnet.

Erstellen der Anwendung

Erstellen Sie eine neue Anwendung für Ihr Projekt, indem Sie die get-started-debugging.cpp Datei im Code-Editor bearbeiten.

Ersetzen Sie den von der Vorlage bereitgestellten Standardinhalt durch den folgenden Code:

#include <string>
#include <vector>
#include <iostream>

void SendMessage(const std::wstring& name, int msg)
{
   std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main()
{
   std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
   std::wstring name = L"";
   std::vector<int> a(10);
   std::wstring key = L"";

   for (int i = 0; i < letters.size(); i++)
   {
      name += letters[i];
      a[i] = i + 1;
      SendMessage(name, a[i]);
   }
   std::wcin >> key;
   return 0;
}

Starten des Debuggers

Jetzt können Sie mit dem Debuggen des aktualisierten Codes beginnen:

Starten Sie die Debugsitzung, indem Sie F5- oder Debuggen > Debuggen startenauswählen. Sie können auch Debuggen starten (einfarbiges grünes Pfeilsymbol) in der Debugsymbolleiste auswählen.

Die F5- Tastenkombination startet die Anwendung mit dem Debugger, der an den App-Prozess angefügt ist, aber es gibt noch nichts Besonderes im Code zu untersuchen. Die App wird einfach geladen, und die Konsolenausgabe wird angezeigt:
```
Hello, f! Count to 1
Hello, fr! Count to 2
Hello, fre! Count to 3
Hello, fred! Count to 4
Hello, fred ! Count to 5
Hello, fred s! Count to 6
Hello, fred sm! Count to 7
Hello, fred smi! Count to 8
Hello, fred smit! Count to 9
Hello, fred smith! Count to 10
```
Später im Lernprogramm betrachten Sie diese App im Debugger genauer und erkunden andere Debugfeatures.
Halten Sie den Debugger an, indem Sie in der Debugsymbolleiste Beenden (rotes Quadratsymbol) auswählen. Sie können auch die Tastenkombination Shift + F5 verwenden.
Wählen Sie im Konsolenfenster der ausgeführten Anwendung eine beliebige Taste und wählen Sie dann Eingabe um das Fenster zu schließen.

Festlegen eines Haltepunkts und Starten des Debuggers

Versuchen Sie, einen Haltepunkt festzulegen und an dem ausgewählten Punkt im Debugger anzuhalten:

Kehren Sie zur get-started-debugging.cpp Datei im Code-Editor zurück, und suchen Sie die for Schleife der main Funktion:

   for (int i = 0; i < letters.size(); i++)
   {
      name += letters[i];
      a[i] = i + 1;
      SendMessage(name, a[i]);
   }

Aktivieren Sie einen Haltepunkt in der Zeile, die die Codeanweisung enthält name += letters[i]; indem Sie in der linken Rinne auf der Zeile für die Anweisung auswählen. Visual Studio fügt einen roten Kreis im Rand hinzu, um den festgelegten Haltepunkt anzuzeigen.

Tipp

Sie können auch den Cursor auf eine Codezeile setzen und die Option F9 um den Haltepunkt für diese Zeile umzuschalten.

Haltepunkte sind ein einfaches und wichtiges Feature zum zuverlässigen Debuggen. Ein Haltepunkt gibt an, wo Visual Studio den ausgeführten Code anhalten soll. Wenn die Ausführung angehalten wird, können Sie sich die Werte von Variablen ansehen, das Speicherverhalten untersuchen oder überprüfen, ob eine Verzweigung des Codes ausgeführt wird.
Starten Sie Ihre App im Debugger, indem Sie F5- oder Debuggen startenauswählen.

Visual Studio startet die Ausführung Ihrer App. Wenn der Debugger den von Ihnen aktivierten Haltepunkt erreicht, wird der Debugging-Prozess angehalten.

Visual Studio fügt dem roten Haltepunktkreis im Rand einen gelben Pfeil hinzu, um die Codestelle darzustellen, an der der Debugger angehalten wird. Die Programmausführung wird angehalten, und die angegebene Anweisung wartet auf die Verarbeitung.

Anmerkung

Die F5--Aktion ist relativ zum aktuellen Ausführungszustand Ihrer Anwendung. Wenn Ihre Anwendung nicht ausgeführt wird und Sie wählen F5Wenn Sie den Debugger starten, startet der Debugger Ihre Anwendung und setzt die Ausführung fort, bis er den ersten aktivierten Haltepunkt erreicht. Dieses Verhalten ist dem Befehl Debuggen>Debuggen starten zugeordnet. Wenn Ihre App bereits ausgeführt wird und Sie F5-auswählen, wird die App-Ausführung fortgesetzt, bis der Debugger den nächsten Haltepunkt oder das Ende des Programms erreicht. Dieses Verhalten ist dem Befehl Debuggen>Continue zugeordnet.

Haltepunkte sind ein nützliches Feature, wenn Sie die Codezeile oder den Codeabschnitt kennen, die Sie im Detail untersuchen möchten. Informationen zu den verschiedenen Typen von Haltepunkten, die Sie festlegen können, z. B. bedingte Haltepunkte, finden Sie unter Verwenden des richtigen Haltepunkttyps.

Durchlaufen Sie Ihren Code im Debugger

Eine bequeme Möglichkeit zum Durchsuchen des Codes im Debugger besteht darin, Schrittbefehlezu verwenden. Mit diesen Befehlen können Sie Schritt in, Schritt über, und Step Out eines Codeabschnitts, und auch Schritt rückwärts in der Ausführung der Anwendung.

Screenshot, der die Schrittbefehle in der Debuggersymbolleiste zeigt.

Im folgenden Verfahren wird erläutert, wie Sie Tastenkombinationen mit Schrittbefehlen verwenden, um Ihren Code schnell zu durchlaufen. (Die entsprechenden Menüaktionen werden in Klammern angezeigt.)

Starten Sie Ihre App im Debugger, indem Sie F5- oder Debuggen startenauswählen.
Während der Debugger im for Schleife in der main Funktion, wählen Sie F11 (Fehlersuche > Schritt in) Klausurrelevanz zwischen 1 (unwichtig) und 10 (sehr wichtig): auf, um zum SendMessage Methodenaufruf.

Nachdem Sie F11- zweimal ausgewählt haben, wird die Ausführung mit der Code-Anweisung SendMessage(name, a[i]);fortgesetzt.
Wählen Sie F11 erneut aus, um in die SendMessage-Methode zu gelangen.

Beachten Sie, dass der gelbe Zeiger in die SendMessage-Methode wechselt:

Die F11 Tastaturkürzel initiiert den Schritt in Befehl, der die Ausführung der Anwendung Anweisung für Anweisung fortschreitet. Es ist eine gute Möglichkeit, den Ausführungsfluss im Detail zu untersuchen. Standardmäßig überspringt der Debugger den Nichtbenutzercode. Weitere Informationen finden Sie unter Just My Code. Später im Lernprogramm lernen Sie, wie Sie schneller durch Ihren Code navigieren können.
Nachdem Sie die SendMessage-Methode untersucht haben, können Sie mit dem Befehl „Schritt zurück“ das Debugging fortsetzen. Wählen Sie Verschiebung + F11 (Fehlersuche > Step Out).

Mit diesem Befehl wird die Ausführung der App so lange fortgesetzt (und der Debugger weiter ausgeführt), bis die aktuelle Methode oder Funktion wieder ausgeführt wird.

Nach Abschluss des Befehls hält der Debugger in der for-Schleife der main-Methode beim Aufruf der SendMessage-Methode an.
Wählen Sie F11- mehrmals aus, bis Sie wieder zum SendMessage Methodenaufruf zurückkehren.
Während der Debugger beim Methodenaufruf angehalten wird, wählen Sie F10 (Debug > Step Over).

Beachten Sie dieses Mal, dass der Debugger nicht in die SendMessage-Methode wechselt. Die F10 Mit dieser Abkürzung wird der Debugger fortgeschrieben, ohne dass Sie in Funktionen oder Methoden in Ihrem Anwendungscode eingreifen müssen (der Code wird weiterhin ausgeführt). Wenn Sie eine F10 zum SendMessage Methodenaufruf (anstelle von F11), Sie Schritt über den Implementierungscode für SendMessage. Dieser Ansatz ist nützlich, um an Code vorbeizugehen, den Sie derzeit nicht inspizieren müssen. Weitere Informationen zu verschiedenen Möglichkeiten zum Navigieren im Code finden Sie unter Navigieren von Code im Debugger.

Durchsuchen Sie Ihren Code mit Ausführung nach Klick

Eine weitere Möglichkeit, Ihren Code im Debugger durchzuarbeiten, ist die Verwendung des Ausführung bis Klick Funktion. Diese Aktion ähnelt dem Festlegen eines temporären Haltepunkts.

Fahren Sie mit der Debugsitzung fort:

Wählen Sie F5 um zum Haltepunkt in Ihrem Code zu gelangen.
Scrollen Sie im Code-Editor zur SendMessage Methodendefinition, und zeigen Sie mit der Maus auf die std::wcout-Funktion.

Bewegen Sie den Mauszeiger bis die Ausführung bis Klick (grünes Pfeilsymbol) erscheint links neben der Code-Anweisung. Wenn Sie den Mauszeiger über das Symbol bewegen, wird die QuickInfo "Ausführung bis hierher" angezeigt:
Wählen Sie Ausführung bis Klick .

Der Debugger führt die Ausführung fort bis zur angegebenen Position. In diesem Beispiel erreicht der Debugger den Aufruf der Methode std::wcout Funktion.

Die Ausführung bis Klick Diese Aktion ist praktisch, um sich schnell innerhalb eines sichtbaren Bereichs des Anwendungscodes zu bewegen. Sie können das Feature in einer beliebigen Datei verwenden, die im Code-Editor geöffnet ist.

Schnelles Neustarten der App

Starten Sie Ihre App schnell neu, indem Sie in der Debugsymbolleiste "Neu starten" (Kreispfeilsymbol) auswählen. Sie können auch Debuggen > Neustarten auswählen oder die tastenkombination STRG + UMSCHALT + F5 verwenden.

Das Feature Neustarten ist effizienter als das Beenden der App und das erneute Starten des Debuggers.

Wenn Sie eine Neu startenDer Debugger hält beim ersten Haltepunkt, auf den er während der Ausführung trifft, an. In diesem Beispiel stoppt der Debugger erneut an dem Haltepunkt, den Sie in der for Schleife festgelegt haben.

Überprüfen von Variablen mit Datentipps

Features, mit denen Sie Variablen überprüfen können, sind eines der nützlichsten Vorteile der Arbeit mit dem Debugger. Häufig versuchen Sie beim Debuggen eines Problems zu ermitteln, ob Variablen zu bestimmten Zeiten erwartete Werte speichern. Visual Studio bietet verschiedene Möglichkeiten, um diese Aufgabe abzuschließen.

Fahren Sie mit der Debugsitzung fort:

Während der Debugger auf der Registerkarte Debugger pausiert name += letters[i] Anweisung, bewegen Sie den Mauszeiger über die letters variabel. Wählen Sie den Pfeil zum Erweitern/Reduzieren links neben dem Variablennamen aus, und zeigen Sie dessen Eigenschaften im Flyoutmenü an.

Die Datentipps Funktion zeigt alle Elemente, die die Variable enthält. Beachten Sie den Standardwert size={10}:
Zeigen Sie als Nächstes auf die name Variable, und beachten Sie den aktuellen Wert, eine leere Zeichenfolge ("").
Wählen Sie F5 (Debug>Continue) mehrmals aus, um die for-Schleife mehrfach zu durchlaufen. Jedes Mal, wenn der Debugger am Haltepunkt angehalten wird, zeigen Sie mit der Maus auf die name Variable, und überprüfen Sie den aktuellen Wert:

Der Wert der Variablen ändert sich bei jeder Iteration der for-Schleife, wobei die Werte f, dann fr, dann freusw. angenommen werden.

Überprüfen von Variablen mit den Fenstern "Autos" und "Locals"

Ein weiterer Ansatz zur Überprüfung von Variablen und Werten ist die Verwendung des Autos und Lokale Fenster. Standardmäßig werden diese Fenster unter dem Code-Editor in der Visual Studio-IDE angezeigt, während Sie Ihre App debuggen:

Screenshot mit den Fenstern

Beachten Sie die Autos Fenster unterhalb des Code-Editors.

Wenn das Fenster während der Debugsitzung nicht angezeigt wird, wählen Sie Debuggen>Windows>Automatisch aus, um das Fenster zu öffnen.

Im Fenster Autos werden alle Variablen angezeigt, die in der aktuellen Zeile oder in der vorhergehenden Zeile zusammen mit ihrem aktuellen Wert verwendet werden. Beachten Sie, dass bestimmte Programmiersprachen ein eindeutiges Verhalten für Variablen und Eigenschaften demonstrieren können. Weitere Informationen finden Sie in den Visual Studio-Sprachanleitungen.
Als nächstes werfen Sie einen Blick auf die Lokale Fenster. Standardmäßig wird dieses Fenster neben dem Fenster Autos Fenster.

Wenn das Fenster während der Debugsitzung nicht angezeigt wird, wählen Sie Debuggen>Windows>Locals aus, um das Fenster zu öffnen.
Erweitern Sie im Fenster locals die letters Variable, um die darin enthaltenen Elemente anzuzeigen.

Im Fenster Lokal werden Ihnen die Variablen angezeigt, die sich im aktuellen Bereich befinden, also im aktuellen Ausführungskontext.

Überwachen einer Variablen

Wenn Sie das Verhalten einer bestimmten Variablen beobachten möchten, können Sie eine Watchfestlegen:

Klicken Sie im Code-Editor mit der rechten Maustaste auf die name variabel und wählen Sie Uhr hinzufügen. Die Beobachten Sie Fenster öffnet sich unterhalb des Code-Editors. Sie können eine Beobachten Sie Geben Sie in diesem Fenster eine Variable (oder einen Ausdruck) an, die Sie verfolgen möchten.

Screenshot, in dem das Überwachungsfenster mit Werten für die Variable 'Name' in Visual Studio angezeigt wird.

Während Sie die name Variable während der App-Ausführung im Debugger beobachten, können Sie dessen Wertänderung sehen. Im Gegensatz zu den anderen Variablenfenstern zeigt das Überwachungsfenster immer die Variablen an, die Sie beobachten. Wenn sich eine überwachte Variable nicht im Bereich befindet, wird der Variablenname abgeblendet.

Überprüfen der Aufrufliste

Das Fenster Aufrufstapel in Visual Studio zeigt die Reihenfolge an, in der Methoden und Funktionen aufgerufen werden. Dieses Fenster ähnelt der Debugperspektive in einigen IDEs wie Eclipse. Standardmäßig ist der Aufrufstapel während der Debugsitzung unterhalb des Code-Editors im unteren rechten Bereich sichtbar.

Während der Debugger im for Schleife, wählen Sie die Stapel aufrufen Fenster, um die aktuelle Aufrufstruktur zu sehen.

Wenn das Fenster während der Debugsitzung nicht angezeigt wird, wählen Sie Debuggen>Windows>Aufrufstapel- aus, um das Fenster zu öffnen.
Wählen Sie F11 (Fehlersuche>Schritt in) ein paar Mal, bis Sie sehen, dass der Debugger eine Pause in der SendMessage Methode.
Schauen Sie sich die Stapel aufrufen Fenster wieder öffnen:

In der Stapel aufrufen Die oberste Zeile des Fensters zeigt die aktuelle Funktion (die SendMessage Methode in dieser Anwendung). Die zweite Zeile zeigt, dass die SendMessage-Methode aus der main-Methode aufgerufen wurde usw.

Der Aufrufstapel ist eine gute Möglichkeit, den Ausführungsfluss einer App zu untersuchen und zu verstehen:

Doppelklicken Sie auf eine Codezeile, um zum Quellcode zu navigieren. Diese Aktion ändert auch den aktuellen Bereich, der vom Debugger untersucht wird, führt den Debugger jedoch nicht weiter.
Zugriff auf Rechtsklick-Menüs für Programmierelemente im Stapel aufrufen Fenster. Sie können zum Beispiel Haltepunkte in bestimmte Funktionen einfügen, den Debugger mit Hilfe von Ausführung nach Cursorund den Quellcode durchsuchen. Weitere Informationen finden Sie unter Anzeigen des Aufrufstapels und Verwenden des Aufrufstapelfensters im Debugger.

Ändern des Ausführungsflusses

Ein weiteres leistungsfähiges Debuggerfeature ist die Möglichkeit, den Ausführungsfluss während des Debuggens zu ändern:

Wählen Sie F11 (Fehlersuche>Schritt in) zweimalige Ausführung der std::wcout Funktion.
Während der Debugger im SendMessage Methodenaufruf hinzufügen, wählen Sie den gelben Pfeil (den Ausführungszeiger) aus, ziehen Sie ihn nach links neben die Variable und verschieben Sie den Pfeil zur vorherigen Codeanweisung, std::wcout.
Wählen Sie F11- erneut aus.

Der Debugger führt die std::wcout-Funktion erneut aus. Sie können den Prozess in der Terminalausgabe nachverfolgen.

Durch Ändern des Ausführungsflusses können Sie z. B. verschiedene Codeausführungspfade testen oder Code erneut ausführen, ohne den Debugger neu zu starten.

Vorsicht

Achten Sie bei der Arbeit mit diesem Feature auf sorgfältige Aufmerksamkeit. Wenn Sie den gelben Pfeil auswählen, zeigt Visual Studio eine Warnung in der QuickInfo an, die angibt, dass die Ausführungsänderung unbeabsichtigte Folgen haben kann. Je nach Szenario werden möglicherweise auch andere Warnungen angezeigt. Denken Sie daran, dass das Verschieben des Zeigers Ihre Anwendung nicht auf einen früheren App-Zustand zurücksetzen kann.
Wählen Sie F5- aus, um die App-Ausführung abzuschließen.

Übergeben von Befehlszeilenargumenten

Legen Sie Befehlszeilenargumente für Ihre Anwendung in Projekteigenschaften fest. Dies ist nützlich, wenn Sie testen möchten, wie sich Ihre App mit unterschiedlichen Befehlszeilenargumenten verhält.

Ab Visual Studio 2026 können Sie Befehlszeilenargumente für Ihre Anwendung in der Dropdownliste der Symbolleiste für Befehlszeilenargumente festlegen. Dieses Feature ist für Visual Studio C++-Projekte, Unreal Engine-Projekte .uproject und CMake-Projekte verfügbar. Sie befindet sich derzeit in der Vorschau und kann vor der endgültigen Veröffentlichung geändert werden.

Ändern Sie die Anwendung so, dass Befehlszeilenargumente akzeptiert werden, indem Sie den Code in der get-started-debugging.cpp Datei durch Folgendes ersetzen:

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>

void SendMessage(const std::wstring& name, int msg)
{
    std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main(int argc, char* argv[])
{
    // Detect if the /u command-line argument was passed to the application.
    bool uppercase = false;
    for (int i = 1; i < argc; ++i)
    {
        if (std::string(argv[i]) == "/u")
        {
            uppercase = true;
            break;
        }
    }

    std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
    std::wstring name = L"";
    std::vector<int> a(10);
    std::wstring key = L"";

    for (int i = 0; i < letters.size(); i++)
    {
        name += letters[i];
        a[i] = i + 1;
        std::wstring nameToSend = name;

        if (uppercase) // Convert the name to uppercase if the /u argument was passed.
        {
            std::transform(nameToSend.begin(), nameToSend.end(), nameToSend.begin(), ::towupper);
        }
        SendMessage(nameToSend, a[i]);
    }
    return 0;
}

Diese aktualisierte Version der Anwendung akzeptiert ein Befehlszeilenargument /u , das den Namen vor der Ausgabe in Großbuchstaben konvertiert.

Führen Sie die folgenden Schritte aus, um das /u Befehlszeilenargument an die Anwendung zu übergeben, wenn Sie mit dem Debuggen beginnen:

Geben Sie in der Standardsymbolleiste das Textfeld " Befehlszeilenargumente " ein /u:
Platzieren Sie einen Haltepunkt in Zeile 19, uppercase = true;indem Sie auf den linken Bundsteg in dieser Linie klicken.
Starten Sie das Debuggen Ihrer Anwendung, indem Sie die Schaltfläche " Debuggen starten " auswählen oder F5 drücken.
Der Debugger trifft den Haltepunkt, da /u er als Befehlszeilenargument übergeben wurde:
Wählen Sie F5 aus, um die Ausführung der Anwendung fortzusetzen. Die Ausgabe im Konsolenfenster zeigt nun die Namen in Großbuchstaben an:

Hello, F! Count to 1
Hello, FR! Count to 2
Hello, FRE! Count to 3
Hello, FRED! Count to 4
Hello, FRED ! Count to 5
Hello, FRED S! Count to 6
Hello, FRED SM! Count to 7
Hello, FRED SMI! Count to 8
Hello, FRED SMIT! Count to 9
Hello, FRED SMITH! Count to 10

Befehlszeilenargumente werden in der Dropdownliste in der Reihenfolge gespeichert, in der Sie sie eingeben und in der Dropdownliste für die zukünftige Verwendung angezeigt werden. Es gibt eine Beschränkung von fünf Befehlszeilen, die Sie hinzufügen können, bevor die älteste hinzugefügt wird, um Platz für die neue zu schaffen.

Sie können den Dropdownlistenpfeil auswählen, um eine Liste der zuvor verwendeten Befehlszeilenargumente anzuzeigen.

Übergeben von Befehlszeilenargumenten in verschiedenen Projekttypen

Die Dropdownliste für Befehlszeilenargumente enthält eine projekttypspezifische Option, um die klassische Methode zum Festlegen der Argumente zu öffnen, die der Debugger an Ihr Programm übergibt. Bei .vcxproj Projekten erfolgt dies über die Eigenschaftenseite der Projekteinstellungen. Bei CMake-Projekten wird die vs.launch.json Datei bearbeitet. Bei Unreal Engine-Projekten wird die .uproject Datei bearbeitet.

Visual Studio-Projekttyp (`.vcxproj`)

In einem Visual Studio-Projekt (.vcxproj) wird eine Option in der Dropdownliste der Befehlszeilenargumente angezeigt, um in Eigenschaftenseiten zu bearbeiten:

Screenshot der Dropdownliste des Befehlszeilenarguments. Es zeigt /u und /d aus einer vorherigen Ausführung an. Die Option zum Bearbeiten auf Eigenschaftenseiten ist hervorgehoben.

Wählen Sie "In Eigenschaftenseiten bearbeiten " aus, um das Projekteigenschaftenfenster auf der Debugeigenschaftsseite zu öffnen, auf der Sie Befehlszeilenargumente festlegen, die beim Debuggen der Anwendung übergeben werden sollen:

Screenshot der Seite

Änderungen an den Befehlsargumenten werden in der Dropdownliste der Befehlszeilenargumente für zukünftige Debugsitzungen widergespiegelt.

CMake-Projekttyp

Für CMake-Projekte wird in der Dropdownliste für Befehlszeilenargumente eine Option zum Bearbeiten in launch.vs.json:

Screenshot der Dropdownliste des Befehlszeilenarguments für CMake-Projekte. Sie zeigt

Wählen Sie "Bearbeiten" aus launch.vs.json, um die launch.vs.json Datei zu öffnen und Befehlszeilenargumente festzulegen, die beim Debuggen der Anwendung im "args" Element übergeben werden:

Screenshot der datei launch.vs.json mit hervorgehobenen Args-Element

Änderungen an der Datei werden in der Dropdownliste der Befehlszeilenargumente für zukünftige Debugsitzungen widergespiegelt.

Unreal Engine-Projekttyp (`.uproject`)

Bei Unreal Engine-Projekten wird eine Option in der Dropdownliste der Befehlszeilenargumente zum Bearbeiten in UETargetProperties.jsonangezeigt:

Screenshot der Dropdownliste für Befehlszeilenargumente für Unreal Engine-Projekte. Sie zeigt

Wählen Sie "Bearbeiten" aus UETargetProperties.json, um die Datei zu öffnen, in der UETargetProperties.json Sie Befehlszeilenargumente festlegen, die beim Debuggen der Anwendung im Element "args" übergeben werden:

Screenshot der datei UETargetProperties.json mit hervorgehobenen Args-Element