1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID馬蘭：好的，歡迎回來。

3
00:00:12,580 --> 00:00:13,290
這是CS50。

4
00:00:13,290 --> 00:00:15,130
這是七週的開始。

5
00:00:15,130 --> 00:00:18,890
因此，它已經有一段時間，所以我想我們最好
在哪裡，我們需要旋風之旅

6
00:00:18,890 --> 00:00:20,760
離開的，我們現在要。

7
00:00:20,760 --> 00:00:23,310
>> 所以這個東西在這裡可能有
造成了一定的焦慮在第一。

8
00:00:23,310 --> 00:00:27,680
但我希望，你開始
適應新環境，這表示在這裡 - 

9
00:00:27,680 --> 00:00:32,670
星級代表一個指針，它是
究竟是什麼，更通俗地說？

10
00:00:32,670 --> 00:00:33,400
因此，它是一個地址。

11
00:00:33,400 --> 00:00:35,490
>> 因此，它的地址是
在內存中的東西。

12
00:00:35,490 --> 00:00:38,260
我們開始剝開層層
幾個星期前，事情喜歡

13
00:00:38,260 --> 00:00:41,800
GetString的和其他類似的功能
這一切的時候已經返回

14
00:00:41,800 --> 00:00:46,010
地址在內存中的東西，像
地址中的第一個字符

15
00:00:46,010 --> 00:00:46,990
一些序列。

16
00:00:46,990 --> 00:00:50,360
>> 因此，我們也介紹了valgrind的，
你會開始使用這個問題

17
00:00:50,360 --> 00:00:53,380
設置，尤其是為下一個
問題設置。

18
00:00:53,380 --> 00:00:54,980
valgrind的為我們做什麼？

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
檢查內存洩漏，
檢查濫用記憶。

21
00:01:01,020 --> 00:01:05,890
>> 以一定的概率，它可以檢測，如果
你的代碼將觸摸內存

22
00:01:05,890 --> 00:01:07,100
那根本不應該。

23
00:01:07,100 --> 00:01:10,410
所以不一定洩漏，但如果你
一些超越的界限

24
00:01:10,410 --> 00:01:14,730
數組，並在實際運行Valgrind的
並誘發這種行為，而

25
00:01:14,730 --> 00:01:17,870
Valgrind是運行在你的程序是
它內部的運行，你會得到

26
00:01:17,870 --> 00:01:21,460
這樣的消息 - “無效寫
尺寸4，“記得一對夫婦

27
00:01:21,460 --> 00:01:25,880
兩週前意味著我不得不意外
喜歡上一個int太遠

28
00:01:25,880 --> 00:01:27,250
邊界之外的一個數組。

29
00:01:27,250 --> 00:01:30,790
等大小4表示這裡的大小
該特定的詮釋。

30
00:01:30,790 --> 00:01:35,260
>> 因此，需要安慰的事實，
Valgrind的輸出，它的格式，

31
00:01:35,260 --> 00:01:36,170
僅僅是殘暴的。

32
00:01:36,170 --> 00:01:40,180
這真的很難識破的一塌糊塗
有趣的信息。

33
00:01:40,180 --> 00:01:42,910
所以我們在這裡所做的只是摘錄
一些對情侶更

34
00:01:42,910 --> 00:01:43,850
有趣的線。

35
00:01:43,850 --> 00:01:46,760
但要意識到80％的valgrind
輸出將是一個有點

36
00:01:46,760 --> 00:01:47,650
分心。

37
00:01:47,650 --> 00:01:52,820
>> 只要看看這些模式，如 - 
無效的，正確的，無效的閱讀，40個字節

38
00:01:52,820 --> 00:01:56,690
和一些的塊數是絕對
丟失，這樣的關鍵字。

39
00:01:56,690 --> 00:02:01,920
什麼，你會希望看到的是一些
那種一絲什麼功能

40
00:02:01,920 --> 00:02:03,340
錯誤是實際上英寸的

41
00:02:03,340 --> 00:02:07,195
在這種情況下，在這裡，在哪一行
我的代碼，顯然是錯誤的嗎？

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> 在一個名為memory.c，這是26
例如，我們都在玩

44
00:02:14,130 --> 00:02:14,890
的時間。

45
00:02:14,890 --> 00:02:16,460
所以它可能不是malloc的。

46
00:02:16,460 --> 00:02:18,630
這可能是在我的代碼代替。

47
00:02:18,630 --> 00:02:20,910
因此，我們將再次看到這
前再次長。

48
00:02:20,910 --> 00:02:24,080
>> 因此，scanf函數，這是在一個
夫婦迄今形式。

49
00:02:24,080 --> 00:02:26,410
我們看到sscanf的簡要介紹。

50
00:02:26,410 --> 00:02:28,330
而東西
你在你跳入

51
00:02:28,330 --> 00:02:29,535
準備測驗。

52
00:02:29,535 --> 00:02:33,130
和scanf實際上是什麼CS50
圖書館一直使用下面的

53
00:02:33,130 --> 00:02:36,560
相當長的一段時間，以便罩
得到來自用戶的輸入。

54
00:02:36,560 --> 00:02:40,420
>> 舉例來說，如果我移動到CS50
家電在這裡，讓我開了

55
00:02:40,420 --> 00:02:45,315
比如今天這就是所謂的scanf函數0.C
它的超簡單。

56
00:02:45,315 --> 00:02:46,590
這只是一個幾行代碼。

57
00:02:46,590 --> 00:02:50,880
但它真的演示如何調用getInt
已經工作的這段時間。

58
00:02:50,880 --> 00:02:54,710
>> 在這個程序中在這裡，在第16行
請注意我聲明一個int。

59
00:02:54,710 --> 00:02:57,270
因此，沒有指針，沒有什麼神奇
在那裡，只是一個int。

60
00:02:57,270 --> 00:03:00,330
然後在第17行，我提示
用戶輸入一個數字，請。

61
00:03:00,330 --> 00:03:02,930
然後在18年底，我這裡使用的scanf。

62
00:03:02,930 --> 00:03:06,910
我和規定，一種如printf，
我期待報價

63
00:03:06,910 --> 00:03:08,110
引文結束％。

64
00:03:08,110 --> 00:03:10,920
>> 所以我％，當然，
表示一個int。

65
00:03:10,920 --> 00:03:14,580
但是要注意什麼第二
是scanf函數參數。

66
00:03:14,580 --> 00:03:17,350
你會如何形容第二
逗號後的參數？

67
00:03:17,350 --> 00:03:19,450
那是什麼？

68
00:03:19,450 --> 00:03:20,670
>> 這是x的地址。

69
00:03:20,670 --> 00:03:25,490
因此，這是非常有用的，因為通過提供
scanf函數x的地址，什麼

70
00:03:25,490 --> 00:03:29,560
授權功能怎麼辦？

71
00:03:29,560 --> 00:03:33,010
不只是去那裡，而且還做什麼呢？

72
00:03:33,010 --> 00:03:34,060
>> 它的變化。

73
00:03:34,060 --> 00:03:38,080
因為你可以去那裡，它的排序
就像一張地圖在內存中的位置。

74
00:03:38,080 --> 00:03:41,900
所以只要你提供scanf函數，或
任何這樣的地圖，即功能

75
00:03:41,900 --> 00:03:45,840
功能可以去那裡，不僅
看一看的價值，但它也可以

76
00:03:45,840 --> 00:03:49,670
更改該值，這是有用的，如果
scanf函數在生活中是

77
00:03:49,670 --> 00:03:53,060
掃描來自用戶的輸入，具體
從鍵盤輸入。

78
00:03:53,060 --> 00:03:57,830
和F表示格式化，就像
printf的一個格式化的，f表示

79
00:03:57,830 --> 00:03:58,930
要打印的串。

80
00:03:58,930 --> 00:04:04,430
>> 因此，在短期，簡單地說，此行18，
從用戶的嘗試讀取一個int

81
00:04:04,430 --> 00:04:10,420
鍵盤和它裡面存儲的x，
無論地址x恰巧住在。

82
00:04:10,420 --> 00:04:14,860
然後最後，19號線剛說，
感謝為int的，在這種情況下。

83
00:04:14,860 --> 00:04:15,940
>> 所以，讓我繼續前進，使這個。

84
00:04:15,940 --> 00:04:18,570
所以使：scanf的0。

85
00:04:18,570 --> 00:04:20,130
讓我繼續放大。

86
00:04:20,130 --> 00:04:22,960
我會去，並運行此
點斜線：scanf的0。

87
00:04:22,960 --> 00:04:24,020
號碼好嗎？

88
00:04:24,020 --> 00:04:24,720
50。

89
00:04:24,720 --> 00:04:25,730
感謝為50。

90
00:04:25,730 --> 00:04:27,270
因此，它是相當簡單的。

91
00:04:27,270 --> 00:04:28,160
>> 現在是什麼是不是在做什麼？

92
00:04:28,160 --> 00:04:29,940
這不是做了一大堆
錯誤檢查。

93
00:04:29,940 --> 00:04:33,000
舉例來說，如果我不配合，
我不鍵入一個數字，但

94
00:04:33,000 --> 00:04:37,860
而不是我寫的東西，如“你好”，
這只是一種奇怪的。

95
00:04:37,860 --> 00:04:41,130
因此CS50的事情之一
庫已經為我們做了一些

96
00:04:41,130 --> 00:04:43,440
時間是再次提示
並再次提示。

97
00:04:43,440 --> 00:04:49,320
>> 重試短語召回在cs50.c，
的原因，調用getInt

98
00:04:49,320 --> 00:04:51,670
CS50庫實際上是一個整體
一堆線長，因為我們

99
00:04:51,670 --> 00:04:53,190
檢查這樣的愚蠢的東西。

100
00:04:53,190 --> 00:04:55,730
用戶不要給
我們，其實，一個int？

101
00:04:55,730 --> 00:04:57,910
他或她給我們的東西
像一個字母？

102
00:04:57,910 --> 00:05:01,410
如果是這樣，我們要檢測
，並大聲喝斥。

103
00:05:01,410 --> 00:05:03,915
>> 但是，事情變得更加有趣
在下一個例子。

104
00:05:03,915 --> 00:05:09,840
如果我去scanf函數1.C，什麼是一個
事情是從根本上改變

105
00:05:09,840 --> 00:05:11,135
在下一個例子嗎？

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
我使用char *，當然，
而不是int。

108
00:05:16,010 --> 00:05:19,210
>> 因此，這是有趣的，因為char *，
回想一下，其實只是

109
00:05:19,210 --> 00:05:20,190
同樣的事情串。

110
00:05:20,190 --> 00:05:23,840
所以感覺一樣，也許這是一個超級
GetString的簡單實現。

111
00:05:23,840 --> 00:05:26,010
但我已經去皮層
CS50庫，所以我

112
00:05:26,010 --> 00:05:27,550
現在調用這個char *的。

113
00:05:27,550 --> 00:05:30,070
讓我們看看，如果在任何地方，
我們去錯了。

114
00:05:30,070 --> 00:05:30,840
>> 第17行 - 

115
00:05:30,840 --> 00:05:33,950
我再次說，請你給我的東西，
在這種情況下，一個字符串。

116
00:05:33,950 --> 00:05:37,940
然後在下一行，我調用scanf函數，
再次，給它一個格式碼，

117
00:05:37,940 --> 00:05:39,310
但這次％秒。

118
00:05:39,310 --> 00:05:41,900
那麼這個時候，我
給它的緩衝區。

119
00:05:41,900 --> 00:05:43,550
>> 現在請注意，我沒有使用
符號。

120
00:05:43,550 --> 00:05:47,120
但是，這是為什麼這裡大概OK？

121
00:05:47,120 --> 00:05:49,760
原因是什麼緩衝了嗎？

122
00:05:49,760 --> 00:05:50,770
這已經是一個指針。

123
00:05:50,770 --> 00:05:51,650
它已經一個地址。

