1
00:00:00,000 --> 00:00:03,381
>> [音樂播放]

2
00:00:03,381 --> 00:00:10,626

3
00:00:10,626 --> 00:00:11,610
>> [視頻回放]

4
00:00:11,610 --> 00:00:13,640
>>  - 他在說謊。

5
00:00:13,640 --> 00:00:14,380
>>  - 關於什麼？

6
00:00:14,380 --> 00:00:17,182
>>  - 我不知道。

7
00:00:17,182 --> 00:00:19,990
>>  - 所以我們怎麼知道？

8
00:00:19,990 --> 00:00:23,145
>>  - 即在9:15，雷
Santoya是在自動取款機。

9
00:00:23,145 --> 00:00:23,644
 - 是啊。

10
00:00:23,644 --> 00:00:27,030
所以，問題是，什麼樣
是他在9:16做什麼？

11
00:00:27,030 --> 00:00:29,720
>> -Shooting的9毫米的東西。

12
00:00:29,720 --> 00:00:31,540
也許他看到了狙擊手。

13
00:00:31,540 --> 00:00:33,412
>>  - 或者是和他一起工作。

14
00:00:33,412 --> 00:00:34,340
>> -Wait。

15
00:00:34,340 --> 00:00:36,200
回到之一。

16
00:00:36,200 --> 00:00:36,975
>>  - 什麼，你看到了什麼？

17
00:00:36,975 --> 00:00:44,400

18
00:00:44,400 --> 00:00:47,805
>> -Bring臉上了整個屏幕。

19
00:00:47,805 --> 00:00:48,680
>> -His眼鏡。

20
00:00:48,680 --> 00:00:50,060
>>  - 存在的一種反映。

21
00:00:50,060 --> 00:01:00,455

22
00:01:00,455 --> 00:01:02,280
>>  - 它是在努埃維塔斯棒球隊。

23
00:01:02,280 --> 00:01:03,110
這是他們的標誌。

24
00:01:03,110 --> 00:01:05,820
>>  - 和他交談
誰穿著那件夾克衫。

25
00:01:05,820 --> 00:01:06,670
>> [結束播放]

26
00:01:06,670 --> 00:01:07,628
>> DAVID馬蘭：好的。

27
00:01:07,628 --> 00:01:11,210
這是CS50，這是一個有點多
的[聽不清]與你

28
00:01:11,210 --> 00:01:12,890
有問題的涉足設4。

29
00:01:12,890 --> 00:01:16,606
今天我們先來了解一下多一點
深入這些東西叫做三分球，

30
00:01:16,606 --> 00:01:18,480
這即使它
一個非常神秘的話題，

31
00:01:18,480 --> 00:01:20,813
事實證明，這是怎麼回事
是通過何種途徑，我們

32
00:01:20,813 --> 00:01:24,320
可以開始構建和組裝
更複雜的方案。

33
00:01:24,320 --> 00:01:28,150
但是我們做到了上週三
一些粘土動畫的第一種方式。

34
00:01:28,150 --> 00:01:30,190
所以這一點，召回，是
賓基，我們用他

35
00:01:30,190 --> 00:01:33,148
要看一看一個程序，
真的沒有做什麼有趣的事，

36
00:01:33,148 --> 00:01:34,950
但它確實揭示了一些問題。

37
00:01:34,950 --> 00:01:38,570
因此，為了從今天開始，我們為什麼不走
快速通過幾個步驟，

38
00:01:38,570 --> 00:01:41,920
嘗試提煉到人的方面
什麼是怎麼回事

39
00:01:41,920 --> 00:01:45,410
為什麼這是不好的，然後繼續前進
而真正開始構建的東西

40
00:01:45,410 --> 00:01:46,309
這種技術？

41
00:01:46,309 --> 00:01:48,350
因此，這些是第一
該程序中的兩行

42
00:01:48,350 --> 00:01:51,340
在通俗地說，是什麼
在這兩條線在做什麼？

43
00:01:51,340 --> 00:01:55,600
有人誰是相當舒適
用什麼屏幕上的聲明？

44
00:01:55,600 --> 00:01:58,340

45
00:01:58,340 --> 00:02:00,120
什麼是這兩條線在做什麼？

46
00:02:00,120 --> 00:02:02,070
這還不是所有的
從一周不同，

47
00:02:02,070 --> 00:02:03,611
但有一些新的特殊符號。

48
00:02:03,611 --> 00:02:04,152
是嗎？

49
00:02:04,152 --> 00:02:05,628
回到那裡。

50
00:02:05,628 --> 00:02:07,092
>> 聽眾：聲明指針？

51
00:02:07,092 --> 00:02:08,050
DAVID馬蘭：再說一遍嗎？

52
00:02:08,050 --> 00:02:08,860
聽眾：聲明指針？

53
00:02:08,860 --> 00:02:11,776
DAVID馬蘭：聲明指針和
讓我們來完善它多一點點。

54
00:02:11,776 --> 00:02:14,050
聽眾：[聽不清]
地址X，那麼y。

55
00:02:14,050 --> 00:02:15,300
DAVID馬蘭：然後解決。

56
00:02:15,300 --> 00:02:18,550
那麼具體是什麼，我們正在做
是我們宣布的兩個變量。

57
00:02:18,550 --> 00:02:21,252
這些變量，雖然，將會
是int類型的明星，哪

58
00:02:21,252 --> 00:02:23,210
更具體地指
他們將要存儲

59
00:02:23,210 --> 00:02:26,450
一個int的地址，
分別使用x和y。

60
00:02:26,450 --> 00:02:27,660
現在還有什麼價值？

61
00:02:27,660 --> 00:02:32,621
有沒有在這些任何實際地址
兩個變量在這個時間點？

62
00:02:32,621 --> 00:02:33,120
第

63
00:02:33,120 --> 00:02:35,030
這只是所謂的垃圾值。

64
00:02:35,030 --> 00:02:38,120
如果你不實際分配
變量，無論是在RAM中

65
00:02:38,120 --> 00:02:42,224
以前是要填補零
和那些這兩個變量。

66
00:02:42,224 --> 00:02:44,140
但是，我們還不知道
它們是什麼，這就是

67
00:02:44,140 --> 00:02:47,060
將是關鍵，為什麼賓基
上週失去了他的頭。

68
00:02:47,060 --> 00:02:49,980
>> 因此，這是粘土動畫
這個化身

69
00:02:49,980 --> 00:02:53,580
因此你只有兩個變量，
小環形件粘土，

70
00:02:53,580 --> 00:02:57,330
可以存儲的變量，但作為
該包裹起來箭頭提示，

71
00:02:57,330 --> 00:03:00,640
他們不是真正指向
到任何地方本身已知。

72
00:03:00,640 --> 00:03:03,670
於是，我們有這條線，這
是新的，上週的malloc內存

73
00:03:03,670 --> 00:03:07,130
分配，這僅僅是一個奇特的方式
告訴操作系統，Linux的的

74
00:03:07,130 --> 00:03:09,750
或Mac OS或Windows，
嘿，給我一些記憶，

75
00:03:09,750 --> 00:03:11,780
而你要告訴
操作系統

76
00:03:11,780 --> 00:03:14,699
就是要求它的內存時。

77
00:03:14,699 --> 00:03:16,990
它不會去關心什麼
你會用它做什麼，

78
00:03:16,990 --> 00:03:19,786
但你需要告訴工作
什麼系統由malloc的方式。

79
00:03:19,786 --> 00:03:20,286
是嗎？

80
00:03:20,286 --> 00:03:21,078
>> 聽眾：多少錢？

81
00:03:21,078 --> 00:03:21,994
DAVID馬蘭：多少錢？

82
00:03:21,994 --> 00:03:25,280
多少字節，所以，這再次
一個人為的例子，只是說，

83
00:03:25,280 --> 00:03:27,360
給我一個int的大小。

84
00:03:27,360 --> 00:03:30,550
一個int現在，大小
是四字節或32位。

85
00:03:30,550 --> 00:03:32,850
因此，這只是一種方式
他說，嘿，操作系統，

86
00:03:32,850 --> 00:03:37,290
給我4個字節的內存
我可以用在我手上，

87
00:03:37,290 --> 00:03:40,560
具體有哪些呢
malloc的收益相對於

88
00:03:40,560 --> 00:03:41,795
以四個字節塊？

89
00:03:41,795 --> 00:03:44,110

90
00:03:44,110 --> 00:03:44,860
聽眾：地址？

91
00:03:44,860 --> 00:03:45,901
DAVID馬蘭：地址。

92
00:03:45,901 --> 00:03:47,580
四個字節塊的地址。

93
00:03:47,580 --> 00:03:48,190
沒錯。

94
00:03:48,190 --> 00:03:51,430
所以這就是所儲存的最終
在x和這就是為什麼我們真的不

95
00:03:51,430 --> 00:03:55,240
關心的是，數
地址是，無論是OX1或OX2

96
00:03:55,240 --> 00:03:57,110
或者一些神秘的十六進制地址。

97
00:03:57,110 --> 00:03:59,850
我們只關心形象化
那該變量x是現在

98
00:03:59,850 --> 00:04:01,630
指向的內存塊。

99
00:04:01,630 --> 00:04:05,570
這樣的箭頭表示的指針，或
更具體地說，存儲器地址。

100
00:04:05,570 --> 00:04:09,120
但是再次，我們並不關心通常
什麼樣的實際地址。

101
00:04:09,120 --> 00:04:11,780
現在，這條線說：
什麼通俗地說？

102
00:04:11,780 --> 00:04:14,330
星x被42分號。

103
00:04:14,330 --> 00:04:17,390
這是什麼意思？

104
00:04:17,390 --> 00:04:18,200
你想去？

105
00:04:18,200 --> 00:04:20,102
不要劃傷你的脖子。

106
00:04:20,102 --> 00:04:22,360
>> 聽眾：x的地址是在42。

107
00:04:22,360 --> 00:04:24,300
>> DAVID馬蘭：x的地址是42位。

108
00:04:24,300 --> 00:04:25,190
不完全是。

109
00:04:25,190 --> 00:04:28,485
如此接近，但並不完全，因為有
多數民眾贊成這個前綴X中的明星。

110
00:04:28,485 --> 00:04:29,860
因此，我們需要調整一點點。

111
00:04:29,860 --> 00:04:31,032
是嗎？

112
00:04:31,032 --> 00:04:36,044
>> 聽眾：值了
指針x被指向的是42。

113
00:04:36,044 --> 00:04:36,710
DAVID馬蘭：OK。

114
00:04:36,710 --> 00:04:40,840
的值，該指針x是
指著，讓我們說，應是42，

115
00:04:40,840 --> 00:04:44,165
或者換一種方式，星
x說，去到任何地址

116
00:04:44,165 --> 00:04:48,340
在X，無論是1牛津
街或33牛津街

117
00:04:48,340 --> 00:04:51,850
或OX1或ox33，無論
該數字地址，

118
00:04:51,850 --> 00:04:54,380
明星x是x的間接引用。

119
00:04:54,380 --> 00:04:57,297
所以去該地址並
然後把數字42出現。

120
00:04:57,297 --> 00:04:59,380
因此，這將是一個
的話說，相當於途徑。

121
00:04:59,380 --> 00:05:01,860
所以這一切都很好，然後
我們將代表圖像

122
00:05:01,860 --> 00:05:05,370
如下所示，我們已經添加
42到四個是塊

123
00:05:05,370 --> 00:05:09,370
字節上的右手邊，但
這條線是那裡的東西去了歪

124
00:05:09,370 --> 00:05:11,120
和賓基的頭部彈出
關於這一點，

125
00:05:11,120 --> 00:05:15,290
因為不好的事情發生時，
取消引用垃圾值

126
00:05:15,290 --> 00:05:18,210
或取消引用無效
指針和我說無效

127
00:05:18,210 --> 00:05:21,020
因為在這一點上，在
故事，什麼是Y的內部？

128
00:05:21,020 --> 00:05:24,440
什麼是Y的基礎價值
在過去的幾個步驟？

129
00:05:24,440 --> 00:05:25,360
是嗎？

130
00:05:25,360 --> 00:05:26,115
那是什麼？

131
00:05:26,115 --> 00:05:26,990
>> 聽眾：一個地址。

132
00:05:26,990 --> 00:05:28,460
DAVID馬蘭：地址。

133
00:05:28,460 --> 00:05:31,910
它應是一個地址
但我初始化呢？

134
00:05:31,910 --> 00:05:32,800
所以我還沒有。

135
00:05:32,800 --> 00:05:35,430
那麼，什麼是已知的在那裡？

136
00:05:35,430 --> 00:05:37,590
這只是一些垃圾的價值。

137
00:05:37,590 --> 00:05:41,500
它可以是從零到任何地址
2十億，如果你的RAM 2演出，

138
00:05:41,500 --> 00:05:44,289
或零4個十億，如果你已經
有4 GB的RAM。

139
00:05:44,289 --> 00:05:46,080
這是一些垃圾的價值，
但問題是

140
00:05:46,080 --> 00:05:48,200
操作系統，
如果沒有給你

141
00:05:48,200 --> 00:05:51,140
該內存塊專
你試圖去，

142
00:05:51,140 --> 00:05:54,650
它通常會導致什麼
我們已經看到了一個分段錯誤。

143
00:05:54,650 --> 00:05:57,810
所以，事實上，任何你們誰
在掙扎於辦公時間問題

144
00:05:57,810 --> 00:06:00,393
或者問題，更
通常，試圖找出

145
00:06:00,393 --> 00:06:02,150
段錯誤，
這通常意味著

146
00:06:02,150 --> 00:06:05,017
你觸摸的段
內存，你不應該。

147
00:06:05,017 --> 00:06:07,350
你觸摸內存
操作系統有不

148
00:06:07,350 --> 00:06:10,450
讓你觸摸，無論是
通過去太遠陣列

149
00:06:10,450 --> 00:06:12,870
或者從現在開始，無論是
那是因為你接觸

150
00:06:12,870 --> 00:06:14,780
內存僅僅是一些垃圾的價值。

151
00:06:14,780 --> 00:06:18,230
>> 這樣算下來星X這裡是
那種不確定的行為。

152
00:06:18,230 --> 00:06:22,030
你不應該這樣做，因為賠率
是，該方案只是將崩潰，

153
00:06:22,030 --> 00:06:24,050
因為你說，
去這個地址

154
00:06:24,050 --> 00:06:27,000
你不知道在哪裡
該地址實際上是。

155
00:06:27,000 --> 00:06:30,300
因此操作系統很可能
將你的程序崩潰

156
00:06:30,300 --> 00:06:33,840
因此，事實上，這是
那裡發生的事情來賓基。

157
00:06:33,840 --> 00:06:37,210
所以，最後，賓基固定
此問題與此。

158
00:06:37,210 --> 00:06:38,909
這樣程序本身是有缺陷的。

