1
00:00:07,170 --> 00:00:12,630
[Powered by Google Translate] GDB, Proyek GNU Debugger, adalah alat yang ampuh untuk debugging C,

2
00:00:12,630 --> 00:00:14,300
bersama dengan banyak bahasa lainnya.

3
00:00:14,300 --> 00:00:17,440
Hal ini memungkinkan Anda untuk melihat-lihat di dalam program Anda C ketika mereka mengeksekusi,

4
00:00:17,440 --> 00:00:20,880
dan juga memberikan Anda kesempatan untuk melihat apa yang terjadi

5
00:00:20,880 --> 00:00:22,490
ketika crash program anda.

6
00:00:22,490 --> 00:00:24,690
Ini cukup bagus, kan?

7
00:00:24,690 --> 00:00:27,980
GDB adalah perangkat lunak bebas, dan berjalan pada UNIX populer dan

8
00:00:27,980 --> 00:00:31,840
Berbasis Windows sistem operasi, sehingga alat yang sangat luas.

9
00:00:31,840 --> 00:00:33,560
>> Anda harus belajar untuk menyukainya.

10
00:00:33,560 --> 00:00:36,800
Pro GDB memiliki waktu yang jauh lebih mudah melacak bug

11
00:00:36,800 --> 00:00:39,150
dibandingkan dengan mereka yang menggunakan kekisruhan melalui tebakan

12
00:00:39,150 --> 00:00:41,420
dan jumlah tak terbatas pernyataan cetakan.

13
00:00:41,420 --> 00:00:45,810
GDB adalah alat baris perintah, yang berarti Anda dapat berinteraksi dengan itu dalam terminal

14
00:00:45,810 --> 00:00:49,720
mengeluarkan perintah melalui keyboard daripada mengklik tombol dengan mouse anda.

15
00:00:49,720 --> 00:00:54,960
>> Untuk memulai GDB, Anda benar-benar hanya gdb pada prompt dan tekan enter.

16
00:00:54,960 --> 00:00:58,230
Anda akan melihat beberapa baris dicetak ke layar

17
00:00:58,230 --> 00:01:00,810
menunjukkan kepada Anda versi GDB bahwa Anda menjalankan,

18
00:01:00,810 --> 00:01:07,890
informasi hak cipta, dan pada akhirnya Anda akan melihat prompt GDB: (gdb).

19
00:01:07,890 --> 00:01:10,770
Ini memungkinkan Anda tahu bahwa GDB siap untuk perintah.

20
00:01:10,770 --> 00:01:15,400
Pada titik ini, hal yang paling penting untuk mengetahui bagaimana melakukan adalah berhenti.

21
00:01:15,400 --> 00:01:17,790
Untungnya, ini cukup sederhana.

22
00:01:17,790 --> 00:01:19,840
Perintah berhenti tidak hanya itu.

23
00:01:19,840 --> 00:01:23,090
Sebagai jalan pintas, Anda hanya dapat menggunakan q juga.

24
00:01:23,090 --> 00:01:27,410
Menyenangkan seperti boot up GDB dan kemudian segera berhenti adalah,

25
00:01:27,410 --> 00:01:30,800
mari kita sekarang berbicara tentang menggunakan GDB untuk membantu men-debug program.

26
00:01:30,800 --> 00:01:34,630
>> Untuk memulai, saya punya program di sini di factorial.c

27
00:01:34,630 --> 00:01:37,380
yang mendapat int dan mencoba untuk menghitung faktorial nya.

28
00:01:37,380 --> 00:01:41,270
Dalam kasus Anda belum melihat faktorial sebelumnya atau tidak ingat mereka,

29
00:01:41,270 --> 00:01:47,840
Faktorial dari jumlah n adalah sama dengan produk dari n - (n - 1), (n - 2), dan seterusnya -

30
00:01:47,840 --> 00:01:49,230
sampai Anda mencapai 1.

31
00:01:49,230 --> 00:01:54,550
Oleh karena itu, faktorial dari 3 adalah 3 * 2 * 1, atau 6,

32
00:01:54,550 --> 00:02:00,180
dan faktorial 4 adalah 4 * 3 * 2 * 1, atau 24.

33
00:02:00,180 --> 00:02:03,970
Faktorial dari nol merupakan kasus yang aneh, itu 1,

34
00:02:03,970 --> 00:02:06,970
dan faktorial bilangan bulat negatif tidak didefinisikan.

