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

2
00:00:00,309 --> 00:00:02,350
[? DAN ARMADARAS:?] Hi,
Saya m [? Dan Armadaras?].

3
00:00:02,350 --> 00:00:04,410
Hari ini, kita akan
akan melihat debugging.

4
00:00:04,410 --> 00:00:06,697
Tidak hanya kita akan
berbicara tentang beberapa teknik,

5
00:00:06,697 --> 00:00:09,280
tetapi juga kita akan melihat
beberapa fitur yang terdapat

6
00:00:09,280 --> 00:00:14,170
dalam IDE CS50 yang memungkinkan
Anda untuk dengan mudah men-debug program.

7
00:00:14,170 --> 00:00:16,272
>> Salah satu contoh
sesuatu yang bisa salah

8
00:00:16,272 --> 00:00:18,730
dan itu sebenarnya sesuatu
bahwa kita sudah lihat sebelumnya.

9
00:00:18,730 --> 00:00:23,200
Dalam hal ini, program ini adalah program C
yang menerima integer dari pengguna,

10
00:00:23,200 --> 00:00:27,580
membaginya dengan dua, dan menyediakan
output kembali ke pengguna.

11
00:00:27,580 --> 00:00:30,610
Sekarang dari apa yang telah kita lihat
awal kuliah,

12
00:00:30,610 --> 00:00:34,370
kita tahu bahwa ini benar-benar akan menyebabkan
tipe tertentu dari masalah divisi

13
00:00:34,370 --> 00:00:35,860
ketika kita memiliki angka ganjil.

14
00:00:35,860 --> 00:00:40,330
>> Secara khusus, kami hanya akan membuang
apapun setelah titik desimal.

15
00:00:40,330 --> 00:00:43,170
Sekarang, kita tahu bahwa ini
terjadi menjadi kasus.

16
00:00:43,170 --> 00:00:47,430
Dan jika kita menjalankannya, kita dapat mengkonfirmasi
kecurigaan kami, pertama, dengan menyusun.

17
00:00:47,430 --> 00:00:50,460
Dan kemudian, dengan menjalankan dan
memasuki ganjil.

18
00:00:50,460 --> 00:00:51,720
>> Ini bukan hal yang baru.

19
00:00:51,720 --> 00:00:54,490
Tapi ini sebenarnya merupakan
contoh bug yang

20
00:00:54,490 --> 00:00:58,810
bisa ada dalam program yang lebih besar
yang menjadi lebih sulit untuk melacak.

21
00:00:58,810 --> 00:01:02,640
Meskipun kita tahu apa masalah
adalah, inti sebenarnya dari masalah ini

22
00:01:02,640 --> 00:01:06,250
mungkin mencoba untuk mengidentifikasi
khusus di mana kesalahan terjadi,

23
00:01:06,250 --> 00:01:09,750
mengidentifikasi apa masalah itu
adalah, dan kemudian memperbaikinya.

24
00:01:09,750 --> 00:01:14,400
Jadi memberikan ini sebagai contoh
apa mungkin sesuatu

25
00:01:14,400 --> 00:01:19,030
bahwa kita sudah tahu tapi bisa dikuburkan
dalam unsur-unsur lain dari kode.

26
00:01:19,030 --> 00:01:23,090
>> Jadi membuka sumber lain ini
Kode file sebagai contoh,

27
00:01:23,090 --> 00:01:27,165
Masalah pembagian ini sekarang
bagian dari program yang lebih besar.

28
00:01:27,165 --> 00:01:29,040
Masih mungkin sedikit
bit dibikin, dan kami

29
00:01:29,040 --> 00:01:31,076
mungkin bisa dengan mudah
mengidentifikasi, terutama

30
00:01:31,076 --> 00:01:32,450
karena kami hanya membahas ini.

31
00:01:32,450 --> 00:01:38,250
Tapi kita tahu bahwa ini
Masalah bisa berada pada skala yang lebih besar.

32
00:01:38,250 --> 00:01:45,450
>> Jika saya mengkompilasi ini dan sekarang
menjalankannya, masukkan angka ganjil,

33
00:01:45,450 --> 00:01:49,816
kita dapat melihat bahwa kita tidak mendapatkan tepatnya
output yang kita mungkin telah diharapkan.

34
00:01:49,816 --> 00:01:51,690
Dalam kasus ini,
kita bisa mengatakan bahwa kita

35
00:01:51,690 --> 00:01:56,060
ingin menghitung semua nomor
dari satu hingga beberapa nomor tertentu.

36
00:01:56,060 --> 00:01:58,130
Dan kita dapat melihat bahwa kita
memiliki berbagai masalah

37
00:01:58,130 --> 00:02:03,880
sini jika kita keluaran, hanya, 0
dan 1 ketika kita memberikan masukan dari 5.

38
00:02:03,880 --> 00:02:07,380
>> Jadi kita sudah tahu bahwa
ada masalah di sini.

39
00:02:07,380 --> 00:02:11,662
Tapi kita mungkin tidak tahu persis
di mana masalah ini benar-benar ada.

40
00:02:11,662 --> 00:02:13,620
Sekarang salah satu cara yang
kita dapat mencoba untuk memperbaiki ini

41
00:02:13,620 --> 00:02:15,745
adalah sesuatu yang kita sudah
telah diperkenalkan ke.

42
00:02:15,745 --> 00:02:18,880
Kami hanya dapat menggunakannya pada skala yang lebih besar.

43
00:02:18,880 --> 00:02:21,680
>> On line 14, kita memiliki
Fungsi printf ini,

44
00:02:21,680 --> 00:02:25,620
yang memungkinkan kita untuk mencetak negara
berbagai potongan informasi.

45
00:02:25,620 --> 00:02:28,880
Dan ini adalah sesuatu yang Anda
harus memanfaatkan dalam program Anda

46
00:02:28,880 --> 00:02:33,100
mencoba untuk mencari tahu persis apa yang
terjadi di berbagai baris kode.

47
00:02:33,100 --> 00:02:36,350
Jadi bahkan jika ini bukan
hasil akhir yang kita benar-benar

48
00:02:36,350 --> 00:02:39,830
ingin menghasilkan dari
program ini, kami masih

49
00:02:39,830 --> 00:02:42,300
mungkin memiliki beberapa men-debug
pernyataan di mana kita

50
00:02:42,300 --> 00:02:46,970
dapat mencoba untuk mencari tahu persis apa
yang terjadi di dalam kode kami.

51
00:02:46,970 --> 00:02:51,210
>> Jadi dalam hal ini, saya akan
printf dengan tag debug.

52
00:02:51,210 --> 00:02:53,540
Dalam hal ini, ini
hanya debug string

53
00:02:53,540 --> 00:02:56,840
bahwa aku up-menempatkan sehingga menjadi
sangat jelas dalam output dari kode saya