159
00:06:38,909 --> 00:06:41,450
但是，如果你之類的銳意進取
並執行此行，而不是，

160
00:06:41,450 --> 00:06:45,580
Ÿ度等於x只是意味著什麼
地址是一個X，也把它的年。

161
00:06:45,580 --> 00:06:48,740
>> 因此形象化，我們已經
有兩個箭頭表示這

162
00:06:48,740 --> 00:06:51,570
從x和從y中指點
同一個地方。

163
00:06:51,570 --> 00:06:55,760
因此語義，x等於
為y，因為這兩項的

164
00:06:55,760 --> 00:07:00,300
都存儲相同
地址，ERGO指著42，

165
00:07:00,300 --> 00:07:04,910
而現在，當你說明星
Y，轉到地址Y，

166
00:07:04,910 --> 00:07:06,790
這有一個有趣的副作用。

167
00:07:06,790 --> 00:07:10,320
因此，在y中的地址是
同樣的事情在X中的地址。

168
00:07:10,320 --> 00:07:15,060
所以，如果你說去地址
在Y和值更改為13，

169
00:07:15,060 --> 00:07:17,140
還有誰受影響？

170
00:07:17,140 --> 00:07:21,100
X的，點D，可以這麼說，
應該受到影響。

171
00:07:21,100 --> 00:07:24,340
>> 事實上，尼克怎麼畫了這幅畫
在粘土動畫正是這一點。

172
00:07:24,340 --> 00:07:28,665
即使我們按照指針
Y，我們結束了在同一個地方，

173
00:07:28,665 --> 00:07:32,780
所以，如果我們要打印
出X或Y的指針對象，

174
00:07:32,780 --> 00:07:35,720
那麼我們將看到13的值。

175
00:07:35,720 --> 00:07:37,927
現在，我說指針對象是
與視頻一致。

176
00:07:37,927 --> 00:07:39,760
程序員，我
知識，從來沒有真正

177
00:07:39,760 --> 00:07:42,460
說一句話指針對象，
這是尖

178
00:07:42,460 --> 00:07:44,650
在，但對於一致性
與視頻，實現

179
00:07:44,650 --> 00:07:47,520
這一切，這是
意味著在這種情況下。

180
00:07:47,520 --> 00:07:54,190
因此，對粘土動畫有任何疑問
或指針或malloc的，只是還沒有？

181
00:07:54,190 --> 00:07:54,850
沒有？

182
00:07:54,850 --> 00:07:55,470
好的。

183
00:07:55,470 --> 00:07:58,560
>> 因此，沒有進一步的
廢話不多說，讓我們一起來看看

184
00:07:58,560 --> 00:08:00,700
在其中，這實際上已經
已經使用了一段時間。

185
00:08:00,700 --> 00:08:03,580
因此，我們有這個CS50庫
這得到了所有這些功能。

186
00:08:03,580 --> 00:08:06,810
我們使用調用getInt很多，GetString的，
也許更早GetLongLong

187
00:08:06,810 --> 00:08:09,840
在我的PSET一左右，但
什麼實際已經持續？

188
00:08:09,840 --> 00:08:12,920
好吧，讓我們快速瀏覽一下
罩在一個程序下方那

189
00:08:12,920 --> 00:08:17,017
激勵我們為什麼給你CS50
圖書館，實際上截至上週，

190
00:08:17,017 --> 00:08:18,850
我們開始採取這些
訓練車輪關閉。

191
00:08:18,850 --> 00:08:21,080
因此，這是現在排序
一個死後是什麼

192
00:08:21,080 --> 00:08:23,690
已經持續
在CS50庫中，

193
00:08:23,690 --> 00:08:27,250
即使我們現在將開始移動
遠離它對於大多數程序。

194
00:08:27,250 --> 00:08:29,460
>> 因此，這是一個名為scanf函數0的程序。

195
00:08:29,460 --> 00:08:30,510
它的超級短。

196
00:08:30,510 --> 00:08:33,909
它只是這些行，但它
引入了一個函數調用scanf函數

197
00:08:33,909 --> 00:08:36,909
那我們究竟要看到
片刻CS50庫裡面，

198
00:08:36,909 --> 00:08:38,600
儘管在一個稍微不同的形式。

199
00:08:38,600 --> 00:08:41,330
所以這個方案行16
正在申報一個變量x。

200
00:08:41,330 --> 00:08:43,150
所以給我四個字節為一個int。

201
00:08:43,150 --> 00:08:45,750
它在告訴用戶，
號碼請，然後

202
00:08:45,750 --> 00:08:49,010
這是一個有趣的行
上週實際聯繫在一起

203
00:08:49,010 --> 00:08:49,790
而這一點。

204
00:08:49,790 --> 00:08:53,230
scanf函數，然後發現它需要一個
格式字符串，就像printf的，

205
00:08:53,230 --> 00:08:57,480
％我是指一個int，然後它需要一個
這看起來有點第二個參數

206
00:08:57,480 --> 00:08:58,260
時髦。

207
00:08:58,260 --> 00:09:01,880
它的符號x和召回，
我們只有這一次看到上週。

208
00:09:01,880 --> 00:09:03,465
這是什麼符號的x代表？

209
00:09:03,465 --> 00:09:06,210

210
00:09:06,210 --> 00:09:08,450
C語言是什麼符號呢？

211
00:09:08,450 --> 00:09:08,950
是嗎？

212
00:09:08,950 --> 00:09:10,024
>> 聽眾：地址。

213
00:09:10,024 --> 00:09:11,190
DAVID馬蘭：的地址。

214
00:09:11,190 --> 00:09:13,190
因此，它是相反的
星運營商，

215
00:09:13,190 --> 00:09:17,270
而明星接線員說，去
這個地址，符號運算符

216
00:09:17,270 --> 00:09:20,280
說，計算出
這個變量的地址，

217
00:09:20,280 --> 00:09:23,530
所以這是關鍵，因為
scanf函數的人生目標

218
00:09:23,530 --> 00:09:26,320
是掃描用戶的
從鍵盤輸入，

219
00:09:26,320 --> 00:09:29,970
根據不管他或她
類型，然後讀取該用戶的輸入

220
00:09:29,970 --> 00:09:32,970
成可變的，但我們
在過去兩個星期看到

221
00:09:32,970 --> 00:09:36,080
這是交換功能，我們
試圖輕鬆實現

222
00:09:36,080 --> 00:09:37,110
剛剛打破。

223
00:09:37,110 --> 00:09:42,470
回想一下，與交換功能，
如果我們只是宣布A和B為整數，

224
00:09:42,470 --> 00:09:47,040
我們也成功地交換
互換中的兩個變量

225
00:09:47,040 --> 00:09:50,080
只是想用牛奶和OJ，
但只要換回來了，

226
00:09:50,080 --> 00:09:55,200
結果是什麼就
x和y，原始值？

227
00:09:55,200 --> 00:09:55,700
什麼也沒有。

228
00:09:55,700 --> 00:09:56,200
是啊。

229
00:09:56,200 --> 00:09:59,754
什麼都沒有發生的時候，因為
掉期只改變它的本地副本，

230
00:09:59,754 --> 00:10:01,670
這就是說，所有
這個時候，每當我們已經

231
00:10:01,670 --> 00:10:04,010
被傳入的參數
到功能，我們

232
00:10:04,010 --> 00:10:05,939
剛好路過的那些參數的拷貝。

233
00:10:05,939 --> 00:10:07,980
你可以用那些
無論你想和他們在一起，

234
00:10:07,980 --> 00:10:10,890
但他們將不得不無
上的原始值影響。

235
00:10:10,890 --> 00:10:13,650
因此，這是有問題的，如果你
想擁有像scanf函數的函數

236
00:10:13,650 --> 00:10:17,170
在生活中，其目的是要掃描
用戶的從鍵盤輸入

237
00:10:17,170 --> 00:10:22,010
然後填補空白，所以
說話，就是給如x變量

238
00:10:22,010 --> 00:10:25,410
一個值，因為如果我是
只是傳遞X到scanf函數，

239
00:10:25,410 --> 00:10:28,790
如果你考慮最後的邏輯
本週，scanf函數可以為所欲為

240
00:10:28,790 --> 00:10:33,100
與x的拷貝，但它不能
永久x更改，除非我們放棄

241
00:10:33,100 --> 00:10:37,120
scanf的藏寶圖，可以這麼說，
因此，其中的X標記的位置，

242
00:10:37,120 --> 00:10:41,860
我們通過x的地址，以便
scanf函數可以去那裡其實是一個改變

243
00:10:41,860 --> 00:10:42,920
x的值。

244
00:10:42,920 --> 00:10:45,080
所以，事實上，所有的
這個程序會

245
00:10:45,080 --> 00:10:53,180
如果我做的scanf 0，在我的源代碼
5米目錄，使scanf函數0，

246
00:10:53,180 --> 00:10:57,730
點斜線scanf函數，數
請50，感謝50。

247
00:10:57,730 --> 00:11:01,020
>> 因此，它不是那麼有趣，
但什麼是確實發生的事情

248
00:11:01,020 --> 00:11:04,820
是，只要我打電話
的scanf這裡，x的值

249
00:11:04,820 --> 00:11:06,410
被永久改變。

250
00:11:06,410 --> 00:11:08,335
現在，這似乎不錯，
好，而且，事實上，它

251
00:11:08,335 --> 00:11:11,200
看起來我們並不真正需要的
在CS50庫在所有了。

252
00:11:11,200 --> 00:11:13,960
例如，讓我們運行
這一次在這裡。

253
00:11:13,960 --> 00:11:15,750
讓我重新打開第二個。

254
00:11:15,750 --> 00:11:20,600
讓我們嘗試了一些，請與
而不是說50像以前一樣，

255
00:11:20,600 --> 00:11:22,810
我們只能說沒有。

256
00:11:22,810 --> 00:11:24,000
OK，這是一個有點怪異。

257
00:11:24,000 --> 00:11:25,270
確定。

258
00:11:25,270 --> 00:11:28,680
而只是一些廢話這裡。

259
00:11:28,680 --> 00:11:31,170
因此，它似乎並沒有
處理錯誤的情況。

260
00:11:31,170 --> 00:11:33,620
因此，我們需要最小的開始
加入一些錯誤檢查

261
00:11:33,620 --> 00:11:37,460
以確保用戶具有
鍵入的實際數目的像50，

262
00:11:37,460 --> 00:11:40,720
因為很明顯打字的話
不被檢測為有問題的，

263
00:11:40,720 --> 00:11:42,020
但它可能應該是。

264
00:11:42,020 --> 00:11:46,450
>> 讓我們來看看這個版本現在是
我試圖重新實現的GetString。

265
00:11:46,450 --> 00:11:48,437
如果scanf函數有這一切
功能內置，

266
00:11:48,437 --> 00:11:51,270
為什麼我們已經涉足這些
培訓車輪狀的GetString？

267
00:11:51,270 --> 00:11:55,450
好了，下面也許是我自己
簡單的GetString版本

268
00:11:55,450 --> 00:12:00,766
因此一個星期前，我可能會說，
給我一個字符串，並將其命名為緩衝區。

269
00:12:00,766 --> 00:12:03,390
今天，我要開始只是
話說焦明星，其中，召回，

270
00:12:03,390 --> 00:12:04,400
它只是代名詞。

271
00:12:04,400 --> 00:12:06,629
它看起來可怕，但它
同樣的事情。

272
00:12:06,629 --> 00:12:09,420
所以給我一個變量叫做緩衝
那將存放的字符串，

273
00:12:09,420 --> 00:12:12,780
告訴用戶字符串請
然後，就像以前一樣，

274
00:12:12,780 --> 00:12:17,760
讓我們嘗試借用這一課的scanf
％S這個時候再通過緩衝區。

275
00:12:17,760 --> 00:12:19,310
現在，一個快速的完整性檢查。

276
00:12:19,310 --> 00:12:22,120
為什麼我不能說
符號緩衝這段時間？

277
00:12:22,120 --> 00:12:25,190

278
00:12:25,190 --> 00:12:26,625
從前面的例子推斷。

279
00:12:26,625 --> 00:12:28,000
聽眾：字符明星是一個指針。

280
00:12:28,000 --> 00:12:29,920
DAVID馬蘭：沒錯，
因為這個時候，炭

281
00:12:29,920 --> 00:12:34,080
星已經是一個指針，一個地址，
由明星在那裡的定義。

282
00:12:34,080 --> 00:12:37,530
並且如果scanf的期望一個地址，
它足以只是為了打發在緩衝區中。

283
00:12:37,530 --> 00:12:39,260
我不需要說了連字符緩衝區。

284
00:12:39,260 --> 00:12:42,177
對於好奇的，你可以
做這樣的事情。

285
00:12:42,177 --> 00:12:43,510
它將有不同的意義。

286
00:12:43,510 --> 00:12:47,240
這會給你一個指針
一個指針，它實際上是

287
00:12:47,240 --> 00:12:50,050
一個有效的東西在C中，但對於
現在，讓我們保持簡單

288
00:12:50,050 --> 00:12:51,750
和保持故事的連貫。

289
00:12:51,750 --> 00:12:54,100
我只是要傳遞
緩衝，這就是正確的。

290
00:12:54,100 --> 00:12:56,487
這個問題雖然是這樣的。

291
00:12:56,487 --> 00:12:58,820
讓我繼續前進，運行這個
編譯後的程序。

292
00:12:58,820 --> 00:13:00,902
讓scanf函數1。

293
00:13:00,902 --> 00:13:02,610
該死的，我的編譯器
抓住我的錯誤。

294
00:13:02,610 --> 00:13:04,090
給我一秒鐘。

295
00:13:04,090 --> 00:13:05,460
鏘。

296
00:13:05,460 --> 00:13:06,990
比方說，scanf函數，1.C。

297
00:13:06,990 --> 00:13:10,880

298
00:13:10,880 --> 00:13:11,380
確定。

299
00:13:11,380 --> 00:13:12,720
在那裡，我們走了。

300
00:13:12,720 --> 00:13:14,280
我需要它。

301
00:13:14,280 --> 00:13:16,750
CS50 ID有不同
配置設置

302
00:13:16,750 --> 00:13:18,280
保護您免受自己。

303
00:13:18,280 --> 00:13:21,300
我需要禁用那些
手動運行鐺這個時候。

304
00:13:21,300 --> 00:13:22,140
所以字符串請。

305
00:13:22,140 --> 00:13:25,560
我要繼續前進，並鍵入
在我最喜歡的Hello World。

306
00:13:25,560 --> 00:13:26,490
OK，空。

307
00:13:26,490 --> 00:13:27,700
這不是我所輸入的。

308
00:13:27,700 --> 00:13:29,690
因此，它指示
什麼是錯的。

309
00:13:29,690 --> 00:13:33,920
讓我繼續前進，鍵入
在很長的字符串。

310
00:13:33,920 --> 00:13:37,210
感謝您的空，我不知道
如果我將能夠讓它崩潰。

