1
00:00:00,000 --> 00:00:02,760
[Powered by Google Translate] [週5]

2
00:00:02,760 --> 00:00:04,760
戴維·J·馬蘭，哈佛大學]

3
00:00:04,760 --> 00:00:11,990
這是CS50。[CS50.TV]

4
00:00:11,990 --> 00:00:17,780
[女人]他在說謊的是什麼，我不知道。

5
00:00:17,780 --> 00:00:20,300
[文]因此，我們知道些什麼？

6
00:00:20,300 --> 00:00:24,120
[女人] 9時15分，雷Santoya是在ATM。

7
00:00:24,120 --> 00:00:27,420
[文]因此，問題是，什麼是他做的9:16？

8
00:00:27,420 --> 00:00:29,980
[女人]拍攝9毫米的東西。

9
00:00:29,980 --> 00:00:31,900
也許他看到了狙擊手。

10
00:00:31,900 --> 00:00:34,000
[文]他與他共事。

11
00:00:34,000 --> 00:00:36,330
[女人]等待。回到一個。

12
00:00:36,330 --> 00:00:38,330
[文]你看到了什麼？

13
00:00:38,330 --> 00:00:44,520
[♫懸疑音樂♫]

14
00:00:44,520 --> 00:00:48,320
[女人]把他的臉。全屏。

15
00:00:48,320 --> 00:00:51,230
[文]他的眼鏡。 >>共有的一種體現。

16
00:00:51,230 --> 00:01:00,810
[♫懸疑音樂♫]

17
00:01:00,810 --> 00:01:03,580
[文]這是在Nuevita的棒球隊。這是他們的標誌。

18
00:01:03,580 --> 00:01:07,790
[女人]他在說給誰穿的那件夾克。

19
00:01:07,790 --> 00:01:13,730
>> [大衛·馬蘭]所以，這是CS50 5週，而今天我們為你毀了一個位電視和電影。

20
00:01:13,730 --> 00:01:16,170
所以，每當你看像這樣的在這裡表演，

21
00:01:16,170 --> 00:01:19,910
警察說：“你能不能清理一下？”或“增強”

22
00:01:19,910 --> 00:01:21,900
有沒有提高在現實世界中。

23
00:01:21,900 --> 00:01:25,220
事實上，你真正得到的是這樣一個小東西。

24
00:01:25,220 --> 00:01:27,570
我把從頁面的員工照片之一。

25
00:01:27,570 --> 00:01:30,980
這是一個被稱為Photoshop的。這是1 2 Bowdens

26
00:01:30,980 --> 00:01:36,300
1 3 Bowdens實際上，今天，是因為我們有夫人波頓這裡，Rob和保羅。

27
00:01:36,300 --> 00:01:41,950
但這裡是搶在屏幕上，如果我們放大上，閃閃發光，他總是有他的眼睛，

28
00:01:41,950 --> 00:01:47,600
你看到的就是你所看到的就是你得到的。

29
00:01:47,600 --> 00:01:51,690
這是“增強”，因此“CSI”有點不對勁。

30
00:01:51,690 --> 00:01:55,190
還有另外一個片段，如果我們可以選擇“CSI”只是一點點的時間。

31
00:01:55,190 --> 00:01:58,500
這是一個很好的短語，從今以後，如果你想說出

32
00:01:58,500 --> 00:02:10,280
完善的技術的時候，真的與你的朋友，你是說絕對沒有。

33
00:02:10,280 --> 00:02:12,970
>> [文]幾個星期以來，我一直在調查的馬車夫的殺手謀殺

34
00:02:12,970 --> 00:02:15,360
具有一定的病態的迷戀。

35
00:02:15,360 --> 00:02:17,160
[女人＃1]這是實時的。

36
00:02:17,160 --> 00:02:22,930
[女人]我使用Visual Basic創建一個GUI界面，看看我是否能跟踪一個IP地址。

37
00:02:22,930 --> 00:02:29,570
>> [馬蘭]音頻不同步一旁，創建一個GUI界面，使用Visual Basic

38
00:02:29,570 --> 00:02:31,820
跟踪一個IP地址是完全荒謬的。

39
00:02:31,820 --> 00:02:33,840
這些日子裡，你將不能使用Visual Basic，

40
00:02:33,840 --> 00:02:38,920
有沒有需要一個圖形用戶界面，IP地址是一個技術上準確的術語。

41
00:02:38,920 --> 00:02:41,730
因此，保持一個眼睛，對於這些，我的最愛之一：

42
00:02:41,730 --> 00:02:45,070
這其中的多了幾分神秘的，因為你需要知道不同的語言。

43
00:02:45,070 --> 00:02:47,860
有一種語言叫Objective-C中，這是一個C的超集

44
00:02:47,860 --> 00:02:51,960
這意味著它的C加上一些額外的功能，其中包括面向對象的編程。

45
00:02:51,960 --> 00:02:55,070
這是語言，蘋果已經為iOS編程推廣。

46
00:02:55,070 --> 00:02:58,760
因此，這裡是一個片段從一個完全不同的節目，從“數字”

47
00:02:58,760 --> 00:03:02,450
其實，如果你仔細看你的TiVo和暫停在適當的時候，

48
00:03:02,450 --> 00:03:07,700
你會看到，他們想要的東西是不太所描述的是什麼。

49
00:03:07,700 --> 00:03:11,170
讓我嘗試不同的音頻連接器，看看如果我們不能

50
00:03:11,170 --> 00:03:13,780
保持音頻的同步時間。

51
00:03:13,780 --> 00:03:20,530
我給你的“數字”。

52
00:03:20,530 --> 00:03:23,240
>> [文＃1]這是一個32位的IPv4地址。

53
00:03:23,240 --> 00:03:38,930
[文2]的IP地址，這是互聯網。 >>專用網絡。這是梅艷芳的專用網絡。

54
00:03:38,930 --> 00:03:43,810
[馬蘭]好吧。這是Objective-C，這是一些孩子的著色方案，

55
00:03:43,810 --> 00:03:51,140
你或許可以推斷出變量的名稱。

56
00:03:51,140 --> 00:03:54,410
這樣，那麼，“數字”。所以我們今天和本週介紹

57
00:03:54,410 --> 00:03:57,740
取證和背景的問題，因此世界上的一點點。

58
00:03:57,740 --> 00:04:00,590
今天將是一個簡短的演講，因為在這裡有一個特殊的事件

59
00:04:00,590 --> 00:04:05,530
之後，我們將採取偷看，和逗學生和家長的一致好評今天

60
00:04:05,530 --> 00:04:07,420
一些的東西，是在地平線上。

61
00:04:07,420 --> 00:04:12,240
其中，截至週一，你將有一些更多的同學。

62
00:04:12,240 --> 00:04:16,050
EDX，哈佛和MITS新的在線主動開放課件

63
00:04:16,050 --> 00:04:19,120
多，正在啟動（星期一）在哈佛的校園。

64
00:04:19,120 --> 00:04:21,490
這意味著前來週一，你將有 - 如最近的一次統計，

65
00:04:21,490 --> 00:04:26,210
86,000額外的同學也將會跟隨著CS50的演講

66
00:04:26,210 --> 00:04:29,170
和部分演練和習題集。

67
00:04:29,170 --> 00:04:32,350
作為這項工作的一部分，你會成為會員的首屆類

68
00:04:32,350 --> 00:04:35,090
CS50和現在CS50x。

69
00:04:35,090 --> 00:04:39,310
>> 作為其中的一部分，現在，意識到，會有一些不相上下以及。

70
00:04:39,310 --> 00:04:43,790
要為此做好準備，對於數量龐大的學生，

71
00:04:43,790 --> 00:04:47,180
可以肯定地說，即使我們有108個轉錄因子和CA，

72
00:04:47,180 --> 00:04:50,790
不太最好的學生/教師比例後，我們打80000其他學生。

73
00:04:50,790 --> 00:04:52,850
因此，我們不會被分級這麼多的問題，手動設置。

74
00:04:52,850 --> 00:04:55,920
所以，本週推出的習題集將是CS50檢查，

75
00:04:55,920 --> 00:04:58,450
這將是一個命令行實用程序在設備

76
00:04:58,450 --> 00:05:01,200
一次，你會得到你以後更新本週末，

77
00:05:01,200 --> 00:05:03,200
，你就可以運行一個命令，檢查50

78
00:05:03,200 --> 00:05:06,500
在您自身的pset中，你會得到一些反饋，為您的程序是否

79
00:05:06,500 --> 00:05:11,160
正確的或不正確的，根據我們所提供的各種設計規範。

80
00:05:11,160 --> 00:05:13,580
因此，更多的問題設定的規範和

81
00:05:13,580 --> 00:05:17,240
CS50x同學們將利用這一點。

82
00:05:17,240 --> 00:05:19,230
>> 所以，問題設置4個是所有約取證。

83
00:05:19,230 --> 00:05:21,940
這件作品的靈感來自一些真實的東西，

84
00:05:21,940 --> 00:05:24,620
由此，當我在讀研究生，我實習一段時間，

85
00:05:24,620 --> 00:05:28,650
米德爾塞克斯郡的地區檢察官辦公室從事法醫工作

86
00:05:28,650 --> 00:05:31,650
他們的領導取證調查，這為

87
00:05:31,650 --> 00:05:35,260
，我想我提到的幾個星期過去，是質量國家警察或其他

88
00:05:35,260 --> 00:05:39,000
會來的，他們會脫落的東西，如硬盤驅動器和光盤和軟盤

89
00:05:39,000 --> 00:05:42,340
等，然後取證辦公室的目標是，以確定是否

90
00:05:42,340 --> 00:05:44,600
有或沒有某種形式的證據。

91
00:05:44,600 --> 00:05:48,010
這是特別調查組，所以它是白領犯罪，

92
00:05:48,010 --> 00:05:52,350
更令人不安的是排序的犯罪，

