1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:11,261
[音樂播放]

3
00:00:11,261 --> 00:00:12,640
>> 戴維·J·馬蘭：好吧。

4
00:00:12,640 --> 00:00:14,525
這是CS50。

5
00:00:14,525 --> 00:00:16,009
這是5週的開始。

6
00:00:16,009 --> 00:00:18,050
正如你可能已經注意到，
一些材料

7
00:00:18,050 --> 00:00:21,050
越來越多一點
複雜，小更密。

8
00:00:21,050 --> 00:00:24,560
>> 而且它是很容易的，尤其是當
你已經在習慣了一段時間，

9
00:00:24,560 --> 00:00:28,600
是為了要塗下最
什麼我們做什麼，我們說在課堂上。

10
00:00:28,600 --> 00:00:31,626
但要意識到，這也許不是
理想的教學方法

11
00:00:31,626 --> 00:00:34,250
學習這種物質，
而材料更普遍。

12
00:00:34,250 --> 00:00:37,250
因此，我們很高興
宣布，CS50自己Gheng

13
00:00:37,250 --> 00:00:39,780
龔已開始準備
一個規範的集合票據

14
00:00:39,780 --> 00:00:42,100
用於操作過程中，希望
其是，一個，這些

15
00:00:42,100 --> 00:00:44,030
不僅作為
參考和資源

16
00:00:44,030 --> 00:00:47,410
審查材料中去
回通過材料可能具有的

17
00:00:47,410 --> 00:00:51,230
逃脫你在第一時間左右，但
也讓你的頭可以更

18
00:00:51,230 --> 00:00:53,740
向上比下降，當它
談到時間來講課，

19
00:00:53,740 --> 00:00:56,960
所以，你可能搞
更周到，為

20
00:00:56,960 --> 00:00:59,170
相對於更雜亂。

21
00:00:59,170 --> 00:01:02,510
>> 雖這麼說，你會發現
該網站是這樣的文件，因為這。

22
00:01:02,510 --> 00:01:04,660
並請注意，在左上角，有
不僅表的內容，

23
00:01:04,660 --> 00:01:06,920
而且時間碼的
會立即跳到你

24
00:01:06,920 --> 00:01:09,077
到相應的部分
在視頻網上。

25
00:01:09,077 --> 00:01:11,410
什麼常在這裡做了
在本質上，記載

26
00:01:11,410 --> 00:01:13,340
發生了什麼事在這
特別講座。

27
00:01:13,340 --> 00:01:16,370
和許多的講座是
已經在線使用這個網址。

28
00:01:16,370 --> 00:01:20,110
我們將繼續張貼其餘
那些在本週末結束，

29
00:01:20,110 --> 00:01:22,380
所以不要採取資源優勢。

30
00:01:22,380 --> 00:01:25,740
>> 因此，事不宜遲，
我們開始剝離回

31
00:01:25,740 --> 00:01:28,180
已經作為層
串持續一段時間。

32
00:01:28,180 --> 00:01:30,670
並沒有說什麼一個字符串
上週居然是？

33
00:01:30,670 --> 00:01:31,720

34
00:01:31,720 --> 00:01:32,900
因此，焦炭的明星。

35
00:01:32,900 --> 00:01:34,900
和CHAR星，那麼，
這樣做究竟意味著什麼？

36
00:01:34,900 --> 00:01:37,150
那麼，這一切的時候，如果我們已經
被調用的函數，

37
00:01:37,150 --> 00:01:40,450
喜歡的getString和存儲
所謂返回

38
00:01:40,450 --> 00:01:42,910
的getString的價值
變量 - 這就是所謂的

39
00:01:42,910 --> 00:01:47,721
S型string--我們已經寫
這行代碼在那裡上面。

40
00:01:47,721 --> 00:01:49,970
而且它是只有當我看到我的
在這裡手寫放大

41
00:01:49,970 --> 00:01:51,930
我意識到多麼惡劣，這是。

42
00:01:51,930 --> 00:01:54,180
>> 但是，讓我們假設，
在右手側

43
00:01:54,180 --> 00:01:57,070
是，但是，合理的
一個什麼樣的描述

44
00:01:57,070 --> 00:01:58,880
一直在進行這一切
時間的getString。

45
00:01:58,880 --> 00:02:00,380
的getString，當然，得到​​的字符串。

46
00:02:00,380 --> 00:02:01,691
但是，這究竟意味著什麼？

47
00:02:01,691 --> 00:02:04,190
這意味著它得到了一大塊
來自操作系統的內存

48
00:02:04,190 --> 00:02:06,040
通過調用一個函數，稱為malloc的。

49
00:02:06,040 --> 00:02:07,390
但後​​來更多。

50
00:02:07,390 --> 00:02:09,139
然後填充
該內存塊

51
00:02:09,139 --> 00:02:11,764
以字母的用戶具有
當然鍵入，緊接著，，

52
00:02:11,764 --> 00:02:14,800
一個空字符或反斜杠
零在最後。

53
00:02:14,800 --> 00:02:18,280
>> 同時，在左手側
這個故事，這一切的時候，

54
00:02:18,280 --> 00:02:20,850
我們已經聲明了一個變量，如第

55
00:02:20,850 --> 00:02:24,770
而這個變量就是現在
將開始調用的指針。

56
00:02:24,770 --> 00:02:29,190
這不是這裡面一箱
我們把串，Daven，本身

57
00:02:29,190 --> 00:02:32,550
而是我們把在這方
箱體左側究竟是什麼？

58
00:02:32,550 --> 00:02:34,890

59
00:02:34,890 --> 00:02:35,390
是嗎？

60
00:02:35,390 --> 00:02:37,118
>> 聽眾：的地址
它位於內存中。

61
00:02:37,118 --> 00:02:38,118
>> 戴維·J·馬蘭：沒錯。

62
00:02:38,118 --> 00:02:40,690
Daven的所在地址
位於存儲器。

63
00:02:40,690 --> 00:02:44,650
不，所有Daven的所在，
本身，而是專門的地址

64
00:02:44,650 --> 00:02:45,150
什麼？

65
00:02:45,150 --> 00:02:46,311

66
00:02:46,311 --> 00:02:46,810
是嗎？

67
00:02:46,810 --> 00:02:47,460
>> 聽眾：第一個字符。

68
00:02:47,460 --> 00:02:50,209
>> 戴維·J·馬蘭：第一個字符
在Daven，其中，在這種情況下，

69
00:02:50,209 --> 00:02:53,820
我提出了任意
和不切實際1，OX1，

70
00:02:53,820 --> 00:02:55,910
它的意思是，
1的十六進制數。

71
00:02:55,910 --> 00:02:57,993
但是，它可能會
是一個更大的數字

72
00:02:57,993 --> 00:03:01,260
我們可能會得出
以0X作為前綴，

73
00:03:01,260 --> 00:03:02,806
代表一個十六進制字符。

74
00:03:02,806 --> 00:03:05,930
而且，由於我們並不需要知道在哪裡
Daven的字符的其餘部分

75
00:03:05,930 --> 00:03:09,860
是因為，有什麼簡單的設計
決定這是多年前？

76
00:03:09,860 --> 00:03:10,548
是嗎？

77
00:03:10,548 --> 00:03:11,651
>> 聽眾：反斜杠0。

78
00:03:11,651 --> 00:03:12,900
戴維·J·馬蘭：是的，沒錯。

79
00:03:12,900 --> 00:03:18,100
反斜線0可以讓你，儘管在
線性時間，來遍歷字符串

80
00:03:18,100 --> 00:03:20,400
由左到右行走，
用for循環，或同時

81
00:03:20,400 --> 00:03:22,608
環或類似的東西
這一點，決定了哦，這裡

82
00:03:22,608 --> 00:03:24,751
是這個特定字符串的結尾。

83
00:03:24,751 --> 00:03:27,000
所以只用在地址
字符串的開始，

84
00:03:27,000 --> 00:03:30,290
我們可以訪問的全部
它，因為這一切的同時，

85
00:03:30,290 --> 00:03:32,030
一個字符串，剛剛一個char明星。

86
00:03:32,030 --> 00:03:36,370
>> 因此，這的確精緻繼續使用
在CS50庫，而且這樣的抽象，

87
00:03:36,370 --> 00:03:38,440
可以這麼說，但我們會
首先，看看到底

88
00:03:38,440 --> 00:03:41,230
什麼是怎麼回事
下面這整個時間。

89
00:03:41,230 --> 00:03:45,260
所以，你可能還記得這個例子中，
同樣，從去年的時候，比較0，

90
00:03:45,260 --> 00:03:47,300
這實際上並沒有進行比較。

91
00:03:47,300 --> 00:03:49,070
但是，我們開始解決這個問題。

92
00:03:49,070 --> 00:03:52,020
>> 但是作為也許是複習，
我可能感興趣的人

93
00:03:52,020 --> 00:03:54,261
粉紅色的大象的今天，
還長呢？

94
00:03:54,261 --> 00:03:55,760
怎麼樣，你在前面？ [聽不清]。

95
00:03:55,760 --> 00:03:56,660
上來吧。

96
00:03:56,660 --> 00:03:58,740
>> 並且在此期間，
你上來，讓我們

97
00:03:58,740 --> 00:04:01,670
考慮了一會兒就好了什麼
這段代碼實際上做的事情。

98
00:04:01,670 --> 00:04:04,917
它聲明兩個變量了
頂，S和T，並調用的getString。

99
00:04:04,917 --> 00:04:08,250
這不是一個非常用戶友好的程序，
因為它不會告訴你的事。

100
00:04:08,250 --> 00:04:10,541
但是，讓我們姑且我們
重點是多汁的一部分。

101
00:04:10,541 --> 00:04:14,470
然後我們做的，如果s等於
等於T，應該說printf的，

102
00:04:14,470 --> 00:04:16,170
您鍵入同樣的事情。

103
00:04:16,170 --> 00:04:16,670
你好。

104
00:04:16,670 --> 00:04:17,050
你叫什麼名字？

105
00:04:17,050 --> 00:04:17,779
>> 詹妮爾：詹妮爾。

106
00:04:17,779 --> 00:04:19,529
戴維·J·馬蘭：詹妮爾，
很高興認識你。

107
00:04:19,529 --> 00:04:21,800
所以，你在挑戰
手這頭大象

108
00:04:21,800 --> 00:04:25,230
是第一個吸引我們的是什麼圖片
被代表的前兩個

109
00:04:25,230 --> 00:04:25,970
線。

110
00:04:25,970 --> 00:04:28,139
因此，S和T可能是
顯示在畫面上如何？

111
00:04:28,139 --> 00:04:30,680
而且你可以繪製與
將手指放在這個大屏幕上。

112
00:04:30,680 --> 00:04:31,780

113
00:04:31,780 --> 00:04:34,510
>> 因此，有兩部分，以
該方程的每一側。

114
00:04:34,510 --> 00:04:37,760
所以有S上的左側，並且
然後GetString的右邊。

115
00:04:37,760 --> 00:04:40,540
再有就是噸左邊，
然後GetString的右邊。

116
00:04:40,540 --> 00:04:42,630
那麼我們如何開始
繪製的畫面，

117
00:04:42,630 --> 00:04:46,340
表示這是怎麼回事
這裡的記憶，你會說什麼？

118
00:04:46,340 --> 00:04:49,150
讓我讓你解釋
你在做什麼，當您去。

119
00:04:49,150 --> 00:04:49,820
>> 詹妮爾：好的。

120
00:04:49,820 --> 00:04:58,890
嗯，首先，它會問
你得到輸入字符串。

121
00:04:58,890 --> 00:05:00,439
它會store--哦，對不起。

122
00:05:00,439 --> 00:05:01,230
戴維·J·馬蘭：確定。

123
00:05:01,230 --> 00:05:01,730
好。

124
00:05:01,730 --> 00:05:03,330
而這個叫什麼？

125
00:05:03,330 --> 00:05:03,950
哦，好吧。

126
00:05:03,950 --> 00:05:04,450
繼續前進。

127
00:05:04,450 --> 00:05:05,575
我不是故意要打斷。

128
00:05:05,575 --> 00:05:07,060
詹妮爾：對不起。

129
00:05:07,060 --> 00:05:14,237
因此，將其輸入到
地址of--不能確定。

130
00:05:14,237 --> 00:05:17,320
我不記得確切的數字，
但我相信這是從0開始。

131
00:05:17,320 --> 00:05:18,420
>> 戴維·J·馬蘭：沒關係，
因為我做的數字了，

132
00:05:18,420 --> 00:05:19,650
所以沒有正確的答案。

133
00:05:19,650 --> 00:05:22,105
>> 詹妮爾：用0起弧。

134
00:05:22,105 --> 00:05:24,000
>> 戴維·J·馬蘭：好了，元素0。

135
00:05:24,000 --> 00:05:24,765
當然。

136
00:05:24,765 --> 00:05:28,295
>> 詹妮爾：然後如果是
像剛才兩個letter--

137
00:05:28,295 --> 00:05:30,496
>> 戴維·J·馬蘭：好了，還給你。

138
00:05:30,496 --> 00:05:33,629
>> 詹妮爾：所以元素0，
然後元件1或元件2。

139
00:05:33,629 --> 00:05:36,670
戴維·J·馬蘭：而且這一塊
圖片是你畫的權利嗎？

140
00:05:36,670 --> 00:05:37,690
給GetString的調用？

141
00:05:37,690 --> 00:05:38,830
或s的聲明？

142
00:05:38,830 --> 00:05:42,890
>> 詹妮爾：報關
的S，我相信。

143
00:05:42,890 --> 00:05:45,980
哦，對的getString，因為它會
被輸入到每一個[？區。 ？]