54
00:02:56,840 --> 00:02:59,200
apa yang saya ingin menunjukkan.

55
00:02:59,200 --> 00:03:04,410
Dan output di sini nomor
bahwa kita telah dihitung.

56
00:03:04,410 --> 00:03:06,800
>> Dalam hal ini, aku mungkin
ingin tahu persis

57
00:03:06,800 --> 00:03:11,380
apa yang terjadi sebelum dan
setelah beberapa perhitungan tertentu.

58
00:03:11,380 --> 00:03:16,224
Jadi saya bisa menggunakan printf sebelum
dan setelah itu baris kode.

59
00:03:16,224 --> 00:03:18,640
Dalam hal ini, saya bahkan bisa
membuatnya sedikit lebih jelas

60
00:03:18,640 --> 00:03:21,960
dengan mengatakan men-debug sebelum
dan debug setelah begitu

61
00:03:21,960 --> 00:03:26,540
bahwa saya tidak bingung sendiri dengan
beberapa baris yang terlihat identik.

62
00:03:26,540 --> 00:03:32,290
>> Sekarang jika kita mengkompilasi ulang ini dan menjalankan
itu, masukkan nomor seperti lima lagi,

63
00:03:32,290 --> 00:03:35,090
kita dapat melihat bahwa kita memiliki
sekarang keluaran sebelum dan sesudah

64
00:03:35,090 --> 00:03:40,670
dan menemukan bahwa kita tidak melakukan jelas
divisi atau yang jelas memiliki nomor tersebut

65
00:03:40,670 --> 00:03:43,680
bahwa kita benar-benar ingin lakukan.

66
00:03:43,680 --> 00:03:48,660
Sekarang dalam kasus ini, ini
tidak benar-benar output yang jelas.

67
00:03:48,660 --> 00:03:52,440
Ini tidak benar-benar hasil yang jelas bahwa
kami ingin keluar dari program khusus ini.

68
00:03:52,440 --> 00:03:54,427
>> Dan ini, sekali lagi,
sedikit dibikin.

69
00:03:54,427 --> 00:03:57,510
Tapi, mungkin, salah satu hal yang
kita bisa lakukan jika spesifikasi mengatakan

70
00:03:57,510 --> 00:04:01,900
bahwa kita ingin membagi ini dengan
2 dan menambahkan 1-- jadi dengan kata lain,

71
00:04:01,900 --> 00:04:04,550
kami ingin melengkapi up-- kemudian
kita mungkin tahu bahwa kita bisa

72
00:04:04,550 --> 00:04:08,060
melakukannya hal tertentu, dalam hal ini.

73
00:04:08,060 --> 00:04:14,010
Sekarang di sini kita tahu bahwa kita akan
mampu menambah 1 ke nomor dibelah dua kami.

74
00:04:14,010 --> 00:04:16,490
>> Mari kita ulang ini
dan mengkonfirmasi bahwa ini

75
00:04:16,490 --> 00:04:18,860
berperilaku dengan cara yang kita ingin.

76
00:04:18,860 --> 00:04:21,980
Kita bisa melihat bahwa sekarang sebelum
memiliki, kita memiliki nomor 5.

77
00:04:21,980 --> 00:04:26,620
Setelah, kami memiliki nomor 3,
yang sesuai dengan spesifikasi kami,

78
00:04:26,620 --> 00:04:29,292
adalah apa yang kita ingin lakukan.

79
00:04:29,292 --> 00:04:31,000
Tetapi jika kita melihat
output di sini, kita bisa

80
00:04:31,000 --> 00:04:33,760
melihat bahwa kita mungkin memiliki lain
bug sama sekali, yang merupakan

81
00:04:33,760 --> 00:04:36,940
bahwa kita mulai menghitung kami dari 0.

82
00:04:36,940 --> 00:04:39,390
>> Sekarang lagi, ini adalah sesuatu
bahwa kita telah melihat di masa lalu

83
00:04:39,390 --> 00:04:42,500
dan kita bisa memperbaikinya cukup mudah.

84
00:04:42,500 --> 00:04:44,790
Tapi dalam kasus ini, kita
juga memiliki manfaat

85
00:04:44,790 --> 00:04:48,940
menggunakan pernyataan printf
langsung dalam untuk loop

86
00:04:48,940 --> 00:04:52,930
untuk tahu persis di mana
kesalahan yang terjadi.

87
00:04:52,930 --> 00:04:55,150
Laporan Jadi printf adalah
sangat berguna dalam membantu

88
00:04:55,150 --> 00:04:57,940
Anda menentukan di mana,
tepatnya di kode sumber Anda,

89
00:04:57,940 --> 00:05:00,620
kesalahan tertentu terjadi.

90
00:05:00,620 --> 00:05:03,650
>> Dan itu juga penting untuk menyadari
itu, seperti yang kita menulis kode,

91
00:05:03,650 --> 00:05:06,052
kita mungkin memiliki asumsi
tentang keadaan program.

92
00:05:06,052 --> 00:05:08,510
Atau kita mungkin memiliki asumsi
tentang apa bagian dari program

93
00:05:08,510 --> 00:05:13,020
sebenarnya benar atau salah ketika
nanti seperti yang kita membangun program yang

94
00:05:13,020 --> 00:05:15,950
dan menjadikannya bagian dari
kompleks dan program yang lebih besar

95
00:05:15,950 --> 00:05:19,700
bahwa kita menyadari bahwa beberapa aspek
dari yang sebenarnya kereta.

96
00:05:19,700 --> 00:05:22,680
>> Menggunakan printf benar-benar dapat membantu
mempersempit dan mengidentifikasi

97
00:05:22,680 --> 00:05:26,430
daerah dari sebuah program yang mungkin tidak
akan berperilaku persis seperti yang kita

98
00:05:26,430 --> 00:05:29,500
berharap, berdasarkan asumsi kami.

99
00:05:29,500 --> 00:05:31,460
Tapi ada alat-alat lain
tersedia, juga,

100
00:05:31,460 --> 00:05:34,860
yang memungkinkan kita untuk mencoba untuk angka
tahu di mana kesalahan terjadi

101
00:05:34,860 --> 00:05:39,930
dan juga, secara khusus, hal apa
yang terjadi di dalam program.

102
00:05:39,930 --> 00:05:41,990
>> Jadi menggunakan printf sangat
ketika kita ingin berguna

103
00:05:41,990 --> 00:05:45,900
untuk mengidentifikasi daerah-daerah tertentu
sebuah program yang memiliki beberapa bug.

104
00:05:45,900 --> 00:05:47,730
Tapi itu juga menjadi
membosankan setelah beberapa saat.