35
00:02:06,970 --> 00:02:10,280
Pokoknya, sesuatu tentang program faktorial saya funky.

36
00:02:10,280 --> 00:02:15,410
Ketika saya menjalankannya, ia akan mencetak angka aneh yang tidak ada hubungannya dengan faktorial.

37
00:02:15,410 --> 00:02:19,030
>> Jadi, kita dapat menggunakan GDB untuk membantu mencari tahu apa yang terjadi.

38
00:02:19,030 --> 00:02:21,720
GDB beroperasi pada file executable,

39
00:02:21,720 --> 00:02:24,910
yang merupakan file biner yang dihasilkan oleh proses kompilasi.

40
00:02:24,910 --> 00:02:30,940
Artinya, kita tidak dapat menjalankan GDB pada c kami. Atau file h kode sumber seperti factorial.c..

41
00:02:30,940 --> 00:02:34,650
Kami ingin menjalankannya hanya pada faktorial sebagai gantinya.

42
00:02:34,650 --> 00:02:38,340
Jika program yang dibutuhkan setiap argumen baris perintah,

43
00:02:38,340 --> 00:02:40,230
ini adalah di mana kita akan menentukan mereka.

44
00:02:40,230 --> 00:02:44,050
Dalam hal ini, faktorial tidak memerlukan argumen baris perintah,

45
00:02:44,050 --> 00:02:46,410
jadi kami hanya menjalankan atau ketik r untuk pendek.

46
00:02:46,410 --> 00:02:50,440
>> Ini akan memulai program berjalan faktorial.

47
00:02:50,440 --> 00:02:53,940
Ketika program berhenti berjalan, saya akan mendapatkan GDB saya meminta kembali.

48
00:02:53,940 --> 00:02:58,130
Oke, mari kita coba hal yang sama lagi, faktorial 4.

49
00:02:58,130 --> 00:03:02,910
Baiklah, kita melihat bahwa kita mendapatkan jenis yang sama dari sampah di sini di GDB.

50
00:03:02,910 --> 00:03:04,850
Sekarang program tersebut telah selesai,

51
00:03:04,850 --> 00:03:06,870
kita tidak bisa masuk dan mengakses salah satu dari negaranya,

52
00:03:06,870 --> 00:03:09,870
jadi kita harus mulai berjalan lagi sebelum kita bisa melihat apa yang terjadi.

53
00:03:09,870 --> 00:03:13,570
Namun, kita perlu cara untuk menghentikannya sementara itu di tengah-tengah menjalankan nya.

54
00:03:13,570 --> 00:03:16,970
>> Untuk melakukan itu, kita menggunakan apa yang disebut breakpoint.

55
00:03:16,970 --> 00:03:21,880
Breakpoints memberitahu GDB untuk menghentikan program pada fungsi tertentu atau baris kode sumber

56
00:03:21,880 --> 00:03:24,070
sehingga kita bisa memeriksa keadaan program,

57
00:03:24,070 --> 00:03:27,380
nilai-nilai variabel, keadaan memori dan semacamnya, pada saat itu.

58
00:03:27,380 --> 00:03:30,750
Karena saya tidak benar-benar tahu di mana sesuatu yang buruk terjadi,

59
00:03:30,750 --> 00:03:33,510
>> Saya hanya ingin memulai debug tepat di awal,

60
00:03:33,510 --> 00:03:36,510
tepat ketika utama dimulai.

61
00:03:36,510 --> 00:03:39,260
Kami akan mengatur breakpoint pada awal utama menggunakan perintah istirahat.

62
00:03:39,260 --> 00:03:42,640
Kita juga bisa menggunakan b untuk menyingkat istirahat.

63
00:03:42,640 --> 00:03:45,000
Sekarang mari kita mulai program berjalan lagi.

64
00:03:45,000 --> 00:03:48,140
Di sini kita berada di awal utama, seperti GDB memberitahu kita.

65
00:03:48,140 --> 00:03:51,970
Baris kode yang akan mengeksekusi namun belum

66
00:03:51,970 --> 00:03:53,480
adalah baris printf.

67
00:03:53,480 --> 00:03:57,200
Kita bisa mengatakan GDB untuk mengeksekusi baris kode ini dan pergi ke baris berikutnya

68
00:03:57,200 --> 00:03:59,840
dengan perintah selanjutnya atau n.