144
00:05:45,980 --> 00:05:46,510
>> 戴維·J·馬蘭：好。

145
00:05:46,510 --> 00:05:47,051
沒錯。

146
00:05:47,051 --> 00:05:49,300
儘管這有效地
返回一個數組，調用，

147
00:05:49,300 --> 00:05:53,300
當我們回到一個字符串，我們可以
索引使用01和2的字符串。

148
00:05:53,300 --> 00:05:56,180
從技術上講，這很可能是
個別地址表示，

149
00:05:56,180 --> 00:05:57,100
但是這很好。

150
00:05:57,100 --> 00:06:00,170
>> 於是想，如果我可以快
轉發給我們留下了

151
00:06:00,170 --> 00:06:04,320
最後時刻，如果一個
字符串是克A B E，

152
00:06:04,320 --> 00:06:10,337
反斜杠0，從而表示Gabe的
輸入，怎麼可能，我們代表就談到？

153
00:06:10,337 --> 00:06:12,670
如果是這樣的存儲器那
被送回了的getString？

154
00:06:12,670 --> 00:06:14,415

155
00:06:14,415 --> 00:06:17,610
>> 詹妮爾：這將是
由電弧所表示？

156
00:06:17,610 --> 00:06:18,750
>> 戴維·J·馬蘭：通過電弧？

157
00:06:18,750 --> 00:06:19,130
哦，不。

158
00:06:19,130 --> 00:06:21,171
遠的不說，形象地，
讓我繼續前進

159
00:06:21,171 --> 00:06:25,710
和建議，如果這是秒，這
是的getString的返回值。

160
00:06:25,710 --> 00:06:29,482
而你畫這是0，1，2，其中
是完全合理的，因為我們

161
00:06:29,482 --> 00:06:30,940
可以索引到字符串，作為這樣。

162
00:06:30,940 --> 00:06:33,340
但剛需一致
最後一次，讓我先走

163
00:06:33,340 --> 00:06:37,310
並隨意提出這
是地址1，這是地址2，

164
00:06:37,310 --> 00:06:39,597
這是地址3，依此類推。

165
00:06:39,597 --> 00:06:41,430
因此，剛需超
顯然，這是怎麼回事

166
00:06:41,430 --> 00:06:44,580
s中去，作為一個結果，
代碼的第一行，你會說什麼？

167
00:06:44,580 --> 00:06:45,420
>> 詹妮爾：地址1？

168
00:06:45,420 --> 00:06:46,420
>> 戴維·J·馬蘭：沒錯。

169
00:06:46,420 --> 00:06:47,190
因此，解決為0x1。

170
00:06:47,190 --> 00:06:48,220

171
00:06:48,220 --> 00:06:51,230
而與此同時，讓我繼續前進，
重複的很多東西，你做

172
00:06:51,230 --> 00:06:52,740
在這裡添加自己噸。

173
00:06:52,740 --> 00:06:56,340
如果我要在加布型
再一次，第二次，

174
00:06:56,340 --> 00:07:01,530
當用的getString提示，其中，
當然，被加布要去？

175
00:07:01,530 --> 00:07:02,280
那麼，presumably--

176
00:07:02,280 --> 00:07:04,935

177
00:07:04,935 --> 00:07:05,975
>> 詹妮爾：像在這裡？

178
00:07:05,975 --> 00:07:06,850
戴維·J·馬蘭：是的。

179
00:07:06,850 --> 00:07:08,516
詹妮爾：或者它也是在同一個箱子？

180
00:07:08,516 --> 00:07:11,940
戴維·J·馬蘭：我建議，是啊，
準確，因此，在這些附加的盒子。

181
00:07:11,940 --> 00:07:15,230
但是，什麼是現在的關鍵是，即使
雖然我畫這些八九不離十

182
00:07:15,230 --> 00:07:18,650
together--為0x1，這
被0x2--在現實中，

183
00:07:18,650 --> 00:07:25,750
這個現在可能是地址為0x10，
例如，和為0x11，以及0x12的

184
00:07:25,750 --> 00:07:26,870
等等。

185
00:07:26,870 --> 00:07:29,955
因此，如果是這樣的話，
這是怎麼回事結束了在這裡噸？

186
00:07:29,955 --> 00:07:30,830
>> 詹妮爾：為0x10？

187
00:07:30,830 --> 00:07:31,830
戴維·J·馬蘭：沒錯。

188
00:07:31,830 --> 00:07:33,180
因此，為0x10。

189
00:07:33,180 --> 00:07:34,570
所以現在，最後一個問題。

190
00:07:34,570 --> 00:07:37,510
你有，到目前為止，已經工作了
最難的大象迄今。

191
00:07:37,510 --> 00:07:42,650
事到如今，如果我拉起碼
再次，當我這樣做，在三線，

192
00:07:42,650 --> 00:07:47,630
如果s等於等於T，我算什麼實際
相比較，我們在這裡畫？

193
00:07:47,630 --> 00:07:49,271
>> 詹妮爾：這兩個地址？

194
00:07:49,271 --> 00:07:50,270
戴維·J·馬蘭：沒錯。

195
00:07:50,270 --> 00:07:53,350
所以，我要說的是S等於等於t？

196
00:07:53,350 --> 00:07:56,210
換句話說，是1等於等於10？

197
00:07:56,210 --> 00:07:59,710
並且，當然，在
答案很明顯，現在是，沒有。

198
00:07:59,710 --> 00:08:02,920
所以這個方案最終是
要打印的內容，你會說什麼？

199
00:08:02,920 --> 00:08:05,770

200
00:08:05,770 --> 00:08:08,405
>> 詹妮爾：它會是這樣，
您鍵入同樣的事情？

201
00:08:08,405 --> 00:08:11,446
>> 戴維·J·馬蘭：所以，如果
s是1和t是10？

202
00:08:11,446 --> 00:08:13,320
>> 詹妮爾：輸入不同的事情。

203
00:08:13,320 --> 00:08:13,570
>> 戴維·J·馬蘭：沒錯。

204
00:08:13,570 --> 00:08:14,480
你輸入不同的事情。

205
00:08:14,480 --> 00:08:14,850
好吧。

206
00:08:14,850 --> 00:08:16,714
所以，掌聲雷動，
如果我們能在這裡。

207
00:08:16,714 --> 00:08:17,214
[掌聲]

208
00:08:17,214 --> 00:08:17,708
這是痛苦的。

209
00:08:17,708 --> 00:08:18,208
我知道。

210
00:08:18,208 --> 00:08:19,684
很好地完成。

211
00:08:19,684 --> 00:08:24,690
所以，現在讓我們來看看，如果我們不能
梳理出什麼樣的修復程序。

212
00:08:24,690 --> 00:08:28,040
當然，當我們固定this--
現在我將代表green--

213
00:08:28,040 --> 00:08:29,690
我們做了幾個增強功能在這裡。

214
00:08:29,690 --> 00:08:32,409
首先，正如一個理智
檢查一下，我先檢查

215
00:08:32,409 --> 00:08:35,110
如果s等於null和T等於null。

216
00:08:35,110 --> 00:08:39,440
而只是要清楚，如果可能
s或t為null，在這樣的代碼？

217
00:08:39,440 --> 00:08:43,140

218
00:08:43,140 --> 00:08:44,490
當可能s或t為null。

219
00:08:44,490 --> 00:08:44,990
是嗎？

220
00:08:44,990 --> 00:08:45,990
>> 聽眾：[聽不清]。

221
00:08:45,990 --> 00:08:49,490

222
00:08:49,490 --> 00:08:50,510
>> 戴維·J·馬蘭：沒錯。

223
00:08:50,510 --> 00:08:52,840
如果字符串用戶
鍵入的是太長時間

224
00:08:52,840 --> 00:08:56,140
要裝入內存，或者一些
奇怪的角落情況下那樣，

225
00:08:56,140 --> 00:08:59,010
GetString的，正如我們所看到的，從字面上
今天，它的文檔中，

226
00:08:59,010 --> 00:09:02,330
表示將返回null作為
一個特殊的標記值，

227
00:09:02,330 --> 00:09:05,417
或者只是有點特殊符號
這意味著出事了。

228
00:09:05,417 --> 00:09:07,500
因此，我們要檢查
是，因為事實證明

229
00:09:07,500 --> 00:09:09,720
那空是一個非常危險的價值。

230
00:09:09,720 --> 00:09:14,250
>> 通常情況下，如果你嘗試做一些與
空涉及函數 - 它傳遞

231
00:09:14,250 --> 00:09:17,470
作為輸入，對instance--該功能
很可能會崩潰，並用它，

232
00:09:17,470 --> 00:09:19,090
記下你的整個程序。

233
00:09:19,090 --> 00:09:22,570
因此，這第三條線，現在僅僅是一個理智
檢查，檢查錯誤，如果你願意。

234
00:09:22,570 --> 00:09:25,450
這是一個好習慣，現在的
我們進入任何時候我們

235
00:09:25,450 --> 00:09:28,050
嘗試使用一個值，
可能，可能，是空的。

236
00:09:28,050 --> 00:09:32,000
>> 現在，在第四行此處，
“如果STRCMP（S，T），”好了，

237
00:09:32,000 --> 00:09:33,180
那是什麼指？

238
00:09:33,180 --> 00:09:36,750
好吧，我們說這是一個非常簡潔
命名函數的字符串比較。

239
00:09:36,750 --> 00:09:40,370
及其在生命的目的是比較
其反對的第一個參數第二，

240
00:09:40,370 --> 00:09:44,640
但不是在它們的地址而言，
因為我們沒有無意中片刻

241
00:09:44,640 --> 00:09:48,270
以前的紅色代碼，但
而比較這兩個

242
00:09:48,270 --> 00:09:53,210
在力所能及直觀的字符串
通過比較這一點，對這種方式，

243
00:09:53,210 --> 00:09:56,690
針對這一點，針對這一點，並
然後停止，如果和當一個

244
00:09:56,690 --> 00:09:59,590
還是我的兩個手指
打一個反斜杠0。

245
00:09:59,590 --> 00:10:04,530
因此，有人年前實施的strcmp
實現我們的功能

246
00:10:04,530 --> 00:10:08,890
我們希望我們會得到
僅通過比較兩個簡單的值。

247
00:10:08,890 --> 00:10:14,929
>> 現在，坦率地說，我把圖紙
所有這些不同的數字。

248
00:10:14,929 --> 00:10:17,470
但現實是，我已經
製備這些向上的全部時間。

249
00:10:17,470 --> 00:10:19,580
因此，讓我乾脆去
而這些亂塗出來

250
00:10:19,580 --> 00:10:23,100
做一個點，在結束
這一天，並向前走，

251
00:10:23,100 --> 00:10:30,160
我們不是真的要關心
有什麼解決的事情，其實

252
00:10:30,160 --> 00:10:30,790
在存儲器中。

253
00:10:30,790 --> 00:10:34,320
所以，我不會畫這些
種數的那麼多了，

254
00:10:34,320 --> 00:10:38,970
我只是一個抽象的這個客場
小只箭更友好。

255
00:10:38,970 --> 00:10:42,060
>> 換言之，如果s是一個指針，
好了，讓我們只繪製它，從字面上看，

256
00:10:42,060 --> 00:10:45,430
作為一個指針箭頭指向
從自身到別的東西，

257
00:10:45,430 --> 00:10:48,280
而不用太擔心更多
這些地址的細節

258
00:10:48,280 --> 00:10:49,910
其中，再次，我反正做了。

259
00:10:49,910 --> 00:10:52,680
但是，我們可以看到這些地址，
有時，調試代碼的時候。

260
00:10:52,680 --> 00:10:56,450
>> 現在，同時，該計劃
當然，在這裡的修復，

261
00:10:56,450 --> 00:10:58,720
通過比較該問題
這兩個字符串。

262
00:10:58,720 --> 00:11:00,260
但是，我們遇到了另一個問題。

263
00:11:00,260 --> 00:11:03,180
這是從複製
節目最後一次，

264
00:11:03,180 --> 00:11:06,880
因此，我試圖利用
在一個字符串僅僅是第一個字符。

265
00:11:06,880 --> 00:11:09,620
但究竟是什麼症狀
我們看到最後的時候

266
00:11:09,620 --> 00:11:14,150
用戶鍵入一個值，如
加布於小寫的S，

267
00:11:14,150 --> 00:11:19,310
那麼我們分配s轉換T，
如第三行那裡，

268
00:11:19,310 --> 00:11:22,900
然後我試圖
資本噸支架0？

269
00:11:22,900 --> 00:11:25,950
什麼效果
改變噸支架0嗎？

270
00:11:25,950 --> 00:11:27,150
>> 聽眾：它改變了第

271
00:11:27,150 --> 00:11:29,360
>> 戴維·J·馬蘭：是啊，
我換了S，以及。

272
00:11:29,360 --> 00:11:31,050
因為什麼怎麼回事？

273
00:11:31,050 --> 00:11:34,130
好吧，讓我看看，如果我能清潔
這幅畫，如下所示。

274
00:11:34,130 --> 00:11:41,390
>> 如果S是再次，字克，
A，B，E，反斜杠，0和s

275
00:11:41,390 --> 00:11:44,084
我們將繼續繪製一個框
在這裡，但沒有更多的地址。

276
00:11:44,084 --> 00:11:45,250
讓我們停止做的事情了。

277
00:11:45,250 --> 00:11:47,510
讓我們只畫一幅畫
簡化了世界。

278
00:11:47,510 --> 00:11:52,640
>> 當我宣布噸，串T，
創建的內存塊。