124
00:05:51,650 --> 00:05:54,510
>> ，讓我們這個“混淆視聽”，讓我
只是把它，例如，

125
00:05:54,510 --> 00:05:55,050
簡約。

126
00:05:55,050 --> 00:05:58,250
不過，我已經把它稱為緩衝，因為在
一般情況下，在編程中，如果你有一個

127
00:05:58,250 --> 00:06:02,130
大塊的內存，這一個字符串真的
只是，你可以稱之為一個緩衝區。

128
00:06:02,130 --> 00:06:04,460
這是一個地方來存儲信息。

129
00:06:04,460 --> 00:06:07,400
>> 類似的事情，如YouTube，當
他們正在緩衝，可以這麼說，

130
00:06:07,400 --> 00:06:10,270
只是意味著它的下載位
將它們保存在互聯網和

131
00:06:10,270 --> 00:06:14,160
本地陣列，一個地方的內存塊，所以
，你可以看它，以後不

132
00:06:14,160 --> 00:06:16,830
跳躍或掛在
你一邊玩。

133
00:06:16,830 --> 00:06:20,930
>> 所以這是一個問題，但在這裡，
因為我告訴scanf函數，期望

134
00:06:20,930 --> 00:06:22,320
來自用戶的字符串。

135
00:06:22,320 --> 00:06:24,410
這裡的地址是
一塊內存。

136
00:06:24,410 --> 00:06:26,180
把該字符串。

137
00:06:26,180 --> 00:06:31,230
這是為什麼綁定給
給我們帶來麻煩，但？

138
00:06:31,230 --> 00:06:33,490
>> 那是什麼？

139
00:06:33,490 --> 00:06:35,510
我允許訪問
內存的那部分？

140
00:06:35,510 --> 00:06:36,250
你知道，我不知道。

141
00:06:36,250 --> 00:06:39,210
由於緩衝區被初始化
什麼嗎？

142
00:06:39,210 --> 00:06:39,820
真的沒有。

143
00:06:39,820 --> 00:06:43,090
因此，這是我們一直呼籲
垃圾值，這

144
00:06:43,090 --> 00:06:44,040
是不是一個正式的詞。

145
00:06:44,040 --> 00:06:49,200
它只是意味著，我們不知道什麼位
內的四個字節，

146
00:06:49,200 --> 00:06:51,240
我已經分配緩衝區。

147
00:06:51,240 --> 00:06:52,450
>> 我還沒有叫的malloc。

148
00:06:52,450 --> 00:06:53,940
我肯定不叫GetString的。

149
00:06:53,940 --> 00:06:56,380
那麼，誰知道什麼是真正的
緩衝液內？

150
00:06:56,380 --> 00:07:00,550
還告訴scanf的盲目，去那裡
並把任何用戶輸入。

151
00:07:00,550 --> 00:07:04,460
>> 那麼，什麼是可能造成
在我們的代碼中，如果我們運行呢？

152
00:07:04,460 --> 00:07:05,700
大概一個segfault。

153
00:07:05,700 --> 00:07:07,970
也許不是，但可能是一個段錯誤。

154
00:07:07,970 --> 00:07:10,620
和我說，也許不是因為有時
你這樣做，有時

155
00:07:10,620 --> 00:07:11,380
你沒有得到一個段錯誤。

156
00:07:11,380 --> 00:07:14,280
有時候你就是幸運的，但
但是這將是

157
00:07:14,280 --> 00:07:15,340
在我們的程序中的一個bug。

158
00:07:15,340 --> 00:07:17,060
>> 所以，讓我繼續前進，編譯這個。

159
00:07:17,060 --> 00:07:18,280
我要做到這一點老派的方式。

160
00:07:18,280 --> 00:07:23,825
所以鐺破折號scanf函數-1，0，
scanf函數1.C，回車。

161
00:07:23,825 --> 00:07:24,720
哎呀，太舊的學校。

162
00:07:24,720 --> 00:07:26,550
讓我們來看看。

163
00:07:26,550 --> 00:07:28,440
我應該在哪裡？

164
00:07:28,440 --> 00:07:29,700
哦，字符*緩衝區。

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
哦，謝謝你 - 

167
00:07:35,130 --> 00:07:36,930
保存，OK  - 

168
00:07:36,930 --> 00:07:37,690
很老的學校。

169
00:07:37,690 --> 00:07:38,900
好吧，它已經有一段時間。

170
00:07:38,900 --> 00:07:41,720
>> 所以，我剛剛保存後的文件
使該臨時

171
00:07:41,720 --> 00:07:42,700
前改變了一會兒。

172
00:07:42,700 --> 00:07:46,090
現在我已經編譯
手動鏘。

173
00:07:46,090 --> 00:07:49,500
現在我要繼續前進
並運行scanf函數-1，回車。

174
00:07:49,500 --> 00:07:50,290
字符串。

175
00:07:50,290 --> 00:07:51,600
我會鍵入“你好。”

176
00:07:51,600 --> 00:07:54,070
>> 而現在，這裡的地方，坦率地說，PRINTF
可以是有點惱人。

177
00:07:54,070 --> 00:07:56,020
它實際上並不是要
在這種情況下，段錯誤。

178
00:07:56,020 --> 00:07:59,860
printf是有點特殊的，因為
它是如此的超級常用

179
00:07:59,860 --> 00:08:03,570
基本上printf是做
我們贊成和實現，

180
00:08:03,570 --> 00:08:04,830
這不是一個有效的指針。

181
00:08:04,830 --> 00:08:09,080
讓我把它後，我自己只是打印
在括號空，甚至

182
00:08:09,080 --> 00:08:13,340
雖然它不一定是
我們自己的預期。

183
00:08:13,340 --> 00:08:16,940
>> 因此，我們不能真的很容易誘發
段錯誤這一點，但顯然這

184
00:08:16,940 --> 00:08:18,600
是不是我想要的行為。

185
00:08:18,600 --> 00:08:19,800
那麼，有什麼簡單的解決方案？

186
00:08:19,800 --> 00:08:25,650
那麼，在scanf-2，讓我提出，
而不是實際只是分配

187
00:08:25,650 --> 00:08:30,100
的char *，讓我有點小聰明有關
這一點，讓我分配緩衝區

188
00:08:30,100 --> 00:08:32,940
為16個字符的序列。

189
00:08:32,940 --> 00:08:34,200
>> 所以，我可以做到這一點的方式在一對夫婦。

190
00:08:34,200 --> 00:08:35,610
我完全可以使用malloc。

191
00:08:35,610 --> 00:08:38,980
但我可以回去兩個星期時
我只是需要一大堆

192
00:08:38,980 --> 00:08:39,620
字符。

193
00:08:39,620 --> 00:08:40,860
這只是一個數組。

194
00:08:40,860 --> 00:08:44,870
因此，讓我，而不是重新定義緩衝區
是一個數組為16個字符。

195
00:08:44,870 --> 00:08:47,340
>> 而現在，當我通過緩衝區 - 

196
00:08:47,340 --> 00:08:49,940
這是我們沒有的東西
談談在本週二 - 

197
00:08:49,940 --> 00:08:53,730
但你可以把一個數組作為
雖然它是一個地址。

198
00:08:53,730 --> 00:08:56,390
技術上，正如我們已經看到的那樣，他們是
有一點點不同。

199
00:08:56,390 --> 00:09:01,290
但scanf函數不會介意，如果你傳遞給它
數組名，原因是什麼

200
00:09:01,290 --> 00:09:05,030
鐺會為我們做本質上是
作為治療該數組的名稱

201
00:09:05,030 --> 00:09:08,280
16個字節的數據塊的地址。

202
00:09:08,280 --> 00:09:09,550
>> 因此，這是更好的。

203
00:09:09,550 --> 00:09:12,110
這意味著，現在我希望能
做到以下幾點。

204
00:09:12,110 --> 00:09:16,800
讓我縮小了一會兒，
做scanf的-2，編譯OK。

205
00:09:16,800 --> 00:09:19,390
現在讓我做了斜線scanf函數2。

206
00:09:19,390 --> 00:09:22,430
字符串。 “你好。”並且它
似乎工作時間。

207
00:09:22,430 --> 00:09:26,020
>> 但有人提出了一個方案
它仍然可能不工作？

208
00:09:26,020 --> 00:09:28,550
是嗎？

209
00:09:28,550 --> 00:09:30,640
東西超過16個字符。

210
00:09:30,640 --> 00:09:32,020
而實際上，我們可以
更確切的一點。

211
00:09:32,020 --> 00:09:36,540
東西不再那麼15個字符，
因為我們真的需要牢記

212
00:09:36,540 --> 00:09:39,920
我們需要反斜杠零
上面的字符串末尾的隱式

213
00:09:39,920 --> 00:09:42,950
這是一個拋開scanf函數通常會
照顧我們。

214
00:09:42,950 --> 00:09:46,210
>> 因此，讓我做這樣的事情 - 

215
00:09:46,210 --> 00:09:48,040
有時我們就可以
離開它這樣。

216
00:09:48,040 --> 00:09:50,630
好了，我們現在已經引起
我們的分割故障。

217
00:09:50,630 --> 00:09:51,000
為什麼呢？

218
00:09:51,000 --> 00:09:54,940
因為我打字不超過15個
字符，所以我們實際上已經

219
00:09:54,940 --> 00:09:58,280
其實我感動內存
不應該有。

220
00:09:58,280 --> 00:10:00,180
>> 那麼，什麼是真正的解決方案在這裡？

221
00:10:00,180 --> 00:10:02,210
那麼，如果我們需要一個更長的字符串？

222
00:10:02,210 --> 00:10:03,960
好吧，我們也許做32個字節。

223
00:10:03,960 --> 00:10:05,160
那麼，如果不夠長嗎？

224
00:10:05,160 --> 00:10:06,040
大約64個字節？

225
00:10:06,040 --> 00:10:07,080
如果不夠長？

226
00:10:07,080 --> 00:10:09,640
約128或200字節？

227
00:10:09,640 --> 00:10:12,660
什麼是真正的解決方案，在這裡
一般情況下，如果我們不知道在

228
00:10:12,660 --> 00:10:14,460
推進用戶要輸入什麼？

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> 這是一個很大的痛苦的屁股只是一種，
說實話，這是為什麼

231
00:10:23,050 --> 00:10:29,050
CS50庫有幾十行
共同實施的代碼

232
00:10:29,050 --> 00:10:32,390
字符串的方式，我們不這樣做，則由GetString引發
提前知道什麼

233
00:10:32,390 --> 00:10:33,430
用戶將要輸入。

234
00:10:33,430 --> 00:10:37,370
特別是，如果你回頭看看
cs50.c從兩個星期前，你會看到

235
00:10:37,370 --> 00:10:40,480
確實，GetString的
以這種方式不使用的scanf。

236
00:10:40,480 --> 00:10:43,720
相反，它讀取一個字符
的時間。

237
00:10:43,720 --> 00:10:46,010
>> 因為一個美好的事情
我們可以讀取一個字符

238
00:10:46,010 --> 00:10:48,490
保證自己總是
至少有一個字符。

239
00:10:48,490 --> 00:10:51,740
我可以聲明一個char，然後採取
只是這些真正的嬰兒的步驟

240
00:10:51,740 --> 00:10:54,380
在讀取一個字符
從鍵盤輸入的時間。

241
00:10:54,380 --> 00:10:58,240
然後，你會看到的GetString
確實是每次用完，

242
00:10:58,240 --> 00:11:02,280
說，16字節的內存，它使用
malloc的，或一個表弟物，

243
00:11:02,280 --> 00:11:06,810
分配更多的內存，複製舊
內存成新的，然後爬

244
00:11:06,810 --> 00:11:09,900
一直以來，得到一個字符的時間，
當它用完

245
00:11:09,900 --> 00:11:13,370
的內存塊，它扔了出去，待價而沽
更大的內存塊複製舊

246
00:11:13,370 --> 00:11:14,750
進入新的和重複。

