1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Minggu 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
[Ini adalah CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Baiklah, ini adalah CS50, dan ini adalah awal minggu 4,

5
00:00:12,000 --> 00:00:16,000
dan ini adalah salah satu algoritma penyortiran paling lambat mungkin.

6
00:00:16,000 --> 00:00:19,000
Yang satu adalah bahwa kita hanya menyaksikan sana?

7
00:00:19,000 --> 00:00:24,000
Itu semacam gelembung, dalam rangka big O (n ^ 2) + sum,

8
00:00:24,000 --> 00:00:28,000
dan memang kita tidak satu-satunya di dunia ini untuk tampaknya tahu

9
00:00:28,000 --> 00:00:30,000
macam apa gelembung atau waktu yang berjalan.

10
00:00:30,000 --> 00:00:33,000
Memang, ini adalah sebuah wawancara dengan Eric Schmidt dari Google

11
00:00:33,000 --> 00:00:45,000
dan mantan senator Barack Obama hanya beberapa tahun yang lalu.

12
00:00:45,000 --> 00:00:48,000
>> Sekarang, Senator, kau di sini di Google,

13
00:00:48,000 --> 00:00:54,000
dan saya suka berpikir kepresidenan sebagai wawancara kerja.

14
00:00:54,000 --> 00:00:58,000
Sekarang, sulit untuk mendapatkan pekerjaan sebagai presiden, dan Anda akan melalui kerasnya sekarang.

15
00:00:58,000 --> 00:01:00,000
Ini juga sulit untuk mendapatkan pekerjaan di Google.

16
00:01:00,000 --> 00:01:05,000
Kami memiliki pertanyaan, dan kami meminta kandidat kami pertanyaan,

17
00:01:05,000 --> 00:01:10,000
dan yang satu ini adalah dari Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Kalian pikir aku bercanda? Ada di sini.

19
00:01:14,000 --> 00:01:18,000
Apa cara yang paling efisien untuk menyortir satu juta 32-bit bilangan bulat?

20
00:01:18,000 --> 00:01:21,000
[Tertawa]

21
00:01:21,000 --> 00:01:24,000
Nah-

22
00:01:24,000 --> 00:01:26,000
Maafkan aku >> Tidak, tidak, tidak, tidak..

23
00:01:26,000 --> 00:01:34,000
Saya pikir bubble sort akan menjadi cara yang salah untuk pergi.

24
00:01:34,000 --> 00:01:39,000
>> Ayo, yang mengatakan kepadanya ini?

25
00:01:39,000 --> 00:01:43,000
Pekan lalu mengingat kami mengambil istirahat dari kode, setidaknya untuk satu hari,

26
00:01:43,000 --> 00:01:46,000
dan mulai fokus pada beberapa ide tingkat yang lebih tinggi dan pemecahan masalah yang lebih umum

27
00:01:46,000 --> 00:01:49,000
dalam konteks pencarian dan menyortir,

28
00:01:49,000 --> 00:01:53,000
dan kami memperkenalkan sesuatu yang kita tidak menampar nama ini pada pekan lalu,

29
00:01:53,000 --> 00:01:56,000
tapi asimtotik notasi, Big O, Omega Big,

30
00:01:56,000 --> 00:02:00,000
dan kadang-kadang notasi Big Theta, dan ini hanyalah cara

31
00:02:00,000 --> 00:02:02,000
menggambarkan waktu berjalan dari algoritma,

32
00:02:02,000 --> 00:02:05,000
berapa banyak waktu yang diperlukan untuk algoritma untuk menjalankan.

33
00:02:05,000 --> 00:02:08,000
>> Dan Anda mungkin ingat bahwa Anda berbicara tentang waktu berjalan dalam hal ukuran

34
00:02:08,000 --> 00:02:11,000
dari input, yang biasanya kita sebut n, apapun masalahnya mungkin,

35
00:02:11,000 --> 00:02:13,000
di mana n adalah jumlah orang di dalam ruangan,

36
00:02:13,000 --> 00:02:17,000
jumlah halaman dalam buku telepon, dan kami mulai menulis hal-hal

37
00:02:17,000 --> 00:02:21,000
seperti O (n ^ 2) atau O (n) atau O (n log n),

38
00:02:21,000 --> 00:02:24,000
dan bahkan ketika matematika tidak cukup berhasil dengan sempurna

39
00:02:24,000 --> 00:02:28,000
dan itu adalah n ² - n / 2 atau sesuatu seperti itu

40
00:02:28,000 --> 00:02:31,000
kita malah akan hanya membuang beberapa istilah orde yang lebih rendah,

41
00:02:31,000 --> 00:02:34,000
dan motivasi ada adalah bahwa kita benar-benar ingin

42
00:02:34,000 --> 00:02:37,000
macam cara obyektif mengevaluasi

43
00:02:37,000 --> 00:02:39,000
kinerja program atau kinerja algoritma

44
00:02:39,000 --> 00:02:42,000
bahwa pada akhir hari tidak ada hubungannya, misalnya,

45
00:02:42,000 --> 00:02:45,000
dengan kecepatan komputer Anda hari ini.

46
00:02:45,000 --> 00:02:47,000
>> Misalnya, jika Anda menerapkan bubble sort,

47
00:02:47,000 --> 00:02:50,000
atau Anda menerapkan menggabungkan semacam jenis atau seleksi pada komputer saat ini,

48
00:02:50,000 --> 00:02:53,000
2 GHz komputer, dan Anda menjalankannya,

49
00:02:53,000 --> 00:02:56,000
dan dibutuhkan beberapa jumlah detik, tahun depan ada 3 GHz

50
00:02:56,000 --> 00:02:59,000
atau komputer 4 GHz, dan Anda mungkin kemudian mengklaim bahwa "Wow, algoritma saya

51
00:02:59,000 --> 00:03:03,000
kini dua kali lebih cepat, "padahal itu jelas tidak terjadi.

52
00:03:03,000 --> 00:03:06,000
Ini hanya perangkat keras telah mendapat lebih cepat, tetapi komputer Anda

53
00:03:06,000 --> 00:03:10,000
belum, dan jadi kita benar-benar ingin membuang hal-hal seperti

54
00:03:10,000 --> 00:03:13,000
kelipatan 2 atau kelipatan 3 ketika datang untuk menggambarkan

55
00:03:13,000 --> 00:03:17,000
seberapa cepat atau seberapa lambat algoritma adalah dan benar-benar hanya fokus

56
00:03:17,000 --> 00:03:20,000
pada n atau beberapa faktor daripadanya,

57
00:03:20,000 --> 00:03:24,000
listrik beberapa daripadanya seperti dalam kasus macam dari minggu lalu.

58
00:03:24,000 --> 00:03:27,000
Dan ingat bahwa dengan bantuan semacam merge

59
00:03:27,000 --> 00:03:31,000
kami mampu melakukannya jauh lebih baik daripada bubble sort dan selection sort

60
00:03:31,000 --> 00:03:33,000
dan bahkan penyisipan semacam.

61
00:03:33,000 --> 00:03:36,000
>> Kami turun ke n log n, dan sekali lagi,

62
00:03:36,000 --> 00:03:39,000
ingat bahwa log n umumnya mengacu pada sesuatu yang tumbuh

63
00:03:39,000 --> 00:03:43,000
lebih lambat maka n, maka n log n sejauh itu baik

64
00:03:43,000 --> 00:03:45,000
karena itu kurang dari ² n.

65
00:03:45,000 --> 00:03:47,000
Tetapi untuk mencapai n log n dengan gabungan semacam

66
00:03:47,000 --> 00:03:51,000
apa kuman dasar ide bahwa kita harus memanfaatkan

67
00:03:51,000 --> 00:03:54,000
bahwa kita juga memanfaatkan kembali dalam seminggu 0?

68
00:03:54,000 --> 00:03:58,000
Bagaimana kita mengatasi masalah menyortir cerdik dengan gabungan semacam?

69
00:03:58,000 --> 00:04:04,000
Apa wawasan kunci, mungkin?

70
00:04:04,000 --> 00:04:07,000
Siapapun sama sekali.

71
00:04:07,000 --> 00:04:09,000
Oke, mari kita mengambil langkah mundur.

72
00:04:09,000 --> 00:04:11,000
Jelaskan menggabungkan semacam kata-kata Anda sendiri.

73
00:04:11,000 --> 00:04:15,000
Bagaimana cara kerjanya?

74
00:04:15,000 --> 00:04:17,000
Oke, kita akan mendayung kembali ke 0 minggu.

75
00:04:17,000 --> 00:04:19,000
Oke, yeah.

76
00:04:19,000 --> 00:04:22,000
[Tak terdengar-murid]

77
00:04:22,000 --> 00:04:26,000
Oke, baik, jadi kami membagi array angka menjadi 2 bagian.

78
00:04:26,000 --> 00:04:29,000
Kami diurutkan masing-masing potongan, dan kemudian kami bergabung mereka,

79
00:04:29,000 --> 00:04:33,000
dan kami telah melihat ide ini sebelum mengambil suatu masalah yang besar ini

80
00:04:33,000 --> 00:04:36,000
dan memotong itu menjadi masalah yang ini besar atau sebesar ini.

81
00:04:36,000 --> 00:04:38,000
>> Ingat contoh buku telepon.

82
00:04:38,000 --> 00:04:42,000
Ingat algoritma self-menghitung dari minggu lalu,

83
00:04:42,000 --> 00:04:45,000
semacam itu sehingga menggabungkan diringkas oleh pseudocode sini.

84
00:04:45,000 --> 00:04:48,000
Bila Anda diberi n elemen, pertama itu kewarasan cek.

85
00:04:48,000 --> 00:04:51,000
Jika n <2 maka jangan melakukan apa-apa

86
00:04:51,000 --> 00:04:55,000
karena jika n <2 maka n jelas 0 atau 1,

87
00:04:55,000 --> 00:04:57,000
dan jadi jika itu baik 0 atau 1 tidak ada yang perlu menyortir.

88
00:04:57,000 --> 00:04:59,000
Anda sudah selesai.

89
00:04:59,000 --> 00:05:01,000
Daftar Anda sudah sepele diurutkan.

90
00:05:01,000 --> 00:05:04,000
Tapi sebaliknya jika Anda punya 2 atau lebih elemen pergi ke depan dan membagi mereka

91
00:05:04,000 --> 00:05:06,000
menjadi 2 bagian, kiri dan kanan.

92
00:05:06,000 --> 00:05:09,000
Urutkan masing-masing bagian, dan kemudian menggabungkan bagian diurutkan.

93
00:05:09,000 --> 00:05:13,000
Namun masalah di sini adalah bahwa pada pandangan pertama ini terasa seperti kita punting.

94
00:05:13,000 --> 00:05:17,000
Ini adalah definisi melingkar dalam bahwa jika saya meminta Anda untuk mengurut elemen n

95
00:05:17,000 --> 00:05:22,000
dan kau bilang "Oke, baiklah, kita akan mengurutkan unsur-unsur n / 2 dan mereka n / 2,"

96
00:05:22,000 --> 00:05:27,000
maka pertanyaan berikutnya akan menjadi "Baik, bagaimana Anda menyortir n / 2 elemen?"

97
00:05:27,000 --> 00:05:30,000
>> Tetapi karena struktur program ini,

98
00:05:30,000 --> 00:05:33,000
karena ada kasus ini dasar, sehingga untuk berbicara,

99
00:05:33,000 --> 00:05:39,000
ini kasus khusus yang mengatakan jika n <beberapa nilai tetap seperti 2 kembali segera.

100
00:05:39,000 --> 00:05:42,000
Jangan menanggapi dengan jawaban melingkar yang sama.

101
00:05:42,000 --> 00:05:46,000
Proses ini, cyclicity ini akhirnya akan berakhir.

102
00:05:46,000 --> 00:05:50,000
Jika saya meminta Anda "Urutkan unsur-unsur n," dan Anda berkata, "Baik, menyortir n / 2,"

103
00:05:50,000 --> 00:05:53,000
maka Anda berkata, "Baik, semacam ini n / 4, n / 8, n/16,"

104
00:05:53,000 --> 00:05:56,000
akhirnya Anda akan membagi dengan jumlah yang cukup besar

105
00:05:56,000 --> 00:05:59,000
bahwa Anda akan memiliki hanya 1 kiri elemen, di titik mana Anda dapat mengatakan,

106
00:05:59,000 --> 00:06:02,000
"Di sini, di sini adalah elemen tunggal diurutkan."

107
00:06:02,000 --> 00:06:06,000
Kemudian kecemerlangan algoritma ini di sini adalah untuk berasal dari kenyataan

108
00:06:06,000 --> 00:06:09,000
bahwa setelah Anda memiliki semua daftar individual diurutkan,

109
00:06:09,000 --> 00:06:12,000
yang semuanya ukuran 1, yang tampaknya akan sia-sia,

110
00:06:12,000 --> 00:06:15,000
setelah Anda mulai menggabungkan mereka dan menggabungkan mereka

111
00:06:15,000 --> 00:06:19,000
Anda membangun akhirnya sebagai Rob lakukan dalam video daftar akhirnya diurutkan.

112
00:06:19,000 --> 00:06:22,000
>> Tapi ide ini jauh melebihi penyortiran.

113
00:06:22,000 --> 00:06:26,000
Ada ide ini tertanam dalam program ini dikenal sebagai rekursi,

114
00:06:26,000 --> 00:06:29,000
gagasan dimana Anda program,

115
00:06:29,000 --> 00:06:32,000
dan untuk memecahkan beberapa masalah Anda menyebut diri Anda,

116
00:06:32,000 --> 00:06:36,000
atau dimasukkan ke dalam konteks bahasa pemrograman Anda fungsi,

117
00:06:36,000 --> 00:06:39,000
dan dalam rangka memecahkan masalah, Anda fungsi menyebut diri

118
00:06:39,000 --> 00:06:42,000
lagi dan lagi dan lagi, tetapi Anda fungsi

119
00:06:42,000 --> 00:06:44,000
tidak bisa menyebut diri kali tak terhingga banyaknya.

120
00:06:44,000 --> 00:06:47,000
Akhirnya Anda harus keluar bawah, sehingga untuk berbicara,

121
00:06:47,000 --> 00:06:49,000
dan memiliki beberapa kondisi keras-kode dasar yang mengatakan

122
00:06:49,000 --> 00:06:53,000
pada titik ini berhenti menyebut diri Anda sehingga seluruh proses

123
00:06:53,000 --> 00:06:56,000
akhirnya tidak pada kenyataannya berhenti.

124
00:06:56,000 --> 00:06:58,000
Apa ini benar-benar berarti, untuk recurse?

125
00:06:58,000 --> 00:07:01,000
>> Mari kita lihat, jika kita bisa melakukan contoh sederhana, sepele dengan, katakanlah,

126
00:07:01,000 --> 00:07:03,000
3 orang dengan saya di sini di atas panggung, jika seseorang nyaman.

127
00:07:03,000 --> 00:07:06,000
1, ayolah up, 2 dan 3.

128
00:07:06,000 --> 00:07:09,000
Jika Anda ingin 3 datang ke sini.

129
00:07:09,000 --> 00:07:12,000
Jika Anda ingin berdiri tepat di samping saya di sini dalam satu garis, misalkan bahwa masalah yang dihadapi

130
00:07:12,000 --> 00:07:15,000
sangat sepele menghitung jumlah orang yang ada di sini.

131
00:07:15,000 --> 00:07:18,000
Tapi terus terang, aku lelah dari semua contoh menghitung.

132
00:07:18,000 --> 00:07:21,000
Ini akan memakan waktu, 1, 2, dan titik, titik, titik.

133
00:07:21,000 --> 00:07:23,000
Ini akan mengambil selamanya.

134
00:07:23,000 --> 00:07:25,000
Saya lebih suka hanya tendangan masalah ini sama sekali dengan bantuan-siapa namamu?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, baik-baik saja.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> Kelly dan?

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Willy, Sara, Kelly, dan Willy.

138
00:07:31,000 --> 00:07:34,000
Sekarang saya telah diminta pertanyaan oleh seseorang

139
00:07:34,000 --> 00:07:37,000
berapa banyak orang yang sampai pada tahap ini, dan saya tidak tahu.

140
00:07:37,000 --> 00:07:40,000
Ini adalah daftar sangat panjang, dan jadi bukannya aku akan melakukan trik ini.

141
00:07:40,000 --> 00:07:43,000
Aku akan meminta orang di sebelah saya untuk melakukan sebagian besar pekerjaan,

142
00:07:43,000 --> 00:07:46,000
dan sekali dia selesai melakukan sebagian besar pekerjaan

143
00:07:46,000 --> 00:07:49,000
Aku akan melakukan sedikitnya jumlah pekerjaan mungkin dan hanya menambahkan 1

144
00:07:49,000 --> 00:07:51,000
apa pun jawabannya adalah, jadi di sini kita pergi.

145
00:07:51,000 --> 00:07:54,000
Saya telah bertanya berapa banyak orang berada di atas panggung.

146
00:07:54,000 --> 00:07:57,000
Berapa banyak orang di atas panggung di sebelah kiri Anda?

147
00:07:57,000 --> 00:08:00,000
Sebelah kiri saya >> Oke?, Tapi jangan menipu.

148
00:08:00,000 --> 00:08:04,000
Itu bagus, itu benar, tetapi jika kita ingin melanjutkan logika ini

149
00:08:04,000 --> 00:08:08,000
mari kita asumsikan bahwa Anda sama ingin menyepak bola masalah ini di sebelah kiri Anda,

150
00:08:08,000 --> 00:08:11,000
jadi daripada jawaban langsung pergi ke depan dan hanya lulus uang.

151
00:08:11,000 --> 00:08:14,000
Oh, berapa banyak orang yang di sebelah kiri saya?

152
00:08:14,000 --> 00:08:16,000
Berapa banyak orang yang ke kiri?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Tertawa]

155
00:08:27,000 --> 00:08:30,000
Oke, jadi 0, jadi apa sekarang Willy telah dilakukan

156
00:08:30,000 --> 00:08:33,000
adalah Anda telah kembali jawaban Anda ini arah mengatakan 0.

157
00:08:33,000 --> 00:08:36,000
Sekarang, apa yang harus Anda lakukan? >> 1.

158
00:08:36,000 --> 00:08:39,000
Oke, jadi kau 1, sehingga Anda mengatakan, "Baiklah, aku akan menambahkan 1

159
00:08:39,000 --> 00:08:41,000
untuk apa pun jumlah Willy adalah, "sehingga 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Anda sekarang 1 sehingga jawaban Anda ke kanan sekarang-