69
00:03:59,840 --> 00:04:04,120
>> Baiklah, sekarang GDB memberitahu kita bahwa kita berada di jalur GetInt.

70
00:04:04,120 --> 00:04:06,630
Saya tahu bahwa sepertinya baris printf tidak dijalankan

71
00:04:06,630 --> 00:04:10,070
karena kita tidak melihat "Masukkan bilangan bulat positif" print out di layar,

72
00:04:10,070 --> 00:04:12,040
tapi itu benar-benar dijalankan.

73
00:04:12,040 --> 00:04:16,029
Apa yang kita lihat adalah sistem operasi menekan apapun tulisan ke layar

74
00:04:16,029 --> 00:04:19,649
sampai benar-benar harus, yang mengapa debugging dengan cetakan

75
00:04:19,649 --> 00:04:21,730
kadang-kadang bisa diandalkan.

76
00:04:21,730 --> 00:04:26,240
Pokoknya, mari kita lagi pergi ke baris berikutnya kode dan masuk dalam sebuah int.

77
00:04:26,240 --> 00:04:30,070
Sekali lagi, mari kita tipe 4.

78
00:04:30,070 --> 00:04:34,540
Jadi ini terlihat aneh. Kami berada di baris 12 sesuai dengan GDB,

79
00:04:34,540 --> 00:04:37,660
tapi baris berikutnya yang akan mengeksekusi hanya penjepit keriting.

80
00:04:37,660 --> 00:04:42,110
>> Itu hanya berarti kita berada di akhir loop, kami lakukan sementara loop pada kenyataannya,

81
00:04:42,110 --> 00:04:46,710
GDB dan mengatakan kepada kita bahwa kondisi terminasi, yaitu tidak kurang dari nol,

82
00:04:46,710 --> 00:04:48,010
akan mengeksekusi berikutnya.

83
00:04:48,010 --> 00:04:50,230
Jika ini pernah mendapat sedikit membingungkan,

84
00:04:50,230 --> 00:04:54,860
kita dapat menarik kode sumber dalam GDB dengan daftar atau perintah l.

85
00:04:54,860 --> 00:04:56,880
Hal ini mencetak kode sumber

86
00:04:56,880 --> 00:04:59,010
yang berpusat di sekitar garis bahwa kita saat ini.

87
00:04:59,010 --> 00:05:03,590
Jika kita mengetik daftar atau l lagi, kita akan melihat set berikutnya garis mencetak.

88
00:05:03,590 --> 00:05:06,070
Kita bisa melakukan hal ini sampai kita memukul akhir file.

89
00:05:06,070 --> 00:05:11,210
>> Untuk kembali ke tempat kami, kami dapat menyediakan daftar dengan nomor baris,

90
00:05:11,210 --> 00:05:14,120
dalam kasus ini, baris 12.

91
00:05:14,120 --> 00:05:16,040
Pokoknya, mari kita lanjutkan.

92
00:05:16,040 --> 00:05:18,240
Sekarang kita berada di lingkaran 4.

93
00:05:18,240 --> 00:05:21,490
Mari kita pastikan bahwa variabel num kami berisi 4.

94
00:05:21,490 --> 00:05:26,170
Kami melakukan ini dengan cetak, atau p, perintah.

95
00:05:26,170 --> 00:05:31,140
Jadi, GDB memberitahu kita bahwa num memang menyimpan 4, seperti yang kami harapkan.

96
00:05:31,140 --> 00:05:35,180
$ 1 GDB yang mencetak adalah variabel GDB khusus

97
00:05:35,180 --> 00:05:37,720
yang kini ditetapkan untuk menyimpan 4 angka juga.

98
00:05:37,720 --> 00:05:42,240
Anda dapat mengabaikan ini untuk saat ini, namun variabel-variabel GDB datang di super berguna

99
00:05:42,240 --> 00:05:46,380
dalam kasus-kasus yang lebih maju bila Anda ingin mengingat apa yang telah Anda lakukan di masa lalu.

100
00:05:46,380 --> 00:05:50,970
Pokoknya, bergerak dengan berikutnya, kita melihat bahwa kita mulai bergerak melalui untuk loop.

101
00:05:50,970 --> 00:05:54,790
Mari kita terus melalui sini dengan bit n demi sedikit.

