1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ROB Bowden: Hi, aku Rob Bowden,
dan mari kita bicara tentang quiz0.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> Jadi, pertanyaan pertama.

5
00:00:14,545 --> 00:00:17,750
Ini adalah pertanyaan di mana
Anda perlu kode nomor

6
00:00:17,750 --> 00:00:21,270
127 di lampu biner.

7
00:00:21,270 --> 00:00:23,550
Jika Anda ingin, Anda bisa
melakukan konversi biasa

8
00:00:23,550 --> 00:00:25,950
dari bi-- atau, dari desimal ke biner.

9
00:00:25,950 --> 00:00:28,300
Tapi itu mungkin akan
untuk mengambil banyak waktu.

10
00:00:28,300 --> 00:00:31,750
Maksudku, Anda bisa mengetahui bahwa,
OK, 1 adalah di sana, 2 di sana,

11
00:00:31,750 --> 00:00:33,650
4 adalah di sana, 8 di sana.

12
00:00:33,650 --> 00:00:39,280
Cara yang lebih mudah, 127 adalah 128 minus satu.

13
00:00:39,280 --> 00:00:42,013
Itu bola lampu paling kiri adalah 128-bit.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
Jadi 127 adalah benar-benar hanya semua
dari bola lampu lainnya,

16
00:00:47,860 --> 00:00:51,420
karena itulah paling kiri
bola lampu minus 1.

17
00:00:51,420 --> 00:00:52,800
Itu saja untuk pertanyaan itu.

18
00:00:52,800 --> 00:00:54,060
>> Pertanyaan satu.

19
00:00:54,060 --> 00:00:56,710
Jadi dengan 3 bit Anda dapat
mewakili 8 nilai yang berbeda.

20
00:00:56,710 --> 00:01:01,000
Mengapa, kemudian, adalah 7 terbesar non-negatif
bilangan bulat desimal Anda dapat mewakili?

21
00:01:01,000 --> 00:01:04,050
Nah, jika kita hanya bisa
mewakili 8 nilai yang berbeda,

22
00:01:04,050 --> 00:01:07,430
maka apa yang kita akan menjadi
mewakili adalah 0 sampai 7.

23
00:01:07,430 --> 00:01:08,745
0 mengambil salah satu nilai.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> Pertanyaan kedua.

26
00:01:11,190 --> 00:01:14,610
Dengan n bit, berapa banyak yang berbeda
Nilai-nilai yang dapat Anda mewakili?

27
00:01:14,610 --> 00:01:19,080
Jadi, dengan n bit, Anda memiliki 2
nilai yang mungkin untuk setiap bit.

28
00:01:19,080 --> 00:01:22,300
Jadi kita memiliki 2 nilai yang mungkin untuk
bit pertama, 2 nilai yang mungkin

29
00:01:22,300 --> 00:01:24,450
untuk yang kedua, 2
mungkin bagi ketiga.

30
00:01:24,450 --> 00:01:28,730
Dan jadi itu 2 kali 2 kali 2, dan
akhirnya jawabannya adalah 2 sampai n.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> Pertanyaan ketiga.

33
00:01:31,100 --> 00:01:33,450
Apa 0x50 dalam biner?

34
00:01:33,450 --> 00:01:39,490
Jadi ingat bahwa heksadesimal memiliki sangat
konversi langsung ke biner.

35
00:01:39,490 --> 00:01:43,180
Jadi di sini, kita hanya perlu melihat
5 dan 0 independen.

36
00:01:43,180 --> 00:01:45,110
Jadi apa 5 dalam biner?

37
00:01:45,110 --> 00:01:48,400
0101, itulah 1 bit dan 4 bit.

38
00:01:48,400 --> 00:01:49,900
Apa 0 dalam biner?

39
00:01:49,900 --> 00:01:50,520
Tidak rumit.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
Jadi hanya menempatkan mereka bersama-sama, dan
itu jumlah penuh dalam biner.

42
00:01:54,970 --> 00:01:57,640
01.010.000.

43
00:01:57,640 --> 00:02:00,439
Dan jika Anda ingin Anda bisa
melepas bahwa nol paling kiri.

44
00:02:00,439 --> 00:02:01,105
Itu tidak relevan.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> Jadi alternatif,
apa 0x50 dalam desimal?

47
00:02:05,733 --> 00:02:08,649
Jika Anda ingin, Anda could-- jika Anda
lebih nyaman dengan biner,

48
00:02:08,649 --> 00:02:11,340
Anda bisa mengambil bahwa jawaban biner
dan mengkonversikan menjadi desimal.

49
00:02:11,340 --> 00:02:13,870
Atau kita hanya bisa mengingat
bahwa heksadesimal.

50
00:02:13,870 --> 00:02:21,140
Sehingga 0 adalah di tempat-0 th, dan
5 berada di 16 tempat pertama.

51
00:02:21,140 --> 00:02:25,990
Jadi di sini, kami memiliki 5 kali 16 ke
pertama, ditambah 0 kali 16 ke nol,

52
00:02:25,990 --> 00:02:27,520
adalah 80.

53
00:02:27,520 --> 00:02:29,710
Dan jika Anda melihat
hak atas pertanyaan,

54
00:02:29,710 --> 00:02:32,920
itu CS 80, yang merupakan jenis dari
petunjuk untuk jawaban atas masalah ini.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> Pertanyaan lima.

57
00:02:35,420 --> 00:02:40,320
Kami memiliki naskah Scratch ini, yang
diulang 4 kali selai kacang jelly.

58
00:02:40,320 --> 00:02:42,800
Jadi bagaimana kita sekarang kode yang di C?

59
00:02:42,800 --> 00:02:47,730
Yah, kita memiliki di sini-bagian dalam huruf tebal
adalah satu-satunya bagian yang Anda harus melaksanakan.

60
00:02:47,730 --> 00:02:51,950
Jadi kita memiliki 4 lingkaran yang looping 4
kali, printf-ing peanut butter jelly,

61
00:02:51,950 --> 00:02:53,910
dengan baris baru sebagai masalah meminta.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> Pertanyaan enam, masalah Scratch lain.

64
00:02:57,490 --> 00:03:00,210
Kita melihat bahwa kita berada dalam lingkaran selamanya.