247
00:11:14,750 --> 00:11:18,480
，它是一個真正的痛苦其實
實現的東西一樣簡單

248
00:11:18,480 --> 00:11:19,710
得到來自用戶的輸入。

249
00:11:19,710 --> 00:11:21,090
>> 所以，你可以使用scanf函數。

250
00:11:21,090 --> 00:11:22,430
您可以使用其他類似功能。

251
00:11:22,430 --> 00:11:25,420
而很多課本和在線
例子，但他們都

252
00:11:25,420 --> 00:11:27,210
脆弱到這樣的問題。

253
00:11:27,210 --> 00:11:29,550
最終，得到一個segfault
是有點惱人。

254
00:11:29,550 --> 00:11:30,680
這不是為用戶好。

255
00:11:30,680 --> 00:11:33,560
>> 但是，在最壞情況下，這是什麼
它從根本上把你的

256
00:11:33,560 --> 00:11:37,160
代碼的風險嗎？

257
00:11:37,160 --> 00:11:39,250
某種攻擊，有可能。

258
00:11:39,250 --> 00:11:41,680
我們談到了一個這樣的攻擊 - 
堆棧溢出。

259
00:11:41,680 --> 00:11:44,660
但在一般情況下，如果你允許
緩衝區溢出，像我們做了一個

260
00:11:44,660 --> 00:11:48,070
幾個星期前，只是寫
以上的“你好”，你在堆棧上

261
00:11:48,070 --> 00:11:52,330
的確可以考慮，潛在的，
計算機上，或者至少在數據

262
00:11:52,330 --> 00:11:53,510
不屬於你。

263
00:11:53,510 --> 00:11:55,970
>> 因此，在短期，這就是為什麼我們有
這些培訓輪子。

264
00:11:55,970 --> 00:11:59,090
但是現在，我們開始把他們趕走，
因為我們的課程不再需要，

265
00:11:59,090 --> 00:12:00,610
必須的，來自用戶的輸入。

266
00:12:00,610 --> 00:12:03,960
但在問題的情況下，設置6個，
您的輸入將來自一個巨大的

267
00:12:03,960 --> 00:12:07,520
一些字典文件150
奇千言萬語。

268
00:12:07,520 --> 00:12:10,330
>> 所以，你將不必擔心
用戶任意輸入。

269
00:12:10,330 --> 00:12:13,720
我們會給你一些假設
關於該文件。

270
00:12:13,720 --> 00:12:20,340
指針上有任何疑問或scanf
或用戶輸入一般？

271
00:12:20,340 --> 00:12:24,450
>> 所有的權利，所以在一個快速瀏覽一下，然後
尾隨從兩個星期前的話題。

272
00:12:24,450 --> 00:12:28,590
這是一個struct這個概念。

273
00:12:28,590 --> 00:12:34,180
不 - 這個概念，
結構，這是什麼？

274
00:12:34,180 --> 00:12:35,430
什麼結構為我們做什麼？

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> 定義 - 

277
00:12:39,860 --> 00:12:41,710
對不起？

278
00:12:41,710 --> 00:12:42,820
定義一個變量的類型。

279
00:12:42,820 --> 00:12:44,410
因此，排序。

280
00:12:44,410 --> 00:12:46,180
其實我們兩個主題結合。

281
00:12:46,180 --> 00:12:49,510
因此，用typedef，回想一下，我們可以
聲明一個類型，像我們自己的

282
00:12:49,510 --> 00:12:51,500
的代名詞，就像字符串的char *。

283
00:12:51,500 --> 00:12:56,200
但是，我們可以使用typedef和結構
真正創造我們自己的數據結構。

284
00:12:56,200 --> 00:12:59,600
>> 舉例來說，如果我回去到gedit中
這裡只是一個瞬間，我先走

285
00:12:59,600 --> 00:13:08,230
做這樣的事情，讓我節省
本作，讓我們說，structs.c

286
00:13:08,230 --> 00:13:10,840
暫時我只是
繼續前進，包括

287
00:13:10,840 --> 00:13:14,360
standardio.h，INT主要無效。

288
00:13:14,360 --> 00:13:18,960
然後在這裡，假設，我想
寫一個程序，存儲

289
00:13:18,960 --> 00:13:21,840
多個學生從多個
房屋，例如。

290
00:13:21,840 --> 00:13:24,430
因此，它是像一個registrarial的
某種數據庫。

291
00:13:24,430 --> 00:13:29,550
>> 所以，如果我需要一個學生的名字，我
可能會做一些像char *的名稱，

292
00:13:29,550 --> 00:13:31,570
我會做這樣的事情 - 

293
00:13:31,570 --> 00:13:34,410
其實，讓我們使用CS50庫
只是一瞬間，使這個

294
00:13:34,410 --> 00:13:38,380
簡單一點的，所以我們可以借用
那些幾十行代碼。

295
00:13:38,380 --> 00:13:39,340
只是，讓我們保持它的簡單。

296
00:13:39,340 --> 00:13:42,610
我們會保持它的字符串，
現在則由GetString引發。

297
00:13:42,610 --> 00:13:47,420
>> 因此，我要求現在，我已經存儲的名稱
一些學生，房子

298
00:13:47,420 --> 00:13:50,240
一些學生，只需使用變量
像我們一樣，在第一個星期。

299
00:13:50,240 --> 00:13:52,370
但是，假設我現在要支持
多個學生。

300
00:13:52,370 --> 00:13:58,460
好吧，讓我的直覺是做
字符串名稱2，得到的GetString，串

301
00:13:58,460 --> 00:14:01,370
house2得到的GetString。

302
00:14:01,370 --> 00:14:05,850
然後我們的第三個學生，
讓我們做NAME3 GetString的。

303
00:14:05,850 --> 00:14:09,170
>> 所有的權利，所以這是希望引人注目
作為一種愚蠢的，

304
00:14:09,170 --> 00:14:11,580
因為這個過程是真的從來沒有
將要結束，它只是要

305
00:14:11,580 --> 00:14:13,130
使我的代碼看起來更糟糕
和每況愈下。

306
00:14:13,130 --> 00:14:14,810
但我們解決了這個在本週二也。

307
00:14:14,810 --> 00:14:19,450
我們比較乾淨的解決方案是什麼
當我們有多個變量，

308
00:14:19,450 --> 00:14:23,580
相同的數據類型都有關，但
我們不希望這種殘暴的混亂

309
00:14:23,580 --> 00:14:26,870
同樣命名的變量？

310
00:14:26,870 --> 00:14:30,060
我們做了什麼呢？

311
00:14:30,060 --> 00:14:31,260
>> 所以我想我聽到了幾個地方。

312
00:14:31,260 --> 00:14:32,590
我們有一個數組。

313
00:14:32,590 --> 00:14:37,110
如果你想的多個實例
的東西，為什麼不要我們清理這一切

314
00:14:37,110 --> 00:14:39,540
，只是說，給我
數組的名字呢？

315
00:14:39,540 --> 00:14:41,640
>> 現在，讓我們的硬編碼3。

316
00:14:41,640 --> 00:14:44,450
然後給我另一個數組
稱為房子，讓我

317
00:14:44,450 --> 00:14:45,800
現在硬編碼3。

318
00:14:45,800 --> 00:14:49,220
而且我已經大規模清理
亂，我只是創建。

319
00:14:49,220 --> 00:14:52,400
現在，我還是硬編碼3，但即使
3可以動態來自

320
00:14:52,400 --> 00:14:54,350
用戶，或者argv的或類似。

321
00:14:54,350 --> 00:14:55,720
所以這已經是清潔。

322
00:14:55,720 --> 00:15:00,100
>> 但惱人的是，
現在，即使名字是某種

323
00:15:00,100 --> 00:15:02,280
根本聯繫
學生的家 - 

324
00:15:02,280 --> 00:15:04,720
這是一個學生，我真的
要代表 - 

325
00:15:04,720 --> 00:15:08,080
我現在有兩個平行的陣列
在這個意義上，他們是

326
00:15:08,080 --> 00:15:13,930
相同的大小，名稱托架0
想必映射到房子支架0，

327
00:15:13,930 --> 00:15:16,600
和名稱支架1地圖
房屋支架1。

328
00:15:16,600 --> 00:15:19,280
換句話說，該學生生活在
那房子，房子和其他學生

329
00:15:19,280 --> 00:15:20,530
生活在其他的房子。

330
00:15:20,530 --> 00:15:23,720
但可以肯定，這可能是
做得更乾淨。

331
00:15:23,720 --> 00:15:24,990
>> 好吧，它可以，其實。

332
00:15:24,990 --> 00:15:28,730
並讓我繼續前進，打開
了structs.h，你會

333
00:15:28,730 --> 00:15:31,130
在這裡看到這個想法。

334
00:15:31,130 --> 00:15:34,905
請注意，我用的typedef，因為你
剛才提到申報我們

335
00:15:34,905 --> 00:15:35,570
自己的數據類型。

336
00:15:35,570 --> 00:15:39,660
但是，我也使用此關鍵字
稱為struct這給了我一個新的

337
00:15:39,660 --> 00:15:40,790
的數據結構。

338
00:15:40,790 --> 00:15:43,980
>> 而這一數據結構，我要求是怎麼回事
有兩件事情裡面

339
00:15:43,980 --> 00:15:47,060
 - 一個字符串名為name，
一個字符串，稱為房子。

340
00:15:47,060 --> 00:15:49,820
和名字我要去給
將這樣的數據結構

341
00:15:49,820 --> 00:15:51,005
被稱為學生。

342
00:15:51,005 --> 00:15:54,030
我可以打電話給我想要的任何東西，
但這種語義

343
00:15:54,030 --> 00:15:55,810
我感覺到，在我的腦海裡。

344
00:15:55,810 --> 00:15:59,160
>> 所以，現在，如果我打開了一個更好的版本
的節目，我開始寫

345
00:15:59,160 --> 00:16:00,390
那裡，讓我滾動到頂部。

346
00:16:00,390 --> 00:16:03,190
還有一些更多的代碼行
在這裡，但讓我專注

347
00:16:03,190 --> 00:16:04,160
一個時刻。

348
00:16:04,160 --> 00:16:07,790
我宣布一個恆定的所謂學生
硬編碼的現在。

349
00:16:07,790 --> 00:16:11,110
但現在，注意到何潔
我的代碼開始就搞定了。

350
00:16:11,110 --> 00:16:15,030
>> 在22行，我宣布
陣列的學生。

351
00:16:15,030 --> 00:16:18,760
並注意學生顯然是
現在的數據類型。

352
00:16:18,760 --> 00:16:23,360
因為在頂部的文件，通知
我已經包含了該頭文件

353
00:16:23,360 --> 00:16:24,820
我拉起剛才。

354
00:16:24,820 --> 00:16:28,820
該頭文件很簡單
這個定義一個學生。

355
00:16:28,820 --> 00:16:32,470
>> 所以，現在，我創建了自己的自定義數據
類型，作者的C年

356
00:16:32,470 --> 00:16:33,890
前事先沒有想到的。

357
00:16:33,890 --> 00:16:34,570
但沒有問題。

358
00:16:34,570 --> 00:16:35,870
我可以做自己。

359
00:16:35,870 --> 00:16:39,050
所以這是一個陣列稱為學生，
其每名成員

360
00:16:39,050 --> 00:16:41,100
是學生結構。

361
00:16:41,100 --> 00:16:44,270
我想三個
在數組中。

362
00:16:44,270 --> 00:16:46,030
>> 而現在，沒有休息
這個程序怎麼辦？

363
00:16:46,030 --> 00:16:47,550
我需要的東西有點武斷。

364
00:16:47,550 --> 00:16:51,450
因此，從24日起在網上，
我遍歷從0到3。

365
00:16:51,450 --> 00:16:54,000
然後我再問用戶
學生的名字。

366
00:16:54,000 --> 00:16:56,110
然後我用則由GetString引發如前。

367
00:16:56,110 --> 00:16:59,410
然後，我問學生的房子，
我用則由GetString引發像以前那樣。

