3.7 — Korzystanie ze zintegrowanego debugera: Uruchamianie i punkty przerwania

Podczas wykonywania kroków (omówione w lekcji 3.6 — Korzystanie ze zintegrowanego debugera: Stepping) jest przydatny do sprawdzania każdej pojedynczej linii kodu z osobna, w dużym programie przejście przez kod nawet do punktu, w którym chcesz sprawdzić bardziej szczegółowo, może zająć dużo czasu.

Na szczęście nowoczesne debugery zapewniają więcej narzędzi, które pomagają nam skutecznie debugować nasze programy. W tej lekcji przyjrzymy się niektórym funkcjom debugera, które pozwalają nam szybciej poruszać się po kodzie.

Uruchom do kursora

Pierwsze przydatne polecenie jest powszechnie nazywane Uruchom do kursora. To Uruchom do kursora poleceniem, które wykonuje program, dopóki wykonanie nie osiągnie instrukcji wybranej przez kursor. Następnie zwraca Ci kontrolę, dzięki czemu możesz debugować zaczynając od tego momentu. Zapewnia to efektywny sposób rozpoczęcia debugowania w określonym miejscu kodu lub, jeśli już debugujesz, przejścia od razu do miejsca, które chcesz dokładniej sprawdzić.

Spróbujmy tego przy użyciu tego samego programu, którego używaliśmy używając:

#include <iostream>

void printValue(int value)
{
    std::cout << value << '\n';
}

int main()
{
    printValue(5);

    return 0;
}

Po prostu kliknij prawym przyciskiem myszy w dowolnym miejscu linii 5, a następnie wybierz „Uruchom do kursora”.

Zauważysz, że program zacznie działać, a znacznik wykonania przesunie się do właśnie wybranej linii. Twój program został wykonany do tego momentu i teraz czeka na dalsze polecenia debugowania. Stąd możesz przejść przez swój program, uruchom do kursor do innej lokalizacji itd...

Jeśli uruchom do kursor do lokalizacji, która nie jest wykonywana, uruchom do kursor po prostu uruchomi program do momentu zakończenie.

Continue

Gdy jesteś w środku sesji debugowania, możesz po prostu uruchomić program od tego momentu. Najłatwiej to zrobić, używając komendy Kontynuować . Polecenie Kontynuować debug po prostu kontynuuje normalne działanie programu do czasu jego zakończenia lub do chwili, gdy coś spowoduje powrót sterowania do ciebie (np. punkt przerwania, o którym omówimy w dalszej części tej lekcji).

Przetestujmy polecenie Kontynuować . Jeśli Twój znacznik wykonania nie znajduje się jeszcze w linii 5, uruchom do kursor do linii 5. Następnie wybierz Kontynuować od tego miejsca. Twój program zakończy wykonywanie, a następnie zakończy działanie.

Start

Klasa Kontynuować polecenie ma brata bliźniaka o imieniu start. Słowo kluczowe start polecenie wykonuje tę samą akcję co Kontynuować, zaczynam od początku programu. Można je wywołać tylko wtedy, gdy nie jest to jeszcze sesja debugowania.

Jeśli użyjesz polecenia start w powyższym przykładowym programie, będzie on działał bez przerwy (z wyjątkiem na VS Code, ponieważ ustawiliśmy stopAtEntry: true na poprzedniej lekcji). Choć może się to wydawać niczym niezwykłym, dzieje się tak tylko dlatego, że nie powiedzieliśmy debugerowi, aby przerwał program. Lepiej wykorzystamy to polecenie w następnej sekcji.

Punkty przerwania

Ostatnim tematem, który omówimy w tej sekcji, są punkty przerwania. A punkt przerwania to specjalny znacznik, który informuje debuger, aby zatrzymał wykonywanie programu w punkcie przerwania podczas działania w trybie debugowania.

Gdy ustawisz punkt przerwania, pojawi się ikona nowego typu. Visual Studio używa czerwonego koła, Code::Blocks używa czerwonego ośmiokąta (jak znak stopu):

Śmiało, ustaw punkt przerwania w linii 5, jak pokazano na powyższym obrazku.

Teraz wybierz polecenie Start , aby debuger uruchomił Twój kod i zobaczmy punkt przerwania w akcji. Zauważysz, że zamiast działać aż do końca programu, debugger zatrzymuje się w punkcie przerwania (ze znacznikiem wykonania umieszczonym na górze ikony punktu przerwania):

To tak, jakbyś uruchom do kursor do tego punktu.

Punkty przerwania mają kilka zalet w porównaniu z uruchom do kursor. Po pierwsze, punkt przerwania spowoduje, że debuger zwróci kontrolę za każdym razem, gdy zostanie napotkany (w przeciwieństwie do uruchom do kursor, który uruchamia się do kursora tylko raz przy każdym wywołaniu). Po drugie, możesz ustawić punkt przerwania i będzie on trwał, dopóki go nie usuniesz, podczas gdy w uruchom do kursor musisz zlokalizować miejsce, do którego chcesz się uruchomić za każdym razem, gdy wywołasz polecenie.