161
00:08:43,000 --> 00:08:45,000
1. >> Dan saya akan menjadi 2.

162
00:08:45,000 --> 00:08:48,000
Baik, jadi Anda mengambil jawaban sebelumnya 1,

163
00:08:48,000 --> 00:08:51,000
menambahkan jumlah minimal pekerjaan yang ingin Anda lakukan, yaitu +1.

164
00:08:51,000 --> 00:08:55,000
Anda sekarang memiliki 2, dan Anda kemudian tangan saya yang nilai?

165
00:08:55,000 --> 00:08:57,000
3, maksudku, maaf, 2.

166
00:08:57,000 --> 00:08:59,000
Baik.

167
00:08:59,000 --> 00:09:02,000
>> Nah, kami memiliki 0 ke kiri.

168
00:09:02,000 --> 00:09:05,000
Kemudian kami memiliki 1, dan kemudian kita tambahkan 2,

169
00:09:05,000 --> 00:09:07,000
dan sekarang kau menyodorkan nomor 2,

170
00:09:07,000 --> 00:09:10,000
dan jadi aku katakan, oke, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Ada memang 3 orang berdiri di samping saya di tahap ini,

172
00:09:13,000 --> 00:09:16,000
sehingga kita bisa melakukan ini jelas sangat linear,

173
00:09:16,000 --> 00:09:19,000
sangat banyak dengan cara yang jelas, tapi apa yang kita benar-benar lakukan?

174
00:09:19,000 --> 00:09:21,000
Kami mengambil masalah ukuran 3 awalnya.

175
00:09:21,000 --> 00:09:24,000
Kami kemudian pecah itu ke dalam masalah ukuran 2,

176
00:09:24,000 --> 00:09:27,000
maka masalah ukuran 1, dan akhirnya kasus dasar

177
00:09:27,000 --> 00:09:29,000
benar-benar, oh, tidak ada seorang pun di sana,

178
00:09:29,000 --> 00:09:33,000
di mana titik Willy kembali efektif jawaban keras-kode beberapa kali,

179
00:09:33,000 --> 00:09:36,000
dan yang kedua kemudian menggelegak, menggelegak, menggelegak,

180
00:09:36,000 --> 00:09:39,000
dan kemudian dengan menambahkan dalam 1 satu tambahan

181
00:09:39,000 --> 00:09:41,000
kami telah menerapkan ide dasar dari rekursi.

182
00:09:41,000 --> 00:09:44,000
>> Sekarang, dalam hal ini tidak benar-benar memecahkan masalah

183
00:09:44,000 --> 00:09:46,000
lagi efektif maka kita telah melihat sejauh ini.

184
00:09:46,000 --> 00:09:48,000
Tapi pikirkan tentang algoritma yang kami lakukan di atas panggung sejauh ini.

185
00:09:48,000 --> 00:09:51,000
Kami memiliki 8 potongan kertas di papan tulis,

186
00:09:51,000 --> 00:09:55,000
video saat Sean sedang mencari nomor 7, dan apa yang dia benar-benar?

187
00:09:55,000 --> 00:09:58,000
Yah, dia tidak melakukan apapun membagi dan menaklukkan.

188
00:09:58,000 --> 00:10:01,000
Dia tidak melakukan apapun rekursi.

189
00:10:01,000 --> 00:10:03,000
Sebaliknya dia hanya melakukan ini algoritma linier.

190
00:10:03,000 --> 00:10:07,000
Tetapi ketika kita memperkenalkan ide nomor diurutkan di atas panggung hidup minggu lalu

191
00:10:07,000 --> 00:10:09,000
maka kita punya naluri untuk pergi ke tengah,

192
00:10:09,000 --> 00:10:13,000
di mana titik kami memiliki daftar yang lebih kecil dari ukuran 4 atau daftar lain ukuran 4,

193
00:10:13,000 --> 00:10:17,000
dan kemudian kami memiliki masalah yang sama, jadi kami mengulangi, diulang, diulang.

194
00:10:17,000 --> 00:10:19,000
Dengan kata lain, kita recursed.

195
00:10:19,000 --> 00:10:24,000
Terima kasih banyak untuk 3 relawan kami di sini untuk menunjukkan rekursi dengan kami.

196
00:10:24,000 --> 00:10:28,000
>> Mari kita lihat apakah kita tidak bisa membuat ini sekarang beton sedikit lebih,

197
00:10:28,000 --> 00:10:30,000
memecahkan masalah yang lagi kita bisa lakukan cukup mudah,

198
00:10:30,000 --> 00:10:34,000
tapi kami akan menggunakannya sebagai batu loncatan untuk menerapkan ide dasar.

199
00:10:34,000 --> 00:10:37,000
Jika saya ingin menghitung penjumlahan dari sekelompok angka,

200
00:10:37,000 --> 00:10:39,000
Misalnya, jika Anda lulus dalam nomor 3,

201
00:10:39,000 --> 00:10:42,000
Saya ingin memberikan nilai sigma 3,

202
00:10:42,000 --> 00:10:46,000
jadi jumlah 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Saya ingin mendapatkan kembali jawaban 6,

204
00:10:48,000 --> 00:10:51,000
jadi kita akan menerapkan fungsi sigma, fungsi penjumlahan

205
00:10:51,000 --> 00:10:54,000
itu, sekali lagi, mengambil input, dan kemudian kembali penjumlahan

206
00:10:54,000 --> 00:10:57,000
dari jumlah tersebut semua jalan ke 0.

207
00:10:57,000 --> 00:10:59,000
Kita bisa melakukan ini cukup sederhana, kan?

208
00:10:59,000 --> 00:11:01,000
Kita bisa melakukan ini dengan beberapa jenis struktur perulangan,

209
00:11:01,000 --> 00:11:04,000
jadi biarkan aku pergi ke depan dan mendapatkan ini dimulai.

210
00:11:04,000 --> 00:11:07,000
>> Sertakan stdio.h.

211
00:11:07,000 --> 00:11:09,000
Biarkan saya mendapatkan diri ke utama untuk bekerja dengan di sini.

212
00:11:09,000 --> 00:11:12,000
Mari kita simpan ini sebagai sigma.c.

213
00:11:12,000 --> 00:11:14,000
Lalu aku akan pergi di sini, dan aku akan mendeklarasikan int n,

214
00:11:14,000 --> 00:11:18,000
dan aku akan melakukan hal berikut saat pengguna tidak bekerja sama.

215
00:11:18,000 --> 00:11:22,000
Sementara pengguna tidak memberi saya angka positif

216
00:11:22,000 --> 00:11:26,000
biarkan aku pergi ke depan dan meminta mereka untuk GetInt = n,

217
00:11:26,000 --> 00:11:28,000
dan biarkan aku memberi mereka beberapa petunjuk untuk apa yang harus dilakukan,

218
00:11:28,000 --> 00:11:33,000
sehingga printf ("bilangan bulat positif silahkan").

219
00:11:33,000 --> 00:11:39,000
Sama relatif sederhana seperti ini sesuatu sehingga pada saat kita memukul baris 14

220
00:11:39,000 --> 00:11:42,000
kita sekarang memiliki bilangan bulat positif mungkin dalam n.

221
00:11:42,000 --> 00:11:44,000
>> Sekarang mari kita melakukan sesuatu dengan itu.

222
00:11:44,000 --> 00:11:50,000
Biarkan aku pergi ke depan dan menghitung penjumlahan, sehingga int sum = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma hanya penjumlahan, jadi aku hanya menulis dengan cara yang lebih menarik.

224
00:11:54,000 --> 00:11:56,000
Kami hanya akan menyebutnya sigma ada.

225
00:11:56,000 --> 00:11:58,000
Itulah jumlah itu, dan sekarang aku akan mencetak hasilnya,

226
00:11:58,000 --> 00:12:08,000
printf ("Jumlahnya adalah% d, \ n", sum).

227
00:12:08,000 --> 00:12:11,000
Dan kemudian aku akan kembali 0 untuk mengukur baik.

228
00:12:11,000 --> 00:12:15,000
Kami telah melakukan segala sesuatu yang program ini membutuhkan kecuali bagian yang menarik,

229
00:12:15,000 --> 00:12:18,000
yang sebenarnya adalah untuk mengimplementasikan fungsi sigma.

230
00:12:18,000 --> 00:12:22,000
>> Biarkan aku pergi ke sini ke bawah, dan biarkan aku mendeklarasikan fungsi sigma.

231
00:12:22,000 --> 00:12:26,000
Ini harus mengambil variabel yang bertipe integer,

232
00:12:26,000 --> 00:12:30,000
dan apa tipe data yang saya ingin kembali mungkin dari sigma?

233
00:12:30,000 --> 00:12:34,000
Int, karena saya ingin mencocokkan harapan saya on line 15.

234
00:12:34,000 --> 00:12:37,000
Di sini biarkan aku pergi ke depan dan menerapkan ini

235
00:12:37,000 --> 00:12:41,000
dengan cara yang cukup sederhana.

236
00:12:41,000 --> 00:12:45,000
>> Mari kita pergi ke depan dan mengatakan jumlah int = 0,

237
00:12:45,000 --> 00:12:47,000
dan sekarang aku akan pergi memiliki sedikit untuk loop di sini

238
00:12:47,000 --> 00:12:50,000
itu akan mengatakan sesuatu seperti ini,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0; I <= nomor; i + +) jumlah + = i.

240
00:13:01,000 --> 00:13:05,000
Dan kemudian aku akan kembali sum.

241
00:13:05,000 --> 00:13:07,000
Saya bisa menerapkan ini dalam berbagai cara.

242
00:13:07,000 --> 00:13:09,000
Saya bisa menggunakan loop sementara.

243
00:13:09,000 --> 00:13:11,000
Saya bisa dilewati dengan menggunakan variabel jumlah jika saya benar-benar ingin,

244
00:13:11,000 --> 00:13:15,000
tetapi dalam waktu singkat, kita hanya memiliki fungsi bahwa jika saya tidak menyia-nyiakan menyatakan jumlah adalah 0.

245
00:13:15,000 --> 00:13:18,000
Kemudian iterates dari 0 ke atas melalui nomor,

246
00:13:18,000 --> 00:13:23,000
dan pada setiap iterasi ia menambahkan bahwa nilai saat ini untuk jumlah dan kemudian kembali sum.

247
00:13:23,000 --> 00:13:25,000
>> Sekarang, ada optimasi sedikit di sini.

248
00:13:25,000 --> 00:13:29,000
Ini mungkin langkah sia-sia, tapi begitu baik. Itu baik untuk saat ini.

249
00:13:29,000 --> 00:13:32,000
Kami setidaknya menjadi menyeluruh dan akan 0 semua jalan ke atas.

250
00:13:32,000 --> 00:13:34,000
Tidak terlalu keras dan cukup sederhana,

251
00:13:34,000 --> 00:13:37,000
tapi ternyata bahwa dengan fungsi sigma kita memiliki kesempatan yang sama

252
00:13:37,000 --> 00:13:39,000
seperti yang kita lakukan di sini di atas panggung.

253
00:13:39,000 --> 00:13:42,000
Di atas panggung kita hanya menghitung berapa banyak orang yang di samping saya,

254
00:13:42,000 --> 00:13:47,000
tetapi jika kita ingin menghitung jumlah 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
pada turun ke 0 kita bisa sama menyepak bola ke fungsi

256
00:13:51,000 --> 00:13:55,000
bahwa saya bukan akan menjelaskan sebagai rekursif.

257
00:13:55,000 --> 00:13:57,000
Berikut mari kita lakukan sebuah kewarasan cepat memeriksa dan memastikan aku tidak menyia-nyiakan.

258
00:13:57,000 --> 00:14:00,000
>> Saya tahu ada setidaknya satu hal dalam program ini yang aku lakukan salah.

259
00:14:00,000 --> 00:14:04,000
Ketika saya tekan enter aku akan mendapatkan jenis berteriak padaku?

260
00:14:04,000 --> 00:14:06,000
Apa yang saya akan berteriak tentang?

261
00:14:06,000 --> 00:14:11,000
Ya, saya lupa prototipe, jadi aku menggunakan fungsi yang disebut sigma on line 15,

262
00:14:11,000 --> 00:14:16,000
tapi itu tidak dideklarasikan sampai garis 22, jadi aku paling proaktif pergi di sini

263
00:14:16,000 --> 00:14:22,000
dan menyatakan prototipe, dan saya akan mengatakan int sigma (int number), dan hanya itu.

264
00:14:22,000 --> 00:14:24,000
Ini diterapkan di bagian bawah.

265
00:14:24,000 --> 00:14:27,000
>> Atau cara lain saya bisa memecahkan masalah ini,

266
00:14:27,000 --> 00:14:30,000
Saya bisa memindahkan fungsi di atas sana, yang tidak buruk,

267
00:14:30,000 --> 00:14:32,000
tapi setidaknya ketika program Anda mulai mendapatkan panjang, terus terang,

268
00:14:32,000 --> 00:14:35,000
Saya pikir ada beberapa nilai dalam selalu memiliki utama di bagian atas

269
00:14:35,000 --> 00:14:38,000
sehingga Anda pembaca dapat membuka file tersebut dan kemudian segera melihat

270
00:14:38,000 --> 00:14:40,000
program apa yang dilakukan tanpa harus mencari melalui itu

271
00:14:40,000 --> 00:14:42,000
mencari fungsi utama.

272
00:14:42,000 --> 00:14:49,000
Mari kita pergi ke jendela terminal saya di sini, cobalah membuat sigma membuat sigma,

273
00:14:49,000 --> 00:14:51,000
dan saya kacau di sini juga.

274
00:14:51,000 --> 00:14:55,000
Deklarasi implisit dari fungsi GetInt berarti saya sudah lupa untuk melakukan apa lagi?

275
00:14:55,000 --> 00:14:57,000
[Tak terdengar-murid]

276
00:14:57,000 --> 00:15:00,000
Baik, begitu rupanya kesalahan umum, jadi mari kita memasang ini di sini,

277
00:15:00,000 --> 00:15:04,000
cs50.h, dan sekarang mari kita kembali ke jendela terminal saya.

278
00:15:04,000 --> 00:15:08,000
>> Aku akan membersihkan layar, dan aku akan jalankan kembali membuat sigma.

279
00:15:08,000 --> 00:15:11,000
Ini tampaknya telah disusun. Sekarang saya jalankan sigma.

280
00:15:11,000 --> 00:15:15,000
Saya akan mengetikkan nomor 3, dan aku mendapatkan 6, sehingga tidak cek ketat,

281
00:15:15,000 --> 00:15:18,000
tapi setidaknya itu tampaknya akan bekerja pada pandangan pertama, tapi sekarang mari kita robek itu terpisah,

282
00:15:18,000 --> 00:15:21,000
dan mari kita benar-benar memanfaatkan gagasan rekursi, sekali lagi,

283
00:15:21,000 --> 00:15:24,000
dalam konteks yang sangat sederhana sehingga dalam waktu beberapa minggu '

284
00:15:24,000 --> 00:15:27,000
ketika kita mulai mengeksplorasi struktur data lebih menarik daripada array

285
00:15:27,000 --> 00:15:30,000
kita memiliki alat lain dalam toolkit yang dapat digunakan untuk

286
00:15:30,000 --> 00:15:33,000
memanipulasi struktur data tersebut seperti yang akan kita lihat.

287
00:15:33,000 --> 00:15:36,000
Ini adalah pendekatan iteratif, pendekatan loop berbasis.

288
00:15:36,000 --> 00:15:39,000
>> Biarkan aku bukan sekarang melakukan hal ini.

289
00:15:39,000 --> 00:15:44,000
Biarkan saya bukan mengatakan bahwa penjumlahan nomor

290
00:15:44,000 --> 00:15:48,000
pada turun ke 0 adalah benar-benar hal yang sama seperti

291
00:15:48,000 --> 00:15:53,000
nomor + sigma (nomor - 1).

292
00:15:53,000 --> 00:15:57,000
Dengan kata lain, sama seperti di atas panggung saya punted untuk masing-masing orang di sebelah saya,

293
00:15:57,000 --> 00:16:00,000
dan mereka pada gilirannya terus punting sampai kami akhirnya dipercaya keluar di Willy,

294
00:16:00,000 --> 00:16:03,000
yang harus kembali jawaban yang keras-kode seperti 0.

295
00:16:03,000 --> 00:16:07,000
Disini sekarang kita sama punting ke sigma

296
00:16:07,000 --> 00:16:10,000
fungsi yang sama seperti yang awalnya disebut, tetapi wawasan kunci di sini

297
00:16:10,000 --> 00:16:12,000
adalah bahwa kita tidak menelepon sigma identik.

298
00:16:12,000 --> 00:16:14,000
Kami tidak lewat di n.

299
00:16:14,000 --> 00:16:17,000
Kami jelas lewat di nomor - 1,

300
00:16:17,000 --> 00:16:20,000
sehingga masalah yang sedikit lebih kecil, masalah yang sedikit lebih kecil.

301
00:16:20,000 --> 00:16:23,000
>> Sayangnya, hal ini tidak cukup solusi belum, dan sebelum kita memperbaiki

302
00:16:23,000 --> 00:16:26,000
apa yang mungkin melompat keluar sebagai jelas pada beberapa dari Anda

303
00:16:26,000 --> 00:16:28,000
biarkan aku pergi ke depan dan menjalankan kembali membuat.

304
00:16:28,000 --> 00:16:30,000
Tampaknya untuk mengkompilasi baik-baik saja.

305
00:16:30,000 --> 00:16:32,000
Mari saya memutarkan sigma dengan 6.

306
00:16:32,000 --> 00:16:37,000
Whoops, biarkan aku memutarkan sigma dengan 6.

307
00:16:37,000 --> 00:16:42,000
Kita telah melihat ini sebelumnya, meskipun waktu sengaja terakhir juga.

308
00:16:42,000 --> 00:16:48,000
Mengapa saya mendapatkan kesalahan segmentasi samar? Ya.

309
00:16:48,000 --> 00:16:50,000
[Tak terdengar-murid]

310
00:16:50,000 --> 00:16:53,000
Tidak ada base case, dan lebih khusus lagi, apa yang mungkin terjadi?

311
00:16:53,000 --> 00:16:58,000
Ini adalah gejala dari apa perilaku?

312
00:16:58,000 --> 00:17:00,000
Katakanlah sedikit lebih keras.

313
00:17:00,000 --> 00:17:02,000
[Tak terdengar-murid]

314
00:17:02,000 --> 00:17:05,000
Ini loop tak terbatas secara efektif, dan masalah dengan loop tak terbatas