65
00:03:00,210 --> 00:03:05,000
Kami mengatakan i variabel
dan kemudian incrementing i oleh 1.

66
00:03:05,000 --> 00:03:09,580
Sekarang kita ingin melakukan itu di C. Ada
beberapa cara kita bisa melakukan ini.

67
00:03:09,580 --> 00:03:12,840
Di sini kita terjadi untuk kode
selamanya lingkaran sebagai sementara (benar).

68
00:03:12,840 --> 00:03:16,600
Jadi kita mendeklarasikan variabel i, hanya
seperti kami memiliki variabel i dalam Scratch.

69
00:03:16,600 --> 00:03:21,950
Deklarasikan i variabel, dan selamanya
sementara (benar), kita katakan variabel i.

70
00:03:21,950 --> 00:03:25,260
Jadi printf% Aku-- atau Anda sudah bisa digunakan% d.

71
00:03:25,260 --> 00:03:27,985
Kita mengatakan variabel itu, dan
kemudian kenaikan itu, i ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> Pertanyaan tujuh.

74
00:03:30,830 --> 00:03:35,560
Sekarang kita ingin melakukan sesuatu yang sangat mirip
Mario dot c dari masalah menetapkan satu.

75
00:03:35,560 --> 00:03:39,110
Kami ingin mencetak hashtags ini,
kita ingin mencetak lima

76
00:03:39,110 --> 00:03:40,700
oleh tiga persegi panjang hash ini.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
Jadi bagaimana yang akan kita melakukan itu?

79
00:03:43,162 --> 00:03:45,370
Yah, kami memberikan seluruh
sekelompok kode, dan Anda hanya

80
00:03:45,370 --> 00:03:47,560
harus mengisi fungsi cetak jaringan.

81
00:03:47,560 --> 00:03:49,540
>> Jadi apa PrintGrid terlihat seperti?

82
00:03:49,540 --> 00:03:51,480
Nah Anda melewati
lebar dan tinggi.

83
00:03:51,480 --> 00:03:53,520
Jadi kita memiliki outer 4
lingkaran, yang looping

84
00:03:53,520 --> 00:03:57,650
atas semua baris ini
grid yang ingin kita mencetak.

85
00:03:57,650 --> 00:04:01,250
Maka kita memiliki antar-bersarang 4 lingkaran,
itu mencetak lebih dari setiap kolom.

86
00:04:01,250 --> 00:04:06,210
Jadi untuk setiap baris, kita mencetak untuk
setiap kolom, hash tunggal.

87
00:04:06,210 --> 00:04:10,045
Kemudian pada akhir baris kami mencetak
baris baru tunggal untuk pergi ke baris berikutnya.

88
00:04:10,045 --> 00:04:11,420
Dan itu untuk seluruh jaringan.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> Pertanyaan delapan.

91
00:04:13,675 --> 00:04:17,170
Sebuah fungsi seperti PrintGrid dikatakan
memiliki efek samping, tapi tidak kembali sebuah

92
00:04:17,170 --> 00:04:17,670
nilai.

93
00:04:17,670 --> 00:04:19,209
Jelaskan perbedaan.

94
00:04:19,209 --> 00:04:23,080
Jadi ini bergantung pada Anda mengingat
apa efek samping adalah.

95
00:04:23,080 --> 00:04:25,180
Nah, kembalinya value--
kita tahu PrintGrid tidak

96
00:04:25,180 --> 00:04:28,180
memiliki nilai kembali, karena
di sini dikatakan batal.

97
00:04:28,180 --> 00:04:31,150
Jadi apa pun yang mengembalikan void
tidak benar-benar kembali apa-apa.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
Jadi apa efek samping?

100
00:04:33,620 --> 00:04:36,620
Nah, efek samping adalah
apa pun yang semacam berlanjut

101
00:04:36,620 --> 00:04:39,500
setelah fungsi ujung
itu tidak hanya kembali,

102
00:04:39,500 --> 00:04:41,340
dan itu bukan hanya dari input.

103
00:04:41,340 --> 00:04:44,970
>> Jadi, misalnya, kita mungkin
mengubah variabel global.

104
00:04:44,970 --> 00:04:46,590
Itu akan menjadi efek samping.

105
00:04:46,590 --> 00:04:49,000
Dalam kasus ini, seorang
efek samping yang sangat penting

106
00:04:49,000 --> 00:04:51,070
sedang mencetak ke layar.

107
00:04:51,070 --> 00:04:53,110
Jadi itu adalah efek samping
PrintGrid yang memiliki.

108
00:04:53,110 --> 00:04:54,980
Kami mencetak hal-hal ini ke layar.

109
00:04:54,980 --> 00:04:56,370
Dan Anda bisa memikirkan
bahwa sebagai efek samping,

110
00:04:56,370 --> 00:04:58,690
karena itu sesuatu yang
berlanjut setelah fungsi ini berakhir.

111
00:04:58,690 --> 00:05:01,481
Itu sesuatu di luar ruang lingkup
fungsi ini yang pada akhirnya

112
00:05:01,481 --> 00:05:03,380
sedang berubah,
isi layar.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> Pertanyaan sembilan.

115
00:05:05,839 --> 00:05:07,880
Pertimbangkan program di bawah ini,
yang nomor baris

116
00:05:07,880 --> 00:05:09,740
telah ditambahkan untuk
kepentingan diskusi.

117
00:05:09,740 --> 00:05:13,480
Jadi dalam program ini kita hanya
memanggil GetString, menyimpannya

118
00:05:13,480 --> 00:05:16,220
dalam variabel ini s, dan kemudian
mencetak bahwa variabel s.

119
00:05:16,220 --> 00:05:16,720
OK.

120
00:05:16,720 --> 00:05:19,090
Jadi menjelaskan mengapa satu baris hadir.

121
00:05:19,090 --> 00:05:20,920
# include CS50 dot h.

122
00:05:20,920 --> 00:05:23,820
Mengapa kita perlu # include CS50 dot h?

123
00:05:23,820 --> 00:05:26,180
Yah, kita panggil
GetString fungsi,

124
00:05:26,180 --> 00:05:28,840
dan GetString didefinisikan
di perpustakaan CS50.

125
00:05:28,840 --> 00:05:31,600
Jadi jika kita tidak memiliki
#include CS50 dot h,