93
00:05:52,350 --> 00:05:55,990
什麼涉及某種數字媒體;原來，沒有那麼多的人

94
00:05:55,990 --> 00:05:59,370
寫一封電子郵件說：“我做到了。”

95
00:05:59,370 --> 00:06:03,290
所以，很多時候，這些取證搜索沒有打開所有的東西，水果，

96
00:06:03,290 --> 00:06:05,850
但有時人們會寫這樣的郵件。

97
00:06:05,850 --> 00:06:08,490
所以有時的努力得到了回報。

98
00:06:08,490 --> 00:06:14,420
>> 但是，得出了這個法醫pset中，我們將介紹在pset中4位的圖形。

99
00:06:14,420 --> 00:06:18,260
所以，你可能把這些東西是理所當然的，JPEG格式，GIF和像這些天，

100
00:06:18,260 --> 00:06:21,640
但如果你真的仔細想想，圖像，就像羅布的臉，

101
00:06:21,640 --> 00:06:24,430
可以建模為一個序列的點，或像素。

102
00:06:24,430 --> 00:06:26,680
現在，在羅布的臉的情況下，有各種顏色，

103
00:06:26,680 --> 00:06:29,940
我們開始看到的各個點，otherwide稱為像素，

104
00:06:29,940 --> 00:06:31,610
一旦我們開始放大。

105
00:06:31,610 --> 00:06:35,590
但是，如果我們簡化了這個世界變得，只是說，這裡是Rob

106
00:06:35,590 --> 00:06:40,560
在黑色和白色，代表黑色和白色，我們可以只使用二進制文件。

107
00:06:40,560 --> 00:06:44,960
如果我們要使用二進制的1或0，我們可以表達這種相同的圖像

108
00:06:44,960 --> 00:06:51,970
Rob的笑臉這種模式位：11000011表示

109
00:06:51,970 --> 00:06:55,160
白，白，黑，黑，黑，黑，白白。

110
00:06:55,160 --> 00:06:59,290
因此，這不是一個巨大的飛躍，然後，開始談論精美圖片。

111
00:06:59,290 --> 00:07:01,920
的東西，你會看到在Facebook或用數碼相機，

112
00:07:01,920 --> 00:07:04,730
但肯定的是，當涉及到顏色，你需要更多的比特。

113
00:07:04,730 --> 00:07:08,470
在世界上的照片相當普遍的是使用1位顏色，

114
00:07:08,470 --> 00:07:12,730
因為這建議，但24位色，你實際上得到數百萬種顏色。

115
00:07:12,730 --> 00:07:15,430
因此，作為的情況下，當我們放大羅布的眼睛上，

116
00:07:15,430 --> 00:07:19,270
這是任何數以百萬計的不同顏色的可能性。

117
00:07:19,270 --> 00:07:22,260
>> 因此，我們就為大家介紹這方面的問題集4以及在演練中，

118
00:07:22,260 --> 00:07:27,050
這將是今天下午3:30，而不是平常的下午2時30分，因為上週五的演講在這裡。

119
00:07:27,050 --> 00:07:29,930
但視頻是在線的，像往常一樣，明天。

120
00:07:29,930 --> 00:07:31,880
我們還將為您介紹另一種文件格式。

121
00:07:31,880 --> 00:07:34,150
因此，這是故意為了看起來嚇人，

122
00:07:34,150 --> 00:07:38,980
但是，這僅僅是一些文件的C結構。

123
00:07:38,980 --> 00:07:42,280
事實證明，微軟，幾年前，捧紅了這種格式，

124
00:07:42,280 --> 00:07:46,630
被稱為位圖文件格式，BMP，這是一個超級簡單的，

125
00:07:46,630 --> 00:07:50,390
豐富多彩的圖形文件格式，使用相當長的一段時間

126
00:07:50,390 --> 00:07:53,640
有時仍然在桌面上的壁紙。

127
00:07:53,640 --> 00:07:57,410
如果你覺得回到了Windows XP和綿延的群山和蔚藍的天空，

128
00:07:57,410 --> 00:08:00,660
這是典型的一個BMP位圖圖像，位圖

129
00:08:00,660 --> 00:08:03,340
是我們的樂趣，因為他們有了更多的複雜性。

130
00:08:03,340 --> 00:08:05,640
這不是一件簡單的事情，因為這格的0和1的;

131
00:08:05,640 --> 00:08:10,680
代替，你必須像一個頭在一個文件的開始的東西。

132
00:08:10,680 --> 00:08:15,520
所以，換句話說，裡面的。bmp文件是0和1的一大堆，

133
00:08:15,520 --> 00:08:18,070
但有一些額外的0和1的在那裡。

134
00:08:18,070 --> 00:08:21,450
而事實證明，我們可能已經多年理所當然的，

135
00:08:21,450 --> 00:08:27,040
doc或xls或。MP3或MP4的文件格式，如，

136
00:08:27,040 --> 00:08:29,910
任何你熟悉的文件格式。

137
00:08:29,910 --> 00:08:31,900
那麼，是什麼它甚至意味著是一個文件格式？

138
00:08:31,900 --> 00:08:35,740
因為在一天結束的時候，我們使用所有這些文件都只是0和1的

139
00:08:35,740 --> 00:08:39,950
也許那些0和1的代表，乙，丙，通過ASCII或等，

140
00:08:39,950 --> 00:08:42,030
但通過一天結束的時候，它只是0和1。

141
00:08:42,030 --> 00:08:45,300
>> 因此，人類只是偶爾決定發明一種新的文件格式

142
00:08:45,300 --> 00:08:49,420
他們規範的位模式，實際上的意思。

143
00:08:49,420 --> 00:08:52,790
在這種情況下，這裡的人誰設計的位圖文件格式

144
00:08:52,790 --> 00:08:58,260
說，在第一個字節中的位圖文件，並標示為偏移0，在那裡，

145
00:08:58,260 --> 00:09:02,320
將是一些神秘命名的變量稱為bfType，

146
00:09:02,320 --> 00:09:06,510
這只是代表了位圖文件的類型，這是什麼類型的位圖文件。

147
00:09:06,510 --> 00:09:10,780
你可以推斷出，或許，從第二排，偏移量為2，第2字節數

148
00:09:10,780 --> 00:09:15,980
有圖案的0和1組成的，代表什麼嗎？

149
00:09:15,980 --> 00:09:18,320
事物的大小，它從那裡。

150
00:09:18,320 --> 00:09:20,660
因此，問題集4中，你會走過一些事情。

151
00:09:20,660 --> 00:09:24,480
>> 我們不會關心所有的人，但是請注意，它開始變得有趣

152
00:09:24,480 --> 00:09:30,780
周圍線或54字節，rgbtBlue，綠色和紅色。

153
00:09:30,780 --> 00:09:35,280
如果你聽說過的縮寫，RGB，紅，綠，藍，這是一個參考。

154
00:09:35,280 --> 00:09:37,840
因為事實證明，你可以畫的彩虹的所有顏色

155
00:09:37,840 --> 00:09:41,580
與紅色，藍色和綠色的某種組合。

156
00:09:41,580 --> 00:09:46,560
而且，事實上，在房間裡的父母可能還記得最早的投影機。

157
00:09:46,560 --> 00:09:49,360
這些天，你只看到1個明亮的光出來的一個鏡頭。

158
00:09:49,360 --> 00:09:52,870
但是，早在一天，你有紅色的鏡片，藍色鏡片，綠色鏡片

159
00:09:52,870 --> 00:09:56,620
和他們一起旨在在屏幕上，並形成了豐富多彩的畫面。

160
00:09:56,620 --> 00:09:59,590
經常中學和高中有那些鏡頭

161
00:09:59,590 --> 00:10:02,680
不斷稍微歪斜，所以你看到雙重或三重影像，

162
00:10:02,680 --> 00:10:07,500
但他的想法。你有紅色，綠色和藍色光畫一幅畫。

163
00:10:07,500 --> 00:10:09,570
在電腦上使用相同的原則。

164
00:10:09,570 --> 00:10:12,000
>> 因此，當中的挑戰，那麼，你在問題設置4

165
00:10:12,000 --> 00:10:16,080
將要幾件事情，一個是調整圖像的大小。

166
00:10:16,080 --> 00:10:18,050
要採取的圖案中的0和1，

167
00:10:18,050 --> 00:10:22,840
找出結構中的這樣的塊0和1的代表，

168
00:10:22,840 --> 00:10:26,800
然後找出如何複製像素的紅色，藍色，果嶺

169
00:10:26,800 --> 00:10:32,460
內，這樣當最初的圖片看起來是這樣的，可能是這樣的，而不是之後。

170
00:10:32,460 --> 00:10:35,590
在其他的挑戰，也將是你會交由

171
00:10:35,590 --> 00:10:38,900
法醫的形象，一個實際的文件從數碼相機

172
00:10:38,900 --> 00:10:42,410
，相機，曾幾何時，一大堆的照片。

173
00:10:42,410 --> 00:10:47,030
問題是，我們不小心刪除或有圖像損壞，不知何故。

174
00:10:47,030 --> 00:10:51,040
數碼相機，不好的事情發生，所以我們很快就複製了所有的0和1的

175
00:10:51,040 --> 00:10:55,410
關閉該卡給你，救了他們一大的文件，然後我們會交給你

176
00:10:55,410 --> 00:11:00,000
在問題設置，讓您可以寫一個程序在C恢復

177
00:11:00,000 --> 00:11:02,660
所有這些JPEG文件，最好。

178
00:11:02,660 --> 00:11:06,280
而事實證明，JPEG文件，即使它們是有點複雜的文件格式，

179
00:11:06,280 --> 00:11:09,580
他們要複雜得多，這笑臉。

180
00:11:09,580 --> 00:11:14,320
事實證明，每一個JPEG相同的模式0和1的開始。

181
00:11:14,320 --> 00:11:18,820
因此，使用一個while循環或循環或類似的，

