Samouczek: dowiedz się, jak debugować kod C++ przy użyciu programu Visual Studio

W tym artykule przedstawiono funkcje debugera programu Visual Studio w przewodniku krok po kroku. Jeśli chcesz wyświetlić funkcje debugera wyższego poziomu, zobacz Pierwsze spojrzenie na debuger. Podczas debugowania aplikacji zwykle oznacza to, że uruchamiasz aplikację z dołączonym debugerem. Gdy to zrobisz, debuger udostępnia wiele sposobów, aby zobaczyć, co robi kod podczas jego działania. Możesz przejść przez kod i przyjrzeć się wartościom przechowywanym w zmiennych. Możesz ustawić zegarki na zmiennych, aby zobaczyć, kiedy wartości się zmieniają, możesz sprawdzić ścieżkę wykonywania kodu, sprawdzić, czy działa gałąź kodu itd. Jeśli po raz pierwszy próbowano debugować kod, warto przeczytać artykuł Debugowanie dla bezwzględnych początkujących przed przejściem do tego artykułu.

Mimo że aplikacja demonstracyjna jest językiem C++, większość funkcji ma zastosowanie do języków C#, Visual Basic, F#, Python, JavaScript i innych obsługiwanych przez program Visual Studio (F# nie obsługuje edycji i kontynuowania). Języki F# i JavaScript nie obsługują okna Autos(Autos ). Zrzuty ekranu znajdują się w języku C++.

Ten samouczek obejmuje następujące kroki:

• Uruchom debuger i naciśnij punkty 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ń

Wymagania wstępne

Musisz mieć zainstalowany program Visual Studio i programowanie aplikacji klasycznych z obciążeniem języka C++ .

Jeśli nie zainstalowano jeszcze programu Visual Studio 2022, przejdź do strony pobierania programu Visual Studio 2022, aby zainstalować ją bezpłatnie.

Jeśli musisz zainstalować obciążenie, ale masz już program Visual Studio, przejdź do pozycji Narzędzia Pobierz narzędzia>i funkcje..., co spowoduje otwarcie Instalator programu Visual Studio. Zostanie uruchomiona Instalator programu Visual Studio. Wybierz pakiet roboczy Programowanie aplikacji klasycznych przy użyciu języka C++ , a następnie wybierz pozycję Modyfikuj.

Tworzenie projektu

Najpierw utworzysz projekt aplikacji konsolowej języka C++. Typ projektu jest dostarczany ze wszystkimi potrzebnymi plikami szablonów, zanim jeszcze wszystko zostało dodane.

1. Otwórz program Visual Studio.

   Jeśli okno uruchamiania nie jest otwarte, wybierz pozycję Okno uruchamiania pliku>.

2. W oknie uruchamiania wybierz pozycję Utwórz nowy projekt.

3. W oknie Tworzenie nowego projektu wprowadź lub wpisz konsolę w polu wyszukiwania. Następnie wybierz pozycję C++ z listy Język, a następnie wybierz pozycję Windows z listy Platforma.

   Po zastosowaniu filtrów języka i platformy wybierz szablon Aplikacja konsolowa, a następnie wybierz przycisk Dalej.

   

   Uwaga

   Jeśli nie widzisz szablonu Aplikacja konsolowa, możesz zainstalować go w oknie Tworzenie nowego projektu . W komunikacie Nie można znaleźć tego, czego szukasz? wybierz link Zainstaluj więcej narzędzi i funkcji. Następnie w Instalator programu Visual Studio wybierz pakiet roboczy Programowanie aplikacji klasycznych przy użyciu języka C++.

4. W oknie Konfigurowanie nowego projektu wpisz lub wprowadź polecenie get-started-debug w polu Nazwa projektu. Następnie wybierz pozycję Utwórz.

   Program Visual Studio otwiera nowy projekt.

Tworzenie aplikacji

1. W pliku get-started-debug.cpp zastąp zamiast tego cały kod domyślny 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;
   }
   

Uruchom debuger!

