Samouczek: debugowanie kodu C++ za pomocą programu Visual Studio

2025-06-12

W tym artykule przedstawiono funkcje debugera programu Visual Studio w przewodniku krok po kroku. Podczas debugowania aplikacji zwykle uruchamiasz aplikację z dołączonym debugerem. Debuger udostępnia wiele sposobów sprawdzania, co robi kod podczas wykonywania programu. Możesz przejść przez kod i przyjrzeć się wartościom przechowywanym w zmiennych i ustawić zegarki na zmiennych, aby zobaczyć, kiedy wartości się zmieniają. Debuger pomaga zbadać ścieżkę wykonywania kodu i potwierdzić, że działa gałąź kodu.

W tym samouczku nauczysz się następujących rzeczy:

Uruchom debuger i wstrzymaj się w punktach przerwania
Learn commands to step through code in the debugger (Instrukcje dotyczące wykonywania kroków w kodzie w debugerze)
Sprawdzanie zmiennych w poradach dotyczących danych i oknach debugera
Badanie stosu wywołań

Jeśli dopiero zaczynasz debugowanie, możesz przeczytać Debugowanie dla początkujących przed rozpoczęciem tego samouczka. Jeśli chcesz wyświetlić funkcje debugera wyższego poziomu, zobacz Najpierw zobacz debuger.

Warunki wstępne

Program Visual Studio 2022 w wersji 17.12 lub nowszej z zainstalowanym obciążeniem Desktop w języku C++.
- Aby bezpłatnie zainstalować Visual Studio 2022, przejdź do strony pobierania Visual Studio .
- Aby zainstalować program Visual Studio bezpłatnie, przejdź do strony Release and Build History (Historia wydań i budowy), aby dowiedzieć się więcej.
- Jeśli masz już program Visual Studio, możesz zainstalować obciążenie z poziomu interaktywnego środowiska projektowego (IDE):
  1. Wybierz Narzędzia>Uzyskaj narzędzia i funkcje.
  2. W Instalatorze programu Visual Studio wybierz kartę Zadania.
  3. Wybierz pakiet roboczy Desktop z obciążeniem języka C++, a następnie wybierz pozycję Modyfikuj.
  4. Postępuj zgodnie z monitami i ukończ instalację.
W tym samouczku użyto aplikacji demonstracyjnej języka C++, a zrzuty ekranu przedstawiają składnię języka C++. Większość przedstawionych funkcji ma również zastosowanie do języków C#, Visual Basic, F#, Python, JavaScript i innych języków obsługiwanych przez program Visual Studio. Należy pamiętać o kilku ograniczeniach:
- języka F#: funkcja Edytuj i kontynuuj nie jest obsługiwana.
- języka F# i JavaScript: okno Autos nie jest obsługiwane.

Tworzenie projektu

Wykonaj następujące kroki, aby utworzyć projekt aplikacji konsolowej języka C++ w programie Visual Studio. Typ projektu zawiera wszystkie pliki szablonów potrzebne do szybkiego rozpoczęcia pracy:

W oknie Start programu Visual Studio (File>okno Start) wybierz pozycję Utwórz nowy projekt:
Ustaw filtr języka na C++ i ustaw filtr platformy na Windows.
W polu wyszukiwania wprowadź konsolii wybierz szablon Aplikacja konsolowa na liście wyników:

Notatka

Jeśli nie widzisz szablonu Console App, możesz zainstalować go w oknie Create a new project (Tworzenie nowego projektu). Znajdź Nie możesz znaleźć tego, czego szukasz? sekcję, która pojawia się po wynikach wyszukiwania i wybierz opcję Zainstaluj więcej narzędzi i funkcji. W Instalatorze programu Visual Studio wybierz obciążenie robocze Desktop Development with C++ i zaktualizuj instalację. Aby uzyskać więcej informacji, zobacz sekcję Wymagania wstępne.
Wybierz pozycję Dalej, aby przejść do strony konfiguracji.
Wprowadź get-started-debugging jako nazwę projektu i nazwę rozwiązania dla nowej aplikacji. Wybierz domyślną Lokalizację lub przejdź do innej ścieżki w danym środowisku.
Wybierz pozycję Utwórz, aby utworzyć nowy projekt Node.js.