315
00:17:05,000 --> 00:17:08,000
ketika mereka melibatkan rekursi dalam kasus ini, fungsi menamakan dirinya,

316
00:17:08,000 --> 00:17:10,000
apa yang terjadi setiap kali Anda memanggil fungsi?

317
00:17:10,000 --> 00:17:13,000
Nah, pikirkan kembali bagaimana kita meletakkan keluar memori di komputer.

318
00:17:13,000 --> 00:17:16,000
Kami mengatakan bahwa ada ini sepotong memori yang disebut tumpukan yang di bagian bawah,

319
00:17:16,000 --> 00:17:19,000
dan setiap kali Anda memanggil fungsi memori sedikit lebih akan dimasukkan

320
00:17:19,000 --> 00:17:24,000
pada tumpukan disebut mengandung variabel lokal bahwa fungsi atau parameter,

321
00:17:24,000 --> 00:17:27,000
jadi jika sigma panggilan panggilan sigma sigma panggilan sigma

322
00:17:27,000 --> 00:17:29,000
 panggilan sigma mana hal ini akhir ceritanya?

323
00:17:29,000 --> 00:17:31,000
>> Nah, akhirnya overruns jumlah total

324
00:17:31,000 --> 00:17:33,000
memori yang telah tersedia ke komputer Anda.

325
00:17:33,000 --> 00:17:37,000
Anda dibanjiri segmen yang Anda seharusnya tinggal di dalam,

326
00:17:37,000 --> 00:17:40,000
dan Anda mendapatkan kesalahan segmentasi, inti dibuang,

327
00:17:40,000 --> 00:17:43,000
dan apa inti dibuang berarti bahwa saya sekarang memiliki sebuah file yang bernama inti

328
00:17:43,000 --> 00:17:46,000
yang merupakan file yang berisi nol dan satu

329
00:17:46,000 --> 00:17:49,000
bahwa sebenarnya di masa depan akan diagnosa berguna.

330
00:17:49,000 --> 00:17:52,000
Jika tidak jelas bagi Anda di mana Anda adalah bug

331
00:17:52,000 --> 00:17:54,000
Anda benar-benar dapat melakukan sedikit analisis forensik, sehingga untuk berbicara,

332
00:17:54,000 --> 00:17:58,000
pada file dump inti, yang, sekali lagi, hanya sejumlah besar nol dan satu

333
00:17:58,000 --> 00:18:02,000
yang pada dasarnya merupakan keadaan program Anda dalam memori

334
00:18:02,000 --> 00:18:05,000
saat itu jatuh dengan cara ini.

335
00:18:05,000 --> 00:18:11,000
>> Cara mengatasinya di sini adalah bahwa kita tidak bisa hanya membabi buta kembali sigma,

336
00:18:11,000 --> 00:18:14,000
jumlah + sigma dari masalah yang sedikit lebih kecil.

337
00:18:14,000 --> 00:18:16,000
Kita perlu memiliki semacam kasus dasar di sini,

338
00:18:16,000 --> 00:18:19,000
dan apa yang harus kasus dasar mungkin akan?

339
00:18:19,000 --> 00:18:22,000
[Tak terdengar-murid]

340
00:18:22,000 --> 00:18:25,000
Oke, asalkan jumlah tersebut secara positif kita benar-benar harus kembali ini,

341
00:18:25,000 --> 00:18:29,000
atau dengan kata lain, jika nomor adalah, katakanlah, <= 0 untuk

342
00:18:29,000 --> 00:18:32,000
Anda tahu apa, saya akan pergi ke depan dan kembali 0,

343
00:18:32,000 --> 00:18:36,000
seperti Willy lakukan, dan yang lain, aku akan pergi ke depan

344
00:18:36,000 --> 00:18:41,000
dan kembali ini, sehingga tidak yang jauh lebih pendek

345
00:18:41,000 --> 00:18:44,000
dari versi iteratif bahwa kita melecut pertama menggunakan untuk loop,

346
00:18:44,000 --> 00:18:48,000
tetapi perhatikan bahwa ada semacam ini keanggunan untuk itu.

347
00:18:48,000 --> 00:18:51,000
Alih-alih kembali beberapa nomor dan melakukan semua matematika ini

348
00:18:51,000 --> 00:18:54,000
dan menambahkan hal-hal dengan variabel lokal

349
00:18:54,000 --> 00:18:57,000
Anda malah berkata "Oke, jika ini adalah masalah super mudah,

350
00:18:57,000 --> 00:19:01,000
seperti nomor adalah <0, biarkan aku segera kembali 0. "

351
00:19:01,000 --> 00:19:03,000
>> Kita tidak akan repot-repot angka negatif pendukung,

352
00:19:03,000 --> 00:19:05,000
jadi aku pergi ke kode keras nilai 0.

353
00:19:05,000 --> 00:19:08,000
Tapi sebaliknya, untuk melaksanakan gagasan ini menjumlahkan

354
00:19:08,000 --> 00:19:11,000
semua angka bersama Anda secara efektif dapat mengambil gigitan kecil

355
00:19:11,000 --> 00:19:14,000
keluar dari masalah, seperti yang kita lakukan di sini di atas panggung,

356
00:19:14,000 --> 00:19:18,000
maka punt sisa masalah kepada orang berikutnya,

357
00:19:18,000 --> 00:19:20,000
tetapi dalam hal ini orang berikutnya adalah diri Anda sendiri.

358
00:19:20,000 --> 00:19:22,000
Ini adalah fungsi bernama identik.

359
00:19:22,000 --> 00:19:25,000
Hanya lulus masalah kecil dan lebih kecil dan lebih kecil setiap kali,

360
00:19:25,000 --> 00:19:28,000
dan meskipun kami belum diformalkan dalam hal cukup kode di sini

361
00:19:28,000 --> 00:19:33,000
ini adalah apa yang terjadi di minggu 0 dengan buku telepon.

362
00:19:33,000 --> 00:19:36,000
Ini adalah persis apa yang terjadi dalam beberapa pekan terakhir dengan Sean

363
00:19:36,000 --> 00:19:39,000
dan dengan demonstrasi kami mencari angka.

364
00:19:39,000 --> 00:19:42,000
Ini mengambil masalah dan membaginya lagi dan lagi.

365
00:19:42,000 --> 00:19:44,000
>> Dengan kata lain, ada cara sekarang menerjemahkan

366
00:19:44,000 --> 00:19:47,000
ini membangun dunia nyata, ini membangun tingkat yang lebih tinggi

367
00:19:47,000 --> 00:19:51,000
dari membagi dan menaklukkan dan melakukan sesuatu lagi dan lagi

368
00:19:51,000 --> 00:19:56,000
dalam kode, jadi ini adalah sesuatu yang kita akan melihat lagi dari waktu ke waktu.

369
00:19:56,000 --> 00:20:00,000
Sekarang, sebagai samping, jika Anda baru untuk rekursi Anda harus setidaknya mengerti sekarang

370
00:20:00,000 --> 00:20:02,000
mengapa hal ini lucu.

371
00:20:02,000 --> 00:20:05,000
Aku akan pergi ke google.com,

372
00:20:05,000 --> 00:20:17,000
dan aku akan mencari beberapa tips dan trik rekursi, masukkan.

373
00:20:17,000 --> 00:20:21,000
Beritahu orang di sebelah Anda jika mereka tidak tertawa sekarang.

374
00:20:21,000 --> 00:20:23,000
Apakah maksud Anda rekursi?

375
00:20:23,000 --> 00:20:25,000
Apakah maksud Anda-ah, di sana kita pergi.

376
00:20:25,000 --> 00:20:28,000
Oke, sekarang itu sisa orang.

377
00:20:28,000 --> 00:20:30,000
Sebuah telur Paskah kecil tertanam di suatu tempat ada di Google.

378
00:20:30,000 --> 00:20:33,000
Sebagai samping, salah satu link yang kita pasang di web kursus ini

379
00:20:33,000 --> 00:20:36,000
untuk hari ini hanya ini grid algoritma pemilahan berbagai,

380
00:20:36,000 --> 00:20:39,000
beberapa di antaranya kita melihat pekan lalu, tapi apa yang baik tentang visualisasi ini

381
00:20:39,000 --> 00:20:43,000
ketika Anda mencoba untuk membungkus pikiran Anda sekitar berbagai hal yang berkaitan dengan algoritma

382
00:20:43,000 --> 00:20:46,000
tahu bahwa Anda dapat dengan mudah sekarang mulai dengan berbagai jenis input.

383
00:20:46,000 --> 00:20:50,000
Masukan semua terbalik, masukan sebagian besar diurutkan, input acak dan sebagainya.

384
00:20:50,000 --> 00:20:53,000
Ketika Anda mencoba untuk, sekali lagi, membedakan hal-hal ini dalam pikiran Anda

385
00:20:53,000 --> 00:20:57,000
menyadari bahwa URL ini di website kursus pada halaman Kuliah

386
00:20:57,000 --> 00:21:00,000
dapat membantu Anda melalui beberapa alasan dari mereka.

387
00:21:00,000 --> 00:21:05,000
>> Hari ini kita akhirnya bisa memecahkan masalah ini dari beberapa waktu lalu,

388
00:21:05,000 --> 00:21:08,000
yang adalah bahwa fungsi swap ini hanya tidak bekerja,

389
00:21:08,000 --> 00:21:12,000
dan apa masalah mendasar dengan pertukaran fungsi,

390
00:21:12,000 --> 00:21:15,000
tujuan yang, sekali lagi, untuk bertukar nilai di sini dan di sini

391
00:21:15,000 --> 00:21:17,000
sehingga hal ini terjadi?

392
00:21:17,000 --> 00:21:20,000
Hal ini tidak benar-benar bekerja. Kenapa?

393
00:21:20,000 --> 00:21:22,000
Ya.

394
00:21:22,000 --> 00:21:28,000
[Tak terdengar-murid]

395
00:21:28,000 --> 00:21:31,000
Tepat, penjelasan untuk bugginess ini

396
00:21:31,000 --> 00:21:34,000
hanya karena ketika Anda menelepon fungsi dalam C

397
00:21:34,000 --> 00:21:38,000
dan fungsi-fungsi mengambil argumen, seperti a dan b di sini,

398
00:21:38,000 --> 00:21:42,000
Anda lewat di salinan nilai apa pun yang Anda berikan untuk fungsi itu.

399
00:21:42,000 --> 00:21:46,000
Anda tidak memberikan nilai-nilai asli sendiri,

400
00:21:46,000 --> 00:21:49,000
jadi kami melihat ini dalam konteks buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, yang tampak sedikit sesuatu seperti ini.

402
00:21:52,000 --> 00:21:57,000
>> Ingatlah bahwa kita memiliki x dan y diinisialisasi ke 1 dan 2, masing-masing.

403
00:21:57,000 --> 00:21:59,000
Kami kemudian dicetak apa yang mereka.

404
00:21:59,000 --> 00:22:03,000
Saya kemudian mengklaim bahwa saya menukar mereka dengan memanggil swap x, y.

405
00:22:03,000 --> 00:22:06,000
Tapi masalahnya adalah bahwa swapping bekerja,

406
00:22:06,000 --> 00:22:10,000
tetapi hanya dalam lingkup swap berfungsi sendiri.

407
00:22:10,000 --> 00:22:13,000
Segera setelah kita memukul garis 40 nilai-nilai bertukar

408
00:22:13,000 --> 00:22:16,000
yang dibuang, sehingga tidak ada

409
00:22:16,000 --> 00:22:21,000
dalam fungsi utama asli sebenarnya berubah sama sekali,

410
00:22:21,000 --> 00:22:26,000
jadi jika Anda berpikir waktu itu seperti apa ini terlihat seperti dalam hal memori kami

411
00:22:26,000 --> 00:22:29,000
jika sisi kiri papan mewakili-

412
00:22:29,000 --> 00:22:33,000
dan saya akan melakukan yang terbaik untuk semua orang untuk melihat ini-jika sisi kiri dari papan

413
00:22:33,000 --> 00:22:37,000
mewakili, katakanlah, RAM Anda, dan stack akan tumbuh di atas cara ini,

414
00:22:37,000 --> 00:22:43,000
dan kami memanggil fungsi seperti main, dan utama memiliki 2 variabel lokal, x dan y,

415
00:22:43,000 --> 00:22:48,000
mari kita menggambarkan mereka sebagai x di sini, dan mari kita menjelaskan ini sebagai y di sini,

416
00:22:48,000 --> 00:22:55,000
dan mari kita dimasukkan ke dalam nilai-nilai 1 dan 2, jadi ini di sini adalah utama,

417
00:22:55,000 --> 00:22:58,000
dan ketika utama memanggil fungsi swap sistem operasi

418
00:22:58,000 --> 00:23:02,000
memberikan fungsi swap petak sendiri memori di stack,

419
00:23:02,000 --> 00:23:04,000
bingkai sendiri di stack, sehingga untuk berbicara.

420
00:23:04,000 --> 00:23:08,000
Hal ini juga mengalokasikan 32 bit untuk ints tersebut.

421
00:23:08,000 --> 00:23:11,000
Hal ini terjadi untuk memanggil mereka dan b, tapi itu benar-benar sewenang-wenang.

422
00:23:11,000 --> 00:23:13,000
Ini bisa menyebut mereka apapun yang diinginkan, tapi apa yang terjadi ketika main

423
00:23:13,000 --> 00:23:19,000
panggilan swap dibutuhkan ini 1, menempatkan salinan sana, menempatkan salinan sana.

424
00:23:19,000 --> 00:23:23,000
>> Ada 1 variabel lokal lainnya di swap, meskipun, disebut apa? Tmp >>.

425
00:23:23,000 --> 00:23:27,000
Tmp, jadi biarkan aku memberi diriku lagi 32 bit di sini,

426
00:23:27,000 --> 00:23:29,000
dan apa yang saya lakukan dalam fungsi ini?

427
00:23:29,000 --> 00:23:34,000
Aku berkata tmp int mendapat, sehingga memiliki 1, jadi saya melakukan ini ketika kami terakhir bermain dengan contoh ini.

428
00:23:34,000 --> 00:23:39,000
Kemudian mendapat b, sehingga b adalah 2, jadi sekarang ini menjadi 2,

429
00:23:39,000 --> 00:23:42,000
dan sekarang b mendapat suhu, sehingga suhu adalah 1,

430
00:23:42,000 --> 00:23:44,000
jadi sekarang ini menjadi b.

431
00:23:44,000 --> 00:23:46,000
Itu bagus. Ini bekerja.

432
00:23:46,000 --> 00:23:49,000
Tapi kemudian segera setelah kembali fungsi

433
00:23:49,000 --> 00:23:52,000
memori swap secara efektif menghilang sehingga dapat digunakan kembali

434
00:23:52,000 --> 00:23:58,000
oleh beberapa fungsi lain di masa depan, dan utama adalah jelas benar-benar berubah.

435
00:23:58,000 --> 00:24:00,000
Kita perlu cara fundamental memecahkan masalah ini,

436
00:24:00,000 --> 00:24:03,000
dan hari ini kita akhirnya akan memiliki cara untuk melakukan hal ini dimana

437
00:24:03,000 --> 00:24:06,000
kita dapat memperkenalkan sesuatu yang disebut pointer.

438
00:24:06,000 --> 00:24:09,000
Ternyata bahwa kita bisa memecahkan masalah ini

439
00:24:09,000 --> 00:24:12,000
bukan dengan lewat di salinan x dan y

440
00:24:12,000 --> 00:24:18,000
melainkan dengan melewati dalam apa, apakah Anda berpikir, fungsi swap?

441
00:24:18,000 --> 00:24:20,000
Ya, bagaimana dengan alamat?

442
00:24:20,000 --> 00:24:22,000
Kami belum benar-benar berbicara tentang alamat di banyak detail,

443
00:24:22,000 --> 00:24:25,000
tetapi jika papan ini merupakan memori komputer saya

444
00:24:25,000 --> 00:24:28,000
kita pasti bisa memulai penomoran byte dalam RAM saya

445
00:24:28,000 --> 00:24:31,000
dan mengatakan ini adalah byte # 1, ini adalah byte # 2, # 3 byte,

446
00:24:31,000 --> 00:24:35,000
byte # 4, # byte ... 2 miliar jika saya memiliki 2 gigabyte RAM,

447
00:24:35,000 --> 00:24:38,000
jadi kita pasti bisa datang dengan beberapa skema penomoran sewenang-wenang

448
00:24:38,000 --> 00:24:41,000
untuk semua byte individu dalam memori komputer saya.

449
00:24:41,000 --> 00:24:43,000
>> Bagaimana jika sebaliknya ketika saya sebut pertukaran

450
00:24:43,000 --> 00:24:47,000
daripada lulus dalam salinan x dan y

451
00:24:47,000 --> 00:24:51,000
kenapa tidak saya malah lulus dalam alamat dari x di sini,

452
00:24:51,000 --> 00:24:55,000
alamat y di sini, pada dasarnya alamat pos

453
00:24:55,000 --> 00:24:59,000
x dan y karena kemudian swap, jika dia memberitahu

454
00:24:59,000 --> 00:25:01,000
dari alamat dalam memori dari x dan y,

455
00:25:01,000 --> 00:25:04,000
kemudian swap, jika kita melatihnya sedikit,

456
00:25:04,000 --> 00:25:07,000
ia berpotensi bisa mengarahkan ke alamat tersebut, sehingga untuk berbicara,

457
00:25:07,000 --> 00:25:11,000
x, dan mengubah nomor di sana, kemudian pergi ke alamat y,

458
00:25:11,000 --> 00:25:16,000
mengubah nomor di sana, bahkan ketika tidak benar-benar mendapatkan salinan dari nilai-nilai sendiri,

459
00:25:16,000 --> 00:25:19,000
jadi meskipun kita bicarakan ini sebagai memori utama yang

460
00:25:19,000 --> 00:25:23,000
dan ini Swap sebagai memori yang kuat dan bagian berbahaya dari C

461
00:25:23,000 --> 00:25:28,000
adalah bahwa fungsi apapun dapat menyentuh memori di mana saja di komputer,

462
00:25:28,000 --> 00:25:32,000
dan ini sangat kuat dalam bahwa Anda dapat melakukan hal-hal yang sangat mewah dengan program komputer di C.

463
00:25:32,000 --> 00:25:36,000
Hal ini berbahaya karena Anda juga dapat mengacaukan sangat mudah.

464
00:25:36,000 --> 00:25:39,000
Bahkan, salah satu cara yang paling umum untuk program hari ini untuk dimanfaatkan