182
00:11:18,820 --> 00:11:22,350
你可以遍歷所有的0和1這法醫圖像

183
00:11:22,350 --> 00:11:26,670
每次你看到的問題集的規範中定義的特殊模式，

184
00:11:26,670 --> 00:11:29,770
你可以假設，“哦，這裡是具有非常高的概率，

185
00:11:29,770 --> 00:11:33,520
開始的JPEG，只要你找到相同的模式，

186
00:11:33,520 --> 00:11:36,050
一定數目的字節或千字節或兆字節後，

187
00:11:36,050 --> 00:11:40,550
你可以假設，“哦！這是第二個JPEG的照片後，我把第一個。

188
00:11:40,550 --> 00:11:44,720
讓我停止閱讀，第一個文件，開始寫這個新的。“

189
00:11:44,720 --> 00:11:49,980
你的程序的pset 4的輸出將是多達50個JPEG文件。

190
00:11:49,980 --> 00:11:52,400
而且，如果它不是50 JPEG文件，你有一點的循環。

191
00:11:52,400 --> 00:11:55,580
如果你有無限多的JPEG文件，你有一個無限循環。

192
00:11:55,580 --> 00:11:58,280
這樣一來，也將是一個相當普遍的情況。

193
00:11:58,280 --> 00:12:00,280
這是在地平線上。

194
00:12:00,280 --> 00:12:03,740
>> 測驗0，在我們背後。實現的，按我的電子郵件，總是有鄉親

195
00:12:03,740 --> 00:12:06,820
誰是既高興，排序中性，和傷心周圍測驗0時。

196
00:12:06,820 --> 00:12:10,160
請你拿出來給我，頭轉錄因子，Zamyla，你自己的TF

197
00:12:10,160 --> 00:12:14,120
的CA，你知道，如果你想討論如何去。

198
00:12:14,120 --> 00:12:16,460
>> 因此，要在這裡留下深刻印象的父母在房間裡，

199
00:12:16,460 --> 00:12:23,990
是CS50庫？幹得好。

200
00:12:23,990 --> 00:12:32,280
的CS50庫？是嗎？ [學生回答，不知所云]

201
00:12:32,280 --> 00:12:35,730
>>好，好。所以這是一個預先寫好的代碼集，我們的工作人員，寫，

202
00:12:35,730 --> 00:12:38,460
我們提供給你，提供一些常用的功能。

203
00:12:38,460 --> 00:12:42,290
的東西，如給我一個字符串，讓我一個int，此處列出的所有的功能。

204
00:12:42,290 --> 00:12:45,260
從現在起，我們開始真正把這些訓練車輪。

205
00:12:45,260 --> 00:12:48,230
因此，我們要開始你帶走一個“字符串”，

206
00:12:48,230 --> 00:12:52,790
其中，召回，只是一個代名詞什麼實際的數據類型嗎？的char *。

207
00:12:52,790 --> 00:12:57,020
因此，對於家長，這很可能是 - 這是很好的，這樣的char *，我們將開始看到

208
00:12:57,020 --> 00:13:00,810
在屏幕上，更因為我們從我們的詞彙中刪除“字符串”，

209
00:13:00,810 --> 00:13:02,760
至少當涉及到實際編寫代碼。

210
00:13:02,760 --> 00:13:06,240
同樣，我們將停止使用其中的一些功能多，

211
00:13:06,240 --> 00:13:08,390
因為我們的計劃是要變得更加複雜

212
00:13:08,390 --> 00:13:11,370
而不是僅僅寫一個提示，閃爍坐在那裡，

213
00:13:11,370 --> 00:13:13,580
等待用戶輸入一些東西英寸

214
00:13:13,580 --> 00:13:15,220
你會得到你的輸入來自其他地方。

215
00:13:15,220 --> 00:13:18,720
例如，你會得到他們的本地硬盤驅動器上的一系列位。

216
00:13:18,720 --> 00:13:23,340
相反，你會得到他們在未來的網絡連接，一些網站的某個地方。

217
00:13:23,340 --> 00:13:27,460
因此，讓我們剝開這層第一次，並拉起CS50家電

218
00:13:27,460 --> 00:13:32,300
這稱為CS50.h的文件，你已經尖銳包括好幾個星期。

219
00:13:32,300 --> 00:13:34,380
>> 但是，讓我們看到這裡面有什麼。

220
00:13:34,380 --> 00:13:38,250
因此，頂藍色的文件僅僅是一大堆的意見，

221
00:13:38,250 --> 00:13:41,340
保修信息和許可。這是一個共同的範式

222
00:13:41,340 --> 00:13:44,600
軟件，因為很多軟件，這些天是所謂的“開放源碼”

223
00:13:44,600 --> 00:13:46,940
這意味著有人已經寫好的代碼

224
00:13:46,940 --> 00:13:50,060
和自由，而不是僅僅運行和使用，

225
00:13:50,060 --> 00:13:53,660
但實際上讀取和改變，並融入自己的工作。

226
00:13:53,660 --> 00:13:55,790
所以，這就是你一直在使用，開放源代碼軟件，

227
00:13:55,790 --> 00:13:58,030
儘管在一個非常小的形式。

228
00:13:58,030 --> 00:14:01,860
不過，如果我向下滾動過去的意見，我們將開始看到一些比較熟悉的東西。

229
00:14:01,860 --> 00:14:08,090
因此，注意到這裡的頂部，CS50.h文件包括一大堆的頭文件。

230
00:14:08,090 --> 00:14:11,160
現在，這些我們都沒有見過，但一個是

231
00:14:11,160 --> 00:14:15,640
熟悉的，這些我們看到，儘管是短暫的，迄今？

232
00:14:15,640 --> 00:14:18,720
是的，標準庫。 stdlib.h中的malloc，

233
00:14:18,720 --> 00:14:21,590
所以一旦我們開始談論動態內存分配，

234
00:14:21,590 --> 00:14:24,960
我們會回來下週開始，包括該文件。

235
00:14:24,960 --> 00:14:29,660
事實證明，布爾和真假實際上並不存在，在C，本身，

236
00:14:29,660 --> 00:14:32,460
除非你有這個文件在這裡。

237
00:14:32,460 --> 00:14:35,770
因此，我們有好幾個星期，得到了包括標準bool.h

238
00:14:35,770 --> 00:14:39,020
這樣，您可以使用這個概念的一個布爾值，true或false。

239
00:14:39,020 --> 00:14:41,830
沒有這一點，你就必須假的排序，並使用int

240
00:14:41,830 --> 00:14:45,920
只是任意假設0是假的，1是真實的。

241
00:14:45,920 --> 00:14:49,980
>> 現在，如果我們繼續向下滾動，在這裡我們定義一個字符串。

242
00:14:49,980 --> 00:14:54,820
事實證明，正如我們之前所說的，，*其實並不重要。

243
00:14:54,820 --> 00:14:56,750
你甚至可以有空間的限制。

244
00:14:56,750 --> 00:15:01,550
這學期，我們一直在推動它，因為這明確指出，*與類型。

245
00:15:01,550 --> 00:15:05,370
但要意識到，就像常見的，如果沒有一點更常見的，是把它放在那裡

246
00:15:05,370 --> 00:15:07,480
但在功能上是一樣的東西。

247
00:15:07,480 --> 00:15:11,070
但是現在，如果我們讀到進一步下降，讓我們來看看在說，調用getInt，

248
00:15:11,070 --> 00:15:15,350
因為我們使用的是，也許，先天下之憂這個學期。

249
00:15:15,350 --> 00:15:19,620
這裡是調用getInt。這是什麼？

250
00:15:19,620 --> 00:15:24,650
這是原型。所以很多時候，我們已經把原型在我們的頂部。c文件，

251
00:15:24,650 --> 00:15:28,190
但你也可以把原型的頭文件，。h文件，

252
00:15:28,190 --> 00:15:32,110
像這樣的在這裡，所以，當你寫的一些功能

253
00:15:32,110 --> 00:15:36,790
你希望其他人能夠使用，這是​​完全相同的情況下，的CS50庫，

254
00:15:36,790 --> 00:15:40,900
你不僅實現你的功能的東西像CS50.c，

255
00:15:40,900 --> 00:15:46,720
也把原型而不是在該文件的頂部，但在一個頭文件的頂部，

256
00:15:46,720 --> 00:15:50,810
然後，頭文件是什麼樣的朋友和同事，包括，

257
00:15:50,810 --> 00:15:52,800
用鋒利的，包括在自己的代碼。

258
00:15:52,800 --> 00:15:55,440
因此，所有這時候你已經包括所有這些原型

259
00:15:55,440 --> 00:15:59,870
有效地在文件的開頭，但這種尖銳的方式，包括機制

260
00:15:59,870 --> 00:16:03,320
到，從本質上說，這個文件複製和粘貼到您自己的。

261
00:16:03,320 --> 00:16:06,400
現在，這裡是一些比較詳細的文檔。

262
00:16:06,400 --> 00:16:08,880
>> 我們幾乎是理所當然的調用getInt得到一個int，

263
00:16:08,880 --> 00:16:10,740
但事實證明，有一些角落的情況下，對不對？

264
00:16:10,740 --> 00:16:14,320
如果用戶鍵入的數字太大了嗎？

265
00:16:14,320 --> 00:16:17,350
一個三次方，就不能裝進一個int？

266
00:16:17,350 --> 00:16:21,180
什麼是預期的行為嗎？那麼，理想的情況下，這是可預見的。

267
00:16:21,180 --> 00:16:23,460
因此，在這種情況下，如果你真正閱讀印刷精美，

268
00:16:23,460 --> 00:16:27,850
你會看到，如果該行不能被讀取，則返回INT_MAX。

269
00:16:27,850 --> 00:16:30,800
我們從來沒有提到這一點，但其資本額的基礎上，

270
00:16:30,800 --> 00:16:33,030
它是什麼，可能嗎？