311
00:13:37,210 --> 00:13:40,240
讓我們試著一點點副本
粘貼，看看這會有所幫助。

312
00:13:40,240 --> 00:13:43,290
剛貼了很多本。

313
00:13:43,290 --> 00:13:47,310
這絕對是一個更大的
字符串比平常。

314
00:13:47,310 --> 00:13:51,450
讓我們真的把它寫。

315
00:13:51,450 --> 00:13:51,950
第

316
00:13:51,950 --> 00:13:52,650
該死。

317
00:13:52,650 --> 00:13:53,480
找不到命令。

318
00:13:53,480 --> 00:13:54,550
所以這是不相關的。

319
00:13:54,550 --> 00:13:56,440
那是因為我粘貼
一些不好的字，

320
00:13:56,440 --> 00:13:59,780
但事實證明這是行不通的。

321
00:13:59,780 --> 00:14:03,510
>> 讓我們試試這個曾經多，因為
它更多的樂趣，如果我們真的崩潰了。

322
00:14:03,510 --> 00:14:09,116
讓我們輸入這個，現在，我
要複製一個很長的字符串

323
00:14:09,116 --> 00:14:10,990
現在就讓如果我們看看
可能會崩潰這件事。

324
00:14:10,990 --> 00:14:14,235
請注意，我省略了空間和
新的生產線和分號

325
00:14:14,235 --> 00:14:16,035
和所有時髦的人物。

326
00:14:16,035 --> 00:14:16,535
輸入。

327
00:14:16,535 --> 00:14:21,090

328
00:14:21,090 --> 00:14:22,880
而現在的網絡只是正在緩慢。

329
00:14:22,880 --> 00:14:27,460
我按住Command-V鍵太長，清晰。

330
00:14:27,460 --> 00:14:28,190
該死！

331
00:14:28,190 --> 00:14:29,260
找不到命令。

332
00:14:29,260 --> 00:14:29,780
>> 確定。

333
00:14:29,780 --> 00:14:32,240
那麼，問題是
儘管如此以下。

334
00:14:32,240 --> 00:14:36,910
那麼什麼是真正會
與此聲明

335
00:14:36,910 --> 00:14:39,240
的第16行字符星緩衝？

336
00:14:39,240 --> 00:14:41,820
所以，我是什麼讓
當我宣布一個指針？

337
00:14:41,820 --> 00:14:47,440
所有我得到是一個四字節的值
所謂的緩衝區，但什麼是它的內部

338
00:14:47,440 --> 00:14:49,540
此刻？

339
00:14:49,540 --> 00:14:50,930
這只是一些垃圾的價值。

340
00:14:50,930 --> 00:14:54,170
因為任何時候你聲明一個變量
在C，它只是一些垃圾的價值，

341
00:14:54,170 --> 00:14:56,220
我們已經開始
絆倒這個現實。

342
00:14:56,220 --> 00:14:59,720
現在，當我告訴scanf函數，
去這個地址

343
00:14:59,720 --> 00:15:01,520
並把在不管用戶類型。

344
00:15:01,520 --> 00:15:06,400
如果在用戶鍵入你好
世界上，還有，我在哪裡放呢？

345
00:15:06,400 --> 00:15:07,750
緩衝區是一個垃圾的價值。

346
00:15:07,750 --> 00:15:11,510
>> 所以這有點像一個箭頭
該指針誰知道在哪裡。

347
00:15:11,510 --> 00:15:13,880
也許它指向
這裡在我的記憶中。

348
00:15:13,880 --> 00:15:16,560
因此，當用戶
類型的hello world，

349
00:15:16,560 --> 00:15:22,380
該計劃試圖把
字符串的hello world反斜線0

350
00:15:22,380 --> 00:15:23,910
該內存塊。

351
00:15:23,910 --> 00:15:27,070
但是高概率，但
顯然不是100％的概率，

352
00:15:27,070 --> 00:15:30,440
計算機將要然後崩潰
程序，因為這不是

353
00:15:30,440 --> 00:15:32,490
內存我應該被允許觸摸。

354
00:15:32,490 --> 00:15:36,330
因此，在短期，這一計劃是
有缺陷的正是這個原因。

355
00:15:36,330 --> 00:15:38,070
我根本沒有做什麼的？

356
00:15:38,070 --> 00:15:42,366
有哪些步驟我省略了，就像
我們省略了與賓基的第一個例子？

357
00:15:42,366 --> 00:15:42,866
是嗎？

358
00:15:42,866 --> 00:15:43,710
>> 聽眾：內存分配？

359
00:15:43,710 --> 00:15:45,001
>> DAVID馬蘭：內存分配。

360
00:15:45,001 --> 00:15:48,400
我還沒有實際分配
任何內存該字符串。

361
00:15:48,400 --> 00:15:50,270
所以我們可以在幾個方式解決這個問題。

362
00:15:50,270 --> 00:15:52,700
第一，我們可以保持簡單
而事實上，現在你

363
00:15:52,700 --> 00:15:55,116
將開始看到一個模糊
之間有什麼行

364
00:15:55,116 --> 00:15:58,520
數組是什麼，一個字符串是什麼
炭明星，字符什麼數組

365
00:15:58,520 --> 00:15:59,020
是。

366
00:15:59,020 --> 00:16:02,450
下面是第二個例子
涉及字符串和通知

367
00:16:02,450 --> 00:16:05,690
所有我已經在網上做了
16是不是說，

368
00:16:05,690 --> 00:16:09,530
該緩衝區將是一個char
明星，一個指向一個內存塊，

369
00:16:09,530 --> 00:16:14,057
我會很主動地給
我自己一個緩衝的16個字符，

370
00:16:14,057 --> 00:16:16,390
而事實上，如果你熟悉
與術語緩衝，

371
00:16:16,390 --> 00:16:20,570
大概從影片的世界裡，
其中，一個視頻緩衝，緩衝，

372
00:16:20,570 --> 00:16:21,175
緩衝。

373
00:16:21,175 --> 00:16:22,550
那麼，什麼是連接這裡？

374
00:16:22,550 --> 00:16:24,960
YouTube的嘛，裡面
和視頻播放器內

375
00:16:24,960 --> 00:16:27,200
通常是一個數組
這是大於16。

376
00:16:27,200 --> 00:16:30,340
它可能是大小為一的陣列
兆字節，也許10兆，

377
00:16:30,340 --> 00:16:34,330
進入該數組做您的瀏覽器
下載一個一大堆字節，

378
00:16:34,330 --> 00:16:37,500
一大堆的兆字節
視頻和視頻播放器，

379
00:16:37,500 --> 00:16:40,930
YouTube的還是誰的，開始
從陣列讀取的字節數，

380
00:16:40,930 --> 00:16:43,530
任何時候你看到的
字緩衝，緩衝，

381
00:16:43,530 --> 00:16:46,350
這意味著該播放器具有
得到該數組的末尾。

382
00:16:46,350 --> 00:16:50,430
該網絡是如此緩慢，它並沒有
回填數組有更多的字節

383
00:16:50,430 --> 00:16:55,610
所以你出位
以顯示給​​用戶。

384
00:16:55,610 --> 00:16:59,430
>> 因此，緩衝區是一個恰當的詞在這裡是
它只是一個數組，一個內存塊。

385
00:16:59,430 --> 00:17:02,530
這將解決這個問題
因為事實證明

386
00:17:02,530 --> 00:17:07,410
你可以把數組，就好像
他們的地址，即使緩衝區

387
00:17:07,410 --> 00:17:10,710
僅僅是一個符號，它是一個
字符序列，緩衝液，

388
00:17:10,710 --> 00:17:14,760
這對我來說是非常有用的，程序員，
你可以通過周圍的名字

389
00:17:14,760 --> 00:17:17,079
就好像它是一個
指針，就好像它

390
00:17:17,079 --> 00:17:21,000
是一個組塊的地址
內存為16個字符。

391
00:17:21,000 --> 00:17:24,530
所以這是說，我可以通過
scanf函數正是那個詞

392
00:17:24,530 --> 00:17:30,670
所以現在，如果我做這個節目，
讓scanf函數2，點斜線scanf函數2，

393
00:17:30,670 --> 00:17:35,386
和類型的hello world，
回車，即時間 - 

394
00:17:35,386 --> 00:17:37,590
>> 嗯，什麼事？

395
00:17:37,590 --> 00:17:39,340
字符串請。

396
00:17:39,340 --> 00:17:41,430
我做了什麼錯？

397
00:17:41,430 --> 00:17:43,800
世界您好，緩衝區。

398
00:17:43,800 --> 00:17:44,705
世界，你好。

399
00:17:44,705 --> 00:17:48,201

400
00:17:48,201 --> 00:17:49,420
嗯，我知道它在做什麼。

401
00:17:49,420 --> 00:17:49,920
確定。

402
00:17:49,920 --> 00:17:51,628
因此，它的讀了
直到第一空間。

403
00:17:51,628 --> 00:17:55,680
因此，讓我們騙了就一下
說我只是想輸入的東西

404
00:17:55,680 --> 00:18:01,408
真的長的很像，這是一個長句子
這是一個，兩個，三個，四個，五個，

405
00:18:01,408 --> 00:18:04,420
六，七，八，九，
10，11，12，13，14，15，16。

406
00:18:04,420 --> 00:18:05,300
確定。

407
00:18:05,300 --> 00:18:07,600
這的確是一個長句子。

408
00:18:07,600 --> 00:18:10,710
所以，這句話是
長度超過16個字符

409
00:18:10,710 --> 00:18:13,670
所以當我按下回車鍵，
什麼會發生？

410
00:18:13,670 --> 00:18:16,940
那麼，在的這種情況下，
故事，我宣布緩衝區

411
00:18:16,940 --> 00:18:22,190
實際上是一個數組
有16個字符蓄勢待發。

412
00:18:22,190 --> 00:18:27,426
這樣一，二，三，四，五，六，
七，八，九，十，十一，十二，十三，十四，

413
00:18:27,426 --> 00:18:29,440
15，16。

414
00:18:29,440 --> 00:18:34,410
所以16個字符，而現在，當我
讀這樣的事情是一個長期的

415
00:18:34,410 --> 00:18:43,950
一句話，是什麼將要發生的
那我要讀這是一個漫長

416
00:18:43,950 --> 00:18:49,660
S-E-N-T-E-N-C-E，句子。

417
00:18:49,660 --> 00:18:52,270
>> 因此，這是故意
一件壞事，我

418
00:18:52,270 --> 00:18:55,060
不斷書寫超越
我的數組的邊界，

419
00:18:55,060 --> 00:18:56,660
超出了我緩衝器的邊界。

420
00:18:56,660 --> 00:19:00,100
我能得到幸運和程序
將繼續運行，並沒有在意，

421
00:19:00,100 --> 00:19:03,450
但一般來說，這
確實會崩潰我的程序，

422
00:19:03,450 --> 00:19:06,440
它是在一個錯誤我
代碼的那一刻，我一步

423
00:19:06,440 --> 00:19:08,576
超越界限
該數組的，因為我

424
00:19:08,576 --> 00:19:10,450
不知道這是否是
必然要崩潰

425
00:19:10,450 --> 00:19:12,120
或者，如果我只是要得到幸運。

426
00:19:12,120 --> 00:19:15,750
因此，這是有問題的，因為在
這種情況下，它似乎工作

427
00:19:15,750 --> 00:19:20,931
讓我們鋌而走險這裡，即使
在IDE似乎容忍了不少

428
00:19:20,931 --> 00:19:21,430
of--

429
00:19:21,430 --> 00:19:22,040
>> 在那裡，我們走了。

430
00:19:22,040 --> 00:19:23,240
最後。

431
00:19:23,240 --> 00:19:26,470
所以我能看到這唯一的一個。

432
00:19:26,470 --> 00:19:29,630
所以，我只是有很多好玩的打字
出了很長的實際短語

433
00:19:29,630 --> 00:19:32,800
它肯定超過
16個字節，因為我

434
00:19:32,800 --> 00:19:38,050
輸入在這個瘋狂的長期多線
短語，然後看到發生了什麼。

435
00:19:38,050 --> 00:19:41,110
該程序試圖在打印
然後得到一個分段錯誤

436
00:19:41,110 --> 00:19:44,430
和段錯誤是當
這樣的事情發生

437
00:19:44,430 --> 00:19:47,650
和操作系統說
不，不能觸摸的記憶。

438
00:19:47,650 --> 00:19:49,570
我們會殺了
該方案完全。

439
00:19:49,570 --> 00:19:51,180
>> 因此，這似乎是有問題的。

440
00:19:51,180 --> 00:19:54,540
我已經提高了該計劃的實施
至少有一些記憶，

441
00:19:54,540 --> 00:19:58,000
但是這似乎局限
該函數的GetString，這是讓

442
00:19:58,000 --> 00:20:00,780
一些有限的長度為16的字符串。

443
00:20:00,780 --> 00:20:04,200
所以，如果你想支持更長
句子超過16個字符，

444
00:20:04,200 --> 00:20:04,880
你該怎麼辦？

445
00:20:04,880 --> 00:20:07,970
那麼，你可以增加
此緩衝器32的大小

446
00:20:07,970 --> 00:20:09,190
或者說似乎有點短。

447
00:20:09,190 --> 00:20:12,260
為什麼我們不只是做
它1000，但推回。

448
00:20:12,260 --> 00:20:17,100
什麼是直覺的反應
只是通過避免這種問題

449
00:20:17,100 --> 00:20:20,660
我的緩衝更大，像1000字符？

450
00:20:20,660 --> 00:20:23,470
通過實施GetString的這種方式。

451
00:20:23,470 --> 00:20:27,130
什麼是好還是壞嗎？

452
00:20:27,130 --> 00:20:28,033
是嗎？

453
00:20:28,033 --> 00:20:30,574
聽眾：如果你綁定了很多
的空間，你不使用它，

454
00:20:30,574 --> 00:20:33,500
那麼你就不能重新分配空間。

455
00:20:33,500 --> 00:20:34,500
DAVID馬蘭：沒錯。

456
00:20:34,500 --> 00:20:38,480
這是浪費的，只要你不
實際上需要那些字節的900

457
00:20:38,480 --> 00:20:41,057
可是你要求
1000共無論如何，

458
00:20:41,057 --> 00:20:44,140
你只是佔用更多的內存
比你需要到用戶的計算機上，

459
00:20:44,140 --> 00:20:45,740
畢竟，一些
你已經遇到

460
00:20:45,740 --> 00:20:47,620
在生活中，當你
運行很多程序

461
00:20:47,620 --> 00:20:50,470
和他們吃了大量的內存，
這實際上可能會影響性能

462
00:20:50,470 --> 00:20:52,220
和用戶的經驗
上的計算機中。

463
00:20:52,220 --> 00:20:56,090
所以這是一種懶的解決方案，
可以肯定，相反，