465
00:25:39,000 --> 00:25:42,000
masih untuk programmer tidak menyadari

466
00:25:42,000 --> 00:25:45,000
bahwa ia adalah memungkinkan data

467
00:25:45,000 --> 00:25:49,000
yang akan ditulis dalam sebuah lokasi di memori yang tidak dimaksudkan.

468
00:25:49,000 --> 00:25:51,000
>> Misalnya, ia menyatakan sebuah array ukuran 10

469
00:25:51,000 --> 00:25:56,000
tapi kemudian sengaja mencoba untuk menempatkan 11 byte ke dalam array memori,

470
00:25:56,000 --> 00:25:59,000
dan Anda mulai menyentuh bagian-bagian dari memori yang tidak lagi berlaku.

471
00:25:59,000 --> 00:26:02,000
Hanya untuk kontekstual ini, beberapa dari Anda mungkin tahu bahwa

472
00:26:02,000 --> 00:26:06,000
perangkat lunak sering meminta Anda untuk nomor seri atau kunci pendaftaran,

473
00:26:06,000 --> 00:26:08,000
Photoshop dan Word dan program-program seperti ini.

474
00:26:08,000 --> 00:26:12,000
Ada ada retakan, karena beberapa dari Anda tahu, online di mana Anda dapat menjalankan program kecil,

475
00:26:12,000 --> 00:26:14,000
dan voila, tidak ada permintaan lebih untuk nomor seri.

476
00:26:14,000 --> 00:26:16,000
Bagaimana itu bekerja?

477
00:26:16,000 --> 00:26:21,000
Dalam banyak kasus hal-hal ini hanya menemukan di komputer

478
00:26:21,000 --> 00:26:24,000
teks segmen di nol sebenarnya komputer dan yang

479
00:26:24,000 --> 00:26:28,000
mana adalah bahwa fungsi di mana nomor seri yang diminta,

480
00:26:28,000 --> 00:26:31,000
dan Anda menimpa ruang itu, atau saat program sedang berjalan

481
00:26:31,000 --> 00:26:33,000
Anda dapat mencari tahu di mana kunci sebenarnya disimpan

482
00:26:33,000 --> 00:26:37,000
menggunakan sesuatu yang disebut debugger, dan Anda dapat crack software seperti itu.

483
00:26:37,000 --> 00:26:40,000
Ini bukan untuk mengatakan bahwa ini adalah tujuan kami untuk beberapa hari,

484
00:26:40,000 --> 00:26:42,000
tetapi memiliki sangat nyata-dunia konsekuensi.

485
00:26:42,000 --> 00:26:45,000
Yang satu terjadi untuk melibatkan pencurian perangkat lunak,

486
00:26:45,000 --> 00:26:47,000
tapi ada juga kompromi mesin keseluruhan.

487
00:26:47,000 --> 00:26:50,000
>> Bahkan, ketika website hari ini dieksploitasi

488
00:26:50,000 --> 00:26:53,000
dan dikompromikan dan data bocor dan password yang dicuri

489
00:26:53,000 --> 00:26:58,000
ini sangat sering berhubungan dengan manajemen yang buruk dari memori seseorang,

490
00:26:58,000 --> 00:27:01,000
atau, dalam kasus database, kegagalan untuk mengantisipasi

491
00:27:01,000 --> 00:27:03,000
permusuhan masukan, sehingga lebih pada bahwa dalam minggu-minggu yang akan datang,

492
00:27:03,000 --> 00:27:07,000
tapi untuk sekarang hanya sneak preview dari jenis kerusakan yang dapat Anda lakukan

493
00:27:07,000 --> 00:27:11,000
dengan tidak cukup memahami bagaimana segala sesuatu bekerja di bawah tenda.

494
00:27:11,000 --> 00:27:14,000
Mari kita pergi tentang memahami mengapa ini rusak

495
00:27:14,000 --> 00:27:17,000
dengan alat yang akan menjadi lebih dan lebih berguna

496
00:27:17,000 --> 00:27:19,000
program-program kami mendapatkan lebih kompleks.

497
00:27:19,000 --> 00:27:21,000
Sejauh ini ketika Anda sudah bug dalam program Anda

498
00:27:21,000 --> 00:27:23,000
bagaimana anda pergi tentang debugging?

499
00:27:23,000 --> 00:27:25,000
Apa yang telah Anda teknik telah sejauh ini, apakah diajarkan oleh TF Anda

500
00:27:25,000 --> 00:27:27,000
atau hanya otodidak?

501
00:27:27,000 --> 00:27:29,000
[Mahasiswa] printf.

502
00:27:29,000 --> 00:27:31,000
Printf, sehingga printf mungkin telah teman Anda dalam bahwa jika Anda ingin melihat

503
00:27:31,000 --> 00:27:33,000
apa yang terjadi dalam program Anda

504
00:27:33,000 --> 00:27:36,000
Anda hanya menempatkan printf sini, printf sini, printf sini.

505
00:27:36,000 --> 00:27:38,000
Kemudian Anda menjalankannya, dan Anda mendapatkan sejumlah besar barang-barang di layar

506
00:27:38,000 --> 00:27:43,000
yang dapat Anda gunakan untuk kemudian menyimpulkan apa yang sebenarnya terjadi salah dalam program Anda.

507
00:27:43,000 --> 00:27:45,000
>> Printf cenderung menjadi hal yang sangat kuat,

508
00:27:45,000 --> 00:27:47,000
tapi itu sebuah proses yang sangat manual.

509
00:27:47,000 --> 00:27:49,000
Anda harus menempatkan printf sini, printf sini,

510
00:27:49,000 --> 00:27:51,000
dan jika Anda memasukkannya ke dalam loop mungkin anda akan mendapatkan 100 baris

511
00:27:51,000 --> 00:27:53,000
output yang kemudian harus menyaring.

512
00:27:53,000 --> 00:27:58,000
Ini bukan mekanisme user-friendly atau interaktif yang sangat untuk program debugging,

513
00:27:58,000 --> 00:28:00,000
tapi untungnya ada ada alternatif.

514
00:28:00,000 --> 00:28:03,000
Ada sebuah program, misalnya, disebut GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
yang merupakan rahasia sedikit bagaimana Anda menggunakannya.

516
00:28:06,000 --> 00:28:08,000
Ini sedikit rumit, tapi terus terang,

517
00:28:08,000 --> 00:28:11,000
ini adalah salah satu hal di mana jika Anda masukkan ke dalam minggu ini dan berikutnya

518
00:28:11,000 --> 00:28:14,000
jam tambahan untuk memahami sesuatu seperti GDB

519
00:28:14,000 --> 00:28:18,000
itu akan menghemat mungkin puluhan jam dalam jangka panjang,

520
00:28:18,000 --> 00:28:21,000
sehingga dengan itu, izinkan saya memberi Anda sebuah teaser tentang bagaimana hal ini bekerja.

521
00:28:21,000 --> 00:28:23,000
>> Saya di jendela terminal saya.

522
00:28:23,000 --> 00:28:26,000
Biarkan aku pergi ke depan dan mengkompilasi program ini, buggy3.

523
00:28:26,000 --> 00:28:28,000
Ini sudah up to date.

524
00:28:28,000 --> 00:28:31,000
Mari saya menjalankannya seperti yang kami lakukan beberapa waktu lalu, dan memang, itu rusak.

525
00:28:31,000 --> 00:28:34,000
Tapi mengapa ini? Mungkin aku mengacaukan fungsi swap.

526
00:28:34,000 --> 00:28:37,000
Mungkin itu a dan b. Saya tidak cukup memindahkan mereka sekitar dengan benar.

527
00:28:37,000 --> 00:28:39,000
Biarkan aku pergi ke depan dan melakukan hal ini.

528
00:28:39,000 --> 00:28:43,000
Daripada hanya menjalankan buggy3 biarkan aku bukannya menjalankan GDB program,

529
00:28:43,000 --> 00:28:48,000
dan aku akan mengatakan itu untuk menjalankan buggy3,

530
00:28:48,000 --> 00:28:52,000
dan aku akan menyertakan sebuah argumen baris perintah,-tui,

531
00:28:52,000 --> 00:28:55,000
dan kami akan menempatkan ini dalam masalah masa depan di spec untuk mengingatkan.

532
00:28:55,000 --> 00:28:57,000
Dan sekarang ini antarmuka hitam dan putih muncul itu, sekali lagi,

533
00:28:57,000 --> 00:28:59,000
adalah sedikit berlebihan pada awalnya karena ada semua ini

534
00:28:59,000 --> 00:29:02,000
Informasi garansi di sini, tapi setidaknya ada sesuatu yang akrab.

535
00:29:02,000 --> 00:29:04,000
Di bagian atas jendela adalah kode yang sebenarnya,

536
00:29:04,000 --> 00:29:08,000
dan jika saya gulir di sini biarkan aku gulir ke bagian paling atas dari file saya,

537
00:29:08,000 --> 00:29:11,000
dan memang, ada buggy3.c, dan perhatikan di bagian bawah jendela ini

538
00:29:11,000 --> 00:29:13,000
Aku punya cepat GDB.

539
00:29:13,000 --> 00:29:16,000
>> Ini tidak sama seperti biasa saya Harvard John prompt.

540
00:29:16,000 --> 00:29:19,000
Ini adalah sebuah prompt yang akan memungkinkan saya untuk mengontrol GDB.

541
00:29:19,000 --> 00:29:21,000
GDB adalah debugger.

542
00:29:21,000 --> 00:29:24,000
Debugger adalah program yang memungkinkan Anda berjalan melalui

543
00:29:24,000 --> 00:29:27,000
pelaksanaan program baris dengan baris demi baris,

544
00:29:27,000 --> 00:29:30,000
sepanjang jalan melakukan apa pun yang Anda ingin program ini,

545
00:29:30,000 --> 00:29:33,000
bahkan memanggil fungsi, atau mencari, yang lebih penting,

546
00:29:33,000 --> 00:29:35,000
pada nilai variabel berbagai s.

547
00:29:35,000 --> 00:29:37,000
Mari kita pergi ke depan dan melakukan hal ini.

548
00:29:37,000 --> 00:29:40,000
Aku akan pergi ke depan dan ketik dalam jangka pada prompt GDB itu,

549
00:29:40,000 --> 00:29:43,000
jadi perhatikan di bagian bawah kiri layar aku mengetik dijalankan,

550
00:29:43,000 --> 00:29:45,000
dan aku sudah tekan enter, dan apa yang mereka lakukan?

551
00:29:45,000 --> 00:29:50,000
Ini benar-benar berlari program saya, tapi saya tidak benar-benar melihat banyak pergi di sini

552
00:29:50,000 --> 00:29:55,000
karena saya belum benar-benar mengatakan debugger

553
00:29:55,000 --> 00:29:57,000
untuk berhenti pada suatu saat tertentu.

554
00:29:57,000 --> 00:29:59,000
Hanya mengetik run menjalankan program.

555
00:29:59,000 --> 00:30:01,000
Saya tidak benar-benar melihat apa-apa. Saya tidak bisa memanipulasinya.

556
00:30:01,000 --> 00:30:03,000
>> Alih-alih membiarkan saya melakukan hal ini.

557
00:30:03,000 --> 00:30:08,000
Pada prompt GDB biarkan aku bukan tipe istirahat, masukkan.

558
00:30:08,000 --> 00:30:10,000
Itu bukan apa yang saya dimaksudkan untuk mengetik.

559
00:30:10,000 --> 00:30:13,000
Mari kita bukannya mengetik istirahat utama.

560
00:30:13,000 --> 00:30:15,000
Dengan kata lain, saya ingin mengatur sesuatu yang disebut breakpoint,

561
00:30:15,000 --> 00:30:18,000
yang aptly bernama karena akan istirahat atau jeda

562
00:30:18,000 --> 00:30:21,000
pelaksanaan program anda di tempat tertentu.

563
00:30:21,000 --> 00:30:23,000
Main adalah nama fungsi saya.

564
00:30:23,000 --> 00:30:25,000
Perhatikan bahwa GDB cukup pintar.

565
00:30:25,000 --> 00:30:28,000
Ini tahu bahwa utama terjadi mulai kira-kira pada baris 18

566
00:30:28,000 --> 00:30:32,000
dari buggy3.c, dan kemudian melihat di sini di sebelah kiri atas

567
00:30:32,000 --> 00:30:34,000
b + tepat di sebelah garis 18.

568
00:30:34,000 --> 00:30:38,000
Itu mengingatkan saya bahwa saya telah menetapkan breakpoint pada baris 18.

569
00:30:38,000 --> 00:30:42,000
Kali ini ketika saya mengetik lari, aku akan menjalankan program saya

570
00:30:42,000 --> 00:30:45,000
sampai hits breakpoint itu,

571
00:30:45,000 --> 00:30:48,000
sehingga program akan berhenti untuk saya pada baris 18.

572
00:30:48,000 --> 00:30:50,000
Di sini kita pergi, jalankan.

573
00:30:50,000 --> 00:30:53,000
Tidak ada yang tampaknya telah terjadi, tapi perhatikan di bagian kiri bawah

574
00:30:53,000 --> 00:30:58,000
memulai program, buggy3, breakpoint 1 di utama pada baris buggy3.c 18.

575
00:30:58,000 --> 00:31:00,000
Apa yang bisa saya lakukan sekarang?

576
00:31:00,000 --> 00:31:03,000
>> Perhatikan saya bisa mulai mengetik hal-hal seperti cetak,

577
00:31:03,000 --> 00:31:08,000
tidak printf, x cetak, dan sekarang itu aneh.

578
00:31:08,000 --> 00:31:11,000
$ 1 hanya rasa ingin tahu, seperti yang kita akan melihat

579
00:31:11,000 --> 00:31:14,000
setiap kali Anda mencetak sesuatu Anda mendapatkan nilai $ baru.

580
00:31:14,000 --> 00:31:18,000
Itu sehingga Anda dapat merujuk kembali ke nilai sebelumnya hanya dalam kasus,

581
00:31:18,000 --> 00:31:21,000
tapi untuk sekarang apa cetak mengatakan saya adalah bahwa nilai x pada titik ini dalam cerita

582
00:31:21,000 --> 00:31:26,000
ternyata 134.514.032.

583
00:31:26,000 --> 00:31:29,000
Apa? Mana yang bahkan datang dari?

584
00:31:29,000 --> 00:31:31,000
[Tak terdengar-murid]

585
00:31:31,000 --> 00:31:34,000
Memang, ini adalah apa yang kita sebut nilai sampah, dan kami sudah tidak membicarakan hal ini belum,

586
00:31:34,000 --> 00:31:37,000
tetapi alasan bahwa Anda menginisialisasi variabel

587
00:31:37,000 --> 00:31:40,000
jelas sehingga mereka memiliki beberapa nilai yang Anda ingin mereka miliki.

588
00:31:40,000 --> 00:31:44,000
Tapi tangkapan ingat bahwa Anda dapat mendeklarasikan variabel

589
00:31:44,000 --> 00:31:46,000
seperti yang saya lakukan beberapa saat yang lalu dalam contoh sigma saya

590
00:31:46,000 --> 00:31:48,000
tanpa benar-benar memberi mereka nilai.

591
00:31:48,000 --> 00:31:50,000
Ingat apa yang saya lakukan di sini di sigma.

592
00:31:50,000 --> 00:31:52,000
Saya menyatakan n, tapi apa nilai yang saya berikan?

593
00:31:52,000 --> 00:31:56,000
Tidak ada, karena saya tahu bahwa dalam beberapa baris berikutnya

594
00:31:56,000 --> 00:31:59,000
GetInt akan mengurus masalah menempatkan nilai dalam n.

595
00:31:59,000 --> 00:32:02,000
>> Tapi pada titik ini dalam kisah baris 11

596
00:32:02,000 --> 00:32:05,000
dan garis 12 dan baris 13 dan baris 14

597
00:32:05,000 --> 00:32:08,000
seluruh garis beberapa berapakah nilai dari n?

598
00:32:08,000 --> 00:32:10,000
Dalam C Anda hanya tidak tahu.

599
00:32:10,000 --> 00:32:14,000
Itu umumnya beberapa nilai sampah, beberapa nomor benar-benar acak

600
00:32:14,000 --> 00:32:17,000
yang tersisa pada dasarnya dari beberapa fungsi sebelumnya

601
00:32:17,000 --> 00:32:21,000
yang telah dijalankan, sehingga program Anda berjalan

602
00:32:21,000 --> 00:32:24,000
ingat bahwa fungsi mendapatkan fungsi, fungsi, fungsi.

603
00:32:24,000 --> 00:32:27,000
Semua frame bisa memakai memori, dan kemudian mereka kembali fungsi,

604
00:32:27,000 --> 00:32:31,000
dan seperti saya menyarankan dengan penghapus memori mereka akhirnya digunakan kembali.

605
00:32:31,000 --> 00:32:37,000
Nah, kebetulan bahwa variabel x dalam program ini

606
00:32:37,000 --> 00:32:41,000
tampaknya telah mengandung beberapa nilai seperti sampah 134514032

607
00:32:41,000 --> 00:32:44,000
dari beberapa fungsi sebelumnya, tak satu pun yang saya tulis.

608
00:32:44,000 --> 00:32:47,000
Ini bisa menjadi sesuatu yang datang secara efektif dengan sistem operasi,

609
00:32:47,000 --> 00:32:49,000
beberapa fungsi di bawah tenda.

610
00:32:49,000 --> 00:32:52,000
>> Oke, itu bagus, tetapi mari kita sekarang maju ke baris berikutnya.

611
00:32:52,000 --> 00:32:55,000
Jika saya ketik "berikutnya" pada saya GDB prompt dan saya tekan enter,

612
00:32:55,000 --> 00:32:58,000
melihat bahwa menyoroti bergerak ke baris 19,

613
00:32:58,000 --> 00:33:01,000
tetapi implikasi logis adalah bahwa garis 18

614
00:33:01,000 --> 00:33:06,000
kini telah selesai mengeksekusi, jadi jika saya kembali ketik "print x"

615
00:33:06,000 --> 00:33:10,000
Sekarang saya akan melihat 1, dan memang, saya lakukan.

616
00:33:10,000 --> 00:33:14,000
Sekali lagi, hal-hal $ adalah cara GDB mengingatkan Anda

617
00:33:14,000 --> 00:33:17,000
apa sejarah cetak adalah bahwa Anda lakukan.

618
00:33:17,000 --> 00:33:21,000
Sekarang biarkan aku pergi ke depan dan mencetak y, dan memang, y adalah beberapa nilai gila juga,