271
00:16:33,030 --> 00:16:36,610
這是一個常數，所以它的一些特殊常量，可能宣布

272
00:16:36,610 --> 00:16:39,460
了更高的文件中的這些頭文件之一，

273
00:16:39,460 --> 00:16:43,400
INT_MAX可能是類似的東西，大約2億美元。

274
00:16:43,400 --> 00:16:48,160
的想法是，因為我們需要以某種方式表明的東西出了問題，

275
00:16:48,160 --> 00:16:51,090
是的，我們有我們所掌握的4十億的數字，

276
00:16:51,090 --> 00:16:53,980
負2億美元至2億美元，給予或採取。

277
00:16:53,980 --> 00:16:58,030
那麼，什麼是常見的編程是你偷這些數字。

278
00:16:58,030 --> 00:17:02,250
也許0，也許2十億，也許負2億美元。

279
00:17:02,250 --> 00:17:06,720
所以你用一個可能的值，這樣就可以提交到世界

280
00:17:06,720 --> 00:17:10,089
，如果出現錯誤，我會回到這個超級大的價值。

281
00:17:10,089 --> 00:17:13,329
但你不希望用戶輸入諸如“2，3，4神秘的東西......”

282
00:17:13,329 --> 00:17:17,079
非常大的數字，在那裡你概括，而不是為一個常數。

283
00:17:17,079 --> 00:17:19,380
所以，真的，如果你是肛門過去的幾個星期中，

284
00:17:19,380 --> 00:17:23,800
任何時候，你調用調用getInt，你應該已經檢查的，如果條件。

285
00:17:23,800 --> 00:17:27,109
做了用戶在INT_MAX類型，或者更具體地說，

286
00:17:27,109 --> 00:17:29,900
調用getInt返回INT_MAX？因為如果它這樣做，

287
00:17:29,900 --> 00:17:35,140
實際上意味著他們沒有輸入，在這種情況下，出現了錯誤。

288
00:17:35,140 --> 00:17:38,970
因此，這是通常被稱為一個“哨兵”的價值，這只是意味著什麼。

289
00:17:38,970 --> 00:17:41,020
>> 好了，現在讓我們來打開的。c文件。

290
00:17:41,020 --> 00:17:44,500
C文件已經存在了一段時間的家電，

291
00:17:44,500 --> 00:17:47,540
，事實上，該設備具有預編譯為你

292
00:17:47,540 --> 00:17:49,720
到那個東西我們稱之為“目標代碼”

293
00:17:49,720 --> 00:17:52,940
但它只是對你重要，那是因為系統知道，

294
00:17:52,940 --> 00:17:54,780
在這種情況下，它的位置，該設備。

295
00:17:54,780 --> 00:18:00,620
但是，讓我們現在向下滾動到調用getInt，看看如何調用getInt一直在這麼長的時間。

296
00:18:00,620 --> 00:18:02,380
所以，在這裡，我們從之前也有類似的評論。

297
00:18:02,380 --> 00:18:04,930
讓我放大的代碼部分，

298
00:18:04,930 --> 00:18:07,410
我們調用getInt如下。

299
00:18:07,410 --> 00:18:12,770
它沒有輸入和返回一個int，而（真），所以我們有一個故意的無限循環

300
00:18:12,770 --> 00:18:16,560
但是，據推測，我們將打破這個不知何故，或返回在此。

301
00:18:16,560 --> 00:18:19,890
因此，讓我們來看看它是如何工作的。那麼，我們似乎可以使用GetString

302
00:18:19,890 --> 00:18:22,550
在這第一行內循環，166。

303
00:18:22,550 --> 00:18:25,320
現在，這是很好的做法，因為在什麼樣的情況下，

304
00:18:25,320 --> 00:18:30,820
可能的GetString返回這個特殊的關鍵字，NULL嗎？

305
00:18:30,820 --> 00:18:38,460
如果出現錯誤。什麼可能出問題，當你調用類似的GetString？

306
00:18:38,460 --> 00:18:42,550
是嗎？ [學生回答，不知所云] >>呀。因此，也許malloc失敗。

307
00:18:42,550 --> 00:18:45,310
引擎蓋下方的GetString調用malloc，

308
00:18:45,310 --> 00:18:48,210
它分配內存，這使得計算機存儲

309
00:18:48,210 --> 00:18:50,950
所有的字符，進入鍵盤的用戶類型。

310
00:18:50,950 --> 00:18:53,270
假設用戶有一大堆的空閒時間

311
00:18:53,270 --> 00:18:56,470
和類型化的，例如，超過2十億字符。

312
00:18:56,470 --> 00:18:59,600
甚至有更多的字符比計算機RAM。

313
00:18:59,600 --> 00:19:02,350
是，GetString能夠以表示對你，

314
00:19:02,350 --> 00:19:05,650
即使這是一個超級，超級罕見的角落的情況。

315
00:19:05,650 --> 00:19:08,490
它以某種方式來處理這個問題，所以GetString的，

316
00:19:08,490 --> 00:19:11,850
如果我們回過頭來閱讀其說明文件，不，其實，返回NULL。

317
00:19:11,850 --> 00:19:16,150
現在，如果GetString的失敗，返回NULL，調用getInt是要失敗的

318
00:19:16,150 --> 00:19:19,370
返回INT_MAX，就像一個哨兵。

319
00:19:19,370 --> 00:19:22,650
這些都只是人的約定。只有這樣，你會知道這是

320
00:19:22,650 --> 00:19:24,840
是通過閱讀文檔。

321
00:19:24,840 --> 00:19:28,200
因此，讓我們向下滾動到的詮釋其實是GotInt的地方。

322
00:19:28,200 --> 00:19:34,220
>> 所以，如果我向下滾動位，在170行，我們有意見，以上這些線路。

323
00:19:34,220 --> 00:19:38,470
因此，我們宣布，在172，一個int n和一個字符c，那麼這個新功能

324
00:19:38,470 --> 00:19:41,870
你們中的一些偶然發現之前，但sscanf的。

325
00:19:41,870 --> 00:19:44,190
這代表字符串掃描f。

326
00:19:44,190 --> 00:19:48,580
換句話說，給我一個字符串，我將掃描件信息感興趣。

327
00:19:48,580 --> 00:19:53,820
那麼，是什麼意思呢？好吧，假設我在鍵盤上輸入，從字面上看，1 2 3，

328
00:19:53,820 --> 00:19:59,730
並按下回車鍵。 1 2 3時，由GetString返回的數據類型是什麼？

329
00:19:59,730 --> 00:20:05,010
這顯然是一個字符串，對不對？我有一個字符串，所以1 2 3是真的“1 2 3”

330
00:20:05,010 --> 00:20:07,260
\ 0在它的結束。這不是一個整數。

331
00:20:07,260 --> 00:20:10,420
這不是一個數字。它看起來像一個數字，但它實際上不是。

332
00:20:10,420 --> 00:20:14,680
那麼，是什麼調用getInt有什麼關係？它具有從左向右掃描該字符串，

333
00:20:14,680 --> 00:20:19,010
1 2 3 \ 0，並以某種方式將其轉換為一個實際的整數。

334
00:20:19,010 --> 00:20:21,010
現在，你可以找出如何做到這一點。

335
00:20:21,010 --> 00:20:24,240
如果你覺得回到了pset中2，你大概有一點點舒適

336
00:20:24,240 --> 00:20:26,810
與凱撒的vigenere，這樣你就可以遍歷字符串，

337
00:20:26,810 --> 00:20:29,800
你可以將字符轉換成整數與挑。這是一個大量的工作。

338
00:20:29,800 --> 00:20:32,800
sscanf的，做一個這樣的函數，你為什麼不叫？

339
00:20:32,800 --> 00:20:37,520
因此，sscanf的預計參數，在這種情況下，所謂的線，這是一個字符串。

340
00:20:37,520 --> 00:20:41,310
然後，您可以指定，在引號中，非常類似於printf，

341
00:20:41,310 --> 00:20:44,960
在此字符串你希望看到什麼？

342
00:20:44,960 --> 00:20:52,980
我在這裡說的是什麼，我希望看到一個十進制數，也許一個字符。

343
00:20:52,980 --> 00:20:54,990
我們會看到為什麼是這樣的情況下，在短短的時刻。

344
00:20:54,990 --> 00:20:58,440
事實證明，這個符號是回憶的東西

345
00:20:58,440 --> 00:21:00,840
我們開始談論了一個多星期前。

346
00:21:00,840 --> 00:21:05,430
>> 什麼是＆N＆C為我們做嗎？ [學生回答，不知所云]

347
00:21:05,430 --> 00:21:07,610
>>呀。它給我的地址n和c的地址。

348
00:21:07,610 --> 00:21:10,440
那麼，為什麼那麼重要嗎？嗯，你知道，在C函數

349
00:21:10,440 --> 00:21:13,440
你總是可以返回一個值或沒有價值。

350
00:21:13,440 --> 00:21:16,630
您可以返回一個int，一個字符串，一個浮子，一個字符，不管。

351
00:21:16,630 --> 00:21:21,150
或者你也可以返回void，但你只能返回1最大限度。

352
00:21:21,150 --> 00:21:26,100
但在這裡我們要sscanf的我，也許返回一個int，一個十進制數，

353
00:21:26,100 --> 00:21:29,240
和一個字符，在某一時刻，我會解釋為什麼字符。

354
00:21:29,240 --> 00:21:34,250
因此，您可以有效地希望F返回兩件事情，這是不可能的C.

355
00:21:34,250 --> 00:21:38,460
所以，你可以解決的，通過在2個地址，

356
00:21:38,460 --> 00:21:43,710
因為只要你交給一個功能，2個地址，該功能可以與他們做嗎？

357
00:21:43,710 --> 00:21:49,880
它可以寫入到這些地址。您可以使用*操作和“走出去”，每個地址。