464
00:20:56,090 --> 00:21:00,140
這不僅造成浪費，什麼問題
仍然存在，即使我讓我的緩衝區

465
00:21:00,140 --> 00:21:02,100
1000？

466
00:21:02,100 --> 00:21:02,600
是嗎？

467
00:21:02,600 --> 00:21:04,475
>> 聽眾：字符串的長度為1001。

468
00:21:04,475 --> 00:21:05,350
DAVID馬蘭：沒錯。

469
00:21:05,350 --> 00:21:08,280
如果字符串的長度為1001，
你有相同的問題，

470
00:21:08,280 --> 00:21:10,705
和我的觀點，我會
就在這時，使其2000年，

471
00:21:10,705 --> 00:21:12,830
但你不知道
推進它應該多大，

472
00:21:12,830 --> 00:21:16,890
然而，我必須編譯我的程序
之前，讓人們使用和下載

473
00:21:16,890 --> 00:21:17,390
它。

474
00:21:17,390 --> 00:21:21,490
因此，這也正是那種
東東的CS50庫嘗試

475
00:21:21,490 --> 00:21:24,750
幫助我們，我們將只一瞥
一些底層實現的

476
00:21:24,750 --> 00:21:29,790
這裡，但這是CS50點C.這
是一直在CS50 IDE文件

477
00:21:29,790 --> 00:21:31,420
所有這幾個星期你一直在使用。

478
00:21:31,420 --> 00:21:34,280
這是預編譯的。而你
一直在使用它自動

479
00:21:34,280 --> 00:21:38,780
由具有的性質
衝大號CS50標誌鏗鏘，

480
00:21:38,780 --> 00:21:42,300
但如果我向下滾動，通過所有的
這些功能，這裡是GetString的，

481
00:21:42,300 --> 00:21:44,636
而只給你一個
什麼樣的味道是怎麼回事，

482
00:21:44,636 --> 00:21:46,760
讓我們快速瀏覽一下
的相對複雜性。

483
00:21:46,760 --> 00:21:48,870
這不是一個超長
功能，但我們沒有

484
00:21:48,870 --> 00:21:52,530
必須考慮所有的硬盤約
如何去得到的字符串。

485
00:21:52,530 --> 00:21:55,660
>> 因此，這裡是我的緩衝區和我
顯然初始化為null。

486
00:21:55,660 --> 00:21:57,990
當然，這是在
同樣的事情為char明星，

487
00:21:57,990 --> 00:22:00,585
但我決定
實施CS50庫

488
00:22:00,585 --> 00:22:02,460
如果我們要
是完全動態的，

489
00:22:02,460 --> 00:22:05,770
我事先不知道有多大的根本
字符串用戶會希望得到的。

490
00:22:05,770 --> 00:22:08,140
所以我要開始
只有一個空字符串

491
00:22:08,140 --> 00:22:11,507
我要去建立盡可能多
記憶，因為我需要適合用戶字符串

492
00:22:11,507 --> 00:22:13,340
如果我沒有
夠了，我要去問

493
00:22:13,340 --> 00:22:15,010
操作系統為更多的內存。

494
00:22:15,010 --> 00:22:17,510
我打算把他們的串
成的存儲器的更大的塊

495
00:22:17,510 --> 00:22:21,847
我要去釋放或釋放
內存不夠大塊

496
00:22:21,847 --> 00:22:23,680
我們正要
反复地做到這一點。

497
00:22:23,680 --> 00:22:25,570
>> 因此，快速瀏覽，
這裡只是一個變量

498
00:22:25,570 --> 00:22:28,780
與我要去跟踪
的我的緩衝器的容量。

499
00:22:28,780 --> 00:22:30,071
我多少字節可以裝？

500
00:22:30,071 --> 00:22:32,070
這裡有一個變量n與
而我要繼續

501
00:22:32,070 --> 00:22:36,200
跟踪有多少字節實際上是
緩衝器或用戶已鍵入。

502
00:22:36,200 --> 00:22:39,900
如果你還沒有見過這個，你
可以指定就像一個int變量

503
00:22:39,900 --> 00:22:46,370
是無符號的，它顧名思義，
意味著它的非負的，為什麼會

504
00:22:46,370 --> 00:22:50,590
我曾經想打擾指定
即一個int不只是一個int，

505
00:22:50,590 --> 00:22:52,540
但它是一個unsigned int？

506
00:22:52,540 --> 00:22:55,064
這是一個非負的int。

507
00:22:55,064 --> 00:22:56,355
什麼是[聽不清]是什麼意思？

508
00:22:56,355 --> 00:22:58,910
>> 聽眾：它描述了一個量
內存，可以[聽不清]。

509
00:22:58,910 --> 00:22:59,660
>> DAVID馬蘭：是的。

510
00:22:59,660 --> 00:23:03,710
所以，如果我說的符號，這其實是
給你一個額外的內存一位

511
00:23:03,710 --> 00:23:07,440
它似乎有點傻，但如果你
擁有更多的內存一位，那

512
00:23:07,440 --> 00:23:09,940
意味著你有兩倍多
你可以代表值，

513
00:23:09,940 --> 00:23:11,570
因為它可以是一個0或1。

514
00:23:11,570 --> 00:23:14,660
因此，在默認情況下，一個int可以大致
負2十億一路

515
00:23:14,660 --> 00:23:16,030
達正2十億。

516
00:23:16,030 --> 00:23:18,540
這些都是大的範圍，但
它是一種浪費還是

517
00:23:18,540 --> 00:23:21,280
如果你只關心
尺寸，這只是直覺

518
00:23:21,280 --> 00:23:24,620
應該是非負或
正或0，那麼，

519
00:23:24,620 --> 00:23:28,884
你為什麼要浪費2十億
為負數的可能值

520
00:23:28,884 --> 00:23:30,300
如果你從來沒有打算使用它們？

521
00:23:30,300 --> 00:23:35,350
所以說無符號的，現在我的INT可以
介於0和約4十億。

522
00:23:35,350 --> 00:23:39,280
>> 因此，這裡只是一個int下原因
我們不會進入剛才的

523
00:23:39,280 --> 00:23:42,280
為什麼它是一個int，而不是
一個char，但這裡是

524
00:23:42,280 --> 00:23:44,630
發生了什麼事情的要點
上，並且一些你

525
00:23:44,630 --> 00:23:48,340
可能使用，例如，在
即使在PSET 4龜etc功能

526
00:23:48,340 --> 00:23:51,580
或之後，我們會看到它
又在問題設置五，

527
00:23:51,580 --> 00:23:55,410
龜etc是不錯的，因為作為名稱
那種，有點arcanely表明，

528
00:23:55,410 --> 00:23:57,940
這是一個函數，
獲取一個字符等等，

529
00:23:57,940 --> 00:24:00,690
有什麼本質上的區別
什麼，我們正在做的GetString的

530
00:24:00,690 --> 00:24:03,110
是我們沒有使用
scanf的以相同的方式。

531
00:24:03,110 --> 00:24:07,550
我們沿著一步一步的只是爬行
以上的任何用戶已鍵入中，

532
00:24:07,550 --> 00:24:10,970
因為我們總是可以分配一個
字符，所以我們總能安全地

533
00:24:10,970 --> 00:24:15,599
看一個字符的時間，和
神奇的開始發生在這裡。

534
00:24:15,599 --> 00:24:17,890
我要向下滾動到
此功能的中間

535
00:24:17,890 --> 00:24:20,360
只是簡單介紹一下這個功能。

536
00:24:20,360 --> 00:24:22,670
就像有一個
malloc函數，有

537
00:24:22,670 --> 00:24:27,740
一個realloc函數，其中的realloc
讓你重新分配一塊內存

538
00:24:27,740 --> 00:24:29,570
並使它更大或更小。

539
00:24:29,570 --> 00:24:33,060
所以長話短說，並與
一波我的手今天，

540
00:24:33,060 --> 00:24:35,620
知道什麼樣的GetString
正在做的是它的排序

541
00:24:35,620 --> 00:24:39,720
的神奇成長或
緩衝收縮作為用戶

542
00:24:39,720 --> 00:24:41,440
類型在他或她的字符串。

543
00:24:41,440 --> 00:24:43,962
>> 因此，如果用戶鍵入一個
短字符串，該代碼

544
00:24:43,962 --> 00:24:45,920
僅分配足夠
存儲器以適應串。

545
00:24:45,920 --> 00:24:48,086
如果用戶保持打字
我一次又一次做到了

546
00:24:48,086 --> 00:24:50,330
又一次，好吧，如果
緩衝區的最初這個大

547
00:24:50,330 --> 00:24:53,310
和程序實現，對
等一下，我的空間，

548
00:24:53,310 --> 00:24:55,410
這將增加一倍
緩衝區的大小

549
00:24:55,410 --> 00:24:59,110
然後加倍緩衝區的大小
而且確實增加一倍代碼，

550
00:24:59,110 --> 00:25:03,170
如果我們看一下在這裡，它是
只是這個聰明的一班輪。

551
00:25:03,170 --> 00:25:06,830
你可能沒見過這種語法
之前，但如果你說明星等於，

552
00:25:06,830 --> 00:25:10,470
這是同樣的事情，
說產能的2倍。

553
00:25:10,470 --> 00:25:13,390
因此，它只是不斷翻番
所述緩衝器的容量

554
00:25:13,390 --> 00:25:17,480
然後告訴realloc的給
本身更多的內存。

555
00:25:17,480 --> 00:25:19,720
>> 現在，順便說一句，有
在這裡等功能

556
00:25:19,720 --> 00:25:23,680
我們不會考慮任何細節
比其他的調用getInt顯示，

557
00:25:23,680 --> 00:25:26,150
我們使用的GetString的調用getInt。

558
00:25:26,150 --> 00:25:28,192
我們檢查，這不是
空，其中，召回，

559
00:25:28,192 --> 00:25:30,400
是特殊的值，
意味著出事了。

560
00:25:30,400 --> 00:25:31,233
我們是內存不足。

561
00:25:31,233 --> 00:25:32,310
更好地檢查了。

562
00:25:32,310 --> 00:25:33,710
而我們返回的警戒值。

563
00:25:33,710 --> 00:25:37,850
但我會推遲到的意見，以
為什麼然後我們用這個表弟scanf函數的

564
00:25:37,850 --> 00:25:42,100
所謂sscanf的和原來
該sscanf的，或字符串scanf函數，

565
00:25:42,100 --> 00:25:45,310
讓你看看就行了
用戶鍵入，讓你

566
00:25:45,310 --> 00:25:49,610
本質上分析它，就是我
這裡做的是我要告訴sscanf的，

567
00:25:49,610 --> 00:25:54,440
分析任何用戶具有
鍵入並確保％我，

568
00:25:54,440 --> 00:25:59,250
有在它的整數，並且我們不會
進入今天究竟為什麼有還

569
00:25:59,250 --> 00:26:03,760
一％C在這裡，但簡而言之允許
我們檢測是否用戶已鍵入

570
00:26:03,760 --> 00:26:06,050
在一些號碼後偽造的。

571
00:26:06,050 --> 00:26:11,766
因此原因，調用getInt和GetString
告訴你重試，重試，重試

572
00:26:11,766 --> 00:26:13,640
是因為所有的
我們編寫的代碼，

573
00:26:13,640 --> 00:26:17,900
它種在看用戶的輸入
在確保它完全數字

574
00:26:17,900 --> 00:26:21,700
或者它是一個真正的浮動
點值等，

575
00:26:21,700 --> 00:26:24,233
這取決於什麼樣的價值
您正在使用的功能。

576
00:26:24,233 --> 00:26:25,060
>> 呼。

577
00:26:25,060 --> 00:26:25,710
確定。

578
00:26:25,710 --> 00:26:27,592
這是一個拗口
但問題在這裡

579
00:26:27,592 --> 00:26:29,550
我們有原因
這些培訓車輪

580
00:26:29,550 --> 00:26:32,880
是因為在最低水平，
還有就是這麼多的事情

581
00:26:32,880 --> 00:26:35,674
可以去錯了，我們想
搶先處理

582
00:26:35,674 --> 00:26:38,090
這些東西肯定是在
最早的幾個星期之類的，

583
00:26:38,090 --> 00:26:42,230
但現在PSET四個PSET五
以後你會發現它更對

584
00:26:42,230 --> 00:26:45,570
你還要你更強大
對解決這些類型的問題

585
00:26:45,570 --> 00:26:47,180
你自己。

586
00:26:47,180 --> 00:26:51,770
上的GetString或調用getInt有問題嗎？

587
00:26:51,770 --> 00:26:52,630
是嗎？

588
00:26:52,630 --> 00:26:55,130
>> 聽眾：你為什麼會增加一倍
所述緩衝器的容量

589
00:26:55,130 --> 00:26:57,630
而不是僅僅增加
它的具體數額？

590
00:26:57,630 --> 00:26:58,100
>> DAVID馬蘭：好問題。

591
00:26:58,100 --> 00:27:00,474
為什麼我們的身份倍增
緩衝器的相

592
00:27:00,474 --> 00:27:02,800
只是增加它
一些常數值？

593
00:27:02,800 --> 00:27:03,900
這是一個設計決策。

594
00:27:03,900 --> 00:27:08,590
我們剛剛決定，因為它往往
有點貴的時間，聰明的問

595
00:27:08,590 --> 00:27:10,440
操作系統
內存，我們沒有

596
00:27:10,440 --> 00:27:13,210
要最終進入
這種情況對於大串

597
00:27:13,210 --> 00:27:14,960
我們被要求
連連操作系統

598
00:27:14,960 --> 00:27:17,500
一次又一次的
快速連續的內存。

599
00:27:17,500 --> 00:27:20,387
因此，我們剛剛決定，多少有些
任意但我們希望合理，

600
00:27:20,387 --> 00:27:22,720
如此，你知道嗎，讓我們
試圖獲得超越自我

601
00:27:22,720 --> 00:27:25,520
而只是一味增加了一倍它使
我們最小化的倍量

602
00:27:25,520 --> 00:27:29,010
我們必須調用malloc或
realloc的，但總的判斷

603
00:27:29,010 --> 00:27:31,820
在沒有知道的調用
什麼樣的用戶可能需要輸入內容。

604
00:27:31,820 --> 00:27:33,600
這兩種方式可能是值得商榷的。

605
00:27:33,600 --> 00:27:35,430
可以說不錯。

606
00:27:35,430 --> 00:27:39,240
>> 因此，讓我們來看看一對夫婦
的內存等副作用，

607
00:27:39,240 --> 00:27:41,610
事情可能出錯
和工具，你可以

608
00:27:41,610 --> 00:27:43,880
用它來捕獲這些類型的錯誤。

609
00:27:43,880 --> 00:27:47,800
原來大家，即使
check50沒有告訴你一樣多，

610
00:27:47,800 --> 00:27:50,050
一直在寫越野車
因為一個星期代碼，