Program Visual Studio tworzy nowy projekt i otwiera hierarchię projektu w eksploratorze rozwiązań . Plik get-started-debugging.cpp jest otwarty w edytorze kodu.

Tworzenie aplikacji

Utwórz nową aplikację dla projektu, edytując plik get-started-debugging.cpp w edytorze kodu.

Zastąp domyślną zawartość dostarczaną przez szablon następującym kodem:

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

Uruchamianie debugera

Teraz możesz rozpocząć debugowanie zaktualizowanego kodu:

Rozpocznij sesję debugowania, wybierając pozycję F5 lub Debug > Start Debugging. Na pasku narzędzi Debugowanie możesz również wybrać Rozpocznij debugowanie (ikona zielonej stałej strzałki).

Skrót klawiaturowy F5 uruchamia aplikację z debugerem dołączonym do procesu aplikacji, ale nie masz jeszcze niczego specjalnego do zbadania w kodzie. Aplikacja po prostu ładuje się i zobaczysz dane wyjściowe konsoli:
```
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
```
W dalszej części samouczka przyjrzysz się bliżej tej aplikacji w debugerze i zapoznasz się z innymi funkcjami debugowania.
Zatrzymaj debugger, wybierając pozycję Zatrzymaj (ikona czerwonego kwadratu) na pasku narzędzi debugowania. Możesz również użyć skrótu klawiaturowego Shift + F5.
W oknie konsoli uruchomionej aplikacji wybierz dowolny klucz, a następnie wybierz pozycję Wprowadź, aby zamknąć okno.

Ustawianie punktu przerwania i uruchamianie debugera

Spróbuj ustawić punkt przerwania i wstrzymywać go w wybranym punkcie w debugerze:

Wróć do pliku get-started-debugging.cpp w edytorze kodu i znajdź pętlę for funkcji main:

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

Ustaw punkt przerwania w wierszu zawierającym instrukcję kodu name += letters[i];, wybierając linię w lewym marginesie. Program Visual Studio dodaje czerwony okrąg o wartości w marginesie, aby wskazać ustawiony punkt przerwania.

Napiwek

Możesz również umieścić kursor w wierszu kodu i wybrać pozycję F9, aby przełączyć punkt przerwania dla tego wiersza.

Punkty przerwania są jedną z najbardziej podstawowych i podstawowych funkcji niezawodnego debugowania. Punkt przerwania wskazuje, gdzie program Visual Studio ma zawiesić uruchomiony kod. Po wstrzymaniu wykonywania możesz przyjrzeć się wartościom zmiennych, sprawdzić zachowanie pamięci lub sprawdzić, czy jest uruchamiana gałąź kodu.
Uruchom aplikację w debugerze, wybierając pozycję F5 lub Rozpocznij debugowanie.

Program Visual Studio rozpoczyna wykonywanie aplikacji. Gdy debuger osiągnie ustawiony punkt przerwania, proces debugowania zostanie wstrzymany.

Program Visual Studio dodaje żółtą strzałkę do czerwonego okręgu punktu przerwania w marginesie, aby reprezentować instrukcję kodu, w którym debuger został zatrzymany. Wykonywanie programu jest wstrzymane i wskazana instrukcja oczekuje na przetworzenie.

Notatka

Akcja F5 odnosi się do bieżącego stanu wykonywania aplikacji. Jeśli aplikacja nie jest uruchomiona i wybierzesz F5, debuger uruchamia aplikację i kontynuuje wykonywanie, dopóki nie osiągnie pierwszego ustawionego punktu przerwania. To zachowanie przypisuje się do polecenia Debug>Rozpocznij debugowanie. Jeśli aplikacja jest już uruchomiona i wybierzesz pozycję F5, wykonywanie aplikacji będzie kontynuowane, dopóki debuger nie osiągnie następnego punktu przerwania lub zakończenia programu. To zachowanie odpowiada poleceniu „Debug>Kontynuuj”.