105
00:05:47,730 --> 00:05:50,500
Dalam hal ini, ini adalah
Program yang relatif sederhana

106
00:05:50,500 --> 00:05:52,750
hanya dengan satu atau dua variabel.

107
00:05:52,750 --> 00:05:57,260
Dan itu menjadi sangat mudah bagi kita untuk
mencetak nilai variabel

108
00:05:57,260 --> 00:05:59,670
dalam konteks program yang lebih besar.

109
00:05:59,670 --> 00:06:02,670
>> Tapi kita mungkin memiliki berbeda
program yang memiliki banyak variabel.

110
00:06:02,670 --> 00:06:06,530
Dan hal itu mungkin tidak cukup
sehingga mudah digunakan printf

111
00:06:06,530 --> 00:06:10,120
mencoba untuk mengevaluasi apa yang terjadi
untuk masing-masing dari variabel-variabel

112
00:06:10,120 --> 00:06:13,590
sebagai program mengeksekusi.

113
00:06:13,590 --> 00:06:16,960
Ada program yang ada
disebut program debugger.

114
00:06:16,960 --> 00:06:20,320
Dalam hal ini, salah satu yang kita akan
penggunaan adalah debugger GNU, atau GDB,

115
00:06:20,320 --> 00:06:24,260
yang memungkinkan kita untuk memeriksa internal
kerja program dalam jauh lebih

116
00:06:24,260 --> 00:06:25,700
cara rinci.

117
00:06:25,700 --> 00:06:28,810
>> Kami benar-benar bisa menjalankan
GDB dari baris perintah

118
00:06:28,810 --> 00:06:35,370
di sini dengan hanya mengetik GDB dan
perintah yang ingin kita untuk debug.

119
00:06:35,370 --> 00:06:37,550
Dalam hal ini, menghitung.

120
00:06:37,550 --> 00:06:41,650
Sekarang dalam kasus ini, kita dapat melihat bahwa itu
membawa kita ke prompt yang mengatakan GDB.

121
00:06:41,650 --> 00:06:44,020
Dan kita bisa benar-benar
menjalankan perintah untuk GDB

122
00:06:44,020 --> 00:06:48,260
untuk benar-benar memulai pelaksanaan
Program, menghentikannya pada titik-titik tertentu,

123
00:06:48,260 --> 00:06:51,060
mengevaluasi variabel dan
memeriksa variabel yang

124
00:06:51,060 --> 00:06:54,152
ada dalam program negara
pada saat itu,

125
00:06:54,152 --> 00:06:55,110
dan sebagainya dan sebagainya.

126
00:06:55,110 --> 00:06:57,240
Ini memberikan banyak kekuatan untuk kita.

127
00:06:57,240 --> 00:06:59,960
>> Tapi kebetulan
bahwa CS50 IDE juga

128
00:06:59,960 --> 00:07:05,870
menyediakan GUI atau pengguna
interface untuk GDB yang

129
00:07:05,870 --> 00:07:11,120
memungkinkan kita untuk melakukan hal ini tanpa perlu
antarmuka baris perintah apapun

130
00:07:11,120 --> 00:07:13,560
atau bahkan sama sekali.

131
00:07:13,560 --> 00:07:16,930
Cara yang saya dapat mengakses
adalah dengan menggunakan tombol men-debug

132
00:07:16,930 --> 00:07:20,120
di bagian paling atas dari IDE CS50.

133
00:07:20,120 --> 00:07:24,280
Sekarang di masa lalu, apa yang kita miliki
dilihat adalah bahwa kita menggunakan perintah

134
00:07:24,280 --> 00:07:27,660
line untuk mengkompilasi dan kemudian menjalankan program.

135
00:07:27,660 --> 00:07:29,790
>> Tombol men-debug tidak
kedua langkah tersebut.

136
00:07:29,790 --> 00:07:34,380
Tetapi juga akan memunculkan
debugger tab di paling kanan

137
00:07:34,380 --> 00:07:38,280
yang memungkinkan kita untuk memeriksa berbagai sebuah
sifat program

138
00:07:38,280 --> 00:07:40,500
seperti yang mengeksekusi.

139
00:07:40,500 --> 00:07:44,280
Jika saya klik debug, dalam hal ini
kasus, hal itu akan memunculkan

140
00:07:44,280 --> 00:07:48,230
tab baru di konsol
jendela di bagian paling bawah.

141
00:07:48,230 --> 00:07:51,160
>> Dan Anda dapat melihat bahwa tab ini memiliki
beberapa informasi di bagian paling atas.

142
00:07:51,160 --> 00:07:52,670
Dan kami sebagian besar dapat mengabaikan hal ini.

143
00:07:52,670 --> 00:07:54,800
Tapi salah satu hal
bahwa kita ingin melihat

144
00:07:54,800 --> 00:07:57,170
adalah bahwa itu output
hal yang sama bahwa kita

145
00:07:57,170 --> 00:08:03,000
akan dapatkan jika kita mencoba untuk menjalankan make pada
program C di jendela terminal.

146
00:08:03,000 --> 00:08:06,230
>> Di sini, kita bisa melihat itu berjalan dentang,
dan memiliki berbagai bendera,

147
00:08:06,230 --> 00:08:12,660
dan itu kompilasi berkas count.c kami,
yang merupakan tab yang dipilih pada saat itu

148
00:08:12,660 --> 00:08:15,100
bahwa aku memukul debug.

149
00:08:15,100 --> 00:08:18,010
Jadi ini sangat berguna karena
sekarang menggunakan tombol debug,

150
00:08:18,010 --> 00:08:23,280
kita secara bersamaan dapat mengkompilasi dan kemudian
mengeksekusi program yang kita benar-benar

151
00:08:23,280 --> 00:08:24,460
ingin menjalankan.

152
00:08:24,460 --> 00:08:27,880
>> Salah satu bendera yang
penting, dalam hal ini,

153
00:08:27,880 --> 00:08:30,190
kita sudah benar-benar telah menggunakan
untuk waktu yang lama

154
00:08:30,190 --> 00:08:32,450
tetapi juga hanya melakukan beberapa tangan
melambaikan [tak terdengar], yang

155
00:08:32,450 --> 00:08:33,820
adalah salah satu ini di sini.

156
00:08:33,820 --> 00:08:35,790
Dalam dentang, ia mengatakan -ggdb3.

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

158
00:08:38,570 --> 00:08:41,250
Dalam hal ini, apa yang kita
mengatakan dentang, kompiler kami,

159
00:08:41,250 --> 00:08:43,820
adalah bahwa kita ingin mengkompilasi program kami.

160
00:08:43,820 --> 00:08:46,810
Tetapi juga memberikan apa yang
disebut informasi simbol

161
00:08:46,810 --> 00:08:50,940
sehingga compiler sebenarnya memiliki akses
untuk banyak informasi yang mendasari