102
00:05:54,790 --> 00:05:58,280
Daripada mengetik n setiap kali, Anda juga dapat hanya tekan enter.

103
00:05:58,280 --> 00:06:03,710
Ketika Anda tekan enter tanpa mengetik apa-apa, GDB hanya mengulangi perintah sebelumnya.

104
00:06:03,710 --> 00:06:05,910
Jadi sekarang kita telah memukul panggilan printf.

105
00:06:05,910 --> 00:06:09,520
Sepertinya kita memang pergi melalui kami untuk loop 4 kali,

106
00:06:09,520 --> 00:06:13,750
yang adalah apa yang kita ingin lakukan dalam rangka kalikan dengan 1, 2, 3, dan 4.

107
00:06:13,750 --> 00:06:15,870
>> Semuanya tampak seperti itu bekerja,

108
00:06:15,870 --> 00:06:19,680
kecuali ketika kita memukul berikutnya lagi kita mendapatkan sejumlah besar bukannya 24.

109
00:06:19,680 --> 00:06:23,100
Jika kita mencetak nilai p menggunakan faktorial,

110
00:06:23,100 --> 00:06:26,120
kita melihat bahwa faktorial tidak memiliki jumlah besar di dalamnya.

111
00:06:26,120 --> 00:06:28,740
Sesuatu yang pasti akan salah.

112
00:06:28,740 --> 00:06:31,960
Pada titik ini, meskipun, kita hampir di akhir program,

113
00:06:31,960 --> 00:06:34,610
dan sudah terlambat untuk memperbaiki apa-apa.

114
00:06:34,610 --> 00:06:39,750
>> Namun, kita dapat memulai program dengan mengetik r lagi dan kemudian y untuk mengkonfirmasi.

115
00:06:39,750 --> 00:06:43,460
Sekarang kita kembali pada breakpoint kami pada awal utama.

116
00:06:43,460 --> 00:06:46,600
Kita tahu bahwa segala sesuatu tampaknya baik-baik saja dengan membaca di n.

117
00:06:46,600 --> 00:06:48,630
sehingga kita bisa melompat ke depan dengan n.

118
00:06:48,630 --> 00:06:52,280
Atau, kita dapat mengatur breakpoint baru setelah melakukan sementara loop

119
00:06:52,280 --> 00:06:54,910
dan melompat di sana. Mari kita lakukan itu.

120
00:06:54,910 --> 00:06:59,080
Sepertinya baris 14 datang hanya setelah loop.

121
00:06:59,080 --> 00:07:01,070
Mari kita mengatur breakpoint sana.

122
00:07:01,070 --> 00:07:05,220
Ini praktik yang baik untuk menentukan nama file dalam perintah breakpoint

123
00:07:05,220 --> 00:07:08,480
sejak GDB dapat bingung jika Anda bekerja dengan beberapa file.

124
00:07:08,480 --> 00:07:13,230
Untuk bergerak maju dari breakpoint ini, kita akan menggunakan berlanjut atau perintah c.

125
00:07:13,230 --> 00:07:16,570
>> Oke, di sini kita berada di untuk loop.

126
00:07:16,570 --> 00:07:19,060
Ayo baris 1 lebih ke dalam untuk loop,

127
00:07:19,060 --> 00:07:21,630
dan kemudian kita akan mulai mencetak variabel untuk melihat apa yang terjadi.

128
00:07:21,630 --> 00:07:26,410
Mari kita pastikan bahwa saya memang 1, seperti yang diharapkan.

129
00:07:26,410 --> 00:07:28,300
Yup, itu semua baik.

130
00:07:28,300 --> 00:07:30,270
Bagaimana faktorial meskipun?

131
00:07:30,270 --> 00:07:33,760
Whoa, itu tidak baik.

132
00:07:33,760 --> 00:07:35,800
Kami punya angka negatif besar di sini.

133
00:07:35,800 --> 00:07:38,190
Bagaimana itu terjadi?

134
00:07:38,190 --> 00:07:40,040
Nah, jika kita melihat kembali kode,

135
00:07:40,040 --> 00:07:44,800
kita melihat bahwa kita tidak pernah diinisialisasi itu, jadi kami hanya punya sampah di sana.

136
00:07:44,800 --> 00:07:46,820
Yang pasti akan membuang perhitungan kami.

137
00:07:46,820 --> 00:07:49,930
>> Untungnya, kita tidak harus meninggalkan GDB untuk memperbaiki hal ini.