Punkty przerwania to przydatna funkcja, gdy znasz wiersz kodu lub sekcję kodu, którą chcesz szczegółowo zbadać. Aby uzyskać informacje na temat różnych typów punktów przerwania, które można ustawić, takich jak warunkowe punkty przerwania, zobacz Użyj odpowiedniego typu punktu przerwania.

Przechodź przez kod w debugerze

Wygodnym sposobem przeglądania kodu w debugerze jest użycie komend krokowych. Te polecenia umożliwiają przechodzenie do, krok po krokui sekcji kodu, a także krok wstecz wykonywania aplikacji.

Zrzut ekranu przedstawiający polecenia kroków na pasku narzędzi debugera.

Poniższa procedura podkreśla, jak używać skrótów klawiaturowych z poleceniami do krokowego wykonywania, aby szybko przechodzić przez kod. (Równoważne akcje menu są wyświetlane w nawiasach).

Uruchom aplikację w debugerze, wybierając pozycję F5 lub Rozpocznij debugowanie.
Podczas gdy debuger jest wstrzymany w pętli for w funkcji main, wybierz pozycję F11 (Debugowanie > Krok do) dwa razy, aby przejść do wywołania metody SendMessage.

Po dwukrotnym wybraniu F11, kontynuowane jest wykonywanie instrukcji kodu SendMessage(name, a[i]);.
Ponownie wybierz F11, aby przejść do metody SendMessage.

Zwróć uwagę, że żółty wskaźnik przechodzi do metody SendMessage:

Skrót klawiaturowy F11 inicjuje polecenie Step Into, które powoduje postęp wykonywania aplikacji po jednej instrukcji naraz. Jest to dobry sposób, aby w najbardziej szczegółowy sposób zbadać przepływ wykonania. Domyślnie debuger pomija kod nieużytkownika. Aby uzyskać więcej informacji, zobacz Just My Code. W dalszej części samouczka nauczysz się, jak szybciej przechodzić przez kod.
Po zbadania metody SendMessage możesz kontynuować debugowanie za pomocą polecenia Step Out. Wybierz pozycję Shift + F11 (Debug > Wyjdź).

To polecenie wznawia wykonywanie aplikacji (i kontynuuje działanie debugera) do momentu zakończenia działania bieżącej metody lub funkcji.

Po zakończeniu polecenia debuger zatrzymuje się w pętli for w metodzie main przy wywołaniu metody SendMessage.
Wybierz F11 kilka razy, aż powrócisz ponownie do wywołania metody SendMessage.
Podczas wstrzymania debugera przy wywołaniu metody wybierz F10 (Debug > Przejdź przez).

Zauważ, że tym razem debuger nie przechodzi do metody SendMessage. Skrót F10 przesuwa debuger bez wchodzenia do funkcji czy metod w kodzie aplikacji (kod nadal jest wykonywany). Po wybraniu F10 wywołania metody SendMessage (zamiast F11) kod implementacji dla SendMessage. Takie podejście przydaje się do pomijania kodu, którego nie trzeba obecnie sprawdzać. Aby uzyskać więcej informacji na temat różnych sposobów przechodzenia przez kod, zobacz Nawigacja po kodzie w debugerze.

Przeglądaj kod za pomocą funkcji Run to Click

Innym sposobem pracy z kodem w debugerze jest użycie funkcji Uruchom, aby kliknąć. Ta akcja jest podobna do ustawiania tymczasowego punktu przerwania.

Kontynuuj sesję debugowania:

Wybierz pozycję F5, aby przejść do punktu przerwania w kodzie.
W edytorze kodu przewiń do definicji metody SendMessage i umieść kursor na funkcji std::wcout.

Najedź kursorem, aż Run to Click (ikona zielonej strzałki) pojawi się po lewej stronie kodu. Jeśli umieścisz wskaźnik myszy na ikonie, zobaczysz etykietkę narzędzia "Uruchom wykonywanie tutaj":
Wybierz Uruchom, aby kliknąć.

Debugger doprowadza wykonanie do wskazanej pozycji. W tym przykładzie debuger osiąga wywołanie funkcji std::wcout.