162
00:08:50,940 --> 00:08:52,610
terkandung dalam program ini.

163
00:08:52,610 --> 00:08:55,260
>> Lebih khusus, nomor
fungsi yang saya miliki,

164
00:08:55,260 --> 00:08:58,000
nama-nama fungsi-fungsi,
variabel, jenis

165
00:08:58,000 --> 00:09:01,730
yang variabel tersebut adalah, dan varietas
hal-hal lain yang membantu debugger

166
00:09:01,730 --> 00:09:04,350
melakukan operasinya.

167
00:09:04,350 --> 00:09:06,600
Sekarang ada hal lain
yang penting untuk menyebutkan

168
00:09:06,600 --> 00:09:10,280
ketika kita membahas berjalan
program dengan cara ini.

169
00:09:10,280 --> 00:09:13,660
>> Perhatikan bahwa ia memiliki sebenarnya
dibesarkan tab baru di konsol kami

170
00:09:13,660 --> 00:09:14,780
sepanjang bagian bawah.

171
00:09:14,780 --> 00:09:18,600
Kami tidak lagi harus berinteraksi
langsung dengan jendela terminal.

172
00:09:18,600 --> 00:09:21,420
Tapi tab baru ini
sebenarnya jendela terminal.

173
00:09:21,420 --> 00:09:26,710
Itu hanya khusus untuk menjalankan
program yang telah kita buat.

174
00:09:26,710 --> 00:09:29,270
>> Perhatikan bahwa di bagian bawah, di
kombinasi dengan beberapa output

175
00:09:29,270 --> 00:09:33,500
oleh dentang compiler dan GDB,
yang kita sebagian besar dapat mengabaikan,

176
00:09:33,500 --> 00:09:37,570
itu benar-benar menunjukkan output dari
program kami di bagian paling bawah.

177
00:09:37,570 --> 00:09:41,240
Sekarang penting untuk menyadari
bahwa jendela ini yang benar-benar

178
00:09:41,240 --> 00:09:43,360
akan menunjukkan
Output dari program Anda

179
00:09:43,360 --> 00:09:47,190
tetapi juga dapat menerima input
untuk program itu, juga.

180
00:09:47,190 --> 00:09:49,260
>> Jadi pernyataan yang menyebutkan
masukkan nomor,

181
00:09:49,260 --> 00:09:53,050
yang merupakan output yang sama yang kita miliki
telah di jendela terminal sebelumnya.

182
00:09:53,050 --> 00:09:55,510
Tapi sekarang ditampilkan di tab baru ini.

183
00:09:55,510 --> 00:09:56,550
Saya dapat memasukkan nomor.

184
00:09:56,550 --> 00:10:00,900
Dan itu akan benar-benar
fungsi seperti yang kita harapkan

185
00:10:00,900 --> 00:10:05,890
menunjukkan kita men-debug kami, output,
output yang mungkin kereta,

186
00:10:05,890 --> 00:10:07,010
seperti yang telah kita lihat sebelumnya.

187
00:10:07,010 --> 00:10:10,460
Dan di bagian paling bawah, itu
sebenarnya memiliki beberapa output tambahan

188
00:10:10,460 --> 00:10:14,550
dari PDB hanya mengatakan bahwa
Program ini telah selesai.

189
00:10:14,550 --> 00:10:16,655
>> Sekarang seperti yang Anda lihat dalam
run khususnya melalui,

190
00:10:16,655 --> 00:10:19,370
itu tidak terlalu
berguna karena bahkan

191
00:10:19,370 --> 00:10:23,740
meskipun kami memiliki menu debugger datang
up, ini masih program berjalan.

192
00:10:23,740 --> 00:10:26,790
Pada titik itu tidak benar-benar
jeda eksekusi bagi kami

193
00:10:26,790 --> 00:10:30,767
untuk dapat memeriksa semua
variabel yang terkandung dalam.

194
00:10:30,767 --> 00:10:32,850
Ada sesuatu yang lain
yang harus kita lakukan dalam rangka

195
00:10:32,850 --> 00:10:36,910
untuk mendapatkan GDB untuk mengakui bahwa kita ingin
untuk menghentikan sementara eksekusi program

196
00:10:36,910 --> 00:10:42,820
dan tidak hanya memungkinkan untuk melanjutkan
biasanya seperti yang kita akan dalam hal lain.

197
00:10:42,820 --> 00:10:45,530
>> Dalam rangka untuk menghentikan sementara eksekusi,
di beberapa baris tertentu,

198
00:10:45,530 --> 00:10:47,830
kita perlu membuat apa
disebut titik istirahat.

199
00:10:47,830 --> 00:10:52,670
Dan titik istirahat sangat mudah dibuat
dalam hal ini CS50 IDE dengan mengambil mouse Anda

200
00:10:52,670 --> 00:10:57,090
dan mengklik langsung ke kiri
beberapa nomor baris tertentu.

201
00:10:57,090 --> 00:10:59,920
Setelah saya melakukan itu, titik merah
muncul, yang menunjukkan

202
00:10:59,920 --> 00:11:02,300
bahwa garis yang sekarang menjadi titik istirahat.

203
00:11:02,300 --> 00:11:07,540
>> Dan waktu berikutnya yang saya jalankan GDB, itu
akan menghentikan eksekusi pada titik istirahat

204
00:11:07,540 --> 00:11:10,280
saat mencapai bahwa baris kode.

205
00:11:10,280 --> 00:11:12,230
Sekarang ini adalah penting
hal untuk mewujudkan

206
00:11:12,230 --> 00:11:16,140
bahwa itu belum tentu
kasus bahwa setiap baris kode

207
00:11:16,140 --> 00:11:17,880
sebenarnya diakses.

208
00:11:17,880 --> 00:11:23,780
Jika saya harus membuat fungsi
di sini, untuk example-- batal f--

209
00:11:23,780 --> 00:11:31,230
dan hanya melakukan baris cetak sini-halo
dunia-- jika saya tidak pernah memanggil fungsi ini,

210
00:11:31,230 --> 00:11:34,770
itu akan menjadi kasus yang,
jika saya menetapkan titik istirahat di sini,

211
00:11:34,770 --> 00:11:36,220
fungsi akan pernah disebut.

212
00:11:36,220 --> 00:11:38,310
Dan oleh karena itu, ini
break point tertentu

213
00:11:38,310 --> 00:11:43,040
tidak akan pernah benar-benar berhenti
eksekusi program.

214
00:11:43,040 --> 00:11:48,020
>> Jadi mari kita mengatakan bahwa saya benar membuat
break point pada beberapa baris kode

215
00:11:48,020 --> 00:11:50,340
yang akan benar-benar dijalankan.