1. Naciśnij klawisz F5 (Debuguj > rozpocznij debugowanie) lub przycisk Rozpocznij debugowanie na pasku narzędzi debugowania.

   Klawisz F5 uruchamia aplikację z debugerem dołączonym do procesu aplikacji, ale teraz nie zrobiliśmy nic specjalnego w celu zbadania kodu. Aplikacja zostanie załadowana 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 tym samouczku przyjrzymy się bliżej tej aplikacji przy użyciu debugera i przyjrzymy się funkcjom debugera.

2. Zatrzymaj debuger, naciskając czerwony przycisk zatrzymania (Shift + F5).

3. W oknie konsoli naciśnij klawisz i klawisz Enter , aby zamknąć okno konsoli.

Ustawianie punktu przerwania i uruchamianie debugera

1. for W pętli main funkcji ustaw punkt przerwania, klikając lewy margines następującego wiersza kodu:

   name += letters[i];

   Zostanie wyświetlone czerwone kółko , w którym ustawiono punkt przerwania.

   Punkty przerwania są jedną z najbardziej podstawowych i podstawowych funkcji niezawodnego debugowania. Punkt przerwania wskazuje, gdzie program Visual Studio powinien zawiesić uruchomiony kod, aby można było przyjrzeć się wartościom zmiennych lub zachowaniu pamięci, czy też czy jest uruchamiana gałąź kodu.

2. Naciśnij klawisz F5 lub przycisk Rozpocznij debugowanie , aplikacja zostanie uruchomiona, a debuger zostanie uruchomiony do wiersza kodu, w którym ustawiono punkt przerwania.

   

   Żółta strzałka reprezentuje instrukcję, na której wstrzymano debuger, który również zawiesza wykonywanie aplikacji w tym samym momencie (ta instrukcja nie została jeszcze wykonana).

   Jeśli aplikacja nie jest jeszcze uruchomiona, klawisz F5 uruchamia debuger i zatrzymuje się w pierwszym punkcie przerwania. W przeciwnym razie klawisz F5 kontynuuje uruchamianie aplikacji w następnym punkcie przerwania.

   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żywanie punktów przerwania.

Nawigowanie po kodzie w debugerze przy użyciu poleceń kroków

W większości przypadków używamy tutaj skrótów klawiaturowych, ponieważ jest to dobry sposób na szybkie wykonywanie aplikacji w debugerze (równoważne polecenia, takie jak polecenia menu, są wyświetlane w nawiasach).

1. Podczas wstrzymania for w pętli w metodzie main naciśnij klawisz F11 (lub wybierz pozycję Debuguj > krok do), aby przejść do SendMessage wywołania metody.

   Po dwukrotnym naciśnięciu klawisza F11 powinien znajdować się w tym wierszu kodu:

   SendMessage(name, a[i]);

2. Naciśnij klawisz F11 jeszcze raz, aby przejść do SendMessage metody .

   Żółty wskaźnik przechodzi do SendMessage metody .

   

   F11 jest poleceniem Step Into i rozwija wykonywanie aplikacji po jednej instrukcji naraz. F11 to dobry sposób na sprawdzenie przepływu wykonywania w najbardziej szczegółowy sposób. (Aby przyspieszyć przechodzenie przez kod, pokażemy również inne opcje). Domyślnie debuger pomija kod inny niż użytkownik (jeśli chcesz uzyskać więcej szczegółów, zobacz Tylko mój kod).

   Załóżmy, że wykonano badanie SendMessage metody i chcesz wydostać się z metody, ale pozostać w debugerze. Można to zrobić za pomocą polecenia Krok do wyjścia .

3. Naciśnij klawisze Shift + F11 (lub debuguj).>

   To polecenie wznawia wykonywanie aplikacji (i przechodzi do debugera), dopóki bieżąca metoda lub funkcja nie zostanie zwrócona.

   Należy wrócić do for pętli w metodzie main , wstrzymane przy wywołaniu SendMessage metody.

4. Naciśnij klawisz F11 kilka razy, aż wrócisz do SendMessage wywołania metody ponownie.