279
00:11:52,640 --> 00:11:55,850
方碰巧是32
位在大多數計算機上。

280
00:11:55,850 --> 00:11:59,530
事實上，如果你曾經聽說過的
具有32位體系結構的計算機，

281
00:11:59,530 --> 00:12:03,000
真正看中的，說話，只是
意味著它採用32位地址。

282
00:12:03,000 --> 00:12:05,370
而作為一個技術不談，
如果你曾經想知道

283
00:12:05,370 --> 00:12:09,630
為什麼舊的電腦，如果你真的
想喝湯起來，有很多的RAM，

284
00:12:09,630 --> 00:12:12,360
只能有一個最大
四個千兆字節的RAM，

285
00:12:12,360 --> 00:12:14,860
好，這是因為，從字面上看，
您的舊電腦只能

286
00:12:14,860 --> 00:12:17,250
計高達4
十億，4個十億字節，

287
00:12:17,250 --> 00:12:20,590
因為它是使用32位
號碼的地址。

288
00:12:20,590 --> 00:12:23,260
>> 但在任何情況下，在該
比如，故事中的要簡單得多。

289
00:12:23,260 --> 00:12:27,250
t是只是一個指針，或
真是一個char星，又名字符串。

290
00:12:27,250 --> 00:12:30,860
怎麼辦我想更新這幅畫
現在的代碼，第二行，

291
00:12:30,860 --> 00:12:31,950
點後，點，點？

292
00:12:31,950 --> 00:12:35,845
當我做串T等於Š分號，
請問這張照片改變？

293
00:12:35,845 --> 00:12:37,500

294
00:12:37,500 --> 00:12:38,000
是嗎？

295
00:12:38,000 --> 00:12:38,916
>> 聽眾：[聽不清]。

296
00:12:38,916 --> 00:12:41,087

297
00:12:41,087 --> 00:12:42,020
>> 戴維·J·馬蘭：是的。

298
00:12:42,020 --> 00:12:42,600
沒錯。

299
00:12:42,600 --> 00:12:45,620
我只是把一個箭頭從
噸方塊以相同的地址，

300
00:12:45,620 --> 00:12:47,570
在相同的第一個字母給了。

301
00:12:47,570 --> 00:12:50,850
或在技術上，如果這
男人仍然在為0x1，

302
00:12:50,850 --> 00:12:53,052
這是因為雖然我有
這裡為0x1和0x1這裡。

303
00:12:53,052 --> 00:12:54,760
但同樣，誰在乎
關於地址？

304
00:12:54,760 --> 00:12:56,345
只是，現在最重要的想法。

305
00:12:56,345 --> 00:12:57,720
因此，這是這裡發生了什麼。

306
00:12:57,720 --> 00:13:02,690
所以，當然，如果你做T支架
0，這是數組符號，

307
00:13:02,690 --> 00:13:05,650
的course--坦率地說，它看起來
像有一個數組在這裡，

308
00:13:05,650 --> 00:13:07,340
但現在有這樣奇怪的事情。

309
00:13:07,340 --> 00:13:11,160
要知道，編程語言，
C，為您提供此功能，

310
00:13:11,160 --> 00:13:14,650
由此，即使t是
指針，或s是一個指針，

311
00:13:14,650 --> 00:13:18,050
您還可以使用熟悉的，
舒適的括號

312
00:13:18,050 --> 00:13:22,520
符號去的第一要素，
或所述第二元件，或任何元件

313
00:13:22,520 --> 00:13:26,130
在該指針指向
到，因為，據推測，它

314
00:13:26,130 --> 00:13:29,410
是，因為在這種情況下，
指著一些數組。

315
00:13:29,410 --> 00:13:30,340
>> 那麼，我們如何解決這個問題？

316
00:13:30,340 --> 00:13:33,660
坦率地說，這是它得到了
有點麻煩第一眼。

317
00:13:33,660 --> 00:13:35,340
但這裡是一個新的和改進的版本。

318
00:13:35,340 --> 00:13:37,460
>> 因此，首先，我越來越
擺脫CS50庫，

319
00:13:37,460 --> 00:13:41,170
只是揭露S是真的
一個char明星，只是一個代名詞。

320
00:13:41,170 --> 00:13:43,540
和T也是一個char明星。

321
00:13:43,540 --> 00:13:48,290
但對到底是怎麼回事
該行的右手側

322
00:13:48,290 --> 00:13:49,970
其中T是賦值？

323
00:13:49,970 --> 00:13:50,790
>> 什麼是malloc的？

324
00:13:50,790 --> 00:13:51,630
什麼是strlen的？

325
00:13:51,630 --> 00:13:52,547
什麼是的sizeof（char）的？

326
00:13:52,547 --> 00:13:54,380
為什麼非得這樣做
線看起來那麼複雜嗎？

327
00:13:54,380 --> 00:13:55,713
它是什麼做在一個較高的水平？

328
00:13:55,713 --> 00:13:56,482

329
00:13:56,482 --> 00:13:57,440
什麼是存儲在T？

330
00:13:57,440 --> 00:13:58,646
是嗎？

331
00:13:58,646 --> 00:14:01,104
聽眾：它的分配
一定量的存儲空間。

332
00:14:01,104 --> 00:14:03,032
它的存儲，我想，
信[聽不清]。

333
00:14:03,032 --> 00:14:04,032
>> 戴維·J·馬蘭：完美。

334
00:14:04,032 --> 00:14:04,540
完美的。

335
00:14:04,540 --> 00:14:06,650
它分配一個特定的
存儲空間量

336
00:14:06,650 --> 00:14:08,940
存儲，據推測，未來的信件。

337
00:14:08,940 --> 00:14:11,310
並且特別地，malloc的
因此，返回什麼？

338
00:14:11,310 --> 00:14:13,114

339
00:14:13,114 --> 00:14:14,851
>> 聽眾：返回的[聽不清]？

340
00:14:14,851 --> 00:14:15,850
戴維·J·馬蘭：沒錯。

341
00:14:15,850 --> 00:14:18,850
返回的內存地址，
這只不過是一個奇特的方式，

342
00:14:18,850 --> 00:14:21,640
返回的地址
該內存的第一個字節。

343
00:14:21,640 --> 00:14:25,460
的責任是我記住
實際上有多少內存I

344
00:14:25,460 --> 00:14:27,140
分配或要求的malloc的。

345
00:14:27,140 --> 00:14:28,384
>> 現在是多少呢？

346
00:14:28,384 --> 00:14:30,550
好吧，即使有
很多括號在這裡，

347
00:14:30,550 --> 00:14:32,970
malloc的只需要一個參數。

348
00:14:32,970 --> 00:14:37,250
和我指定的字符strlen，所以給
我盡可能多的字節，因為在S，

349
00:14:37,250 --> 00:14:37,800
但新增一個。

350
00:14:37,800 --> 00:14:38,300
為什麼呢？

351
00:14:38,300 --> 00:14:39,030

352
00:14:39,030 --> 00:14:39,530
是嗎？

353
00:14:39,530 --> 00:14:40,840
>> 聽眾：反斜杠0。

354
00:14:40,840 --> 00:14:41,840
戴維·J·馬蘭：沒錯。

355
00:14:41,840 --> 00:14:43,423
我們必須做一點家務。

356
00:14:43,423 --> 00:14:45,970
所以，因為有一個反斜杠
0，我們最好記住這一點。

357
00:14:45,970 --> 00:14:47,310
否則，我們將
創建一個字符串，

358
00:14:47,310 --> 00:14:49,170
沒有特別的終結者。

359
00:14:49,170 --> 00:14:52,640
>> 同時，剛需超
肛門，我的sizeof（char）的，

360
00:14:52,640 --> 00:14:55,730
萬一有人跑我
不上CS50設備代碼，

361
00:14:55,730 --> 00:14:58,220
但也許在不同的計算機
乾脆在那裡字符

362
00:14:58,220 --> 00:15:01,470
是一個字節，按照慣例，但有兩個
字節或更大的東西不止這些。

363
00:15:01,470 --> 00:15:04,490
這是剛需超，
超級反感的錯誤。

364
00:15:04,490 --> 00:15:06,940
儘管，在現實中，這是
最有可能將是一個1。

365
00:15:06,940 --> 00:15:11,490
>> 現在，同時，我繼續和複製
字符串，T支架i等於噸支架第

366
00:15:11,490 --> 00:15:14,962
我將按照上週的
源代碼，看看是怎麼回事。

367
00:15:14,962 --> 00:15:17,670
但關鍵的外賣，以及
我之所以把代碼現在綠，

368
00:15:17,670 --> 00:15:22,520
是因為很最後一行
噸支架0等於TOUPPER，

369
00:15:22,520 --> 00:15:25,230
具有的效果
轉增股本的字符串？

370
00:15:25,230 --> 00:15:26,960
T和/或S？

371
00:15:26,960 --> 00:15:29,280

372
00:15:29,280 --> 00:15:30,580
最後一行代碼。

373
00:15:30,580 --> 00:15:32,930

374
00:15:32,930 --> 00:15:35,560
>> 只是T，是因為什麼
最少此時，

375
00:15:35,560 --> 00:15:41,500
如果我稍微撤消最後一步，
什麼情況是，當我調用malloc，

376
00:15:41,500 --> 00:15:45,380
í基本上得到一個內存塊
這是相同的尺寸，原來，

377
00:15:45,380 --> 00:15:47,020
因為這是算術我做到了。

378
00:15:47,020 --> 00:15:50,920
我存儲在T地址
的內存塊。

379
00:15:50,920 --> 00:15:53,370
儘管這看起來不錯
漂亮，漂亮，一片空白，

380
00:15:53,370 --> 00:15:56,882
實際情況是有，我們會
保持通話，在這裡的垃圾值。

381
00:15:56,882 --> 00:15:59,340
該內存塊可能很
也有之前被使用，

382
00:15:59,340 --> 00:16:00,940
幾秒鐘，幾分鐘前。

383
00:16:00,940 --> 00:16:04,410
因此，有可能完全是數字
或字母那裡，只是偶然。

384
00:16:04,410 --> 00:16:08,580
但他們不是有效的，直到我
我自己填充此塊內存

385
00:16:08,580 --> 00:16:12,510
與實際的字符，如我
做在for循環出現。

386
00:16:12,510 --> 00:16:13,180
好吧？

387
00:16:13,180 --> 00:16:16,180
>> 所以，現在的高潮
這三個例子

388
00:16:16,180 --> 00:16:20,730
那名看似打破最後一次，
這個互換的例子，這個功能

389
00:16:20,730 --> 00:16:23,670
在這個意義上製作
它交換a和b。

390
00:16:23,670 --> 00:16:25,620
但它並沒有什麼其他意義的工作？

391
00:16:25,620 --> 00:16:27,616

392
00:16:27,616 --> 00:16:28,614
是嗎？

393
00:16:28,614 --> 00:16:29,612
>> 聽眾：[聽不清]。

394
00:16:29,612 --> 00:16:35,600

395
00:16:35,600 --> 00:16:36,700
>> 戴維·J·馬蘭：沒錯。

396
00:16:36,700 --> 00:16:39,530
如果我要調用這個函數
從another--例如

397
00:16:39,530 --> 00:16:42,870
從主一樣，在功能
我有一個變量，x和y，當我

398
00:16:42,870 --> 00:16:46,160
上星期，同樣的代碼，
而我通過在X和Y

399
00:16:46,160 --> 00:16:49,860
以交換，然後調用Swap--這一點，
當然是正確的版本

400
00:16:49,860 --> 00:16:52,220
就是我們即將
see--沒有奏效。

401
00:16:52,220 --> 00:16:53,770
那麼，什麼是定位？

402
00:16:53,770 --> 00:16:56,850
>> 好了，所以才要
顯然，讓我先走

403
00:16:56,850 --> 00:17:05,450
還有 - 給我1秒在這裡，看
如果我能告訴你的最後一個，這

404
00:17:05,450 --> 00:17:12,464
將in--讓我們來看看，如果我能找到
這種真正的fast--確定，[聽不清]。

405
00:17:12,464 --> 00:17:18,440

406
00:17:18,440 --> 00:17:19,240
好了，它就在那裡。

407
00:17:19,240 --> 00:17:21,000
所以忽略我只是鍵入命令。

408
00:17:21,000 --> 00:17:23,780
我希望它在檢索
最後一分鐘的一例

409
00:17:23,780 --> 00:17:27,960
從去年的時間，這
現在所謂的無交換。

410
00:17:27,960 --> 00:17:30,200
>> 因此，沒有交換的地方
我們離開的最後一次，

411
00:17:30,200 --> 00:17:32,930
因此，我初始化
X要1和y 2。

412
00:17:32,930 --> 00:17:35,840
後來我打電話交換，傳遞1和2。

413
00:17:35,840 --> 00:17:37,930
然後這個函數
在某種意義上工作，

414
00:17:37,930 --> 00:17:40,750
但它沒有永久的
在x和y的影響。

415
00:17:40,750 --> 00:17:45,430
因此，目前的問題是，怎麼現在
我們其實解決這個問題？

416
00:17:45,430 --> 00:17:47,820
如何解決在眼前？

417
00:17:47,820 --> 00:17:53,150
>> 那麼，在swap.c，今天是新的，
看到一對夫婦的差異。

418
00:17:53,150 --> 00:17:54,700
x和y是相同的。

419
00:17:54,700 --> 00:17:57,250
但顯然
約25行有什麼不同？

420
00:17:57,250 --> 00:17:58,880

421
00:17:58,880 --> 00:18:01,715
最新消息那裡，如果你還記得
它看起來像一秒鐘前？

422
00:18:01,715 --> 00:18:02,565
>> 聽眾：[聽不清]。