216
00:11:50,340 --> 00:11:53,470
Sekarang dalam kasus ini, ini adalah
baris pertama dalam fungsi utama.

217
00:11:53,470 --> 00:11:56,630
Sehingga pasti akan terjadi
itu, segera setelah saya mulai eksekusi,

218
00:11:56,630 --> 00:11:58,580
baris pertama akan tercapai.

219
00:11:58,580 --> 00:12:00,230
GDB akan berhenti eksekusi.

220
00:12:00,230 --> 00:12:04,100
Dan kemudian, aku akan dapat
berinteraksi dengan debugger.

221
00:12:04,100 --> 00:12:08,480
>> Anda dapat mengatur beberapa baris sebagai
breakpoints, jika Anda ingin.

222
00:12:08,480 --> 00:12:11,365
Kami juga dapat membuat line up
di sini di segmen ini kode

223
00:12:11,365 --> 00:12:12,490
yang tidak akan pernah tercapai.

224
00:12:12,490 --> 00:12:14,744
Dan kita juga dapat mengatur satu lebih lanjut di bawah.

225
00:12:14,744 --> 00:12:16,660
Alasan bahwa kita akan
ingin melakukan hal ini kita akan

226
00:12:16,660 --> 00:12:19,119
masuk ke sedikit lebih
rinci dalam sesaat.

227
00:12:19,119 --> 00:12:21,660
Jadi untuk saat ini, saya hanya menonaktifkan
istirahat tambahan titik-titik

228
00:12:21,660 --> 00:12:24,940
sehingga kita dapat melihat apa yang terjadi
ketika saya memiliki satu break

229
00:12:24,940 --> 00:12:27,650
titik dalam program saya.

230
00:12:27,650 --> 00:12:29,410
Saya telah membuat beberapa
perubahan program ini.

231
00:12:29,410 --> 00:12:30,750
Jadi saya harus menyimpannya.

232
00:12:30,750 --> 00:12:34,490
Aku akan men-debug klik sehingga saya bisa
mulai kompilasi dan kemudian

233
00:12:34,490 --> 00:12:36,880
pelaksanaan debugger.

234
00:12:36,880 --> 00:12:40,632
>> Kita akan melihat bahwa, setelah saat,
garis yang kita terpilih sebagai istirahat

235
00:12:40,632 --> 00:12:43,360
Titik disorot dengan warna kuning.

236
00:12:43,360 --> 00:12:47,440
Kita juga dapat melihat bahwa di
atas tepat di panel men-debug

237
00:12:47,440 --> 00:12:50,940
bahwa ikon jeda telah berubah
menjadi ikon bermain sedikit.

238
00:12:50,940 --> 00:12:54,710
Ini berarti bahwa kita memiliki jeda
eksekusi, dalam kasus ini.

239
00:12:54,710 --> 00:12:57,840
Dan memukul tombol Play akan
memungkinkan kita untuk melanjutkan eksekusi

240
00:12:57,840 --> 00:13:00,000
pada titik tertentu.

241
00:13:00,000 --> 00:13:03,240
>> Perhatikan bahwa ada beberapa lainnya
tombol yang tersedia di panel debug,

242
00:13:03,240 --> 00:13:04,220
demikian juga.

243
00:13:04,220 --> 00:13:09,470
Langkah lebih, yang memungkinkan saya untuk
mengeksekusi bahwa satu baris kode

244
00:13:09,470 --> 00:13:14,030
dan langkah ke baris ke
berikutnya, yang, dalam hal ini,

245
00:13:14,030 --> 00:13:17,060
akan berarti bahwa printf
pernyataan dieksekusi.

246
00:13:17,060 --> 00:13:22,310
Dan kemudian akan berhenti
eksekusi pada baris 13, seperti begitu.

247
00:13:22,310 --> 00:13:25,090
>> Dan ada juga langkah
ke dalam fungsi, yang

248
00:13:25,090 --> 00:13:28,950
berguna jika saya telah membuat lainnya
fungsi lain dalam kode sumber.

249
00:13:28,950 --> 00:13:31,420
Dan saya ingin melangkah ke
fungsi-fungsi daripada

250
00:13:31,420 --> 00:13:33,050
mengeksekusi fungsi yang secara keseluruhan.

251
00:13:33,050 --> 00:13:37,279
Tapi kita akan melihat lebih pada langkah yang
ke dalam fungsi hanya dalam beberapa saat.

252
00:13:37,279 --> 00:13:40,320
Sekarang perhatikan beberapa hal lain yang
benar-benar ada dalam panel debug.

253
00:13:40,320 --> 00:13:44,110
>> Kami memiliki panel ini disebut
panggilan stack, yang menunjukkan kepada kita

254
00:13:44,110 --> 00:13:45,300
di mana tepatnya kita berada.

255
00:13:45,300 --> 00:13:48,550
Dalam hal ini, kita berada di dalam
dari fungsi utama.

256
00:13:48,550 --> 00:13:50,880
Script kami disebut count.c.

257
00:13:50,880 --> 00:13:53,820
Dan kita kebetulan berada di
baris 13, kolom satu, yang

258
00:13:53,820 --> 00:13:58,950
adalah tepat apa wilayah disorot
dari kode sumber menunjukkan, juga.

259
00:13:58,950 --> 00:14:02,435
>> Sekarang perhatikan bahwa ini juga menunjukkan
di bawah bagian variabel lokal

260
00:14:02,435 --> 00:14:06,710
semua variabel yang
ada dalam fungsi ini.

261
00:14:06,710 --> 00:14:08,930
Sangat penting untuk dicatat
bahwa semua variabel

262
00:14:08,930 --> 00:14:12,580
akan muncul dalam variabel lokal ini
Bagian dalam fungsi,

263
00:14:12,580 --> 00:14:14,380
bahkan sebelum mereka didefinisikan.

264
00:14:14,380 --> 00:14:19,160
Kita bisa lihat di sini bahwa kita memiliki variabel
disebut num, memiliki nilai default 0,

265
00:14:19,160 --> 00:14:21,280
dan itu adalah tipe int.

266
00:14:21,280 --> 00:14:24,110
>> Sekarang sebelum kita benar-benar menginisialisasi
semua variabel,

267
00:14:24,110 --> 00:14:26,685
kita tidak perlu
dijamin untuk melihat nilai 0.

268
00:14:26,685 --> 00:14:29,200
Dan tergantung pada eksekusi lain
bahwa Anda telah melakukan

269
00:14:29,200 --> 00:14:32,020
dan keadaan memori Anda ketika
Anda benar-benar menjalankan program ini,

270
00:14:32,020 --> 00:14:34,605
Anda mungkin menemukan bahwa Anda
tidak melihat nilai 0

271
00:14:34,605 --> 00:14:36,550
dan, sebaliknya, beberapa nomor gila lainnya.

