1
00:00:00,000 --> 00:00:00,309

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:] Witam,
Jestem [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Dzisiaj jedziemy do
patrząc na debugowanie.

4
00:00:04,410 --> 00:00:06,697
Nie tylko będziemy
mówić o pewnych technik,

5
00:00:06,697 --> 00:00:09,280
ale również będziemy patrzeć na
niektóre funkcje zawarte

6
00:00:09,280 --> 00:00:14,170
w IDE CS50, które pozwalają
łatwe debugowanie programu.

7
00:00:14,170 --> 00:00:16,272
>> Tylko jeden z przykładów
coś, co może się nie udać

8
00:00:16,272 --> 00:00:18,730
i to rzeczywiście coś
które widzieliśmy już wcześniej.

9
00:00:18,730 --> 00:00:23,200
W tym przypadku, to program C
który przyjmuje liczbę całkowitą od użytkownika,

10
00:00:23,200 --> 00:00:27,580
dzieli się przez dwa, a także zapewnia
wyjście z powrotem do użytkownika.

11
00:00:27,580 --> 00:00:30,610
Teraz od tego, co widzieliśmy
wcześniej w wykładach,

12
00:00:30,610 --> 00:00:34,370
Wiemy, że będzie to rzeczywiście spowodować
specyficzne rodzaje problemów podziału

13
00:00:34,370 --> 00:00:35,860
kiedy mają numery nieparzyste.

14
00:00:35,860 --> 00:00:40,330
>> W szczególności, po prostu wyrzucić
wszystko po przecinku.

15
00:00:40,330 --> 00:00:43,170
Teraz wiemy, że to
dzieje się inaczej.

16
00:00:43,170 --> 00:00:47,430
A jeśli go uruchomić, możemy potwierdzić,
nasze podejrzenia, po pierwsze, kompilacji.

17
00:00:47,430 --> 00:00:50,460
A potem, przez prowadzenie i
wprowadzenie nieparzystej.

18
00:00:50,460 --> 00:00:51,720
>> To nie jest nic nowego.

19
00:00:51,720 --> 00:00:54,490
Ale to jest w rzeczywistości
Przykładem błędu, że

20
00:00:54,490 --> 00:00:58,810
może istnieć w ramach większego programu
że staje się trudniejsze do wyśledzenia.

21
00:00:58,810 --> 00:01:02,640
Nawet jeśli wiemy, co to jest problem
jest prawdziwe sedno sprawy

22
00:01:02,640 --> 00:01:06,250
może być trudny do określenia
szczególnie, gdy wystąpi błąd,

23
00:01:06,250 --> 00:01:09,750
identyfikacja co to problemu
Jest, a następnie naprawić.

24
00:01:09,750 --> 00:01:14,400
Więc zapewnić to jako przykład
z tego, co może być coś

25
00:01:14,400 --> 00:01:19,030
że już wiemy, ale może być pochowany
w ramach innych elementów kodu.

26
00:01:19,030 --> 00:01:23,090
>> Więc otwarciu tego innego źródła
Plik kod jako przykład,

27
00:01:23,090 --> 00:01:27,165
problem ten podział jest teraz
część większego programu.

28
00:01:27,165 --> 00:01:29,040
Wciąż może być trochę
nieco wymyślił, a my

29
00:01:29,040 --> 00:01:31,076
może być w stanie łatwo
go zidentyfikować, zwłaszcza

30
00:01:31,076 --> 00:01:32,450
ponieważ jesteśmy po prostu omawiania tego.

31
00:01:32,450 --> 00:01:38,250
Ale możemy dowiedzieć się, że to
Problem ten może występować w większej skali.

32
00:01:38,250 --> 00:01:45,450
>> Jeśli mogę skompilować to i teraz
go uruchomić, wprowadzić nieparzysta,

33
00:01:45,450 --> 00:01:49,816
widzimy, że nie mamy precyzyjnie
wyjście, że możemy się spodziewać.

34
00:01:49,816 --> 00:01:51,690
W tym konkretnym przypadku,
możemy powiedzieć, że

35
00:01:51,690 --> 00:01:56,060
chcą liczyć wszystkie numery
od jednego do jakiegoś konkretnego numeru.

36
00:01:56,060 --> 00:01:58,130
I widzimy, że my
mają różne problemy

37
00:01:58,130 --> 00:02:03,880
tutaj, jeśli mamy na wyjściu, po prostu, 0
i 1, gdy zapewniamy wejście 5.

38
00:02:03,880 --> 00:02:07,380
>> Tak więc wiemy już, że
istnieje problem tutaj.

39
00:02:07,380 --> 00:02:11,662
Ale może nie wiedzieć dokładnie,
gdzie ten problem rzeczywiście istnieje.

40
00:02:11,662 --> 00:02:13,620
Teraz jeden ze sposobów, które
możemy spróbować to naprawić

41
00:02:13,620 --> 00:02:15,745
jest coś, co mamy
już wprowadzone.

42
00:02:15,745 --> 00:02:18,880
Możemy po prostu używać go w większej skali.

43
00:02:18,880 --> 00:02:21,680
>> W linii 14, mamy
printf tej funkcji,

44
00:02:21,680 --> 00:02:25,620
co pozwala nam wydrukować stanie
z różnych informacji.

45
00:02:25,620 --> 00:02:28,880
I to jest coś, co Cię
Należy wykorzystać w swoim programie

46
00:02:28,880 --> 00:02:33,100
aby spróbować dowiedzieć się dokładnie, co jest
dzieje się w różnych linii kodu.

47
00:02:33,100 --> 00:02:36,350
Więc nawet jeśli nie jest to
wyjście ostateczne, że faktycznie

48
00:02:36,350 --> 00:02:39,830
chcą produkować z
ten program, nadal

49
00:02:39,830 --> 00:02:42,300
może mieć jakiś debug
Oświadczenia, gdzie

50
00:02:42,300 --> 00:02:46,970
Można spróbować dowiedzieć się, co dokładnie
dzieje się wewnątrz naszego kodu.

51
00:02:46,970 --> 00:02:51,210
>> Więc w tym przypadku, będę
printf z tagiem debugowania.

52
00:02:51,210 --> 00:02:53,540
W tym przypadku jest
tylko ciąg debug

53
00:02:53,540 --> 00:02:56,840
że mi się odpychające, tak, że staje
bardzo jasne, na wyjściu mojego kodu

54
00:02:56,840 --> 00:02:59,200
co to jest, że chcę pokazać.

55
00:02:59,200 --> 00:03:04,410
I wyjście tutaj numer
że mamy obliczone.

56
00:03:04,410 --> 00:03:06,800
>> W tym przypadku, mogę
chcą wiedzieć dokładnie

57
00:03:06,800 --> 00:03:11,380
to, co dzieje się przed i
po jakimś konkretnym obliczeń.

58
00:03:11,380 --> 00:03:16,224
Więc mogę używać printf przed
i po tej linii kodu.

59
00:03:16,224 --> 00:03:18,640
W tym przypadku, mogłem nawet
sprawiają, że nieco bardziej jasne

60
00:03:18,640 --> 00:03:21,960
mówiąc debug przed
i debugowania po tak

61
00:03:21,960 --> 00:03:26,540
że nie myli się z
wiele linii, które wyglądają identyczne.

62
00:03:26,540 --> 00:03:32,290
>> Jeśli teraz skompilować to i bieg
to, wprowadź numer jak pięć znowu,

63
00:03:32,290 --> 00:03:35,090
widzimy, że mamy
teraz wyjście przed i po

64
00:03:35,090 --> 00:03:40,670
i okaże się, że nie zrobiliśmy wyraźny
podziału lub jasno o liczby

65
00:03:40,670 --> 00:03:43,680
że rzeczywiście chcemy zrobić.

66
00:03:43,680 --> 00:03:48,660
Obecnie w tym przypadku jest
nie bardzo wyraźne wyjście.

67
00:03:48,660 --> 00:03:52,440
To naprawdę nie jest to oczywiste, że wynik
chcemy z tego konkretnego programu.

68
00:03:52,440 --> 00:03:54,427
>> I to jest, znowu,
trochę wymyślone.

69
00:03:54,427 --> 00:03:57,510
Ale, być może, jedną z rzeczy, które
możemy zrobić, jeżeli specyfikacja powiedział

70
00:03:57,510 --> 00:04:01,900
że chcemy podzielić to przez
2 i dodać 1-- więc innymi słowy,

71
00:04:01,900 --> 00:04:04,550
chcemy zaokrąglić up-- następnie
możemy wiedzieć, że mogliśmy

72
00:04:04,550 --> 00:04:08,060
to, że konkretnej rzeczy, w tym przypadku.

73
00:04:08,060 --> 00:04:14,010
A teraz wiemy, że będziemy
w stanie dodać 1 do naszej połowę liczby.

74
00:04:14,010 --> 00:04:16,490
>> Miejmy skompilować to
i potwierdzić, że ta

75
00:04:16,490 --> 00:04:18,860
zachowuje się tak, że chcemy.

76
00:04:18,860 --> 00:04:21,980
Widzimy, że teraz przed
o, mamy numer 5.

77
00:04:21,980 --> 00:04:26,620
Po, mamy numer 3,
który zgodnie z naszym opisie

78
00:04:26,620 --> 00:04:29,292
jest to, co chcieliśmy zrobić.

79
00:04:29,292 --> 00:04:31,000
Ale jeśli spojrzeć na
Wyjście tutaj, możemy

80
00:04:31,000 --> 00:04:33,760
zobaczyć, że możemy mieć inny
bug w ogóle, co jest

81
00:04:33,760 --> 00:04:36,940
że zaczynamy naszą liczbę od 0.

82
00:04:36,940 --> 00:04:39,390
>> Teraz znowu, to jest coś,
które widzieliśmy w przeszłości

83
00:04:39,390 --> 00:04:42,500
i możemy rozwiązać dość łatwo.

84
00:04:42,500 --> 00:04:44,790
Jednak w tym przypadku,
miał również korzyści

85
00:04:44,790 --> 00:04:48,940
korzystania z instrukcji printf
bezpośrednio w pętli for

86
00:04:48,940 --> 00:04:52,930
wiedzieć dokładnie, gdzie
że błąd został występujących.

87
00:04:52,930 --> 00:04:55,150
Więc printf są
bardzo przydatne w pomaganiu

88
00:04:55,150 --> 00:04:57,940
można określić, gdzie,
właśnie w kodzie źródłowym,

89
00:04:57,940 --> 00:05:00,620
konkretny błąd występuje.

90
00:05:00,620 --> 00:05:03,650
>> I to jest również uświadomienie sobie
że jak jesteśmy pisania kodu,

91
00:05:03,650 --> 00:05:06,052
możemy mieć założenia
o stanie programu.

92
00:05:06,052 --> 00:05:08,510
A może mamy założenia
o tym, co należy do programu

93
00:05:08,510 --> 00:05:13,020
jest rzeczywiście poprawne lub niepoprawne, gdy
później, jak budujemy na tym programie

94
00:05:13,020 --> 00:05:15,950
i sprawiają, że część
złożone i większe Program

95
00:05:15,950 --> 00:05:19,700
, że zdajemy sobie sprawę, że niektóre z aspektów
stanowi, że jest rzeczywiście buggy.

96
00:05:19,700 --> 00:05:22,680
>> Korzystanie printf może naprawdę pomóc
zawężenia i identyfikacji

97
00:05:22,680 --> 00:05:26,430
regiony programu, który nie może
należy zachowywać się dokładnie tak, że

98
00:05:26,430 --> 00:05:29,500
spodziewać, na podstawie naszych założeń.

99
00:05:29,500 --> 00:05:31,460
Ale jest inne narzędzia
dostępne, jak również,

100
00:05:31,460 --> 00:05:34,860
które pozwalają nam spróbować rysunku
gdzie błąd występuje

101
00:05:34,860 --> 00:05:39,930
a także, w szczególności, jakie rzeczy
dzieje się wewnątrz programu.

102
00:05:39,930 --> 00:05:41,990
>> Tak więc za pomocą printf jest bardzo
przydatne, gdy chcemy

103
00:05:41,990 --> 00:05:45,900
zidentyfikować konkretne obszary
program, który ma jakiś błąd.

104
00:05:45,900 --> 00:05:47,730
Ale również staje
nudne po chwili.

105
00:05:47,730 --> 00:05:50,500
W tym przypadku, to jest
stosunkowo prosty program

106
00:05:50,500 --> 00:05:52,750
z jednego lub dwóch zmiennych.

107
00:05:52,750 --> 00:05:57,260
I to staje się bardzo łatwe dla nas
wydrukować wartości tych zmiennych

108
00:05:57,260 --> 00:05:59,670
w ramach większego programu.

109
00:05:59,670 --> 00:06:02,670
>> Ale możemy mieć inny
Program, który ma wiele zmiennych.

110
00:06:02,670 --> 00:06:06,530
I nie może być zupełnie
tak łatwe w użyciu printf

111
00:06:06,530 --> 00:06:10,120
spróbować ocenić, co się dzieje
na każdej z tych zmiennych

112
00:06:10,120 --> 00:06:13,590
jak program jest wykonywany.

113
00:06:13,590 --> 00:06:16,960
Jest to program, który istnieje
zwany program debugger.

114
00:06:16,960 --> 00:06:20,320
W tym przypadku, który będziemy
stosowanie jest debugger GNU lub GDB,

115
00:06:20,320 --> 00:06:24,260
która pozwala nam sprawdzić wewnętrzny
funkcjonowanie programu w znacznie bardziej

116
00:06:24,260 --> 00:06:25,700
Szczegółowy sposób.

117
00:06:25,700 --> 00:06:28,810
>> Faktycznie możemy wykonać
GDB z wiersza poleceń

118
00:06:28,810 --> 00:06:35,370
tutaj po prostu wpisując GDB i
polecenia, które chcemy debugować.

119
00:06:35,370 --> 00:06:37,550
W tym przypadku liczy.

120
00:06:37,550 --> 00:06:41,650
Teraz w tym przypadku, możemy zobaczyć, że
prowadzi nas do wiersza, który mówi GDB.

121
00:06:41,650 --> 00:06:44,020
I możemy rzeczywiście
wykonywanie poleceń do GDB

122
00:06:44,020 --> 00:06:48,260
faktycznie rozpocząć realizacji
Program, zatrzymać go w niektórych punktach,

123
00:06:48,260 --> 00:06:51,060
oceny zmiennych i
sprawdzić zmienne, które

124
00:06:51,060 --> 00:06:54,152
istnieje w stanie programu
w danym momencie

125
00:06:54,152 --> 00:06:55,110
i tak dalej i tak dalej.

126
00:06:55,110 --> 00:06:57,240
To zapewnia dużo mocy, aby nas.

127
00:06:57,240 --> 00:06:59,960
>> Ale tak się składa,
że IDE CS50 również

128
00:06:59,960 --> 00:07:05,870
zapewnia GUI lub użytkownika
interfejs do GDB, że

129
00:07:05,870 --> 00:07:11,120
pozwala nam to zrobić bez konieczności
interfejs wiersza poleceń ogóle

130
00:07:11,120 --> 00:07:13,560
lub nawet w ogóle.

131
00:07:13,560 --> 00:07:16,930
Sposób, w jaki można uzyskać dostęp, że
jest za pomocą przycisku debugowania

132
00:07:16,930 --> 00:07:20,120
na samym szczycie IDE CS50.

133
00:07:20,120 --> 00:07:24,280
Teraz w przeszłości, co mamy
widać jest to, że możemy użyć polecenia

134
00:07:24,280 --> 00:07:27,660
Linia skompilować i uruchomić program.

135
00:07:27,660 --> 00:07:29,790
>> Przycisk debug robi
obydwie te czynności.

136
00:07:29,790 --> 00:07:34,380
Ale także przyniesie w górę
Zakładka debugger po prawej stronie

137
00:07:34,380 --> 00:07:38,280
która pozwala nam sprawdzić różne
właściwości programu

138
00:07:38,280 --> 00:07:40,500
ponieważ jest wykonywany.

139
00:07:40,500 --> 00:07:44,280
Gdybym kliknij debug, w tym
Sprawa będzie wychowywać

140
00:07:44,280 --> 00:07:48,230
nowa karta w konsoli
Okno na samym dole.

141
00:07:48,230 --> 00:07:51,160
>> I widać, że ta karta ma
niektóre informacje na samej górze.

142
00:07:51,160 --> 00:07:52,670
I możemy w dużej mierze to zignorować.

143
00:07:52,670 --> 00:07:54,800
Ale jedną z rzeczy,
że chcemy zauważać

144
00:07:54,800 --> 00:07:57,170
jest to, że generuje
to samo, co my

145
00:07:57,170 --> 00:08:03,000
dostanie, jeśli próbował uruchomić, aby na
Program C w oknie terminala.

146
00:08:03,000 --> 00:08:06,230
>> Tutaj widzimy, że to działa szczęk,
i ma wiele flag,

147
00:08:06,230 --> 00:08:12,660
i jest kompilacją nasz plik count.c,
który był wybrany tab chwili

148
00:08:12,660 --> 00:08:15,100
że uderzę debug.

149
00:08:15,100 --> 00:08:18,010
Więc to jest bardzo przydatne, ponieważ
teraz za pomocą tego przycisku debugowania,

150
00:08:18,010 --> 00:08:23,280
możemy jednocześnie kompilacji, a następnie
uruchomić program, który tak naprawdę

151
00:08:23,280 --> 00:08:24,460
chce uruchomić.

152
00:08:24,460 --> 00:08:27,880
>> Jedna z flag, które jest
ważny w tym przypadku

153
00:08:27,880 --> 00:08:30,190
my faktycznie przy użyciu
najdłużej

154
00:08:30,190 --> 00:08:32,450
ale także po prostu zrobił kilka rękę
machając [niesłyszalne], który

155
00:08:32,450 --> 00:08:33,820
Jest to jeden tutaj.

156
00:08:33,820 --> 00:08:35,790
W brzękiem, mówi -ggdb3.

157
00:08:35,790 --> 00:08:38,570

158
00:08:38,570 --> 00:08:41,250
W tym przypadku, co jest
mówi brzękiem, nasz kompilator,

159
00:08:41,250 --> 00:08:43,820
jest to, że chcemy skompilować nasz program.

160
00:08:43,820 --> 00:08:46,810
Ale również to, co jest
nazywa informacje symbolem

161
00:08:46,810 --> 00:08:50,940
tak, że kompilator faktycznie ma dostęp
do wielu podstawowej informacji

162
00:08:50,940 --> 00:08:52,610
zawarte w programie.

163
00:08:52,610 --> 00:08:55,260
>> Bardziej konkretnie, ilość
funkcji, które mam,

164
00:08:55,260 --> 00:08:58,000
nazwiska tych funkcji,
zmienne, rodzajów

165
00:08:58,000 --> 00:09:01,730
że te zmienne są, i wiele
innych rzeczy, które pomagają debuggera

166
00:09:01,730 --> 00:09:04,350
wykonywać swoją pracę.

167
00:09:04,350 --> 00:09:06,600
Teraz jest coś jeszcze
że ważne jest, aby wspomnieć,

168
00:09:06,600 --> 00:09:10,280
kiedy będziemy dyskutować bieganie
Program w ten sposób.

169
00:09:10,280 --> 00:09:13,660
>> Zauważ, że to ma rzeczywiście
przyniósł nową kartę w naszej konsoli

170
00:09:13,660 --> 00:09:14,780
u dołu.

171
00:09:14,780 --> 00:09:18,600
Nie musimy już do interakcji
bezpośrednio z oknem zaciskowej.

172
00:09:18,600 --> 00:09:21,420
Ale ta nowa karta jest
faktycznie okno terminala.

173
00:09:21,420 --> 00:09:26,710
To po prostu jest specyficzny do biegania
Program, który stworzyliśmy.

174
00:09:26,710 --> 00:09:29,270
>> Należy zauważyć, że w dolnej części, w
Połączenie z jakimś wyjściem

175
00:09:29,270 --> 00:09:33,500
przez brzękiem kompilator i GDB,
które możemy w dużym stopniu ignorować,

176
00:09:33,500 --> 00:09:37,570
to faktycznie pokazuje wyjście
nasz program na samym dole.

177
00:09:37,570 --> 00:09:41,240
Teraz ważne jest, aby uświadomić sobie,
że jedno okno w rzeczywistości

178
00:09:41,240 --> 00:09:43,360
pozwoli Ci pokazać
Wyjście z programu

179
00:09:43,360 --> 00:09:47,190
ale również może zaakceptować wejście
dla tego programu, jak również.

180
00:09:47,190 --> 00:09:49,260
>> Tak więc informacja, że ​​mówi
należy wprowadzić numer,

181
00:09:49,260 --> 00:09:53,050
które jest takie samo wyjście, które mieliśmy
miał w oknie terminala przed.

182
00:09:53,050 --> 00:09:55,510
Ale to już przedstawiono w tej nowej karcie.

183
00:09:55,510 --> 00:09:56,550
I może wprowadzić numer.

184
00:09:56,550 --> 00:10:00,900
I to będzie w rzeczywistości
funkcja, jak oczekujemy

185
00:10:00,900 --> 00:10:05,890
pokazuje nam naszą debug, wyjście,
wyjście, które może być wadliwy,

186
00:10:05,890 --> 00:10:07,010
jak widzieliśmy wcześniej.

187
00:10:07,010 --> 00:10:10,460
A na samym dole, to
faktycznie ma jakieś dodatkowe wyjście

188
00:10:10,460 --> 00:10:14,550
od PKB tylko powiedzieć, że
program ten zakończył.

189
00:10:14,550 --> 00:10:16,655
>> Teraz, jak widzieliśmy w tym
szczególności prowadzony przez,

190
00:10:16,655 --> 00:10:19,370
nie jest szczególnie
przydatne, ponieważ nawet

191
00:10:19,370 --> 00:10:23,740
że mieliśmy menu debuggera się
w górę, to był jeszcze program.

192
00:10:23,740 --> 00:10:26,790
W żadnym momencie nie jest w rzeczywistości
wstrzymać wykonanie dla nas

193
00:10:26,790 --> 00:10:30,767
aby móc zbadać cały
zmienne zawarte w.

194
00:10:30,767 --> 00:10:32,850
Jest coś jeszcze
które musimy zrobić, aby

195
00:10:32,850 --> 00:10:36,910
aby uznać, że GDB chcemy
aby wstrzymać wykonanie programu

196
00:10:36,910 --> 00:10:42,820
a nie tylko pozwolić mu kontynuować
normalnie jak w przypadku każdego innego przypadku.

197
00:10:42,820 --> 00:10:45,530
>> Aby wstrzymać wykonanie,
w pewnej określonej linii,

198
00:10:45,530 --> 00:10:47,830
musimy stworzyć co
nazywa się punkt krytyczny.

199
00:10:47,830 --> 00:10:52,670
I punkt krytyczny jest bardzo łatwo stworzyć
w tym CS50 IDE poprzez myszki

200
00:10:52,670 --> 00:10:57,090
i kliknięcie bezpośrednio do lewej
jakiegoś konkretnego numeru linii.

201
00:10:57,090 --> 00:10:59,920
Po to zrobić, czerwona kropka
wydaje się, co wskazuje

202
00:10:59,920 --> 00:11:02,300
że jest to obecnie punkt krytyczny.

203
00:11:02,300 --> 00:11:07,540
>> I następnym razem, że biegnę GDB, to
zatrzyma się wykonanie w tym momencie przerwy

204
00:11:07,540 --> 00:11:10,280
po osiągnięciu tej linii kodu.

205
00:11:10,280 --> 00:11:12,230
Teraz jest to ważny
rzeczą, aby uświadomić sobie,

206
00:11:12,230 --> 00:11:16,140
że to nie jest koniecznie
tak, że każda linia kodu

207
00:11:16,140 --> 00:11:17,880
jest w rzeczywistości dostępne.

208
00:11:17,880 --> 00:11:23,780
Gdybym miał stworzyć funkcję
tu, na example-- void F--

209
00:11:23,780 --> 00:11:31,230
i po prostu zrobić linię wydruku here-- komentarzy
world-- jeśli nigdy nie wywołać tę funkcję,

210
00:11:31,230 --> 00:11:34,770
będzie to przypadek, że
jeżeli ustawić punkt przerwy tutaj,

211
00:11:34,770 --> 00:11:36,220
funkcja nie zostanie wywołana.

212
00:11:36,220 --> 00:11:38,310
I dlatego ta
szczególności punkt krytyczny

213
00:11:38,310 --> 00:11:43,040
będzie w rzeczywistości nigdy nie zatrzymać
Realizacja programu.

214
00:11:43,040 --> 00:11:48,020
>> Więc powiedzmy, że ja właściwie stworzyć
punkt załamania na jakiejś linii kodu

215
00:11:48,020 --> 00:11:50,340
które będą faktycznie wykonywany.

216
00:11:50,340 --> 00:11:53,470
Obecnie w tym przypadku, to jest
Pierwsza linia w głównej funkcji.

217
00:11:53,470 --> 00:11:56,630
Więc będzie to na pewno przypadek
że, jak tylko rozpocząć realizację,

218
00:11:56,630 --> 00:11:58,580
zostanie osiągnięty pierwszy wiersz.

219
00:11:58,580 --> 00:12:00,230
GDB będzie wstrzymać wykonanie.

220
00:12:00,230 --> 00:12:04,100
A potem, będę w stanie
interakcji z debuggera.

221
00:12:04,100 --> 00:12:08,480
>> Można ustawić wiele linii jak
przerwań jeśli chcesz.

222
00:12:08,480 --> 00:12:11,365
Możemy również utworzyć linię w górę
tu w tym segmencie kodu

223
00:12:11,365 --> 00:12:12,490
że nigdy nie zostanie osiągnięty.

224
00:12:12,490 --> 00:12:14,744
Możemy również ustawić jeden poniżej.

225
00:12:14,744 --> 00:12:16,660
Powodem, że będzie
chcesz to zrobimy

226
00:12:16,660 --> 00:12:19,119
przejść do nieco bardziej
szczegółowo za chwilę.

227
00:12:19,119 --> 00:12:21,660
Więc teraz, pozwól mi tylko wyłączyć
te dodatkowe punkty przerwa

228
00:12:21,660 --> 00:12:24,940
tak, że możemy patrzeć na to, co się dzieje,
kiedy mam jedną przerwę

229
00:12:24,940 --> 00:12:27,650
punkt w moim programie.

230
00:12:27,650 --> 00:12:29,410
Zrobiłem kilka
zmiany w tym programie.

231
00:12:29,410 --> 00:12:30,750
Więc muszę go zapisać.

232
00:12:30,750 --> 00:12:34,490
Będę kliknij debug tak, że mogę
rozpocząć kompilację, a następnie

233
00:12:34,490 --> 00:12:36,880
wykonanie debuggera.

234
00:12:36,880 --> 00:12:40,632
>> Przekonamy się, że po chwilach
wiersz, który wybraliśmy jako przerwy

235
00:12:40,632 --> 00:12:43,360
punkt jest zaznaczony na żółto.

236
00:12:43,360 --> 00:12:47,440
Możemy również zauważyć, że w
w prawym górnym rogu panelu debugowania

237
00:12:47,440 --> 00:12:50,940
że ikona pauzy okazało
w małą ikonę odtwarzania.

238
00:12:50,940 --> 00:12:54,710
Oznacza to, że mamy przerwę
wykonanie w tym szczególnym przypadku.

239
00:12:54,710 --> 00:12:57,840
I naciśnięcie przycisku odtwarzania będzie
pozwalają nam wznowić wykonanie

240
00:12:57,840 --> 00:13:00,000
w tym konkretnym miejscu.

241
00:13:00,000 --> 00:13:03,240
>> Zauważ, że jest kilka innych
Przyciski dostępne w tym panelu Debug

242
00:13:03,240 --> 00:13:04,220
równie dobrze.

243
00:13:04,220 --> 00:13:09,470
Krok w ciągu, co pozwala mi
wykonanie tej jednej linii kodu

244
00:13:09,470 --> 00:13:14,030
i krok na tej linii do
następny, które w tym wypadku

245
00:13:14,030 --> 00:13:17,060
oznaczałoby, że printf
instrukcja jest wykonywana.

246
00:13:17,060 --> 00:13:22,310
A zostanie on wstrzymać
Wykonanie na linii 13, jak tak.

247
00:13:22,310 --> 00:13:25,090
>> I jest także krokiem
do funkcji, która

248
00:13:25,090 --> 00:13:28,950
jest przydatna, gdy stworzyłem inne
Funkcje gdzie indziej w kodzie źródłowym.

249
00:13:28,950 --> 00:13:31,420
I chcę, aby wejść do
te funkcje, a nie

250
00:13:31,420 --> 00:13:33,050
wykonać tę funkcję, jako całości.

251
00:13:33,050 --> 00:13:37,279
Ale będziemy wyglądać bardziej na etapie
do funkcji w chwilę.

252
00:13:37,279 --> 00:13:40,320
Teraz zauważyć kilka innych rzeczy, które
faktycznie istnieją w tym panelu debugowania.

253
00:13:40,320 --> 00:13:44,110
>> Mamy ten panel o nazwie
zadzwoń do stosu, który pokazuje nam,

254
00:13:44,110 --> 00:13:45,300
gdzie dokładnie jesteśmy.

255
00:13:45,300 --> 00:13:48,550
W tym przypadku, znajduje się wewnątrz
z głównych funkcji.

256
00:13:48,550 --> 00:13:50,880
Nasz skrypt nazywa count.c.

257
00:13:50,880 --> 00:13:53,820
A my stało się na
wiersz 13, kolumna jeden, który

258
00:13:53,820 --> 00:13:58,950
jest właśnie to, co podkreślił regionu
kodu źródłowego wskazuje również.

259
00:13:58,950 --> 00:14:02,435
>> Teraz zauważył, że ten pokazuje również,
w ramach lokalnej części zmiennej

260
00:14:02,435 --> 00:14:06,710
wszystkich zmiennych
istnieją w tej funkcji.

261
00:14:06,710 --> 00:14:08,930
Ważne jest, aby pamiętać,
że wszystkie zmienne

262
00:14:08,930 --> 00:14:12,580
pojawi się w tej zmiennej lokalnej
Sekcja wewnątrz funkcji,

263
00:14:12,580 --> 00:14:14,380
nawet przed ich zdefiniowaniem.

264
00:14:14,380 --> 00:14:19,160
Widzimy tutaj, że mamy zmienną
nazywa num, ma domyślną wartość 0,

265
00:14:19,160 --> 00:14:21,280
i jest on typu int.

266
00:14:21,280 --> 00:14:24,110
>> Teraz, zanim faktycznie zainicjować
wszystkie z tych zmiennych

267
00:14:24,110 --> 00:14:26,685
Nie jesteśmy zawsze
gwarantowane, aby zobaczyć wartość 0.

268
00:14:26,685 --> 00:14:29,200
I w zależności od innych egzekucji
które zostały wykonane

269
00:14:29,200 --> 00:14:32,020
i stan pamięci, gdy
faktycznie uruchomić ten program,

270
00:14:32,020 --> 00:14:34,605
Może się okazać, że
nie widzę wartości 0

271
00:14:34,605 --> 00:14:36,550
, a zamiast tego inne szalone numery.

272
00:14:36,550 --> 00:14:38,390
>> Ale nie martw się o to.

273
00:14:38,390 --> 00:14:44,610
To nie będzie istotne, dopóki
faktycznie zainicjować wartości.

274
00:14:44,610 --> 00:14:49,630
Teraz w tym przypadku widzimy, że
Wykonałam kilka wyjść.

275
00:14:49,630 --> 00:14:52,131
A ja, teraz, przerwał egzekucję.

276
00:14:52,131 --> 00:14:53,880
Jednak w tym przypadku to, co
Naprawdę chcę zrobić

277
00:14:53,880 --> 00:14:58,060
jest teraz krok na tej linii
kodu tak, że mogę naprawdę

278
00:14:58,060 --> 00:15:04,390
zapytanie użytkownika o tym int, że
chcemy użyć w naszym programie.

279
00:15:04,390 --> 00:15:07,060
>> Obecnie w tym przypadku, gdy
I hit krok nad, zawiadomienie

280
00:15:07,060 --> 00:15:11,940
że Pauza lub raczej CV
Przycisk zmieniła się do tego przycisku pauzy

281
00:15:11,940 --> 00:15:14,022
ponieważ kod ten jest faktycznie wykonywany.

282
00:15:14,022 --> 00:15:15,730
Co się dzieje
teraz jest to, że

283
00:15:15,730 --> 00:15:21,630
czeka na nas, aby wprowadzić pewne informacje
jak widać przez naszego tekstu wyjściowego

284
00:15:21,630 --> 00:15:23,600
na samym dole.

285
00:15:23,600 --> 00:15:25,787
>> Więc teraz, to jest
faktycznie nie zatrzymał się,

286
00:15:25,787 --> 00:15:28,620
chociaż to rodzaj pojawia się,
być, bo nic się nie dzieje.

287
00:15:28,620 --> 00:15:32,360
Ale tak się składa, że ​​w
mój konkretny przypadek na linii 13,

288
00:15:32,360 --> 00:15:34,210
Czekam na dane od użytkownika.

289
00:15:34,210 --> 00:15:39,130
I tak GDB nie jest w stanie kontrolować
program, jak to działa.

290
00:15:39,130 --> 00:15:43,370
>> Teraz kolejny raz, kiedy wprowadzić pewne
input-- więc będę wprowadzić ten numer 5,

291
00:15:43,370 --> 00:15:46,140
jak widzieliśmy w
past-- naciśnij Enter, a my

292
00:15:46,140 --> 00:15:51,430
zauważyć, że bezpośrednio, GDB pauz
i, ponownie, wskazuje na następną linię.

293
00:15:51,430 --> 00:15:55,320
Ale zauważ, że teraz, jako
wynikiem naszych wprowadzania wartości,

294
00:15:55,320 --> 00:15:58,930
zaktualizowaliśmy tę wartość w środku
naszych zmiennych lokalnych, które

295
00:15:58,930 --> 00:16:05,560
jest bardzo przydatne, aby dokładnie wiedzieć,
co to było ich w pamięci.

296
00:16:05,560 --> 00:16:10,650
>> Teraz mogę pozwolić ten program, aby kontynuować
odtwarzania do końca jego wykonanie

297
00:16:10,650 --> 00:16:12,570
trafiając CV.

298
00:16:12,570 --> 00:16:16,410
Widzimy, że bardzo szybko
Program wykończenie robi wykonywania

299
00:16:16,410 --> 00:16:19,790
o to samo wyjście, które
przedtem, debugger zamyka,

300
00:16:19,790 --> 00:16:23,170
a teraz ten program
zatrzymał się całkowicie.

301
00:16:23,170 --> 00:16:25,320
>> I pokazują, że tylko dla
cele widząc, co

302
00:16:25,320 --> 00:16:27,280
się dzieje, gdy rzeczywiście trafiliśmy CV.

303
00:16:27,280 --> 00:16:30,640
Ale tak naprawdę będziemy
chcę wrócić do tego programu

304
00:16:30,640 --> 00:16:33,820
tak, że możemy spróbować debugowania
właśnie to, co się dzieje.

305
00:16:33,820 --> 00:16:37,980
Teraz, używam debugger, że może
Nie potrzebujemy tych sprawozdań debugowania printf.

306
00:16:37,980 --> 00:16:43,860
>> Mogłem więc usunąć je jak będę robić
teraz po prostu wrócić do naszej prostszy kod

307
00:16:43,860 --> 00:16:45,950
że mieliśmy przed chwilą.

308
00:16:45,950 --> 00:16:48,790
Teraz, kiedy zapisać
program i uruchomić,

309
00:16:48,790 --> 00:16:53,700
będzie ponownie udać się do tego pierwszego
Break Point, które miałem na linii 11.

310
00:16:53,700 --> 00:16:57,700
I będę w stanie sprawdzić
moje zmienne, jak chcę zrobić.

311
00:16:57,700 --> 00:17:00,695
>> Tak się składa, że ​​ten
część nie jest bardzo ciekawy,

312
00:17:00,695 --> 00:17:04,364
I wiem, że będę
wydrukować to oświadczenie.

313
00:17:04,364 --> 00:17:05,280
Proszę wprowadzić numer.

314
00:17:05,280 --> 00:17:08,099
I wtedy wiem, że będę
poprosić użytkownika o tym liczby całkowitej.

315
00:17:08,099 --> 00:17:13,329
Być może więc, tak naprawdę chcą przenieść
Point Break trochę dalej w dół.

316
00:17:13,329 --> 00:17:16,710
>> Możesz usunąć punkty przerwy
klikając ponownie bezpośrednio

317
00:17:16,710 --> 00:17:18,460
z lewej strony tego numeru telefonicznego.

318
00:17:18,460 --> 00:17:22,200
Że czerwona kropka zniknie, wskazując,
że punkt krytyczny już nie ma.

319
00:17:22,200 --> 00:17:24,780
Obecnie w tym wypadku
wykonanie zostało wstrzymane.

320
00:17:24,780 --> 00:17:27,770
A więc to nie jest rzeczywiście będzie
wznowić w tym konkretnym przypadku.

321
00:17:27,770 --> 00:17:30,210
Ale mogę ustawić sobie przerwę
litera a nieco później.

322
00:17:30,210 --> 00:17:33,880
>> I kiedy teraz wznowić
Kod będzie wznowić i powiedz

323
00:17:33,880 --> 00:17:36,190
punkt tego punktu krytycznego.

324
00:17:36,190 --> 00:17:37,374
Znowu uderzył CV.

325
00:17:37,374 --> 00:17:39,040
Nie wydaje się coś dzieje.

326
00:17:39,040 --> 00:17:41,450
Ale to dlatego, że mój
Kod czeka na wejście.

327
00:17:41,450 --> 00:17:47,900
Będę wprowadzić numer 5, naciśnij Enter, a
Teraz następny punkt przerwa będzie hit.

328
00:17:47,900 --> 00:17:50,570
>> Teraz w tym przypadku jest
jest linia kodu

329
00:17:50,570 --> 00:17:53,820
że przed wiedzieliśmy,
okazał się być wadliwy.

330
00:17:53,820 --> 00:17:57,590
Warto więc ocenić, co się dzieje,
w tym konkretnym momencie.

331
00:17:57,590 --> 00:18:02,620
Gdy jest zaznaczona linia ta
linia nie została jeszcze wykonana.

332
00:18:02,620 --> 00:18:06,490
Więc w tym przypadku, możemy zobaczyć
że mam numer, który

333
00:18:06,490 --> 00:18:11,610
Mam liczbę całkowitą o nazwie
num, że ma wartość 5.

334
00:18:11,610 --> 00:18:15,090
A ja zamierzam być wykonywania
niektóre matematyki na ten numer.

335
00:18:15,090 --> 00:18:20,130
>> Gdybym krok nad tym, możemy
Zauważ, że wartość num

336
00:18:20,130 --> 00:18:23,780
zmienił się zgodnie z
arytmetyka, że ​​mamy rzeczywiście zrobić.

337
00:18:23,780 --> 00:18:26,810
I teraz, że jesteśmy
to dla pętli wewnątrz

338
00:18:26,810 --> 00:18:29,090
i teraz, że dla pętli
Sam jest podświetlony,

339
00:18:29,090 --> 00:18:32,450
widzimy, że mamy nowy
Zmienna o nazwie: i że

340
00:18:32,450 --> 00:18:35,370
ma być wykorzystywane w tej pętli.

341
00:18:35,370 --> 00:18:38,230
>> Teraz pamiętać przed tym I
wspomniano, że czasami jesteś

342
00:18:38,230 --> 00:18:43,470
zobaczymy jakiś szalony
Domyślnie numery jak przed tym numerem

343
00:18:43,470 --> 00:18:45,530
lub, że zmienna jest
właściwie zainicjowana.

344
00:18:45,530 --> 00:18:49,040
Widzimy, że właśnie
tutaj, w zmiennej tej

345
00:18:49,040 --> 00:18:51,345
nazywa i, co nie ma
jeszcze zainicjowany

346
00:18:51,345 --> 00:18:53,560
w czasie przedstawienia.

347
00:18:53,560 --> 00:18:57,070
Ale widać, że ma pewną liczbę
że nie będziemy właściwie spodziewać.

348
00:18:57,070 --> 00:18:57,620
>> Dobrze.

349
00:18:57,620 --> 00:18:59,661
Nie martw się o to
bo mamy w rzeczywistości nie

350
00:18:59,661 --> 00:19:04,970
inicjowane tej liczby do czasu I
krok na tej linii, a wartość

351
00:19:04,970 --> 00:19:08,560
i został zainicjowany na wartość 1.

352
00:19:08,560 --> 00:19:11,400
Tak więc, aby zobaczyć, że to jest rzeczywiście
sprawa, niech krok nad.

353
00:19:11,400 --> 00:19:14,420
Możemy teraz zobaczyć, że
Linia została wykonana.

354
00:19:14,420 --> 00:19:17,000
A teraz jesteśmy podkreślając
ta linia printf.

355
00:19:17,000 --> 00:19:22,230
>> A teraz możemy zobaczyć, jak nasze wartości
z I i 3 z czasem uległy zmianie.

356
00:19:22,230 --> 00:19:26,450
Jest to bardzo przydatne do zrobienia, w rzeczywistości,
jest krok na linii wielokrotnie.

357
00:19:26,450 --> 00:19:30,480
I można znaleźć to, co w rzeczywistości
dzieje się wewnątrz Twojego pętli for

358
00:19:30,480 --> 00:19:33,660
i co się dzieje z
zmienne wewnątrz tej pętli

359
00:19:33,660 --> 00:19:39,200
w tym realizacji programu
występuje jeden krok na raz.

360
00:19:39,200 --> 00:19:41,110
>> Teraz w tym momencie
podszedł na tyle,

361
00:19:41,110 --> 00:19:44,210
że jestem teraz na końcu mojego programu.

362
00:19:44,210 --> 00:19:46,980
Gdybym krok nad tym, to będzie
faktycznie przestanie wykonanie

363
00:19:46,980 --> 00:19:48,860
jak widzieliśmy w przeszłości.

364
00:19:48,860 --> 00:19:52,110
Pozwól mi ponownie uruchomić tego, jeszcze raz, tak
że mogę zwrócić się coś innego,

365
00:19:52,110 --> 00:19:53,320
równie dobrze.

366
00:19:53,320 --> 00:19:55,350
>> W tym przypadku jest
teraz pyta mnie, znowu,

367
00:19:55,350 --> 00:19:57,100
na liczbę, która
I będzie znowu wejść.

368
00:19:57,100 --> 00:20:00,300
Ale tym razem mam zamiar wprowadzić w
większą ilość, tak aby dla pętli

369
00:20:00,300 --> 00:20:02,540
będzie iteracji więcej razy.

370
00:20:02,540 --> 00:20:06,090
W tym przypadku, zamierzam
wprowadzić wartość 11.

371
00:20:06,090 --> 00:20:08,390
>> Teraz ponownie, ponieważ chciałbym ustawić
punkt załamania na linii 15,

372
00:20:08,390 --> 00:20:10,490
to będzie zaznaczyć tę linię.

373
00:20:10,490 --> 00:20:12,980
Widzimy, że nasze
Numer 11 jest prawidłowo

374
00:20:12,980 --> 00:20:15,560
reprezentowane w naszych zmiennych lokalnych.

375
00:20:15,560 --> 00:20:22,460
Przestępując, że możemy teraz
obserwować co się dzieje z naszą wartość i

376
00:20:22,460 --> 00:20:25,680
jak postępować w środku to dla pętli.

377
00:20:25,680 --> 00:20:31,960
Robi zwiększany za każdym razem,
dotrzeć na szczyt, że na pętli.

378
00:20:31,960 --> 00:20:35,110
>> Teraz jedna z rzeczy, które mogą
być przydatne podczas wykonywania zrobić

379
00:20:35,110 --> 00:20:40,490
ten program jest dla mnie rzeczywiście
zmienić nurt zmiennych zobaczyć

380
00:20:40,490 --> 00:20:42,450
co się dzieje z moim programie.

381
00:20:42,450 --> 00:20:46,540
W tym przypadku, mogę rzeczywiście
kliknij dwukrotnie wartość.

382
00:20:46,540 --> 00:20:48,040
Zauważ, że staje się pole tekstowe.

383
00:20:48,040 --> 00:20:50,280
>> Teraz mogę wprowadzić różne
wartości łącznie

384
00:20:50,280 --> 00:20:55,700
zobaczyć, jak mój program zachowuje się
kiedy zmieniłem tę zmienną.

385
00:20:55,700 --> 00:20:59,560
Obecnie w tym przypadku, zmienna
I teraz zawiera wartość 10.

386
00:20:59,560 --> 00:21:02,810
Ale program jest nadal
Zatrzymał się egzekucji.

387
00:21:02,810 --> 00:21:07,610
Kiedy krok nad, widzę, że
wartość i, który wszedłem jako 10,

388
00:21:07,610 --> 00:21:12,170
nie jest większa od wartości num
co od razu powoduje pętli for

389
00:21:12,170 --> 00:21:14,240
aby zatrzymać wykonywanie.

390
00:21:14,240 --> 00:21:16,210
>> Teraz to nie jest jedyny
Powodem, dla którego będzie

391
00:21:16,210 --> 00:21:19,450
Aby zmodyfikować zmienną w miejscu.

392
00:21:19,450 --> 00:21:22,210
Może rzeczywiście chcesz
spróbować zmodyfikować go tak,

393
00:21:22,210 --> 00:21:24,590
że można kontynuować
wykonywanie pętli

394
00:21:24,590 --> 00:21:27,370
albo tak, że można zmodyfikować
jakaś wartość przed nim

395
00:21:27,370 --> 00:21:32,630
osiągnie pewien określony zestaw arytmetyki
że masz zamiar wykonać.

396
00:21:32,630 --> 00:21:36,210
>> Więc teraz, że rzeczywiście możemy zmienić
wartość i jak program był wykonywany,

397
00:21:36,210 --> 00:21:39,540
spowodował pętli for, aby zamknąć
przedwcześnie, bo się nagle, i

398
00:21:39,540 --> 00:21:42,770
okazał się być większa niż wartość
z num, co oznacza, że ​​na pętli

399
00:21:42,770 --> 00:21:45,410
nie są już potrzebne do wykonania.

400
00:21:45,410 --> 00:21:48,780
Co więcej, stało się to za
tak, że zmieniliśmy wartość i

401
00:21:48,780 --> 00:21:53,270
kiedy została podkreślona linia 17,
który był moment

402
00:21:53,270 --> 00:21:56,280
że do wykonania pętli
faktycznie jest oceniany.

403
00:21:56,280 --> 00:22:00,210
>> Gdybym zmienił wartości
i na innej linii, powiedzmy 19,

404
00:22:00,210 --> 00:22:03,360
nie widzieliśmy inna
zachowanie, bo linia 19 będzie

405
00:22:03,360 --> 00:22:08,310
zostały wykonane przed pętli
warunek został reevaluated.

406
00:22:08,310 --> 00:22:11,900
Teraz w tym momencie, jestem, jeszcze raz,
po zakończeniu programu.

407
00:22:11,900 --> 00:22:15,707
A ja mogę na to pozwolić, aby przejść do
pozwala mój program rzucić naturalnie.

408
00:22:15,707 --> 00:22:18,290
Ale jest kilka rzeczy,
które są ważne, aby zabrać

409
00:22:18,290 --> 00:22:19,960
z tym konkretnym dyskusji.

410
00:22:19,960 --> 00:22:22,490
Musisz ocenić
własne założenia

411
00:22:22,490 --> 00:22:24,710
o tym, jak należy zachowywać się kod.

412
00:22:24,710 --> 00:22:28,220
Za każdym razem, że niektóre kawałek
Kod wiesz w stanie pracować,

413
00:22:28,220 --> 00:22:30,940
że może być czerwona flaga iść
wstecz i ocenić, i upewnij się,

414
00:22:30,940 --> 00:22:33,470
że swoim założeniu
jak ten kod działa

415
00:22:33,470 --> 00:22:38,290
jest rzeczywiście prawdziwe, jak to jest
wyrażone w kodzie źródłowym.

416
00:22:38,290 --> 00:22:41,300
>> Ale jeszcze bardziej do punktu było,
kiedy używamy debuggera,

417
00:22:41,300 --> 00:22:43,920
można umieścić punkty przerwania na
różne linie kodu,

418
00:22:43,920 --> 00:22:48,110
co spowoduje debugger do
wstrzymać wykonanie na każdej z tych linii

419
00:22:48,110 --> 00:22:52,210
tak aby można było ocenić
pamięci lub nawet zmienić go w miejscu.

420
00:22:52,210 --> 00:22:55,630
I znowu, pamiętaj, że możesz
tworzenie wielu punktów przerwania tak, że

421
00:22:55,630 --> 00:23:00,390
może wznowić egzekucję, pomiń
na dużych porcji kodu,

422
00:23:00,390 --> 00:23:04,790
i będzie ona automatycznie wstrzymać
na kolejnym punktem załamania.

423
00:23:04,790 --> 00:23:07,760
>> Jest rzeczywiście bardziej zaawansowany
cechy debuggera, jak również.

424
00:23:07,760 --> 00:23:10,170
Ale musimy skierować
niektórych późniejszych filmów

425
00:23:10,170 --> 00:23:14,090
aby naprawdę odciąć jak
używać tych funkcji.

426
00:23:14,090 --> 00:23:15,990
Na razie, dziękuję
bardzo za oglądanie.

427
00:23:15,990 --> 00:23:18,080
Powodzenia debugowania.