611
00:27:50,050 --> 00:27:53,630
即使所有check50測試
過去了，即使你和你的TF

612
00:27:53,630 --> 00:27:56,010
超級信心
你的代碼按預期工作。

613
00:27:56,010 --> 00:27:59,190
您的代碼已被馬車或
有缺陷的，所有的你，

614
00:27:59,190 --> 00:28:02,540
在使用CS50庫
被洩漏內存。

615
00:28:02,540 --> 00:28:06,040
你一直在問的操作系統
對於存儲器在大多數的節目

616
00:28:06,040 --> 00:28:08,850
你寫的，但你
從來沒有真正賦予它回來。

617
00:28:08,850 --> 00:28:12,110
你所謂的GetString
和調用getInt和GetFloat，

618
00:28:12,110 --> 00:28:15,270
但GetString的，你
從來沒有所謂unGetString或給

619
00:28:15,270 --> 00:28:19,890
返回的字符串或類似的，但我們已經看到
是的GetString確實分配內存

620
00:28:19,890 --> 00:28:22,810
由malloc或方式這
功能realloc的，這僅僅是

621
00:28:22,810 --> 00:28:25,670
在精神上非常相似，
然而，我們已經

622
00:28:25,670 --> 00:28:28,629
詢問操作系統以
存儲器和存儲器連連

623
00:28:28,629 --> 00:28:29,670
但從來沒有給它回來。

624
00:28:29,670 --> 00:28:33,550
>> 現在，順便說一句，事實證明，
當程序退出，所有內存

625
00:28:33,550 --> 00:28:34,870
自動釋放。

626
00:28:34,870 --> 00:28:36,150
所以它沒有一個巨大的交易。

627
00:28:36,150 --> 00:28:38,590
它不會打破
IDE或放慢改革的步伐，

628
00:28:38,590 --> 00:28:40,670
但是當程序執行
一般內存洩漏

629
00:28:40,670 --> 00:28:42,170
而他們正在運行很長一段時間。

630
00:28:42,170 --> 00:28:45,640
如果你見過那些愚蠢的小
在Mac OS或沙漏沙灘球

631
00:28:45,640 --> 00:28:51,160
在Windows上它是一種
減緩或思考或思維

632
00:28:51,160 --> 00:28:53,770
或者只是真正開始
慢如蝸牛，

633
00:28:53,770 --> 00:28:56,960
它很可能可以
內存洩漏的結果。

634
00:28:56,960 --> 00:28:59,970
誰寫的程序員
您正在使用的軟件

635
00:28:59,970 --> 00:29:03,570
要求對內存的操作系統
每隔幾分鐘，每隔一小時。

636
00:29:03,570 --> 00:29:05,570
但是，如果你正在運行的
軟件，即使是

637
00:29:05,570 --> 00:29:08,680
最小化您的電腦
幾個小時或幾天，

638
00:29:08,680 --> 00:29:11,980
你可能會問了越來越多
內存和從來沒有真正使用它

639
00:29:11,980 --> 00:29:15,180
所以你的代碼可能是，或
程序可能洩漏內存，

640
00:29:15,180 --> 00:29:18,350
如果你開始洩漏內存，
還有其他程序內存少，

641
00:29:18,350 --> 00:29:21,220
而且其效果是
慢都記錄下來。

642
00:29:21,220 --> 00:29:23,600
>> 現在，這是迄今為止的一個
最殘暴的方案

643
00:29:23,600 --> 00:29:26,350
你將有機會
在CS50運行，只要

644
00:29:26,350 --> 00:29:31,650
作為其輸出甚至比更深奧
鏗鏘的或做的或任何命令

645
00:29:31,650 --> 00:29:35,930
我們之前已經運行線方案，但
值得慶幸的是，鑲嵌在其輸出

646
00:29:35,930 --> 00:29:39,810
一些超有用的技巧，
將是有益的無論是PSET 4

647
00:29:39,810 --> 00:29:41,510
不然肯定P設定五位。

648
00:29:41,510 --> 00:29:44,250
所以Valgrind是一個工具，
可用於看

649
00:29:44,250 --> 00:29:46,930
程序中的內存洩漏。

650
00:29:46,930 --> 00:29:48,570
這是相對簡單的運行。

651
00:29:48,570 --> 00:29:51,420
你跑Valgrind的，然後，連
雖然這是一個有點冗長，

652
00:29:51,420 --> 00:29:54,440
短跑衝刺洩漏檢查
等於滿，然後點

653
00:29:54,440 --> 00:29:56,320
斜線和你的程序的名稱。

654
00:29:56,320 --> 00:30:00,010
因此，Valgrind的會後運行程序
並在程序的最後

655
00:30:00,010 --> 00:30:02,240
運行它退出前，
為您提供了另一個提示，

656
00:30:02,240 --> 00:30:04,980
它會分析你的
雖然它已經正在運行的程序

657
00:30:04,980 --> 00:30:07,740
並告訴你你洩露
任何內存和更好的是，

658
00:30:07,740 --> 00:30:10,610
你觸碰內存
不屬於你？

659
00:30:10,610 --> 00:30:13,700
它無法趕上一切，但它的
在最醒目的東西很不錯。

660
00:30:13,700 --> 00:30:19,700
>> 因此，這裡是有經營我的一個例子
這個節目，有跑Valgrind的，

661
00:30:19,700 --> 00:30:21,470
在調用程序
記憶，我要去

662
00:30:21,470 --> 00:30:24,730
以突出的線條
最終我們感興趣的。

663
00:30:24,730 --> 00:30:27,690
因此，有更多的分心
我已經從幻燈片中刪除。

664
00:30:27,690 --> 00:30:30,930
但是，讓我們只看看這是什麼
程序能夠告訴我們的。

665
00:30:30,930 --> 00:30:34,800
它能夠告訴我們的東西
像大小為4無效寫。

666
00:30:34,800 --> 00:30:38,020
換句話說，如果你觸碰到內存，
特別是4字節的內存

667
00:30:38,020 --> 00:30:40,350
你不應該有，
的valgrind可以告訴你。

668
00:30:40,350 --> 00:30:41,660
無效的寫大小為4。

669
00:30:41,660 --> 00:30:43,640
你感動了四個字節
你不應該有。

670
00:30:43,640 --> 00:30:44,840
你在哪兒做的？

671
00:30:44,840 --> 00:30:45,900
這是美。

672
00:30:45,900 --> 00:30:50,000
記憶點C線21就是你
搞砸了，這就是為什麼它是有幫助的。

673
00:30:50,000 --> 00:30:53,410
就像GDB，它可以幫助
點你在實際的錯誤。

674
00:30:53,410 --> 00:30:57,170
>> 現在，這一個多一點
冗長的，如果不是混亂。

675
00:30:57,170 --> 00:31:01,307
在1塊40個字節肯定
在負的戰績1 1的丟失。

676
00:31:01,307 --> 00:31:02,140
這是什麼意思？

677
00:31:02,140 --> 00:31:05,920
嗯，這只是意味著你問
40個字節，你從來沒有給它回來。

678
00:31:05,920 --> 00:31:08,930
你叫的malloc，或者您叫
GetString的和操作系統

679
00:31:08,930 --> 00:31:12,450
給你40​​個字節，但你永遠不
釋放或者釋放內存，

680
00:31:12,450 --> 00:31:15,400
而公平地說，我們從來沒有展示
你如何回饋內存。

681
00:31:15,400 --> 00:31:17,910
原來有一個超
所謂的自由簡單的功能。

682
00:31:17,910 --> 00:31:21,170
有一個參數的東西
你想免費或給予回复，

683
00:31:21,170 --> 00:31:23,430
但40個字節，顯然，
這個方案

684
00:31:23,430 --> 00:31:27,300
已經失去了線
內存20 C點。

685
00:31:27,300 --> 00:31:28,650
>> 因此，讓我們看到這個計劃。

686
00:31:28,650 --> 00:31:31,020
這是超級沒用。

687
00:31:31,020 --> 00:31:33,980
它不僅展現
此特定錯誤。

688
00:31:33,980 --> 00:31:34,920
因此，讓我們一起來看看。

689
00:31:34,920 --> 00:31:39,920
下面是主要的和主要的，通知，電話
一個函數調用f和再返回。

690
00:31:39,920 --> 00:31:41,550
所以不是那麼有趣。

691
00:31:41,550 --> 00:31:42,664
什麼是f執行？

692
00:31:42,664 --> 00:31:44,330
請注意，我並沒有原型麻煩。

693
00:31:44,330 --> 00:31:46,520
我想保持代碼
盡可能小。

694
00:31:46,520 --> 00:31:49,530
所以我把F時上部主
這很好，當然，

695
00:31:49,530 --> 00:31:51,500
對於這樣的短期課程。

696
00:31:51,500 --> 00:31:56,910
因此，F不返回任何東西和做
不能帶什麼，但它確實做到這一點。

697
00:31:56,910 --> 00:31:59,620
它聲明，很像
在賓基例如，

698
00:31:59,620 --> 00:32:02,682
一個名為x的指針是怎麼回事
存儲一個int的地址。

699
00:32:02,682 --> 00:32:03,890
所以這是左手側。

700
00:32:03,890 --> 00:32:07,230
在英語中，什麼是
右手邊做什麼？

701
00:32:07,230 --> 00:32:09,770
有人嗎？

702
00:32:09,770 --> 00:32:13,665
這是什麼做的我們呢？

703
00:32:13,665 --> 00:32:14,651
是嗎？

704
00:32:14,651 --> 00:32:16,623
>> 聽眾：[聽不清]
倍int的大小

705
00:32:16,623 --> 00:32:19,175
它是10倍，[聽不清]

706
00:32:19,175 --> 00:32:20,800
DAVID馬蘭：好，讓我來總結。

707
00:32:20,800 --> 00:32:25,480
因此，分配足夠的空間為10整數
或10，什麼是一個int的大小，

708
00:32:25,480 --> 00:32:29,340
它的四個字節，所以10次4
40，使右手邊，我已經

709
00:32:29,340 --> 00:32:33,930
高亮顯示的是給我40個字節，
存儲第一字節的地址

710
00:32:33,930 --> 00:32:34,940
成X個。

711
00:32:34,940 --> 00:32:38,380
而現在最後，而這裡的地方
這個程序有錯誤，什麼是

712
00:32:38,380 --> 00:32:41,540
錯線21基於該邏輯是什麼？

713
00:32:41,540 --> 00:32:45,197

714
00:32:45,197 --> 00:32:46,280
有什麼不對線21？

715
00:32:46,280 --> 00:32:46,780
是嗎？

716
00:32:46,780 --> 00:32:49,550
聽眾：你不能
索引X [聽不清]。

717
00:32:49,550 --> 00:32:50,300
DAVID馬蘭：是的。

718
00:32:50,300 --> 00:32:52,270
我不該指數成X個這樣的。

719
00:32:52,270 --> 00:32:53,850
所以語法，沒關係。

720
00:32:53,850 --> 00:32:56,990
什麼是好的是，就像你
可以把一個數組名

721
00:32:56,990 --> 00:33:01,080
就好像它是一個指針，同樣
你可以把一個指針，彷彿它是

722
00:33:01,080 --> 00:33:06,425
一個數組，這樣我就可以在語法
例如x支架的東西，X架我，

723
00:33:06,425 --> 00:33:07,800
但10是有問題的。

724
00:33:07,800 --> 00:33:09,096
為什麼呢？

725
00:33:09,096 --> 00:33:10,910
>> 聽眾：因為它不是內。

726
00:33:10,910 --> 00:33:12,390
>> DAVID馬蘭：這不是
裡面的內存塊。

727
00:33:12,390 --> 00:33:15,306
什麼是最大的價值，我應該
可以把這些方括號？

728
00:33:15,306 --> 00:33:16,870
9，0到9。

729
00:33:16,870 --> 00:33:18,160
因為零索引。

730
00:33:18,160 --> 00:33:20,190
因此，從0到9就可以了。

731
00:33:20,190 --> 00:33:23,960
支架10是不好的，
但是，每一次回憶，雖然

732
00:33:23,960 --> 00:33:27,017
我似乎盡量讓CS50的IDE
墜毀通過鍵入假值，

733
00:33:27,017 --> 00:33:29,100
它並不總是合作，
而事實上，你經常

734
00:33:29,100 --> 00:33:31,460
幸運只是因為
操作系統不

735
00:33:31,460 --> 00:33:35,467
請注意，您可以輕微
通過一些內存塊，

736
00:33:35,467 --> 00:33:38,300
因為你住在技術上
您的段，但更多介紹

737
00:33:38,300 --> 00:33:40,940
在一個操作系統類，
所以像這樣

738
00:33:40,940 --> 00:33:43,000
可以很容易被忽視。

739
00:33:43,000 --> 00:33:48,120
你的程序永遠不會崩潰
持續但也許曾經在一段時間。

740
00:33:48,120 --> 00:33:50,610
>> 因此，讓我們嘗試的valgrind
這一點，和這裡的

741
00:33:50,610 --> 00:33:52,870
在這裡，我們會變得不知所措
通過瞬間的輸出。

742
00:33:52,870 --> 00:34:00,810
因此，請Valgrind的內存洩漏檢查
等於全點斜線內存。

743
00:34:00,810 --> 00:34:03,040
這裡就是為什麼我保證
這將壓倒。

744
00:34:03,040 --> 00:34:05,700
以下是Valgrind的，下面是
一個程序員，有些年份ago-

745
00:34:05,700 --> 00:34:08,469
決定這將是一個好主意
為輸出的樣子。

746
00:34:08,469 --> 00:34:09,750
因此，讓我們理解這一點。

747
00:34:09,750 --> 00:34:13,120
因此，所有對左手的方式
側面沒有很好的理由

748
00:34:13,120 --> 00:34:16,620
是程序的進程ID
我們只需運行，唯一標識符

749
00:34:16,620 --> 00:34:18,030
對於該方案，我們只是跑。

750
00:34:18,030 --> 00:34:19,738
我們刪除了從
滑動，但也有

751
00:34:19,738 --> 00:34:22,190
在這裡一些有用的信息。

752
00:34:22,190 --> 00:34:24,684
>> 讓我們向上滾動到頂部。

753
00:34:24,684 --> 00:34:25,600
這裡就是我們的開始。

754
00:34:25,600 --> 00:34:27,040
因此，它不是所有的東西輸出。

755
00:34:27,040 --> 00:34:30,429
下面是無效的寫
對21行大小4。

756
00:34:30,429 --> 00:34:31,760
那麼，什麼是第21行？

757
00:34:31,760 --> 00:34:34,500
第21行正是
這一點，這是有道理的

758
00:34:34,500 --> 00:34:37,290
我是在有效
寫4個字節，因為我

759
00:34:37,290 --> 00:34:40,389
試圖把這個整數，
它可以是任何東西，

760
00:34:40,389 --> 00:34:42,370
這恰好是
零，但是我想