126
00:05:31,600 --> 00:05:35,760
kita akan mendapatkan bahwa deklarasi implisit
dari kesalahan fungsi GetString

127
00:05:35,760 --> 00:05:36,840
dari compiler.

128
00:05:36,840 --> 00:05:40,110
Jadi kita perlu menyertakan library-- yang
kita perlu menyertakan file header,

129
00:05:40,110 --> 00:05:42,870
atau compiler tidak akan
mengakui bahwa GetString ada.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> Jelaskan mengapa garis dua hadir.

132
00:05:46,140 --> 00:05:47,890
Jadi standar io dot h.

133
00:05:47,890 --> 00:05:50,430
Ini persis sama
sebagai masalah sebelumnya,

134
00:05:50,430 --> 00:05:53,310
kecuali bukan berurusan dengan
GetString, kita sedang berbicara tentang printf.

135
00:05:53,310 --> 00:05:56,654
Jadi jika kita tidak mengatakan kita perlu
untuk menyertakan standar io dot h,

136
00:05:56,654 --> 00:05:58,820
maka kita tidak akan mampu
untuk menggunakan fungsi printf,

137
00:05:58,820 --> 00:06:00,653
karena compiler
tidak akan tahu tentang hal itu.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- apa signifikansinya
dari membatalkan sejalan empat?

140
00:06:05,260 --> 00:06:08,010
Jadi di sini kita memiliki int main (void).

141
00:06:08,010 --> 00:06:10,600
Itu hanya mengatakan kita bahwa
tidak mendapatkan apapun baris perintah

142
00:06:10,600 --> 00:06:12,280
argumen untuk utama.

143
00:06:12,280 --> 00:06:17,390
Ingat bahwa kita bisa mengatakan int
utama int argc kurung tali argv.

144
00:06:17,390 --> 00:06:20,400
Jadi di sini kita hanya mengatakan batal untuk mengatakan kami
mengabaikan argumen baris perintah.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> Jelaskan, sehubungan dengan memori, tepatnya
apa GetString sejalan enam kembali.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString adalah kembali blok
memori, sebuah array karakter.

149
00:06:31,640 --> 00:06:34,870
Ini benar-benar mengembalikan
pointer ke karakter pertama.

150
00:06:34,870 --> 00:06:37,170
Ingat bahwa string adalah bintang arang.

151
00:06:37,170 --> 00:06:41,360
Jadi s adalah pointer ke pertama
karakter dalam apa pun string adalah

152
00:06:41,360 --> 00:06:43,510
bahwa pengguna masuk pada keyboard.

153
00:06:43,510 --> 00:06:47,070
Dan memori yang kebetulan malloced,
sehingga memori yang ada di heap.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> Pertanyaan 13.

156
00:06:50,450 --> 00:06:51,960
Mempertimbangkan program di bawah ini.

157
00:06:51,960 --> 00:06:55,579
Jadi semua program ini adalah melakukan
adalah printf-ing 1 dibagi dengan 10.

158
00:06:55,579 --> 00:06:57,370
Jadi ketika dikompilasi dan
dieksekusi, program ini

159
00:06:57,370 --> 00:07:01,170
output 0.0, meskipun
1 dibagi dengan 10 adalah 0,1.

160
00:07:01,170 --> 00:07:02,970
Jadi mengapa 0.0?

161
00:07:02,970 --> 00:07:05,510
Nah, hal ini karena
dari pembagian integer.

162
00:07:05,510 --> 00:07:08,580
Jadi 1 adalah integer, 10 adalah bilangan bulat.

163
00:07:08,580 --> 00:07:11,980
Jadi 1 dibagi dengan 10, semuanya
diperlakukan sebagai bilangan bulat,

164
00:07:11,980 --> 00:07:16,380
dan di C, ketika kita melakukan pembagian integer,
kita memotong setiap titik desimal.

165
00:07:16,380 --> 00:07:19,590
Jadi 1 dibagi dengan 10 adalah
0, dan kemudian kami berusaha

166
00:07:19,590 --> 00:07:24,410
untuk mencetak bahwa sebagai pelampung, sehingga
nol dicetak sebagai pelampung adalah 0,0.

167
00:07:24,410 --> 00:07:27,400
Dan itulah mengapa kita mendapatkan 0,0.

168
00:07:27,400 --> 00:07:28,940
>> Mempertimbangkan program di bawah ini.

169
00:07:28,940 --> 00:07:31,280
Sekarang kita mencetak 0,1.

170
00:07:31,280 --> 00:07:34,280
Jadi tidak ada pembagian integer,
kami hanya mencetak 0,1,

171
00:07:34,280 --> 00:07:37,100
tapi kami mencetaknya
28 tempat desimal.

172
00:07:37,100 --> 00:07:41,810
Dan kami mendapatkan ini 0,1000, seluruh sekelompok
dari nol, 5 5 5, bla bla bla.

173
00:07:41,810 --> 00:07:45,495
Jadi pertanyaan di sini adalah mengapa hal itu
mencetak bahwa, alih-alih persis 0,1?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> Jadi alasan di sini sekarang
floating point ketidaktepatan.

176
00:07:49,640 --> 00:07:53,410
Ingat bahwa pelampung hanya 32 bit.

177
00:07:53,410 --> 00:07:57,540
Jadi kita hanya dapat mewakili jumlah terbatas
floating point nilai dengan orang-orang 32

178
00:07:57,540 --> 00:07:58,560
bit.

179
00:07:58,560 --> 00:08:01,760
Yah ada akhirnya jauh
banyak nilai-nilai floating point,

180
00:08:01,760 --> 00:08:04,940
dan ada tak terhingga banyaknya mengambang
nilai titik antara 0 dan 1,

181
00:08:04,940 --> 00:08:07,860
dan kami jelas bisa
mewakili lebih nilai dari itu.

182
00:08:07,860 --> 00:08:13,230
Jadi kita harus berkorban untuk
dapat mewakili sebagian besar nilai-nilai.

183
00:08:13,230 --> 00:08:16,960
>> Jadi nilai seperti 0.1, rupanya
kita tidak bisa menyatakan bahwa tepat.

184
00:08:16,960 --> 00:08:22,500
Jadi, bukannya mewakili 0,1 kita melakukan
terbaik yang kami dapat mewakili ini 0.100000 5 5

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
Dan itu cukup dekat, tapi
untuk banyak aplikasi