272
00:14:36,550 --> 00:14:38,390
>> Tapi jangan khawatir tentang itu.

273
00:14:38,390 --> 00:14:44,610
Ini tidak akan menjadi relevan sampai
Anda benar-benar menginisialisasi nilai.

274
00:14:44,610 --> 00:14:49,630
Sekarang dalam kasus ini, kita dapat melihat bahwa
Saya telah melakukan beberapa output.

275
00:14:49,630 --> 00:14:52,131
Dan aku, sekarang, berhenti eksekusi.

276
00:14:52,131 --> 00:14:53,880
Tapi dalam kasus ini, apa
Aku benar-benar ingin melakukan

277
00:14:53,880 --> 00:14:58,060
adalah untuk sekarang melangkahi garis ini
kode sehingga saya benar-benar bisa

278
00:14:58,060 --> 00:15:04,390
query pengguna untuk itu int yang
kita ingin menggunakan dalam program kami.

279
00:15:04,390 --> 00:15:07,060
>> Sekarang dalam kasus ini, ketika
Aku memukul melangkahi, pemberitahuan

280
00:15:07,060 --> 00:15:11,940
bahwa Jeda atau lebih tepatnya Resume
tombol telah berubah menjadi tombol Pause ini

281
00:15:11,940 --> 00:15:14,022
karena kode ini sebenarnya mengeksekusi.

282
00:15:14,022 --> 00:15:15,730
Apa yang terjadi
sekarang adalah bahwa hal itu

283
00:15:15,730 --> 00:15:21,630
menunggu kita untuk memasukkan beberapa informasi
seperti yang kita dapat melihat dengan teks output kami

284
00:15:21,630 --> 00:15:23,600
di bagian paling bawah.

285
00:15:23,600 --> 00:15:25,787
>> Jadi sekarang, ini adalah
tidak benar-benar berhenti,

286
00:15:25,787 --> 00:15:28,620
meskipun itu, semacam, muncul
menjadi karena tidak ada yang terjadi.

287
00:15:28,620 --> 00:15:32,360
Tapi kebetulan bahwa dalam
kasus tertentu saya on line 13,

288
00:15:32,360 --> 00:15:34,210
Aku sedang menunggu input pengguna.

289
00:15:34,210 --> 00:15:39,130
Dan GDB tidak mampu memeriksa
program seperti yang berjalan.

290
00:15:39,130 --> 00:15:43,370
>> Sekarang waktu berikutnya yang saya masukkan beberapa
input-- jadi saya akan memasukkan nomor 5,

291
00:15:43,370 --> 00:15:46,140
seperti yang kita lihat dalam
past-- tekan Kembali, dan kami

292
00:15:46,140 --> 00:15:51,430
melihat bahwa, segera, GDB jeda
dan, sekali lagi, menyoroti baris berikutnya.

293
00:15:51,430 --> 00:15:55,320
Tapi melihat bahwa sekarang, sebagai
Hasil kami memasukkan nilai,

294
00:15:55,320 --> 00:15:58,930
kami telah memperbarui nilai yang dalam
variabel lokal kami, yang

295
00:15:58,930 --> 00:16:05,560
sangat berguna untuk mengetahui secara tepat
apa nomor yang ada di memori.

296
00:16:05,560 --> 00:16:10,650
>> Sekarang saya bisa memungkinkan program ini untuk terus
bermain sampai akhir pelaksanaannya

297
00:16:10,650 --> 00:16:12,570
dengan memukul Lanjutkan.

298
00:16:12,570 --> 00:16:16,410
Kita bisa melihat bahwa sangat cepat
tidak selesai Program mengeksekusi

299
00:16:16,410 --> 00:16:19,790
dengan output yang sama bahwa kita
sebelumnya, debugger menutup,

300
00:16:19,790 --> 00:16:23,170
dan sekarang program ini
telah berhenti sepenuhnya.

301
00:16:23,170 --> 00:16:25,320
>> Saya menunjukkan bahwa hanya untuk
tujuan melihat apa

302
00:16:25,320 --> 00:16:27,280
terjadi ketika kita benar-benar memukul Lanjutkan.

303
00:16:27,280 --> 00:16:30,640
Tapi kita benar-benar akan
ingin kembali ke dalam program ini

304
00:16:30,640 --> 00:16:33,820
sehingga kita dapat mencoba untuk debug
tepatnya apa yang terjadi.

305
00:16:33,820 --> 00:16:37,980
Sekarang bahwa saya menggunakan debugger, saya mungkin
tidak perlu debug laporan printf ini.

306
00:16:37,980 --> 00:16:43,860
>> Jadi saya bisa menghapusnya karena saya akan melakukan
sekarang hanya untuk kembali ke kode sederhana kami

307
00:16:43,860 --> 00:16:45,950
bahwa kita memiliki beberapa saat yang lalu.

308
00:16:45,950 --> 00:16:48,790
Sekarang ketika saya menyimpan
program dan jalankan,

309
00:16:48,790 --> 00:16:53,700
akan, lagi, pergi ke awal yang
istirahat saat itu saya harus on line 11.

310
00:16:53,700 --> 00:16:57,700
Dan saya akan dapat memeriksa
variabel saya seperti yang saya ingin lakukan.

311
00:16:57,700 --> 00:17:00,695
>> Kebetulan yang ini
bagian tidak sangat menarik,

312
00:17:00,695 --> 00:17:04,364
Dan aku tahu bahwa aku akan
untuk mencetak pernyataan ini.

313
00:17:04,364 --> 00:17:05,280
Silakan masukkan nomor.

314
00:17:05,280 --> 00:17:08,099
Dan kemudian, aku tahu bahwa aku akan
untuk meminta pengguna untuk integer yang.

315
00:17:08,099 --> 00:17:13,329
Jadi mungkin, aku benar-benar ingin pindah saya
titik istirahat sedikit lebih bawah.

316
00:17:13,329 --> 00:17:16,710
>> Anda dapat menghapus break point
dengan mengklik, sekali lagi, langsung

317
00:17:16,710 --> 00:17:18,460
di sebelah kiri yang nomor baris.

318
00:17:18,460 --> 00:17:22,200
Itu titik merah akan hilang, menunjukkan
bahwa break point sekarang hilang.

319
00:17:22,200 --> 00:17:24,780
Sekarang dalam kasus ini,
eksekusi telah berhenti.

320
00:17:24,780 --> 00:17:27,770
Dan sehingga tidak benar-benar akan
melanjutkan dalam contoh khusus.

321
00:17:27,770 --> 00:17:30,210
Tapi aku bisa mengatur istirahat
menunjukkan sedikit kemudian.

322
00:17:30,210 --> 00:17:33,880
>> Dan ketika saya sekarang melanjutkan saya
kode, akan melanjutkan dan memberitahu