368
00:16:59,410 --> 00:17:01,780
>> 但通知 - 稍微新
一塊語法 - 

369
00:17:01,780 --> 00:17:07,010
我仍然可以索引到的第i個學生，
但我怎麼得到的具體數據

370
00:17:07,010 --> 00:17:08,354
領域裡面的結構嗎？

371
00:17:08,354 --> 00:17:11,770
那麼，什麼是顯然
新語法？

372
00:17:11,770 --> 00:17:13,339
這僅僅是點操作符。

373
00:17:13,339 --> 00:17:14,510
>> 這之前，我們還沒有真正見過。

374
00:17:14,510 --> 00:17:17,819
你已經看到了它的pset五，如果你
已經跌位圖文件。

375
00:17:17,819 --> 00:17:22,372
但點只是意味著在這裡面，
結構或多個領域，給點

376
00:17:22,372 --> 00:17:24,510
名稱，或者給我點的房子。

377
00:17:24,510 --> 00:17:28,690
這意味著內部結構
得到這些特定的領域。

378
00:17:28,690 --> 00:17:30,200
>> 這個程序的其餘部分做什麼？

379
00:17:30,200 --> 00:17:31,190
這還不是全部，性感。

380
00:17:31,190 --> 00:17:34,640
請注意，我再次循環從0到3，
我只是創造英語

381
00:17:34,640 --> 00:17:40,500
短語，比如某某等
這樣的房子，通過在點名稱

382
00:17:40,500 --> 00:17:43,320
的第i個學生和他們的
房子，以及。

383
00:17:43,320 --> 00:17:47,560
>> 最後，現在我們將開始得到
肛門，現在我們

384
00:17:47,560 --> 00:17:49,580
熟悉什麼malloc和
其他功能已經

385
00:17:49,580 --> 00:17:50,570
做這一切的時候。

386
00:17:50,570 --> 00:17:54,220
為什麼我一定要釋放這兩個名字
和房子，即使我

387
00:17:54,220 --> 00:17:56,960
沒有調用malloc？

388
00:17:56,960 --> 00:17:58,020
>> GetString的了。

389
00:17:58,020 --> 00:18:00,930
那是骯髒的小秘密
幾個星期，但GetString的

390
00:18:00,930 --> 00:18:03,530
遍布洩漏內存
把所有學期迄今為止。

391
00:18:03,530 --> 00:18:05,990
valgrand終於將
揭示給我們。

392
00:18:05,990 --> 00:18:10,730
>> 但是，它不是一個大不了的，因為我知道，
我可以簡單地釋放名稱

393
00:18:10,730 --> 00:18:15,750
和房子，雖然在技術上，
超強，安全，應該是我

394
00:18:15,750 --> 00:18:17,890
做一些錯誤檢查。

395
00:18:17,890 --> 00:18:19,040
什麼是你的直覺告訴你嗎？

396
00:18:19,040 --> 00:18:22,480
我應該怎麼檢查
之前，我釋放什麼是

397
00:18:22,480 --> 00:18:25,470
字符串，又名一個char *？

398
00:18:25,470 --> 00:18:33,460
>> 我真的應該進行檢查，如果學生
支架I點名稱不

399
00:18:33,460 --> 00:18:34,840
等於空。

400
00:18:34,840 --> 00:18:40,400
然後，它會確定先走，並免費
該指針，相同或其他

401
00:18:40,400 --> 00:18:41,160
別人。

402
00:18:41,160 --> 00:18:46,860
如果學生支架I點的房子是不是
等於為null，這將保護

403
00:18:46,860 --> 00:18:52,520
對角落的情況
的形式返回類似空。

404
00:18:52,520 --> 00:18:57,310
而且我們剛才也看到了，printf的
保護我們在這裡只是說

405
00:18:57,310 --> 00:18:58,990
null，這是怎麼回事，看起來很怪異。

406
00:18:58,990 --> 00:19:02,340
但至少它不會出現段錯誤，
正如我們所看到。

407
00:19:02,340 --> 00:19:05,990
>> 好吧，讓我在這裡做另一件事。
結構-0是​​一個愚蠢的計劃

408
00:19:05,990 --> 00:19:09,700
因為我輸入所有數據，然後
它失去了，一旦程序結束。

409
00:19:09,700 --> 00:19:10,940
但是，讓我繼續前進，做到這一點。

410
00:19:10,940 --> 00:19:12,830
讓我做終端
窗口有點大了。

411
00:19:12,830 --> 00:19:17,000
讓我結構-1，
這是一個新版本。

412
00:19:17,000 --> 00:19:18,520
>> 我會在一點點放大。

413
00:19:18,520 --> 00:19:21,620
現在讓我跑點
削減結構1。

414
00:19:21,620 --> 00:19:22,590
學生的名字 - 

415
00:19:22,590 --> 00:19:31,500
大衛·馬瑟，讓我們做羅布·柯克蘭，
讓勞倫利維瑞特。

416
00:19:31,500 --> 00:19:33,650
現在是什麼有趣的通知 - 

417
00:19:33,650 --> 00:19:35,540
我只知道這是因為
我寫的程序 - 

418
00:19:35,540 --> 00:19:38,930
現在我目前有一個文件
目錄students.csv。

419
00:19:38,930 --> 00:19:40,420
你們當中有些人可能已經看到
這些在現實世界中。

420
00:19:40,420 --> 00:19:42,980
>> 什麼是CSV文件？

421
00:19:42,980 --> 00:19:44,170
逗號分隔值。

422
00:19:44,170 --> 00:19:46,670
它有點像一個窮人的
版本的Excel文件。

423
00:19:46,670 --> 00:19:50,580
這是一個表中的行和列，
你可以打開一個程序如Excel，

424
00:19:50,580 --> 00:19:51,800
或在Mac上的數字。

425
00:19:51,800 --> 00:19:55,180
>> 如果我在這裡打開此文件gedit中，
通知 - 數字是不存在的。

426
00:19:55,180 --> 00:19:57,360
這只是gedit的告訴
我行號。

427
00:19:57,360 --> 00:19:59,740
的第一行通知
文件是大衛和馬瑟。

428
00:19:59,740 --> 00:20:01,450
下一行是羅布逗號柯克蘭。

429
00:20:01,450 --> 00:20:04,170
第三行是勞倫
逗號利維瑞特。

430
00:20:04,170 --> 00:20:05,480
>> 所以，我創建了什麼？

431
00:20:05,480 --> 00:20:09,580
我現在寫的C程序
可以有效地生成電子表格

432
00:20:09,580 --> 00:20:11,840
可以打開在
如Excel程序。

433
00:20:11,840 --> 00:20:15,520
並非所有引人注目的一個數據集，但
如果你有更大的大塊

434
00:20:15,520 --> 00:20:18,440
數據，你其實是要
操縱，使圖表和

435
00:20:18,440 --> 00:20:21,260
喜歡，這也許是一個
的方式來創建數據。

436
00:20:21,260 --> 00:20:25,370
此外，特裝車點實際上超共同
只是簡單的數據存儲 - 

437
00:20:25,370 --> 00:20:28,940
雅虎財經，舉例來說，如果你得到
通過他們所謂的股票行情

438
00:20:28,940 --> 00:20:33,180
API的免費服務，讓您
獲取當前到最新的庫存

439
00:20:33,180 --> 00:20:35,650
公司的報價，他們
在給數據

440
00:20:35,650 --> 00:20:37,800
超簡單的CSV格式。

441
00:20:37,800 --> 00:20:39,380
>> 所以，我們是怎麼做到的呢？

442
00:20:39,380 --> 00:20:42,530
注意到，這一計劃的最
幾乎是相同的。

443
00:20:42,530 --> 00:20:46,870
但是請注意，在這裡，而不是打印
學生，上線35

444
00:20:46,870 --> 00:20:51,040
開始，我要求我保存
學生到磁盤，保存文件。

445
00:20:51,040 --> 00:20:53,630
>> 因此，注意到我聲明一個FILE *  - 

446
00:20:53,630 --> 00:20:57,260
現在，這是一種異常C.
無論出於何種原因，文件是全部大寫，

447
00:20:57,260 --> 00:21:00,690
這是不是像大多數其他數據類型
但是這是一個內置的

448
00:21:00,690 --> 00:21:02,320
數據類型，文件*。

449
00:21:02,320 --> 00:21:05,900
我聲明一個指針到一個文件，
你怎麼能想到的。

450
00:21:05,900 --> 00:21:08,070
>> FOPEN意味著打開的文件。

451
00:21:08,070 --> 00:21:09,470
你想打開什麼文件？

452
00:21:09,470 --> 00:21:12,620
我想打開一個文件，我將
任意調用students.csv。

453
00:21:12,620 --> 00:21:14,480
我可以打電話，我想要的任何東西。

454
00:21:14,480 --> 00:21:15,200
>> 再取一個猜測。

455
00:21:15,200 --> 00:21:18,960
第二個參數做什麼
FOPEN大概是這個意思嗎？

456
00:21:18,960 --> 00:21:21,480
右，w代表寫，
是讀r為。

457
00:21:21,480 --> 00:21:24,120
還有一個附加的，如果你
要添加行，而不是

458
00:21:24,120 --> 00:21:25,200
覆蓋整個事情。

459
00:21:25,200 --> 00:21:28,005
>> 但我只是想創建這個文件
一次，所以我會使用報價引文結束瓦特。

460
00:21:28,005 --> 00:21:31,880
而且我知道，只有在讀取
文檔或手冊頁。

461
00:21:31,880 --> 00:21:35,100
如果文件不為空 - 換句話說，
如果沒事就去那裡錯了 - 

462
00:21:35,100 --> 00:21:37,820
讓我遍歷
從0到3的學生。

463
00:21:37,820 --> 00:21:40,410
>> 現在注意到有什麼東西
曾經如此略有不同

464
00:21:40,410 --> 00:21:42,110
行約41。

465
00:21:42,110 --> 00:21:42,960
這不是printf的。

466
00:21:42,960 --> 00:21:46,530
fprintf printf的文件。

467
00:21:46,530 --> 00:21:47,790
因此，它會寫入文件。

468
00:21:47,790 --> 00:21:48,860
哪個文件？

469
00:21:48,860 --> 00:21:53,630
您指定的指針
作為第一個參數。

470
00:21:53,630 --> 00:21:55,940
>> 然後，我們指定格式字符串。

471
00:21:55,940 --> 00:21:59,660
然後，我們指定我們想要什麼字符串
插頭的第一％S和

472
00:21:59,660 --> 00:22:04,320
然後另一個變量或
第二個％秒。

473
00:22:04,320 --> 00:22:06,760
然後關閉文件FCLOSE。

474
00:22:06,760 --> 00:22:09,380
比我釋放內存之前，雖然
我應該回去，並添加

475
00:22:09,380 --> 00:22:10,540
一些檢查為空。

476
00:22:10,540 --> 00:22:12,090
>> 就是這樣。

477
00:22:12,090 --> 00:22:16,960
FOPEN，fprintf等FCLOSE給我
創建文本文件的能力。

478
00:22:16,960 --> 00:22:19,640
現在，你會看到問題集五，
涉及圖像，您將使用

479
00:22:19,640 --> 00:22:20,990
二進制文件來代替。

480
00:22:20,990 --> 00:22:24,200
但是從根本上說，這個想法是一樣的，
即使功能，你會

481
00:22:24,200 --> 00:22:28,710
看到的是有一點點不同。

482
00:22:28,710 --> 00:22:32,580
>> 所以旋風之旅，但你會得到
太熟悉文件I/O--

483
00:22:32,580 --> 00:22:34,960
輸入和輸出 -  pset中五。

484
00:22:34,960 --> 00:22:38,607
而任何疑問
初始的基礎在這裡？

485
00:22:38,607 --> 00:22:39,857
是嗎？

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> 如果你試圖釋放一個空值？