423
00:18:02,565 --> 00:18:03,440
>> 戴維·J·馬蘭：是的。

424
00:18:03,440 --> 00:18:06,680
所以連字號是一個新的作品
語法不僅這個程序中，

425
00:18:06,680 --> 00:18:08,560
而且更普遍的CS50。

426
00:18:08,560 --> 00:18:10,680
到目前為止，我不認為
我們見過的任何實例

427
00:18:10,680 --> 00:18:14,070
還是真的在任何談論他們
細節，不是，也許，搶先其他

428
00:18:14,070 --> 00:18:16,467
在節中，像這樣的符號。

429
00:18:16,467 --> 00:18:19,300
嗯，原來符號是
最後張新語法

430
00:18:19,300 --> 00:18:20,174
我們要學習的。

431
00:18:20,174 --> 00:18:23,500
它的意思是在
一些變量的地址。

432
00:18:23,500 --> 00:18:25,070
請問您的地址並點¯x住在哪裡？

433
00:18:25,070 --> 00:18:26,510
但ÿ住什麼地址？

434
00:18:26,510 --> 00:18:28,700
因為如果
之前根本問題

435
00:18:28,700 --> 00:18:32,970
在x和y分別被傳遞
作為副本，我們真正想做的事

436
00:18:32,970 --> 00:18:38,780
是提供交換與像寶貝一樣
地圖，導致其中x和y實際上

437
00:18:38,780 --> 00:18:41,910
在RAM中，從而使
交換可以按照該圖

438
00:18:41,910 --> 00:18:47,760
和去哪裡x或y標誌的地方
和改變實際值1和2

439
00:18:47,760 --> 00:18:48,270
那裡。

440
00:18:48,270 --> 00:18:50,710
>> 所以交換需要稍微改變了。

441
00:18:50,710 --> 00:18:53,760
乍看之下，這可能
似乎有點類似於字符的明星。

442
00:18:53,760 --> 00:18:54,850
的確是。

443
00:18:54,850 --> 00:18:59,635
所以a是一個指向什麼類型的數據，
在此基礎上突出部分？

444
00:18:59,635 --> 00:19:00,810

445
00:19:00,810 --> 00:19:01,620
所以這是一個int。

446
00:19:01,620 --> 00:19:04,880
>> 所以不再是一個int，
這是一個int的地址。

447
00:19:04,880 --> 00:19:07,910
同樣，B現在準備
是一個int的地址。

448
00:19:07,910 --> 00:19:12,470
所以，當我現在請交換從主，
我不會給交換1和2。

449
00:19:12,470 --> 00:19:15,540
我要去給它像
牛的東西，黃牛的東西，

450
00:19:15,540 --> 00:19:19,820
兩個地址，這將導致
交換自己的實際位置

451
00:19:19,820 --> 00:19:21,310
在我的電腦的內存中。

452
00:19:21,310 --> 00:19:25,580
>> 所以，現在，我剩下的落實
需要改變一點點。

453
00:19:25,580 --> 00:19:28,650
有什麼明顯的不同，現在
在這三行代碼？

454
00:19:28,650 --> 00:19:31,350
有這些該死的明星都
過的地方，好嗎？

455
00:19:31,350 --> 00:19:33,014
所以，這是怎麼回事嗎？

456
00:19:33,014 --> 00:19:33,514
是嗎？

457
00:19:33,514 --> 00:19:35,055
>> 聽眾：這是很明顯[聽不清]。

458
00:19:35,055 --> 00:19:36,832

459
00:19:36,832 --> 00:19:37,990
>> 戴維·J·馬蘭：沒錯。

460
00:19:37,990 --> 00:19:41,560
所以在此context--，這是不
最好的設計決定，無可否認，

461
00:19:41,560 --> 00:19:42,530
幾年前。

462
00:19:42,530 --> 00:19:45,110
在這種情況下，其中
你只需要一個明星，

463
00:19:45,110 --> 00:19:48,240
而你沒有的數據類型，
如int，立即到左邊，

464
00:19:48,240 --> 00:19:53,146
而不是你有一個等號，顯然，
在這種情況下，當你說星A，

465
00:19:53,146 --> 00:19:56,980
這意味著去
地址是在一個。

466
00:19:56,980 --> 00:19:58,870
按照藏寶圖，可以這麼說。

467
00:19:58,870 --> 00:20:01,720
>> 並且同時，在第37行，
這意味著同樣的事情。

468
00:20:01,720 --> 00:20:05,460
去的地址，並把什麼呢？

469
00:20:05,460 --> 00:20:09,520
不管是在
地理位置使得b指定。

470
00:20:09,520 --> 00:20:10,980
換句話說，去到b。

471
00:20:10,980 --> 00:20:12,130
獲得該值。

472
00:20:12,130 --> 00:20:15,620
去和每平等
簽署，賦值運算符，

473
00:20:15,620 --> 00:20:17,010
把該值存在。

474
00:20:17,010 --> 00:20:19,272
>> 同樣，INT溫度僅僅是一個int。

475
00:20:19,272 --> 00:20:20,730
沒有什麼需要改一下溫度。

476
00:20:20,730 --> 00:20:24,810
這只是一個備用的玻璃從安嫩伯格
對於一些牛奶或橙汁。

477
00:20:24,810 --> 00:20:27,630
但我需要說的，去到B。

478
00:20:27,630 --> 00:20:31,449
去那個目的地，
放在那裡的溫度值。

479
00:20:31,449 --> 00:20:32,490
因此，發生了什麼呢？

480
00:20:32,490 --> 00:20:36,540
當我真正稱之為交換這個時候，如果
這第一盤在這裡代表主，

481
00:20:36,540 --> 00:20:42,270
當第二盤代表交換，
我通過符號x和符號ÿ

482
00:20:42,270 --> 00:20:47,150
從主來交換，只是要清楚，
這是什麼堆棧幀接收？

483
00:20:47,150 --> 00:20:48,700

484
00:20:48,700 --> 00:20:49,200
是嗎？

485
00:20:49,200 --> 00:20:50,180
>> 聽眾：[聽不清]。

486
00:20:50,180 --> 00:20:51,180
戴維·J·馬蘭：沒錯。

487
00:20:51,180 --> 00:20:53,129
x的地址和y的地址。

488
00:20:53,129 --> 00:20:55,170
而你能想到的這些
如郵寄地址。

489
00:20:55,170 --> 00:20:58,772
33牛津街和35
牛津街和你

490
00:20:58,772 --> 00:21:01,230
要移動的兩棟樓
這是在這些地方。

491
00:21:01,230 --> 00:21:04,680
>> 這有點荒謬的想法，
但是這就是我們所說的地址。

492
00:21:04,680 --> 00:21:07,000
凡在世界上可以
你會發現這兩個整數？

493
00:21:07,000 --> 00:21:09,470
凡在世界上你
找到這兩個建築物？

494
00:21:09,470 --> 00:21:15,170
因此，如果最後，畢竟這個時候我
進入今天的源代碼和編譯

495
00:21:15,170 --> 00:21:22,110
交換和運行./swap，最後，為
第一次，我們確實看到，

496
00:21:22,110 --> 00:21:25,330
我的價值觀的確有
已成功交換。

497
00:21:25,330 --> 00:21:30,860
而現在，我們甚至可以把
請注意這一點，比如，廣發銀行。

498
00:21:30,860 --> 00:21:32,740
>> 所以，讓我去到同一個文件中。

499
00:21:32,740 --> 00:21:35,010
讓我繼續運行./swap的GDB。

500
00:21:35,010 --> 00:21:36,590

501
00:21:36,590 --> 00:21:40,547
而現在，在交換，我會去
未來，並設置一個斷點在主。

502
00:21:40,547 --> 00:21:42,630
現在我要去
繼續運行該程序。

503
00:21:42,630 --> 00:21:45,810
現在我們看到我的代碼
停在該行。

504
00:21:45,810 --> 00:21:48,330
>> 如果我繼續和打印
X，我應該在這裡看到的？

505
00:21:48,330 --> 00:21:49,314

506
00:21:49,314 --> 00:21:49,980
這是一個問題。

507
00:21:49,980 --> 00:21:51,030

508
00:21:51,030 --> 00:21:51,530
再說一遍？

509
00:21:51,530 --> 00:21:52,295
>> 聽眾：[聽不清]。

510
00:21:52,295 --> 00:21:53,910
>> 戴維·J·馬蘭：所以
隨機數，也許。

511
00:21:53,910 --> 00:21:56,010
也許我很幸運，它的
優雅而簡單，如0。

512
00:21:56,010 --> 00:21:57,230
但也許這是一些隨機數。

513
00:21:57,230 --> 00:21:58,090
在這種情況下，我真的很幸運。

514
00:21:58,090 --> 00:21:59,030
這恰好是0。

515
00:21:59,030 --> 00:22:00,780
但它確實是運氣，
因為直到我

516
00:22:00,780 --> 00:22:06,280
輸入下一個，然後打印x的那
代碼行，19行，被執行死刑。

517
00:22:06,280 --> 00:22:10,942
>> 同時，如果我輸入下一一遍，
現在打印出Y，我要見2。

518
00:22:10,942 --> 00:22:13,900
現在，如果我輸入下一個，它要
變得有點混亂，因為現在，

519
00:22:13,900 --> 00:22:17,250
中的printf會出現在
在屏幕上，因為它沒有。 x是1。

520
00:22:17,250 --> 00:22:18,606
>> 讓我們再次做到這一點。

521
00:22:18,606 --> 00:22:20,480
而現在，這裡的地方
事情變得有趣。

522
00:22:20,480 --> 00:22:21,580

523
00:22:21,580 --> 00:22:26,580
在我打電話交換，甚至一步
進去，讓我們一點點偷看。

524
00:22:26,580 --> 00:22:28,980
x是，再次，1。

525
00:22:28,980 --> 00:22:33,240
Y是當然，快清醒
檢查，2，所以並不難有。

526
00:22:33,240 --> 00:22:35,740
但是，什麼是符號X你是否

527
00:22:35,740 --> 00:22:36,760

528
00:22:36,760 --> 00:22:39,350
答案，它是一種時髦好看。

529
00:22:39,350 --> 00:22:43,500
但INT明星在括號只是
對這種說法GDP的方式是一個地址。

530
00:22:43,500 --> 00:22:48,290
它不是一個整數，它是一個指向
int或以其他方式被稱為一個地址。

531
00:22:48,290 --> 00:22:49,742
>> 這是什麼瘋狂的事？

532
00:22:49,742 --> 00:22:51,825
我們從來沒有見過的東西
很喜歡之前。

533
00:22:51,825 --> 00:22:53,650

534
00:22:53,650 --> 00:22:58,120
因此，這是在我的電腦的地址
內存，其中x恰好住。

535
00:22:58,120 --> 00:22:59,040
這是黃牛的東西。

536
00:22:59,040 --> 00:23:01,290
這是坦率地說，為什麼
我開始畫箭頭，

537
00:23:01,290 --> 00:23:03,340
不是數字的，
因為誰真正關心

538
00:23:03,340 --> 00:23:06,890
您的int是在一個特定的
地址是那麼大。

539
00:23:06,890 --> 00:23:12,160
但bffff0c4，這些都是
的確十六進制數字，

540
00:23:12,160 --> 00:23:13,720
這是0到f。

541
00:23:13,720 --> 00:23:16,590
>> 因此，我們不會過多糾纏
長在什麼地方的東西。

542
00:23:16,590 --> 00:23:19,400
但是，如果我打印出Y，
當然，我看到2。

543
00:23:19,400 --> 00:23:22,440
但符號Y，我看這個地址。

544
00:23:22,440 --> 00:23:26,527
並請注意，為好奇，
相距多遠是x和y？

545
00:23:26,527 --> 00:23:27,985
您可以忽略大部分的地址。

546
00:23:27,985 --> 00:23:29,330

547
00:23:29,330 --> 00:23:29,920
四個字節。

548
00:23:29,920 --> 00:23:33,510
而這與我們的一致
早前聲稱有多大是一個int？

549
00:23:33,510 --> 00:23:34,130
四個字節。

550
00:23:34,130 --> 00:23:37,420
所以看起來一切都排隊
很好，你可能希望，在內存中。

551
00:23:37,420 --> 00:23:40,010
>> 所以，現在，讓我們快進
這個故事的結尾。

552
00:23:40,010 --> 00:23:43,290
讓我們繼續前進，步型，
潛入交換功能。

553
00:23:43,290 --> 00:23:46,880
現在發現，如果我輸入一個，它的
相同，x的地址。

554
00:23:46,880 --> 00:23:52,130
如果我B型是相同的
到y的地址。

555
00:23:52,130 --> 00:23:57,020
所以，我應該怎樣，如果我看到
說，進入地址的？

556
00:23:57,020 --> 00:23:58,120
因此，打印星號標示。

557
00:23:58,120 --> 00:24:00,130
所以，明星意味著去那裡，在這種情況下。

558
00:24:00,130 --> 00:24:02,730
＆符號意味著什麼的地址。

559
00:24:02,730 --> 00:24:05,000
所以，明星的手段1。

560
00:24:05,000 --> 00:24:09,590
並打印星級的住宿給我2。

561
00:24:09,590 --> 00:24:15,750
>> 讓我假設，就目前而言，
至少所述代碼

562
00:24:15,750 --> 00:24:18,950
現在進入執行即可
通過這種方式的理由。

563
00:24:18,950 --> 00:24:21,150
但我們會在不久重新討論這個想法。

564
00:24:21,150 --> 00:24:23,850
所以這個版本的互換
現在是正確的，並且允許