323
00:17:33,880 --> 00:17:36,190
titik titik istirahat.

324
00:17:36,190 --> 00:17:37,374
Sekali lagi, aku memukul Lanjutkan.

325
00:17:37,374 --> 00:17:39,040
Tidak tampak seperti ada sesuatu yang terjadi.

326
00:17:39,040 --> 00:17:41,450
Tapi itu karena saya
Kode menunggu masukan.

327
00:17:41,450 --> 00:17:47,900
Saya akan memasukkan nomor 5, tekan Enter, dan
sekarang titik istirahat berikutnya akan terkena.

328
00:17:47,900 --> 00:17:50,570
>> Sekarang dalam kasus ini, ini
adalah baris kode

329
00:17:50,570 --> 00:17:53,820
bahwa, sebelumnya, kami tahu
kebetulan kereta.

330
00:17:53,820 --> 00:17:57,590
Jadi mari kita mengevaluasi apa yang terjadi
pada titik tertentu dalam waktu.

331
00:17:57,590 --> 00:18:02,620
Ketika garis disorot, ini
garis belum dieksekusi.

332
00:18:02,620 --> 00:18:06,490
Jadi dalam hal ini, kita dapat melihat
bahwa saya memiliki nomor, yang

333
00:18:06,490 --> 00:18:11,610
Saya memiliki sebuah integer disebut
num yang memiliki nilai 5.

334
00:18:11,610 --> 00:18:15,090
Dan aku akan tampil
beberapa matematika di nomor itu.

335
00:18:15,090 --> 00:18:20,130
>> Jika saya melangkah lebih dari itu, kita dapat
melihat bahwa nilai num

336
00:18:20,130 --> 00:18:23,780
telah berubah sesuai dengan
aritmatika bahwa kita sudah benar-benar dilakukan.

337
00:18:23,780 --> 00:18:26,810
Dan sekarang bahwa kita
dalam hal ini untuk loop

338
00:18:26,810 --> 00:18:29,090
atau sekarang bahwa untuk loop
sendiri disorot,

339
00:18:29,090 --> 00:18:32,450
kita melihat bahwa kita memiliki baru
variabel yang disebut i yang

340
00:18:32,450 --> 00:18:35,370
akan digunakan dalam untuk loop.

341
00:18:35,370 --> 00:18:38,230
>> Sekarang ingat sebelum itu saya
disebutkan bahwa kadang-kadang Anda

342
00:18:38,230 --> 00:18:43,470
akan melihat beberapa jenis gila
nomor sebagai default sebelum nomor yang

343
00:18:43,470 --> 00:18:45,530
atau variabel yang
sebenarnya diinisialisasi.

344
00:18:45,530 --> 00:18:49,040
Kita bisa melihat bahwa justru
di sini di variabel ini

345
00:18:49,040 --> 00:18:51,345
disebut i, yang belum
belum diinisialisasi

346
00:18:51,345 --> 00:18:53,560
pada saat menyoroti.

347
00:18:53,560 --> 00:18:57,070
Tapi kita dapat melihat bahwa ia memiliki beberapa nomor
bahwa kita tidak akan benar-benar berharap.

348
00:18:57,070 --> 00:18:57,620
>> Tidak apa-apa.

349
00:18:57,620 --> 00:18:59,661
Jangan khawatir tentang hal itu
karena kita belum benar-benar

350
00:18:59,661 --> 00:19:04,970
diinisialisasi jumlah yang sampai aku
melangkahi garis ini dan nilai

351
00:19:04,970 --> 00:19:08,560
i telah diinisialisasi dengan nilai 1.

352
00:19:08,560 --> 00:19:11,400
Jadi untuk melihat bahwa itu sebenarnya
kasus, mari kita melangkah lebih.

353
00:19:11,400 --> 00:19:14,420
Kita sekarang dapat melihat bahwa yang
garis telah dieksekusi.

354
00:19:14,420 --> 00:19:17,000
Dan kita sekarang menyoroti
baris printf ini.

355
00:19:17,000 --> 00:19:22,230
>> Dan kita sekarang dapat melihat bagaimana nilai-nilai kita
i dan 3 telah berubah dari waktu ke waktu.

356
00:19:22,230 --> 00:19:26,450
Hal ini sangat berguna untuk dilakukan, pada kenyataannya,
adalah langkah di atas garis berulang kali.

357
00:19:26,450 --> 00:19:30,480
Dan Anda dapat menemukan apa yang sebenarnya
terjadi dalam untuk loop Anda

358
00:19:30,480 --> 00:19:33,660
dan apa yang terjadi pada
variabel dalam yang untuk loop

359
00:19:33,660 --> 00:19:39,200
sebagai pelaksanaan program yang
terjadi satu langkah pada satu waktu.

360
00:19:39,200 --> 00:19:41,110
>> Sekarang pada saat ini, saya
melangkahi cukup

361
00:19:41,110 --> 00:19:44,210
bahwa saya sekarang saya di akhir program saya.

362
00:19:44,210 --> 00:19:46,980
Jika saya melangkah lebih dari itu, itu akan
sebenarnya berhenti eksekusi

363
00:19:46,980 --> 00:19:48,860
seperti yang kita lihat di masa lalu.

364
00:19:48,860 --> 00:19:52,110
Biarkan saya memulai ini, lagi-lagi, sehingga
bahwa saya bisa menunjukkan sesuatu yang lain keluar,

365
00:19:52,110 --> 00:19:53,320
demikian juga.

366
00:19:53,320 --> 00:19:55,350
>> Dalam hal ini, itu adalah
sekarang meminta saya, sekali lagi,

367
00:19:55,350 --> 00:19:57,100
untuk nomor, yang
Saya akan, lagi, masuk.

368
00:19:57,100 --> 00:20:00,300
Tapi kali ini, saya akan masuk dalam
jumlah yang lebih besar sehingga untuk loop

369
00:20:00,300 --> 00:20:02,540
akan iterate kali.

370
00:20:02,540 --> 00:20:06,090
Dalam hal ini, saya akan
untuk memasukkan nilai 11.

371
00:20:06,090 --> 00:20:08,390
>> Sekarang lagi karena saya akan mengatur
break point pada baris 15,

372
00:20:08,390 --> 00:20:10,490
itu akan menyoroti garis.

373
00:20:10,490 --> 00:20:12,980
Kita dapat melihat bahwa kami
nomor 11 adalah benar

374
00:20:12,980 --> 00:20:15,560
direpresentasikan dalam variabel lokal kami.

375
00:20:15,560 --> 00:20:22,460
Melangkahi itu, kita dapat sekarang
menonton apa yang terjadi pada nilai kami i