Akcja Uruchom do kliknięcia jest przydatna do szybkiej nawigacji w obrębie widocznego regionu kodu aplikacji. Możesz użyć tej funkcji w dowolnym pliku otwartym w edytorze kodu.

Szybkie ponowne uruchamianie aplikacji

Szybko uruchom ponownie aplikację, wybierając pozycję Uruchom ponownie (ikona strzałki cyklicznej) na pasku narzędzi debugowania. Możesz również wybrać Debugowanie > Uruchom ponownie lub użyć skrótu klawiaturowego Ctrl + Shift + F5.

Funkcja Uruchom ponownie jest wydajniejsza niż zatrzymywanie aplikacji i ponowne uruchamianie debugera.

Po wybraniu Uruchom ponowniedebuger wstrzymuje się w pierwszym punkcie przerwania, na który natrafi podczas wykonywania. W tym przykładzie debuger zatrzymuje się ponownie w punkcie przerwania ustawionym wewnątrz pętli for.

Sprawdzanie zmiennych za pomocą porad dotyczących danych

Funkcje, które ułatwiają sprawdzanie zmiennych, są jedną z najbardziej przydatnych zalet pracy z debugerem. Często podczas debugowania problemu próbujesz ustalić, czy zmienne przechowują oczekiwane wartości w określonych godzinach. Program Visual Studio udostępnia kilka sposobów, aby ułatwić wykonanie tego zadania.

Kontynuuj sesję debugowania:

Podczas gdy debuger jest wstrzymany w instrukcji name += letters[i], umieść kursor na zmiennej letters. Wybierz strzałkę rozwijania/zwijania po lewej stronie nazwy zmiennej i wyświetl jej właściwości w menu wysuwany.

Funkcja wskazówek dotyczących danych pokazuje wszystkie elementy, które zawiera zmienna. Zwróć uwagę na wartość domyślną size={10}:
Następnie umieść kursor na zmiennej name i zwróć uwagę na jej bieżącą wartość, pusty ciąg ("").
Wybierz F5 (Debug>Kontynuuj) kilkakrotnie, aby wielokrotnie przejść przez pętlę for. Za każdym razem, gdy debuger wstrzymuje się w punkcie przerwania, umieść kursor na zmiennej name i sprawdź bieżącą wartość:

Wartość zmiennej zmienia się wraz z każdą iterację pętli for, pokazując wartości f, a następnie fr, a następnie freitd.

Sprawdzanie zmiennych za pomocą okien Autos i Locals

Innym podejściem do sprawdzania zmiennych i wartości jest użycie okien Autos i Locals. Domyślnie te okna są wyświetlane poniżej edytora kodu w środowisku IDE programu Visual Studio podczas debugowania aplikacji:

Zrzut ekranu przedstawiający okna Automatyczne i Lokalne poniżej edytora kodu w debugerze podczas sesji debugowania.

Zwróć uwagę na okno Autos poniżej edytora kodu.

Jeśli nie widzisz okna podczas sesji debugowania, wybierz pozycję Debugowanie>Windows>Autos, aby otworzyć okno.

W oknie Autos są wyświetlane wszystkie zmienne używane w bieżącym wierszu lub poprzednim wierszu wraz z ich bieżącą wartością. Należy pamiętać, że określone języki programowania mogą demonstrować unikatowe zachowanie zmiennych i właściwości. Aby uzyskać więcej informacji, zobacz wskazówki dotyczące języka Visual Studio.
Następnie zapoznaj się z oknem Lokale. Domyślnie to okno jest wyrównane obok okna Autos.

Jeśli nie widzisz okna podczas sesji debugowania, wybierz pozycję Debugowanie>>Ustawienia lokalne systemu Windows, aby otworzyć okno
W oknie Locals rozwiń zmienną letters, aby wyświetlić elementy, które zawiera.

W oknie Locals są wyświetlane zmienne, które znajdują się w bieżącym zakresie , czyli bieżącym kontekście wykonywania.

Obserwowanie zmiennej

Jeśli interesuje Cię obserwowanie zachowania określonej zmiennej, możesz ustawić zegarek :