565
00:24:23,850 --> 00:24:26,650
我們來交換該特定數據類型。

566
00:24:26,650 --> 00:24:29,120
>> 所以任何疑問然後交換？

567
00:24:29,120 --> 00:24:29,890
在星？

568
00:24:29,890 --> 00:24:30,690
對地址？

569
00:24:30,690 --> 00:24:33,270
你會看到，有
問題集4，排序，

570
00:24:33,270 --> 00:24:37,310
但問題集5，絕對，如何將這些
東西是有用的，並得到更多的

571
00:24:37,310 --> 00:24:39,584
熟悉他們，作為一個結果。

572
00:24:39,584 --> 00:24:40,430
什麼呢？

573
00:24:40,430 --> 00:24:40,930
好吧。

574
00:24:40,930 --> 00:24:44,350
所以malloc的是，再次，此功能
剛剛分配內存，內存

575
00:24:44,350 --> 00:24:45,330
分配。

576
00:24:45,330 --> 00:24:47,024
以及為什麼是這樣有用嗎？

577
00:24:47,024 --> 00:24:48,940
那麼，這一切的時候，
你一直在使用malloc。

578
00:24:48,940 --> 00:24:52,230
如果你現在怎麼考慮的
GetString的作品，據推測，這是

579
00:24:52,230 --> 00:24:56,140
被問的人一大塊
記憶，隨時在用戶鍵入字符串

580
00:24:56,140 --> 00:24:59,040
在，因為我們肯定
不知道，因為CS50的工作人員，

581
00:24:59,040 --> 00:25:02,710
有多大的字符串，人類
要鍵入可能。

582
00:25:02,710 --> 00:25:07,910
>> 因此，讓我們，第一次，開始
剝開如何CS50庫工程，

583
00:25:07,910 --> 00:25:10,990
通過幾個實例來
這將導致我們的。

584
00:25:10,990 --> 00:25:15,300
所以，如果我打開gedit的
開拓scanf函數0，

585
00:25:15,300 --> 00:25:17,055
我們將看到下面的代碼。

586
00:25:17,055 --> 00:25:18,720

587
00:25:18,720 --> 00:25:23,530
scanf函數0，可以在網站上
今天，有代碼相對較少的行

588
00:25:23,530 --> 00:25:25,351
在這裡，14至20。

589
00:25:25,351 --> 00:25:26,600
讓我們來看看它在做什麼。

590
00:25:26,600 --> 00:25:28,920
它聲明為int，名為x。

591
00:25:28,920 --> 00:25:30,850
它說像，數請。

592
00:25:30,850 --> 00:25:33,940
而現在它說，scanf函數％I，＆X。

593
00:25:33,940 --> 00:25:35,620
因此，有一堆新的東西出現。

594
00:25:35,620 --> 00:25:38,420
>> 但是scanf函數，你可以種思考
作為printf的相反。

595
00:25:38,420 --> 00:25:40,090
printf的，當然，打印到屏幕上。

596
00:25:40,090 --> 00:25:44,410
scanf的排序從用戶的掃描
鍵盤的東西，他或她已經打出來。

597
00:25:44,410 --> 00:25:46,550
>> ％i是一樣的printf。

598
00:25:46,550 --> 00:25:49,410
這意味著預期
用戶鍵入一個int。

599
00:25:49,410 --> 00:25:52,820
而現在，你為什麼認為我
可能是通過scanf函數＆X？

600
00:25:52,820 --> 00:25:54,030

601
00:25:54,030 --> 00:25:57,770
如果目的在scanf生活
是得到的東西從用戶

602
00:25:57,770 --> 00:26:02,480
是什麼意思
通過它，與X，現在呢？

603
00:26:02,480 --> 00:26:02,980
是嗎？

604
00:26:02,980 --> 00:26:03,896
>> 聽眾：[聽不清]。

605
00:26:03,896 --> 00:26:05,540

606
00:26:05,540 --> 00:26:06,540
戴維·J·馬蘭：沒錯。

607
00:26:06,540 --> 00:26:12,900
無論我，人，請在我的輸入
將被保存在該位置。

608
00:26:12,900 --> 00:26:17,660
這是不夠的，還記得，剛
通過在X，因為我們已經看到，

609
00:26:17,660 --> 00:26:21,630
任何時候，你只需通過一個原始變量，
就像一個int，一些其他的功能，

610
00:26:21,630 --> 00:26:25,640
當然，它可以改變
可變的，但不會永久。

611
00:26:25,640 --> 00:26:27,360
它不能對主要的效果。

612
00:26:27,360 --> 00:26:29,420
它只能改變自己的本地副本。

613
00:26:29,420 --> 00:26:32,560
但相反，如果你不這樣做
給我實際的詮釋，

614
00:26:32,560 --> 00:26:36,640
但你給我方向
在INT，我現在，是scanf函數，

615
00:26:36,640 --> 00:26:41,050
當然，我可以按照這
解決並把一些有

616
00:26:41,050 --> 00:26:43,280
所以你可以訪問它。

617
00:26:43,280 --> 00:26:45,120
>> 所以，當我運行這個程序，讓我們來看看。

618
00:26:45,120 --> 00:26:49,660
使scanf函數0點斜線，scanf函數0。

619
00:26:49,660 --> 00:26:54,030
如果我現在鍵入數字
像50，感謝50。

620
00:26:54,030 --> 00:26:58,150
如果我現在鍵入數字一樣
負1，為負1。

621
00:26:58,150 --> 00:27:04,200
我現在鍵入數字如1.5，HM。

622
00:27:04,200 --> 00:27:06,030
為什麼我的程序不理我了？

623
00:27:06,030 --> 00:27:07,300

624
00:27:07,300 --> 00:27:09,880
嗯，因為簡單地說，我告訴
只期待一個int。

625
00:27:09,880 --> 00:27:10,380
好吧。

626
00:27:10,380 --> 00:27:11,630
所以這是其中的一個版本。

627
00:27:11,630 --> 00:27:16,600
讓我們拿東西了一個缺口，
提出，這是不好的。

628
00:27:16,600 --> 00:27:20,530
而就在這裡一個很簡單的例子，
怎麼我們就可以開始編寫代碼

629
00:27:20,530 --> 00:27:24,450
其他人可以利用或
做不好的事情妥協。

630
00:27:24,450 --> 00:27:28,336
所以第16行，如此相似
在精神之前，

631
00:27:28,336 --> 00:27:29,960
但我不會宣布它詮釋這個時候。

632
00:27:29,960 --> 00:27:32,970
我宣布它炭星，又名字符串。

633
00:27:32,970 --> 00:27:35,190
>> 但是，這究竟意味著什麼？

634
00:27:35,190 --> 00:27:38,790
所以，如果我不指定address--和
我打電話是隨意，緩衝，

635
00:27:38,790 --> 00:27:43,370
但我可以把它稱為為s，是simple--
然後我做到這一點，給我解釋一下，

636
00:27:43,370 --> 00:27:48,630
如果可以的話，基於先前
邏輯是什麼scanf函數在做線18，

637
00:27:48,630 --> 00:27:55,000
如果傳％s和緩衝區，
這是一個地址？

638
00:27:55,000 --> 00:27:58,210
什麼是scanf函數，如果你申請的
完全相同的邏輯版本0，

639
00:27:58,210 --> 00:28:00,640
當將試圖在這裡做，
在用戶類型的東西嗎？

640
00:28:00,640 --> 00:28:02,630

641
00:28:02,630 --> 00:28:03,409
是嗎？

642
00:28:03,409 --> 00:28:04,407
>> 聽眾：[聽不清]。

643
00:28:04,407 --> 00:28:07,401

644
00:28:07,401 --> 00:28:08,890
>> 戴維·J·馬蘭：沒錯。

645
00:28:08,890 --> 00:28:11,577
scanf函數，通過邏輯較早，
將要採取的串

646
00:28:11,577 --> 00:28:13,410
該人的類型化
in--它現在是一個字符串，

647
00:28:13,410 --> 00:28:15,790
它不是一個數，據推測，
如果他或她cooperates--

648
00:28:15,790 --> 00:28:19,310
並且它會試圖把那
字符串在內存中的任何地址

649
00:28:19,310 --> 00:28:20,340
緩衝區指定。

650
00:28:20,340 --> 00:28:23,870
這是偉大的，因為緩衝
的確意味著是一個地址。

651
00:28:23,870 --> 00:28:30,470
>> 但我要求這個節目是越野車的
很嚴肅的方式，因為價值是什麼

652
00:28:30,470 --> 00:28:31,330
默認情況下緩衝區？

653
00:28:31,330 --> 00:28:33,380

654
00:28:33,380 --> 00:28:34,790
我有什麼初始化為？

655
00:28:34,790 --> 00:28:35,770
什麼的內存塊？

656
00:28:35,770 --> 00:28:37,480

657
00:28:37,480 --> 00:28:38,620
我沒有，對不對？

658
00:28:38,620 --> 00:28:42,265
>> 所以，即使我已經分配了
焦恆星的不再叫S，

659
00:28:42,265 --> 00:28:48,030
它不是所謂的，buffer--所以
讓我們來繪製變量名

660
00:28:48,030 --> 00:28:53,380
現在的buffer--如果我沒有
所謂的getString或malloc的位置，

661
00:28:53,380 --> 00:28:56,030
這實際上意味著，
緩衝區只是一些垃圾值。

662
00:28:56,030 --> 00:28:57,030
>> 現在是什麼意思？

663
00:28:57,030 --> 00:29:00,220
這意味著，我已經告訴scanf函數
期望從用戶的字符串。

664
00:29:00,220 --> 00:29:01,300
而且你知道嗎？

665
00:29:01,300 --> 00:29:03,883
不管這件事情是指向
to--和我畫問號，

666
00:29:03,883 --> 00:29:07,060
但在現實中，這將是
像OX1，2，3，對不對？

667
00:29:07,060 --> 00:29:10,730
這是一些虛假的價值，僅僅
恰好從之前在那裡。

668
00:29:10,730 --> 00:29:13,440
所以，換句話說，它是
彷彿緩衝只是

669
00:29:13,440 --> 00:29:16,180
指著東西在內存中。

670
00:29:16,180 --> 00:29:17,610
我不知道是什麼。

671
00:29:17,610 --> 00:29:24,130
>> 所以，如果我輸入加布現在，這是怎麼回事
嘗試把G-A-B-E / 0出現。

672
00:29:24,130 --> 00:29:25,530
但誰知道這是什麼嗎？

673
00:29:25,530 --> 00:29:27,480
和過去一樣，任何
我們試圖去觸摸時間

674
00:29:27,480 --> 00:29:29,770
不屬於存儲器
對我們來說，發生了什麼事？

675
00:29:29,770 --> 00:29:31,020

676
00:29:31,020 --> 00:29:32,870
或幾乎所有的時間。

677
00:29:32,870 --> 00:29:34,310
分段錯誤，對吧？

678
00:29:34,310 --> 00:29:37,829
>> 這個箭頭，我不知道它是
指點。它只是一些隨機值。

679
00:29:37,829 --> 00:29:40,370
當然，如果你解釋
一個隨機值作為地址，

680
00:29:40,370 --> 00:29:42,610
你會去
一些隨機的目的地。

681
00:29:42,610 --> 00:29:46,810
所以加布可能確實崩潰
我在這裡這種情況下程序。

682
00:29:46,810 --> 00:29:50,600
>> 所以，我們可以做到這一點幾乎是壞？

683
00:29:50,600 --> 00:29:52,660
考慮這個第三和
scanf函數的最後一個例子。

684
00:29:52,660 --> 00:29:53,890

685
00:29:53,890 --> 00:29:56,870
這個版本是在何種意義上比較好？

686
00:29:56,870 --> 00:29:57,990

687
00:29:57,990 --> 00:30:01,400
如果你是舒服了
以前的問題，這是更好的。

688
00:30:01,400 --> 00:30:02,250
為什麼呢？

689
00:30:02,250 --> 00:30:03,250
>> 聽眾：[聽不清]。

690
00:30:03,250 --> 00:30:06,235

691
00:30:06,235 --> 00:30:07,110
戴維·J·馬蘭：好。

692
00:30:07,110 --> 00:30:09,970
線16，以便該情況下
較好，在這個意義上

693
00:30:09,970 --> 00:30:12,030
我們是明確的
分配一些內存。

694
00:30:12,030 --> 00:30:14,190
我們不使用malloc，
我們使用了2週

695
00:30:14,190 --> 00:30:16,060
只是聲明數組的方法。

696
00:30:16,060 --> 00:30:18,130
而我們在此之前一個字符串說過
是一個字符只是一個數組，

697
00:30:18,130 --> 00:30:19,690
所以這是完全合法的。

698
00:30:19,690 --> 00:30:22,910
但它的，當然，如
您注意，固定的大小，16。

699
00:30:22,910 --> 00:30:25,440
>> 因此，這個計劃是
完全安全的，如果我輸入

700
00:30:25,440 --> 00:30:29,760
在一個文字串，兩個字符的
串，15字符的字符串。

701
00:30:29,760 --> 00:30:34,970
但是當我開始打字16，
17，第18，千字符串，

702
00:30:34,970 --> 00:30:37,390
這裡是該字符串將要結束？

703
00:30:37,390 --> 00:30:39,570
這將結束部分在這裡。

704
00:30:39,570 --> 00:30:42,820
但誰知道還有什麼
超出了界限

705
00:30:42,820 --> 00:30:44,270
這個陣列呢？

706
00:30:44,270 --> 00:30:48,015
>> 這是因為雖然我
在這裡宣布16箱。

707
00:30:48,015 --> 00:30:49,300