488
00:22:43,710 --> 00:22:48,880
我相信，除非已經得到了自由
對用戶來說更加友好，你可以

489
00:22:48,880 --> 00:22:49,890
潛在的段錯誤。

490
00:22:49,890 --> 00:22:54,160
它傳遞空是不好的，因為我不
相信自由困擾為你檢查，

491
00:22:54,160 --> 00:22:57,330
因為它可能會是浪費
為它做自己的時間

492
00:22:57,330 --> 00:22:59,022
在世界上的每個人。

493
00:22:59,022 --> 00:23:00,590
好問題，雖然。

494
00:23:00,590 --> 00:23:04,300
>> 好，那麼這種得到
我們一個有趣的話題。

495
00:23:04,300 --> 00:23:07,010
習題集的主題
五是取證。

496
00:23:07,010 --> 00:23:08,420
至少這是一個部分
問題集。

497
00:23:08,420 --> 00:23:12,030
取證一般是指在
恢復的信息，可能或

498
00:23:12,030 --> 00:23:14,110
可能沒有被刪除
故意的。

499
00:23:14,110 --> 00:23:18,680
所以我想，我想給你一個快速
什麼味道真的

500
00:23:18,680 --> 00:23:21,230
下面這段時間
引擎蓋您的計算機。

501
00:23:21,230 --> 00:23:23,960
>> 舉例來說，如果你裡面有你
筆記本電腦或桌面電腦一

502
00:23:23,960 --> 00:23:28,040
硬盤驅動器，它可以通過機械
設備實際旋轉 - 

503
00:23:28,040 --> 00:23:31,650
有圓形的東西稱為盤片
看起來很喜歡我

504
00:23:31,650 --> 00:23:34,540
剛剛在這裡，雖然在屏幕上
這是越來越多的老同學。

505
00:23:34,540 --> 00:23:37,370
這是三個和一個半英寸
硬盤驅動器。

506
00:23:37,370 --> 00:23:40,070
三個半英寸指
的東西，當你安裝它

507
00:23:40,070 --> 00:23:40,890
在一台計算機。

508
00:23:40,890 --> 00:23:44,890
>> 你們中許多人的傢伙現在在您的筆記本電腦
有固態硬盤或SSD，

509
00:23:44,890 --> 00:23:46,260
沒有移動部件。

510
00:23:46,260 --> 00:23:49,170
他們更像RAM不像
這些機械設備。

511
00:23:49,170 --> 00:23:51,450
但這些想法仍然是相同的，
當然，因為它們涉及

512
00:23:51,450 --> 00:23:52,790
問題五。

513
00:23:52,790 --> 00:23:57,400
>> 如果你想想現在的硬盤驅動器
代表了一圈，這

514
00:23:57,400 --> 00:23:58,930
在這裡，我會得出這樣的。

515
00:23:58,930 --> 00:24:02,290
當您在您的計算機上創建一個文件，
無論它是一個SSD，或在

516
00:24:02,290 --> 00:24:06,610
這種情況下，硬盤驅動器是較舊的學校，
該文件包括多個位。

517
00:24:06,610 --> 00:24:10,510
比方說，它的0和1，
一大堆的0和1。

518
00:24:10,510 --> 00:24:11,660
所以這是我的整個硬盤驅動器。

519
00:24:11,660 --> 00:24:13,225
這顯然是一個相當大的文件。

520
00:24:13,225 --> 00:24:18,080
並且被使用在該0s和1s
部分的物理盤片。

521
00:24:18,080 --> 00:24:19,750
>> 那麼，什麼是物理部分？

522
00:24:19,750 --> 00:24:25,310
嗯，事實證明，在硬盤上，
至少在此類型中，有

523
00:24:25,310 --> 00:24:27,340
這些微小的磁性粒子。

524
00:24:27,340 --> 00:24:32,630
他們基本上有北部和
南極，因此，如果您

525
00:24:32,630 --> 00:24:35,710
打開其中一個，這些磁性顆粒
通過這種方式，你可能會說，這是

526
00:24:35,710 --> 00:24:36,720
較1。

527
00:24:36,720 --> 00:24:39,340
如果它是倒掛南下
北，你可能會說，這是

528
00:24:39,340 --> 00:24:40,390
代表一個0。

529
00:24:40,390 --> 00:24:43,660
>> 因此，在真實的物理世界，這是
你如何能代表的東西

530
00:24:43,660 --> 00:24:45,670
二進位的0狀態和1。

531
00:24:45,670 --> 00:24:46,720
所以這是一個文件。

532
00:24:46,720 --> 00:24:49,300
有一大堆磁
是他們這樣或顆粒

533
00:24:49,300 --> 00:24:51,920
通過這種方式，創建模式
0和1。

534
00:24:51,920 --> 00:24:56,760
>> 但事實證明，當你保存文件，
一些信息分開保存。

535
00:24:56,760 --> 00:25:00,000
所以這是一個小桌子，
一個目錄，可以這麼說。

536
00:25:00,000 --> 00:25:05,810
我會打電話給這列名，
我會打電話給這個列位置。

537
00:25:05,810 --> 00:25:08,850
>> 我要去說，假設
這是我的簡歷。

538
00:25:08,850 --> 00:25:14,050
我的resume.doc被存儲在
位置，比方說123。

539
00:25:14,050 --> 00:25:15,390
我總是去該號碼。

540
00:25:15,390 --> 00:25:18,810
但我只想說，就像
在RAM中，你可以把一個硬盤驅動器

541
00:25:18,810 --> 00:25:22,350
這是一個千兆字節或200千兆字節
TB級，你可以

542
00:25:22,350 --> 00:25:23,750
所有的字節數。

543
00:25:23,750 --> 00:25:26,480
你可以列出所有的8位塊。

544
00:25:26,480 --> 00:25:29,030
>> 因此，我們會說，這
是123的位置。

545
00:25:29,030 --> 00:25:32,070
因此，這個目錄裡面，我的作業
系統會記住我

546
00:25:32,070 --> 00:25:34,250
簡歷是在位置123。

547
00:25:34,250 --> 00:25:36,850
但它變得有趣，當
你刪除一個文件。

548
00:25:36,850 --> 00:25:37,820
>> 因此，例如 - 

549
00:25:37,820 --> 00:25:40,790
令人欣慰的是，世界上大多數國家都有
捕捉到這 - 時會發生什麼

550
00:25:40,790 --> 00:25:45,040
拖動文件到您的Mac OS垃圾桶
或Windows回收站？

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
這樣做的目的是什麼？

553
00:25:50,510 --> 00:25:53,860
這顯然是要擺脫的文件，
但到底是什麼行為拖動

554
00:25:53,860 --> 00:25:57,550
下降到廢紙簍或
回收站在電腦上做的嗎？

555
00:25:57,550 --> 00:25:59,230
>> 絕對沒有，真的。

556
00:25:59,230 --> 00:26:00,320
這就像一個文件夾。

557
00:26:00,320 --> 00:26:01,800
這是一個特殊的文件夾，可以肯定的。

558
00:26:01,800 --> 00:26:04,460
但它實際上刪除的文件？

559
00:26:04,460 --> 00:26:06,780
>> 哦，不，因為一些你可能
一直喜歡，哦，該死的，你沒有

560
00:26:06,780 --> 00:26:07,420
意味著這樣做。

561
00:26:07,420 --> 00:26:09,130
所以，你雙擊
垃圾桶或回收站。

562
00:26:09,130 --> 00:26:11,630
你周圍戳，你已經恢復
只需拖動文件

563
00:26:11,630 --> 00:26:12,110
離開那裡。

564
00:26:12,110 --> 00:26:14,420
所以很明顯，它不一定
刪除。

565
00:26:14,420 --> 00:26:15,990
>> OK，你聰明得多。

566
00:26:15,990 --> 00:26:18,860
你知道，只是拖動它到
垃圾桶或回收站並不意味著

567
00:26:18,860 --> 00:26:19,930
你清空垃圾桶。

568
00:26:19,930 --> 00:26:24,110
所以，你上去的菜單，和你說
清空廢紙簍或清空回收站。

569
00:26:24,110 --> 00:26:25,360
然後會發生什麼？

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> 是啊，所以它被刪除，更是這樣。

572
00:26:32,530 --> 00:26:37,660
但所發生的一切是這樣的。

573
00:26:37,660 --> 00:26:45,350
電腦忘記
是resume.doc。

574
00:26:45,350 --> 00:26:47,400
>> 但什麼也沒有明顯變化
在畫面？

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
位，0和1，我要求的是
在現場的一些物理方面的

577
00:26:55,570 --> 00:26:56,280
硬件。

578
00:26:56,280 --> 00:26:57,110
他們還在那裡。

579
00:26:57,110 --> 00:26:58,930
這只是電腦有
遺忘它們是什麼。

580
00:26:58,930 --> 00:27:03,160
>> 因此，它本質上釋放文件的
位的，所以它們可以被重複使用。

581
00:27:03,160 --> 00:27:06,940
但直到你創建更多的文件，
多個文件，多個文件

582
00:27:06,940 --> 00:27:12,150
概率，這些0和1，
這些磁性粒子，得到重用，

583
00:27:12,150 --> 00:27:16,220
上攻或右側，
其他文件，0和1。

584
00:27:16,220 --> 00:27:17,980
>> 所以，你有這樣的時間窗口。

585
00:27:17,980 --> 00:27:19,860
它不是可預測
長度，真的。

586
00:27:19,860 --> 00:27:22,240
這取決於你的硬盤的大小
驅動器和你有多少個文件

587
00:27:22,240 --> 00:27:23,490
你如何迅速做出新的。

588
00:27:23,490 --> 00:27:27,050
但是這期間的時間窗口
該文件仍然是完美的

589
00:27:27,050 --> 00:27:27,770
收回。

590
00:27:27,770 --> 00:27:31,050
>> 所以，如果你使用的程序如McAfee
或Norton嘗試恢復

591
00:27:31,050 --> 00:27:35,680
數據，他們正在做的是試圖
恢復這個所謂的目錄

592
00:27:35,680 --> 00:27:37,340
弄清楚你的文件在哪裡。

593
00:27:37,340 --> 00:27:40,605
有時諾頓和會說，
文件是可收回93％。

594
00:27:40,605 --> 00:27:42,020
那麼，是什麼意思呢？

595
00:27:42,020 --> 00:27:45,690
這只是意味著，其他一些文件
巧合的結束使用，也就是說，

596
00:27:45,690 --> 00:27:48,920
那些位出你的原始文件。

597
00:27:48,920 --> 00:27:51,950
>> 那麼，什麼是真正參與
在恢復數據？

598
00:27:51,950 --> 00:27:55,720
好吧，如果你不會有這樣的事情
諾頓預先安裝在電腦上，

599
00:27:55,720 --> 00:27:59,510
有時你可以做的是最好的看
在整個硬盤尋找

600
00:27:59,510 --> 00:28:00,510
的位模式。

601
00:28:00,510 --> 00:28:05,350
和問題集的主題之一
五是，你會搜索

602
00:28:05,350 --> 00:28:09,570
相當於一個硬盤驅動器，一個法醫
形象從一個緊湊的閃存卡

603
00:28:09,570 --> 00:28:13,660
數碼相機，搜索為0
和1，通常，具有較高的

604
00:28:13,660 --> 00:28:16,720
概率，代表
開始的JPEG圖像。

605
00:28:16,720 --> 00:28:21,120
>> 你們可以收回這些圖像
假設，如果我看到這個圖案

606
00:28:21,120 --> 00:28:24,380
位法醫形象，
的概率很高，這標誌著

607
00:28:24,380 --> 00:28:25,650
開始的JPEG。

608
00:28:25,650 --> 00:28:29,520
如果我再次看到同樣的模式，
可能標誌著開始

609
00:28:29,520 --> 00:28:32,440
另一個JPEG格式，和其他
JPEG格式，和其他的JPEG。

610
00:28:32,440 --> 00:28:34,970
這通常是如何
數據恢復工作。