376
00:20:22,460 --> 00:20:25,680
seperti yang kita lanjutkan dalam ini untuk loop.

377
00:20:25,680 --> 00:20:31,960
Ini akan bertambah setiap kali kita
mencapai puncak yang untuk loop.

378
00:20:31,960 --> 00:20:35,110
>> Sekarang salah satu hal yang mungkin
berguna untuk melakukan selama eksekusi

379
00:20:35,110 --> 00:20:40,490
dari program ini adalah bagi saya untuk benar-benar
mengubah variabel tengah jalan untuk melihat

380
00:20:40,490 --> 00:20:42,450
apa yang terjadi pada program saya.

381
00:20:42,450 --> 00:20:46,540
Dalam hal ini, saya benar-benar bisa
klik dua kali nilai.

382
00:20:46,540 --> 00:20:48,040
Perhatikan bahwa itu menjadi kolom teks.

383
00:20:48,040 --> 00:20:50,280
>> Sekarang saya bisa masuk berbeda
menghargai sama sekali

384
00:20:50,280 --> 00:20:55,700
untuk melihat bagaimana program saya berperilaku
ketika aku sudah berubah variabel itu.

385
00:20:55,700 --> 00:20:59,560
Sekarang dalam kasus ini, variabel
i sekarang berisi nilai 10.

386
00:20:59,560 --> 00:21:02,810
Namun program ini masih
berhenti di eksekusi.

387
00:21:02,810 --> 00:21:07,610
Ketika saya melangkah lebih, saya melihat bahwa
nilai i, yang saya dimasukkan sebagai 10,

388
00:21:07,610 --> 00:21:12,170
tidak lebih besar dari nilai num,
yang segera menyebabkan untuk loop

389
00:21:12,170 --> 00:21:14,240
untuk menghentikan mengeksekusi.

390
00:21:14,240 --> 00:21:16,210
>> Nah, itu bukan satu-satunya
Alasan mengapa Anda akan

391
00:21:16,210 --> 00:21:19,450
ingin memodifikasi variabel di tempat.

392
00:21:19,450 --> 00:21:22,210
Anda mungkin benar-benar ingin
untuk mencoba memodifikasinya sehingga

393
00:21:22,210 --> 00:21:24,590
Anda dapat melanjutkan
eksekusi loop

394
00:21:24,590 --> 00:21:27,370
atau sehingga Anda dapat memodifikasi
beberapa nilai sebelum

395
00:21:27,370 --> 00:21:32,630
mencapai beberapa set tertentu dari aritmatika
bahwa Anda sedang melakukan.

396
00:21:32,630 --> 00:21:36,210
>> Jadi sekarang kita benar-benar mengubah
nilai i sebagai program mengeksekusi,

397
00:21:36,210 --> 00:21:39,540
itu disebabkan untuk loop untuk berhenti
prematur karena, tiba-tiba, saya

398
00:21:39,540 --> 00:21:42,770
terjadi lebih besar dari nilai
num, artinya bahwa untuk loop

399
00:21:42,770 --> 00:21:45,410
tidak lagi diperlukan untuk dieksekusi.

400
00:21:45,410 --> 00:21:48,780
Selanjutnya, hal itu terjadi untuk menjadi
hal ini kita mengubah nilai dari i

401
00:21:48,780 --> 00:21:53,270
ketika garis 17 disorot,
yang merupakan titik waktu

402
00:21:53,270 --> 00:21:56,280
bahwa untuk pelaksanaan lingkaran
sebenarnya sedang dievaluasi.

403
00:21:56,280 --> 00:22:00,210
>> Jika saya telah mengubah nilai
i pada baris yang berbeda, mengatakan 19,

404
00:22:00,210 --> 00:22:03,360
kita akan melihat yang berbeda
perilaku karena baris 19 akan

405
00:22:03,360 --> 00:22:08,310
telah dijalankan sebelum loop
Kondisi itu dievaluasi ulang.

406
00:22:08,310 --> 00:22:11,900
Sekarang pada titik ini, saya, lagi,
pada akhir program ini.

407
00:22:11,900 --> 00:22:15,707
Dan aku bisa membiarkan ini melanjutkan ke
memungkinkan program saya untuk berhenti secara alami.

408
00:22:15,707 --> 00:22:18,290
Tapi ada beberapa hal
yang penting untuk mengambil

409
00:22:18,290 --> 00:22:19,960
dari diskusi khusus ini.

410
00:22:19,960 --> 00:22:22,490
Anda perlu mengevaluasi
asumsi Anda sendiri

411
00:22:22,490 --> 00:22:24,710
tentang bagaimana kode harus berperilaku.

412
00:22:24,710 --> 00:22:28,220
Setiap kali Anda berpikir bahwa beberapa bagian
kode Anda tahu terjadi untuk bekerja,

413
00:22:28,220 --> 00:22:30,940
yang mungkin bendera merah untuk pergi
kembali dan mengevaluasi, dan pastikan

414
00:22:30,940 --> 00:22:33,470
bahwa asumsi Anda
bagaimana kode yang beroperasi

415
00:22:33,470 --> 00:22:38,290
sebenarnya benar bagaimana itu
dinyatakan dalam kode sumber Anda.

416
00:22:38,290 --> 00:22:41,300
>> Tetapi bahkan lebih ke titik itu,
ketika kita menggunakan debugger,

417
00:22:41,300 --> 00:22:43,920
Anda dapat menempatkan breakpoints di
baris yang berbeda dari kode,

418
00:22:43,920 --> 00:22:48,110
yang akan menyebabkan debugger untuk
jeda eksekusi pada masing-masing baris

419
00:22:48,110 --> 00:22:52,210
sehingga Anda dapat mengevaluasi
memori atau bahkan mengubahnya di tempat.

420
00:22:52,210 --> 00:22:55,630
Dan lagi, ingat bahwa Anda dapat
membuat beberapa breakpoints sehingga Anda

421
00:22:55,630 --> 00:23:00,390
juga dapat melanjutkan eksekusi, melewatkan
lebih besar bagian dari kode,

422
00:23:00,390 --> 00:23:04,790
dan secara otomatis akan berhenti
pada titik istirahat berikutnya.

423
00:23:04,790 --> 00:23:07,760
>> Ada sebenarnya yang lebih maju
fitur dari debugger, juga.

424
00:23:07,760 --> 00:23:10,170
Tapi kita harus merujuk Anda
untuk beberapa video berikutnya

425
00:23:10,170 --> 00:23:14,090
agar benar-benar menggoda terpisah bagaimana
menggunakan fungsi-fungsi tertentu.

426
00:23:14,090 --> 00:23:15,990
Untuk saat ini, terima kasih
sangat banyak untuk menonton.

427
00:23:15,990 --> 00:23:18,080
Dan keberuntungan debugging.