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

In diesem Artikel werden die Features des Visual Studio-Debuggers in einer schrittweisen exemplarischen Vorgehensweise vorgestellt. 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:

• 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

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 2022 kostenlos zu installieren, wechseln Sie zur Visual Studio-Downloads Seite.

  • 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 Extras>Tools und Features abrufen aus.

    2. Wählen Sie im Visual Studio-Installer die Registerkarte Workloads aus.

    3. Wählen Sie die Workload Desktopentwicklung mit C++ und dann Ändern aus.

    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 Funktion Bearbeiten und fortfahren wird nicht unterstützt.

  • F# und JavaScript: Das Fenster Auto 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:

1. Wählen Sie in Visual Studio im Startfenster (Datei>Startfenster) Neues Projekt erstellen aus:

   

2. Legen Sie den Filter Sprache auf C++- fest, und legen Sie den Filter Platform auf Windowsfest.

3. Geben Sie im Feld Suche Konsole ein, und wählen Sie in der Ergebnisliste die Vorlage Konsolen-App aus:

   

   Anmerkung

   Wenn die Vorlage Konsolen-App- nicht angezeigt wird, können Sie sie aus dem Fenster Erstellen eines neuen Projekts installieren. Suchen Sie den Abschnitt Nicht gefunden, wonach Sie suchen?, der den Suchergebnissen folgt, und wählen Sie Weitere Tools und Features installieren aus. 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.

4. Wählen Sie Weiter aus, um mit der Konfigurationsseite fortzufahren.

5. Geben Sie get-started-debugging als Projektname und Projektmappenname für die neue App ein. Wählen Sie den standardmäßigen Speicherort aus, oder navigieren Sie zu einem anderen Pfad in Ihrer Umgebung.

6. Klicken Sie auf Erstellen, um das neue Node.js-Projekt zu erstellen.

Visual Studio erstellt Ihr neues Projekt und öffnet die Projekthierarchie im Projektmappen-Explorer. Die datei get-started-debugging.cpp 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:

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

2. Halten Sie den Debugger an, indem Sie in der Debugsymbolleiste Beenden (rotes Quadratsymbol) auswählen. Sie können auch die Tastenkombination Shift + F5 verwenden.

3. Wählen Sie im Konsolenfenster für die ausgeführte Anwendung einen beliebigen Schlüssel aus, und drücken Sie dann die EINGABETASTE, 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:

1. Kehren Sie zur Datei get-started-debugging.cpp 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]);
      }
   

2. Setzen Sie einen Haltepunkt in der Zeile mit der Codeanweisung name += letters[i];, indem Sie am linken Bundsteg auf der Zeile die Anweisung auswählen. Visual Studio fügt einen roten Kreis im Rand hinzu, um den festgelegten Haltepunkt anzuzeigen.

   Tipp

   Sie können den Cursor auch in eine Codezeile setzen und F9 drücken, 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.

3. 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 festgelegten Haltepunkt erreicht, wird der Debugvorgang 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 App nicht ausgeführt wird und Sie F5 auswählen, startet der Debugger Ihre App und setzt die Ausführung fort, bis sie den ersten festgelegten 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 die Aktionen Schrittweise ausführen, Schritt überspringen und Ausführen bis Rücksprung für einen Codeabschnitt ausführen und außerdem in der Anwendungsausführung die Aktion Schritt zurück ausführen.

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

1. Starten Sie Ihre App im Debugger, indem Sie F5- oder Debuggen startenauswählen.

2. Während der Debugger in der for-Schleife der main-Funktion pausiert, drücken Sie zweimal F11 (Debuggen > Schrittweise ausführen), um zum SendMessage-Methodenaufruf zu gelangen.

   Nachdem Sie F11- zweimal ausgewählt haben, wird die Ausführung mit der Code-Anweisung SendMessage(name, a[i]);fortgesetzt.

3. Wählen Sie F11 erneut aus, um in die SendMessage-Methode zu gelangen.

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

   

   Der Tastaturkurzbefehl F11 initiiert den Befehl Schrittweise ausführen, mit dem die App Anweisung für Anweisung ausgeführt wird. 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.

4. Nachdem Sie die SendMessage-Methode untersucht haben, können Sie mit dem Befehl „Schritt zurück“ das Debugging fortsetzen. Wählen Sie UMSCHALT + F11 (Debuggen > Ausführen bis Rücksprung).

   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.

5. Wählen Sie F11- mehrmals aus, bis Sie wieder zum SendMessage Methodenaufruf zurückkehren.

6. 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. Durch Drücken der Taste F10 fährt der Debugger in Ihrem App-Code fort, ohne dass Funktionen oder Methoden schrittweise ausgeführt werden (der Code wird immer noch ausgeführt). Wenn Sie für den SendMessage-Methodenaufruf F10 (statt F11) wählen, wird die Aktion Schritt überspringen im Implementierungscode für SendMessage ausgeführt. 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 des Codes mit „Ausführen bis Klick“

