Witam i zapraszam ponownie.
W tym wykładzie chcę przejść przez demonstrację, jak można używać debuggera.
Chcę więc przeprowadzić przez graficzny interfejs użytkownika, pokazać jak można uruchomić program w trybie
debugowania, jak można ustawić punkty przerwania, jak można spojrzeć na stos wywołań i jak można zobaczyć różne zmienne
za pomocą okna zegarka.
Po prostu prosty program, który wyznacza średnią.
Użyję tego jako mojej demonstracji.
Wszystko, co robi, to wczytuje trzy liczby całkowite i przechowuje je, a następnie oblicza ich średnią.
Teraz, jedna rzecz, o której chcę wspomnieć, zanim zaczniemy używać debuggera, musisz upewnić się,
że twoja konfiguracja jest ustawiona poprawnie.
I mówiłem o tym we wcześniejszym filmie, w zasadzie konfigurując code light do korzystania z debuggera.
Ale tylko dla odświeżenia pamięci, możesz wybrać projekt tutaj, możesz kliknąć prawym przyciskiem myszy i przechodzisz
do ustawień.
Chcesz się upewnić, że ponownie, w zależności od tego, na jakiej platformie jesteś, chcesz się upewnić,
że ustawienia debuggera tutaj po lewej stronie mają właściwą ścieżkę do GDB.
Teraz, jeśli jesteś na Windowsie, może to oznaczać użycie GDB X z Cygwin lub może to być użycie MinGW w64, cokolwiek masz działającego.
Jeśli jesteś w systemie Unix i Linux, ta ścieżka nawet nie musi być ustawiona.
Inną ważną rzeczą jest w opcjach kompilatora chcesz się upewnić, że kompilujesz
dla debugowania, aby krasnoludek Dash G był na dash o dla optymalizacji.
Ponownie, w systemie Windows, te rzeczy muszą być ustawione, aby mieć informacje o debugowaniu wraz z programem
wykonywalnym.
Musisz również upewnić się, że budujesz dla trybu debugowania.
Musisz więc upewnić się, że debug jest wybrany, a nie release.
Kiedy masz wszystkie te rzeczy skonfigurowane poprawnie, powinieneś być w stanie użyć debuggera i światła
kodu.
Jeśli masz z tym jakieś problemy, wróć proszę do mojego filmu o konfiguracji na twojej platformie.
Debugger i Code Light.
Najważniejszym pojęciem dotyczącym debugera jest idea punktu przerwania.
I tak punkt przerwania jest czymś, co możesz ustawić w swoim programie, gdzie zatrzyma wykonanie twojego
kodu.
Możesz zasadniczo powiedzieć, Hej, chcę zatrzymać się w tej linii i twój program, gdy uruchomisz
debugger, zatrzyma się w tej linii To pozwala ci patrzeć na zmienne, wartości zmiennych.
Pozwala na krok przez swój kod po jednej linii na raz, aby spróbować zdiagnozować i naprawić wszelkie problemy, które
mogą mieć.
Normalnie, kiedy uruchamiasz swój program, jeśli spróbujesz go uruchomić w debugerze i nie masz ustawionego punktu przerwania,
nic się nie stanie.
Więc normalnie, kiedy budujesz, wiesz, możesz iść i możesz zbudować swój projekt tak jak każdy
inny projekt, przejdź do budowania, przejdź do budowania projektu.
Kiedy budujesz go i uruchamiasz w trybie debugowania, musisz podejść do opcji menu debugera i musisz przejść
do startu, kontynuuj debugowanie.
A kiedy wykonasz to ponownie, jeśli masz ustawiony punkt przerwania, uderzy w niego.
Jeśli nie masz ustawionego punktu przerwania, to po prostu będzie działać.
Więc jeśli spróbujemy wykonać ten program w trybie debugowania, to po prostu pojawia się i prosi o enter, ponieważ
zatrzymuje się tuż przy liczbach, a potem wystarczy wbić kilka liczb w i po prostu się zamyka.
W zasadzie to nawet nie drukuje informacji, prawda?
Więc bardzo ważne jest, jeśli chcesz użyć debuggera, że masz ustawiony co najmniej jeden punkt przerwania.
Najprostszym sposobem ustawienia punktu przerwania jest po prostu kliknięcie wewnątrz marginesu przez numery linii na numerze linii, który chcesz
ustawić punkt przerwania.
I znowu, punkt przerwania zatrzyma wykonanie na tym numerze linii.
Jeśli więc ustawimy breakpoint tuż przy funkcji printf w linii dziesiątej, po prostu dwukrotnie klikniemy, zobaczysz,
że pojawi się czerwone kółko.
To mówi debuggerowi, hej, zatrzymaj się na linii dziesiątej.
Więc ponownie, sposób, w jaki uruchamiamy debuggera jest taki, że wchodzimy do debuggera i mówimy, start, continue, prawda?
Wszystko inne jest jakby wyszarzone, prawda?
Uruchommy więc debugger tylko po to, by trafić w ten punkt przerwania.
Więc przejdźmy do kontynuowania debugera i powiemy build and debug i zauważysz, że
program zatrzymuje się na linii dziesiątej.
Widzisz tę zieloną strzałkę, widzisz też, że pojawiło się okienko debugera.
Jeśli przejdziesz do widoku, możesz wywołać okno debugera ręcznie lub automatycznie,
gdy przejdziesz do trybu debugowania, a okno debugera ma wiele różnych zakładek dla informacji, które można zobaczyć.
Możesz też przez to przejść przez debugger wchodzisz w okna GDB, widzisz wszystkie
zaznaczone.
Istnieje wiele okien debuggera, na które możesz spojrzeć.
Więc locals zwykle ma do czynienia z twoimi lokalnymi zmiennymi zegarkami.
Możesz umieścić zegarek na zmiennej, aby jeśli zmienna się zmieni, wyskoczy.
Wyjście jest do wykorzystania dla różnych opcji debugowania i wątków wyjściowych.
Możesz faktycznie spojrzeć na wątki, które uruchamiają twój program.
Bardziej zaawansowana koncepcja Callstack jest tym, na czym się skupiamy.
Zasadniczo patrzymy na stos wywołań i locale.
To są dwa najważniejsze, które pomagają ci w debugowaniu, a następnie pamięć, a następnie również punkty przerwania.
Możesz zobaczyć, gdzie ustawione są punkty przerwania.
Tak więc wiele różnych opcji.
Obecnie zatrzymaliśmy się na linii dziesiątej.
Możemy przyjrzeć się stosowi wywołań.
Stos wywołań pokazuje nam, że wywołana została funkcja główna.
Jeśli spojrzymy na locals, pokazuje nam trzy zmienne zero jeden i zero.
Nie wprowadziliśmy właściwie żadnych informacji w tych są inicjalizowane zero jeden i zero.
Zegarek to można faktycznie dodać.
Dodaj poprzez uderzenie w znak plusa, aby dodać zegarek na konkretnej zmiennej.
Kolejną ważną rzeczą, którą należy zauważyć, jest to, że kiedy uruchamiasz w trybie debugowania, masz teraz
pasek narzędzi dla debugera, prawda?
Przycisk play będzie po prostu kontynuował.
Więc to pójdzie.
Jeśli nacisnę play, to po prostu wyjdzie z programu, tak?
Po prostu zacznie działać.
Program faktycznie poprosi o wprowadzenie danych.
Więc wcisnąłem play.
Wracam do aplikacji konsoli i mówi Enter.
Czyli trafiłem w moje trzy numery w programowych przebiegach.
Wtedy nadal nie widziałeś funkcji drukowania.
Okno po prostu zniknęło.
Więc znowu uruchamiamy w trybie debugowania i znowu przechodzi do punktu przerwania, pojawia się okienko debuggera, zatrzymuje
linię dziesiątą.
Teraz pasek narzędzi jest ważny, ponieważ w ten sposób można faktycznie przejść przez swój
kod i można użyć paska narzędzi lub przejść do debuggera i można spojrzeć na wszystkie opcje tutaj.
Więc możesz powiedzieć krok w krok w instrukcję next, następna instrukcja, krok out, krok into pójdzie
wewnątrz funkcji.
Jeśli funkcja jest wywoływana w tej linii, krok w instrukcję idzie bardziej do rzeczy typu języka
montażowego.
W następnej kolejności przeskoczymy tę linię kodu.
A instrukcja szyi to jakby to samo.
Step out, próbuje wyskoczyć z funkcji, jeśli jesteś już w jednej i przeskoczyć do linii marchewki.
Właściwie to myślę, że idzie do kursora.
To samo z biegiem do linii marchewki.
Możesz włączyć lub wyłączyć punkty przerwania, wyłączyć je wszystkie, wszystkie te rzeczy, więc możesz uzyskać dostęp do tego
przez menu.
Albo znowu pasek narzędzi.
Zazwyczaj używam paska narzędzi, ponieważ jest on już w górze.
A następnie, jeśli spojrzysz na różne okna ponownie, lokalizacje stosu wywołań i punkty przerwania.
Naprawdę te ważne.
To mówi, że mam punkt przerwania w linii dziesiątej.
A potem myślę, że jeden mówi po prostu kursor.
Więc teraz zatrzymałem się tutaj na print F enter w linii dziesiątej.
Mogę przejść do następnej instrukcji, a to spowoduje przejście do skanowania linii 11.
F jest w rzeczywistości funkcją blokującą, która prosi o dane wejściowe.
Więc jeśli spróbuję przejść dalej tutaj, to faktycznie tylko rodzaj pauzy.
Może się okazać, że będziesz musiał nacisnąć next kilka razy.
To, co zwykle robię, gdy program prosi o wejście i chcę, to już jest zablokowane, już się zatrzymało i chcę,
żeby przeszło do następnego.
Umieszczę punkt przerwania w następnej linii i nacisnę przycisk odtwarzania.
Więc teraz naciskam przycisk odtwarzania i nic się nie dzieje, ponieważ czeka na wejście.
W programie jest napisane Enter.
Więc tutaj mogę uderzyć pięć, sześć, siedem, nacisnąć przycisk enter i teraz uderza w mój punkt przerwania.
Więc teraz jesteśmy przy przycisku drukowania, gdzie możemy faktycznie wskoczyć do funkcji drukowania.
I właściwie najpierw przeskoczy do funkcji średniej.
Więc jeśli powiemy step into to widzimy, że przechodzimy do funkcji średniej.
I co zauważysz, to jeśli spojrzysz na swoje zmienne, możesz zobaczyć, jak zmieniają się twoje zmienne.
Więc jeśli pójdziesz dalej, przejdziesz do następnej linii w 27, a następnie 28, a następnie kontynuuj uderzanie.
Następnie faktycznie wyskakujesz i faktycznie jesteś na końcu funkcji.
Więc wtedy możesz uderzyć w play i możesz zobaczyć, że twój program został teraz zakończony, a okno zniknęło.
Ale możesz spojrzeć na swoje zmienne, możesz spojrzeć na wszystko inne.
I tak, ponownie, możesz również umieścić punkt przerwania wewnątrz funkcji drukowania właśnie tutaj.
A jeśli uruchomimy do tego, możemy ponownie zobaczyć, że funkcja print zatrzyma wykonanie zamiast średniej.
I wtedy możemy jakby zobaczyć, co się dzieje w rzeczywistości, jeśli przejdziemy i przejdziemy
do aplikacji, widać, że informacje zostały wydrukowane.
Prawda?
Kiedy kontynuujesz, kiedy biegniesz do końca, otrzymujesz deklarację return i program się kończy.
Więc ważne jest, jeśli chcesz zobaczyć wyjście programu, że umieszczasz punkt przerwania
przed tym powrotem i nie musisz kontynuować.
Możesz zatrzymać debugger, uderzając w ten czerwony prostokąt, wstrzymać debugger, uderzając w dwa równoległe
paski, ponownie uruchomić debugger za pomocą tej opcji i callstack.
Ponownie, łatwiej jest zobaczyć tutaj, jeśli dostaniesz się do wnętrza funkcji i uruchomisz debugger, uruchomimy debugger
ponownie.
Powiedz debugger, start, kontynuuj.
I kiedy uderzymy w ten punkt przerwania po wprowadzeniu informacji wewnątrz funkcji, zobaczysz, że stos
samochodów ma main i print, tak jak pokazaliśmy wcześniej.
I tak możesz zobaczyć ostatnią funkcję, która została wywołana teraz z programem, który ma wiele funkcji i tak dalej,
stos wywołań może stać się znacznie większy niż ten.
Jedyną inną rzeczą, która może być ważna, są punkty przerwania.
Jeśli chcesz zobaczyć, jakie punkty przerwania ustawiłeś, pokaże ci wszystkie punkty przerwania i cały twój program,
w którym się znajdują.
Ale będziesz musiał się z tym bawić, zapoznać się z nim, wygodnie się z nim zapoznać i używać go dość często w przypadku problemów,
których nie możesz rozgryźć za pomocą podstawowych technik debugowania lub programów.
Crash idzie linia po linii.
I jak idziesz linia po linii, możesz faktycznie zobaczyć, jak program kończy się, gdy się zawiesi i
będziesz wiedział, w której linii to się stało.
Ponownie, jest to mały program, ale powinieneś uzyskać podstawowe zrozumienie, jak działa debugowanie.
Ponownie, mam nadzieję, że to było pomocne.
Najlepszym sposobem na nauczenie się tych rzeczy jest rozpoczęcie zabawy z nimi i rozpoczęcie korzystania z nich.
Przywołaj jeden z programów, nad którymi pracowałeś w poprzednim wyzwaniu.
Dodaj punkt przerwania, bardzo proste.
Wystarczy kliknąć prawym przyciskiem wewnątrz rzeczy, aby dodać punkty przerwania.
Uruchom go w trybie debugowania i przejdź przez każdą linię i zobacz, jak zmieniają się zmienne i jak
wzrasta stos wywołań.
Jeśli masz większe funkcje.
Dziękuję.