5. Podczas wstrzymania przy wywołaniu metody naciśnij klawisz F10 (lub wybierz pozycję Debuguj > krok do tyłu).

   

   Zauważ, że tym razem debuger nie przechodzi do SendMessage metody . Klawisz F10 rozwija debuger bez przechodzenia do funkcji lub metod w kodzie aplikacji (kod nadal jest wykonywany). Naciskając klawisz F10 na SendMessage wywołaniu metody (zamiast F11), pominięto kod SendMessage implementacji dla elementu (co może nie być teraz interesujące). Aby uzyskać więcej informacji na temat różnych sposobów przechodzenia przez kod, zobacz Navigate code in the debugger (Nawigowanie po kodzie w debugerze).

Nawigowanie po kodzie przy użyciu polecenia Uruchom do kliknięcia

1. Naciśnij klawisz F5 , aby przejść do punktu przerwania.

2. W edytorze kodu przewiń w dół i umieść kursor na std::wcout funkcji w metodzieSendMessage, aż zielony przycisk Uruchom do kliknięcia pojawi się po lewej stronie. Etykietka narzędzia przycisku zawiera komunikat "Uruchom wykonanie tutaj".

   

   Uwaga

   Przycisk Uruchom do kliknięcia jest nowy w programie Visual Studio 2017. (Jeśli nie widzisz zielonego przycisku strzałki, użyj polecenia W tym przykładzie F11 zamiast tego przesunie debuger do odpowiedniego miejsca).

3. Kliknij przycisk Uruchom, aby kliknąć.

   Debuger przechodzi do std::wcout funkcji.

   Użycie tego przycisku jest podobne do ustawiania tymczasowego punktu przerwania. Polecenie Uruchom do kliknięcia jest przydatne, aby szybko obejść się w widocznym regionie kodu aplikacji (możesz kliknąć dowolny otwarty plik).

Szybkie ponowne uruchamianie aplikacji

Kliknij przycisk Uruchom ponownie na pasku narzędzi debugowania (Ctrl Shift + + F5).

Po naciśnięciu przycisku Uruchom ponownie oszczędza czas w porównaniu z zatrzymywaniem aplikacji i ponownym uruchamianiem debugera. Debuger wstrzymuje się w pierwszym punkcie przerwania, który zostanie trafiony przez wykonanie kodu.

Debuger zatrzymuje się ponownie w punkcie przerwania ustawionym wcześniej wewnątrz for pętli.

Sprawdzanie zmiennych za pomocą porad dotyczących danych

Funkcje, które umożliwiają inspekcję zmiennych, są jedną z najbardziej przydatnych funkcji debugera i istnieją różne sposoby, aby to zrobić. Często podczas próby debugowania problemu próbujesz dowiedzieć się, czy zmienne przechowują wartości, których oczekujesz w określonym czasie.

1. Podczas wstrzymania instrukcji umieść kursor na zmiennej name += letters[i]letters i zobaczysz, że jest to wartość domyślna. size={10}

2. Rozwiń zmienną, letters aby wyświetlić jej właściwości, które zawierają wszystkie elementy, które zawiera zmienna.

3. Następnie umieść kursor na zmiennej name i zobaczysz jego bieżącą wartość, pusty ciąg.

4. Naciśnij klawisz F5 (lub Kontynuuj debugowanie>) kilka razy, aby iterować kilka razy przez for pętlę, wstrzymując ponownie w punkcie przerwania i umieszczając wskaźnik myszy na name zmiennej za każdym razem, aby sprawdzić jego wartość.

   

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

   Często podczas debugowania chcesz szybko sprawdzić wartości właściwości w zmiennych, aby sprawdzić, czy przechowują one wartości, które mają być przechowywane, a porady dotyczące danych są dobrym sposobem na to.

Sprawdzanie zmiennych za pomocą okien Autos i Locals

1. Zapoznaj się z oknem Autos w dolnej części edytora kodu.

   Jeśli jest on zamknięty, otwórz go podczas wstrzymania w debugerze, wybierając pozycję Debuguj>autos windows.>

   W oknie Autos zobaczysz zmienne i ich bieżącą wartość. W oknie Autos (Autos ) są wyświetlane wszystkie zmienne używane w bieżącym wierszu lub w poprzednim wierszu (Sprawdź dokumentację pod kątem zachowania specyficznego dla języka).