Eine weitere Möglichkeit, den Code im Debugger durchzuarbeiten, bietet das Feature Ausführen bis Klick. Diese Aktion ähnelt dem Festlegen eines temporären Haltepunkts.

Fahren Sie mit der Debugsitzung fort:

1. Drücken Sie die Taste F5, um zum Haltepunkt im Code zu gelangen.

2. Scrollen Sie im Code-Editor zur SendMessage Methodendefinition, und zeigen Sie mit der Maus auf die std::wcout-Funktion.

   Bewegen Sie die Maus, bis die Aktion Ausführen bis Klick (grünes Pfeilsymbol) links neben der Codeanweisung angezeigt wird. Wenn Sie mit dem Mauszeiger auf das Symbol zeigen, wird die QuickInfo „Ausführung bis hier ausführen“ angezeigt:

   

3. Wählen Sie Ausführen bis Klick aus.

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

Die Aktion Ausführen bis Klick ist nützlich, wenn Sie eine sichtbare Region des App-Codes schnell durchlaufen möchten. 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 Neu starten auswählen, wird der Debugger am ersten Haltepunkt in der Ausführung angehalten. 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:

1. Während der Debugger in der name += letters[i]-Anweisung pausiert, zeigen Sie mit dem Mauszeiger auf die Variable letters. 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}:

   

2. Zeigen Sie als Nächstes auf die name Variable, und beachten Sie den aktuellen Wert, eine leere Zeichenfolge ("").

3. 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 zum Überprüfen von Variablen und Werten ist die Verwendung der Fenster Auto und Locals. Standardmäßig werden diese Fenster unter dem Code-Editor in der Visual Studio-IDE angezeigt, während Sie Ihre App debuggen:

1. Achten Sie auf das Fenster Auto unter dem Code-Editor.

   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.

2. Sehen Sie sich als Nächstes das Fenster Lokale Variablen an. Dieses Fenster wird standardmäßig neben dem Fenster Auto angeordnet.

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

3. Erweitern Sie im Fenster locals die letters Variable, um die darin enthaltenen Elemente anzuzeigen.

   

   Im Fenster Lokale Variablen werden die Variablen angezeigt, die sich im aktuellen Geltungsbereich, also im aktuellen Ausführungskontext befinden.

Ü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 Variable name, und wählen Sie Überwachung hinzufügen aus. Das Fenster Überwachung wird unten im Code-Editor geöffnet. Sie können das Fenster Überwachung verwenden, um eine Variable (oder einen Ausdruck) anzugeben, die Sie nachverfolgen möchten.

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.

Untersuchen Sie den Aufrufstapel

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.

1. Während der Debugger in der for-Schleife pausiert, wählen Sie das Fenster Aufrufliste aus, um die aktuelle Aufrufstruktur anzuzeigen.

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

2. Wählen Sie einige Male F11 (Debuggen>Schrittweise ausführen), bis der Debugger in der SendMessage-Methode anhält.

3. Sehen Sie sich das Fenster Aufrufliste erneut an:

   

   Im Fenster Aufrufliste wird in der obersten Zeile die aktuelle Funktion angezeigt (die SendMessage-Methode in dieser App). 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.

• Rufen Sie im Fenster Aufrufliste Kontextmenüs für Programmierelemente auf. Beispielsweise können Sie Haltepunkte in bestimmte Funktionen einfügen, den Debugger über Ausführen bis Cursor voranbringen oder in den Quellcode wechseln. Weitere Informationen finden Sie unter Anzeigen des Aufrufstapels und Verwenden des Aufrufstapelfensters im Debugger.

Ändern des Ausführungsflusses

Ein weiteres Feature des Debuggers in Visual Studio ist die Möglichkeit, den Ausführungsfluss Ihrer App zu ändern:

1. Wählen Sie zweimal F11 (Debuggen>Schrittweise ausführen) aus, um die std::wcout-Funktion auszuführen.

2. Während der Debugger im SendMessage-Methodenaufruf pausiert, wählen Sie den gelben Pfeil (den Ausführungszeiger) aus und ziehen ihn links neben die Variable, und verschieben Sie den Pfeil zur vorherigen Codeanweisung (std::wcout).

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

4. Wählen Sie F5- aus, um die App-Ausführung abzuschließen.

Verwandte Inhalte

• Sehen Sie sich zuerst den Visual Studio-Debugger
• Navigieren durch Code mithilfe des Visual Studio-Debugger-
• Verwenden Sie den richtigen Haltepunkttyp (.NET, .NET Framework, C++, Alle Sprachen)