761
00:34:42,370 --> 00:34:44,940
把它在一個位置
這不屬於我。

762
00:34:44,940 --> 00:34:50,900
此外，到這裡，40在一個字節
塊肯定是失去了在創紀錄的1。

763
00:34:50,900 --> 00:34:56,500
這是因為當我調用malloc
在這裡，我從來沒有真正釋放內存。

764
00:34:56,500 --> 00:34:58,140
>> 那麼，如何才能解決這個問題？

765
00:34:58,140 --> 00:35:02,970
讓我繼續前進，是一個小更安全
並做9那兒，讓我在這裡免費的X。

766
00:35:02,970 --> 00:35:04,820
這是新的功能，為今天。

767
00:35:04,820 --> 00:35:11,520
如果我現在重新運行使內存點斜線，
讓我們在其上運行的valgrind再次，

768
00:35:11,520 --> 00:35:14,990
最大限度地發揮我的窗口，然後按Enter。

769
00:35:14,990 --> 00:35:16,900
現在，這是很好的。

770
00:35:16,900 --> 00:35:19,590
他們埋葬好消息
在這一切的輸出。

771
00:35:19,590 --> 00:35:20,810
所有堆塊是免費的。

772
00:35:20,810 --> 00:35:23,604
我們會回來的東西堆
是，但無洩漏是可能的。

773
00:35:23,604 --> 00:35:25,520
因此，這只是另一種
工具的工具箱

774
00:35:25,520 --> 00:35:30,220
使用它可以開始
現在發現這樣的錯誤。

775
00:35:30,220 --> 00:35:34,532
>> 但是讓我們看看有什麼
更可以去錯在這裡。

776
00:35:34,532 --> 00:35:38,890
現在讓我們來轉變
其實解決問題。

777
00:35:38,890 --> 00:35:42,440
順便說一句，如果這將緩解一
混亂或緊張一點，

778
00:35:42,440 --> 00:35:43,430
這是現在好笑。

779
00:35:43,430 --> 00:35:46,400

780
00:35:46,400 --> 00:35:46,900
是啊。

781
00:35:46,900 --> 00:35:49,040
這是相當不錯的。

782
00:35:49,040 --> 00:35:50,890
因為指針
地址和地址

783
00:35:50,890 --> 00:35:53,098
一般都是按照慣例
寫的十六進制。

784
00:35:53,098 --> 00:35:54,650
哈，哈，這個現在好笑。

785
00:35:54,650 --> 00:35:58,390
總之，讓我們現在
其實解決的一個問題。

786
00:35:58,390 --> 00:36:00,840
這一直是超級，
超低水平迄今為止，

787
00:36:00,840 --> 00:36:03,950
而我們實際上可以做有益
事情與這些低級別的細節。

788
00:36:03,950 --> 00:36:06,710
>> 因此，我們介紹了幾個星期
前的陣列的概念。

789
00:36:06,710 --> 00:36:09,177
數組是不錯的，因為
很難清理我們的代碼

790
00:36:09,177 --> 00:36:11,760
因為如果我們想寫
程序有多個學生

791
00:36:11,760 --> 00:36:15,270
或多個名稱和房屋及
宿舍，學院和所有這一切，

792
00:36:15,270 --> 00:36:19,430
我們可以存儲的一切更
乾淨的陣列的內部。

793
00:36:19,430 --> 00:36:23,039
但提出一個缺點
陣列的迄今。

794
00:36:23,039 --> 00:36:26,080
即使你沒有自己遭受它
在一個程序，只是本能地，

795
00:36:26,080 --> 00:36:30,870
什麼是壞事
有關陣列，也許？

796
00:36:30,870 --> 00:36:32,337
我聽到一些​​雜音。

797
00:36:32,337 --> 00:36:34,170
聽眾：這很難
改變大小。

798
00:36:34,170 --> 00:36:36,128
DAVID馬蘭：這很難
改變大小。

799
00:36:36,128 --> 00:36:38,660
你不能改變大小
陣列的，實際上，本身

800
00:36:38,660 --> 00:36:43,040
在C.你可以分配另一個數組，
從舊的移動一切

801
00:36:43,040 --> 00:36:45,380
到新的，現在
有一些額外的空間，

802
00:36:45,380 --> 00:36:47,469
但它不喜歡
如Java或Python語言

803
00:36:47,469 --> 00:36:49,760
或任何數目的其他的
與語言的一些你

804
00:36:49,760 --> 00:36:52,070
可能是熟悉的，你
可以只保留添加的東西

805
00:36:52,070 --> 00:36:53,930
令人作嘔到數組的結尾。

806
00:36:53,930 --> 00:36:57,880
當你有一個數組
大小6，這是它的大小，

807
00:36:57,880 --> 00:37:01,970
和這麼多喜歡這個主意更早
具有一定大小的緩衝區，

808
00:37:01,970 --> 00:37:05,940
你必須猜測出大門
你想要什麼尺寸它是什麼？

809
00:37:05,940 --> 00:37:07,880
如果你猜過大，
你就是在浪費空間。

810
00:37:07,880 --> 00:37:10,950
如果你猜過小，
不能存儲的數據，至少

811
00:37:10,950 --> 00:37:12,940
沒有更多的工作。

812
00:37:12,940 --> 00:37:18,180
>> 所以今天，多虧了指針，我們可以
開始拼接起來自己的自定義

813
00:37:18,180 --> 00:37:20,989
數據結構，以及在
其實，這裡的東西

814
00:37:20,989 --> 00:37:23,030
看起來有點多
神秘的第一眼，

815
00:37:23,030 --> 00:37:26,440
但是這就是我們會打電話給一個鏈接
列表，它的名字樣的總結

816
00:37:26,440 --> 00:37:26,940
它。

817
00:37:26,940 --> 00:37:29,550
它的號碼的列表，或者在
這種情況下，數字的列表，

818
00:37:29,550 --> 00:37:33,480
但它可能是任何一個列表，但
它連接在一起的箭頭的方式，

819
00:37:33,480 --> 00:37:36,380
而只是採取一種猜測
有什麼方法

820
00:37:36,380 --> 00:37:38,310
我們要能
縫合在一起，

821
00:37:38,310 --> 00:37:42,540
有點像爆米花用線，
一個鍊錶矩形嗎？

822
00:37:42,540 --> 00:37:43,936
它的數字？

823
00:37:43,936 --> 00:37:45,560
什麼是底層語言功能？

824
00:37:45,560 --> 00:37:46,350
>> 聽眾：一個指針。

825
00:37:46,350 --> 00:37:47,308
>> DAVID馬蘭：一個指針。

826
00:37:47,308 --> 00:37:51,700
所以，每一個箭在這裡代表
指針或只是一個地址。

827
00:37:51,700 --> 00:37:54,590
因此，換句話說，如果我想
來存儲數字列表，

828
00:37:54,590 --> 00:37:59,040
我不能只保存它，如果我想
增長和收縮的能力

829
00:37:59,040 --> 00:38:00,990
我的數據結構中的陣列。

830
00:38:00,990 --> 00:38:03,000
因此，我需要有一點
更複雜，

831
00:38:03,000 --> 00:38:05,720
但是請注意，這
圖片一種暗示

832
00:38:05,720 --> 00:38:08,650
如果你拿到的小線程
一切都連接在一起，

833
00:38:08,650 --> 00:38:13,100
也許並不難，以騰出空間
其中的兩個矩形之間

834
00:38:13,100 --> 00:38:16,750
兩個這些節點，因為我們將開始
美其名曰，放入一個新的節點，

835
00:38:16,750 --> 00:38:19,547
然後用一些新的線程，只
溝三個節點一起，

836
00:38:19,547 --> 00:38:22,880
第一個，最後一個，並且所述一個
您剛剛插入中間。

837
00:38:22,880 --> 00:38:26,000
>> 事實上鍊錶，
一個數組不同的，是動態的。

838
00:38:26,000 --> 00:38:27,840
它可以成長，它可以
收縮而你不知道

839
00:38:27,840 --> 00:38:32,434
有知道或關心提前如何
你要多少數據被存儲，

840
00:38:32,434 --> 00:38:35,600
但事實證明，我們是一個小
小心如何實現這一點。

841
00:38:35,600 --> 00:38:39,070
因此，首先讓我們來看看我們如何實現
其中一個小矩形。

842
00:38:39,070 --> 00:38:40,690
這很容易實現一個int。

843
00:38:40,690 --> 00:38:44,000
你剛才說INT n和再
你得到的4個字節為一個int，

844
00:38:44,000 --> 00:38:49,089
但我怎麼得到一個int，正調用它，
再一個指針，讓我們稱之為下一個。

845
00:38:49,089 --> 00:38:50,880
我們可以把這些
什麼東西我們要

846
00:38:50,880 --> 00:38:53,590
但我需要一個自定義的數據結構。

847
00:38:53,590 --> 00:38:54,257
是嗎？

848
00:38:54,257 --> 00:38:57,020
>> 聽眾：＆符號[聽不清]。

849
00:38:57,020 --> 00:39:00,940
>> DAVID馬蘭：所以符號，我們將用它來
獲得一個節點的地址可能。

850
00:39:00,940 --> 00:39:02,740
但是，我們需要另一個
C的順序功能

851
00:39:02,740 --> 00:39:06,700
給我創造的能力
這個自定義的矩形，這種風俗

852
00:39:06,700 --> 00:39:08,919
變量，如果你願意，在內存中。

853
00:39:08,919 --> 00:39:09,710
聽眾：一個結構。

854
00:39:09,710 --> 00:39:10,626
DAVID馬蘭：一個結構。

855
00:39:10,626 --> 00:39:14,310
從上週還記得，我們​​推出
結構，這種相對簡單的關鍵詞

856
00:39:14,310 --> 00:39:16,254
這讓我們做這樣的事情。

857
00:39:16,254 --> 00:39:18,420
Ç沒有配備數據
結構被稱為學生。

858
00:39:18,420 --> 00:39:22,190
它配備了int和float和char和
這樣，但它不來學生，

859
00:39:22,190 --> 00:39:26,750
但我們可以創建一個學生數據類型，
學生結構，這種語法

860
00:39:26,750 --> 00:39:27,250
在這裡。

861
00:39:27,250 --> 00:39:28,350
你會一次又一次地看到這一點。

862
00:39:28,350 --> 00:39:30,426
所以不要擔心
記憶中的關鍵字，

863
00:39:30,426 --> 00:39:33,300
但關鍵字，重要的是
只是一個事實，即我們所說的結構

864
00:39:33,300 --> 00:39:37,590
然後我們把它稱為學生和內
學生的是一個名字和一個房子

865
00:39:37,590 --> 00:39:39,390
或者宿舍等。

866
00:39:39,390 --> 00:39:41,980
>> 所以現在的今天，讓我們提出這一點。

867
00:39:41,980 --> 00:39:45,240
我加了幾句話，但是如果我想
實現這個矩形的

868
00:39:45,240 --> 00:39:48,440
既得到了一個int和
指針，你知道嗎，我

869
00:39:48,440 --> 00:39:51,540
要聲明一個叫做節點結構。

870
00:39:51,540 --> 00:39:55,630
我也是，在它的內部，會說
一個節點，這個矩形，有一個int

871
00:39:55,630 --> 00:39:59,730
我們將稱之為n和
它具有一個下一個指針。

872
00:39:59,730 --> 00:40:02,540
這是一個有點冗長，
但如果你仔細想想，

873
00:40:02,540 --> 00:40:07,300
那些出現在畫面中的箭頭
剛才是什麼數據類型？

874
00:40:07,300 --> 00:40:12,330
每個這些箭頭的指向
數據結構是什麼類型？

875
00:40:12,330 --> 00:40:14,332
這不是指著剛本身一個int。

876
00:40:14,332 --> 00:40:16,165
它指向
整個矩形的事情

877
00:40:16,165 --> 00:40:18,720
那長方形的東西，
我們說，被稱為一個節點。

878
00:40:18,720 --> 00:40:21,720
所以，我們種得
遞歸定義該這樣

879
00:40:21,720 --> 00:40:26,270
一個節點，我們會說，
將包含一個名為-n的INT

880
00:40:26,270 --> 00:40:31,070
並呼籲下及指針
數據結構的類型向其中

881
00:40:31,070 --> 00:40:35,770
該指針指向顯然是
將是結構節點。

882
00:40:35,770 --> 00:40:41,550
>> 因此，這是煩人詳細
而剛需迂腐，

883
00:40:41,550 --> 00:40:44,100
我們之所以不能
只是這麼一說，坦率地說

884
00:40:44,100 --> 00:40:46,860
看起來很多更具可讀性，
是因為回想一下，C了解

885
00:40:46,860 --> 00:40:48,710
東西從上到下，從左到右。

886
00:40:48,710 --> 00:40:54,120
這不是直到我們得到了分號
該關鍵字的節點確實存在。

887
00:40:54,120 --> 00:40:57,980
因此，如果我們希望有這樣的
數據的內部循環參考

888
00:40:57,980 --> 00:41:02,120
結構，我們不得不這樣做，在哪裡
我們說結構節點在頂部，這

889
00:41:02,120 --> 00:41:06,770
給我們描述了這樣一個更長的路
的事情，然後在裡面我們說結構節點，

890
00:41:06,770 --> 00:41:09,560
然後在最後一行
我們說，沒事，C，順便說一下，

891
00:41:09,560 --> 00:41:12,060
只需撥打這個整個該死
事情的一個節點，並停止

892
00:41:12,060 --> 00:41:14,360
共使用關鍵字結構。

893
00:41:14,360 --> 00:41:18,030
因此，這只是有點句法
伎倆，最終讓我們創造

894
00:41:18,030 --> 00:41:21,370
一些看起來完全一樣。

895
00:41:21,370 --> 00:41:25,010
>> 因此，如果我們現在假設我們可以
用C實現這個東西，

896
00:41:25,010 --> 00:41:28,040
我們如何做實際上
開始遍歷這個？

897
00:41:28,040 --> 00:41:32,360
唉，其實，我們所要做的就是
遍歷從左至右，只是

898
00:41:32,360 --> 00:41:35,960
一種插入節點或刪除節點
或搜索東西的地方，我們希望，

899
00:41:35,960 --> 00:41:39,560
但要做到這一點，讓我們繼續前進，使
事情變得更真實，因為這

900
00:41:39,560 --> 00:41:42,560
已經超低水平迄今。

901
00:41:42,560 --> 00:41:45,700
會有人從字面上想成為第一個？

902
00:41:45,700 --> 00:41:46,200
確定。

903
00:41:46,200 --> 00:41:47,092
上來吧。

904
00:41:47,092 --> 00:41:47,800
你叫什麼名字？

905
00:41:47,800 --> 00:41:48,499
>> 大衛：大衛。

906
00:41:48,499 --> 00:41:49,290
DAVID馬蘭：大衛。

907
00:41:49,290 --> 00:41:49,998
認識你很高興。