619
00:33:21,000 --> 00:33:24,000
tapi bukan masalah besar karena di baris 19 kita akan menetapkan

620
00:33:24,000 --> 00:33:27,000
nilai 2, jadi biar ketik "next" lagi.

621
00:33:27,000 --> 00:33:29,000
Dan sekarang kita berada di garis printf.

622
00:33:29,000 --> 00:33:31,000
Biarkan aku melakukan x cetak.

623
00:33:31,000 --> 00:33:34,000
Biarkan aku melakukan y cetak. Terus terang, saya mendapatkan sedikit lelah pencetakan ini.

624
00:33:34,000 --> 00:33:38,000
Biarkan saya bukan ketik "display x" dan "y layar,"

625
00:33:38,000 --> 00:33:41,000
dan sekarang setiap kali saya ketik perintah di masa depan

626
00:33:41,000 --> 00:33:45,000
Aku akan teringat apa x dan y, apa x dan y, apa x dan y.

627
00:33:45,000 --> 00:33:48,000
>> Saya juga dapat, sebagai tipe samping, dalam "penduduk setempat info."

628
00:33:48,000 --> 00:33:50,000
Info adalah perintah khusus.

629
00:33:50,000 --> 00:33:52,000
Penduduk setempat berarti itu menunjukkan saya variabel lokal.

630
00:33:52,000 --> 00:33:55,000
Hanya dalam kasus saya lupa atau ini adalah fungsi, gila rumit

631
00:33:55,000 --> 00:33:57,000
bahwa saya atau orang lain menulis penduduk setempat Info akan memberitahu Anda

632
00:33:57,000 --> 00:34:00,000
apa semua variabel lokal dalam fungsi lokal

633
00:34:00,000 --> 00:34:03,000
bahwa Anda mungkin peduli jika Anda ingin melihat-lihat.

634
00:34:03,000 --> 00:34:07,000
Sekarang, printf adalah untuk mengeksekusi, jadi biarkan aku pergi ke depan dan ketikkan "berikutnya."

635
00:34:07,000 --> 00:34:10,000
Karena kita berada di lingkungan ini kita tidak benar-benar melihatnya

636
00:34:10,000 --> 00:34:14,000
mengeksekusi di sini, tapi perhatikan itu semakin sedikit hancur di sini.

637
00:34:14,000 --> 00:34:17,000
Tapi perhatikan itu override layar ada,

638
00:34:17,000 --> 00:34:21,000
jadi bukan program yang sempurna di sini, tapi tidak apa-apa karena saya selalu bisa menyodok sekitar

639
00:34:21,000 --> 00:34:23,000
menggunakan print jika saya ingin.

640
00:34:23,000 --> 00:34:26,000
>> Mari saya ketik next lagi, dan sekarang inilah bagian yang menarik.

641
00:34:26,000 --> 00:34:29,000
Pada titik ini dalam cerita y adalah 2, dan x adalah 1,

642
00:34:29,000 --> 00:34:32,000
seperti yang disarankan di sini, dan lagi,

643
00:34:32,000 --> 00:34:35,000
alasan ini secara otomatis menampilkan sekarang adalah karena saya menggunakan perintah

644
00:34:35,000 --> 00:34:40,000
display x dan y layar, sehingga saat aku mengetik berikutnya

645
00:34:40,000 --> 00:34:43,000
dalam teori x dan y harus menjadi bertukar.

646
00:34:43,000 --> 00:34:45,000
Sekarang, kita sudah tahu itu tidak akan terjadi,

647
00:34:45,000 --> 00:34:49,000
tapi kita akan lihat sebentar lagi bagaimana kita bisa menyelam lebih dalam untuk mencari tahu mengapa itu benar.

648
00:34:49,000 --> 00:34:54,000
Selanjutnya, dan sayangnya, y masih 2 dan x masih 1, dan saya bisa mengkonfirmasikan sebanyak.

649
00:34:54,000 --> 00:34:56,000
Cetak x, y cetak.

650
00:34:56,000 --> 00:34:59,000
Memang, tidak ada swapping sebenarnya telah terjadi, jadi mari kita mulai hal ini.

651
00:34:59,000 --> 00:35:01,000
Jelas swap rusak.

652
00:35:01,000 --> 00:35:04,000
Mari kita bukan ketik "run" lagi.

653
00:35:04,000 --> 00:35:07,000
Izinkan saya mengatakan ya, saya ingin memulai kembali dari awal, masukkan.

654
00:35:07,000 --> 00:35:09,000
>> Sekarang aku kembali pada baris 18.

655
00:35:09,000 --> 00:35:11,000
Sekarang perhatikan x dan y adalah nilai-nilai sampah lagi.

656
00:35:11,000 --> 00:35:15,000
Selanjutnya, berikutnya, berikutnya, berikutnya.

657
00:35:15,000 --> 00:35:17,000
Jika saya bosan saya juga bisa cukup ketik n untuk selanjutnya.

658
00:35:17,000 --> 00:35:21,000
Anda dapat menyingkatnya dengan urutan sesingkat mungkin karakter.

659
00:35:21,000 --> 00:35:23,000
Swap sekarang rusak.

660
00:35:23,000 --> 00:35:25,000
Mari selami, sehingga bukannya mengetik berikutnya,

661
00:35:25,000 --> 00:35:30,000
sekarang aku akan mengetik langkah sehingga saya melangkah di dalam fungsi ini

662
00:35:30,000 --> 00:35:33,000
sehingga saya dapat berjalan melalui itu, jadi aku memukul langkah dan kemudian enter.

663
00:35:33,000 --> 00:35:37,000
Perhatikan bahwa melompat menyoroti turun lebih rendah dalam program saya ke baris 36.

664
00:35:37,000 --> 00:35:39,000
Sekarang apa variabel lokal?

665
00:35:39,000 --> 00:35:41,000
Info penduduk setempat.

666
00:35:41,000 --> 00:35:43,000
Tidak hanya namun karena kita sudah tidak mendapatkan ke baris tersebut,

667
00:35:43,000 --> 00:35:47,000
jadi mari kita pergi ke depan dan berkata "selanjutnya."

668
00:35:47,000 --> 00:35:50,000
Sekarang kita tampaknya memiliki tmp, tmp cetak.

669
00:35:50,000 --> 00:35:52,000
Nilai sampah, kan? Saya kira begitu.

670
00:35:52,000 --> 00:35:55,000
Bagaimana mencetak, print b, 1 dan 2?

671
00:35:55,000 --> 00:35:58,000
Dalam beberapa saat, segera setelah saya ketik next lagi

672
00:35:58,000 --> 00:36:02,000
tmp akan mengambil nilai 1, mudah-mudahan,

673
00:36:02,000 --> 00:36:05,000
karena tmp akan diberi nilai dari.

674
00:36:05,000 --> 00:36:08,000
>> Sekarang mari kita lakukan mencetak b, cetak,

675
00:36:08,000 --> 00:36:11,000
tapi sekarang mencetak tmp, dan itu memang 1.

676
00:36:11,000 --> 00:36:14,000
Biarkan saya lakukan selanjutnya. Biarkan saya lakukan selanjutnya.

677
00:36:14,000 --> 00:36:16,000
Aku sudah selesai fungsi swap.

678
00:36:16,000 --> 00:36:19,000
Aku masih di dalamnya di baris 40, jadi biar mencetak,

679
00:36:19,000 --> 00:36:22,000
print b, dan aku tidak peduli apa yang tmp.

680
00:36:22,000 --> 00:36:27,000
Sepertinya swap adalah benar ketika datang untuk swapping dan b.

681
00:36:27,000 --> 00:36:31,000
Tapi kalau aku sekarang ketik berikutnya, saya melompat kembali ke baris 25,

682
00:36:31,000 --> 00:36:34,000
dan tentu saja, jika saya ketik x dan y cetak

683
00:36:34,000 --> 00:36:38,000
mereka masih tidak berubah, jadi kita belum tetap masalah.

684
00:36:38,000 --> 00:36:41,000
Tapi diagnosa sekarang mungkin dengan program GDB

685
00:36:41,000 --> 00:36:44,000
kami telah mendapatkan setidaknya satu langkah lebih dekat untuk memahami

686
00:36:44,000 --> 00:36:47,000
apa yang salah tanpa harus serasah kode kita dengan meletakkan printf sini,

687
00:36:47,000 --> 00:36:50,000
printf sini, printf sini dan kemudian berjalan lagi dan lagi

688
00:36:50,000 --> 00:36:52,000
mencoba untuk mencari tahu apa yang salah.

689
00:36:52,000 --> 00:36:55,000
>> Aku akan pergi ke depan dan berhenti keluar dari ini sama sekali dengan berhenti.

690
00:36:55,000 --> 00:36:57,000
Ini akan kemudian berkata, "Keluar sih?" Ya.

691
00:36:57,000 --> 00:37:00,000
Sekarang aku kembali pada prompt normal saya, dan saya sudah selesai menggunakan GDB.

692
00:37:00,000 --> 00:37:03,000
Sebagai samping, Anda tidak perlu menggunakan ini-tui bendera.

693
00:37:03,000 --> 00:37:07,000
Bahkan, jika Anda menghilangkan itu Anda mendapatkan dasarnya bagian bawah layar.

694
00:37:07,000 --> 00:37:11,000
Jika saya kemudian ketik istirahat utama dan kemudian jalankan

695
00:37:11,000 --> 00:37:15,000
Saya masih bisa menjalankan program saya, tapi apa yang akan dilakukan adalah lebih tekstual

696
00:37:15,000 --> 00:37:18,000
hanya menunjukkan satu baris saat ini pada satu waktu.

697
00:37:18,000 --> 00:37:21,000
The-tui, antarmuka pengguna tekstual,

698
00:37:21,000 --> 00:37:25,000
hanya menunjukkan Anda lebih dari program sekaligus, yang mungkin sedikit lebih mudah konseptual.

699
00:37:25,000 --> 00:37:27,000
Tapi memang, saya hanya bisa lakukan selanjutnya, next, next,

700
00:37:27,000 --> 00:37:30,000
dan aku akan melihat satu baris pada satu waktu, dan jika saya benar-benar ingin melihat apa yang terjadi

701
00:37:30,000 --> 00:37:35,000
Saya bisa mengetik daftar dan melihat sejumlah besar baris tetangga.

702
00:37:35,000 --> 00:37:39,000
>> Ada video yang kita telah meminta bahwa Anda menonton untuk masalah set 3

703
00:37:39,000 --> 00:37:43,000
di mana Nate mencakup beberapa seluk-beluk GDB,

704
00:37:43,000 --> 00:37:46,000
dan ini adalah salah satu hal, jujur, di mana beberapa persentase non-sepele Anda

705
00:37:46,000 --> 00:37:49,000
tidak akan pernah menyentuh GDB, dan itu akan menjadi hal yang buruk

706
00:37:49,000 --> 00:37:53,000
karena secara harfiah Anda akan berakhir menghabiskan lebih banyak waktu nanti semester ini

707
00:37:53,000 --> 00:37:56,000
memburu bug maka Anda akan jika anda menaruh di setengah jam / jam

708
00:37:56,000 --> 00:38:00,000
minggu ini dan belajar berikutnya untuk mendapatkan nyaman dengan GDB.

709
00:38:00,000 --> 00:38:02,000
Printf adalah teman Anda.

710
00:38:02,000 --> 00:38:05,000
GDB sekarang harus menjadi teman Anda.

711
00:38:05,000 --> 00:38:08,000
>> Setiap pertanyaan tentang GDB?

712
00:38:08,000 --> 00:38:12,000
Dan di sini adalah daftar singkat dari beberapa perintah yang paling kuat dan berguna.

713
00:38:12,000 --> 00:38:15,000
Ya. >> Dapatkah Anda mencetak string?

714
00:38:15,000 --> 00:38:17,000
Dapatkah Anda mencetak string? Tentu saja.

715
00:38:17,000 --> 00:38:19,000
Ini tidak harus hanya menjadi bilangan bulat.

716
00:38:19,000 --> 00:38:22,000
Jika variabel s adalah string ketik saja s cetak.

717
00:38:22,000 --> 00:38:24,000
Ini akan menunjukkan kepada Anda apa yang variabel string adalah.

718
00:38:24,000 --> 00:38:26,000
[Tak terdengar-murid]

719
00:38:26,000 --> 00:38:28,000
Ini akan memberi Anda alamat dan string itu sendiri.

720
00:38:28,000 --> 00:38:32,000
Ini akan menunjukkan Anda berdua.

721
00:38:32,000 --> 00:38:34,000
Dan satu hal lagi, hanya karena ini adalah baik untuk mengetahui juga.

722
00:38:34,000 --> 00:38:37,000
Backtrace dan frame, biarkan aku menyelam ke dalam kali ini yang terakhir,

723
00:38:37,000 --> 00:38:39,000
sama program dengan GDB.

724
00:38:39,000 --> 00:38:44,000
Biarkan aku pergi ke depan dan menjalankan versi antarmuka pengguna tekstual,

725
00:38:44,000 --> 00:38:46,000
istirahat utama.

726
00:38:46,000 --> 00:38:49,000
Biarkan aku pergi ke depan dan berjalan lagi. Aku di sini.

727
00:38:49,000 --> 00:38:55,000
Sekarang biarkan aku pergi next, next, next, next, selanjutnya, langkah, masukkan.

728
00:38:55,000 --> 00:39:00,000
>> Dan sekarang kira aku sekarang di swap sengaja, tapi aku seperti "Sialan, apa nilai x?"

729
00:39:00,000 --> 00:39:02,000
Saya tidak bisa melakukan x lagi.

730
00:39:02,000 --> 00:39:05,000
Saya tidak bisa melakukan y karena mereka tidak dalam lingkup.

731
00:39:05,000 --> 00:39:07,000
Mereka tidak dalam konteks, tapi tidak ada masalah.

732
00:39:07,000 --> 00:39:09,000
Saya bisa mengetik backtrace.

733
00:39:09,000 --> 00:39:13,000
Itu menunjukkan saya semua fungsi yang telah dieksekusi sampai dengan titik waktu ini.

734
00:39:13,000 --> 00:39:16,000
Perhatikan bahwa satu di bawah, utama, jalur utama dengan

735
00:39:16,000 --> 00:39:18,000
berada di bawah gambar kami di sini.

736
00:39:18,000 --> 00:39:22,000
Fakta bahwa swap adalah di atasnya berbaris dengan swap berada di atas dalam memori di sini,

737
00:39:22,000 --> 00:39:26,000
dan jika saya ingin kembali ke utama sementara bisa saya katakan "frame."

738
00:39:26,000 --> 00:39:30,000
Nomor berapa? Main bingkai # 1.

739
00:39:30,000 --> 00:39:32,000
Aku akan pergi ke depan dan berkata "frame 1."

740
00:39:32,000 --> 00:39:36,000
>> Sekarang aku kembali main, dan saya bisa mencetak x, dan saya dapat mencetak y,

741
00:39:36,000 --> 00:39:40,000
tapi aku tidak bisa mencetak b atau.

742
00:39:40,000 --> 00:39:43,000
Tapi aku bisa jika saya mengatakan, "Oke, tunggu sebentar Dimana swap?."

743
00:39:43,000 --> 00:39:46,000
Biarkan aku pergi ke depan dan berkata "0 frame."

744
00:39:46,000 --> 00:39:48,000
Sekarang aku kembali di mana saya ingin menjadi, dan sebagai samping,

745
00:39:48,000 --> 00:39:52,000
ada perintah lain juga, seperti jika Anda benar-benar mendapatkan mengetik bosan next, next, next, next,

746
00:39:52,000 --> 00:39:56,000
biasanya Anda bisa mengatakan hal-hal seperti "10 berikutnya," dan itu akan melangkah melalui 10 baris berikutnya.

747
00:39:56,000 --> 00:39:59,000
Anda juga dapat menulis "lanjutkan" ketika Anda benar-benar mendapatkan muak dengan melangkah melewatinya.

748
00:39:59,000 --> 00:40:05,000
Lanjutkan akan menjalankan program Anda tanpa gangguan sampai hits breakpoint lain,

749
00:40:05,000 --> 00:40:07,000
apakah dalam satu lingkaran atau menurunkan bawah dalam program Anda.

750
00:40:07,000 --> 00:40:11,000
>> Dalam hal ini kami terus sampai akhir, dan program keluar secara normal.

751
00:40:11,000 --> 00:40:13,000
Ini adalah cara yang mewah, proses rendah.

752
00:40:13,000 --> 00:40:16,000
Hanya program anda keluar secara normal.

753
00:40:16,000 --> 00:40:24,000
Lagi di dalam video dan debugging sesi yang akan datang.

754
00:40:24,000 --> 00:40:26,000
Itu banyak.

755
00:40:26,000 --> 00:40:35,000
Mari kita 5 menit istirahat kami di sini, dan kami akan kembali dengan structs dan file.

756
00:40:35,000 --> 00:40:38,000
>> Jika Anda telah menyelam ke pset minggu ini sudah

757
00:40:38,000 --> 00:40:41,000
Anda akan tahu bahwa kita gunakan dalam kode distribusi,

758
00:40:41,000 --> 00:40:45,000
sumber kode yang kami sediakan untuk Anda sebagai titik awal, beberapa teknik baru.

759
00:40:45,000 --> 00:40:50,000
Secara khusus, kami memperkenalkan kata kunci baru yang disebut struct, untuk struktur,

760
00:40:50,000 --> 00:40:53,000
sehingga kita dapat membuat variabel disesuaikan macam.

761
00:40:53,000 --> 00:40:57,000
Kami juga memperkenalkan konsep file I / O, file input dan output,

762
00:40:57,000 --> 00:41:00,000
dan ini adalah agar kita dapat menyelamatkan negara

763
00:41:00,000 --> 00:41:03,000
dewan Scramble Anda ke file pada disk

764
00:41:03,000 --> 00:41:06,000
sehingga rekan-rekan mengajar dan aku bisa mengerti

765
00:41:06,000 --> 00:41:09,000
apa yang terjadi di dalam program Anda tanpa harus bermain secara manual

766
00:41:09,000 --> 00:41:11,000
puluhan permainan Scramble.

767
00:41:11,000 --> 00:41:13,000
Kita bisa melakukan ini lebih automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Ini ide struct memecahkan masalah yang cukup menarik.

769
00:41:18,000 --> 00:41:21,000
Misalkan kita ingin menerapkan beberapa program

770
00:41:21,000 --> 00:41:25,000
yang entah bagaimana melacak informasi pada siswa,