708
00:30:49,300 --> 00:30:52,690
因此，而不是畫出來的所有16中，我們將
只是假裝我畫16。

709
00:30:52,690 --> 00:30:56,540
但是，如果我再嘗試讀取字符串
這是更長的時間，如50個字符，

710
00:30:56,540 --> 00:31:01,270
我要開始把
A，B，C，D，X，Y，Z。

711
00:31:01,270 --> 00:31:04,916
這大概是
其它一些內存段

712
00:31:04,916 --> 00:31:06,790
即，再次，可能會導致
我的程序崩潰，

713
00:31:06,790 --> 00:31:10,600
因為我沒有要求
事情不止16個字節。

714
00:31:10,600 --> 00:31:12,260
>> 那麼，誰在乎呢？

715
00:31:12,260 --> 00:31:13,880
好了，這裡的CS50庫。

716
00:31:13,880 --> 00:31:17,220
而且大部分這只是
類似的指令往上頂。

717
00:31:17,220 --> 00:31:21,670
該CS50庫，這一切的時候，
已經有這一行52行。

718
00:31:21,670 --> 00:31:23,680
我們已經看到的typedef，或
你會看到的typedef

719
00:31:23,680 --> 00:31:27,930
在PSET 4，剛剛創建了一個
同義詞其中焦炭明星可以更

720
00:31:27,930 --> 00:31:29,290
簡稱為字符串。

721
00:31:29,290 --> 00:31:31,540
因此，這是一個
數輪培訓

722
00:31:31,540 --> 00:31:34,120
我們已經偷偷使用了引擎蓋下方。

723
00:31:34,120 --> 00:31:36,490
>> 同時，這裡的函數，getchar函數。

724
00:31:36,490 --> 00:31:38,190
現在很明顯，沒有身體吧。

725
00:31:38,190 --> 00:31:40,273
而事實上，如果我繼續
滾動，我實際上並不

726
00:31:40,273 --> 00:31:42,080
看不到任何的實現
這些功能。

727
00:31:42,080 --> 00:31:43,140

728
00:31:43,140 --> 00:31:45,516
作為一個全面的檢查，這是為什麼？

729
00:31:45,516 --> 00:31:46,795
>> 聽眾：[聽不清]。

730
00:31:46,795 --> 00:31:47,670
戴維·J·馬蘭：是的。

731
00:31:47,670 --> 00:31:48,950
因此，這是頭文件。

732
00:31:48,950 --> 00:31:52,520
和頭文件包含原型，
再加上一些其他的東西，現在看來，

733
00:31:52,520 --> 00:31:53,780
喜歡的類型定義。

734
00:31:53,780 --> 00:31:56,910
但在CS50.c，我們已經
從來沒有給你顧左右而言他，

735
00:31:56,910 --> 00:32:02,100
但一直在CS50所有家電
這個時候，內心深處的文件夾，

736
00:32:02,100 --> 00:32:04,990
注意到有一個整體
在這裡一堆功能。

737
00:32:04,990 --> 00:32:06,720
>> 事實上，我們向下滾動。

738
00:32:06,720 --> 00:32:08,810
讓我們忽略了他們中的大多數現在。

739
00:32:08,810 --> 00:32:12,670
但是，向下滾動到調用getInt
看看調用getInt是如何工作的。

740
00:32:12,670 --> 00:32:13,890
因此，這裡是調用getInt。

741
00:32:13,890 --> 00:32:17,727
如果你真的關心如何獲得
INT作品，這裡是它的文檔。

742
00:32:17,727 --> 00:32:19,560
而當中的事
它說的是它告訴你

743
00:32:19,560 --> 00:32:21,340
什麼值的範圍就可以返回。

744
00:32:21,340 --> 00:32:24,400
它本質上是負面的2十億
以正面的2十億，給予或採取。

745
00:32:24,400 --> 00:32:26,420
>> 而事實證明，這一切
時間，即使我們從來沒有

746
00:32:26,420 --> 00:32:28,570
有了你檢查它，
如果出現錯誤，

747
00:32:28,570 --> 00:32:30,680
事實證明，所有的
此時，調用getInt有

748
00:32:30,680 --> 00:32:33,600
已返回一個特殊的
常量，不為空，

749
00:32:33,600 --> 00:32:36,760
而是INT_MAX，這是
只是一個程序員的約定。

750
00:32:36,760 --> 00:32:38,846
這意味著這裡是一個特殊的值。

751
00:32:38,846 --> 00:32:41,470
請一定要檢查這一點，只是
在出錯的時候。

752
00:32:41,470 --> 00:32:43,261
但是，我們從來沒有困擾
同的是，到目前為止，

753
00:32:43,261 --> 00:32:45,200
因為再次，這
是為了簡化。

754
00:32:45,200 --> 00:32:46,950
>> 但如何調用getInt得到實施？

755
00:32:46,950 --> 00:32:48,450
嗯，一，它不帶任何參數。

756
00:32:48,450 --> 00:32:49,390
我們知道這一點。

757
00:32:49,390 --> 00:32:50,820
它返回一個int。

758
00:32:50,820 --> 00:32:51,950
我們知道這一點。

759
00:32:51,950 --> 00:32:54,460
那麼它是怎樣的引擎蓋底下工作？

760
00:32:54,460 --> 00:32:58,290
>> 所以這是很明顯的無限
環，其中一個至少外觀。

761
00:32:58,290 --> 00:33:00,290
請注意，我們使用的getString。

762
00:33:00,290 --> 00:33:04,000
所以這很有趣。調用getInt
調用我們自己的函數，的getString。

763
00:33:04,000 --> 00:33:05,645
現在為什麼會變成這樣？

764
00:33:05,645 --> 00:33:07,400

765
00:33:07,400 --> 00:33:09,842
為什麼我會被防守
在這裡行165？

766
00:33:09,842 --> 00:33:11,390

767
00:33:11,390 --> 00:33:15,639
哪些本著可能發生
164，只是要清楚嗎？

768
00:33:15,639 --> 00:33:16,930
這是同樣的答案和以前一樣。

769
00:33:16,930 --> 00:33:18,660

770
00:33:18,660 --> 00:33:20,089
可能僅僅是內存不足。

771
00:33:20,089 --> 00:33:23,130
不順心的事了的getString，
我們必須能夠處理的。

772
00:33:23,130 --> 00:33:27,070
而我之所以不返回null是
即，在技術上，空是一個指針。

773
00:33:27,070 --> 00:33:29,120
調用getInt必須返回一個int。

774
00:33:29,120 --> 00:33:31,060
所以我隨意
決定，從本質上講，

775
00:33:31,060 --> 00:33:34,600
有2十億，而奮鬥，是怎麼回事
是一種特殊的價值，我永遠不可能

776
00:33:34,600 --> 00:33:35,970
其實獲取用戶。

777
00:33:35,970 --> 00:33:39,930
這只是一個價值我要去
浪費，代表一個錯誤代碼。

778
00:33:39,930 --> 00:33:41,540
>> 所以，現在，事情變得有點奇特。

779
00:33:41,540 --> 00:33:44,670
它不是完全一樣的功能
和以前一樣，但它是非常相似的。

780
00:33:44,670 --> 00:33:50,120
所以請注意，我在這裡聲明，符合
172，無論是一個int n和一個char℃。

781
00:33:50,120 --> 00:33:53,600
然後我用這個時髦的路線，
sscanf的，它原來

782
00:33:53,600 --> 00:33:55,990
不掃描從鍵盤輸入的字符串。

783
00:33:55,990 --> 00:33:59,226
它代表著現有的字符串
用戶已經鍵入英寸

784
00:33:59,226 --> 00:34:02,100
所以，我已經叫的getString，這
意味著我有一個字符串在內存中。

785
00:34:02,100 --> 00:34:05,020
sscanf的是什麼，你會
調用解析函數。

786
00:34:05,020 --> 00:34:07,760
它著眼於我有串
鍵入，字符一個字符，

787
00:34:07,760 --> 00:34:09,250
並做一些有用的東西。

788
00:34:09,250 --> 00:34:10,969
該字符串被存儲在一行。

789
00:34:10,969 --> 00:34:13,560
我知道，只有通過去
備份在這裡，說，哦，好吧，

790
00:34:13,560 --> 00:34:15,143
我把它叫做不發這個時間，但行。

791
00:34:15,143 --> 00:34:15,989

792
00:34:15,989 --> 00:34:18,080
>> 而現在，這是一個有點不同。

793
00:34:18,080 --> 00:34:22,480
但是這實際上意味著，其原因
我們會有點潮手在今天，

794
00:34:22,480 --> 00:34:26,070
我們正在檢查
查看該用戶鍵入

795
00:34:26,070 --> 00:34:29,909
與詮釋，也許另一個字符。

796
00:34:29,909 --> 00:34:33,610
如果用戶輸入了一個int，它的
將要被存儲在正，因為我

797
00:34:33,610 --> 00:34:36,739
按地址傳遞這一點，
今天我們看到的新把戲。

798
00:34:36,739 --> 00:34:41,570
如果用戶還輸入
像123x，使得x

799
00:34:41,570 --> 00:34:45,060
將要結束了
字母字符c。

800
00:34:45,060 --> 00:34:48,739
>> 現在事實證明，sscanf的
告訴我，智能化，

801
00:34:48,739 --> 00:34:54,750
多少個變量是sscanf的
能夠成功地填補。

802
00:34:54,750 --> 00:34:58,770
所以通過這種邏輯，如果該函數
我實施的調用getInt，

803
00:34:58,770 --> 00:35:00,900
但我檢查，
潛在地，對於用戶

804
00:35:00,900 --> 00:35:04,190
已經輸入了一個int
其次是別的東西，

805
00:35:04,190 --> 00:35:08,580
什麼才是我想要的sscanf的
返回值真的是？

806
00:35:08,580 --> 00:35:10,950
如果目的是要獲得
只是從用戶的詮釋？

807
00:35:10,950 --> 00:35:13,980

808
00:35:13,980 --> 00:35:19,300
>> 所以，如果sscanf的回報
2，是什麼意思呢？

809
00:35:19,300 --> 00:35:21,660
用戶鍵入
是這樣，從字面上看，

810
00:35:21,660 --> 00:35:24,770
123x，這只是無稽之談。

811
00:35:24,770 --> 00:35:27,490
這是一個錯誤，並
我要檢查的。

812
00:35:27,490 --> 00:35:32,960
>> 因此，如果這在用戶的類型，由
這個邏輯有哪些呢sscanf的回報，

813
00:35:32,960 --> 00:35:33,740
你會說什麼？

814
00:35:33,740 --> 00:35:35,070

815
00:35:35,070 --> 00:35:39,130
所以它會返回2，因為
123是要去這裡，

816
00:35:39,130 --> 00:35:41,580
而X是要結束在這裡。

817
00:35:41,580 --> 00:35:43,970
但我不想在x得到填補。

818
00:35:43,970 --> 00:35:48,580
我想，sscanf會只成功
灌裝頭的變量。

819
00:35:48,580 --> 00:35:52,490
所以這就是為什麼我
想sscanf會返回1。

820
00:35:52,490 --> 00:35:55,750
>> 如果這是有點在頭上
就目前而言，這是完全正常。

821
00:35:55,750 --> 00:36:00,030
意識到雖然，其中一個
調用getInt和GetString值

822
00:36:00,030 --> 00:36:03,630
就是我們正在做的啦！
很多錯誤檢查這樣使

823
00:36:03,630 --> 00:36:07,130
是，到今天為止，你幾乎可以
在你的鍵盤輸入任何東西，

824
00:36:07,130 --> 00:36:08,490
我們會抓住它。

825
00:36:08,490 --> 00:36:10,592
我們肯定的是，
工作人員，肯定不會

826
00:36:10,592 --> 00:36:13,300
在一個錯誤的來源你
計劃，因為我們的防守

827
00:36:13,300 --> 00:36:16,270
檢查所有的愚蠢的
的東西，用戶可能會做，

828
00:36:16,270 --> 00:36:18,900
如輸入一個字符串，當
你真的想要詮釋。

829
00:36:18,900 --> 00:36:21,350
因此，對於now--我們就來
回此之前long--

830
00:36:21,350 --> 00:36:23,710
但是這一切的時候，
的getString和調用getInt有

831
00:36:23,710 --> 00:36:29,950
在使用這種發動機罩下方
內存地址的基本思路。

832
00:36:29,950 --> 00:36:32,580
>> 所以，現在，讓我們把事情
對用戶來說更加友好。

833
00:36:32,580 --> 00:36:38,740
您可能還記得，從去年賓基
時間 - 如果我的鼠標會cooperate--所以

834
00:36:38,740 --> 00:36:42,560
我們有這個代碼，這
坦率地說，是相當荒謬的。

835
00:36:42,560 --> 00:36:45,330
此代碼實現了什麼
有用的，但它是例子

836
00:36:45,330 --> 00:36:48,330
該教授Parlante
為了表示用於

837
00:36:48,330 --> 00:36:51,840
什麼樣的是怎麼回事
項目涉及內存。

838
00:36:51,840 --> 00:36:54,850
>> 因此，讓我們複述這
故事超簡要介紹。

839
00:36:54,850 --> 00:36:58,720
這些前兩行，在
英語，做什麼，會說什麼？

840
00:36:58,720 --> 00:37:01,230

841
00:37:01,230 --> 00:37:05,430
就在合理的人，但
稍微專業術語，取刺。

842
00:37:05,430 --> 00:37:06,346
聽眾：[聽不清]。

843
00:37:06,346 --> 00:37:07,705

844
00:37:07,705 --> 00:37:11,080
>> 戴維·J·馬蘭：好，你確定
地址為你的x和y變量。