611
00:28:34,970 --> 00:28:37,870
關於JPEG文件有什麼高興的是，即使
的文件格式本身是有點

612
00:28:37,870 --> 00:28:44,400
複雜，每一個這樣的開頭
文件其實是相當可識別

613
00:28:44,400 --> 00:28:47,370
和簡單，因為你會看到，
如果你還沒有準備好。

614
00:28:47,370 --> 00:28:50,270
>> 因此，讓我們來仔細看看下面
正是一直罩

615
00:28:50,270 --> 00:28:53,360
回事，這些0和1
，給你多一點的

616
00:28:53,360 --> 00:28:55,330
上下文這個特殊的挑戰。

617
00:28:55,330 --> 00:28:55,510
>> [視頻回放]

618
00:28:55,510 --> 00:28:58,700
>> ，如果您的電腦存儲最
其永久性的數據。

619
00:28:58,700 --> 00:29:03,390
要做到這一點，數據從RAM
隨著軟件信號，告訴

620
00:29:03,390 --> 00:29:06,110
硬盤驅動器如何將這些數據存儲。

621
00:29:06,110 --> 00:29:09,410
硬盤驅動器電路翻譯
這些信號轉換成電壓

622
00:29:09,410 --> 00:29:10,870
波動的影響。

623
00:29:10,870 --> 00:29:14,970
這些，反過來，控制硬盤驅動器的
移動部件，一些數

624
00:29:14,970 --> 00:29:17,910
留在移動部件
現代計算機。

625
00:29:17,910 --> 00:29:22,130
>> 部分的信號控制電機
其中旋轉金屬塗層盤片。

626
00:29:22,130 --> 00:29:25,470
您的數據實際上是存儲
這些盤片上。

627
00:29:25,470 --> 00:29:28,610
其他信號將讀/寫
頭讀取或

628
00:29:28,610 --> 00:29:30,710
寫在盤片上的數據。

629
00:29:30,710 --> 00:29:35,450
這個機器，一個人如此精確
頭髮甚至不能之間傳遞

630
00:29:35,450 --> 00:29:37,280
磁頭和旋轉盤片。

631
00:29:37,280 --> 00:29:40,316
然而，這一切都以驚人的速度。

632
00:29:40,316 --> 00:29:40,660
>> [END視頻播放]

633
00:29:40,660 --> 00:29:42,190
>> 國寶馬蘭：在一個小放大
更深現在什麼

634
00:29:42,190 --> 00:29:44,360
實際上這些盤片上。

635
00:29:44,360 --> 00:29:44,720
>> [視頻回放]

636
00:29:44,720 --> 00:29:47,660
>>  - 讓我們來看看，在我們剛才
看到慢動作。

637
00:29:47,660 --> 00:29:51,710
當一個簡短的電脈衝
發送到讀/寫頭，如果翻轉

638
00:29:51,710 --> 00:29:54,650
一個微小的電磁
的一小部分的第二個。

639
00:29:54,650 --> 00:29:58,970
磁鐵創建一個字段，該字段
一個微小的，微小的改變極性

640
00:29:58,970 --> 00:30:02,850
部的金屬顆粒
大衣每個盤片表面。

641
00:30:02,850 --> 00:30:05,940
>> 這些微小的一個模式系列，
充電區，在磁盤上的

642
00:30:05,940 --> 00:30:08,470
表示的一個位
二進制數中的數據

643
00:30:08,470 --> 00:30:10,530
由電腦系統使用。

644
00:30:10,530 --> 00:30:13,775
現在，如果當前發送的一種方法
通過讀/寫頭，該地區

645
00:30:13,775 --> 00:30:15,970
是在一個方向上極化。

646
00:30:15,970 --> 00:30:17,950
如果當前的發送，在
相反方向上，

647
00:30:17,950 --> 00:30:19,930
極化反轉。

648
00:30:19,930 --> 00:30:22,370
>> 您是怎樣從硬盤的數據？

649
00:30:22,370 --> 00:30:24,090
只要相反的過程。

650
00:30:24,090 --> 00:30:26,550
因此，它是在磁盤上的顆粒
獲取中的電流

651
00:30:26,550 --> 00:30:27,960
讀/寫頭移動。

652
00:30:27,960 --> 00:30:30,700
這些放在一起百萬
磁化段，

653
00:30:30,700 --> 00:30:32,160
你已經得到了一個文件。

654
00:30:32,160 --> 00:30:36,060
>> 現在，一個單一的文件件
遍布驅動器的

655
00:30:36,060 --> 00:30:39,970
盤片的一塌糊塗，有點像
你的辦公桌上的文件。

656
00:30:39,970 --> 00:30:43,500
因此，一個特殊的額外的文件跟踪
這裡的一切是。

657
00:30:43,500 --> 00:30:45,985
難道你不希望你有
類似的東西？

658
00:30:45,985 --> 00:30:46,470
>> [END視頻播放]

659
00:30:46,470 --> 00:30:47,820
>> 國寶MALAN：OK，大概不會。

660
00:30:47,820 --> 00:30:52,070
所以，你們的許多球員
從小一起長大的這些嗎？

661
00:30:52,070 --> 00:30:53,970
OK，所以越來越少
表決時，每一年。

662
00:30:53,970 --> 00:30:56,550
不過，我很高興你至少熟悉
與他們，因為這和我們自己的

663
00:30:56,550 --> 00:31:00,520
可悲的是，書的演示，死一個非常
熟悉拖死。

664
00:31:00,520 --> 00:31:04,010
>> 但是，這是我，至少，早在
高中，用於備份。

665
00:31:04,010 --> 00:31:08,110
它是令人驚異的，因為你
可以存儲140兆字節

666
00:31:08,110 --> 00:31:08,930
這個特定的磁盤。

667
00:31:08,930 --> 00:31:12,260
這是高密度版本，
所指示的HD，其中有

668
00:31:12,260 --> 00:31:14,240
這意味著之前今天的高清視頻。

669
00:31:14,240 --> 00:31:16,400
>> 標準密度為800千字節。

670
00:31:16,400 --> 00:31:18,640
而在這之前，有
400千字節的磁盤。

671
00:31:18,640 --> 00:31:23,120
而在這之前，共有5和1/4
英寸磁盤，這是真正的軟盤，

672
00:31:23,120 --> 00:31:25,680
和一點點更寬，更高
比這裡這些事。

673
00:31:25,680 --> 00:31:29,150
但實際上你可以看到所謂的
這些磁盤的軟盤方面。

674
00:31:29,150 --> 00:31:32,630
>> 和功能，它們實際上是
非常相似，在硬盤驅動器

675
00:31:32,630 --> 00:31:33,570
至少這種類型。

676
00:31:33,570 --> 00:31:37,270
同樣，固態硬盤在新電腦
工作方式略有不同。

677
00:31:37,270 --> 00:31:41,530
但是，如果你移動，小金屬卡，
實際上，你可以看到一個小的cookie，

678
00:31:41,530 --> 00:31:42,560
或拼盤。

679
00:31:42,560 --> 00:31:43,830
>> 它不是像這樣的金屬。

680
00:31:43,830 --> 00:31:46,000
其實這其中的一些便宜
塑料材料製成。

681
00:31:46,000 --> 00:31:46,750
你可以擺動它的那種。

682
00:31:46,750 --> 00:31:50,310
你trully只是抹去一些
位或磁性顆粒的數量

683
00:31:50,310 --> 00:31:51,220
從該磁盤。

684
00:31:51,220 --> 00:31:52,710
>> 令人欣慰的是，它沒有什麼。

685
00:31:52,710 --> 00:31:55,790
如果這件事情的方式 - 並覆蓋
你的眼睛和你的鄰居 - 

686
00:31:55,790 --> 00:31:58,865
你可以只是一種拉
整個鞘關閉這樣的。

687
00:31:58,865 --> 00:32:01,900
但是，有一個小彈簧，所以
知道你的眼睛。

688
00:32:01,900 --> 00:32:03,620
所以，現在你有一個真正的軟盤。

689
00:32:03,620 --> 00:32:07,090
>> 什麼顯著
在盡可能多的是，因為這是一個

690
00:32:07,090 --> 00:32:10,830
一個更大的小規模的代表性
硬盤驅動器，這些東西都是超，

691
00:32:10,830 --> 00:32:11,590
超級簡單的。

692
00:32:11,590 --> 00:32:15,170
如果你捏它的底部，現在
該金屬的東西，和剝離

693
00:32:15,170 --> 00:32:20,990
他們打開，有兩件
感到，並且所謂的軟盤

694
00:32:20,990 --> 00:32:22,930
一塊金屬在裡面。

695
00:32:22,930 --> 00:32:25,990
>> 並有去一半
我的磁盤的內容。

696
00:32:25,990 --> 00:32:27,540
去他們的另一半。

697
00:32:27,540 --> 00:32:31,375
但是這一切，裡面紡紗
您的計算機在昔日。

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> 再次，把這種成角度，
有多大你的大部分

700
00:32:38,310 --> 00:32:39,560
硬盤驅動器，這些天？

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500千兆字節，TB級，也許在
一台台式電腦，3，2 TB的

703
00:32:46,230 --> 00:32:47,630
TB級，4 TB的，對不對？

704
00:32:47,630 --> 00:32:52,480
這是一個兆字節，或採取
甚至不能符合一個典型的MP3

705
00:32:52,480 --> 00:32:55,310
這些天了，還是有些
類似的音樂文件。

706
00:32:55,310 --> 00:32:59,500
>> 有那麼一點點的紀念品今天為你，
也能幫助處境是什麼

707
00:32:59,500 --> 00:33:03,570
我們將採取理所當然的
現在的問題設置5個。

708
00:33:03,570 --> 00:33:04,820
所以，那些是你的保持。

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
因此，讓我這裡將成為過渡
花下的pset。

711
00:33:13,370 --> 00:33:18,470
所以我們現在已經設置這個頁面 - 哦，
一對夫婦很快公佈。

712
00:33:18,470 --> 00:33:21,730
>> 本星期五，如果您想加入CS50
吃午飯，去平常的地方，

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp。

714
00:33:23,610 --> 00:33:25,100
最終項目 - 

715
00:33:25,100 --> 00:33:28,520
所以每教學大綱，我們已經發布了
項目最終規範已經。

716
00:33:28,520 --> 00:33:31,410
要認識到，這並不意味著
這是由於特別快。

717
00:33:31,410 --> 00:33:33,990
它的貼吧，真的，只是為了得到
你們想著它。

718
00:33:33,990 --> 00:33:37,620
果然，有一個超級顯著
將解決你的百分比

719
00:33:37,620 --> 00:33:40,780
最終項目的材料，我們
甚至還沒有得到在課堂上，

720
00:33:40,780 --> 00:33:42,730
但下週初。

721
00:33:42,730 --> 00:33:45,530
>> 但請注意，該規範要求
幾個不同的組件的

722
00:33:45,530 --> 00:33:46,190
最終的項目。

723
00:33:46,190 --> 00:33:49,590
第一，在幾個星期內，是一種
建議前期，很隨意的電子郵件

724
00:33:49,590 --> 00:33:52,760
你的TF告訴他，或者你在做什麼
想為您的項目，

725
00:33:52,760 --> 00:33:53,650
沒有承諾。

726
00:33:53,650 --> 00:33:56,710
建議將您的特定
的承諾，他說，在這裡，這是什麼

727
00:33:56,710 --> 00:33:57,770
我想為我的項目做。

728
00:33:57,770 --> 00:33:58,250
你覺得呢？

729
00:33:58,250 --> 00:33:58,650
太大？

730
00:33:58,650 --> 00:33:59,145
太小？

731
00:33:59,145 --> 00:34:00,330
是管理？

732
00:34:00,330 --> 00:34:02,230
你可以看到更多的細節。規範

733
00:34:02,230 --> 00:34:05,060
>> 幾個星期後，狀態
報告，這是一個類似的