771
00:41:25,000 --> 00:41:28,000
dan mahasiswa mungkin, misalnya, ID, nama

772
00:41:28,000 --> 00:41:31,000
dan sebuah rumah di tempat seperti Harvard, jadi ini adalah 3 potongan informasi

773
00:41:31,000 --> 00:41:34,000
kami ingin menjaga sekitar, jadi biarkan aku pergi ke depan dan mulai menulis sebuah program kecil di sini,

774
00:41:34,000 --> 00:41:38,000
termasuk stdio.h.

775
00:41:38,000 --> 00:41:42,000
Biarkan aku melakukan termasuk cs50.h.

776
00:41:42,000 --> 00:41:44,000
Dan kemudian mulai fungsi utama saya.

777
00:41:44,000 --> 00:41:46,000
Aku tidak akan repot-repot dengan argumen baris perintah,

778
00:41:46,000 --> 00:41:49,000
dan di sini saya ingin memiliki mahasiswa, jadi aku akan mengatakan

779
00:41:49,000 --> 00:41:54,000
siswa memiliki nama, jadi aku akan mengatakan "string name."

780
00:41:54,000 --> 00:41:59,000
Lalu aku akan mengatakan mahasiswa juga memiliki ID, id sehingga int,

781
00:41:59,000 --> 00:42:03,000
dan mahasiswa memiliki rumah, jadi aku juga akan mengatakan "rumah string."

782
00:42:03,000 --> 00:42:06,000
Lalu aku akan memesan ini sedikit lebih bersih seperti ini.

783
00:42:06,000 --> 00:42:11,000
Oke, sekarang aku punya 3 variabel yang dapat digunakan untuk mewakili mahasiswa, jadi "mahasiswa."

784
00:42:11,000 --> 00:42:15,000
>> Dan sekarang saya ingin mengisi nilai-nilai, jadi biarkan aku pergi ke depan dan mengatakan sesuatu seperti

785
00:42:15,000 --> 00:42:18,000
"Id = 123."

786
00:42:18,000 --> 00:42:21,000
Nama akan mendapatkan David.

787
00:42:21,000 --> 00:42:24,000
Katakanlah rumah akan mendapatkan Mather,