187
00:08:26,306 --> 00:08:28,430
Anda perlu khawatir tentang
floating point ketidaktepatan,

188
00:08:28,430 --> 00:08:30,930
karena kita tidak dapat mewakili
semua titik mengambang persis.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> Pertanyaan 15.

191
00:08:33,380 --> 00:08:34,679
Pertimbangkan kode di bawah ini.

192
00:08:34,679 --> 00:08:36,630
Kami hanya mencetak 1 ditambah 1.

193
00:08:36,630 --> 00:08:38,289
Jadi tidak ada trik di sini.

194
00:08:38,289 --> 00:08:41,780
1 ditambah 1 mengevaluasi ke 2, dan
kemudian kita cetak itu.

195
00:08:41,780 --> 00:08:42,789
Ini hanya mencetak 2.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> Pertanyaan 16.

198
00:08:44,700 --> 00:08:49,450
Sekarang kita mencetak karakter
1 ditambah karakter 1.

199
00:08:49,450 --> 00:08:52,110
Jadi mengapa hal ini tidak
mencetak hal yang sama?

200
00:08:52,110 --> 00:08:57,680
Nah karakter 1 ditambah karakter
1, karakter 1 memiliki nilai ASCII 49.

201
00:08:57,680 --> 00:09:04,840
Jadi ini benar-benar mengatakan 49 ditambah 49, dan
akhirnya ini akan mencetak 98.

202
00:09:04,840 --> 00:09:06,130
Jadi ini tidak mencetak 2.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> Pertanyaan 17.

205
00:09:09,271 --> 00:09:11,520
Lengkapi pelaksanaan
aneh di bawah ini sedemikian rupa

206
00:09:11,520 --> 00:09:14,615
bahwa fungsi mengembalikan nilai true jika
n ganjil dan false jika n genap.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
Ini adalah tujuan besar
untuk operator mod.

209
00:09:19,330 --> 00:09:24,530
Jadi kami mengambil kami argumen n,
jika n mod 2 sama dengan 1, baik

210
00:09:24,530 --> 00:09:28,030
yang berarti bahwa n dibagi
oleh 2 memiliki sisa a.

211
00:09:28,030 --> 00:09:33,270
Jika n dibagi 2 memiliki sisa, yaitu
berarti bahwa n adalah ganjil, jadi kami kembali benar.

212
00:09:33,270 --> 00:09:34,910
Lain kita kembali palsu.

213
00:09:34,910 --> 00:09:39,070
Anda juga bisa melakukan n mod 2 equals
nol, kembali palsu, yang lain kembali benar.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> Pertimbangkan fungsi rekursif di bawah ini.

216
00:09:43,640 --> 00:09:46,920
Jadi jika n kurang dari atau
sama dengan 1, kembali 1,

217
00:09:46,920 --> 00:09:50,430
lain kembali n kali f n minus 1.

218
00:09:50,430 --> 00:09:52,556
Jadi apa fungsi ini?

219
00:09:52,556 --> 00:09:54,305
Nah, ini hanya
fungsi faktorial.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
Ini baik diwakili
sebagai n faktorial.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> Jadi pertanyaan 19 sekarang, kita ingin
mengambil fungsi rekursif ini.

224
00:10:02,310 --> 00:10:04,530
Kami ingin membuatnya berulang.

225
00:10:04,530 --> 00:10:05,874
Jadi bagaimana kita melakukannya?

226
00:10:05,874 --> 00:10:07,790
Nah untuk staf
solusi, dan lagi ada

227
00:10:07,790 --> 00:10:11,090
beberapa cara Anda bisa melakukannya
itu, kita mulai dengan produk int ini

228
00:10:11,090 --> 00:10:11,812
sama dengan 1.

229
00:10:11,812 --> 00:10:13,520
Dan sepanjang ini
untuk loop, kita akan

230
00:10:13,520 --> 00:10:17,590
untuk mengalikan produk untuk akhirnya
berakhir dengan faktorial lengkap.

231
00:10:17,590 --> 00:10:21,870
Jadi untuk int i sama dengan 2, i adalah
kurang dari atau sama dengan n, i ++.

232
00:10:21,870 --> 00:10:24,130
>> Anda mungkin bertanya-tanya mengapa saya sama 2.

233
00:10:24,130 --> 00:10:28,380
Nah, ingat bahwa di sini kita harus
pastikan kasus dasar kami adalah benar.

234
00:10:28,380 --> 00:10:32,180
Jadi jika n kurang dari atau sama
1, kami hanya kembali 1.

235
00:10:32,180 --> 00:10:34,830
Jadi di sini, kita mulai dari i sama dengan 2.

236
00:10:34,830 --> 00:10:39,090
Nah jika saya adalah 1, maka the-- atau
jika n adalah 1, maka untuk loop

237
00:10:39,090 --> 00:10:40,600
tidak akan mengeksekusi sekali.

238
00:10:40,600 --> 00:10:43,190
Dan jadi kami akan hanya
produk kembali, yaitu 1.

239
00:10:43,190 --> 00:10:45,920
Demikian pula, jika n adalah
sesuatu yang kurang dari 1--

240
00:10:45,920 --> 00:10:49,290
jika itu 0, 1 negatif, whatever--
kita masih akan kembali 1,

241
00:10:49,290 --> 00:10:52,260
yang persis apa yang
Versi rekursif lakukan.

242
00:10:52,260 --> 00:10:54,660
>> Sekarang, jika n lebih besar
dari 1, maka kita akan

243
00:10:54,660 --> 00:10:56,550
untuk melakukan setidaknya satu
iterasi dari loop ini.

244
00:10:56,550 --> 00:11:00,630
Jadi katakanlah n adalah 5, maka kita
akan melakukan kali produk sama dengan 2.

245
00:11:00,630 --> 00:11:02,165
Jadi sekarang produk 2.

246
00:11:02,165 --> 00:11:04,040
Sekarang kita akan melakukan
kali produk sama dengan 3.

247
00:11:04,040 --> 00:11:04,690
Sekarang 6.

248
00:11:04,690 --> 00:11:07,500
Kali produk sama dengan 4, sekarang 24.