2. Następnie przyjrzyj się oknie Ustawienia lokalne na karcie obok okna Autos .

3. Rozwiń zmienną, letters aby wyświetlić zawarte w niej elementy.

   

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

Ustawianie zegarka

1. W oknie edytora kodu głównego kliknij prawym przyciskiem myszy zmienną name i wybierz polecenie Dodaj zegarek.

   W dolnej części edytora kodu zostanie otwarte okno Obserwowanie . Możesz użyć okna Czujka , aby określić zmienną (lub wyrażenie), na której chcesz mieć oko.

   Teraz masz zegarek ustawiony na zmiennej name i możesz zobaczyć jego zmianę wartości podczas przechodzenia przez debuger. W przeciwieństwie do innych okien zmiennych, okno Obserwowanie zawsze wyświetla zmienne, które obserwujesz (są wyszarywane, gdy poza zakresem).

Badanie stosu wywołań

1. Podczas wstrzymania for w pętli kliknij okno Stos wywołań, które jest domyślnie otwarte w prawym dolnym okienku.

   Jeśli jest on zamknięty, otwórz go podczas wstrzymania w debugerze, wybierając pozycję Debuguj>stos wywołań systemu Windows.>

2. Klikaj klawisz F11 kilka razy, aż w metodzie SendMessage zostanie wstrzymany debuger. Zapoznaj się z oknem stosu wywołań .

   

   W oknie Stos wywołań jest wyświetlana kolejność wywoływania metod i funkcji. W górnym wierszu jest wyświetlana bieżąca funkcja ( SendMessage metoda w tej aplikacji). Drugi wiersz pokazuje, że SendMessage został wywołany z main metody itd.

   Uwaga

   Okno Stos wywołań jest podobne do perspektywy debugowania w niektórych środowiskach IDE, takich jak Eclipse.

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

   Możesz kliknąć dwukrotnie wiersz kodu, aby sprawdzić ten kod źródłowy, a także zmienić bieżący zakres sprawdzany przez debuger. Ta akcja nie powoduje postępu debugera.

   Możesz również użyć menu prawym przyciskiem myszy w oknie Stos wywołań, aby wykonać inne czynności. Można na przykład wstawić punkty przerwania do określonych funkcji, przejść do debugera przy użyciu polecenia Uruchom do kursora i przejść do kodu źródłowego. Aby uzyskać więcej informacji, zobacz How to: Examine the Call Stack (Instrukcje: badanie stosu wywołań).

Zmienianie przepływu wykonywania

1. Naciśnij klawisz F11 dwa razy, aby uruchomić std::wcout funkcję.

2. W przypadku wstrzymania debugera w wywołaniu SendMessage metody użyj myszy, aby chwycić żółtą strzałkę (wskaźnik wykonywania) po lewej stronie i przenieść żółtą strzałkę w górę o jedną linię, z powrotem do std::wcout.

3. Naciśnij klawisz F11.

   Debuger ponownie uruchamia std::wcout funkcję (jest to widoczne w danych wyjściowych okna konsoli).

   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.

   Ostrzeżenie

   Często należy zachować ostrożność przy użyciu tej funkcji i zobaczyć ostrzeżenie w etykietce narzędzia. Mogą też zostać wyświetlone inne ostrzeżenia. Przeniesienie wskaźnika nie może przywrócić aplikacji do wcześniejszego stanu aplikacji.

4. Naciśnij klawisz F5 , aby kontynuować uruchamianie aplikacji.

   Gratulujemy ukończenia tego samouczka!

Następne kroki

W tym samouczku przedstawiono sposób uruchamiania debugera, przechodzenia przez kod i inspekcji zmiennych. Możesz uzyskać ogólne informacje na temat funkcji debugera wraz z linkami do dodatkowych informacji.

Pierwsze spojrzenie na debugera