788
00:42:24,000 --> 00:42:31,000
dan kemudian aku akan melakukan sesuatu yang sewenang-wenang seperti printf ("% s,

789
00:42:31,000 --> 00:42:37,000
mana ID adalah% d, tinggal di s%.

790
00:42:37,000 --> 00:42:41,000
Dan sekarang, apa yang ingin saya pasang di sini, satu demi satu?

791
00:42:41,000 --> 00:42:47,000
Nama, id, rumah, kembali 0.

792
00:42:47,000 --> 00:42:50,000
Oke, kecuali aku kacau di suatu tempat di sini

793
00:42:50,000 --> 00:42:54,000
Saya pikir kami memiliki program yang cukup bagus yang menyimpan satu siswa.

794
00:42:54,000 --> 00:42:57,000
Tentu saja, hal ini tidak semua yang menarik. Bagaimana jika saya ingin memiliki 2 siswa?

795
00:42:57,000 --> 00:42:59,000
Itu bukan masalah besar. Saya dapat mendukung 2 orang.

796
00:42:59,000 --> 00:43:03,000
Biarkan aku pergi ke depan dan menyorot ini dan pergi ke sini,

797
00:43:03,000 --> 00:43:09,000
dan saya dapat mengatakan "id = 456" untuk seseorang seperti Rob yang tinggal di Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Oke, tunggu, tapi aku tidak bisa menyebutnya hal yang sama,

799
00:43:12,000 --> 00:43:15,000
dan sepertinya aku akan harus menyalin ini,

800
00:43:15,000 --> 00:43:19,000
jadi saya katakan bahwa ini akan menjadi variabel Daud,

801
00:43:19,000 --> 00:43:23,000
dan biarkan aku mendapatkan beberapa salinan ini untuk Rob.

802
00:43:23,000 --> 00:43:27,000
Kita akan menyebutnya Rob tapi ini tidak akan bekerja sekarang

803
00:43:27,000 --> 00:43:33,000
karena saya telah menunggu-, mari kita mengubah saya untuk id1, name1 dan House1.

804
00:43:33,000 --> 00:43:35,000
Rob akan menjadi 2, 2.

805
00:43:35,000 --> 00:43:42,000
Aku harus mengubah ini di sini, sini, sini, sini, sini, sini.

806
00:43:42,000 --> 00:43:45,000
Tunggu, bagaimana dengan Tommy? Mari kita lakukan ini lagi.

807
00:43:45,000 --> 00:43:49,000
Tentunya jika Anda masih berpikir ini adalah cara yang baik untuk melakukan hal ini, itu tidak,

808
00:43:49,000 --> 00:43:52,000
jadi copy / paste buruk.

809
00:43:52,000 --> 00:43:55,000
Tapi kita memecahkan ini seminggu yang lalu.

810
00:43:55,000 --> 00:43:59,000
>> Apa solusi kami ketika kita ingin memiliki beberapa contoh dari tipe data yang sama?

811
00:43:59,000 --> 00:44:01,000
[Siswa] Array.

812
00:44:01,000 --> 00:44:03,000
Array, jadi saya mencoba untuk membersihkan ini.

813
00:44:03,000 --> 00:44:07,000
Mari saya membuat beberapa ruang untuk diriku sendiri di bagian atas, dan biarkan aku bukan melakukannya di sini.

814
00:44:07,000 --> 00:44:12,000
Kami akan memanggil orang-orang ini, dan sebagai gantinya aku akan mengatakan "id int,"

815
00:44:12,000 --> 00:44:14,000
dan aku akan mendukung 3 dari kita untuk saat ini.

816
00:44:14,000 --> 00:44:18,000
Aku akan mengatakan "nama string," dan aku akan mendukung 3 dari kita,

817
00:44:18,000 --> 00:44:22,000
dan kemudian aku akan mengatakan "rumah string," dan aku akan mendukung 3 dari kita.

818
00:44:22,000 --> 00:44:26,000
Sekarang di sini bukannya Daud mendapatkan variabel sendiri lokal

819
00:44:26,000 --> 00:44:28,000
kita bisa menyingkirkan mereka.

820
00:44:28,000 --> 00:44:30,000
Itu terasa baik bahwa kita membersihkan ini up.

821
00:44:30,000 --> 00:44:35,000
Saya kemudian bisa mengatakan Daud akan menjadi [0] dan nama [0]

822
00:44:35,000 --> 00:44:38,000
dan rumah-rumah [0].

823
00:44:38,000 --> 00:44:41,000
Dan kemudian Rob kita sama dapat menghemat ini.

824
00:44:41,000 --> 00:44:46,000
Mari kita menempatkan ini di sini, jadi dia akan menjadi sewenang-wenang id [1].

825
00:44:46,000 --> 00:44:50,000
Dia akan menjadi nama [1],

826
00:44:50,000 --> 00:44:53,000
dan kemudian terakhir, rumah [1].

827
00:44:53,000 --> 00:44:57,000
>> Masih sedikit membosankan, dan sekarang aku harus memikirkan hal ini,

828
00:44:57,000 --> 00:45:03,000
jadi mari kita katakan "nama [0], id [0], rumah [0],

829
00:45:03,000 --> 00:45:06,000
dan mari kita mempluralkan ini.

830
00:45:06,000 --> 00:45:09,000
Id, id, id.

831
00:45:09,000 --> 00:45:12,000
Dan lagi, aku melakukannya, jadi sekali lagi, saya sudah beralih ke copy / paste lagi,

832
00:45:12,000 --> 00:45:14,000
sehingga kemungkinan besar ada solusi lain di sini.

833
00:45:14,000 --> 00:45:18,000
Aku mungkin bisa membersihkan ini lebih lanjut dengan loop atau sesuatu seperti itu,

834
00:45:18,000 --> 00:45:21,000
sehingga singkatnya, itu sedikit lebih baik tapi masih terasa seperti

835
00:45:21,000 --> 00:45:24,000
Saya beralih untuk copy / paste, tapi bahkan ini, saya menyatakan,

836
00:45:24,000 --> 00:45:27,000
tidak benar-benar fundamental solusi yang tepat karena

837
00:45:27,000 --> 00:45:29,000
bagaimana jika suatu saat kita memutuskan Anda tahu apa?

838
00:45:29,000 --> 00:45:32,000
Kami benar-benar harus telah menyimpan alamat email untuk David dan Rob

839
00:45:32,000 --> 00:45:34,000
dan semua orang di program ini.

840
00:45:34,000 --> 00:45:36,000
Kita juga harus menyimpan nomor telepon.

841
00:45:36,000 --> 00:45:39,000
Kita juga harus menyimpan nomor kontak darurat.

842
00:45:39,000 --> 00:45:41,000
Kami memiliki semua potongan-potongan dari data yang ingin kita simpan,

843
00:45:41,000 --> 00:45:43,000
jadi bagaimana Anda pergi untuk melakukan itu?

844
00:45:43,000 --> 00:45:46,000
>> Anda mendeklarasikan array lain di bagian atas, dan kemudian Anda tambahkan secara manual

845
00:45:46,000 --> 00:45:49,000
alamat email [0], alamat email [1]

846
00:45:49,000 --> 00:45:51,000
untuk David dan Rob dan sebagainya.

847
00:45:51,000 --> 00:45:56,000
Tapi ada benar-benar hanya sebuah asumsi yang mendasari desain ini

848
00:45:56,000 --> 00:45:59,000
bahwa saya menggunakan sistem kehormatan untuk mengetahui bahwa

849
00:45:59,000 --> 00:46:03,000
[I] di setiap susunan beberapa

850
00:46:03,000 --> 00:46:06,000
hanya begitu terjadi untuk merujuk pada orang yang sama,

851
00:46:06,000 --> 00:46:10,000
sehingga [0] di id adalah nomor 123,

852
00:46:10,000 --> 00:46:13,000
dan aku akan berasumsi bahwa nama [0]

853
00:46:13,000 --> 00:46:16,000
adalah orang yang sama nama dan rumah [0]

854
00:46:16,000 --> 00:46:21,000
adalah rumah orang yang sama dan sebagainya untuk semua array berbagai yang saya buat.

855
00:46:21,000 --> 00:46:24,000
Tapi perhatikan bahwa tidak ada hubungan mendasar

856
00:46:24,000 --> 00:46:27,000
di antara mereka 3 potongan informasi, nama id, dan rumah,

857
00:46:27,000 --> 00:46:32,000
meskipun badan kita mencoba untuk model dalam program ini bukan array.

858
00:46:32,000 --> 00:46:35,000
Array hanya ini cara program untuk melakukan hal ini.

859
00:46:35,000 --> 00:46:38,000
Apa yang kita benar-benar ingin model dalam program kami adalah orang

860
00:46:38,000 --> 00:46:41,000
seperti Daud, orang seperti Rob yang di dalamnya

861
00:46:41,000 --> 00:46:46,000
atau encapsulating adalah nama dan ID dan rumah.

862
00:46:46,000 --> 00:46:49,000
>> Bisakah kita entah bagaimana mengekspresikan ide enkapsulasi

863
00:46:49,000 --> 00:46:52,000
dimana seseorang memiliki ID, nama dan rumah

864
00:46:52,000 --> 00:46:55,000
dan tidak resor untuk benar-benar hack ini dimana kita hanya

865
00:46:55,000 --> 00:46:58,000
percaya bahwa sesuatu braket

866
00:46:58,000 --> 00:47:02,000
mengacu pada entitas manusia yang sama di masing-masing array yang berbeda?

867
00:47:02,000 --> 00:47:04,000
Kami benar-benar bisa melakukan ini.

868
00:47:04,000 --> 00:47:08,000
Biarkan aku pergi di atas utama untuk saat ini, dan biarkan aku membuat tipe sendiri Data

869
00:47:08,000 --> 00:47:10,000
untuk benar-benar pertama kalinya.

870
00:47:10,000 --> 00:47:14,000
Kami menggunakan teknik ini dalam Scramble,

871
00:47:14,000 --> 00:47:17,000
tapi di sini aku akan pergi ke depan dan menciptakan tipe data,

872
00:47:17,000 --> 00:47:19,000
dan kau tahu apa, aku akan menyebutnya siswa atau orang,

873
00:47:19,000 --> 00:47:23,000
dan aku akan menggunakan typedef untuk mendefinisikan tipe.

874
00:47:23,000 --> 00:47:25,000
Aku akan mengatakan bahwa ini adalah struktur,

875
00:47:25,000 --> 00:47:29,000
dan kemudian struktur ini akan menjadi siswa jenis, kita akan mengatakan,

876
00:47:29,000 --> 00:47:31,000
meskipun itu sedikit tanggal sekarang bagi saya.

877
00:47:31,000 --> 00:47:33,000
Kami akan mengatakan "int id."

878
00:47:33,000 --> 00:47:35,000
Kami akan mengatakan "string name."

879
00:47:35,000 --> 00:47:37,000
Kemudian kita akan mengatakan "Rumah string,"

880
00:47:37,000 --> 00:47:40,000
jadi sekarang pada akhir dari beberapa baris kode

881
00:47:40,000 --> 00:47:45,000
Saya baru saja mengajarkan dentang bahwa ada

882
00:47:45,000 --> 00:47:49,000
tipe data selain ints, selain string, selain ganda, selain mengapung.

883
00:47:49,000 --> 00:47:54,000
>> Sampai saat ini dalam garis waktu 11, sekarang ada tipe data baru yang disebut mahasiswa,

884
00:47:54,000 --> 00:47:58,000
dan sekarang saya bisa mendeklarasikan variabel mahasiswa mana saja aku ingin,

885
00:47:58,000 --> 00:48:01,000
jadi biar scroll ke bawah sini untuk orang.

886
00:48:01,000 --> 00:48:05,000
Sekarang saya bisa menyingkirkan ini, dan saya bisa kembali ke sini David,

887
00:48:05,000 --> 00:48:10,000
dan untuk David saya benar-benar dapat mengatakan bahwa David,

888
00:48:10,000 --> 00:48:13,000
kita benar-benar dapat nama variabel setelah diriku sendiri,

889
00:48:13,000 --> 00:48:16,000
akan menjadi mahasiswa tipe.

890
00:48:16,000 --> 00:48:18,000
Ini mungkin terlihat sedikit aneh, tapi ini tidak semua yang berbeda

891
00:48:18,000 --> 00:48:22,000
dari menyatakan sesuatu sebagai int atau string atau pelampung.

892
00:48:22,000 --> 00:48:24,000
Kebetulan dipanggil mahasiswa sekarang,

893
00:48:24,000 --> 00:48:28,000
dan jika saya ingin menempatkan sesuatu di dalam struktur ini

894
00:48:28,000 --> 00:48:31,000
Saya sekarang harus menggunakan sepotong baru sintaks, tapi itu cukup sederhana,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" di ibukota D,

896
00:48:39,000 --> 00:48:42,000
dan david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
dan sekarang saya bisa menyingkirkan barang-barang ini di sini.

898
00:48:46,000 --> 00:48:51,000
Pemberitahuan sekarang kami telah didesain ulang program kami di benar-benar cara yang lebih baik

899
00:48:51,000 --> 00:48:54,000
dalam program kami sekarang mencerminkan dunia nyata.

900
00:48:54,000 --> 00:48:57,000
>> Ada gagasan dunia nyata dari seseorang atau mahasiswa.

901
00:48:57,000 --> 00:49:02,000
Di sini kita miliki sekarang versi C dari seseorang atau lebih khusus mahasiswa.

902
00:49:02,000 --> 00:49:05,000
Di dalam orang yang karakteristik yang relevan,

903
00:49:05,000 --> 00:49:10,000
ID, nama dan rumah, sehingga Rob dasarnya menjadi hal yang sama di sini,

904
00:49:10,000 --> 00:49:14,000
sehingga mahasiswa rob, dan sekarang rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob."

906
00:49:17,000 --> 00:49:20,000
Fakta bahwa variabel disebut Rob adalah semacam berarti.

907
00:49:20,000 --> 00:49:22,000
Kita bisa menyebutnya x atau y atau z.

908
00:49:22,000 --> 00:49:25,000
Kami hanya menamakannya Rob menjadi semantis konsisten,

909
00:49:25,000 --> 00:49:28,000
tapi benar-benar nama adalah dalam bidang tersebut sendiri,

910
00:49:28,000 --> 00:49:30,000
jadi sekarang aku punya ini.

911
00:49:30,000 --> 00:49:33,000
Hal ini juga tidak merasa seperti desain terbaik dalam bahwa saya telah keras kode David.

912
00:49:33,000 --> 00:49:35,000
Saya sudah keras kode Rob.

913
00:49:35,000 --> 00:49:39,000
Dan aku masih harus resor untuk copy dan paste beberapa setiap kali saya ingin variabel baru.

914
00:49:39,000 --> 00:49:43,000
Selain itu, saya harus memberikan rupanya masing-masing variabel nama,

915
00:49:43,000 --> 00:49:46,000
meskipun saya lebih suka mendeskripsikan variabel-variabel

916
00:49:46,000 --> 00:49:48,000
 lebih umum sebagai siswa.

917
00:49:48,000 --> 00:49:52,000
>> Sekarang kita dapat menggabungkan ide-ide yang telah bekerja dengan baik bagi kami

918
00:49:52,000 --> 00:49:56,000
dan bukannya mengatakan, "Kau tahu apa, beri saya siswa disebut variabel,

919
00:49:56,000 --> 00:50:01,000
dan mari kita memilikinya menjadi ukuran 3, "jadi sekarang aku bisa memperbaiki ini lebih lanjut,

920
00:50:01,000 --> 00:50:04,000
menyingkirkan David manual menyatakan,

921
00:50:04,000 --> 00:50:08,000
dan saya malah dapat mengatakan sesuatu seperti siswa [0] di sini.

922
00:50:08,000 --> 00:50:11,000
Saya kemudian bisa mengatakan siswa [0] di sini,

923
00:50:11,000 --> 00:50:14,000
siswa [0] di sini, dan sebagainya, dan aku bisa pergi sekitar

924
00:50:14,000 --> 00:50:16,000
dan membersihkan bahwa untuk Rob.

925
00:50:16,000 --> 00:50:19,000
Saya juga bisa pergi tentang sekarang mungkin menambahkan loop

926
00:50:19,000 --> 00:50:23,000
dan menggunakan GetString dan GetInt untuk benar-benar mendapatkan nilai-nilai dari pengguna.

927
00:50:23,000 --> 00:50:27,000
Aku bisa pergi tentang menambahkan konstan karena ini umumnya praktik buruk

928
00:50:27,000 --> 00:50:29,000
untuk kode keras beberapa nomor sewenang-wenang seperti 3 di sini

929
00:50:29,000 --> 00:50:33,000
dan kemudian hanya ingat bahwa Anda harus menempatkan tidak lebih dari 3 siswa di dalamnya.

930
00:50:33,000 --> 00:50:36,000
Mungkin akan lebih baik untuk menggunakan # define di bagian atas file saya

931
00:50:36,000 --> 00:50:40,000
dan faktor yang keluar, sehingga memang, biarkan aku pergi ke depan dan generalisasi ini.

932
00:50:40,000 --> 00:50:43,000
>> Mari saya membuka sebuah contoh yang salah hari ini

933
00:50:43,000 --> 00:50:46,000
contoh di muka, structs1.

934
00:50:46,000 --> 00:50:49,000
Ini merupakan program yang lebih lengkap yang menggunakan # define di sini

935
00:50:49,000 --> 00:50:51,000
dan mengatakan kita akan memiliki 3 siswa secara default.

936
00:50:51,000 --> 00:50:54,000
Di sini saya menyatakan senilai kelas siswa,

937
00:50:54,000 --> 00:50:57,000
sehingga kelas siswa, dan sekarang saya menggunakan loop

938
00:50:57,000 --> 00:51:00,000
hanya untuk membuat kode sedikit lebih elegan, mengisi kelas

939
00:51:00,000 --> 00:51:05,000
dengan input pengguna, jadi iterate dari i = 0 pada hingga mahasiswa, yaitu 3.

940
00:51:05,000 --> 00:51:07,000
Dan kemudian saya meminta pengguna dalam versi ini

941
00:51:07,000 --> 00:51:10,000
 apa ID siswa, dan saya mendapatkannya dengan GetInt.

942
00:51:10,000 --> 00:51:13,000
Siapa nama siswa, dan kemudian saya mendapatkannya dengan GetString.

943
00:51:13,000 --> 00:51:15,000
Apa rumah siswa? Saya mendapatkannya dengan GetString.

944
00:51:15,000 --> 00:51:19,000
Dan kemudian di bagian bawah di sini saya hanya memutuskan untuk mengubah

945
00:51:19,000 --> 00:51:22,000
bagaimana aku mencetak tersebut keluar dan benar-benar menggunakan loop,

946
00:51:22,000 --> 00:51:24,000
dan yang saya mencetak?

947
00:51:24,000 --> 00:51:27,000
Menurut komentar saya mencetak siapa pun di Mather,

948
00:51:27,000 --> 00:51:30,000
dan itu begitu Rob dan Tommy dan sebagainya-sebenarnya Tommy di Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy dan David akan dicetak dalam kasus ini, tapi bagaimana ini bekerja?

950
00:51:34,000 --> 00:51:40,000
Kami belum melihat fungsi ini sebelumnya, tetapi mengambil menebak untuk apa hal ini.

951
00:51:40,000 --> 00:51:42,000
Membandingkan string.

952
00:51:42,000 --> 00:51:45,000
>> Ini agak tidak jelas bagaimana membandingkan string karena ternyata

953
00:51:45,000 --> 00:51:49,000
jika ia mengembalikan 0 yang berarti string adalah sama.

954
00:51:49,000 --> 00:51:53,000
Jika ia mengembalikan -1 yang berarti satu abjad datang sebelum yang lain,

955
00:51:53,000 --> 00:51:57,000
dan jika ia mengembalikan +1 yang berarti kata lain datang abjad

956
00:51:57,000 --> 00:52:00,000
sebelum yang lain, dan Anda dapat melihat secara online atau di halaman manual

957
00:52:00,000 --> 00:52:04,000
untuk melihat secara tepat jalan mana mana, tapi semua ini lakukan sekarang ini itu mengatakan

958
00:52:04,000 --> 00:52:09,000
jika [i]. rumah adalah sama dengan "Mather"

959
00:52:09,000 --> 00:52:13,000
kemudian pergi ke depan dan mencetak begitu dan begitu berada di Mather.

960
00:52:13,000 --> 00:52:16,000
Tapi di sini sesuatu yang kita belum melihat sebelumnya, dan kami akan kembali ke ini.

961
00:52:16,000 --> 00:52:21,000
Saya tidak ingat pernah memiliki untuk melakukan hal ini dalam salah satu program saya.

962
00:52:21,000 --> 00:52:24,000
Gratis ini rupanya mengacu pada memori, membebaskan memori,

963
00:52:24,000 --> 00:52:31,000
tapi apa memori saya tampaknya membebaskan dalam lingkaran ini di bagian bawah program ini?

964
00:52:31,000 --> 00:52:34,000
Sepertinya aku membebaskan nama seseorang

965
00:52:34,000 --> 00:52:37,000
dan rumah seseorang, tapi kenapa begitu?

966
00:52:37,000 --> 00:52:41,000
>> Ternyata semua minggu yang Anda telah menggunakan GetString

967
00:52:41,000 --> 00:52:45,000
kita jenis telah memperkenalkan bug ke dalam setiap salah satu dari program Anda.

968
00:52:45,000 --> 00:52:51,000
GetString oleh memori desain mengalokasikan sehingga bisa kembali kepada Anda string,

969
00:52:51,000 --> 00:52:55,000
seperti Daud, atau Rob, dan Anda kemudian dapat melakukan apapun yang Anda inginkan

970
00:52:55,000 --> 00:52:59,000
dengan string dalam program anda karena kami telah disediakan memori untuk Anda.

971
00:52:59,000 --> 00:53:02,000
Masalahnya adalah selama ini setiap kali Anda menelepon GetString

972
00:53:02,000 --> 00:53:05,000
kita, penulis GetString, telah meminta sistem operasi

973
00:53:05,000 --> 00:53:07,000
untuk memberi kami sedikit RAM untuk string ini.

974
00:53:07,000 --> 00:53:09,000
Beri kami sedikit RAM untuk string berikutnya.

975
00:53:09,000 --> 00:53:11,000
Beri kami RAM lagi untuk string berikutnya.

976
00:53:11,000 --> 00:53:13,000
Apa yang Anda, programmer, belum pernah melakukan

977
00:53:13,000 --> 00:53:15,000
memberikan kita itu kembali memori,

978
00:53:15,000 --> 00:53:17,000
jadi untuk beberapa minggu ini semua program yang sudah Anda tulis

979
00:53:17,000 --> 00:53:20,000
memiliki apa yang disebut lompatan memori dimana mereka tetap menggunakan

980
00:53:20,000 --> 00:53:24,000
memori lebih dan lebih setiap kali Anda menelepon GetString, dan itu baik-baik saja.

981
00:53:24,000 --> 00:53:27,000
Kami sengaja melakukan itu pada minggu-minggu pertama karena itu tidak menarik

982
00:53:27,000 --> 00:53:29,000
harus khawatir tentang di mana string berasal.

983
00:53:29,000 --> 00:53:34,000
Semua yang Anda inginkan adalah kata Rob kembali bila pengguna jenis itu masuk

984
00:53:34,000 --> 00:53:38,000
>> Tapi bergerak maju sekarang kita harus mulai mendapatkan lebih canggih tentang hal ini.

985
00:53:38,000 --> 00:53:42,000
Setiap kali kita mengalokasikan memori lebih baik kita akhirnya menyerahkannya kembali.

986
00:53:42,000 --> 00:53:45,000
Jika di dunia nyata pada Mac atau PC Anda mungkin memiliki sesekali mengalami

987
00:53:45,000 --> 00:53:50,000
gejala di mana komputer Anda adalah penggilingan berhenti pada akhirnya

988
00:53:50,000 --> 00:53:54,000
atau bola pantai bodoh berputar hanya menempati komputer

989
00:53:54,000 --> 00:53:56,000
seluruh perhatian dan Anda tidak bisa melakukan hal-hal.

990
00:53:56,000 --> 00:54:00,000
Yang dapat dijelaskan oleh sejumlah bug, tetapi di antara mereka kemungkinan bug

991
00:54:00,000 --> 00:54:03,000
adalah hal-hal yang disebut kebocoran memori dimana seseorang yang menulis bahwa software

992
00:54:03,000 --> 00:54:07,000
Anda menggunakan tidak ingat untuk membebaskan memori

993
00:54:07,000 --> 00:54:10,000
bahwa ia meminta sistem operasi untuk,

994
00:54:10,000 --> 00:54:14,000
tidak menggunakan GetString, karena itu hal yang CS50, tetapi menggunakan fungsi yang sama

995
00:54:14,000 --> 00:54:16,000
yang meminta sistem operasi untuk memori.

996
00:54:16,000 --> 00:54:19,000
Jika Anda atau mereka mengacaukan dan tidak pernah benar-benar kembali memori yang

997
00:54:19,000 --> 00:54:24,000
merupakan gejala yang dapat bahwa program melambat dan memperlambat dan memperlambat

998
00:54:24,000 --> 00:54:26,000
kecuali Anda ingat untuk panggilan gratis.

999
00:54:26,000 --> 00:54:28,000
>> Kami akan kembali ke kapan dan mengapa Anda akan panggilan gratis,

1000
00:54:28,000 --> 00:54:32,000
tapi mari kita pergi ke depan hanya untuk mengukur baik dan mencoba menjalankan program tertentu.

1001
00:54:32,000 --> 00:54:35,000
Ini disebut structs1, masukkan.

1002
00:54:35,000 --> 00:54:40,000
Biarkan aku pergi ke depan dan menjalankan structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, dan kita melihat David di Mather, Tommy di Mather.

1005
00:54:50,000 --> 00:54:53,000
Ini hanya cek kewarasan sedikit bahwa program ini bekerja.

1006
00:54:53,000 --> 00:54:56,000
Sekarang, sayangnya, program ini adalah sedikit frustrasi dalam

1007
00:54:56,000 --> 00:55:00,000
Saya melakukan semua pekerjaan itu, saya mengetik 9 string yang berbeda, tekan enter,

1008
00:55:00,000 --> 00:55:04,000
diberitahu yang berada di Mather, namun jelas saya tahu yang berada di Mather sudah karena saya mengetik itu.

1009
00:55:04,000 --> 00:55:07,000
Ini akan setidaknya baik jika program ini adalah lebih seperti database

1010
00:55:07,000 --> 00:55:10,000
dan itu benar-benar ingat apa yang saya telah mengetik

1011
00:55:10,000 --> 00:55:12,000
jadi saya tidak lagi harus memasukkan catatan siswa.

1012
00:55:12,000 --> 00:55:15,000
Mungkin seperti sistem registrarial.

1013
00:55:15,000 --> 00:55:21,000
>> Kita bisa melakukan ini dengan menggunakan teknik ini dikenal sebagai file I / O, file input dan output,

1014
00:55:21,000 --> 00:55:24,000
cara yang sangat generik mengatakan setiap kali Anda ingin membaca file atau menulis file

1015
00:55:24,000 --> 00:55:26,000
Anda dapat melakukan ini dengan satu set tertentu dari fungsi.

1016
00:55:26,000 --> 00:55:29,000
Biarkan aku pergi ke depan dan membuka structs2.c contoh,

1017
00:55:29,000 --> 00:55:33,000
yang hampir sama, tapi mari kita lihat apa yang dilakukannya sekarang.

1018
00:55:33,000 --> 00:55:36,000
Pada bagian atas file saya menyatakan kelas siswa.

1019
00:55:36,000 --> 00:55:38,000
Saya kemudian mengisi kelas dengan input pengguna,

1020
00:55:38,000 --> 00:55:41,000
sehingga mereka baris kode yang persis seperti sebelumnya.

1021
00:55:41,000 --> 00:55:45,000
Lalu jika saya scroll ke bawah di sini saya mencetak semua orang yang ada di Mather sewenang-wenang seperti sebelumnya,

1022
00:55:45,000 --> 00:55:47,000
tapi ini adalah fitur baru yang menarik.

1023
00:55:47,000 --> 00:55:51,000
Ini baris kode yang baru, dan mereka memperkenalkan sesuatu di sini,

1024
00:55:51,000 --> 00:55:55,000
FILE, semua topi, dan memiliki * di sini juga.

1025
00:55:55,000 --> 00:55:58,000
Biarkan saya bergerak ini di sini, * di atas sini juga.

1026
00:55:58,000 --> 00:56:00,000
>> Fungsi ini kita belum melihat sebelumnya, fopen,

1027
00:56:00,000 --> 00:56:03,000
tapi itu berarti file yang terbuka, jadi mari kita skim melalui,

1028
00:56:03,000 --> 00:56:05,000
dan ini adalah sesuatu yang kita akan kembali ke dalam psets masa depan,

1029
00:56:05,000 --> 00:56:10,000
namun baris ini di sini pada dasarnya membuka sebuah file yang bernama database,

1030
00:56:10,000 --> 00:56:13,000
dan secara khusus membuka sedemikian rupa sehingga dapat melakukan apa untuk itu?

1031
00:56:13,000 --> 00:56:15,000
[Tak terdengar-murid]

1032
00:56:15,000 --> 00:56:19,000
Benar, jadi "w" hanya berarti itu mengatakan sistem operasi

1033
00:56:19,000 --> 00:56:21,000
buka file ini sedemikian rupa sehingga saya bisa menulis untuk itu.

1034
00:56:21,000 --> 00:56:23,000
Saya tidak ingin membacanya. Saya tidak ingin hanya melihat itu.

1035
00:56:23,000 --> 00:56:26,000
Saya ingin mengubah dan menambahkan hal-hal yang berpotensi untuk itu,

1036
00:56:26,000 --> 00:56:28,000
dan file tersebut akan disebut database.

1037
00:56:28,000 --> 00:56:30,000
Ini bisa disebut apa-apa.

1038
00:56:30,000 --> 00:56:32,000
Ini bisa menjadi database.txt. Ini bisa jadi. Db.

1039
00:56:32,000 --> 00:56:37,000
Ini bisa menjadi kata seperti foo, tapi saya sewenang-wenang memilih untuk nama file database.

1040
00:56:37,000 --> 00:56:42,000
Ini adalah cek kewarasan kecil yang kita akan kembali ke dalam rinci dari waktu ke waktu,

1041
00:56:42,000 --> 00:56:47,000
jika fp, untuk pointer file, tidak NULL sama yang berarti semuanya baik-baik.

1042
00:56:47,000 --> 00:56:51,000
>> Singkat cerita, fungsi seperti fopen kadang-kadang gagal.

1043
00:56:51,000 --> 00:56:53,000
Mungkin file tidak ada. Mungkin Anda keluar dari ruang disk.

1044
00:56:53,000 --> 00:56:55,000
Mungkin Anda tidak memiliki izin untuk folder itu,

1045
00:56:55,000 --> 00:56:58,000
jadi jika fopen kembali sesuatu yang buruk terjadi nol.

1046
00:56:58,000 --> 00:57:02,000
Sebaliknya, jika fopen tidak kembali nol semua baik

1047
00:57:02,000 --> 00:57:04,000
dan saya bisa mulai menulis ke file ini.

1048
00:57:04,000 --> 00:57:06,000
Berikut ini adalah trik baru.

1049
00:57:06,000 --> 00:57:08,000
Ini adalah sebuah loop untuk iterasi yang masing-masing mahasiswa saya,

1050
00:57:08,000 --> 00:57:10,000
dan ini terlihat sangat mirip dengan apa yang kami lakukan sebelumnya,

1051
00:57:10,000 --> 00:57:15,000
namun fungsi ini adalah sepupu dari printf disebut fprintf untuk file printf,

1052
00:57:15,000 --> 00:57:18,000
dan perhatikan itu berbeda hanya dalam 2 cara.

1053
00:57:18,000 --> 00:57:20,000
Satu, itu dimulai dengan f bukan p,

1054
00:57:20,000 --> 00:57:23,000
tapi kemudian argumen pertama ternyata apa?

1055
00:57:23,000 --> 00:57:25,000
[Siswa] file. >> Ini file.

1056
00:57:25,000 --> 00:57:30,000
Hal ini disebut fp, yang pada akhirnya kita akan menggoda selain apa pointer file,

1057
00:57:30,000 --> 00:57:35,000
tapi untuk saat ini fp hanya merupakan file yang saya telah dibuka,

1058
00:57:35,000 --> 00:57:41,000
sehingga fprintf sini mengatakan cetak ID pengguna ini ke file, bukan ke layar.

1059
00:57:41,000 --> 00:57:44,000
Cetak nama pengguna ke file, bukan ke layar,

1060
00:57:44,000 --> 00:57:47,000
rumah ke file tersebut, bukan ke layar, dan kemudian turun di sini, jelas,

1061
00:57:47,000 --> 00:57:50,000
menutup file, dan kemudian turun di sini gratis memori.

1062
00:57:50,000 --> 00:57:53,000
>> Satu-satunya perbedaan antara versi 2 dan versi 1

1063
00:57:53,000 --> 00:57:58,000
adalah pengenalan fopen dan ini FILE dengan *

1064
00:57:58,000 --> 00:58:01,000
dan ini gagasan fprintf, jadi mari kita lihat apa hasil akhirnya adalah.

1065
00:58:01,000 --> 00:58:03,000
Biarkan aku pergi ke jendela terminal saya.

1066
00:58:03,000 --> 00:58:06,000
Biarkan saya jalankan structs2, masukkan.

1067
00:58:06,000 --> 00:58:09,000
Sepertinya semuanya baik-baik. Mari kita jalankan kembali structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Mather, masukkan.

1070
00:58:19,000 --> 00:58:23,000
Tampak seperti itu berperilaku sama, tetapi jika aku lakukan sekarang ls

1071
00:58:23,000 --> 00:58:28,000
perhatikan apa file di sini antara semua kode saya, database,

1072
00:58:28,000 --> 00:58:32,000
jadi mari kita buka, gedit database, dan melihat itu.

1073
00:58:32,000 --> 00:58:34,000
Ini bukan terseksi dari format file.

1074
00:58:34,000 --> 00:58:38,000
Ini benar-benar adalah salah satu bagian dari baris data per baris per baris,

1075
00:58:38,000 --> 00:58:42,000
namun anda yang menggunakan file Excel atau CSV, nilai terpisah koma,

1076
00:58:42,000 --> 00:58:47,000
Aku pasti bisa menggunakan fprintf untuk bukan mungkin melakukan sesuatu seperti ini

1077
00:58:47,000 --> 00:58:50,000
sehingga saya benar-benar bisa menciptakan setara dari file Excel

1078
00:58:50,000 --> 00:58:53,000
dengan memisahkan hal-hal dengan koma, bukan hanya baris baru.

1079
00:58:53,000 --> 00:58:56,000
>> Dalam hal ini jika aku malah digunakan koma bukan baris baru

1080
00:58:56,000 --> 00:59:01,000
Aku benar-benar bisa membuka file database di Excel jika saya bukan membuatnya terlihat seperti ini.

1081
00:59:01,000 --> 00:59:03,000
Singkatnya, sekarang bahwa kita memiliki kekuatan untuk menulis ke file

1082
00:59:03,000 --> 00:59:07,000
sekarang kita dapat mulai data yang bertahan, menjaga di sekitar pada disk

1083
00:59:07,000 --> 00:59:10,000
sehingga kita dapat menyimpan informasi sekitar lagi dan lagi.

1084
00:59:10,000 --> 00:59:14,000
Perhatikan beberapa hal lain yang sekarang sedikit lebih akrab.

1085
00:59:14,000 --> 00:59:16,000
Pada bagian atas file ini C kita memiliki typedef

1086
00:59:16,000 --> 00:59:21,000
karena kami ingin menciptakan sebuah tipe data yang mewakili kata,

1087
00:59:21,000 --> 00:59:25,000
sehingga jenis ini disebut kata, dan dalam struktur ini

1088
00:59:25,000 --> 00:59:27,000
itu sedikit lebih menarik sekarang.

1089
00:59:27,000 --> 00:59:30,000
Mengapa kata terdiri dari tampaknya array?

1090
00:59:30,000 --> 00:59:33,000
Apa kata hanya intuitif?

1091
00:59:33,000 --> 00:59:35,000
>> Ini adalah array karakter.

1092
00:59:35,000 --> 00:59:37,000
Ini adalah urutan karakter kembali ke belakang ke belakang.

1093
00:59:37,000 --> 00:59:41,000
SURAT dalam semua topi kebetulan kita sewenang-wenang mengatakan panjang maksimum

1094
00:59:41,000 --> 00:59:44,000
dari setiap kata dalam kamus yang kita gunakan untuk Scramble.

1095
00:59:44,000 --> 00:59:46,000
Mengapa saya memiliki +1?

1096
00:59:46,000 --> 00:59:48,000
Karakter null.

1097
00:59:48,000 --> 00:59:51,000
Ingatlah ketika kita melakukan contoh Bananagrams kami membutuhkan nilai khusus

1098
00:59:51,000 --> 00:59:55,000
pada akhir kata untuk melacak

1099
00:59:55,000 --> 00:59:59,000
dari mana kata-kata benar-benar berakhir, dan sebagai spesifikasi sejumlah masalah mengatakan

1100
00:59:59,000 --> 01:00:03,000
di sini kita bergaul dengan kata yang diberikan nilai boolean,

1101
01:00:03,000 --> 01:00:05,000
bendera, sehingga untuk berbicara, benar atau salah.

1102
01:00:05,000 --> 01:00:09,000
Apakah Anda menemukan kata ini sudah, karena kami menyadari

1103
01:00:09,000 --> 01:00:13,000
kita benar-benar membutuhkan cara mengingat tidak hanya apa kata dalam Scramble

1104
01:00:13,000 --> 01:00:15,000
tapi apakah atau tidak Anda, manusia, telah menemukan itu

1105
01:00:15,000 --> 01:00:20,000
sehingga jika Anda menemukan kata "yang" Anda tidak bisa hanya mengetik, masuk,, masuk,, masukkan

1106
01:00:20,000 --> 01:00:23,000
dan mendapatkan 3 poin, 3 poin, 3 poin, 3 poin.

1107
01:00:23,000 --> 01:00:26,000
Kami ingin bisa di blacklist kata itu dengan menetapkan bool

1108
01:00:26,000 --> 01:00:29,000
true jika Anda sudah menemukannya, dan jadi itu sebabnya kita

1109
01:00:29,000 --> 01:00:31,000
dikemas dalam struktur ini.

1110
01:00:31,000 --> 01:00:35,000
>> Sekarang, di sini di Scramble ada ini struct lain yang disebut kamus.

1111
01:00:35,000 --> 01:00:39,000
Absen di sini adalah kata typedef karena dalam kasus ini

1112
01:00:39,000 --> 01:00:43,000
kami perlu untuk merangkum gagasan kamus,

1113
01:00:43,000 --> 01:00:46,000
dan kamus berisi sejumlah kata-kata,

1114
01:00:46,000 --> 01:00:49,000
seperti yang tersirat oleh array ini, dan berapa banyak dari kata-kata yang ada?

1115
01:00:49,000 --> 01:00:51,000
Nah, apa pun ukuran ini disebut variabel kata.

1116
01:00:51,000 --> 01:00:53,000
Tapi kami hanya perlu satu kamus.

1117
01:00:53,000 --> 01:00:55,000
Kita tidak membutuhkan tipe data yang disebut kamus.

1118
01:00:55,000 --> 01:00:58,000
Kita hanya perlu salah satu dari mereka, jadi ternyata di C

1119
01:00:58,000 --> 01:01:03,000
bahwa jika Anda tidak mengatakan typedef, Anda hanya mengatakan struct, kemudian di dalam kurung kurawal

1120
01:01:03,000 --> 01:01:05,000
Anda menempatkan variabel Anda, maka Anda menempatkan nama.

1121
01:01:05,000 --> 01:01:09,000
Hal ini menyatakan salah satu variabel yang disebut kamus

1122
01:01:09,000 --> 01:01:11,000
yang terlihat seperti ini.

1123
01:01:11,000 --> 01:01:16,000
Sebaliknya, garis-garis ini menciptakan struktur data dapat digunakan kembali disebut kata

1124
01:01:16,000 --> 01:01:19,000
bahwa Anda dapat membuat beberapa salinan, seperti yang kita buat

1125
01:01:19,000 --> 01:01:22,000
beberapa salinan siswa.

1126
01:01:22,000 --> 01:01:24,000
>> Apa artinya ini pada akhirnya memungkinkan kita untuk melakukan?

1127
01:01:24,000 --> 01:01:30,000
Biarkan aku pergi kembali ke, katakanlah, contoh sederhana dari zaman sederhana,

1128
01:01:30,000 --> 01:01:34,000
dan biarkan aku membuka, katakanlah, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Masalahnya di sini di tangan adalah untuk benar-benar mengupas

1130
01:01:38,000 --> 01:01:41,000
lapisan string dan mulai melepas roda pelatihan ini

1131
01:01:41,000 --> 01:01:44,000
karena ternyata string sepanjang waktu ini

1132
01:01:44,000 --> 01:01:47,000
adalah seperti yang kita dijanjikan dalam minggu 1 benar-benar hanya nama panggilan,

1133
01:01:47,000 --> 01:01:51,000
sinonim dari perpustakaan CS50 untuk sesuatu yang terlihat sedikit lebih samar,

1134
01:01:51,000 --> 01:01:53,000
char *, dan kita telah melihat bintang ini sebelumnya.

1135
01:01:53,000 --> 01:01:55,000
Kami melihatnya dalam konteks file.

1136
01:01:55,000 --> 01:01:59,000
>> Mari kita sekarang melihat mengapa kita telah menyembunyikan detail ini untuk beberapa waktu sekarang.

1137
01:01:59,000 --> 01:02:02,000
Berikut ini adalah sebuah file yang bernama compare1.c,

1138
01:02:02,000 --> 01:02:07,000
dan itu tampaknya meminta pengguna untuk 2 string, s dan t,

1139
01:02:07,000 --> 01:02:11,000
dan kemudian mencoba untuk membandingkan string untuk kesetaraan di baris 26,

1140
01:02:11,000 --> 01:02:14,000
dan jika mereka sama dikatakan, "Anda mengetik hal yang sama,"

1141
01:02:14,000 --> 01:02:17,000
dan jika mereka tidak sama dikatakan, "Anda mengetik hal yang berbeda."

1142
01:02:17,000 --> 01:02:19,000
Biarkan aku pergi ke depan dan menjalankan program ini.

1143
01:02:19,000 --> 01:02:23,000
Biarkan aku pergi ke direktori sumber saya, membuat compare1 a. Dikompilasi oke.

1144
01:02:23,000 --> 01:02:25,000
Biarkan saya menjalankan compare1.

1145
01:02:25,000 --> 01:02:27,000
Saya akan memperbesar, masukkan.

1146
01:02:27,000 --> 01:02:29,000
Katakan sesuatu. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Aku akan mengatakan sesuatu lagi. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Saya pasti tidak mengetik hal yang berbeda.

1149
01:02:34,000 --> 01:02:37,000
>> Mari saya coba ini lagi. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Jelas tidak berbeda, jadi apa yang terjadi di sini?

1151
01:02:40,000 --> 01:02:44,000
Nah, apa yang sebenarnya sedang dibandingkan di baris 26?

1152
01:02:44,000 --> 01:02:46,000
[Tak terdengar-murid]

1153
01:02:46,000 --> 01:02:49,000
Ya, jadi ternyata string, tipe data, adalah jenis kebohongan putih.

1154
01:02:49,000 --> 01:02:53,000
Sebuah string adalah char *, tapi apa adalah char *?

1155
01:02:53,000 --> 01:02:56,000
Sebuah char *, seperti yang mereka katakan, adalah pointer,

1156
01:02:56,000 --> 01:03:00,000
dan pointer secara efektif alamat,

1157
01:03:00,000 --> 01:03:05,000
lokasi sum dalam memori, dan jika Anda kebetulan telah mengetik kata seperti HELLO,

1158
01:03:05,000 --> 01:03:08,000
ingat dari diskusi masa lalu string

1159
01:03:08,000 --> 01:03:16,000
ini seperti kata HELLO.

1160
01:03:16,000 --> 01:03:19,000
Ingatlah bahwa kata seperti HELLO dapat direpresentasikan

1161
01:03:19,000 --> 01:03:22,000
sebagai array dari karakter seperti ini

1162
01:03:22,000 --> 01:03:25,000
dan kemudian dengan karakter khusus pada akhirnya disebut karakter null,

1163
01:03:25,000 --> 01:03:27,000
sebagai menandakan \.

1164
01:03:27,000 --> 01:03:29,000
Apa yang sebenarnya string?

1165
01:03:29,000 --> 01:03:32,000
Perhatikan bahwa ini adalah beberapa bagian dari memori,

1166
01:03:32,000 --> 01:03:36,000
dan pada kenyataannya, akhir itu hanya dikenal setelah Anda melihat melalui seluruh string

1167
01:03:36,000 --> 01:03:38,000
mencari karakter null khusus.

1168
01:03:38,000 --> 01:03:41,000
Tapi jika ini adalah sepotong memori dari memori komputer saya,

1169
01:03:41,000 --> 01:03:44,000
mari kita sewenang-wenang mengatakan bahwa string ini hanya beruntung,

1170
01:03:44,000 --> 01:03:47,000
dan itu bisa ditempatkan di awal RAM komputer saya.

1171
01:03:47,000 --> 01:03:54,000
Ini adalah byte 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Ketika saya mengatakan sesuatu seperti GetString dan saya lakukan string s = GetString

1173
01:04:02,000 --> 01:04:04,000
apa yang sebenarnya dikembalikan?

1174
01:04:04,000 --> 01:04:08,000
Untuk beberapa minggu terakhir, apa yang sebenarnya disimpan di s

1175
01:04:08,000 --> 01:04:13,000
bukan string per se, tetapi dalam kasus ini apa yang disimpan adalah

1176
01:04:13,000 --> 01:04:18,000
angka 0 karena apa sebenarnya GetString

1177
01:04:18,000 --> 01:04:20,000
yang tidak secara fisik kembali string.

1178
01:04:20,000 --> 01:04:22,000
Itu bahkan tidak benar-benar masuk akal konseptual.

1179
01:04:22,000 --> 01:04:24,000
Apa yang kembali adalah nomor.

1180
01:04:24,000 --> 01:04:28,000
Angka itu adalah alamat dari HELLO di memori,

1181
01:04:28,000 --> 01:04:32,000
dan string s kemudian, jika kita mengupas lapisan ini, string tidak benar-benar ada.

1182
01:04:32,000 --> 01:04:35,000
Ini hanya penyederhanaan dalam perpustakaan CS50.

1183
01:04:35,000 --> 01:04:38,000
>> Ini benar-benar adalah sesuatu yang disebut * char.

1184
01:04:38,000 --> 01:04:41,000
Char masuk akal karena apa kata, seperti HALO?

1185
01:04:41,000 --> 01:04:44,000
Nah, itu adalah serangkaian karakter, serangkaian karakter.

1186
01:04:44,000 --> 01:04:47,000
* Char berarti alamat karakter,

1187
01:04:47,000 --> 01:04:50,000
jadi apa artinya untuk mengembalikan string?

1188
01:04:50,000 --> 01:04:53,000
A, baik cara sederhana untuk kembali string

1189
01:04:53,000 --> 01:04:57,000
ini daripada mencoba untuk mencari tahu bagaimana saya kembali ke 5 atau 6 byte yang berbeda

1190
01:04:57,000 --> 01:05:01,000
biarkan aku kembali ke alamat yang byte?

1191
01:05:01,000 --> 01:05:03,000
Yang pertama.

1192
01:05:03,000 --> 01:05:06,000
Dengan kata lain, izinkan saya memberi Anda alamat sebuah karakter dalam memori.

1193
01:05:06,000 --> 01:05:10,000
Itulah yang char * mewakili, alamat satu karakter tunggal dalam memori.

1194
01:05:10,000 --> 01:05:12,000
Menyebut bahwa variabel s.

1195
01:05:12,000 --> 01:05:15,000
Store di s alamat tertentu, yang saya katakan adalah sewenang-wenang 0,

1196
01:05:15,000 --> 01:05:19,000
hanya untuk menjaga hal-hal sederhana, tetapi dalam kenyataannya itu umumnya jumlah yang lebih besar.

1197
01:05:19,000 --> 01:05:21,000
>> Tunggu sebentar.

1198
01:05:21,000 --> 01:05:23,000
Jika Anda hanya memberi saya alamat karakter pertama, bagaimana saya tahu apa alamat itu

1199
01:05:23,000 --> 01:05:25,000
dari karakter kedua, ketiga, keempat dan kelima?

1200
01:05:25,000 --> 01:05:27,000
[Tak terdengar-murid]

1201
01:05:27,000 --> 01:05:31,000
Anda hanya tahu di mana akhir dari string adalah dengan cara ini trik praktis,

1202
01:05:31,000 --> 01:05:35,000
jadi ketika Anda menggunakan sesuatu seperti printf, apa printf harfiah mengambil sebagai argumen,

1203
01:05:35,000 --> 01:05:39,000
ingat bahwa kita menggunakan placeholder ini% s, dan kemudian Anda lulus dalam

1204
01:05:39,000 --> 01:05:41,000
variabel yang menyimpan string.

1205
01:05:41,000 --> 01:05:47,000
Apa yang Anda benar-benar melewati adalah alamat dari karakter pertama dari string itu.

1206
01:05:47,000 --> 01:05:50,000
Printf kemudian menggunakan untuk loop atau loop sementara setelah menerima alamat tersebut,

1207
01:05:50,000 --> 01:05:53,000
Misalnya, 0, jadi biarkan aku melakukan ini sekarang,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n," s);

1209
01:06:02,000 --> 01:06:07,000
Ketika saya sebut printf ("% s \ n," s), apa yang saya benar-benar memberikan printf dengan

1210
01:06:07,000 --> 01:06:13,000
adalah alamat dari karakter pertama dalam s, yang dalam hal ini adalah sewenang-wenang H.

1211
01:06:13,000 --> 01:06:16,000
>> Bagaimana printf tahu persis apa yang akan ditampilkan pada layar?

1212
01:06:16,000 --> 01:06:19,000
Orang yang diimplementasikan printf menerapkan loop sementara atau untuk loop

1213
01:06:19,000 --> 01:06:23,000
yang mengatakan tidak karakter ini sama dengan karakter null khusus?

1214
01:06:23,000 --> 01:06:25,000
Jika tidak, mencetaknya. Bagaimana dengan yang satu ini?

1215
01:06:25,000 --> 01:06:28,000
Jika tidak mencetaknya, mencetaknya, mencetaknya, mencetaknya.

1216
01:06:28,000 --> 01:06:32,000
Oh, yang satu ini khusus. Berhenti mencetak dan kembali ke pengguna.

1217
01:06:32,000 --> 01:06:35,000
Dan itu benar-benar semua yang telah terjadi di bawah tenda,

1218
01:06:35,000 --> 01:06:38,000
dan itu banyak untuk mencerna di hari pertama kelas,

1219
01:06:38,000 --> 01:06:43,000
tapi untuk saat itu benar-benar blok bangunan dari segala pemahaman

1220
01:06:43,000 --> 01:06:46,000
yang telah terjadi di dalam memori komputer kita,

1221
01:06:46,000 --> 01:06:49,000
dan akhirnya kita akan menggoda ini terpisah dengan sedikit bantuan

1222
01:06:49,000 --> 01:06:51,000
dari salah satu teman-teman kita di Stanford.

1223
01:06:51,000 --> 01:06:56,000
>> Profesor Nick Parlante di Stanford telah melakukan ini urutan video indah

1224
01:06:56,000 --> 01:06:58,000
dari segala macam bahasa yang berbeda yang diperkenalkan

1225
01:06:58,000 --> 01:07:00,000
Binky ini sedikit karakter Claymation.

1226
01:07:00,000 --> 01:07:03,000
Suara Anda akan mendengar hanya dalam sneak preview beberapa detik

1227
01:07:03,000 --> 01:07:05,000
adalah bahwa seorang profesor dari Stanford, dan Anda mendapatkan

1228
01:07:05,000 --> 01:07:07,000
hanya 5 atau 6 detik dari sekarang ini,

1229
01:07:07,000 --> 01:07:09,000
tapi ini adalah catatan di mana kita akan menyimpulkan hari

1230
01:07:09,000 --> 01:07:11,000
dan dimulai pada hari Rabu.

1231
01:07:11,000 --> 01:07:15,000
Saya memberikan Fun Pointer dengan Binky, pratinjau.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ Musik] [Profesor Parlante] Hei, Binky.

1233
01:07:18,000 --> 01:07:21,000
Bangun. Sudah waktunya untuk bersenang-senang pointer.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Apa itu? Pelajari tentang pointer?

1235
01:07:24,000 --> 01:07:26,000
Oh, goody!

1236
01:07:26,000 --> 01:07:29,000
>> Kami akan melihat Anda pada hari Rabu.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]