249
00:11:07,500 --> 00:11:10,420
Kali produk sama dengan 5, sekarang 120.

250
00:11:10,420 --> 00:11:16,730
Jadi pada akhirnya, kita kembali
120, yang benar 5 faktorial.

251
00:11:16,730 --> 00:11:17,510
>> Pertanyaan 20.

252
00:11:17,510 --> 00:11:22,480
Ini adalah satu di mana Anda harus mengisi
dalam tabel ini dengan algoritma tertentu,

253
00:11:22,480 --> 00:11:25,735
apa yang kita lihat, bahwa
cocok ini algoritmik run

254
00:11:25,735 --> 00:11:28,060
kali ini berjalan kali asimtotik.

255
00:11:28,060 --> 00:11:33,270
Jadi apa yang merupakan algoritma yang
adalah omega dari 1, tapi O besar n?

256
00:11:33,270 --> 00:11:35,970
Jadi mungkin ada jauh
banyak jawaban di sini.

257
00:11:35,970 --> 00:11:39,790
Salah satu yang kita lihat mungkin yang paling
sering hanya pencarian linear.

258
00:11:39,790 --> 00:11:42,050
>> Jadi dalam kasus terbaik
skenario, item kami

259
00:11:42,050 --> 00:11:44,050
cari adalah di
mulai dari daftar

260
00:11:44,050 --> 00:11:47,400
dan omega dari 1 langkah,
hal pertama yang kami periksa,

261
00:11:47,400 --> 00:11:49,740
kita hanya segera kembali
bahwa kita menemukan item.

262
00:11:49,740 --> 00:11:52,189
Dalam skenario kasus terburuk,
item tersebut di akhir,

263
00:11:52,189 --> 00:11:53,730
atau item tersebut tidak ada dalam daftar sama sekali.

264
00:11:53,730 --> 00:11:56,700
Jadi kita harus mencari
seluruh daftar, semua n

265
00:11:56,700 --> 00:11:58,480
elemen, dan itulah mengapa itu o n.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> Jadi sekarang itu adalah sesuatu yang baik
omega n log n, dan O besar n log n.

268
00:12:04,880 --> 00:12:08,650
Nah hal yang paling relevan
kita lihat di sini adalah menggabungkan semacam.

269
00:12:08,650 --> 00:12:12,950
Jadi menggabungkan semacam, ingat,
akhirnya theta

270
00:12:12,950 --> 00:12:16,920
n log n, di mana theta didefinisikan
jika kedua omega dan O besar adalah sama.

271
00:12:16,920 --> 00:12:17,580
Kedua n log n.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> Apa sesuatu yang omega
n, dan O n kuadrat?

274
00:12:21,970 --> 00:12:23,990
Nah, sekali lagi ada
beberapa kemungkinan jawaban.

275
00:12:23,990 --> 00:12:26,440
Di sini kita kebetulan mengatakan bubble sort.

276
00:12:26,440 --> 00:12:28,840
Insertion sort juga akan bekerja di sini.

277
00:12:28,840 --> 00:12:31,400
Ingat bahwa bubble sort
memiliki optimasi yang mana,

278
00:12:31,400 --> 00:12:34,630
jika Anda bisa mendapatkan
melalui seluruh daftar

279
00:12:34,630 --> 00:12:37,402
tanpa perlu melakukan
apapun swap, maka, baik,

280
00:12:37,402 --> 00:12:40,110
kita bisa langsung kembali bahwa
daftar diurutkan untuk memulai.

281
00:12:40,110 --> 00:12:43,185
Jadi dalam skenario kasus terbaik,
itu hanya omega n.

282
00:12:43,185 --> 00:12:45,960
Jika tidak hanya baik
diurutkan daftar untuk memulai dengan,

283
00:12:45,960 --> 00:12:48,270
maka kita harus O n kuadrat swap.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
Dan akhirnya, kita memiliki pilihan semacam
untuk n kuadrat, baik omega dan besar O.

286
00:12:55,610 --> 00:12:56,850
>> Pertanyaan 21.

287
00:12:56,850 --> 00:12:58,870
Apa integer overflow?

288
00:12:58,870 --> 00:13:02,160
Nah lagi, mirip dengan sebelumnya,
kita hanya memiliki finitely banyak bit

289
00:13:02,160 --> 00:13:04,255
untuk mewakili integer,
jadi mungkin 32 bit.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
Katakanlah kita memiliki integer ditandatangani.

292
00:13:09,180 --> 00:13:12,800
Kemudian akhirnya tertinggi
angka positif kita dapat mewakili

293
00:13:12,800 --> 00:13:15,910
adalah 2 sampai 31 minus 1.

294
00:13:15,910 --> 00:13:19,370
Jadi apa yang terjadi jika kita mencoba untuk
kemudian increment integer yang?

295
00:13:19,370 --> 00:13:25,320
Yah, kita akan pergi dari 2 ke 31
minus 1, sepanjang jalan turun ke negatif 2

296
00:13:25,320 --> 00:13:26,490
ke 31.

297
00:13:26,490 --> 00:13:29,470
Jadi integer overflow ini
ketika Anda terus incrementing,

298
00:13:29,470 --> 00:13:32,330
dan pada akhirnya Anda tidak bisa
mendapatkan lebih tinggi dan hanya

299
00:13:32,330 --> 00:13:34,520
membungkus sepanjang perjalanan kembali
sekitar untuk nilai negatif.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> Bagaimana buffer overflow?

302
00:13:37,779 --> 00:13:39,820
Jadi buffer overflow--
ingat apa penyangga adalah.

303
00:13:39,820 --> 00:13:41,000
Ini hanya sepotong memori.

304
00:13:41,000 --> 00:13:43,350
Sesuatu seperti sebuah array adalah buffer.

305
00:13:43,350 --> 00:13:46,120
Jadi buffer overflow adalah ketika
Anda mencoba untuk mengakses memori

306
00:13:46,120 --> 00:13:47,880
di luar akhir array.

307
00:13:47,880 --> 00:13:50,410
Jadi jika Anda memiliki
array ukuran 5 dan Anda

308
00:13:50,410 --> 00:13:53,700
mencoba untuk mengakses berbagai braket
5 atau bracket 6 atau braket 7,

309
00:13:53,700 --> 00:13:56,610
atau apa pun di luar
end, atau bahkan apa pun