W edytorze kodu kliknij prawym przyciskiem myszy zmienną name i wybierz pozycję Dodaj zegarek. Okno Watch zostanie otwarte poniżej edytora kodu. Możesz użyć okna Watch, aby określić zmienną (lub wyrażenie), które chcesz śledzić.

Zrzut ekranu przedstawiający okno Obserwowanie z wartościami zmiennej nazwy w programie Visual Studio.

Podczas oglądania zmiennej name podczas wykonywania aplikacji w debugerze można zobaczyć jego zmianę wartości. W przeciwieństwie do innych okien zmiennych, w oknie Watch zawsze są wyświetlane zmienne, które obserwujesz. Gdy obserwowana zmienna nie jest widoczna, jej nazwa jest wyblakła.

Badanie stosu wywołań

Okno Stos wywołań w programie Visual Studio pokazuje kolejność wywoływania metod i funkcji. To okno jest podobne do perspektywy debugowania w niektórych środowiskach IDE, takich jak Eclipse. Domyślnie stos wywołań jest widoczny w prawym dolnym okienku podczas sesji debugowania poniżej edytora kodu.

Podczas gdy debuger jest wstrzymany w pętli for, wybierz okno stosu wywołań, aby zobaczyć obecną strukturę wywołań.

Jeśli podczas sesji debugowania nie widzisz okna, wybierz Debug>Windows>Stos wywołań, aby otworzyć okno.
Wybierz pozycję F11 (Debugowanie>Krok do) kilka razy, aż zobaczysz wstrzymanie debugera w metodzie SendMessage.
Ponownie zapoznaj się z oknem stosu wywołań:

W oknie stosu wywołań, górny wiersz przedstawia bieżącą funkcję (metodę SendMessage w tej aplikacji). Drugi wiersz pokazuje, że metoda SendMessage została wywołana z metody main itd.

Stos wywołań to dobry sposób na sprawdzenie i zrozumienie przepływu wykonywania aplikacji:

Kliknij dwukrotnie wiersz kodu, aby przejść do kodu źródłowego. Ta akcja zmienia również bieżący zakres kontrolowany przez debuger, ale nie przesuwa działania debugera naprzód.
Uzyskaj dostęp do menu prawym przyciskiem myszy dla elementów programowania w oknie stosu wywołań. Można na przykład wstawić punkty przerwania do określonych funkcji, wznowić działanie debugera przy użyciu polecenia Uruchom do kursorai przeglądać kod źródłowy. Aby uzyskać więcej informacji, zobacz Wyświetl stos wywołań i użyj okna stosu wywołań w debugerze.

Zmień przepływ wykonywania

Inną funkcją debugera w programie Visual Studio jest możliwość zmiany przepływu wykonywania aplikacji:

Wybierz pozycję F11 (Debugowanie>Krok do), aby uruchomić funkcję std::wcout.
Podczas gdy debuger jest wstrzymany w wywołaniu metody SendMessage, zaznacz i przeciągnij żółtą strzałkę (wskaźnik wykonywania) z lewej strony zmiennej i przenieś strzałkę do poprzedniej instrukcji kodu, std::wcout.
Ponownie wybierz F11.

Debuger ponownie uruchamia funkcję std::wcout. Proces można śledzić w danych wyjściowych terminalu.

Zmieniając przepływ wykonywania, można wykonywać takie czynności, jak testowanie różnych ścieżek wykonywania kodu lub ponowne uruchamianie kodu bez ponownego uruchamiania debugera.

Ostrożność

Należy zwrócić szczególną uwagę podczas pracy z tą funkcją. Po wybraniu żółtej strzałki program Visual Studio wyświetli ostrzeżenie w etykietce narzędzia wskazujące, że zmiana sposobu wykonania może mieć niezamierzone konsekwencje. Możesz również zobaczyć inne ostrzeżenia w zależności od scenariusza. Pamiętaj, że przeniesienie wskaźnika nie może przywrócić aplikacji do wcześniejszego stanu aplikacji.
Wybierz pozycję F5, aby ukończyć wykonywanie aplikacji.

Udostępnij za pośrednictwem