734
00:34:05,060 --> 00:34:08,260
休閒電子郵件到TF說多麼
不甘落後，你在你的最終

735
00:34:08,260 --> 00:34:12,360
項目的實施，其次是
CS50 Hackathon大家

736
00:34:12,360 --> 00:34:17,520
被邀請，這將是一個事件
下午8:00至7:00一個晚上

737
00:34:17,520 --> 00:34:19,150
AM第二天早晨。

738
00:34:19,150 --> 00:34:22,560
比薩，因為我可能會提到週
為零，將擔任下午9:00，

739
00:34:22,560 --> 00:34:24,120
中國食品在凌晨1:00。

740
00:34:24,120 --> 00:34:27,929
而如果你還醒著上午5:00，
我們帶你去IHOP早餐。

741
00:34:27,929 --> 00:34:31,310
>> 因此，黑客馬拉松是其中一個比較
類中的難忘的經歷。

742
00:34:31,310 --> 00:34:35,290
然後執行由於
然後高潮CS50展。

743
00:34:35,290 --> 00:34:38,070
在所有這些的更多細節
在今後幾個星期。

744
00:34:38,070 --> 00:34:40,739
>> 但是，讓我們回去的東西
舊學校 - 

745
00:34:40,739 --> 00:34:41,920
再次，一個數組。

746
00:34:41,920 --> 00:34:45,040
所以數組是不錯的，因為它解決
的問題，像我們看到的只是一個

747
00:34:45,040 --> 00:34:49,290
剛才學生結構
開始有點失控，如果我們

748
00:34:49,290 --> 00:34:52,405
希望有學生，學生，
學生點點點三，學生，

749
00:34:52,405 --> 00:34:54,400
一些任意數量的學生。

750
00:34:54,400 --> 00:34:58,850
>> 所以陣列，幾個星期前，猛撲
並解決我們的問題不

751
00:34:58,850 --> 00:35:03,340
事先知道有多少東西
某種類型的，我們想要的。

752
00:35:03,340 --> 00:35:07,390
我們已經看到，結構可以幫助我們
進一步組織我們的代碼，並保持

753
00:35:07,390 --> 00:35:11,660
概念類似的變量，就像一個
名稱和房子一起，使我們

754
00:35:11,660 --> 00:35:15,570
可以把它們當作一個實體，裡面
其中有小塊。

755
00:35:15,570 --> 00:35:17,810
>> 但是，陣列具有一些缺點。

756
00:35:17,810 --> 00:35:19,780
的一些缺點是什麼
我們遇到

757
00:35:19,780 --> 00:35:22,320
陣列，從而有多遠？

758
00:35:22,320 --> 00:35:23,450
那是什麼？

759
00:35:23,450 --> 00:35:28,130
固定大小 - 所以即使你可能
能夠分配內存的

760
00:35:28,130 --> 00:35:32,310
陣列，一旦你知道有多少學生
你有，你有多少個字符

761
00:35:32,310 --> 00:35:35,460
從用戶，一旦你分配
數組，你樣的畫

762
00:35:35,460 --> 00:35:36,740
自己陷入了困境。

763
00:35:36,740 --> 00:35:40,600
>> 因為你不能插入新元素
到一個數組中。

764
00:35:40,600 --> 00:35:43,660
您不能插入更多的元素
在結束一個數組。

765
00:35:43,660 --> 00:35:47,750
真的，你不得不求助於創造一個
全新的數組，如我們已經討論了，

766
00:35:47,750 --> 00:35:49,320
複製舊到新。

767
00:35:49,320 --> 00:35:52,610
再次，這是頭痛
則由GetString引發為您處理。

768
00:35:52,610 --> 00:35:56,170
>> 不過，你不能甚至插入
成的中間的數組的東西

769
00:35:56,170 --> 00:35:58,200
如果利率沒有被完全填充。

770
00:35:58,200 --> 00:36:03,010
例如，如果該數組的大小
六只有五件事情，

771
00:36:03,010 --> 00:36:06,080
好了，你可能只是粘
到年底的東西。

772
00:36:06,080 --> 00:36:08,200
但是，如果你要插入的東西
到中間的

773
00:36:08,200 --> 00:36:11,280
陣列，即使它可能有
五六個的東西在裡面？

774
00:36:11,280 --> 00:36:14,250
>> 哦，那我們做的時候，我們都
我們人類志願者在舞台上

775
00:36:14,250 --> 00:36:15,110
週過去？

776
00:36:15,110 --> 00:36:18,710
如果我們希望把這裡有人，無論是
這些人該如何移動

777
00:36:18,710 --> 00:36:22,540
的方式，還是這些人該如何移動
方式，並且變得昂貴了。

778
00:36:22,540 --> 00:36:26,950
裡面的人轉移
陣列加起來和成本

779
00:36:26,950 --> 00:36:31,240
我們的時間，因此我們很多ñ平方
運行時間，如插入排序，

780
00:36:31,240 --> 00:36:32,550
例如，在最壞的情況下。

781
00:36:32,550 --> 00:36:36,520
所以數組是偉大的，但你必須
提前知道你希望他們有多大。

782
00:36:36,520 --> 00:36:38,030
>> 這樣就OK了，這裡是一個解決方案。

783
00:36:38,030 --> 00:36:43,860
如果我事先不知道多少
我可能有學生，而且我知道，一旦

784
00:36:43,860 --> 00:36:47,870
不過，我決定，我堅持與
許多學生，為什麼不我只是一直

785
00:36:47,870 --> 00:36:51,740
分配兩倍的空間
因為我可能認為我需要什麼？

786
00:36:51,740 --> 00:36:54,450
那是不是一個合理的解決方案嗎？

787
00:36:54,450 --> 00:36:58,240
>> 實際上，我不認為我們
將需要超過50個插槽

788
00:36:58,240 --> 00:37:02,190
陣列中的一個中等大小的類，
因此讓剛剛圍捕。

789
00:37:02,190 --> 00:37:07,040
我會讓我的數組，只需100插槽
這樣我們就可以肯定得到

790
00:37:07,040 --> 00:37:10,330
我期望的學生數
在一些中等大小的類。

791
00:37:10,330 --> 00:37:14,320
那麼為什麼不圍捕和分配
更多的記憶體，典型地，一個數組

792
00:37:14,320 --> 00:37:16,290
比你想像的，你甚至可能需要？

793
00:37:16,290 --> 00:37:20,190
這是什麼簡單的推託
這個想法？

794
00:37:20,190 --> 00:37:21,440
>> 你只是浪費內存。

795
00:37:21,440 --> 00:37:25,350
從字面上看你寫的每一個程序，然後
也許使用兩倍的內存

796
00:37:25,350 --> 00:37:26,680
你的實際需要。

797
00:37:26,680 --> 00:37:28,990
而這只是不覺得自己像一個
特別是優雅的解決方案。

798
00:37:28,990 --> 00:37:31,990
此外，它只是降低了
出問題的概率。

799
00:37:31,990 --> 00:37:35,300
如果你碰巧有一個流行的課程
一個學期，你有101

800
00:37:35,300 --> 00:37:39,610
學生，你的程序仍然是
從根本上面臨著同樣的問題。

801
00:37:39,610 --> 00:37:44,280
>> 令人欣慰的是，有一個解決方案，
這個廣告的形式我們所有的問題

802
00:37:44,280 --> 00:37:46,790
的數據結構的
之外的更複雜的

803
00:37:46,790 --> 00:37:47,970
到目前為止，我們已經看到了。

804
00:37:47,970 --> 00:37:50,530
，我要求，這是一個鍊錶。

805
00:37:50,530 --> 00:37:51,920
這是一個數字列表 - 

806
00:37:51,920 --> 00:37:54,970
9，17，22，26，34  - 

807
00:37:54,970 --> 00:38:00,120
已連在一起的方式
什麼，我畫箭頭。

808
00:38:00,120 --> 00:38:03,580
>> 換句話說，如果我想代表
我可以做一個數組，

809
00:38:03,580 --> 00:38:04,910
這樣的事情。

810
00:38:04,910 --> 00:38:07,310
我就把這個開銷
在短短的時刻。

811
00:38:07,310 --> 00:38:09,970
我可以做的 - 

812
00:38:09,970 --> 00:38:12,520
你好，所有的權利。

813
00:38:12,520 --> 00:38:14,470
待機。

814
00:38:14,470 --> 00:38:17,360
在這裡，新的計算機明確 - 

815
00:38:17,360 --> 00:38:18,090
所有權利。

816
00:38:18,090 --> 00:38:21,730
>> 所以，如果我有這些數字陣列 - 

817
00:38:21,730 --> 00:38:28,880
9，17，22，26，24  - 

818
00:38:28,880 --> 00:38:30,530
未必按比例繪製。

819
00:38:30,530 --> 00:38:33,730
所有的權利，所以這裡是我的數組 - 

820
00:38:33,730 --> 00:38:34,980
噢，我的上帝。

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
所有的權利，所以這裡是我的數組。

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
哦，我的上帝。

825
00:38:45,050 --> 00:38:48,820
>> [笑]

826
00:38:48,820 --> 00:38:49,440
>> 國寶馬蘭：假裝。

827
00:38:49,440 --> 00:38:52,330
這是太多精力回去
解決這個問題，所以有 - 

828
00:38:52,330 --> 00:38:54,290
26。

829
00:38:54,290 --> 00:38:57,650
因此，我們有這陣
9，17，22，26，和34。

830
00:38:57,650 --> 00:39:00,260
對於那些你可以看到
令人尷尬的錯誤，我只是做了

831
00:39:00,260 --> 00:39:00,830
它是。

832
00:39:00,830 --> 00:39:04,490
>> 因此，我要求這是一個
非常有效的解決方案。

833
00:39:04,490 --> 00:39:07,310
我分配盡可能多的int類型，
我需要 - 一，二，三，

834
00:39:07,310 --> 00:39:09,100
四，五，六 - 

835
00:39:09,100 --> 00:39:11,660
然後我存儲的數字
這個數組裡面。

836
00:39:11,660 --> 00:39:15,220
但是，假設，然後，我要插入
8號這樣的值？

837
00:39:15,220 --> 00:39:16,100
那麼，它在哪裡去了？

838
00:39:16,100 --> 00:39:18,530
假設我想插入
20這樣的數字。

839
00:39:18,530 --> 00:39:19,790
那麼，它在哪裡去了？

840
00:39:19,790 --> 00:39:23,160
某處有在中間，
或數字35去

841
00:39:23,160 --> 00:39:24,010
某處在年底。

842
00:39:24,010 --> 00:39:25,320
但我所有的空間。

843
00:39:25,320 --> 00:39:29,120
>> 所以這是一個根本性的挑戰
的陣列，它的解決方案。

844
00:39:29,120 --> 00:39:32,280
剛才我聲稱是，GetString
解決了這個問題。

845
00:39:32,280 --> 00:39:37,380
如果你想插入第六號
進入此陣列，什麼是至少一種

846
00:39:37,380 --> 00:39:40,090
解決方案，您可以依傍的肯定，
就像我們做的GetString？

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
那是什麼？

849
00:39:46,030 --> 00:39:48,190
>> 嗯，使其更大
說起來容易做起來難。

850
00:39:48,190 --> 00:39:52,810
我們不一定可以使數組
大，但我們能做些什麼呢？

851
00:39:52,810 --> 00:39:56,570
創建一個新的更大的數組，大小
6，或者大小為10，如果我們想要

852
00:39:56,570 --> 00:40:00,490
出人頭地的東西，然後複製
舊到新的數組，然後

853
00:40:00,490 --> 00:40:01,680
釋放舊的陣列。

854
00:40:01,680 --> 00:40:05,770
>> 但是，什麼是運行時間
現在這一進程？

855
00:40:05,770 --> 00:40:09,870
大O n的，因為複製
要花費你一些單位

856
00:40:09,870 --> 00:40:13,480
時間，所以不是那麼理想，如果我們有
分配一個新的數組，這是怎麼回事