358
00:21:49,880 --> 00:21:54,320
這是這個後門的機制，但很常見的改變變量的值

359
00:21:54,320 --> 00:21:58,020
在超過僅有1的地方，在這種情況下，2。

360
00:21:58,020 --> 00:22:04,590
現在，請注意我檢查==比1，然後返回n如果這樣做，其實，計算結果為true。

361
00:22:04,590 --> 00:22:09,340
所以，這是怎麼回事呢？那麼，在技術上，我們真的要發生在調用getInt是這樣的。

362
00:22:09,340 --> 00:22:12,340
我們要分析，可以這麼說，我們要讀取的字符串

363
00:22:12,340 --> 00:22:16,210
“1 2 3”，如果它看起來像有一些有，

364
00:22:16,210 --> 00:22:21,360
我們告訴sscanf的做的就是把這個數字，1 2 3，在我這個變量n。

365
00:22:21,360 --> 00:22:26,060
那麼，為什麼我有這樣的好了嗎？

366
00:22:26,060 --> 00:22:33,750
也說，sscanf的，你也可能會得到一個字符，在這裡的作用是什麼。

367
00:22:33,750 --> 00:22:36,890
學生來說，不知所云] >>  - 一個小數點工作。

368
00:22:36,890 --> 00:22:40,650
讓我們認為，想了一會兒。還有什麼呢？

369
00:22:40,650 --> 00:22:42,570
[學生，不知所云] >>因此，良好的思想，它可能是NULL字符。

370
00:22:42,570 --> 00:22:44,970
它實際上不是，在這種情況下。是嗎？ [學生，不知所云]

371
00:22:44,970 --> 00:22:47,100
>> >> ASCII。或者，讓我進一步概括。

372
00:22:47,100 --> 00:22:49,670
％c有錯誤檢查。

373
00:22:49,670 --> 00:22:52,510
我們不希望有字符數後，

374
00:22:52,510 --> 00:22:54,980
但讓​​我做的是以下幾點：

375
00:22:54,980 --> 00:23:01,270
事實證明，sscanf的，除了存儲在n和c的值，在這個例子中在這裡，

376
00:23:01,270 --> 00:23:08,170
什麼也沒有返回的變量值英寸

377
00:23:08,170 --> 00:23:13,330
所以，如果你只輸入1 2 3，％d是要匹配

378
00:23:13,330 --> 00:23:18,830
只有n被存儲像1 2 3的值，都不會在c;

379
00:23:18,830 --> 00:23:20,870
C保持一個垃圾值，可以這麼說。

380
00:23:20,870 --> 00:23:23,550
垃圾，因為它從來沒有被初始化為一定的價值。

381
00:23:23,550 --> 00:23:29,390
因此，在這種情況下，sscanf的返回1，因為我填充這些指針之一，

382
00:23:29,390 --> 00:23:33,650
在這種情況下，太棒了。我有一個int，所以我釋放線釋放內存

383
00:23:33,650 --> 00:23:37,150
其實GetString的分配，然後我返回n。

384
00:23:37,150 --> 00:23:42,210
否則，如果你有沒有想過，重試語句，就是這裡。

385
00:23:42,210 --> 00:23:45,770
如果相反，I型1 2 3富，

386
00:23:45,770 --> 00:23:48,640
只是一些隨機序列的文本，，sscanf的是要看到，

387
00:23:48,640 --> 00:23:51,500
哦，數量，哦，數量，哦，數量，噢 -  F。

388
00:23:51,500 --> 00:23:54,190
它打算把1 2 3在n。

389
00:23:54,190 --> 00:23:59,970
這將放置在f中的c，然後返回2。

390
00:23:59,970 --> 00:24:02,980
因此，我們有，只是用scanf函數的行為的基本定義，

391
00:24:02,980 --> 00:24:06,170
一個非常簡單的方法 - 乍一看，複雜的，但在一天結束的時候，

392
00:24:06,170 --> 00:24:11,460
機制相當簡單的說，是有一個int，如果有的話，那件事，我發現嗎？

393
00:24:11,460 --> 00:24:14,950
這裡的空白是故意的。如果你讀的文檔sscanf的，

394
00:24:14,950 --> 00:24:18,690
它會告訴你，如果你有一塊空白的開始或結束，

395
00:24:18,690 --> 00:24:24,990
sscanf的也將允許用戶，無論出於何種原因，打空格鍵1 2 3，，這將是合法的。

396
00:24:24,990 --> 00:24:28,310
只是因為他們打的開頭或結尾的空格鍵，它不會在用戶嚷嚷，

397
00:24:28,310 --> 00:24:32,160
這只是一個小更方便用戶使用。

398
00:24:32,160 --> 00:24:34,160
>> 有任何疑問的話，就GetInts？是嗎？

399
00:24:34,160 --> 00:24:36,820
[學生提問，不知所云]

400
00:24:36,820 --> 00:24:40,740
>>很好的問題。什麼，如果你剛才輸入的一個字符，如f和命中輸入

401
00:24:40,740 --> 00:24:47,830
沒有輸入1 2 3，你怎麼看這行代碼的行為，然後呢？

402
00:24:47,830 --> 00:24:50,500
，所以sscanf的覆蓋太多，因為在這種情況下，

403
00:24:50,500 --> 00:24:56,280
它不會以填補N或C，這是怎麼回事，而不是返回0。

404
00:24:56,280 --> 00:25:01,540
在這種情況下，我也趕上那種情況下，我想是因為預期值1。

405
00:25:01,540 --> 00:25:07,310
我只希望，只有1個東西來填補。這個問題問得好。其他人嗎？

406
00:25:07,310 --> 00:25:09,610
>> 好吧，讓我們不要去所有的功能在這裡，

407
00:25:09,610 --> 00:25:11,820
但，這似乎是，也許，餘下​​權益

408
00:25:11,820 --> 00:25:14,530
GetString的，因為它把GetFloat，調用getInt

409
00:25:14,530 --> 00:25:19,490
GetDouble，GetLongLong所有平底船了很多的功能，GetString的，。

410
00:25:19,490 --> 00:25:22,860
因此，讓我們來看看他是如何在這裡實現。

411
00:25:22,860 --> 00:25:27,040
這一個看起來有點複雜，但它使用相同的基本原理

412
00:25:27,040 --> 00:25:29,680
我們開始談論上週。因此，在GetString時，

413
00:25:29,680 --> 00:25:32,670
它沒有參數，在這裡，每虛空

414
00:25:32,670 --> 00:25:37,110
和它返回一個字符串，所以我聲明了一個字符串緩衝。

415
00:25:37,110 --> 00:25:39,670
我真的不知道那是什麼要用於還，但我們會看到。

416
00:25:39,670 --> 00:25:42,950
看起來像容量，默認情況下，0不太清楚這是怎麼回事。

417
00:25:42,950 --> 00:25:44,920
不知道N的將要用於還。

418
00:25:44,920 --> 00:25:47,860
但現在變得更有趣一些，所以在243，

419
00:25:47,860 --> 00:25:51,760
我們聲明了一個int C，這是一個愚蠢的細節。

420
00:25:51,760 --> 00:25:58,080
char是8位，8位可以存儲多少不同的值嗎？

421
00:25:58,080 --> 00:26:03,310
256。現在的問題是，如果你想有256個不同的ASCII字符，

422
00:26:03,310 --> 00:26:06,210
有，如果你想回來，這是不是記住。

423
00:26:06,210 --> 00:26:09,100
但是，如果你覺得回到了那個大的ASCII圖表，我們有幾個星期前，

424
00:26:09,100 --> 00:26:13,780
有，在這種情況下，128個或256個ASCII字符。

425
00:26:13,780 --> 00:26:16,220
我們使用的所有模式0和1的。

426
00:26:16,220 --> 00:26:19,410
這是一個問題，如果你想成為能夠檢測到一個錯誤。

427
00:26:19,410 --> 00:26:23,290
因為如果你已經使用了256個值，為你的角色，

428
00:26:23,290 --> 00:26:26,390
你真的不提前計劃，因為現在你也沒有辦法說，

429
00:26:26,390 --> 00:26:29,750
“這是不是一個合法的字符，這是一些錯誤的信息。”

430
00:26:29,750 --> 00:26:32,430
因此，世界的是，他們使用的下一個最大的價值，

431
00:26:32,430 --> 00:26:35,790
像int的東西，讓你有一個瘋狂的數位，

432
00:26:35,790 --> 00:26:39,610
32 4億可能的值，這樣你可以簡單地結束了，

433
00:26:39,610 --> 00:26:44,800
基本上，257，1其中有一些特殊的含義為錯誤。

434
00:26:44,800 --> 00:26:49,190
>> 因此，讓我們來看看它是如何工作的。在246行，我有這樣大的while循環

435
00:26:49,190 --> 00:26:54,530
正在調用fgetc函數F含義文件，GETC，然後標準輸入。

436
00:26:54,530 --> 00:26:59,030
原來，這只是說：“從鍵盤讀取輸入更精確的方法。”

437
00:26:59,030 --> 00:27:02,730
標準輸入方式鍵盤，標準輸出屏幕，

438
00:27:02,730 --> 00:27:06,920
和標準錯誤，我們會看到在pset中，是指在屏幕上，

439
00:27:06,920 --> 00:27:09,670
而是一種特殊的屏幕部分，因此，它不是混為一談

440
00:27:09,670 --> 00:27:13,760
與實際輸出，你打算打印，但更多的是在未來。

441
00:27:13,760 --> 00:27:19,430
因此fgetc函數從鍵盤讀取一個字符，並將其存儲在那裡？

442
00:27:19,430 --> 00:27:24,000
將它保存在c，然後檢查，所以我只是在這裡使用一些布爾連詞，

443
00:27:24,000 --> 00:27:28,430
檢查它不等於\ n，所以用戶按下回車鍵。

444
00:27:28,430 --> 00:27:31,510
我們要停止在這一點上，在循環結束，我們還需要檢查