Pamiętaj, że punkty przerwania umieszczone w liniach, które nie znajdują się na ścieżce wykonania, nie spowodują, że debuger zatrzyma wykonywanie kodu.

Przyjrzyjmy się temu nieco zmodyfikowany program, który lepiej ilustruje różnicę pomiędzy punktami przerwania i uruchom do kursor:

#include <iostream>

void printValue(int value)
{
    std::cout << value << '\n';
}

int main()
{
    printValue(5);
    printValue(6);
    printValue(7);

    return 0;
}

Najpierw rozpocznij nową sesję debugowania, a następnie wykonaj uruchom do kursor do linii 5. Teraz wybierz Kontynuować. Program będzie kontynuowany do końca (nie zatrzyma się ponownie na linii 5, mimo że linia 5 zostanie wykonana jeszcze dwukrotnie).

Następnie umieść punkt przerwania w linii 5, a następnie wybierz start. Program zatrzyma się na linii 5. Teraz wybierz Kontynuować. Program zatrzyma się na linii 5 po raz drugi. Wybierz Kontynuować ponownie, a zatrzyma się po raz trzeci. Jeszcze jeden Kontynuować i program się zakończy. Widać, że punkt przerwania powodował zatrzymanie programu tyle razy, ile razy wykonywano tę linię.

Ustaw następną instrukcję

Jest jeszcze jedno polecenie debugowania, które jest używane dość rzadko, ale warto o nim wiedzieć, nawet jeśli nie będziesz go używać zbyt często. Polecenie set next instrukcja pozwala nam zmienić punkt wykonania na inną instrukcję (czasami nieformalnie nazywaną skokiem). Można tego użyć do przeskoczenia punktu wykonania do przodu i pominięcia części kodu, który w przeciwnym razie zostałby wykonany, lub do tyłu i ponownego uruchomienia czegoś, co zostało już wykonane.

Zobaczmy skakanie do przodu w akcji:

#include <iostream>

void printValue(int value)
{
    std::cout << value << '\n';
}

int main()
{
    printValue(5);
    printValue(6);
    printValue(7);

    return 0;
}

Najpierw uruchom do kursor do linii 11. W tym momencie powinieneś zobaczyć wartość 5 w oknie wyjściowym konsoli.

Teraz kliknij prawym przyciskiem myszy linię 12 i wybierz set next instrukcja. Powoduje to pominięcie linii 11 i jej niewykonanie. Następnie wybierz Kontynuować , aby zakończyć wykonywanie programu.

Wyjście programu powinno wyglądać tak:

5
7

Widzimy, że printValue(6) zostało pominięte.

Ta funkcja może być użyteczna w kilku kontekstach.

W trakcie eksploracji podstawowych technik debugowania omawialiśmy komentowanie funkcji w celu ustalenia, czy funkcja ta odegrała rolę w powodowaniu problemu. Wymaga to modyfikacji naszego kodu i pamiętania o późniejszym odkomentowaniu funkcji. W debugerze nie ma bezpośredniego sposobu na pominięcie funkcji, więc jeśli zdecydujesz, że chcesz to zrobić, najłatwiej to zrobić za pomocą set next instrukcja przeskakiwania wywołań funkcji.

Przeskakiwanie do tyłu może być również przydatne, jeśli chcemy zobaczyć, jak funkcja, która właśnie została wykonana, została uruchomiona ponownie, dzięki czemu możemy zobaczyć, co robi.

Korzystając z tego samego kodu powyżej, uruchom do kursor do linii 12. Następnie set next instrukcja w linii 11 i Kontynuować. Dane wyjściowe programu powinny brzmieć:

5
6
6
7

„Krok wstecz” zamiast skakania do tyłu za pomocą „Ustaw następną instrukcję”

„Krok wstecz” przewija stan wszystkiego tak, jakbyś nigdy nie przekroczył tego punktu. Wszelkie zmiany wartości zmiennych lub innego stanu programu zostaną cofnięte. Zasadniczo jest to polecenie „cofnij” dla wykonywania kroków.

„Ustaw następną instrukcję” użyte do skoku wstecz zmienia jedynie punkt wykonania. Wszelkie zmiany wartości zmiennych lub innego stanu programu nie zostaną cofnięte.

Wnioski

Poznałeś teraz główne sposoby wykorzystania zintegrowanego debugera do monitorowania i kontrolowania sposobu wykonywania programu. Chociaż te polecenia mogą być przydatne do diagnozowania problemów z przepływem kodu (np. do określenia, czy określone funkcje są wywoływane, czy nie), stanowią one tylko część korzyści, jakie zapewnia zintegrowany debuger. W następnej lekcji zaczniemy odkrywać dodatkowe sposoby sprawdzania stanu programu, do czego będziesz potrzebować tych poleceń jako warunku wstępnego. Zaczynamy!