310
00:13:56,610 --> 00:14:00,790
below-- Array braket negatif 1--
semua dari mereka adalah buffer overflows.

311
00:14:00,790 --> 00:14:02,810
Anda menyentuh memori dengan cara yang buruk.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> Pertanyaan 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
Jadi dalam satu ini Anda perlu
untuk melaksanakan strlen.

316
00:14:09,100 --> 00:14:11,630
Dan kami memberitahu Anda bahwa Anda bisa
menganggap s tidak akan null,

317
00:14:11,630 --> 00:14:13,790
sehingga Anda tidak perlu
melakukan cek untuk null.

318
00:14:13,790 --> 00:14:16,190
Dan ada beberapa cara
Anda bisa melakukan ini.

319
00:14:16,190 --> 00:14:18,440
Di sini kita hanya mengambil mudah.

320
00:14:18,440 --> 00:14:21,780
Kita mulai dengan counter, n. n adalah
menghitung berapa banyak karakter ada.

321
00:14:21,780 --> 00:14:25,560
Jadi kita mulai dari 0, dan kemudian kita
iterate atas seluruh daftar.

322
00:14:25,560 --> 00:14:29,092
>> Apakah s braket 0 sama dengan
karakter null terminator?

323
00:14:29,092 --> 00:14:31,425
Ingat kita sedang mencari
karakter null terminator

324
00:14:31,425 --> 00:14:33,360
untuk menentukan berapa lama string kita adalah.

325
00:14:33,360 --> 00:14:35,890
Itu akan mengakhiri
string yang relevan.

326
00:14:35,890 --> 00:14:39,400
Begitu juga s braket 0 sama
untuk null terminator?

327
00:14:39,400 --> 00:14:42,850
Jika tidak, maka kita akan
melihat s bracket 1, s braket 2.

328
00:14:42,850 --> 00:14:45,050
Kami terus berjalan sampai kita
menemukan null terminator.

329
00:14:45,050 --> 00:14:48,580
Setelah kami telah menemukan itu, maka n mengandung
total panjang string,

330
00:14:48,580 --> 00:14:49,942
dan kami hanya dapat kembali itu.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> Pertanyaan 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
Jadi ini adalah satu di mana Anda
harus membuat trade off.

335
00:14:56,050 --> 00:14:59,810
Jadi satu hal yang baik dalam satu
cara, tapi dengan cara apa itu buruk?

336
00:14:59,810 --> 00:15:02,980
Jadi di sini, menggabungkan semacam cenderung
lebih cepat dari bubble sort.

337
00:15:02,980 --> 00:15:06,530
Setelah mengatakan itu-- baik, ada
adalah beberapa jawabannya di sini.

338
00:15:06,530 --> 00:15:12,930
Tapi yang utama adalah bahwa bubble sort
adalah omega n untuk daftar diurutkan.

339
00:15:12,930 --> 00:15:14,950
>> Ingat bahwa meja kami hanya lihat sebelumnya.

340
00:15:14,950 --> 00:15:17,600
Jadi gelembung macam omega dari
n, skenario kasus terbaik

341
00:15:17,600 --> 00:15:20,010
adalah itu bisa saja pergi
daftar sekali, menentukan

342
00:15:20,010 --> 00:15:22,270
hey hal ini sudah
diurutkan, dan kembali.

343
00:15:22,270 --> 00:15:25,960
Menggabungkan semacam, tidak peduli apa
Anda lakukan, adalah omega n log n.

344
00:15:25,960 --> 00:15:29,200
Jadi untuk daftar diurutkan, gelembung
semacam akan menjadi lebih cepat.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> Sekarang bagaimana terkait daftar?

347
00:15:32,430 --> 00:15:36,070
Jadi linked list dapat tumbuh dan menyusut
cocok sebagai banyak unsur yang diperlukan.

348
00:15:36,070 --> 00:15:38,489
Setelah mengatakan itu-- begitu
biasanya perbandingan langsung

349
00:15:38,489 --> 00:15:40,280
akan menjadi terkait
daftar dengan array.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
Jadi meskipun array dapat
mudah tumbuh dan menyusut

352
00:15:44,050 --> 00:15:47,130
cocok sebagai banyak unsur
sesuai kebutuhan, sebuah linked list

353
00:15:47,130 --> 00:15:49,600
dibandingkan dengan sebuah array--
Array memiliki akses acak.

354
00:15:49,600 --> 00:15:52,960
Kami dapat mengindeks ke setiap
elemen tertentu dari array.

355
00:15:52,960 --> 00:15:56,430
>> Jadi untuk sebuah linked list, kita tidak bisa
hanya pergi ke elemen kelima,

356
00:15:56,430 --> 00:16:00,260
kita harus melintasi dari awal
sampai kita sampai ke elemen kelima.

357
00:16:00,260 --> 00:16:03,990
Dan itu akan mencegah kita dari
melakukan sesuatu seperti pencarian biner.

358
00:16:03,990 --> 00:16:08,150
Berbicara tentang pencarian biner, pencarian biner
cenderung lebih cepat daripada pencarian linear.

359
00:16:08,150 --> 00:16:11,120
Setelah mengatakan itu--
jadi, satu hal yang mungkin

360
00:16:11,120 --> 00:16:13,380
adalah bahwa Anda tidak dapat melakukan biner
pencarian pada daftar terkait,

361
00:16:13,380 --> 00:16:14,730
Anda hanya bisa melakukannya pada array.

362
00:16:14,730 --> 00:16:18,030
Tapi mungkin lebih penting,
Anda tidak dapat melakukan pencarian biner

363
00:16:18,030 --> 00:16:20,690
pada array yang tidak diurutkan.

364
00:16:20,690 --> 00:16:23,990
Dimuka Anda mungkin perlu untuk memilah
array, dan hanya kemudian dapat

365
00:16:23,990 --> 00:16:25,370
Anda melakukan pencarian biner.

366
00:16:25,370 --> 00:16:27,660
Jadi jika hal Anda tidak
diurutkan untuk memulai dengan,

367
00:16:27,660 --> 00:16:29,250
maka pencarian linear mungkin akan lebih cepat.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> Pertanyaan 27.

370
00:16:31,740 --> 00:16:34,770
Jadi pertimbangkan program di bawah ini,
yang akan di slide berikutnya.