445
00:27:31,510 --> 00:27:36,170
特殊常量，EOF，如果你知道或猜測 - 什麼是代表？

446
00:27:36,170 --> 00:27:39,860
文件結尾。因此，這是一種荒謬的，因為如果我在鍵盤上打字，

447
00:27:39,860 --> 00:27:41,900
真的沒有參與這一​​文件，

448
00:27:41,900 --> 00:27:44,330
但是，這僅僅是排序的通用術語，用來指

449
00:27:44,330 --> 00:27:50,320
，沒有別的來自人類的手指。 EOF。文件結尾。

450
00:27:50,320 --> 00:27:52,600
順便說一句，如果你曾經打你的鍵盤，控制D

451
00:27:52,600 --> 00:27:54,680
不是說你還沒有，你已經打了控制C。

452
00:27:54,680 --> 00:27:57,920
但是，控制D發送這個特殊的常數，稱為EOF。

453
00:27:57,920 --> 00:28:03,100
>> 所以，現在我們只是有一些動態內存分配。

454
00:28:03,100 --> 00:28:06,460
因此，如果n + 1>的能力，現在我將解釋N。

455
00:28:06,460 --> 00:28:09,380
n是目前究竟有多少字節在緩衝區中，

456
00:28:09,380 --> 00:28:11,970
你目前正在建設的字符串從用戶。

457
00:28:11,970 --> 00:28:16,240
如果你有比你有更多的字符在緩衝區中的緩衝能力，

458
00:28:16,240 --> 00:28:20,760
直觀地，我們需要做的，然後被分配更多的容量。

459
00:28:20,760 --> 00:28:24,490
我要掠過的算術

460
00:28:24,490 --> 00:28:26,900
只注重這個功能。

461
00:28:26,900 --> 00:28:29,170
你知道的malloc的是，或者至少是一般熟悉。

462
00:28:29,170 --> 00:28:32,380
什麼realloc的猜測。 [學生回答，不知所云]

463
00:28:32,380 --> 00:28:35,690
>>呀。 ，它不是很新增記憶體，它重新分配內存，例如：

464
00:28:35,690 --> 00:28:40,530
如果在字符串的結尾還是有空間，該內存以使您更

465
00:28:40,530 --> 00:28:43,370
比原來給你，然後你會得到額外的內存。

466
00:28:43,370 --> 00:28:46,640
所以，你可以把字符串的字符背靠背背靠背。

467
00:28:46,640 --> 00:28:49,290
但如果不是這樣的話，因為你等太久

468
00:28:49,290 --> 00:28:51,700
和一些隨機得到了一屁股到內存中，但有額外的

469
00:28:51,700 --> 00:28:56,480
記憶到這裡，那也沒關係。 realloc是要為你做所有的繁重，

470
00:28:56,480 --> 00:28:58,810
移動您已經閱讀因而在離這裡不遠的字符串，

471
00:28:58,810 --> 00:29:02,550
愛不釋手，然後給你一些更多的在這一點上跑道。

472
00:29:02,550 --> 00:29:05,610
因此，一揮手，讓我說，是做什麼的GetString

473
00:29:05,610 --> 00:29:09,540
是它的一個小緩衝區，也許單個字符開始，

474
00:29:09,540 --> 00:29:12,300
如果在2個字符的用戶類型，GetString的結束

475
00:29:12,300 --> 00:29:15,210
調用realloc和說：“噢，1個字符是不夠的。

476
00:29:15,210 --> 00:29:18,480
給我2個字符。然後，如果你讀通過的邏輯循環，

477
00:29:18,480 --> 00:29:21,070
它會說，'噢，用戶輸入3個字符。

478
00:29:21,070 --> 00:29:25,690
現在給我，而不是2 4個字符，然後給我8，然後給我16位和32位。“

479
00:29:25,690 --> 00:29:28,180
事實上，我的能力增加一倍

480
00:29:28,180 --> 00:29:30,320
意味著，緩衝區不會生長緩慢。

481
00:29:30,320 --> 00:29:35,870
這是怎麼回事增長超級快，那可能是什麼優勢？

482
00:29:35,870 --> 00:29:38,540
為什麼我加倍的緩衝區的大小，即使該用戶

483
00:29:38,540 --> 00:29:41,450
可能只需要1個額外的字符從鍵盤嗎？

484
00:29:41,450 --> 00:29:44,830
[學生回答，不知所云]。 >>那是什麼？

485
00:29:44,830 --> 00:29:46,750
沒錯。您不必經常增長。

486
00:29:46,750 --> 00:29:48,870
而這僅僅是一個怎樣的 - 你們在這裡對沖你的賭注。

487
00:29:48,870 --> 00:29:54,150
的想法是，你不希望調用realloc的有很多，因為它往往是緩慢的。

488
00:29:54,150 --> 00:29:56,840
任何時候，你問的操作系統的內存，你很快就會看到

489
00:29:56,840 --> 00:30:00,620
在未來的習題集，它往往需要一定的時間。

490
00:30:00,620 --> 00:30:04,980
因此，最大限度地減少，大量的時間，即使你浪費了一些空間，往往是一件好事。

491
00:30:04,980 --> 00:30:07,250
>> 但是，如果我們在這裡讀通過的最後部分，GetString的，

492
00:30:07,250 --> 00:30:10,880
再次，了解這裡的每一行是不那麼重要的今天。

493
00:30:10,880 --> 00:30:14,830
但是請注意，它最終會再次調用malloc，它分配

494
00:30:14,830 --> 00:30:16,980
一樣多的字節，因為它需要的字符串

495
00:30:16,980 --> 00:30:21,620
然後扔掉，過大的緩衝區，通過調用free

496
00:30:21,620 --> 00:30:23,510
如果它確實得到了太多的時間翻了一倍。

497
00:30:23,510 --> 00:30:25,970
總之，這是多麼的GetString已工作時間。

498
00:30:25,970 --> 00:30:30,100
它的作用是讀取一個字符時，一而再，再而三

499
00:30:30,100 --> 00:30:37,930
而每次需要一些額外的內存，它要求它的操作系統通過調用realloc的。

500
00:30:37,930 --> 00:30:41,660
有什麼問題嗎？好的。

501
00:30:41,660 --> 00:30:45,220
>> 的攻擊。現在，我們理解指針，或至少

502
00:30:45,220 --> 00:30:47,560
越來越熟悉的指針，

503
00:30:47,560 --> 00:30:50,020
讓我們考慮如何在整個世界開始崩潰

504
00:30:50,020 --> 00:30:53,160
如果你不太捍衛對對抗性用戶，

505
00:30:53,160 --> 00:30:55,180
人誰試圖攻入你的系統。

506
00:30:55,180 --> 00:31:00,260
誰是試圖竊取您的軟件繞過一些註冊碼

507
00:31:00,260 --> 00:31:02,150
否則，他們可能有輸入英寸

508
00:31:02,150 --> 00:31:04,860
看一看在這個例子中，這僅僅是C代碼

509
00:31:04,860 --> 00:31:07,920
的底部，有一個main函數的調用函數foo，

510
00:31:07,920 --> 00:31:12,100
又是什麼呢傳遞給foo？ [學生]：一個參數。

511
00:31:12,100 --> 00:31:15,660
>>單參數。所以的argv [1]，這意味著用戶鍵入的第一個字

512
00:31:15,660 --> 00:31:19,150
在命令行後a.out或其他程序調用。

513
00:31:19,150 --> 00:31:24,920
所以foo的頂部，需要一個char *，但char *是什麼？

514
00:31:24,920 --> 00:31:28,860
字符串。這裡沒有什麼新的，而該字符串是任意被稱為酒吧。

515
00:31:28,860 --> 00:31:36,090
在這裡，字符c [12]，半技術英語的排序，這條線是在做什麼？

516
00:31:36,090 --> 00:31:40,640
陣列 - ？字符。給我一個陣列為12個字符。

517
00:31:40,640 --> 00:31:44,970
因此，我們可以稱之為一個緩衝。它在技術上被稱為C，但程序中的緩衝區

518
00:31:44,970 --> 00:31:47,890
只是指一些空間，你可以把一些東西英寸

519
00:31:47,890 --> 00:31:49,940
>> 然後最後，memcpy的，我們還沒有使用過的。

520
00:31:49,940 --> 00:31:52,380
但是，你可能已經猜到它做什麼。它的內存複製。

521
00:31:52,380 --> 00:31:58,790
它有什麼作用呢？那麼，它顯然複製酒吧，它的輸入，轉換成C，

522
00:31:58,790 --> 00:32:03,420
但只有到酒吧的長度。

523
00:32:03,420 --> 00:32:07,440
但有一個錯誤在這裡。

524
00:32:07,440 --> 00:32:14,500
好了，所以在技術上我們確實應該做的strlen（酒吧）x sizeof（char）的的，這是正確的。

525
00:32:14,500 --> 00:32:17,920
但是，在最壞的情況下，在這裡，讓我們假設that's  - 所以，沒關係。

526
00:32:17,920 --> 00:32:23,760
然後有2個錯誤。所以sizeof（char）的的，所有的權利，讓我們使這一點更廣泛。

527
00:32:23,760 --> 00:32:28,860
所以現在仍然是一個錯誤，這是什麼？

528
00:32:28,860 --> 00:32:31,630
[學生回答，不知所云] >>檢查是為了什麼？好了，我們應該檢查

529
00:32:31,630 --> 00:32:35,010
為NULL，因為不好的事情發生時，你的指針為NULL，

530
00:32:35,010 --> 00:32:38,490
因為你可能去那裡，你永遠不應該為NULL

531
00:32:38,490 --> 00:32:40,890
提領*操作符。

532
00:32:40,890 --> 00:32:45,250
所以這是很好的，我們在做什麼？在邏輯上有一個缺陷。

533
00:32:45,250 --> 00:32:47,650
[學生回答，不知所云]