845
00:37:11,080 --> 00:37:15,520
不大，因為x和y是未
變量在傳統意義上的。

846
00:37:15,520 --> 00:37:18,054
x和y是地址
或者將存儲地址。

847
00:37:18,054 --> 00:37:19,220
因此，讓我們試試這個一次。

848
00:37:19,220 --> 00:37:21,010
不是一個糟糕的開局，但。

849
00:37:21,010 --> 00:37:21,510
是嗎？

850
00:37:21,510 --> 00:37:22,426
>> 聽眾：[聽不清]。

851
00:37:22,426 --> 00:37:23,966

852
00:37:23,966 --> 00:37:24,840
戴維·J·馬蘭：好。

853
00:37:24,840 --> 00:37:26,173
我認為這是一個小清潔。

854
00:37:26,173 --> 00:37:28,630
聲明兩個三分球，兩個整數。

855
00:37:28,630 --> 00:37:30,150
而我們稱他們為x和y。

856
00:37:30,150 --> 00:37:32,790
或者，如果我們畫
此為圖片，再

857
00:37:32,790 --> 00:37:36,410
記得很簡單，所有
我們正在做的與第一線

858
00:37:36,410 --> 00:37:39,690
正在制定一個盒子這樣的，
在它的一些垃圾的價值，

859
00:37:39,690 --> 00:37:41,920
並調用它的X，然後
另一個盒子這樣的，

860
00:37:41,920 --> 00:37:43,880
與一些垃圾值
它，叫它年。

861
00:37:43,880 --> 00:37:45,810
我們已經聲明了兩個
三分球，最終

862
00:37:45,810 --> 00:37:47,860
將存儲一個int的地址。

863
00:37:47,860 --> 00:37:49,170
所以這一切都在那裡。

864
00:37:49,170 --> 00:37:53,290
>> 所以當賓基這樣做，則
粘土只是看著這樣的。

865
00:37:53,290 --> 00:37:55,350
和尼克剛種
包裹起來的箭，

866
00:37:55,350 --> 00:37:57,590
彷彿他們不是指向任何地方
特別是，因為他們只是

867
00:37:57,590 --> 00:37:58,250
垃圾值。

868
00:37:58,250 --> 00:38:01,670
他們沒有明確的初始化
任何地方尤其如此。

869
00:38:01,670 --> 00:38:03,980
>> 現在的下一行
代碼，召回，是這樣的。

870
00:38:03,980 --> 00:38:07,510
因此，在合理的人性化，
但有些技術英語，

871
00:38:07,510 --> 00:38:09,790
什麼是這行代碼在做什麼？

872
00:38:09,790 --> 00:38:10,391
是嗎？

873
00:38:10,391 --> 00:38:11,333
>> 聽眾：[聽不清]。

874
00:38:11,333 --> 00:38:12,746

875
00:38:12,746 --> 00:38:13,950
>> 戴維·J·馬蘭：完美。

876
00:38:13,950 --> 00:38:17,016
它分配的大塊
內存是一個int的大小。

877
00:38:17,016 --> 00:38:18,140
而這一半的答案。

878
00:38:18,140 --> 00:38:20,056
你回答正確
一半的表情。

879
00:38:20,056 --> 00:38:22,473
什麼是發生在
等號左邊？

880
00:38:22,473 --> 00:38:22,972
是嗎？

881
00:38:22,972 --> 00:38:24,814
聽眾：和受讓人
它給變量x？

882
00:38:24,814 --> 00:38:27,690
>> 戴維·J·馬蘭：和受讓人
它給變量x。

883
00:38:27,690 --> 00:38:31,650
總括來說，右側會分配
足夠的內存來存儲一個int。

884
00:38:31,650 --> 00:38:34,150
但具體的malloc
返回地址

885
00:38:34,150 --> 00:38:37,270
這大塊的內存，您已中
只是建議被存放在X。

886
00:38:37,270 --> 00:38:42,560
>> 那麼，尼克做了最後一次帶賓基是
他拖著那指針移出，粘土，

887
00:38:42,560 --> 00:38:46,820
現在指向一個內存塊白
等於一個int的大小。

888
00:38:46,820 --> 00:38:49,360
事實上，這意味著
來表示四個字節。

889
00:38:49,360 --> 00:38:55,310
>> 現在，代碼的下一行
這樣做，星x被42。

890
00:38:55,310 --> 00:38:58,530
所以42是簡單的
右手側，生活的含義。

891
00:38:58,530 --> 00:39:00,500
左側，星x表示什麼？

892
00:39:00,500 --> 00:39:01,600

893
00:39:01,600 --> 00:39:03,280
這也可能gone--沒關係。

894
00:39:03,280 --> 00:39:04,220
行。

895
00:39:04,220 --> 00:39:06,875
>> 聽眾：基本上，
進入[聽不清]

896
00:39:06,875 --> 00:39:07,750
戴維·J·馬蘭：好。

897
00:39:07,750 --> 00:39:08,760
聽眾：[聽不清]。

898
00:39:08,760 --> 00:39:09,760
戴維·J·馬蘭：沒錯。

899
00:39:09,760 --> 00:39:11,979
左手邊是指去為x。

900
00:39:11,979 --> 00:39:12,520
x是地址。

901
00:39:12,520 --> 00:39:15,520
這就像33牛津街，或OX1。

902
00:39:15,520 --> 00:39:18,690
和星x表示去那家
解決和放什麼呢？

903
00:39:18,690 --> 00:39:19,520
42。

904
00:39:19,520 --> 00:39:21,290
>> 所以，事實上，這正是尼克做了。

905
00:39:21,290 --> 00:39:23,740
他開始用，
本質上，精神上

906
00:39:23,740 --> 00:39:26,270
用手指指著
的x，下面的箭頭

907
00:39:26,270 --> 00:39:30,670
到右側的白框
側，並且把數42那裡。

908
00:39:30,670 --> 00:39:34,120
但後​​來事情得到了
有點危險吧？

909
00:39:34,120 --> 00:39:35,860
賓基的即將失去他的頭。

910
00:39:35,860 --> 00:39:39,465
>> 星y等於13，運氣不好，意味著什麼？

911
00:39:39,465 --> 00:39:43,620
所以，明星y表示去的地址y中。

912
00:39:43,620 --> 00:39:45,630
但是，什麼是Y中的地址？

913
00:39:45,630 --> 00:39:47,899

914
00:39:47,899 --> 00:39:49,440
好吧，這是垃圾的價值，對不對？

915
00:39:49,440 --> 00:39:50,800
我畫它作為一個問號。

916
00:39:50,800 --> 00:39:54,850
尼克畫了它作為一個蜷縮箭頭。

917
00:39:54,850 --> 00:39:59,600
而且只要你嘗試
做明星Y，說去那裡，

918
00:39:59,600 --> 00:40:03,872
但沒有一個合法的
地址，它的一些虛假的位置，

919
00:40:03,872 --> 00:40:05,080
該計劃的要崩潰。

920
00:40:05,080 --> 00:40:08,580
和賓基的頭部會
飛了出去，在這裡，因為它沒有。

921
00:40:08,580 --> 00:40:12,130
>> 所以，最後，這個方案
只是平了破綻。

922
00:40:12,130 --> 00:40:13,540
這是一個錯誤的程序。

923
00:40:13,540 --> 00:40:14,760
它需要加以固定。

924
00:40:14,760 --> 00:40:18,260
而唯一的辦法，真的，要解決它
將是，舉例來說，這條線，

925
00:40:18,260 --> 00:40:21,010
我們甚至沒有去，因為
程序崩潰得太快。

926
00:40:21,010 --> 00:40:26,170
但是，如果我們要解決這個問題，有什麼
效果確實做Ÿ等於x具有？

927
00:40:26,170 --> 00:40:30,010
那麼，它基本上是在點ÿ
任何值x指向。

928
00:40:30,010 --> 00:40:32,430
>> 因此，在尼克的故事，
或賓基的故事，無論是

929
00:40:32,430 --> 00:40:34,640
x和y分別為指向
白色塊的存儲器，

930
00:40:34,640 --> 00:40:38,300
這樣一來，最終，當
做明星Ÿ再次等於13，

931
00:40:38,300 --> 00:40:43,080
你最終將在13
適當的位置。

932
00:40:43,080 --> 00:40:47,640
因此，所有這些線路都完美
合法的，除了這一個，

933
00:40:47,640 --> 00:40:51,730
之前，當它發生
實際分配Ÿ一定的價值。

934
00:40:51,730 --> 00:40:54,290
>> 現在值得慶幸的是，你不
要通過推理全部

935
00:40:54,290 --> 00:40:56,560
這些類型的問題你自己。

936
00:40:56,560 --> 00:40:59,310
讓我繼續前進，開
在這裡一個終端窗口

937
00:40:59,310 --> 00:41:03,050
與開拓，就一下，
超級短節目的

938
00:41:03,050 --> 00:41:04,360
也就是那種毫無意義的。

939
00:41:04,360 --> 00:41:05,152
這是醜陋的。

940
00:41:05,152 --> 00:41:06,610
它沒有實現任何用處。

941
00:41:06,610 --> 00:41:10,180
但它確實證明問題
記憶，讓我們一起來看看。

942
00:41:10,180 --> 00:41:11,830
>> 主要的，超級簡單。

943
00:41:11,830 --> 00:41:14,830
這顯然是調用一個函數，
F，然後返回0。

944
00:41:14,830 --> 00:41:16,310
這是一種很難搞砸。

945
00:41:16,310 --> 00:41:18,540
所以，主要是相當不錯的，到目前為止。

946
00:41:18,540 --> 00:41:20,100
>> 所以f是有問題的。

947
00:41:20,100 --> 00:41:22,120
只是沒放多少
努力為它命名

948
00:41:22,120 --> 00:41:23,990
在這裡，以保持重心的代碼。

949
00:41:23,990 --> 00:41:25,740
f有兩行。

950
00:41:25,740 --> 00:41:27,610
讓我們看看現在怎麼回事。

951
00:41:27,610 --> 00:41:29,840
這樣一方面
這裡 - 並讓我

952
00:41:29,840 --> 00:41:32,680
與前此一致
example--一方面，

953
00:41:32,680 --> 00:41:35,830
左手側是
做什麼，用英語？

954
00:41:35,830 --> 00:41:36,493
它is--

955
00:41:36,493 --> 00:41:37,701
聽眾：創建一個指針。

956
00:41:37,701 --> 00:41:40,830
戴維·J·馬蘭：創建一個指針
為int，把它x即可。

957
00:41:40,830 --> 00:41:43,789
因此，它的創造者一個箱子
我一直畫在觸摸屏上。

958
00:41:43,789 --> 00:41:45,913
現在，對右手
當然一面，malloc的，

959
00:41:45,913 --> 00:41:47,420
被分配的內存塊。

960
00:41:47,420 --> 00:41:49,989
而只是要清楚，怎麼
多少內存是它明顯

961
00:41:49,989 --> 00:41:52,030
分配，如果你只是
種做數學題嗎？

962
00:41:52,030 --> 00:41:53,200

963
00:41:53,200 --> 00:41:54,040
>> 因此，它是40個字節。

964
00:41:54,040 --> 00:41:57,400
我知道，只是因為我知道的
整數，在CS50器具，至少

965
00:41:57,400 --> 00:41:58,060
是四個字節。

966
00:41:58,060 --> 00:41:59,610
所以，10次4 40。

967
00:41:59,610 --> 00:42:04,924
所以這是存儲一個x，地址
第一次出40的整數

968
00:42:04,924 --> 00:42:07,340
已分配的空間回來了，
背，背，背來。

969
00:42:07,340 --> 00:42:08,470
>> 而這正是重點對malloc的。

970
00:42:08,470 --> 00:42:11,261
它並不需要一點點內存
在這裡，有一點在這裡，在這裡一點點。

971
00:42:11,261 --> 00:42:14,220
它為您提供了一個內存塊，
連續地，從操作

972
00:42:14,220 --> 00:42:15,240
系統。

973
00:42:15,240 --> 00:42:18,500
>> 現在來談談這個，
點¯x支架10等於0？

974
00:42:18,500 --> 00:42:19,470
獨斷專行的代碼。

975
00:42:19,470 --> 00:42:21,100
它沒有實現任何用處。

976
00:42:21,100 --> 00:42:26,128
但有意思的是，
因為變量x支架10--？

977
00:42:26,128 --> 00:42:26,628
是嗎？

978
00:42:26,628 --> 00:42:27,912
>> 聽眾：[聽不清]？

979
00:42:27,912 --> 00:42:30,500
>> 戴維·J·馬蘭：X支架
10不必是空的。

980
00:42:30,500 --> 00:42:35,070
空的細節只有進場
用字符串，在字符串的結尾。

981
00:42:35,070 --> 00:42:36,700
但一個好的想法。

982
00:42:36,700 --> 00:42:39,615
>> 有多大這個數組，甚至
雖然我已經分配40個字節？

983
00:42:39,615 --> 00:42:42,560

984
00:42:42,560 --> 00:42:43,690
這是從0到9，對不對？

985
00:42:43,690 --> 00:42:45,120
這10個整數，總。

986
00:42:45,120 --> 00:42:48,790
40個字節，但是10個整數，
索引0到0。

987
00:42:48,790 --> 00:42:50,930
>> 那麼，什麼是是X支架10？

988
00:42:50,930 --> 00:42:53,090
它實際上是一些
未知的垃圾值。

989
00:42:53,090 --> 00:42:54,780
這是一個不屬於我的記憶。

990
00:42:54,780 --> 00:42:59,650
我不應該碰的
字節數41，42，43，44。