138
00:07:49,930 --> 00:07:54,590
Kita dapat menginisialisasi benar di sini dan memperbaikinya dalam kode kemudian menggunakan perintah cetak.

139
00:07:54,590 --> 00:07:59,500
Kami akan menginisialisasi ke 1 sejak faktorial dari nol dan 1 keduanya 1,

140
00:07:59,500 --> 00:08:03,940
dan jika kita menginisialisasi ke nol, maka kita akan selalu berakhir dengan nol sebagai hasilnya kami.

141
00:08:03,940 --> 00:08:08,370
Anda dapat mengatur cara ini variabel, yang super berguna.

142
00:08:08,370 --> 00:08:10,920
Sekarang, mari kita lanjutkan program kami.

143
00:08:10,920 --> 00:08:14,040
Mari kita pastikan semuanya di mana itu seharusnya.

144
00:08:14,040 --> 00:08:19,090
Num harus 4, saya harus 1, dan faktorial harus 1 juga.

145
00:08:19,090 --> 00:08:23,990
Kita dapat jalan pintas proses ini dan mencetak semua variabel lokal kami

146
00:08:23,990 --> 00:08:26,440
dengan super membantu penduduk setempat Info perintah,

147
00:08:26,440 --> 00:08:29,190
yang mencetak semua di-lingkup variabel lokal kami.

148
00:08:29,190 --> 00:08:31,980
Pokoknya, sepertinya semuanya baik untuk pergi.

149
00:08:31,980 --> 00:08:34,700
>> Mari kita lakukan lagi go-sekitar loop hanya untuk memastikan.

150
00:08:34,700 --> 00:08:38,789
Oke, semuanya tampak hebat.

151
00:08:38,789 --> 00:08:41,659
Sekarang kita dapat menggunakan perintah continue untuk pergi sampai akhir.

152
00:08:41,659 --> 00:08:46,170
Manis! 4 faktorial dicetak 24 seperti yang diharapkan.

153
00:08:46,170 --> 00:08:48,690
Sekarang kita bisa memperbaiki ini dalam kode kita.

154
00:08:48,690 --> 00:08:53,710
Daripada berhenti keluar dari GDB, kita akan menggunakan tab lain terminal untuk melakukan hal ini.

155
00:08:53,710 --> 00:08:58,080
Kembali ke tab GDB kita, sekarang kita perlu mengkompilasi ulang dieksekusi kami.

156
00:08:58,080 --> 00:09:03,180
Salah satu hal terbaik tentang GDB adalah bahwa Anda tidak perlu meninggalkan GDB untuk menjalankan make.

157
00:09:03,180 --> 00:09:06,570
Sehingga kita tidak terus memukul breakpoints tua,

158
00:09:06,570 --> 00:09:10,440
mari kita menonaktifkan mereka dengan, Anda dapat menebaknya, menonaktifkan perintah.

159
00:09:10,440 --> 00:09:13,320
Ini akan menonaktifkan semua breakpoints kami.

160
00:09:13,320 --> 00:09:18,180
Sekarang, kita dapat me-restart program dengan r dan memastikan semuanya baik-baik saja.

161
00:09:18,180 --> 00:09:21,300
Sepertinya semuanya baik untuk pergi.

162
00:09:21,300 --> 00:09:24,410
Faktorial dari 4 print 24, sama seperti kami pikir.

163
00:09:24,410 --> 00:09:28,830
GDB adalah salah satu alat yang paling membantu Anda punya di kotak peralatan Anda.

164
00:09:28,830 --> 00:09:31,970
>> Ada hal-hal ton lebih yang dapat Anda lakukan dengan GDB,

165
00:09:31,970 --> 00:09:34,030
jauh lebih banyak daripada yang dapat Anda lakukan dengan cetakan sederhana.

166
00:09:34,030 --> 00:09:36,730
Lain kali program anda tidak melakukan apa yang Anda ingin,

167
00:09:36,730 --> 00:09:39,740
coba jalankan GDB untuk mencari tahu apa yang terjadi di dalam.

168
00:09:39,740 --> 00:09:44,380
Dengan sedikit latihan, Anda akan dapat menelusuri tepat di bug Anda dalam waktu singkat.

169
00:09:44,380 --> 00:09:48,180
Nama saya adalah Nate Hardison. Ini adalah CS50.