534
00:32:47,650 --> 00:32:51,340
>>因此，檢查如果ARGC≥2，？

535
00:32:51,340 --> 00:32:54,130
好了，所以有3這個程序中的錯誤。

536
00:32:54,130 --> 00:33:00,080
我們不檢查，如果用戶實際上在什麼到argv [1]，良好的輸入。

537
00:33:00,080 --> 00:33:02,240
那麼什麼是第三個錯誤嗎？是嗎？

538
00:33:02,240 --> 00:33:04,420
[學生回答，不知所云] >>好。

539
00:33:04,420 --> 00:33:09,590
所以，我們檢查了一個情景。隱式檢查，請不要複製更多的內存

540
00:33:09,590 --> 00:33:12,800
比超過該長度的酒吧。

541
00:33:12,800 --> 00:33:15,720
因此，如果字符串用戶輸入的長度為10個字符，

542
00:33:15,720 --> 00:33:18,260
這是說，“僅複製10個字符。

543
00:33:18,260 --> 00:33:21,140
這沒關係，但如果用戶在提示符下鍵入一個字

544
00:33:21,140 --> 00:33:29,360
像一個20個字符的字，這是，，說複製20個字符，從酒吧到什麼？

545
00:33:29,360 --> 00:33:32,840
C，否則被稱為我們的緩衝區，這意味著你只是寫數據

546
00:33:32,840 --> 00:33:35,950
8個字節，你沒有自己的位置，

547
00:33:35,950 --> 00:33:38,320
你並不擁有它們在這個意義上，你永遠不分配。

548
00:33:38,320 --> 00:33:41,190
因此，這是一般被稱為緩衝區溢出攻擊，

549
00:33:41,190 --> 00:33:46,650
或緩衝區溢出攻擊，和它的攻擊在這個意義上，如果用戶

550
00:33:46,650 --> 00:33:50,650
或調用你的函數的程序是這樣做的惡意，

551
00:33:50,650 --> 00:33:53,780
到底發生了什麼，未來可能會相當糟糕。

552
00:33:53,780 --> 00:33:55,690
>> 讓我們來看看這張圖片在這裡。

553
00:33:55,690 --> 00:33:59,070
此圖片代表你的內存堆棧。

554
00:33:59,070 --> 00:34:01,050
回想一下，每次你調用一個函數，

555
00:34:01,050 --> 00:34:04,520
你這個小幀在堆棧上，然後再然後另一個。

556
00:34:04,520 --> 00:34:07,250
到目前為止，我們已經只是一種抽象為矩形

557
00:34:07,250 --> 00:34:09,380
要么有在黑板上，或在屏幕上這裡。

558
00:34:09,380 --> 00:34:12,219
但是，如果我們這些矩形中的一個放大，

559
00:34:12,219 --> 00:34:16,460
當你調用一個函數foo，它的出現，更重要的是在棧上

560
00:34:16,460 --> 00:34:18,739
該框架和該矩形內

561
00:34:18,739 --> 00:34:23,370
比是x和y，a和b，就像我們談論交換。

562
00:34:23,370 --> 00:34:25,949
事實證明，有一些較低層次的細節，

563
00:34:25,949 --> 00:34:27,780
在他們返回地址。

564
00:34:27,780 --> 00:34:33,020
因此，原來當主調用foo，主要有告知富

565
00:34:33,020 --> 00:34:36,760
主要是在計算機的內存中的地址。

566
00:34:36,760 --> 00:34:40,659
因為如果不這樣，盡快為foo執行，在這種情況下，這裡，

567
00:34:40,659 --> 00:34:43,790
一旦你達到這種緊密的大括號結束時的foo，

568
00:34:43,790 --> 00:34:48,860
如何赫克富不知道程序的控制，應該去嗎？

569
00:34:48,860 --> 00:34:52,460
事實證明，這個問題的答案是在這裡，紅色的矩形。

570
00:34:52,460 --> 00:34:56,130
這是一個指針，它是電腦存儲，暫時的，

571
00:34:56,130 --> 00:35:00,250
所謂的堆疊上的主地址，以便盡快為foo執行完成，

572
00:35:00,250 --> 00:35:04,110
電腦知道在哪裡和什麼線主要回去。

573
00:35:04,110 --> 00:35:06,900
保存的幀指針與此類似。

574
00:35:06,900 --> 00:35:09,620
CHAR *酒吧代表著什麼？

575
00:35:09,620 --> 00:35:14,740
好了，現在這個藍色的部分是foo的框架，是吧？

576
00:35:14,740 --> 00:35:18,300
好了，所以酒吧是參數的函數foo。

577
00:35:18,300 --> 00:35:20,720
>> 所以現在我們又回到了熟悉的畫面。

578
00:35:20,720 --> 00:35:22,960
還有更多的東西，並在屏幕上的干擾

579
00:35:22,960 --> 00:35:27,490
但這種淡藍色的部分是什麼，我們已經畫在黑板上的東西一樣交換。

580
00:35:27,490 --> 00:35:31,890
這是框架為foo和唯一的，現在是酒吧，

581
00:35:31,890 --> 00:35:34,630
這是此參數。

582
00:35:34,630 --> 00:35:39,840
還有什麼應該是在堆棧中，根據此代碼在這裡？

583
00:35:39,840 --> 00:35:44,280
字符c [12]。因此，我們也應該看到12廣場的內存，

584
00:35:44,280 --> 00:35:46,260
分配給一個變量名為c。

585
00:35:46,260 --> 00:35:48,340
而事實上，我們也有在屏幕上。

586
00:35:48,340 --> 00:35:51,650
最頂端的是c [0]，然後這張圖的作者

587
00:35:51,650 --> 00:35:55,130
沒有理會繪製所有的平方，但確實有12有

588
00:35:55,130 --> 00:36:00,120
因為，如果你看一下在右下角，C [11]，如果算上從0開始，是12個這樣的字節。

589
00:36:00,120 --> 00:36:06,190
但這裡有一個問題：在哪個方向是C成長？

590
00:36:06,190 --> 00:36:10,390
排序的自上而下的，對不對？如果它的頂部開始，並生長至底部，

591
00:36:10,390 --> 00:36:13,480
並不像我們給自己多跑道在這裡。

592
00:36:13,480 --> 00:36:15,320
我們畫種自己陷入了困境，

593
00:36:15,320 --> 00:36:20,210
C [11]是正確的，對吧，這是對堆棧幀指針，

594
00:36:20,210 --> 00:36:23,800
這是對返回地址，有沒有更多的空間。

595
00:36:23,800 --> 00:36:26,100
那麼，有什麼含義，那麼，如果你搞砸了，

596
00:36:26,100 --> 00:36:30,460
您嘗試讀取20字節到12個字節的緩衝區？

597
00:36:30,460 --> 00:36:33,460
這8個額外的字節哪裡去了？

598
00:36:33,460 --> 00:36:36,370
一切裡面，其中有一些是超級重要的。

599
00:36:36,370 --> 00:36:40,480
和最重要的事情，可能是那裡的​​紅色方塊，將返回地址。

600
00:36:40,480 --> 00:36:44,720
因為假設你是個意外或adversarially

601
00:36:44,720 --> 00:36:48,040
覆蓋這4個字節，該指針的地址，

602
00:36:48,040 --> 00:36:53,190
不只是用垃圾，但有一些發生在內存中代表一個實際地址？

603
00:36:53,190 --> 00:36:55,930
什麼是implicaiton，邏輯嗎？

604
00:36:55,930 --> 00:36:59,080
[學生回答，不知所云] >>沒錯。當foo返回

605
00:36:59,080 --> 00:37:03,560
命中，大括號，程序將繼續返回到主，

606
00:37:03,560 --> 00:37:08,320
它會返回的地址是在這紅色框。

607
00:37:08,320 --> 00:37:11,560
>> ，規避軟件登記的情況下，

608
00:37:11,560 --> 00:37:14,400
返回到的地址是什麼是功能

609
00:37:14,400 --> 00:37:18,820
通常被稱為後，你支付的軟件，輸入你的註冊碼？

610
00:37:18,820 --> 00:37:23,160
你可以到這裡不打算的絕招計算機排序，而是，在這裡。

611
00:37:23,160 --> 00:37:27,950
或者，如果你真的很聰明，對手實際上可以輸入在鍵盤上，

612
00:37:27,950 --> 00:37:32,500
例如，而不是實際的單詞，而不是20個字符，但假設他或她

613
00:37:32,500 --> 00:37:36,200
某些字符表示代碼的類型嗎？

614
00:37:36,200 --> 00:37:38,860
它不會是C代碼，這將是字符

615
00:37:38,860 --> 00:37:42,920
的表示二進制機器代碼，0和1的。

616
00:37:42,920 --> 00:37:46,740
但是，假如他們很聰明足以做到這一點，以某種方式粘貼到的GetString提示

617
00:37:46,740 --> 00:37:49,460
的東西，本質上是編譯後的代碼，

618
00:37:49,460 --> 00:37:56,900
最後4個字節覆蓋了返回地址，地址的輸入做呢？

619
00:37:56,900 --> 00:38:01,860
它存儲在這個紅色矩形的緩衝區的第一個字節的地址。

620
00:38:01,860 --> 00:38:04,270
所以，你必須是真聰明，這是一個很大的試驗和錯誤

621
00:38:04,270 --> 00:38:08,500
不好的人，但如果你能弄清楚這個緩衝區有多大，

622
00:38:08,500 --> 00:38:12,170
例如，在輸入最後幾個字節您提供的程序

623
00:38:12,170 --> 00:38:15,970
發生相當於您的緩衝器的起始地址的，

624
00:38:15,970 --> 00:38:22,270
你可以做到這一點。通常情況下，如果我們說，你好，\ 0，也就是在緩衝區。

625
00:38:22,270 --> 00:38:27,860
但是，如果我們更聰明，我們填補了這一緩衝，我們將統稱叫什麼攻擊代碼，