908
00:41:49,998 --> 00:41:50,960
我也是。

909
00:41:50,960 --> 00:41:52,450
好的。

910
00:41:52,450 --> 00:41:53,990
我們需要一個9號。

911
00:41:53,990 --> 00:41:55,240
還不如先，也許是。

912
00:41:55,240 --> 00:41:56,430
OK，號碼9。

913
00:41:56,430 --> 00:41:59,667
一個數字17，請。

914
00:41:59,667 --> 00:42:01,000
讓我回去遠了一點。

915
00:42:01,000 --> 00:42:03,980
22號，請和
怎麼樣靠後

916
00:42:03,980 --> 00:42:06,344
如果我能看到任何的手
與所有的光或沒有。

917
00:42:06,344 --> 00:42:08,010
有人正在被自願在那裡。

918
00:42:08,010 --> 00:42:08,968
難道你要來了？

919
00:42:08,968 --> 00:42:10,450
你的前臂用力往上走。

920
00:42:10,450 --> 00:42:12,340
OK，17。

921
00:42:12,340 --> 00:42:13,690
22。

922
00:42:13,690 --> 00:42:15,120
26下來。

923
00:42:15,120 --> 00:42:18,450
誰都想
forcefully--上來吧。

924
00:42:18,450 --> 00:42:21,030
一個實際的志願者。

925
00:42:21,030 --> 00:42:23,330
>> 所以很快，如果
你們可以安排

926
00:42:23,330 --> 00:42:26,550
自己只是喜歡
屏幕上的節點。

927
00:42:26,550 --> 00:42:27,510
謝謝。

928
00:42:27,510 --> 00:42:29,234
你會是26。

929
00:42:29,234 --> 00:42:30,650
好吧，快速推出。

930
00:42:30,650 --> 00:42:32,139
所以，我是大衛，你也是？

931
00:42:32,139 --> 00:42:32,680
大衛：大衛。

932
00:42:32,680 --> 00:42:33,721
DAVID馬蘭：你是誰？

933
00:42:33,721 --> 00:42:34,229
傑克：傑克。

934
00:42:34,229 --> 00:42:34,729
蘇：蘇。

935
00:42:34,729 --> 00:42:35,229
亞歷克斯：亞歷克斯。

936
00:42:35,229 --> 00:42:36,475
拉斐爾：拉斐爾。

937
00:42:36,475 --> 00:42:37,100
泰勒：泰勒。

938
00:42:37,100 --> 00:42:37,466
DAVID馬蘭：泰勒。

939
00:42:37,466 --> 00:42:37,590
優秀的。

940
00:42:37,590 --> 00:42:39,810
所以，這些都是我們的志願者
今天和前進

941
00:42:39,810 --> 00:42:43,090
和轉移一點的方式，
而只是繼續前進，保持

942
00:42:43,090 --> 00:42:47,024
牽著你的號碼，你的或你的
第一個跡象，用你的左手，

943
00:42:47,024 --> 00:42:48,940
繼續前進，只是實施
這些箭頭，只是

944
00:42:48,940 --> 00:42:51,360
讓你的左手是名副其實
指著無論你應該點

945
00:42:51,360 --> 00:42:54,610
在，給自己一些空間，以便
我們可以直觀地看到你的手臂居然

946
00:42:54,610 --> 00:42:58,120
指點，你可以只點
那種在地面罰款。

947
00:42:58,120 --> 00:43:03,040
>> 所以在這裡我們有一個鍊錶，
兩個，三個，四個，五個節點最初

948
00:43:03,040 --> 00:43:05,860
並請注意，我們有這個特殊的
指針一開始誰的

949
00:43:05,860 --> 00:43:09,770
關鍵，因為我們必須跟踪
全長列表莫名其妙。

950
00:43:09,770 --> 00:43:13,590
這些傢伙，即使他們離開
以對，背靠背在內存中，

951
00:43:13,590 --> 00:43:15,950
他們實際上可以在任何地方
在計算機的存儲器中。

952
00:43:15,950 --> 00:43:18,240
因此，這些人可能是
在舞台上的任何地方靜置

953
00:43:18,240 --> 00:43:20,960
這很好，只要他們
實際上指著對方，

954
00:43:20,960 --> 00:43:22,770
但為了方便，
乾淨簡潔，我們將

955
00:43:22,770 --> 00:43:25,728
只是吸引他們從左到右像
這一點，但可能有大量的空白

956
00:43:25,728 --> 00:43:26,790
在這些節點之間。

957
00:43:26,790 --> 00:43:30,710
>> 現在，如果我想實際插入一些
新的價值，讓我們繼續前進，做到這一點。

958
00:43:30,710 --> 00:43:33,720
我們有機會現
選擇另一個節點。

959
00:43:33,720 --> 00:43:39,820
說讓我們與mallocing 55開始。

960
00:43:39,820 --> 00:43:41,320
會有人介意的malloc？

961
00:43:41,320 --> 00:43:42,280
好了，上來吧。

962
00:43:42,280 --> 00:43:42,992
你叫什麼名字？

963
00:43:42,992 --> 00:43:43,700
彩虹：彩虹。

964
00:43:43,700 --> 00:43:44,050
DAVID馬蘭：彩虹？

965
00:43:44,050 --> 00:43:44,810
好的。

966
00:43:44,810 --> 00:43:46,600
malloc的彩虹。

967
00:43:46,600 --> 00:43:47,450
上來吧。

968
00:43:47,450 --> 00:43:51,610
所以，現在我們要問自己，
算法，我們可以把55。

969
00:43:51,610 --> 00:43:53,610
所以，我們都知道，
顯然，她很可能

970
00:43:53,610 --> 00:43:55,401
所屬如果我們嘗試
保持這個排序

971
00:43:55,401 --> 00:43:58,299
如果你們能帶一個
退一步所以我們不脫落

972
00:43:58,299 --> 00:43:59,590
舞台上，那將是巨大的。

973
00:43:59,590 --> 00:44:01,420
所以實際上，彩虹，
從這裡開始了我，

974
00:44:01,420 --> 00:44:04,200
因為我們的電腦現在可以
只看到一個變量的時間。

975
00:44:04,200 --> 00:44:05,190
因此，如果這是第一個節點。

976
00:44:05,190 --> 00:44:07,160
請注意，他不是一個節點，
他只是一個指針，

977
00:44:07,160 --> 00:44:10,270
這就是為什麼他的畫是
指針只大小，不

978
00:44:10,270 --> 00:44:11,780
其中的一個完整的矩形。

979
00:44:11,780 --> 00:44:16,650
因此，我們要檢查每個
迭代比9 55少？

980
00:44:16,650 --> 00:44:17,150
第

981
00:44:17,150 --> 00:44:19,060
比17 55少了呢？

982
00:44:19,060 --> 00:44:19,720
第

983
00:44:19,720 --> 00:44:20,800
比22少？

984
00:44:20,800 --> 00:44:22,020
比26少？

985
00:44:22,020 --> 00:44:23,390
比34少？

986
00:44:23,390 --> 00:44:25,890
所以現在，很明顯
彩虹所屬的結尾。

987
00:44:25,890 --> 00:44:27,270
所以要明確，什麼
是你的名字，泰勒？

988
00:44:27,270 --> 00:44:27,895
>> 泰勒：泰勒。

989
00:44:27,895 --> 00:44:32,510
DAVID馬蘭：所以之中泰勒
左手和彩虹的手在這裡，

990
00:44:32,510 --> 00:44:38,324
誰的手需要在什麼指向
為了將55進這個名單？

991
00:44:38,324 --> 00:44:39,240
什麼是我們需要做什麼？

992
00:44:39,240 --> 00:44:39,700
是嗎？

993
00:44:39,700 --> 00:44:41,140
>> 聽眾：泰勒的手
需要指向左邊。

994
00:44:41,140 --> 00:44:41,680
>> DAVID馬蘭：沒錯。

995
00:44:41,680 --> 00:44:43,800
所以插入一個節點
成列表的末尾

996
00:44:43,800 --> 00:44:47,140
很簡單，因為泰勒剛
必須指向，而不是在地面

997
00:44:47,140 --> 00:44:49,640
或者我們叫它空，
null是那種沒有

998
00:44:49,640 --> 00:44:51,640
指針或特
零指針，你

999
00:44:51,640 --> 00:44:53,740
要指向用你的左手
手彩虹，然後彩虹，

1000
00:44:53,740 --> 00:44:55,910
其中，如果你的左
一方面可能是點？

1001
00:44:55,910 --> 00:44:56,570
向下。

1002
00:44:56,570 --> 00:45:00,140
這並不好，如果她的手是排序
在這裡或排序的任何指點過的

1003
00:45:00,140 --> 00:45:00,640
哪種方式。

1004
00:45:00,640 --> 00:45:02,407
這將被視為
垃圾值，

1005
00:45:02,407 --> 00:45:04,240
但如果她指向
一些已知的價值，我們將

1006
00:45:04,240 --> 00:45:07,360
稱之為零或零，這是確定
因為我們在這一個術語

1007
00:45:07,360 --> 00:45:09,390
我們知道名單現在就完成了。

1008
00:45:09,390 --> 00:45:11,550
>> 那麼，什麼是另一種
比較簡單的情況下？

1009
00:45:11,550 --> 00:45:13,125
難道我們的malloc 5？

1010
00:45:13,125 --> 00:45:14,010
上來吧。

1011
00:45:14,010 --> 00:45:14,782
你叫什麼名字？

1012
00:45:14,782 --> 00:45:15,490
蒂芬妮：蒂芙尼。

1013
00:45:15,490 --> 00:45:16,000
DAVID馬蘭：對不起？

1014
00:45:16,000 --> 00:45:16,470
蒂芬妮：蒂芙尼。

1015
00:45:16,470 --> 00:45:16,880
DAVID馬蘭：蒂芙尼。

1016
00:45:16,880 --> 00:45:17,110
好的。

1017
00:45:17,110 --> 00:45:19,071
蒂芙尼一直malloced
用值5。

1018
00:45:19,071 --> 00:45:19,570
上來吧。

1019
00:45:19,570 --> 00:45:23,820
這一次是比較容易過，但
讓我們考慮為了操作了。

1020
00:45:23,820 --> 00:45:25,820
這是很容易
與泰勒在末端。

1021
00:45:25,820 --> 00:45:30,302
號碼5是當然小於9，
所以，我們有大衛，我們有蒂芙尼，

1022
00:45:30,302 --> 00:45:31,260
什麼是你的名字嗎？

1023
00:45:31,260 --> 00:45:31,680
>> 傑克：傑克。

1024
00:45:31,680 --> 00:45:32,470
>> DAVID馬蘭：傑克。

1025
00:45:32,470 --> 00:45:34,300
蒂芙尼，傑克和大衛。

1026
00:45:34,300 --> 00:45:36,580
誰的手，應該首先更新？

1027
00:45:36,580 --> 00:45:39,260

1028
00:45:39,260 --> 00:45:40,590
你想在這裡做？

1029
00:45:40,590 --> 00:45:45,244
有一對夫婦可能的方式，但
另外還有一個或多個錯誤的方法。

1030
00:45:45,244 --> 00:45:46,620
>> 聽眾：先從最左邊。

1031
00:45:46,620 --> 00:45:47,800
>> DAVID馬蘭：先從最左邊。

1032
00:45:47,800 --> 00:45:49,008
誰是最左邊的位置呢？

1033
00:45:49,008 --> 00:45:49,700
聽眾：第一。

1034
00:45:49,700 --> 00:45:50,366
>> DAVID馬蘭：OK。

1035
00:45:50,366 --> 00:45:53,781
因此，開始與第一，你在哪裡
要更新大衛的手中呢？

1036
00:45:53,781 --> 00:45:54,780
聽眾：邁向5。

1037
00:45:54,780 --> 00:45:55,446
DAVID馬蘭：OK。

1038
00:45:55,446 --> 00:45:59,026
於是，大衛點五
或蒂芙尼在這裡，現在呢？

1039
00:45:59,026 --> 00:46:01,072
>> 聽眾：蒂芙尼指向9？

1040
00:46:01,072 --> 00:46:04,030
DAVID馬蘭：完美的，除了賓基的
正中下懷頭掉了下來，對不對？

1041
00:46:04,030 --> 00:46:06,820
因為這有什麼錯
這幅畫從字面上？

1042
00:46:06,820 --> 00:46:08,070
聽眾：沒有指向。

1043
00:46:08,070 --> 00:46:09,945
DAVID馬蘭：沒有什麼是
指著傑克了。

1044
00:46:09,945 --> 00:46:13,360
我們已經從字面上孤立9
17，我們已經從字面上

1045
00:46:13,360 --> 00:46:18,450
洩漏的這一切的記憶，因為
首先更新大衛的手，這是

1046
00:46:18,450 --> 00:46:21,660
精細因為它是正確的
現在在蒂凡尼指出，

1047
00:46:21,660 --> 00:46:25,410
但如果沒有人有
深謀遠慮地指向傑克，

1048
00:46:25,410 --> 00:46:27,490
那麼，我們已經失去了
全部的列表。

1049
00:46:27,490 --> 00:46:28,200
因此，讓我們撤消。

1050
00:46:28,200 --> 00:46:30,950
所以這是一件好事，
絆倒，但現在，讓我們糾正。

1051
00:46:30,950 --> 00:46:33,624
我們應該怎麼做第一呢？

1052
00:46:33,624 --> 00:46:34,124
是嗎？

1053
00:46:34,124 --> 00:46:35,791
>> 聽眾：蒂芙尼應指向在9？

1054
00:46:35,791 --> 00:46:37,582
DAVID馬蘭：我不能
得到這個機會給你。

1055
00:46:37,582 --> 00:46:38,720
誰應該指向的9？

1056
00:46:38,720 --> 00:46:39,220
>> 聽眾：蒂芙尼。

1057
00:46:39,220 --> 00:46:39,390
>> DAVID馬蘭：好的。

1058
00:46:39,390 --> 00:46:41,200
因此蒂芙尼應在9第一點。

1059
00:46:41,200 --> 00:46:43,550
因此，蒂芙尼應
在一個相同的值

1060
00:46:43,550 --> 00:46:45,820
大衛，這似乎
多餘的了片刻，

1061
00:46:45,820 --> 00:46:48,820
但是這很好，因為現在，第二
步驟中，我們可以更新大衛的手

1062
00:46:48,820 --> 00:46:52,680
為指向凡尼，然後如果
只是一種清潔我們的東西了

1063
00:46:52,680 --> 00:46:55,740
好像這是一種春天般的，
現在這是一個正確的插入。

1064
00:46:55,740 --> 00:46:56,700
所以，優秀的。

1065
00:46:56,700 --> 00:46:57,970
所以，現在我們快到了。

1066
00:46:57,970 --> 00:47:01,075
讓我們插入一個決賽
值就像值20。

1067
00:47:01,075 --> 00:47:03,010
如果我們能malloc的最後一個志願？