371
00:16:34,770 --> 00:16:37,790
Dan ini adalah satu di mana kami
akan ingin secara eksplisit menyatakan

372
00:16:37,790 --> 00:16:39,980
nilai-nilai untuk berbagai variabel.

373
00:16:39,980 --> 00:16:41,990
Jadi mari kita lihat itu.

374
00:16:41,990 --> 00:16:43,160
>> Jadi baris satu.

375
00:16:43,160 --> 00:16:45,457
Kami memiliki int x sama dengan 1.

376
00:16:45,457 --> 00:16:47,040
Itulah satu-satunya hal yang telah terjadi.

377
00:16:47,040 --> 00:16:50,440
Jadi pada satu baris, kita lihat di kami
tabel, bahwa y, a, b, dan tmp semua

378
00:16:50,440 --> 00:16:51,540
pingsan.

379
00:16:51,540 --> 00:16:52,280
Jadi apa yang x?

380
00:16:52,280 --> 00:16:53,860
Yah kita hanya mengatur itu sama dengan 1.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
Dan kemudian baris kedua, baik,
kita melihat bahwa y diatur ke 2,

383
00:16:58,770 --> 00:17:00,550
dan meja sudah
diisi untuk kita.

384
00:17:00,550 --> 00:17:03,040
Jadi x adalah 1 dan y adalah 2.

385
00:17:03,040 --> 00:17:05,890
>> Sekarang, garis tiga, kami sekarang
dalam fungsi swap.

386
00:17:05,890 --> 00:17:07,560
Apa yang kami melewati untuk swap?

387
00:17:07,560 --> 00:17:11,609
Kami melewati ampersand x untuk
, dan ampersand y untuk b.

388
00:17:11,609 --> 00:17:15,160
Di mana masalah sebelumnya
menyatakan bahwa alamat x

389
00:17:15,160 --> 00:17:17,520
adalah 0x10, dan alamat y adalah 0x14.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
Jadi a dan b adalah sama dengan
0x10 dan 0x14, masing-masing.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> Sekarang pada baris ketiga, apa x dan y?

394
00:17:26,250 --> 00:17:28,554
Yah, tidak ada yang berubah
tentang x dan y pada saat ini.

395
00:17:28,554 --> 00:17:30,470
Meskipun mereka
di dalam stack frame utama,

396
00:17:30,470 --> 00:17:32,469
mereka masih memiliki sama
nilai-nilai yang mereka lakukan sebelumnya.

397
00:17:32,469 --> 00:17:34,030
Kami belum mengubah memori apapun.

398
00:17:34,030 --> 00:17:35,710
Jadi x adalah 1, y adalah 2.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
Baik.

401
00:17:37,050 --> 00:17:40,300
Jadi sekarang kita mengatakan int tmp sama dengan membintangi sebuah.

402
00:17:40,300 --> 00:17:44,410
Jadi pada line empat, semuanya
adalah sama kecuali untuk tmp.

403
00:17:44,410 --> 00:17:47,130
Kami tidak mengubah nilai-nilai
apa pun kecuali tmp.

404
00:17:47,130 --> 00:17:49,230
Kami sedang mengatur tmp sama dengan membintangi sebuah.

405
00:17:49,230 --> 00:17:50,620
Apa itu bintang?

406
00:17:50,620 --> 00:17:56,240
Nah, poin ke x, Jadi membintangi sebuah
akan x sama, yaitu 1.

407
00:17:56,240 --> 00:18:00,080
Jadi semuanya akan disalin
bawah, dan tmp diatur ke 1.

408
00:18:00,080 --> 00:18:01,110
>> Sekarang baris berikutnya.

409
00:18:01,110 --> 00:18:03,380
Bintang sama bintang b.

410
00:18:03,380 --> 00:18:10,000
Jadi dengan garis five-- baik lagi, semuanya
adalah sama kecuali apa bintang adalah.

411
00:18:10,000 --> 00:18:10,830
Apa itu bintang?

412
00:18:10,830 --> 00:18:13,720
Yah, kita hanya mengatakan bintang adalah x.

413
00:18:13,720 --> 00:18:16,400
Jadi kita mengubah x dengan bintang yang sama b.

414
00:18:16,400 --> 00:18:18,960
Apa itu star b? y. b menunjuk ke y.

415
00:18:18,960 --> 00:18:21,030
Jadi Bintang b adalah y.

416
00:18:21,030 --> 00:18:25,140
Jadi kami sedang menyiapkan x sama dengan y,
dan segala sesuatu yang lain adalah sama.

417
00:18:25,140 --> 00:18:29,130
Jadi kita melihat di baris berikutnya yang x sekarang
2, dan sisanya hanya menyalin.

418
00:18:29,130 --> 00:18:31,120
>> Sekarang di baris berikutnya, bintang b sama tmp.

419
00:18:31,120 --> 00:18:34,740
Yah, kita hanya mengatakan bintang b adalah y,
jadi kita sedang menyiapkan y sama dengan tmp.

420
00:18:34,740 --> 00:18:37,450
Segala sesuatu yang lain adalah sama,
jadi semuanya akan disalin ke bawah.

421
00:18:37,450 --> 00:18:42,050
Kami sedang menyiapkan y sama dengan tmp, yang
satu, dan segala sesuatu yang lain adalah sama.

422
00:18:42,050 --> 00:18:43,210
>> Sekarang akhirnya, baris tujuh.

423
00:18:43,210 --> 00:18:44,700
Kami kembali fungsi utama.

424
00:18:44,700 --> 00:18:46,350
Kami setelah swap selesai.

425
00:18:46,350 --> 00:18:48,972
Kami telah kehilangan a, b, dan
tmp, tapi akhirnya kami

426
00:18:48,972 --> 00:18:51,180
tidak mengubah nilai-nilai
apa pun pada saat ini,

427
00:18:51,180 --> 00:18:52,800
kita hanya menyalin x dan y turun.

428
00:18:52,800 --> 00:18:56,490
Dan kita melihat bahwa x dan y
sekarang 2 dan 1, bukan 1 dan 2.

429
00:18:56,490 --> 00:18:58,160
Swap telah berhasil dijalankan.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> Pertanyaan 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
Misalkan Anda temui
pesan kesalahan