626
00:38:27,860 --> 00:38:31,920
A，A，A，A：攻擊，攻擊，攻擊，攻擊，這是只是做了一件壞事。

627
00:38:31,920 --> 00:38:35,190
好了，會發生什麼，如果你真聰明，你可以這樣做：

628
00:38:35,190 --> 00:38:41,740
在這裡的紅色框是一個數字序列：80，CO，35，08。

629
00:38:41,740 --> 00:38:44,890
請注意，相匹配的數字在這裡。

630
00:38:44,890 --> 00:38:47,280
它以相反的順序，但其他一些時間。

631
00:38:47,280 --> 00:38:51,430
請注意，這個返回地址被故意改變

632
00:38:51,430 --> 00:38:54,970
相同的地址，而不是主要的地址。

633
00:38:54,970 --> 00:39:00,170
因此，如果壞傢伙是超級聰明，他或她將要包括在該攻擊代碼

634
00:39:00,170 --> 00:39:02,890
類似的東西，“刪除所有用戶的文件”。

635
00:39:02,890 --> 00:39:06,320
或“複製密碼”或“創建一個用戶帳戶，我可以登錄到”。

636
00:39:06,320 --> 00:39:10,130
任何東西;這是危險的力量C.

637
00:39:10,130 --> 00:39:12,900
因為你必須通過指針存取記憶體

638
00:39:12,900 --> 00:39:15,950
因此，你可以寫任何你想要到一台計算機的內存中。

639
00:39:15,950 --> 00:39:19,290
你可以讓一台計算機做任何你想要的簡單的

640
00:39:19,290 --> 00:39:22,780
跳在其自己的內存空間。

641
00:39:22,780 --> 00:39:27,230
這樣，為了這一天，讓許多計劃和這麼多的網站被攻破

642
00:39:27,230 --> 00:39:29,730
歸結到人趁著這個。

643
00:39:29,730 --> 00:39:32,510
這似乎是一個超級複雜的攻擊，

644
00:39:32,510 --> 00:39:34,220
但它並不總是這種方式開始。

645
00:39:34,220 --> 00:39:36,770
>> 現實情況是，什麼不好的人通常會做的是，

646
00:39:36,770 --> 00:39:41,470
無論它是一個程序，在命令行或GUI程序或網站，

647
00:39:41,470 --> 00:39:43,290
你剛開始提供廢話。

648
00:39:43,290 --> 00:39:46,940
您鍵入一個真正的大詞在搜索字段並按下回車鍵，

649
00:39:46,940 --> 00:39:49,030
你就等著看，如果網站崩潰。

650
00:39:49,030 --> 00:39:53,270
或者，你等著看，如果程序體現了一些錯誤信息。

651
00:39:53,270 --> 00:39:55,480
因為如果你得到幸運的，因為壞人，

652
00:39:55,480 --> 00:39:59,610
您提供一些瘋狂的投入，導致程序崩潰，

653
00:39:59,610 --> 00:40:02,280
這意味著程序員沒有預料到你的錯誤行為

654
00:40:02,280 --> 00:40:05,420
這意味著，有足夠的精力，你或許可以

655
00:40:05,420 --> 00:40:09,870
足夠的試驗和錯誤，找出如何發動更精確的攻擊。

656
00:40:09,870 --> 00:40:15,900
因此，安全的一部分，不只是避免這些攻擊完全，但檢測

657
00:40:15,900 --> 00:40:20,250
實際上是在尋找日誌，看到什麼瘋狂的輸入輸入到你的網站的人。

658
00:40:20,250 --> 00:40:26,040
什麼樣的搜索字詞輸入到您的網站的人一定的緩衝溢出，希望嗎？

659
00:40:26,040 --> 00:40:28,900
而這一切都可以歸結為簡單的基礎知識，什麼是一個數組，

660
00:40:28,900 --> 00:40:32,510
和是什麼意思分配和使用內存？

661
00:40:32,510 --> 00:40:34,920
相關的，也是這樣的。

662
00:40:34,920 --> 00:40:37,520
>> 因此，讓我們只是看了一眼裡面的硬盤驅動器。

663
00:40:37,520 --> 00:40:40,190
所以，你還記得一兩個星期前，當你拖動文件

664
00:40:40,190 --> 00:40:45,470
回收站或垃圾桶，會發生什麼呢？

665
00:40:45,470 --> 00:40:47,850
[學生]：沒有。 >>是的，絕對沒有。最後，如果你運行低

666
00:40:47,850 --> 00:40:51,370
Windows或Mac OS的磁盤空間，將開始為您刪除的文件。

667
00:40:51,370 --> 00:40:53,670
但是，如果你拖動的東西在那裡，然後它不是在所有的安全。

668
00:40:53,670 --> 00:40:56,550
你的室友，朋友或家庭成員的所有需要​​做的是雙擊，瞧。

669
00:40:56,550 --> 00:40:59,720
所有的粗略的，您嘗試刪除的文件。

670
00:40:59,720 --> 00:41:02,840
所以我們大多數人至少知道，你必須右擊或控制點擊

671
00:41:02,840 --> 00:41:05,320
清空垃圾桶，或類似的東西。

672
00:41:05,320 --> 00:41:07,900
但即便如此，這並不完全做到的伎倆。

673
00:41:07,900 --> 00:41:11,340
由於發生了什麼，當你有你的硬盤驅動器上的文件

674
00:41:11,340 --> 00:41:14,590
一些word文檔或者一些JPEG？

675
00:41:14,590 --> 00:41:18,820
這代表您的硬盤驅動器，讓我們說這個條子在這裡表示該文件，

676
00:41:18,820 --> 00:41:21,640
它是由0和1的一大堆。

677
00:41:21,640 --> 00:41:25,470
會發生什麼事時，你不僅該文件拖動到垃圾桶或回收站，

678
00:41:25,470 --> 00:41:30,390
但也空嗎？

679
00:41:30,390 --> 00:41:32,820
排序無關。這不是絕對沒有。

680
00:41:32,820 --> 00:41:37,630
現在是什麼都沒有，因為少了一些發生在此表的形式。

681
00:41:37,630 --> 00:41:41,170
因此，有一些種類的數據庫或表內的一台計算機的內存

682
00:41:41,170 --> 00:41:44,470
基本上有1列文件名，

683
00:41:44,470 --> 00:41:50,550
1列文件的位置，這可能是位置123，只是一個隨機數。

684
00:41:50,550 --> 00:41:58,270
因此，我們可能有一些像x.jpg和位置123。

685
00:41:58,270 --> 00:42:02,870
然後會發生什麼，當你清空你的垃圾箱嗎？

686
00:42:02,870 --> 00:42:06,720
這消失。但不會消失的“0”和“1”。

687
00:42:06,720 --> 00:42:09,690
>> 那麼是什麼，然後，連接到PSET 4？

688
00:42:09,690 --> 00:42:13,460
好了，pset的4，只是因為我們不小心刪除

689
00:42:13,460 --> 00:42:15,890
緊湊的閃存卡，所有的這些照片，

690
00:42:15,890 --> 00:42:18,710
或者僅僅因為運氣不好它成為損壞，

691
00:42:18,710 --> 00:42:21,170
並不意味著，在0和1的是不是仍然存在。

692
00:42:21,170 --> 00:42:23,920
也許他們幾個人都失去了，因為有東西損壞

693
00:42:23,920 --> 00:42:26,530
在這個意義上，一些0成為1和1的成為“0”。

694
00:42:26,530 --> 00:42:30,460
不好的事情都可能發生，因為軟件bug或有缺陷的硬件。

695
00:42:30,460 --> 00:42:33,510
但許多這些位，也許甚至達到100％，其中仍然存在，

696
00:42:33,510 --> 00:42:38,330
它只是電腦或相機，不知道去哪裡JPEG 1日開始

697
00:42:38,330 --> 00:42:41,660
和JPEG 2開始，但如果你作為程序員，

698
00:42:41,660 --> 00:42:45,800
知道，有點悟性，這些JPEG文件或它們看起來像什麼，

699
00:42:45,800 --> 00:42:49,570
你可以分析出0和1的，並說，'哦。 JPEG。哦，JPEG。

700
00:42:49,570 --> 00:42:52,830
您可以編寫一個程序基本上只是一個while循環

701
00:42:52,830 --> 00:42:56,100
，恢復這些文件中的每一個。

702
00:42:56,100 --> 00:42:59,360
因此，教訓的話，是啟動“安全地”刪除文件

703
00:42:59,360 --> 00:43:01,720
如果你想完全避免這種情況。是嗎？

704
00:43:01,720 --> 00:43:06,940
[學生提問，不知所云]

705
00:43:06,940 --> 00:43:11,150
>>有更多的內存比你以前 - 

706
00:43:11,150 --> 00:43:14,790
哦！這個問題問得好。那麼，為什麼，然後，清空垃圾桶後，

707
00:43:14,790 --> 00:43:18,300
你的計算機告訴你，你有更多的自由空間比您以前嗎？

708
00:43:18,300 --> 00:43:22,450
簡單地說，因為它是在撒謊。技術上，你有更多的空間。

709
00:43:22,450 --> 00:43:26,720
因為現在你所說的，你可以把其他的東西，曾經是該文件，

710
00:43:26,720 --> 00:43:28,930
但是，這並不意味著這些位去，

711
00:43:28,930 --> 00:43:33,070
和，這並不意味著位被改變了這一切“0”，例如，為保護您的利益。

712
00:43:33,070 --> 00:43:37,520
與此相反，如果“安全地”擦除文件，或物理破壞的移動設備，

713
00:43:37,520 --> 00:43:40,810
這確實是唯一的辦法，有時，解決這一問題。

714
00:43:40,810 --> 00:43:45,300
那麼，為什麼我們不離開上，半嚇人的，我們將看到你在週一。

715
00:43:45,300 --> 00:43:52,810
CS50.TV