991
00:42:59,650 --> 00:43:01,420
我會稍微有點遠。

992
00:43:01,420 --> 00:43:04,490
>> 事實上，如果我運行這個
程序時，它很可能會崩潰。

993
00:43:04,490 --> 00:43:05,790
但有時，我們會得到幸運。

994
00:43:05,790 --> 00:43:07,706
所以，只是為了演示
this--坦率地說，

995
00:43:07,706 --> 00:43:11,000
你永遠不知道你之前
做它 - 讓我們來運行的。

996
00:43:11,000 --> 00:43:12,480
它實際上並沒有崩潰。

997
00:43:12,480 --> 00:43:15,032
>> 但是，如果我改變這一狀況，為
例如，要像千，

998
00:43:15,032 --> 00:43:16,740
使這真的
故意的，讓我們來看看

999
00:43:16,740 --> 00:43:18,710
如果我們可以得到它的崩潰這個時候。

1000
00:43:18,710 --> 00:43:20,070
好吧，它沒有崩潰。

1001
00:43:20,070 --> 00:43:22,600
如何約10萬？

1002
00:43:22,600 --> 00:43:25,000
讓我們來改造它，現在重新運行它。

1003
00:43:25,000 --> 00:43:25,500
行。

1004
00:43:25,500 --> 00:43:25,960
唷。

1005
00:43:25,960 --> 00:43:26,460
好吧。

1006
00:43:26,460 --> 00:43:29,090
因此很明顯，同樣，這些
內存段，可以這麼說，

1007
00:43:29,090 --> 00:43:32,660
是相當大的，所以我們可以
一次又一次得到幸運。

1008
00:43:32,660 --> 00:43:36,510
但最終，一旦你得到可笑
真正炎等在屏幕上，

1009
00:43:36,510 --> 00:43:39,120
你觸摸記憶真的，
真的不屬於你。

1010
00:43:39,120 --> 00:43:40,870
>> 但坦率地說，這些
種蟲子會

1011
00:43:40,870 --> 00:43:43,020
是難當
找出你自己的。

1012
00:43:43,020 --> 00:43:47,880
不過，值得慶幸的是，作為程序員，我們有
工具，使我們能夠做到這一點的我們。

1013
00:43:47,880 --> 00:43:50,140
因此，這是，也許是一
最醜的節目，

1014
00:43:50,140 --> 00:43:52,060
比gdb的輸出，甚至醜陋。

1015
00:43:52,060 --> 00:43:55,670
但它總有一條線或
2是超級有用。

1016
00:43:55,670 --> 00:44:00,310
>> Valgrind是一個程序，可以幫助
你沒有調試一個程序，本身

1017
00:44:00,310 --> 00:44:03,500
但是發現內存相關
的問題，特別是。

1018
00:44:03,500 --> 00:44:07,590
它會自動運行您的代碼
你看，至少兩件事情。

1019
00:44:07,590 --> 00:44:10,680
一，你做了什麼
偶然像觸摸記憶

1020
00:44:10,680 --> 00:44:11,980
那不屬於你？

1021
00:44:11,980 --> 00:44:13,590
這將幫助你找到這些情況。

1022
00:44:13,590 --> 00:44:15,710
>> 其二，它會幫助
你發現了一種叫做

1023
00:44:15,710 --> 00:44:19,270
內存洩露，我們有
全然不顧，天真，

1024
00:44:19,270 --> 00:44:21,380
一段時間和幸福地。

1025
00:44:21,380 --> 00:44:23,140
但事實證明，所有的
此時，每當

1026
00:44:23,140 --> 00:44:26,620
你所謂的getString在
我們這麼多的節目，

1027
00:44:26,620 --> 00:44:28,930
你問工作
系統記憶體，

1028
00:44:28,930 --> 00:44:32,070
但你有什麼回憶
有史以來給它

1029
00:44:32,070 --> 00:44:36,169
回來了，做unalloc，或
免費的，因為它的調用。

1030
00:44:36,169 --> 00:44:37,960
沒有，因為我們從來沒有
要求你這樣做。

1031
00:44:37,960 --> 00:44:41,250
>> 但所有這一次，程序
你一直在寫C語言

1032
00:44:41,250 --> 00:44:43,800
已經洩漏內存，
要求經營

1033
00:44:43,800 --> 00:44:46,190
系統越來越
存儲字符串和諸如此類的東西，

1034
00:44:46,190 --> 00:44:47,870
但從來沒有遞了回去。

1035
00:44:47,870 --> 00:44:50,080
而現在，這是一個有點
à簡單化的，

1036
00:44:50,080 --> 00:44:53,550
但如果你曾經運行在Mac或
你的電腦很長一段時間，開

1037
00:44:53,550 --> 00:44:55,790
大量的節目，
也許關閉程序，

1038
00:44:55,790 --> 00:44:57,795
而即使你的
電腦沒有死機，

1039
00:44:57,795 --> 00:45:01,690
它變得這麼慢得多，
好像真的

1040
00:45:01,690 --> 00:45:04,290
使用大量的內存或
資源，即使，

1041
00:45:04,290 --> 00:45:06,070
如果你不連
觸摸鍵盤，

1042
00:45:06,070 --> 00:45:10,430
可能be--但不always--能
是因為你正在運行的程序

1043
00:45:10,430 --> 00:45:11,920
有自己的內存洩漏。

1044
00:45:11,920 --> 00:45:15,645
他們不斷地問操作系統的更多，
更多的內存，但忘記了它，

1045
00:45:15,645 --> 00:45:18,470
實際上並不使用它，但
因此，服用內存離開

1046
00:45:18,470 --> 00:45:20,500
從可能希望它的其他程序。

1047
00:45:20,500 --> 00:45:23,940
所以這是一個常見的解釋。

1048
00:45:23,940 --> 00:45:25,940
現在，這裡的地方Valgrind的公司
輸出是完全

1049
00:45:25,940 --> 00:45:29,290
殘暴的那些少
更舒適的一致好評。

1050
00:45:29,290 --> 00:45:32,690
但有趣
東西是正確的在這裡。

1051
00:45:32,690 --> 00:45:37,060
它告訴我一個無效的寫
大小4發生這個程序中，

1052
00:45:37,060 --> 00:45:40,640
特別是，在memory.c的第21行。

1053
00:45:40,640 --> 00:45:45,450
>> 如果我去到第21行，嗯，的確有
是大小為4的無效寫。

1054
00:45:45,450 --> 00:45:46,250
為什麼大小4？

1055
00:45:46,250 --> 00:45:49,500
那麼，這number--它
可能是anything--是一個int。

1056
00:45:49,500 --> 00:45:50,450
因此，這四個字節。

1057
00:45:50,450 --> 00:45:52,550
所以，我把四個字節
他們不屬於。

1058
00:45:52,550 --> 00:45:55,080
這就是Valgrind的
實際上是告訴我。

1059
00:45:55,080 --> 00:45:57,600
此外，它也將
告訴我，因為我們將看到，

1060
00:45:57,600 --> 00:46:01,490
當你運行這個在未來的PSET，如果和
當你的內存洩漏，這確實是

1061
00:46:01,490 --> 00:46:05,300
我有，因為我打過電話
malloc的，但我並沒有實際

1062
00:46:05,300 --> 00:46:08,010
叫，在這種情況下，自由
我們最終會看到

1063
00:46:08,010 --> 00:46:09,830
是的malloc相反。

1064
00:46:09,830 --> 00:46:10,860

1065
00:46:10,860 --> 00:46:12,930
>> 所以，現在，我認為，最後一個例子。

1066
00:46:12,930 --> 00:46:14,050

1067
00:46:14,050 --> 00:46:16,690
所以這一塊是一個有點多
晦澀難懂，但它也許是

1068
00:46:16,690 --> 00:46:19,180
最大的原因
小心內存，

1069
00:46:19,180 --> 00:46:24,490
究其原因，很多節目
和/或Web服務器，甚至到今天，

1070
00:46:24,490 --> 00:46:28,200
被接管壞人的地方
在互聯網上誰是莫名其妙

1071
00:46:28,200 --> 00:46:33,390
發送偽造的數據包到服務器
試圖破壞您的賬戶，

1072
00:46:33,390 --> 00:46:36,420
或者把你的數據，或只是
一般拿過來一台機器。

1073
00:46:36,420 --> 00:46:38,910
緩衝區溢出，隨著
顧名思義，手段

1074
00:46:38,910 --> 00:46:40,740
不溢出為int，而是一個緩衝區。

1075
00:46:40,740 --> 00:46:43,490
和緩衝僅僅是一個奇特的方式
的說這是一串記憶。

1076
00:46:43,490 --> 00:46:46,710
>> 事實上，我叫一個字符串
前緩衝區，而不​​是S，。

1077
00:46:46,710 --> 00:46:49,234
因為如果它是一個緩衝，
像在YouTube的意義，

1078
00:46:49,234 --> 00:46:52,400
或者您正在觀看的視頻的任何時間，
你可能已經看到這個詞的緩衝，

1079
00:46:52,400 --> 00:46:53,040
點，點，點。

1080
00:46:53,040 --> 00:46:54,240
這是令人難以置信的煩人。

1081
00:46:54,240 --> 00:46:55,990
而這僅僅意味著
您的視頻播放器

1082
00:46:55,990 --> 00:46:58,710
試圖下載大量
字節，大量的字節

1083
00:46:58,710 --> 00:47:00,170
從網上的視頻。

1084
00:47:00,170 --> 00:47:02,920
但它是緩慢的，所以它的嘗試
下載了一堆人

1085
00:47:02,920 --> 00:47:06,430
填充緩衝器，一個容器，從而使
你有足夠的字節，它可以再

1086
00:47:06,430 --> 00:47:09,174
告訴你的視頻，
不停頓不斷。

1087
00:47:09,174 --> 00:47:11,340
但事實證明，你可以
有一個緩衝，以這個大。

1088
00:47:11,340 --> 00:47:15,710
但盡量把這麼多數據
微博，很糟糕的事情可能發生。

1089
00:47:15,710 --> 00:47:22,780
因此，例如，讓我們來看看
一個例子的這個最終預告片。

1090
00:47:22,780 --> 00:47:24,720
這是另一種方案
即，乍一看，

1091
00:47:24,720 --> 00:47:26,540
什麼都不做超級有用。

1092
00:47:26,540 --> 00:47:29,590
它有一個主要功能
調用該函數f。

1093
00:47:29,590 --> 00:47:36,640
而且函數f，在這裡，有
一個char數組，稱為大小12℃，。

1094
00:47:36,640 --> 00:47:39,340
然後它用這個
新的函數調用strncpy（）函數。

1095
00:47:39,340 --> 00:47:40,430

1096
00:47:40,430 --> 00:47:45,190
>> 事實證明，這種簡單
代碼簡單的線條，只是兩條線，

1097
00:47:45,190 --> 00:47:49,130
我們已經做了我的整個程序，
因此，我的整個電腦，

1098
00:47:49,130 --> 00:47:54,000
我的用戶帳戶，我的硬盤
開車可能受到任何人

1099
00:47:54,000 --> 00:47:58,170
誰知道，是不夠好，運行
這個節目帶有一定的命令行

1100
00:47:58,170 --> 00:47:58,900
的說法。

1101
00:47:58,900 --> 00:48:03,400
換句話說，如果這個壞傢伙
通過鍵入把argvargv [1]內

1102
00:48:03,400 --> 00:48:08,750
在鍵盤非常特製
字符串，而不是ABC，123，但本質上，

1103
00:48:08,750 --> 00:48:15,180
代表可執行的二進制符號
代碼，一個程序，他或她寫道：

1104
00:48:15,180 --> 00:48:19,190
用這種簡單的方案，這是
代表的數以千計的節目

1105
00:48:19,190 --> 00:48:23,610
這同樣是脆弱的，敢說，
他或她可以最終刪除所有

1106
00:48:23,610 --> 00:48:26,680
在我的硬盤驅動器中的文件，得到了
閃爍提示，以便他或她可以

1107
00:48:26,680 --> 00:48:30,170
自己輸入命令，
電子郵件中的所有文件到自己。

1108
00:48:30,170 --> 00:48:34,660
什麼我可以做的，他
或她可以使用此代碼做。

1109
00:48:34,660 --> 00:48:36,575
>> 我們不太解決這事。

1110
00:48:36,575 --> 00:48:38,700
而事實上，這將
涉及小圖片

1111
00:48:38,700 --> 00:48:41,470
這樣，我們將很快到來
理解就更好了。

1112
00:48:41,470 --> 00:48:44,480
但是今天，讓我們結束
什麼是有希望稍微

1113
00:48:44,480 --> 00:48:48,360
可以理解的XKCD笑話，
直到我們重新開始下一次。

1114
00:48:48,360 --> 00:48:51,100

1115
00:48:51,100 --> 00:48:51,600
好吧。

1116
00:48:51,600 --> 00:48:53,446
星期三見。

1117
00:48:53,446 --> 00:48:54,754
>> [音樂播放]

1118
00:48:54,754 --> 00:48:57,790
>> 演講嘉賓：現在，深
思想，通過Daven法納姆。

1119
00:48:57,790 --> 00:49:00,890

1120
00:49:00,890 --> 00:49:04,770
記憶就像是跳進了一堆
金黃的樹葉在週日下午。

1121
00:49:04,770 --> 00:49:09,000
風拂過，你折騰
hair--哦，我懷念的日子when--

1122
00:49:09,000 --> 00:49:11,100

1123
00:49:11,100 --> 00:49:12,650
>> [笑]

1124
00:49:12,650 --> 00:49:13,750