434
00:19:03,100 --> 00:19:06,790
bawah selama jam kerja
tahun depan sebagai CA atau TF.

435
00:19:06,790 --> 00:19:08,930
Menyarankan bagaimana untuk memperbaiki setiap kesalahan tersebut.

436
00:19:08,930 --> 00:19:11,160
Referensi sehingga terdefinisi untuk GetString.

437
00:19:11,160 --> 00:19:12,540
Mengapa Anda melihat ini?

438
00:19:12,540 --> 00:19:15,380
Nah, jika seorang siswa menggunakan
GetString dalam kode mereka,

439
00:19:15,380 --> 00:19:20,310
mereka telah benar Hash termasuk CS50
dot h untuk memasukkan perpustakaan CS50.

440
00:19:20,310 --> 00:19:22,380
>> Nah, apa yang mereka
perlu untuk memperbaiki kesalahan ini?

441
00:19:22,380 --> 00:19:26,810
Mereka perlu melakukan lcs50 dasbor di
baris perintah ketika mereka kompilasi.

442
00:19:26,810 --> 00:19:29,501
Jadi, jika mereka tidak lulus
dentang dasbor lcs50, mereka

443
00:19:29,501 --> 00:19:32,000
tidak akan memiliki yang sebenarnya
kode yang mengimplementasikan GetString.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> Pertanyaan 29.

446
00:19:34,170 --> 00:19:36,190
Secara implisit menyatakan
fungsi perpustakaan strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
Nah ini sekarang, mereka tidak memiliki
melakukan hash yang tepat termasuk.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
Dalam kasus ini, file header
mereka perlu menyertakan string dot h,

451
00:19:45,410 --> 00:19:48,710
dan termasuk tali dot h, sekarang
yang student-- sekarang compiler

452
00:19:48,710 --> 00:19:51,750
memiliki akses ke
deklarasi strlen,

453
00:19:51,750 --> 00:19:54,120
dan ia tahu bahwa kode Anda
adalah strlen menggunakan dengan benar.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> Pertanyaan 30.

456
00:19:56,580 --> 00:20:00,240
Lebih persen konversi
dari argumen data.

457
00:20:00,240 --> 00:20:01,540
Jadi apa ini?

458
00:20:01,540 --> 00:20:06,470
Nah ingat bahwa persen ini
signs-- bagaimana mereka relevan dengan printf.

459
00:20:06,470 --> 00:20:08,890
Jadi dalam printf kita mungkin percent--
kita mungkin mencetak sesuatu

460
00:20:08,890 --> 00:20:11,380
seperti persen i backslash n.

461
00:20:11,380 --> 00:20:15,310
Atau kita mungkin mencetak seperti persen i,
ruang, persen i, ruang, persen i.

462
00:20:15,310 --> 00:20:18,950
Jadi untuk masing-masing
tanda persen, kita perlu

463
00:20:18,950 --> 00:20:21,560
untuk melewati sebuah variabel pada akhir printf.

464
00:20:21,560 --> 00:20:26,980
>> Jadi jika kita katakan paren printf persen
i backslash paren n dekat,

465
00:20:26,980 --> 00:20:30,270
baik, kita katakan bahwa kita
akan mencetak integer,

466
00:20:30,270 --> 00:20:33,970
tapi kemudian kita tidak lulus printf
integer untuk benar-benar mencetak.

467
00:20:33,970 --> 00:20:37,182
Jadi di sini lebih persen
konversi dari argumen data?

468
00:20:37,182 --> 00:20:39,390
Itu mengatakan bahwa kita memiliki
sejumlah besar persen,

469
00:20:39,390 --> 00:20:42,445
dan kita tidak memiliki variabel yang cukup
untuk benar-benar mengisi pada mereka persen.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> Dan kemudian pasti, untuk pertanyaan 31,
pasti kehilangan 40 byte dalam satu blok.

472
00:20:50,010 --> 00:20:52,350
Jadi ini adalah kesalahan Valgrind.

473
00:20:52,350 --> 00:20:54,720
Hal ini mengatakan bahwa
suatu tempat dalam kode Anda,

474
00:20:54,720 --> 00:20:59,010
Anda memiliki alokasi yang 40
byte besar sehingga Anda malloced 40 byte,

475
00:20:59,010 --> 00:21:00,515
dan Anda tidak pernah dibebaskan itu.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
Kemungkinan besar Anda hanya perlu
untuk menemukan beberapa kebocoran memori,

478
00:21:05,140 --> 00:21:07,650
dan menemukan di mana Anda perlu
membebaskan blok ini memori.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> Dan pertanyaan 32,
menulis tidak valid ukuran 4.

481
00:21:11,910 --> 00:21:13,250
Sekali lagi ini adalah kesalahan Valgrind.

482
00:21:13,250 --> 00:21:15,440
Hal ini tidak harus dilakukan
dengan kebocoran memori sekarang.

483
00:21:15,440 --> 00:21:20,750
Hal ini, sebagian besar likely-- Maksudku, itu
semacam hak memori yang tidak valid.

484
00:21:20,750 --> 00:21:23,270
Dan kemungkinan besar ini adalah beberapa
semacam buffer overflow.

485
00:21:23,270 --> 00:21:26,560
Di mana Anda memiliki sebuah array, mungkin
array integer, dan mari kita

486
00:21:26,560 --> 00:21:30,115
mengatakan itu dari ukuran 5, dan Anda
mencoba menyentuh berbagai braket 5.

487
00:21:30,115 --> 00:21:34,150
Jadi jika Anda mencoba untuk menulis ke
nilai, itu bukan bagian dari memori

488
00:21:34,150 --> 00:21:37,440
bahwa Anda benar-benar memiliki akses ke, dan
sehingga Anda akan mendapatkan error ini,

489
00:21:37,440 --> 00:21:39,272
mengatakan menulis valid ukuran 4.

490
00:21:39,272 --> 00:21:42,480
Valgrind akan mengenali Anda
mencoba untuk menyentuh memori tidak tepat.

491
00:21:42,480 --> 00:21:43,980
>> Dan itu saja untuk quiz0.

492
00:21:43,980 --> 00:21:47,065
Aku Rob Bowden, dan ini adalah CS50.

493
00:21:47,065 --> 00:21:51,104