1068
00:47:03,010 --> 00:47:04,140
上來吧。

1069
00:47:04,140 --> 00:47:06,224
所以這一塊是一個有點棘手。

1070
00:47:06,224 --> 00:47:08,390
但實際上，該代碼我們
寫作，儘管口頭上，

1071
00:47:08,390 --> 00:47:10,610
就像有一群
如果現在的條件下，對不對？

1072
00:47:10,610 --> 00:47:12,318
我們有一個條件
若屬於檢查

1073
00:47:12,318 --> 00:47:13,840
在最後，也許是開始。

1074
00:47:13,840 --> 00:47:15,940
我們需要某種形式循環到
發現在中間的地方。

1075
00:47:15,940 --> 00:47:17,400
因此，讓我們做到這一點與你叫什麼名字？

1076
00:47:17,400 --> 00:47:17,700
>> 艾瑞克：埃里克。

1077
00:47:17,700 --> 00:47:18,340
>> DAVID馬蘭：埃里克？

1078
00:47:18,340 --> 00:47:18,660
埃里克。

1079
00:47:18,660 --> 00:47:19,368
認識你很高興。

1080
00:47:19,368 --> 00:47:20,490
因此，我們有20個。

1081
00:47:20,490 --> 00:47:21,220
超過五少？

1082
00:47:21,220 --> 00:47:21,530
第

1083
00:47:21,530 --> 00:47:22,160
超過九少？

1084
00:47:22,160 --> 00:47:22,410
第

1085
00:47:22,410 --> 00:47:23,050
比17少？

1086
00:47:23,050 --> 00:47:23,550
第

1087
00:47:23,550 --> 00:47:23,740
確定。

1088
00:47:23,740 --> 00:47:25,701
他屬於這裡
你的名字又是什麼？

1089
00:47:25,701 --> 00:47:26,200
蘇：蘇。

1090
00:47:26,200 --> 00:47:26,880
DAVID馬蘭：蘇。

1091
00:47:26,880 --> 00:47:27,379
亞歷克斯：亞歷克斯。

1092
00:47:27,379 --> 00:47:28,790
DAVID馬蘭：蘇，亞歷克斯和？

1093
00:47:28,790 --> 00:47:29,290
艾瑞克：埃里克。

1094
00:47:29,290 --> 00:47:30,120
DAVID馬蘭：埃里克。

1095
00:47:30,120 --> 00:47:32,140
誰的手先獲取更新？

1096
00:47:32,140 --> 00:47:32,930
>> 聽眾：埃里克。

1097
00:47:32,930 --> 00:47:33,429
確定。

1098
00:47:33,429 --> 00:47:35,200
因此，Eric的應指向哪裡？

1099
00:47:35,200 --> 00:47:35,930
在22。

1100
00:47:35,930 --> 00:47:36,430
好。

1101
00:47:36,430 --> 00:47:38,180
現在，下一步是什麼？

1102
00:47:38,180 --> 00:47:40,800
然後蘇可指向埃里克
而現在，如果你們只是

1103
00:47:40,800 --> 00:47:44,077
使一些空間，這是罰款
在視覺上，現在我們所做的插入。

1104
00:47:44,077 --> 00:47:47,160
現在讓我們考慮一個問題，但
非常感謝你對我們的志願者。

1105
00:47:47,160 --> 00:47:48,090
非常出色地完成。

1106
00:47:48,090 --> 00:47:50,831
您可以保留這些，如果你喜歡。

1107
00:47:50,831 --> 00:47:54,140
我們有一個可愛的臨別禮物，如果
你每次想藉此壓力球。

1108
00:47:54,140 --> 00:47:56,030
讓我傳遞下來。

1109
00:47:56,030 --> 00:47:58,430
那麼，什麼是這個外賣？

1110
00:47:58,430 --> 00:48:02,430
這似乎是驚人的
只要我們現在有

1111
00:48:02,430 --> 00:48:06,360
引入了一個替代的
陣列事實並非如此局限

1112
00:48:06,360 --> 00:48:07,780
到一些固定尺寸的陣列。

1113
00:48:07,780 --> 00:48:09,380
他們可以動態地增長。

1114
00:48:09,380 --> 00:48:13,220
>> 但是，就像我們已經看到在週
過去，我們從來沒有得到任何東西是免費的，

1115
00:48:13,220 --> 00:48:15,740
喜歡肯定有一個權衡在這裡。

1116
00:48:15,740 --> 00:48:18,890
因此，與一個鏈接的上漲空間
列表，是這種活力？

1117
00:48:18,890 --> 00:48:21,590
這種能力成長，坦率地說，
我們可以做刪除

1118
00:48:21,590 --> 00:48:23,570
並根據需要，我們有可能縮小。

1119
00:48:23,570 --> 00:48:24,710
是我們付出什麼樣的代價？

1120
00:48:24,710 --> 00:48:28,510

1121
00:48:28,510 --> 00:48:30,340
兩倍的空間，首先。

1122
00:48:30,340 --> 00:48:34,010
如果你看一下圖片，不再
我是存儲整數列表。

1123
00:48:34,010 --> 00:48:36,740
我存儲的列表
整數加指針。

1124
00:48:36,740 --> 00:48:38,240
所以我加倍的空間量。

1125
00:48:38,240 --> 00:48:40,740
現在，也許這不是這樣的
什麼大不了的4個字節，8個字節，

1126
00:48:40,740 --> 00:48:43,160
但它當然可以加
彌補大型數據集。

1127
00:48:43,160 --> 00:48:45,570
什麼是另一個缺點？

1128
00:48:45,570 --> 00:48:46,070
是嗎？

1129
00:48:46,070 --> 00:48:48,010
>> 聽眾：我們要
遍歷它們一個接酮。

1130
00:48:48,010 --> 00:48:48,760
DAVID馬蘭：是的。

1131
00:48:48,760 --> 00:48:50,260
我們必須遍歷它們一個接一個。

1132
00:48:50,260 --> 00:48:53,860
你知道嗎，我們放棄了這個超級
括號的方便的功能，

1133
00:48:53,860 --> 00:48:57,240
符號，更恰當
稱為隨機存取，

1134
00:48:57,240 --> 00:48:59,280
在這裡我們可以自己跳
到單個元素

1135
00:48:59,280 --> 00:49:01,470
但現在，如果我仍然有
我的志願者在這裡，

1136
00:49:01,470 --> 00:49:04,660
如果我想找到
22號，我不能只

1137
00:49:04,660 --> 00:49:06,620
跳轉到支架上一些東西。

1138
00:49:06,620 --> 00:49:10,530
我要看看在列表中，多
像我們的搜索例子線，

1139
00:49:10,530 --> 00:49:12,260
找到數22。

1140
00:49:12,260 --> 00:49:14,340
因此，我們似乎已經付出了代價那裡。

1141
00:49:14,340 --> 00:49:16,430
但是，我們還是能夠
解決其他問題。

1142
00:49:16,430 --> 00:49:18,587
>> 其實，我來介紹一下
只是一對夫婦的視覺效果。

1143
00:49:18,587 --> 00:49:20,920
所以，如果你已經下降到
馬瑟飯堂最近，

1144
00:49:20,920 --> 00:49:23,320
你還記得自己
棧這樣的托盤，

1145
00:49:23,320 --> 00:49:26,300
我們從借來的這些
課前安嫩伯格。

1146
00:49:26,300 --> 00:49:28,930
所以這個棧托盤，不過，
代表實際

1147
00:49:28,930 --> 00:49:30,860
一個計算機科學的數據結構。

1148
00:49:30,860 --> 00:49:32,910
有一個數據結構
在計算機科學

1149
00:49:32,910 --> 00:49:38,010
被稱為棧非常漂亮
適合於正是這種視覺。

1150
00:49:38,010 --> 00:49:41,380
因此，如果每一個托盤的是不是一個
托盤但像一些，我想

1151
00:49:41,380 --> 00:49:45,010
存儲的數字，我
可以放一到這裡，

1152
00:49:45,010 --> 00:49:48,320
我可以把另一個倒在這裡，
並不斷堆積號碼

1153
00:49:48,320 --> 00:49:53,180
對彼此，什麼是頂部
這個可能有幫助

1154
00:49:53,180 --> 00:49:55,450
是什麼含義
這種數據結構？

1155
00:49:55,450 --> 00:49:58,045
哪個號碼，我可以拉出來
第一個最方便？

1156
00:49:58,045 --> 00:50:00,640

1157
00:50:00,640 --> 00:50:03,030
最近期看跌的存在。

1158
00:50:03,030 --> 00:50:06,430
>> 所以，這就是我們所說的
計算機科學後進先出的數據結構。

1159
00:50:06,430 --> 00:50:08,070
後進先出。

1160
00:50:08,070 --> 00:50:10,800
我們將不久為什麼看
現在可能是有用的，但對於，

1161
00:50:10,800 --> 00:50:12,200
只是考慮物業。

1162
00:50:12,200 --> 00:50:15,158
而且它是一種愚蠢的，如果你想
有關如何食堂做的。

1163
00:50:15,158 --> 00:50:17,910
他們每次清潔托盤
把最新鮮的人之上，

1164
00:50:17,910 --> 00:50:22,160
你可以有一個以前乾淨
但最終很髒亂，塵土飛揚

1165
00:50:22,160 --> 00:50:24,360
托盤在最底層
如果你從來沒有真正

1166
00:50:24,360 --> 00:50:26,820
得到的，該底部
堆棧，因為你

1167
00:50:26,820 --> 00:50:29,380
不斷把新的，
乾淨的人在它的上面。

1168
00:50:29,380 --> 00:50:31,840
同樣的事情可能會發生
在一家超市了。

1169
00:50:31,840 --> 00:50:35,450
如果你有一個陳列櫃
牛奶每次CVS

1170
00:50:35,450 --> 00:50:37,610
或者誰得到更多的牛奶，
你剛才推的牛奶

1171
00:50:37,610 --> 00:50:39,880
你已經擁有的背部和
你把新的鋒線，

1172
00:50:39,880 --> 00:50:43,088
你將有一些非常討厭
牛奶在數據結構的末尾，

1173
00:50:43,088 --> 00:50:46,390
因為它總是在底部或
等效它總是在後面。

1174
00:50:46,390 --> 00:50:50,407
>> 但還有另一種方式來思考
排隊的數據和例如，此。

1175
00:50:50,407 --> 00:50:53,490
如果你是其中的一個人誰喜歡
排隊的蘋果專賣店外

1176
00:50:53,490 --> 00:50:55,610
當一個新的產品來
出來，你可能

1177
00:50:55,610 --> 00:50:58,780
不使用堆棧數據
結構，因為你

1178
00:50:58,780 --> 00:51:03,070
會疏遠其他人誰是
排隊購買一些新的玩具。

1179
00:51:03,070 --> 00:51:06,610
相反，你可能使用
什麼樣的數據結構的

1180
00:51:06,610 --> 00:51:10,050
或者是什麼樣的制度
在現實世界？

1181
00:51:10,050 --> 00:51:13,493
希望這是一條線，或更多
正確或更多的英國狀，一個隊列。

1182
00:51:13,493 --> 00:51:17,700
而事實證明隊列也是
數據結構，計算機科學，

1183
00:51:17,700 --> 00:51:19,700
但一個隊列具有一個非常
不同的屬性。

1184
00:51:19,700 --> 00:51:20,820
這不是後進先出法。

1185
00:51:20,820 --> 00:51:21,990
後進先出。

1186
00:51:21,990 --> 00:51:22,800
上帝保佑。

1187
00:51:22,800 --> 00:51:24,280
這是不是FIFO。

1188
00:51:24,280 --> 00:51:26,110
先入先出。

1189
00:51:26,110 --> 00:51:27,970
這是一件好事
為公平起見

1190
00:51:27,970 --> 00:51:30,428
當然，當你排隊
早上起來的超級早。

1191
00:51:30,428 --> 00:51:33,400
如果你第一次那裡，你
想要得到第一個為好。

1192
00:51:33,400 --> 00:51:35,880
>> 所以，所有的這些數據，
結構，隊列，棧

1193
00:51:35,880 --> 00:51:39,220
和其他人一束束，原來你
可以認為這是只是一個數組。

1194
00:51:39,220 --> 00:51:41,820
這是一個數組，也許
一個固定大小為4，但它會

1195
00:51:41,820 --> 00:51:44,990
是種不錯的，如果我們可以只堆
托盤幾乎可以無限高的，如果我們

1196
00:51:44,990 --> 00:51:46,780
有那麼多的托盤或數字。

1197
00:51:46,780 --> 00:51:48,840
因此，也許我們要
使用鍊錶這裡，

1198
00:51:48,840 --> 00:51:51,800
但權衡將是
可能我們需要更多的內存，

1199
00:51:51,800 --> 00:51:55,930
需要多一點的時間，但我們
不限制疊層的高度，

1200
00:51:55,930 --> 00:51:59,550
就像奧美的陳列櫃
可能限制堆棧的大小，

1201
00:51:59,550 --> 00:52:03,117
等等這些都是設計決策或
可供我們選擇大勢所趨。

1202
00:52:03,117 --> 00:52:04,950
因此，這些數據
結構，我們已經開始

1203
00:52:04,950 --> 00:52:09,360
看到新的上限可能
什麼以前是超級快

1204
00:52:09,360 --> 00:52:11,260
當我們將離開
今天關在哪裡

1205
00:52:11,260 --> 00:52:13,200
我們希望能得到
上週三，我們將

1206
00:52:13,200 --> 00:52:15,740
開始看數據
結構讓我們搜索

1207
00:52:15,740 --> 00:52:18,260
通過日誌結束時間的數據了。

1208
00:52:18,260 --> 00:52:21,470
並且我們看到了，記得，在零一周
和一個用二進制搜索或除法

1209
00:52:21,470 --> 00:52:22,180
和征服。

1210
00:52:22,180 --> 00:52:26,240
這是回來了，更好的是，
聖杯這個星期三

1211
00:52:26,240 --> 00:52:29,510
將要拿出
運行真正的數據結構

1212
00:52:29,510 --> 00:52:32,070
或者理論上
恆定時間，由此

1213
00:52:32,070 --> 00:52:34,760
不要緊多少
千萬甚至上億的東西

1214
00:52:34,760 --> 00:52:38,470
我們已經在該數據結構中，它會
需要我們持續的時間，也許一步

1215
00:52:38,470 --> 00:52:41,387
兩個步驟或10個步驟，
但步驟常數

1216
00:52:41,387 --> 00:52:42,970
通過該數據結構進行搜索。

1217
00:52:42,970 --> 00:52:46,300
這的確將是制勝法寶
但更多的是在週三。

1218
00:52:46,300 --> 00:52:49,045
見雅則。

1219
00:52:49,045 --> 00:52:53,704
>> [音樂播放]

1220
00:52:53,704 --> 00:56:08,448