857
00:40:13,480 --> 00:40:15,610
消耗的兩倍多
暫時記憶。

858
00:40:15,610 --> 00:40:16,660
複製舊到新的 - 

859
00:40:16,660 --> 00:40:18,800
我的意思是，它只是頭痛，
再次，我們為什麼寫

860
00:40:18,800 --> 00:40:19,920
則由GetString引發你。

861
00:40:19,920 --> 00:40:21,380
>> 所以我們可能會做什麼呢？

862
00:40:21,380 --> 00:40:25,000
那麼，如果我們的數據結構
實際上有差距？

863
00:40:25,000 --> 00:40:30,790
假設我的目標是讓我放鬆
連續的內存塊，其中9

864
00:40:30,790 --> 00:40:34,500
至17日，這是旁邊
旁邊22，依此類推。

865
00:40:34,500 --> 00:40:39,570
>> 假設9可以在這裡
RAM，17能在RAM中，在這裡

866
00:40:39,570 --> 00:40:40,990
22可以在這裡，在RAM中。

867
00:40:40,990 --> 00:40:43,610
換句話說，我並不需要他們
甚至背靠背了。

868
00:40:43,610 --> 00:40:47,850
我只是必須以某種方式穿針
通過每個這些數字，或每個

869
00:40:47,850 --> 00:40:51,010
這些節點，我們稱之為
我畫的矩形，

870
00:40:51,010 --> 00:40:55,670
記得怎麼到最後
從第一個這樣的節點。

871
00:40:55,670 --> 00:40:59,940
>> 那麼，什麼是編程構造
我們最近見過不少與我

872
00:40:59,940 --> 00:41:03,030
可以實現，線程，或者
吸引到這裡，我可以

873
00:41:03,030 --> 00:41:05,430
實現這些箭頭？

874
00:41:05,430 --> 00:41:06,500
所以指針，對不對？

875
00:41:06,500 --> 00:41:09,560
如果我不只是一個分配
int，但是一個節點 - 和

876
00:41:09,560 --> 00:41:10,810
節點，我的意思只是容器。

877
00:41:10,810 --> 00:41:12,900
和視覺，我的意思是一個矩形。

878
00:41:12,900 --> 00:41:16,420
所以一個節點顯然需要
包含兩個值 - 

879
00:41:16,420 --> 00:41:21,490
的int本身，然後，如所暗示的
矩形的下半部分，

880
00:41:21,490 --> 00:41:23,010
類型為int的足夠的空間。

881
00:41:23,010 --> 00:41:26,130
>> 所以只是想提前在這裡，
有多大，這是節點，這

882
00:41:26,130 --> 00:41:27,170
容器中的問題？

883
00:41:27,170 --> 00:41:29,250
多少字節的整數？

884
00:41:29,250 --> 00:41:31,310
大概4，如果是
一樣平常。

885
00:41:31,310 --> 00:41:33,270
那麼有多少字節
指針？

886
00:41:33,270 --> 00:41:33,650
4。

887
00:41:33,650 --> 00:41:37,940
所以這個容器中，或此節點
將是一個8字節的結構。

888
00:41:37,940 --> 00:41:41,760
哦，這是一個令人高興的巧合，
我們剛剛推出這個概念

889
00:41:41,760 --> 00:41:44,400
一個結構或C結構。

890
00:41:44,400 --> 00:41:48,890
>> 所以我要求，我要採取的一個步驟
朝著這個更複雜

891
00:41:48,890 --> 00:41:52,560
實施數字的列表，
鍊錶的數字，我需要做一個

892
00:41:52,560 --> 00:41:56,920
多思考一點前面
聲明不只是一個int，但結構

893
00:41:56,920 --> 00:41:58,620
我會打電話的，傳統
在這裡，節點。

894
00:41:58,620 --> 00:42:01,630
我們可以把它稱為我們想要的東西，但
節點將是在一個特定的主題

895
00:42:01,630 --> 00:42:03,560
的事情，我們現在開始尋找。

896
00:42:03,560 --> 00:42:06,480
>> 該節點的內部是一個INT N。

897
00:42:06,480 --> 00:42:09,350
那麼這個語法，一點點
怪異的第一眼 - 

898
00:42:09,350 --> 00:42:12,960
結構節點*。

899
00:42:12,960 --> 00:42:16,900
形象好了，那是什麼？

900
00:42:16,900 --> 00:42:21,000
這是下半部分的
我們看到的矩形

901
00:42:21,000 --> 00:42:22,730
剛才。

902
00:42:22,730 --> 00:42:27,600
>> 但是為什麼我說結構節點*
而不是只是節點*？

903
00:42:27,600 --> 00:42:31,370
因為如果指針指向
在另一個節點時，它只是

904
00:42:31,370 --> 00:42:32,760
一個節點的地址。

905
00:42:32,760 --> 00:42:35,630
這是符合我們什麼
關於指針討論迄今。

906
00:42:35,630 --> 00:42:39,690
但是，為什麼，如果我要求這個結構
稱為節點，我不得不說結構

907
00:42:39,690 --> 00:42:42,660
內部節點這裡？

908
00:42:42,660 --> 00:42:43,190
>> 沒錯。

909
00:42:43,190 --> 00:42:46,490
這是一個愚蠢的現實C.
typedef的，可以這麼說，有沒有

910
00:42:46,490 --> 00:42:47,220
尚未發生。

911
00:42:47,220 --> 00:42:48,510
C的超級字面。

912
00:42:48,510 --> 00:42:51,050
它讀取你的代碼頂級
底部，從左到右。

913
00:42:51,050 --> 00:42:54,930
直到它擊中，分號
底線，你猜怎麼著不

914
00:42:54,930 --> 00:42:57,590
作為數據類型存在？

915
00:42:57,590 --> 00:42:59,060
節點，報價引文結束節點的。

916
00:42:59,060 --> 00:43:03,050
>> 但由於更詳細
聲明，我做的第一行 - 

917
00:43:03,050 --> 00:43:05,340
的typedef struct節點的 - 

918
00:43:05,340 --> 00:43:08,790
因為來之前，首先
大括號，有點像

919
00:43:08,790 --> 00:43:11,800
前教育鏘，你
知道嗎，給我一個struct

920
00:43:11,800 --> 00:43:13,570
所謂結構節點。

921
00:43:13,570 --> 00:43:16,270
坦率地說，我不喜歡調用的東西
結構節點，結構節點

922
00:43:16,270 --> 00:43:17,090
在我的代碼。

923
00:43:17,090 --> 00:43:20,660
但我會只使用一次，只是裡面，
讓我能有效地

924
00:43:20,660 --> 00:43:25,010
創建一個循環引用，而不是
一個指針，指向自己本身，而是一種

925
00:43:25,010 --> 00:43:29,400
另一個指針
屬於同一類型。

926
00:43:29,400 --> 00:43:32,330
>> 所以，事實證明，一個數據結構
這樣，有幾

927
00:43:32,330 --> 00:43:34,470
操作，可能會對
我們感興趣的。

928
00:43:34,470 --> 00:43:37,460
我們可能要插入
進入這樣的名單。

929
00:43:37,460 --> 00:43:39,850
我們可能想要刪除
從這樣的名單。

930
00:43:39,850 --> 00:43:43,490
我們可能要搜索一個列表
值，或者更普遍的是，遍歷。

931
00:43:43,490 --> 00:43:46,410
和橫向只是一個奇特的方式
說你應該開始在左側和移動全部

932
00:43:46,410 --> 00:43:47,650
的方式的權利。

933
00:43:47,650 --> 00:43:52,640
>> 通知，即使有這樣的稍多
複雜的數據結構，讓

934
00:43:52,640 --> 00:43:56,510
我建議，我們可以借用一些
在過去兩個星期的思想和

935
00:43:56,510 --> 00:43:58,410
執行一個函數調用
搜索這個樣子。

936
00:43:58,410 --> 00:44:01,360
這將返回true或
false，表示yes或

937
00:44:01,360 --> 00:44:03,390
不中，n為在列表中。

938
00:44:03,390 --> 00:44:05,960
它的第二個參數是一個指針
列表本身，所以

939
00:44:05,960 --> 00:44:07,920
到一個節點的指針。

940
00:44:07,920 --> 00:44:10,350
>> 我要那麼做是申報
一個臨時變量。

941
00:44:10,350 --> 00:44:12,730
我們叫它PTR按照慣例，
指針。

942
00:44:12,730 --> 00:44:15,220
我給它等於
開始的名單。

943
00:44:15,220 --> 00:44:16,680
>> 現在注意到while循環。

944
00:44:16,680 --> 00:44:20,640
只要指針不等於
空，我要來檢查。

945
00:44:20,640 --> 00:44:24,520
指針箭頭n等於
中傳遞的n？

946
00:44:24,520 --> 00:44:26,410
並等待一分鐘 - 新
一塊語法。

947
00:44:26,410 --> 00:44:29,324
什麼是箭頭一下子？

948
00:44:29,324 --> 00:44:30,574
是嗎？

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> 沒錯。

951
00:44:34,810 --> 00:44:38,860
因此，而在幾分鐘前，我們使用
點符號訪問一些東西

952
00:44:38,860 --> 00:44:43,080
內部的一個結構中，如果變量
你是不是該結構

953
00:44:43,080 --> 00:44:47,420
本身，而是指向結構的指針，
令人欣慰的是，一塊語法

954
00:44:47,420 --> 00:44:48,620
終於使得直觀的感覺。

955
00:44:48,620 --> 00:44:52,360
箭頭指按照指針，
像我們的箭通常意味著

956
00:44:52,360 --> 00:44:56,570
形象，並去
數據字段內。

957
00:44:56,570 --> 00:44:59,700
所以箭頭是點，但同樣的事情
你使用它的時候，你有一個指針。

958
00:44:59,700 --> 00:45:05,270
>> 因此，只要回顧一下，然後，如果n場
裡面的結構稱為指針

959
00:45:05,270 --> 00:45:07,760
等於等於N，則返回true。

960
00:45:07,760 --> 00:45:11,970
否則，這條線的位置 - 指針
等於指針。

961
00:45:11,970 --> 00:45:17,540
所以，這是什麼做的，通知，如果我
我目前指向的結構

962
00:45:17,540 --> 00:45:21,430
含有9，和9的不數
我要找的 - 假設我要找

963
00:45:21,430 --> 00:45:22,830
n等於50  - 

964
00:45:22,830 --> 00:45:25,930
我要更新我的臨時指針
在這個節點不指向

965
00:45:25,930 --> 00:45:31,190
了，但指針旁邊的箭頭，
正打算把我在這裡。

966
00:45:31,190 --> 00:45:34,270
>> 現在，我意識到是旋風
的介紹。

967
00:45:34,270 --> 00:45:37,380
上週三，我們將真正做到這一點
用一些人類和一些較

968
00:45:37,380 --> 00:45:38,900
代碼以較慢的速度。

969
00:45:38,900 --> 00:45:42,990
但要意識到，我們現在正在做我們的數據
更複雜的結構，使我們的

970
00:45:42,990 --> 00:45:45,780
算法可以得到更高效，
將是必要條件

971
00:45:45,780 --> 00:45:50,500
pset中六，當我們加載，再次，那些
15萬字，但需要這樣做

972
00:45:50,500 --> 00:45:55,650
高效，理想的情況下，創建一個
我們的用戶不是在運行的程序

973
00:45:55,650 --> 00:46:00,460
線性的，而不是在n的平方，但在
恆定的時間，在理想。

974
00:46:00,460 --> 00:46:02,300
>> 上週三，我們會看到你。

975
00:46:02,300 --> 00:46:07,240
>> 演講嘉賓：在未來CS50大衛
忘記了他的基本情況。

976
00:46:07,240 --> 00:46:12,770
>> 國寶馬蘭：這就是你如何發送
短信與C  - 

977
00:46:12,770 --> 00:46:14,020
>> [各種短信
通知的聲音]

978
00:46:14,020 --> 00:46:19,734