1
00:00:00,000 --> 00:00:04,875

2
00:00:04,875 --> 00:00:05,750
ANDI鵬：好的。

3
00:00:05,750 --> 00:00:08,240
歡迎來到第四個星期

4
00:00:08,240 --> 00:00:10,280
這是一個美麗的一天
在這裡紐黑文

5
00:00:10,280 --> 00:00:14,370
所以我真的覺得疏
孩子散射的

6
00:00:14,370 --> 00:00:17,530
今天加入了我部分，謝謝。

7
00:00:17,530 --> 00:00:21,517
>> 所以很快，就在我們
開始，今天的議程。

8
00:00:21,517 --> 00:00:23,600
我們將走過去一
幾句簡短的公告。

9
00:00:23,600 --> 00:00:26,224
我們有一個非常古怪的時間表
即將在接下來的兩個星期

10
00:00:26,224 --> 00:00:28,010
左右，所以我們要說明一下。

11
00:00:28,010 --> 00:00:30,410
其次，我知道，
大家最喜歡的topic--

12
00:00:30,410 --> 00:00:33,572
我敢肯定，這融化你的心
講座過程中，不用擔心，

13
00:00:33,572 --> 00:00:34,780
那種我仍然不明白這一點。

14
00:00:34,780 --> 00:00:35,444
它的罰款。

15
00:00:35,444 --> 00:00:36,110
這是一個笑話。

16
00:00:36,110 --> 00:00:37,450
其實我明白這一點。

17
00:00:37,450 --> 00:00:40,234
但我會確保
你們得到它了。

18
00:00:40,234 --> 00:00:42,400
所以，我們要花費
真的，真的很好量

19
00:00:42,400 --> 00:00:44,020
時間今天談論的指針。

20
00:00:44,020 --> 00:00:47,012
正如你所看到的，糖果的
今天的談話是巨大的。

21
00:00:47,012 --> 00:00:49,220
我們真的要保持
that--是啊，這是正確的。

22
00:00:49,220 --> 00:00:49,890
繼續服用的糖果。

23
00:00:49,890 --> 00:00:51,556
我打算現在通過他們周圍。

24
00:00:51,556 --> 00:00:55,150

25
00:00:55,150 --> 00:00:56,510
無後顧之憂。

26
00:00:56,510 --> 00:00:59,570
我們要真正嘗試
留人的血糖

27
00:00:59,570 --> 00:01:04,390
，因為大腦會燒
當今一些氧氣，因為指針

28
00:01:04,390 --> 00:01:05,652
真的，真的很難。

29
00:01:05,652 --> 00:01:08,360
然後我們要談
內存管理哪一種是

30
00:01:08,360 --> 00:01:09,487
在相同的領域。

31
00:01:09,487 --> 00:01:11,570
而且我們要動
上重定向和文件

32
00:01:11,570 --> 00:01:15,297
I / O這只是語法，不錯
事情我們應該談談。

33
00:01:15,297 --> 00:01:17,130
然後最後，我
要再次嘗試

34
00:01:17,130 --> 00:01:19,070
離開像10，15分鐘pset4。

35
00:01:19,070 --> 00:01:21,820
在幾天之內這是因為所以我們
那種將真正給你

36
00:01:21,820 --> 00:01:24,850
如果你一些有用的提示
已經開始了這一點。

37
00:01:24,850 --> 00:01:26,141
酷。

38
00:01:26,141 --> 00:01:26,640
確定。

39
00:01:26,640 --> 00:01:30,710
因此，一些公告
對於這個即將到來的一周。

40
00:01:30,710 --> 00:01:31,805
評級。

41
00:01:31,805 --> 00:01:33,930
我真的不知道
這一點你們有多少人

42
00:01:33,930 --> 00:01:37,180
傢伙居然在我
section--你行嗎？

43
00:01:37,180 --> 00:01:38,020
確定。

44
00:01:38,020 --> 00:01:40,150
但是，對於那些你
誰在我的部分，

45
00:01:40,150 --> 00:01:42,180
只是一對夫婦的批語分級。

46
00:01:42,180 --> 00:01:44,899
>> 評論首先，切實抓緊抓好。

47
00:01:44,899 --> 00:01:47,940
你們當中誰不評論，你
知道你是誰，因為你可能

48
00:01:47,940 --> 00:01:50,610
得到這個星期dinged一些造型加分。

49
00:01:50,610 --> 00:01:53,920
只要確保在所有的
程序添加一些評論。

50
00:01:53,920 --> 00:01:56,960
真的，風格是很容易
得到正確的點作為一個範圍。

51
00:01:56,960 --> 00:01:58,710
所以對我們來說，只要
確保你是那種

52
00:01:58,710 --> 00:02:03,770
的增加在所有的簡要說明
你對你在做什麼項目。

53
00:02:03,770 --> 00:02:09,190
>> Secondly--這是一個巨大的問題
很多助教過去week--

54
00:02:09,190 --> 00:02:12,020
所以一定要確保你上傳到
正確的文件夾正確

55
00:02:12,020 --> 00:02:13,370
命名方案。

56
00:02:13,370 --> 00:02:16,820
為什麼我們要求這樣做的原因是
因為我們在分級過程中，

57
00:02:16,820 --> 00:02:20,820
實際上上運行腳本您
自動下載代碼

58
00:02:20,820 --> 00:02:24,780
所有的pset中，運行
對所有的人都正確性測試，

59
00:02:24,780 --> 00:02:27,550
然後上傳你的分數
直接進入成績冊。

60
00:02:27,550 --> 00:02:32,140
但是，在任何時候，如果
正確命名你的程序，

61
00:02:32,140 --> 00:02:34,510
這螺絲了整個
節目給大家。

62
00:02:34,510 --> 00:02:37,280
>> 因此，合法，
這個美麗的腳本

63
00:02:37,280 --> 00:02:40,260
我們已經寫了呢
這一切對我們來說，完全

64
00:02:40,260 --> 00:02:43,070
崩潰，如果您還沒有
你的程序正確命名。

65
00:02:43,070 --> 00:02:46,020
因此，只要上傳到正確的
文件夾，讓他們正確命名，

66
00:02:46,020 --> 00:02:47,372
然後生活是美好的。

67
00:02:47,372 --> 00:02:49,080
我明白你的pset回來
以你們前面

68
00:02:49,080 --> 00:02:51,110
因為我很快得到他們品位。

69
00:02:51,110 --> 00:02:52,461
是啊。

70
00:02:52,461 --> 00:02:52,960
確定。

71
00:02:52,960 --> 00:02:57,870
同時，我們要談
about--耶魯大學有一個非常，非常

72
00:02:57,870 --> 00:02:59,950
古怪的時間表在今後兩個星期。

73
00:02:59,950 --> 00:03:02,460
因此，那些你們的
哈佛，這並不適用。

74
00:03:02,460 --> 00:03:05,585
但對於我們可愛的孩子們在耶魯大學，我們有
所謂秋季break--抱歉，

75
00:03:05,585 --> 00:03:08,430
Harvard--我們有
5天關閉學校。

76
00:03:08,430 --> 00:03:12,270
雖然這是可愛的，它
那種打亂了我們的節奏PSET

77
00:03:12,270 --> 00:03:14,104
因為pset中都將於週四，週五。

78
00:03:14,104 --> 00:03:16,020
所以，如果我們不在這裡
週四，週五，我們

79
00:03:16,020 --> 00:03:18,640
不能為你們工作
由於週四，週五。

80
00:03:18,640 --> 00:03:23,832
>> 所以，我們要做的is--我們做什麼
像99％確定這是發生了什麼事，

81
00:03:23,832 --> 00:03:25,540
可能有一些
改變，但我認為這是

82
00:03:25,540 --> 00:03:28,460
subtle--是我們要
have--這個星期是正常的。

83
00:03:28,460 --> 00:03:32,130
因此，我們有我們的部分
週二其次是辦公時間

84
00:03:32,130 --> 00:03:35,190
整週的其餘部分
然後pset4是由於上週五。

85
00:03:35,190 --> 00:03:38,180
然後，你們都知道，作為
上週我提醒你們，

86
00:03:38,180 --> 00:03:41,700
我們有我們的測驗0
週三上來。

87
00:03:41,700 --> 00:03:44,400
>> 因此，作為學生自己，
我知道，你們中幾乎沒有

88
00:03:44,400 --> 00:03:49,110
球員將實際工作
您的測驗之前pset5兩天。

89
00:03:49,110 --> 00:03:51,110
所以，我們要什麼
可能最終做的是，

90
00:03:51,110 --> 00:03:54,840
週一晚上，我們要去
實際上，從5:30到7:00，

91
00:03:54,840 --> 00:03:59,970
有一個簡要的回顧
會議議題涵蓋。

92
00:03:59,970 --> 00:04:02,040
如果它是一個不明確
審查會議或一個Q＆A。

93
00:04:02,040 --> 00:04:04,650
這將是某種形式的審查
形式，我們將討論

94
00:04:04,650 --> 00:04:06,640
有關為你們的一些話題。

95
00:04:06,640 --> 00:04:09,886
>> 然後週一和週二晚
這一周，從8:00到11:00，

96
00:04:09,886 --> 00:04:11,260
我們將有辦公時間。

97
00:04:11,260 --> 00:04:14,500
這些辦公時間將最
有可能是更多剛進來，

98
00:04:14,500 --> 00:04:17,564
問助教你的問題有關
你感到困惑的任何概念，

99
00:04:17,564 --> 00:04:20,480
他們就會種下去了你
和審查概念測驗。

100
00:04:20,480 --> 00:04:22,920
測驗0，如果你在
週一，週三部分，

101
00:04:22,920 --> 00:04:26,480
將週三的中
在課堂分類 - 週三。

102
00:04:26,480 --> 00:04:29,530
然後，如果你在
週二，週四部分，

103
00:04:29,530 --> 00:04:32,577
也將是週四在課堂上。

104
00:04:32,577 --> 00:04:34,410
你真的無法選擇
你去哪一個。

105
00:04:34,410 --> 00:04:35,640
如果你是一個週一，週三，
你必須去到星期三。

106
00:04:35,640 --> 00:04:38,056
如果你在週二，週四
你必須去到週四。

107
00:04:38,056 --> 00:04:42,277
但後​​來那天晚上，
我們可愛的工作人員，將

108
00:04:42,277 --> 00:04:45,360
有一個巨大的測驗中分級方
我們將讓你的分數還給你

109
00:04:45,360 --> 00:04:46,190
那一夜。

110
00:04:46,190 --> 00:04:46,900
在什麼時候？

111
00:04:46,900 --> 00:04:51,190
目前還不清楚，誰知道，但它會
回來給你24小時內

112
00:04:51,190 --> 00:04:53,700
所以，你們希望
有一些反饋，在週五。

113
00:04:53,700 --> 00:04:55,870
>> 然後我們有一個非常古怪的一周。

114
00:04:55,870 --> 00:05:00,330
所以pset5是其一
今年最困難的pset。

115
00:05:00,330 --> 00:05:03,370
所以，對不起你們。

116
00:05:03,370 --> 00:05:06,520
我們要去嘗試
做的是我們要擁有

117
00:05:06,520 --> 00:05:08,380
一些實際的支持，那個週末。

118
00:05:08,380 --> 00:05:12,970
因為，正如你們所看到的，
PSET是由於秋天休息前。

119
00:05:12,970 --> 00:05:16,760
我們沒有支持
你們在秋天休息

120
00:05:16,760 --> 00:05:18,897
所以我們真的有種
希望這句話的，

121
00:05:18,897 --> 00:05:21,230
讓我們在以得到這個，
下面就讓我們真的，真的很難

122
00:05:21,230 --> 00:05:25,380
這接下來的兩個星期，得到這個測驗
並添加這兩個pset中有做

123
00:05:25,380 --> 00:05:29,650
然後你們有一個不錯的放鬆
7天不假思索CS。

124
00:05:29,650 --> 00:05:33,750
>> 因此，為了使該至
發生，我們可能

125
00:05:33,750 --> 00:05:36,870
要動我的第
至週日下午。

126
00:05:36,870 --> 00:05:39,070
這將被拍攝下來，所以沒有
煩惱，如果你不能來。

127
00:05:39,070 --> 00:05:41,595
但網上拍戲會
在那裡，訪問

128
00:05:41,595 --> 00:05:47,630
讓你們有星期日，
週一，週二，上班pset5。

129
00:05:47,630 --> 00:05:50,205
然後它的秋天
打破，沒有CS，然後

130
00:05:50,205 --> 00:05:51,830
我們回來，它在研磨回來。

131
00:05:51,830 --> 00:05:54,926
>> 但是，這將是一個
可愛的週秋季休息

132
00:05:54,926 --> 00:05:58,050
我們真的希望把它作為壓力
免費提供給大家盡可能哪些

133
00:05:58,050 --> 00:06:02,620
所以，我們提出的PSET是由於
前秋突破，而不是之後。

134
00:06:02,620 --> 00:06:07,601
因為it's--我的意思是，我有種感覺
喜歡它違背了目的

135
00:06:07,601 --> 00:06:10,850
秋天休息，如果有以後的截止日期
在秋天休息反正不支持。

136
00:06:10,850 --> 00:06:14,670
所以這是rather--我想
我們寧願專注於現在。

137
00:06:14,670 --> 00:06:16,950
有沒有人有問題
有關日程安排？

138
00:06:16,950 --> 00:06:17,830
什麼困惑？

139
00:06:17,830 --> 00:06:18,330
是啊。

140
00:06:18,330 --> 00:06:20,944
>> 聽眾：我們仍然有
在21日的演講？

141
00:06:20,944 --> 00:06:21,610
ANDI彭：是的。

142
00:06:21,610 --> 00:06:26,421
因此，21號，這裡將是
講座是活的哈佛大學。

143
00:06:26,421 --> 00:06:29,170
我不知道大衛是拍攝
它，如果他實際上講學，

144
00:06:29,170 --> 00:06:32,430
但它的將是可用
在線為你們訪問。

145
00:06:32,430 --> 00:06:35,510
因此，只要確保你能開一個
小時某處在秋天休息

146
00:06:35,510 --> 00:06:39,375
所以你們可以趕上
上的演講。

147
00:06:39,375 --> 00:06:39,875
是嗎？

148
00:06:39,875 --> 00:06:40,300
>> 聽眾：是的。

149
00:06:40,300 --> 00:06:40,422
抱歉。

150
00:06:40,422 --> 00:06:41,280
我這裡couple--

151
00:06:41,280 --> 00:06:41,640
>> ANDI彭：不用擔心。

152
00:06:41,640 --> 00:06:42,556
在這裡，需要一些糖果。

153
00:06:42,556 --> 00:06:45,350

154
00:06:45,350 --> 00:06:47,800
>> 聽眾：嘿，我抓住了這一點。

155
00:06:47,800 --> 00:06:53,869
因此，只要回顧一下，不是明天，但
之後那個星期三，我們有一個小測驗。

156
00:06:53,869 --> 00:06:54,660
ANDI彭：正確。

157
00:06:54,660 --> 00:06:59,207
聽眾：而且它會be--
什麼是問答的格式？

158
00:06:59,207 --> 00:06:59,790
ANDI彭：哦。

159
00:06:59,790 --> 00:07:03,870
因此，我們將發送一封電子郵件，
涵蓋了深入的一切了。

160
00:07:03,870 --> 00:07:06,590
但是，實際上，它只是覆蓋
已經涵蓋了基本內容

161
00:07:06,590 --> 00:07:09,042
在第一學期的一半。

162
00:07:09,042 --> 00:07:12,250
我們必須審查會議和問題
和答案所以不用擔心這一點。

163
00:07:12,250 --> 00:07:14,107
但是，我們會去了這一點。

164
00:07:14,107 --> 00:07:16,940
聽眾：是否將是，我們
把我們的電腦和代碼那裡 - 

165
00:07:16,940 --> 00:07:17,140
ANDI彭：沒有。

166
00:07:17,140 --> 00:07:20,130
這將是你們寫
並回答用手問題。

167
00:07:20,130 --> 00:07:21,160
>> 聽眾：哦。

168
00:07:21,160 --> 00:07:23,160
>> ANDI彭：所以我們會給
從實踐和東西

169
00:07:23,160 --> 00:07:26,420
所以你們可能想也許去
回重寫馬里奧的手剛

170
00:07:26,420 --> 00:07:28,100
要確保你們有
如何做到這一點的想法。

171
00:07:28,100 --> 00:07:29,933
因為有時當
您手工編寫您

172
00:07:29,933 --> 00:07:32,656
忘了分號和東西
那是非常糟糕的。

173
00:07:32,656 --> 00:07:34,156
聽眾：那不[聽不清]？

174
00:07:34,156 --> 00:07:38,290
就像，你要
在your--分號

175
00:07:38,290 --> 00:07:40,270
>> ANDI彭：是的，沒有。

176
00:07:40,270 --> 00:07:43,170
我們將討論更深入
關於如何測驗佈局

177
00:07:43,170 --> 00:07:44,550
以及我們如何打算檔次。

178
00:07:44,550 --> 00:07:47,425
但實際上，只知道
一般格式將是你

179
00:07:47,425 --> 00:07:49,930
人要么解釋代碼 - 
回答的基本問題。

180
00:07:49,930 --> 00:07:51,370
如果我問你，什麼是庫？

181
00:07:51,370 --> 00:07:53,450
你們應該知道什麼是
圖書館不和寫下來。

182
00:07:53,450 --> 00:07:56,283
或者，我可以說，編寫一個程序，
打印Hello World到屏幕上。

183
00:07:56,283 --> 00:08:01,140
你們會寫，INT主要
無效的printf的Hello World分號。

184
00:08:01,140 --> 00:08:01,908
是啊。

185
00:08:01,908 --> 00:08:04,398
>> 聽眾：所以它不會
到任何地方[聽不清]

186
00:08:04,398 --> 00:08:05,900
問題的難易度來確定？

187
00:08:05,900 --> 00:08:06,170
>> ANDI彭：沒有。

188
00:08:06,170 --> 00:08:06,380
第

189
00:08:06,380 --> 00:08:07,046
我們won't--耶。

190
00:08:07,046 --> 00:08:10,030
寫的全部
比賽15在20分鐘內走了。

191
00:08:10,030 --> 00:08:12,120
沒有，它不會是。

192
00:08:12,120 --> 00:08:12,801
第

193
00:08:12,801 --> 00:08:13,342
聽眾：OK。

194
00:08:13,342 --> 00:08:15,326
所以這是星期三。

195
00:08:15,326 --> 00:08:19,017
在那一周，我們還
已在最困難的問題設置？

196
00:08:19,017 --> 00:08:19,600
ANDI彭：沒有。

197
00:08:19,600 --> 00:08:22,970
所以，問題設置到期
秋天休息的前一天。

198
00:08:22,970 --> 00:08:25,690
該schedule--電子郵件
實際上發出

199
00:08:25,690 --> 00:08:27,232
11分鐘前就了這一切。

200
00:08:27,232 --> 00:08:28,689
所以，你們只是檢查你的電子郵件。

201
00:08:28,689 --> 00:08:29,430
它會在那裡。

202
00:08:29,430 --> 00:08:30,060
是啊。

203
00:08:30,060 --> 00:08:31,701
無後顧之憂。

204
00:08:31,701 --> 00:08:32,200
酷。

205
00:08:32,200 --> 00:08:34,900

206
00:08:34,900 --> 00:08:38,900
>> 對於任何常規問題
公告顯示，分級，測驗，

207
00:08:38,900 --> 00:08:41,659
之前，我們深入到
指針這將消耗

208
00:08:41,659 --> 00:08:45,060
我們的大多數時間段今天？

209
00:08:45,060 --> 00:08:47,030
酷。

210
00:08:47,030 --> 00:08:47,530
好的。

211
00:08:47,530 --> 00:08:50,905
因此，沒有你們都看這個lovely--
我不知道他們所說的。

212
00:08:50,905 --> 00:08:53,490
事情那裡的粘土動畫
自爆本身，因為它

213
00:08:53,490 --> 00:08:54,820
沒有正確使用指針。

214
00:08:54,820 --> 00:08:57,629
那麼，你的程序將
可能打擊本身，如果你

215
00:08:57,629 --> 00:08:59,170
不使用指針正常以及。

216
00:08:59,170 --> 00:09:01,250
因此，我們要作
確保不會發生。

217
00:09:01,250 --> 00:09:04,810
>> 今天我們要
做一些指針樂趣。

218
00:09:04,810 --> 00:09:08,970
我會走過去的事情
那樣順利，因為我認為

219
00:09:08,970 --> 00:09:10,790
有可能在一個小的時間框架。

220
00:09:10,790 --> 00:09:14,592
但是，以支付只是這麼多
我真的希望你們，

221
00:09:14,592 --> 00:09:17,300
如果你不明白的東西，
不只是讓我繼續下去。

222
00:09:17,300 --> 00:09:18,580
因為如果你不這樣做
明白了點什麼，

223
00:09:18,580 --> 00:09:21,329
你可能不會
弄懂之後，我說。

224
00:09:21,329 --> 00:09:23,310
所以，請阻止我，並問一個問題。

225
00:09:23,310 --> 00:09:25,380
因為它都挺
的雪球在一起。

226
00:09:25,380 --> 00:09:27,800
像，三分球領先進入
內存領先進入其他的事情。

227
00:09:27,800 --> 00:09:31,710
所以，如果你不明白三分球，
阻止我，我們會弄明白

228
00:09:31,710 --> 00:09:35,070
生活也會被罰款。

229
00:09:35,070 --> 00:09:35,680
>> 酷。

230
00:09:35,680 --> 00:09:39,050
那麼有多少你們的講座，
當大衛提到的三分球，

231
00:09:39,050 --> 00:09:42,050
那種你的大腦變成果凍？

232
00:09:42,050 --> 00:09:42,550
是啊。

233
00:09:42,550 --> 00:09:44,190
好。

234
00:09:44,190 --> 00:09:46,900
我們將嘗試
脫果凍你的大腦今天。

235
00:09:46,900 --> 00:09:50,300
我們要真正系統
經過究竟一個指針，

236
00:09:50,300 --> 00:09:52,530
它做什麼，以及我們如何使用它們。

237
00:09:52,530 --> 00:09:56,620
>> 因此，所有pointers--所以
通常與變量

238
00:09:56,620 --> 00:10:00,920
我們一直在使用的編碼，如
變量，如整數或字符串

239
00:10:00,920 --> 00:10:04,790
或浮筒，他們都基本上
分配給它們的值

240
00:10:04,790 --> 00:10:06,870
以及一個地址
指向該值。

241
00:10:06,870 --> 00:10:08,895
所以我現在要得出這樣的權利。

242
00:10:08,895 --> 00:10:14,270

243
00:10:14,270 --> 00:10:16,140
我們幾乎沒有粉筆，但沒關係。

244
00:10:16,140 --> 00:10:25,550
>> 因此，例如，通常
我們已經一路

245
00:10:25,550 --> 00:10:30,860
在使用變量是我們創造的
int類型的變量的名字，讓我們

246
00:10:30,860 --> 00:10:31,360
只是說。

247
00:10:31,360 --> 00:10:37,360
所以在這裡我們有INT x和我們
初始化的int值50。

248
00:10:37,360 --> 00:10:42,390
因此，這裡的內存這一塊我們
電腦，我們已經存儲了號碼為50。

249
00:10:42,390 --> 00:10:46,170
那麼，三分球開始發揮作用是
您的計算機itself--一樣，在這裡，

250
00:10:46,170 --> 00:10:48,880
在物理硬盤驅動器
在我的computer--的RAM中

251
00:10:48,880 --> 00:10:51,147
它不僅具有存儲有限數量。

252
00:10:51,147 --> 00:10:53,980
你不能只讓存儲的東西
上面的東西對事物的頂部

253
00:10:53,980 --> 00:10:54,990
並讓他們所有。

254
00:10:54,990 --> 00:10:59,570
>> 所以這樣我們動態地分配
存儲器能夠存儲我們想要的

255
00:10:59,570 --> 00:11:03,150
並對其進行訪問，是由具有指針。

256
00:11:03,150 --> 00:11:06,210
所以，想像一下在你的記憶空間，正確的。

257
00:11:06,210 --> 00:11:10,420
如果是這樣的RAM您
計算機，你有這些小位

258
00:11:10,420 --> 00:11:14,540
或嵌段或存儲器以字節
which--這些都只是小

259
00:11:14,540 --> 00:11:18,120
已經分配出去的塊
硬盤驅動器您的計算機或RAM，

260
00:11:18,120 --> 00:11:21,950
並在每個區塊的
你可以存儲不同的東西。

261
00:11:21,950 --> 00:11:26,990
因此，例如，1
陣列在本實施例

262
00:11:26,990 --> 00:11:29,984
這裡是一個字節是
由8比特組成。

263
00:11:29,984 --> 00:11:32,900
數的變化取決於在
您的計算機的操作系統。

264
00:11:32,900 --> 00:11:35,942
例如，你們有多少人有
聽說32位與64位操作系統

265
00:11:35,942 --> 00:11:36,441
系統？

266
00:11:36,441 --> 00:11:37,070
沒錯。

267
00:11:37,070 --> 00:11:38,860
>> 因此，所有這說
是，memory--

268
00:11:38,860 --> 00:11:42,420
的方式，你的電腦
管理存儲器是不同的。

269
00:11:42,420 --> 00:11:45,370
這就是為什麼它是真的
重要的是了解

270
00:11:45,370 --> 00:11:49,450
為什麼內存本身的功能，而
不是講究數量。

271
00:11:49,450 --> 00:11:52,400
所以，我們真的不關心
怎麼這大陣

272
00:11:52,400 --> 00:11:55,710
是，我們只需要關心
有多大我們需要一個int是，

273
00:11:55,710 --> 00:11:58,350
有多大我們需要一個字符串
是，多大是一個指針？

274
00:11:58,350 --> 00:12:00,630

275
00:12:00,630 --> 00:12:01,130
確定。

276
00:12:01,130 --> 00:12:03,690
因此，這將是一個很大
沉重的，密集的信息。

277
00:12:03,690 --> 00:12:07,005
我想給你們一個
夫婦漫畫救濟的時刻在這裡。

278
00:12:07,005 --> 00:12:09,130
你們應該都可以
現在明白這一點。

279
00:12:09,130 --> 00:12:12,550
因為我們知道，
指針地址，

280
00:12:12,550 --> 00:12:14,480
而這些都是由不同的變量。

281
00:12:14,480 --> 00:12:14,980
確定。

282
00:12:14,980 --> 00:12:15,610
酷。

283
00:12:15,610 --> 00:12:17,065
CS笑話是最好的，是嗎？

284
00:12:17,065 --> 00:12:19,800

285
00:12:19,800 --> 00:12:23,450
>> 所以，我們走的路
有關創建一個指針

286
00:12:23,450 --> 00:12:25,750
語法是一個非常特定的排序。

287
00:12:25,750 --> 00:12:27,870
與創建任何
變量的類型，它的

288
00:12:27,870 --> 00:12:30,240
將是一個特定
語法我們用它來創建它。

289
00:12:30,240 --> 00:12:34,830
因此聲明的任何指針時，
指針只是essentially--

290
00:12:34,830 --> 00:12:37,040
我認為重要的
指針的一部分，是

291
00:12:37,040 --> 00:12:41,650
而這一個變量
兩者的值和地址，

292
00:12:41,650 --> 00:12:44,100
一個指針是一個地址。

293
00:12:44,100 --> 00:12:45,740
它的值是一個地址。

294
00:12:45,740 --> 00:12:48,120
所以這是存儲地址
在不同的地址。

295
00:12:48,120 --> 00:12:49,120
如果讓任何意義。

296
00:12:49,120 --> 00:12:52,390
我們一起去了這個更詳細，
但是這是一般形式

297
00:12:52,390 --> 00:12:54,370
的如何一個打印機存儲why--。

298
00:12:54,370 --> 00:12:58,900
>> 這樣就創建一個指針方式
是通過執行數據的任何類型

299
00:12:58,900 --> 00:13:02,840
該指針是要
要引用和then--

300
00:13:02,840 --> 00:13:05,324
與star--，然後
指針的名稱。

301
00:13:05,324 --> 00:13:07,240
所以在這裡，如果我們想
創建一個指針

302
00:13:07,240 --> 00:13:11,640
指出朝向的整數，且我們
想為x指示器的名稱，

303
00:13:11,640 --> 00:13:13,880
我們會做INT明星的X.

304
00:13:13,880 --> 00:13:14,380
是嗎？

305
00:13:14,380 --> 00:13:16,680
>> 聽眾：所以，如果
下面這行你

306
00:13:16,680 --> 00:13:20,045
做INT X，將整型明星x
指示x的位置

307
00:13:20,045 --> 00:13:21,170
你定義之後？

308
00:13:21,170 --> 00:13:22,000
>> ANDI彭：非常好的問題。

309
00:13:22,000 --> 00:13:23,860
我們一起去了這
一對夫婦後滑動。

310
00:13:23,860 --> 00:13:24,920
是啊。

311
00:13:24,920 --> 00:13:27,610
然後同樣的事
char和同樣的事情浮動。

312
00:13:27,610 --> 00:13:29,950
要知道，在這一點
我們創建了一個指針，

313
00:13:29,950 --> 00:13:32,470
我們還沒有實際設置
它又等於什麼。

314
00:13:32,470 --> 00:13:34,110
我們還沒有實際引用它。

315
00:13:34,110 --> 00:13:36,087
這裡的時候，同樣的事情
您創建一個變量，

316
00:13:36,087 --> 00:13:39,420
您創建的變量的名稱，
你有沒有實際設置一個值給它。

317
00:13:39,420 --> 00:13:41,410
這裡同樣的事情。

318
00:13:41,410 --> 00:13:42,110
>> 確定。

319
00:13:42,110 --> 00:13:44,670
那麼，我們如何設置值指針？

320
00:13:44,670 --> 00:13:47,190
它是通過引用和間接引用。

321
00:13:47,190 --> 00:13:52,260
這樣的方式，我們可以參考
一個varia--的指針，在本質上

322
00:13:52,260 --> 00:13:56,630
我們返回的地址在存儲器
其中的變量被存儲。

323
00:13:56,630 --> 00:14:02,550
所以，如果我有一個pointer--我就畫
這一次，我們到下一個幻燈片，

324
00:14:02,550 --> 00:14:05,760
但只知道，從本質上講，
在和 - 與號

325
00:14:05,760 --> 00:14:10,240
和變量 - 所有
所做的就是告訴你地址

326
00:14:10,240 --> 00:14:11,780
那裡的東西存儲。

327
00:14:11,780 --> 00:14:15,730
而且提領則相反
這一點，這僅僅是個明星。

328
00:14:15,730 --> 00:14:18,950
星只是給你的實際
存儲在該地址數據。

329
00:14:18,950 --> 00:14:21,090
>> 因此，人們給你的地址
存儲在地址，

330
00:14:21,090 --> 00:14:23,945
另外給你的實際
值存儲在該地址。

331
00:14:23,945 --> 00:14:25,820
所以他們兩個給
你不同的東西。

332
00:14:25,820 --> 00:14:27,755

333
00:14:27,755 --> 00:14:29,880
再次，所述幻燈片
所有在線讓您無後顧之憂

334
00:14:29,880 --> 00:14:33,200
如果你們不能複製
下來的時候。

335
00:14:33,200 --> 00:14:36,330
>> 因此，讓我們一起來看看
在這裡這個例子。

336
00:14:36,330 --> 00:14:40,530
所以，我們已經有了一個巨大的
這裡存儲陣列，對不對？

337
00:14:40,530 --> 00:14:42,920
我們在那裡只是有塊
存儲器，或字節的內存，

338
00:14:42,920 --> 00:14:45,060
我們可以在其中存儲不同的事情。

339
00:14:45,060 --> 00:14:47,310
遠的不說，這些都是
地址點在存儲器中。

340
00:14:47,310 --> 00:14:51,350
所以，任何時候你有 - 看到0X，
所有這一切都告訴你的是，

341
00:14:51,350 --> 00:14:52,930
這是一個十六進制數字。

342
00:14:52,930 --> 00:14:56,310
正如你們都知道，數字
可以設在不同的基地。

343
00:14:56,310 --> 00:14:58,770
基10是我們一般
解讀數字。

344
00:14:58,770 --> 00:15:00,550
還有基體2，它是二進制的。

345
00:15:00,550 --> 00:15:03,366
在這種情況下，
十六進制的基數為16。

346
00:15:03,366 --> 00:15:06,240
它是說只是以不同的方式
從零到10--或零到九

347
00:15:06,240 --> 00:15:10,904
然後又A，B，C，D，E，F。
還引用不同的號碼。

348
00:15:10,904 --> 00:15:12,570
大衛就在這個演講中簡要地。

349
00:15:12,570 --> 00:15:14,280
如果你們是
困惑，它只是谷歌。

350
00:15:14,280 --> 00:15:17,370
這裡真的很容易的方法來學習
什麼是十六進制數字的。

351
00:15:17,370 --> 00:15:19,510
所有這一切真的有關
現在是為你

352
00:15:19,510 --> 00:15:24,170
你們要知道，
十六進制在C中位數

353
00:15:24,170 --> 00:15:27,090
告訴你 - 通常
告訴你，這是一個指針。

354
00:15:27,090 --> 00:15:29,150
或者說是一個地址。

355
00:15:29,150 --> 00:15:33,310
>> 因此，在這裡本例中為int x等於5。

356
00:15:33,310 --> 00:15:36,350
我們正在創建一個integer--
類型對不起，可變

357
00:15:36,350 --> 00:15:39,090
整數，我們正在對其進行初始化為5。

358
00:15:39,090 --> 00:15:47,040
所以在這裡我們的內存板，我們可以
看到x是在為0x0地址

359
00:15:47,040 --> 00:15:50,550
並且，你已經價值
裡面存放的是5。

360
00:15:50,550 --> 00:15:52,370
這應該是有意義
每個人，對不對？

361
00:15:52,370 --> 00:15:53,030
確定。

362
00:15:53,030 --> 00:15:56,520
>> 然後我們做了什麼
在代碼的第二線

363
00:15:56,520 --> 00:16:00,290
是，我們已經創建
int類型的指針。

364
00:16:00,290 --> 00:16:02,750
這就是整型
明星指針在做什麼。

365
00:16:02,750 --> 00:16:07,320
而且等於該符號x
是給你的東西的地址。

366
00:16:07,320 --> 00:16:12,120
因此x的在地址
本例中為0x0。

367
00:16:12,120 --> 00:16:15,630
並使得地址正在被
存儲在該指針。

368
00:16:15,630 --> 00:16:17,360
這是否有意義給大家？

369
00:16:17,360 --> 00:16:19,965
>> 因此，認為this--的
想pointers--這裡

370
00:16:19,965 --> 00:16:24,780
在耶魯大學，我們有一個郵政信箱系統
其中，每個學生都​​有一個郵件

371
00:16:24,780 --> 00:16:26,960
地址，你可以去
進入LW地下室

372
00:16:26,960 --> 00:16:30,492
你可以隨便去搶
無論你需要從該地址。

373
00:16:30,492 --> 00:16:32,450
同樣的事情發生
這裡在計算機中。

374
00:16:32,450 --> 00:16:36,770
你有這些內存字節
你可以信息存儲到，

375
00:16:36,770 --> 00:16:39,529
但為了要知道哪些
的信息片

376
00:16:39,529 --> 00:16:42,570
你正在試圖找到匹配起來
何地，你需要一個指針

377
00:16:42,570 --> 00:16:43,740
告訴你如何去那裡。

378
00:16:43,740 --> 00:16:47,270
>> 因此，例如，對我來說，我的寶箱，
我有一個特定的五位數字。

379
00:16:47,270 --> 00:16:48,400
這是我的地址。

380
00:16:48,400 --> 00:16:51,880
所以，我可以實際去記憶，
我可以看這個地址，

381
00:16:51,880 --> 00:16:54,507
我可以去那郵政信箱
並訪問內部數據。

382
00:16:54,507 --> 00:16:57,090
這是否有意義給大家
您的計算機基本上是

383
00:16:57,090 --> 00:16:59,000
做同樣的事情。

384
00:16:59,000 --> 00:17:02,750
>> 因此，所有的指針做的是，
它只是創建一個存儲

385
00:17:02,750 --> 00:17:06,099
和它的內存中的數據實際上是
別的東西的地址。

386
00:17:06,099 --> 00:17:08,210
然後，你可以去發現。

387
00:17:08,210 --> 00:17:09,060
每個人都好？

388
00:17:09,060 --> 00:17:10,720
大家好我這麼遠嗎？

389
00:17:10,720 --> 00:17:11,360
確定。

390
00:17:11,360 --> 00:17:11,859
酷。

391
00:17:11,859 --> 00:17:14,311

392
00:17:14,311 --> 00:17:14,810
好的。

393
00:17:14,810 --> 00:17:19,160
因此，幾乎同樣的事情和以前一樣。

394
00:17:19,160 --> 00:17:23,849
因此，我們有，首先，可變
名為x其中case--

395
00:17:23,849 --> 00:17:27,700
我將這個值更改為5。

396
00:17:27,700 --> 00:17:31,820
遠的不說地址
這在內存為0x0。

397
00:17:31,820 --> 00:17:33,070
00。

398
00:17:33,070 --> 00:17:33,570
太好了。

399
00:17:33,570 --> 00:17:35,320
>> 那麼，在我們的第二個
代碼行，我們

400
00:17:35,320 --> 00:17:41,210
要創建一個指針
所謂PTR指針。

401
00:17:41,210 --> 00:17:45,760
與該地址，讓我們
只是說這是在內存中為0x01。

402
00:17:45,760 --> 00:17:48,280
而我們其實想
store--的符號

403
00:17:48,280 --> 00:17:50,620
X允許你一個什麼樣x為地址。

404
00:17:50,620 --> 00:17:53,990
和x的地址為0×00。

405
00:17:53,990 --> 00:17:57,300
所以這個指針現在
實際上有地址

406
00:17:57,300 --> 00:18:00,210
存儲作為什麼十獲得其值。

407
00:18:00,210 --> 00:18:01,700
每個人都和我這麼遠嗎？

408
00:18:01,700 --> 00:18:02,320
酷。

409
00:18:02,320 --> 00:18:04,670
>> 然後，該方式
我們會複製，

410
00:18:04,670 --> 00:18:09,650
是，如果我們將宣布和初始化
int類型內存的另一個塊。

411
00:18:09,650 --> 00:18:10,150
對嗎？

412
00:18:10,150 --> 00:18:11,130
這將是一個int。

413
00:18:11,130 --> 00:18:14,130
它會被稱為副本。

414
00:18:14,130 --> 00:18:17,120
而你要get--所以
明星指針給你

415
00:18:17,120 --> 00:18:19,080
從該地址的實際數據。

416
00:18:19,080 --> 00:18:22,490
該符號給你的地址，
明星給你的數據。

417
00:18:22,490 --> 00:18:24,630
所以數據在指針。

418
00:18:24,630 --> 00:18:29,420
這個指針指向5。

419
00:18:29,420 --> 00:18:33,140
因此該功能
這裡 - 明星pointer--

420
00:18:33,140 --> 00:18:39,740
雲，獲得無論是在
該塊和在這裡的商店。

421
00:18:39,740 --> 00:18:41,730
每個人都清楚如何發生的？

422
00:18:41,730 --> 00:18:45,490
>> 因此，兩家運營商的權利那裡 - 
連字符和star--

423
00:18:45,490 --> 00:18:48,250
只是做不同的事情
在指針使用時。

424
00:18:48,250 --> 00:18:50,837
一個可以讓你的地址一
讓你的實際值。

425
00:18:50,837 --> 00:18:53,670
所以一定要確保當你傢伙
編碼您不要將兩者混為一談

426
00:18:53,670 --> 00:18:55,650
因為他們是完全不同的。

427
00:18:55,650 --> 00:18:58,880
在這裡，我們有一個為0x01的一個很好的例子。

428
00:18:58,880 --> 00:19:01,207
這是一個非常好的
少量的記憶。

429
00:19:01,207 --> 00:19:03,040
在您的實際計算機
你將有

430
00:19:03,040 --> 00:19:06,740
一個巨大的屁股數量那是後話
這不是很好的，不愉快的。

431
00:19:06,740 --> 00:19:08,280
這將是一些垃圾的價值。

432
00:19:08,280 --> 00:19:10,920
所以它要真的，
真的會打亂你的計劃。

433
00:19:10,920 --> 00:19:12,670
這是非常重要的
現在，我們有

434
00:19:12,670 --> 00:19:16,150
基本面下來why--一樣，
什麼實際發生時，

435
00:19:16,150 --> 00:19:18,270
你正在運行這些代碼塊。

436
00:19:18,270 --> 00:19:19,120
Everyone--是嗎？

437
00:19:19,120 --> 00:19:21,425
>> 聽眾：所以INT x等於INT副本？

438
00:19:21,425 --> 00:19:24,650

439
00:19:24,650 --> 00:19:34,970
>> ANDI彭：沒有，因為在這種情況下，INT
x-- x--的值等於5，對不對？

440
00:19:34,970 --> 00:19:40,546
然後INT副本等於5。

441
00:19:40,546 --> 00:19:43,420
所以，如果你將它們等同於
對方，因為他們是整數，

442
00:19:43,420 --> 00:19:46,379
是的，他們會評估為true。

443
00:19:46,379 --> 00:19:49,670
但是如果他們在存儲器串，像
一個大衛例如在做，

444
00:19:49,670 --> 00:19:51,670
這是不同的，因為
他們引用

445
00:19:51,670 --> 00:19:54,920
在內存場所地址
他們將相當於為false。

446
00:19:54,920 --> 00:20:00,070
>> 所以，在這裡，因為你是這將是真實的
直接比較values​​-- integers--

447
00:20:00,070 --> 00:20:02,240
但在其他你
參考點。

448
00:20:02,240 --> 00:20:05,290
因為一個字符串是在一個陣列，並
all--我們將談論這個later--

449
00:20:05,290 --> 00:20:09,940
但陣列本質上只是一個
指針一堆內存中字符的。

450
00:20:09,940 --> 00:20:11,610
因此，這些都是有點不同。

451
00:20:11,610 --> 00:20:14,642
但在這種情況下，是的，
你能做到這一點。

452
00:20:14,642 --> 00:20:17,354
>> 聽眾：你能解釋一下
副本的地址？

453
00:20:17,354 --> 00:20:18,020
ANDI彭：是的。

454
00:20:18,020 --> 00:20:20,030
所以這是just--我
沒有填寫值

455
00:20:20,030 --> 00:20:23,022
但它只是一些隨機其他
垃圾的價值，我們不關心。

456
00:20:23,022 --> 00:20:25,730
因為一旦你開始計劃
你知道，我們實際上並不

457
00:20:25,730 --> 00:20:28,150
真正關心什麼
實際地址，

458
00:20:28,150 --> 00:20:30,470
我們只需要知道
什麼是在地址。

459
00:20:30,470 --> 00:20:31,608
是啊。

460
00:20:31,608 --> 00:20:36,034
>> 聽眾：為int的下一個明星
第二條線，那是不同的than--

461
00:20:36,034 --> 00:20:36,700
ANDI彭：是的。

462
00:20:36,700 --> 00:20:39,015
聽眾：--the取消引用
並引用明星？

463
00:20:39,015 --> 00:20:39,681
ANDI彭：是的。

464
00:20:39,681 --> 00:20:43,180
因此C--的作者誰
決定寫的語言C--

465
00:20:43,180 --> 00:20:44,200
是不是很聰明。

466
00:20:44,200 --> 00:20:46,830
他們不是很聰明的嘗試
弄清楚為什麼我們應該這樣做。

467
00:20:46,830 --> 00:20:49,413
如果是我，我肯定會
使用兩個不同的字符。

468
00:20:49,413 --> 00:20:52,100
但他們決定使用同一個。

469
00:20:52,100 --> 00:20:56,607
>> 因此，一個int後的明星，
它告訴計算機

470
00:20:56,607 --> 00:20:58,190
你是要創建一個指針。

471
00:20:58,190 --> 00:21:00,820
但是，如果你想提領
something--換句話說，

472
00:21:00,820 --> 00:21:03,780
去的地址和拉
從somewhere--數據

473
00:21:03,780 --> 00:21:05,070
明星用不同。

474
00:21:05,070 --> 00:21:08,750
所以，你倆要小心
沒有搞亂的兩種用法。

475
00:21:08,750 --> 00:21:09,870
酷。

476
00:21:09,870 --> 00:21:10,605
是嗎？

477
00:21:10,605 --> 00:21:14,680
>> 聽眾：所以只是重複到
確保我following--

478
00:21:14,680 --> 00:21:16,252
>> ANDI彭：完全罰款。

479
00:21:16,252 --> 00:21:20,491
>> 聽眾：--in的左手側
該幻燈片，我們這樣做，我們知道的事情。

480
00:21:20,491 --> 00:21:23,124
我們宣布一個整數
[聽不清]是等於5。

481
00:21:23,124 --> 00:21:23,790
ANDI彭：是的。

482
00:21:23,790 --> 00:21:24,456
聽眾：對。

483
00:21:24,456 --> 00:21:28,960
然後我們有一個int明星的事情，
上面寫著那種，OK，像我們

484
00:21:28,960 --> 00:21:31,235
聲明一個整數，現在
我們宣布一個指針。

485
00:21:31,235 --> 00:21:32,110
ANDI彭：正確。

486
00:21:32,110 --> 00:21:32,410
正確的。

487
00:21:32,410 --> 00:21:32,710
>> 聽眾：是嗎？

488
00:21:32,710 --> 00:21:33,870
而我們的指針PTR。

489
00:21:33,870 --> 00:21:34,080
>> ANDI彭：是的。

490
00:21:34,080 --> 00:21:35,460
指針的名稱是PTR。

491
00:21:35,460 --> 00:21:35,959
指針。

492
00:21:35,959 --> 00:21:39,000
聽眾：然後它
等於NX，只是告訴C

493
00:21:39,000 --> 00:21:44,667
它希望訪問的值
x--值的整數x整數

494
00:21:44,667 --> 00:21:45,800
被分配。

495
00:21:45,800 --> 00:21:49,050
>> ANDI彭：小心
因為符號實際上x

496
00:21:49,050 --> 00:21:53,120
告訴你 - 電腦，你
想拉什麼x是地址。

497
00:21:53,120 --> 00:21:56,350
因此，符號給你
地址，星級為您提供的價值。

498
00:21:56,350 --> 00:21:58,255
>> 聽眾：所以我們想要的地址。

499
00:21:58,255 --> 00:22:02,075
比方說，x為at--

500
00:22:02,075 --> 00:22:03,950
ANDI鵬：實際上我們
知道什麼x是吧？

501
00:22:03,950 --> 00:22:06,790
因為我們知道X was--我
使這件事，但我們只能說，

502
00:22:06,790 --> 00:22:08,760
隨意，這是為0x00。

503
00:22:08,760 --> 00:22:09,590
對嗎？

504
00:22:09,590 --> 00:22:14,120
所以我們知道地址為0x00，
所以當我們去和符號X，

505
00:22:14,120 --> 00:22:17,050
我們知道這
應該評估為0x00。

506
00:22:17,050 --> 00:22:20,810
這就是為什麼我們存儲的
作為我們的指針的值。

507
00:22:20,810 --> 00:22:21,924
這是否有意義？

508
00:22:21,924 --> 00:22:22,832
>> 聽眾：是的。

509
00:22:22,832 --> 00:22:28,057
而副本去提領ptr--

510
00:22:28,057 --> 00:22:28,765
ANDI彭：對。

511
00:22:28,765 --> 00:22:30,473
聽眾：可呈現為
我們已經指針

512
00:22:30,473 --> 00:22:35,220
聲明告訴我們
整數x的地址。

513
00:22:35,220 --> 00:22:36,160
>> ANDI彭：是的。

514
00:22:36,160 --> 00:22:39,272
>> 聽眾：而在這
一種情況下，星ptr導

515
00:22:39,272 --> 00:22:41,256
等於x的哪個等於5的值。

516
00:22:41,256 --> 00:22:42,744
>> ANDI彭：正確。

517
00:22:42,744 --> 00:22:44,728
>> 聽眾：酷。

518
00:22:44,728 --> 00:22:49,382
這是一個簡單的方法來獲得
即或是唯一方式 - 

519
00:22:49,382 --> 00:22:51,840
ANDI彭：所以現在它
似乎不是很合乎邏輯的我們

520
00:22:51,840 --> 00:22:54,690
花這一切時間做
這個超級複雜的事情時，

521
00:22:54,690 --> 00:22:57,606
我們所做的只是創建兩個
與5的值的整數，對不對？

522
00:22:57,606 --> 00:22:58,900
它沒有意義。

523
00:22:58,900 --> 00:23:03,060
但是，一旦我們就去了
內存分配還有 - 我們將

524
00:23:03,060 --> 00:23:06,067
走了過來，為什麼這可能是
方便和有用以後。

525
00:23:06,067 --> 00:23:09,150
相信我，當我說我們不只是
為您創造這些任意函數

526
00:23:09,150 --> 00:23:11,340
你們學習，因為我們是
想惹你。

527
00:23:11,340 --> 00:23:14,550
有實際使用所有這些
的事情，我們會談論他們。

528
00:23:14,550 --> 00:23:14,950
>> 聽眾：真棒。

529
00:23:14,950 --> 00:23:15,350
>> ANDI彭：是的。

530
00:23:15,350 --> 00:23:16,150
>> 聽眾：[聽不清]。

531
00:23:16,150 --> 00:23:16,450
>> ANDI彭：這個問題問得好。

532
00:23:16,450 --> 00:23:17,510
>> 聽眾：[聽不清]。

533
00:23:17,510 --> 00:23:18,000
>> ANDI彭：這不是。

534
00:23:18,000 --> 00:23:18,666
這真的不是。

535
00:23:18,666 --> 00:23:21,050
聽眾：--two變量
這也等於[聽不清]。

536
00:23:21,050 --> 00:23:22,400
確定。

537
00:23:22,400 --> 00:23:23,070
>> ANDI彭：是的。

538
00:23:23,070 --> 00:23:23,570
確定。

539
00:23:23,570 --> 00:23:25,249
在我繼續前進，是每個人都清楚了嗎？

540
00:23:25,249 --> 00:23:26,790
我知道泰勒，你有點晚了。

541
00:23:26,790 --> 00:23:27,490
這是確定的。

542
00:23:27,490 --> 00:23:28,100
這是在網上。

543
00:23:28,100 --> 00:23:30,600
你看前20
分鐘，你就會被大家看好。

544
00:23:30,600 --> 00:23:31,190
確定。

545
00:23:31,190 --> 00:23:31,690
酷。

546
00:23:31,690 --> 00:23:35,597

547
00:23:35,597 --> 00:23:37,140
>> 好的。

548
00:23:37,140 --> 00:23:41,270
樣的，所以這是一個基本上
類似的事情，我們只是做了。

549
00:23:41,270 --> 00:23:43,100
它只是在圖形形式。

550
00:23:43,100 --> 00:23:47,070
如果你要跟踪什麼
就這樣發生了，詮釋x等於5，

551
00:23:47,070 --> 00:23:52,159
我們所做的在這一點上是
創建一個名為x int類型的變量。

552
00:23:52,159 --> 00:23:54,200
我們要保存
的這5內在價值。

553
00:23:54,200 --> 00:23:57,366
有沒有指針，因為我們還沒有
實際上創造了一個指針呢，對吧？

554
00:23:57,366 --> 00:24:00,302
然後在下一
行，詮釋明星指針，

555
00:24:00,302 --> 00:24:02,760
這就是我們實際上
實際創建的指針

556
00:24:02,760 --> 00:24:05,010
我們正在制定的
等於，或引用

557
00:24:05,010 --> 00:24:07,250
指針，以符號的X.

558
00:24:07,250 --> 00:24:10,002
這是哪裡的地方在
記憶這事是。

559
00:24:10,002 --> 00:24:12,210
我其實並沒有理會
組成一個值這個時候。

560
00:24:12,210 --> 00:24:14,900
但在這種情況下，該點
您會等於。

561
00:24:14,900 --> 00:24:18,060
>> 再往下還有，明星
指針反引用。

562
00:24:18,060 --> 00:24:20,310
這就是我們
拉動信息。

563
00:24:20,310 --> 00:24:24,170
所以當x是值實際上是
將是等於35。

564
00:24:24,170 --> 00:24:30,390
所以在這一點上，我們基本上已經
只是重新初始化X要35

565
00:24:30,390 --> 00:24:32,320
沒有實際接觸的X.

566
00:24:32,320 --> 00:24:34,560
只需通過指針
這是指向X，

567
00:24:34,560 --> 00:24:36,910
我們其實可以改變什麼x為。

568
00:24:36,910 --> 00:24:38,420
我要畫這一點為好。

569
00:24:38,420 --> 00:24:52,200
>> 所以在這裡，我們已經創建
這裡是一些隨機地址。

570
00:24:52,200 --> 00:24:54,734
遠的不說，又為0x00。

571
00:24:54,734 --> 00:24:56,150
讓我們只說這是地址。

572
00:24:56,150 --> 00:25:00,830
我們已經創建了一個整數名為x
我已經分配給它的值是5。

573
00:25:00,830 --> 00:25:03,840
在第二行，整數
pointer--所以現在我們已經

574
00:25:03,840 --> 00:25:07,820
得到這個第二件事
這裡被稱為pointer--

575
00:25:07,820 --> 00:25:14,310
我們打算用於：我們只能說
它的一些其他隨機的內存地址。

576
00:25:14,310 --> 00:25:18,460
>> 所以，我們要設置這個
等於不管是什麼樣。

577
00:25:18,460 --> 00:25:21,540

578
00:25:21,540 --> 00:25:25,880
與該指針是要
指向x的值

579
00:25:25,880 --> 00:25:30,090
然後，如果改變
the--如果我們做明星的指針，

580
00:25:30,090 --> 00:25:32,800
這是怎麼回事的
我們指針的值。

581
00:25:32,800 --> 00:25:36,979
在這種情況下，它的將跟踪
這支箭過來x的這個值

582
00:25:36,979 --> 00:25:38,395
而這將其更改為35。

583
00:25:38,395 --> 00:25:41,400

584
00:25:41,400 --> 00:25:44,760
實際上，我們只是改變
X =無接觸的X.

585
00:25:44,760 --> 00:25:48,970
通過剛才引用指針，
我們可以去改變x的值。

586
00:25:48,970 --> 00:25:50,050
這是否有意義？

587
00:25:50,050 --> 00:25:55,200
>> 因此以這種方式，我們實際上可以重新命名
和重新改變並重新分配值

588
00:25:55,200 --> 00:25:57,750
以我們沒有的東西
實際上使我們自己。

589
00:25:57,750 --> 00:26:00,925
這是否有意義給大家？

590
00:26:00,925 --> 00:26:01,425
酷。

591
00:26:01,425 --> 00:26:04,450

592
00:26:04,450 --> 00:26:05,310
確定。

593
00:26:05,310 --> 00:26:08,210
因此，複雜的圖形在這裡。

594
00:26:08,210 --> 00:26:09,360
通過走行線。

595
00:26:09,360 --> 00:26:12,055
從本質上講，只是做的確切
同樣的事情，我只是做了。

596
00:26:12,055 --> 00:26:15,977

597
00:26:15,977 --> 00:26:17,810
在我繼續前進，我
真的想只是讓

598
00:26:17,810 --> 00:26:19,370
確保每個人都對這個真的清楚。

599
00:26:19,370 --> 00:26:26,260
所以在這裡，我們有代碼
INT a等於3，B等於4，c等於5。

600
00:26:26,260 --> 00:26:33,130
因此，我們已經創建了一個名為三個整數
a，b和c表示等於3,4和5。

601
00:26:33,130 --> 00:26:38,460
然後，我們創建三個指針
這一點每一個這些變量。

602
00:26:38,460 --> 00:26:41,760
>> 現在我們要去
走在本質

603
00:26:41,760 --> 00:26:44,240
當你對他們的工作會發生什麼。

604
00:26:44,240 --> 00:26:45,490
所以畫出來。

605
00:26:45,490 --> 00:26:48,156
取paper--我做不成片
知道你們都有紙張，

606
00:26:48,156 --> 00:26:50,930
但那些你們誰不這樣做，也許
那些你們誰借錢。

607
00:26:50,930 --> 00:26:53,580
取的紙張
並線走線。

608
00:26:53,580 --> 00:26:59,390
而在你做的每一個操作，
我希望你們真正寫出來

609
00:26:59,390 --> 00:27:00,800
什麼是，b和c在此點。

610
00:27:00,800 --> 00:27:03,550
什麼是地址，什麼是
指向a，b和c中的指針

611
00:27:03,550 --> 00:27:04,410
在這一點？

612
00:27:04,410 --> 00:27:07,150
>> 然後希望這
那種會加強你們

613
00:27:07,150 --> 00:27:08,900
通過如何看待指針。

614
00:27:08,900 --> 00:27:10,650
我們不會去
通過所有這些。

615
00:27:10,650 --> 00:27:13,450
也許我給你five--
像，三分鐘。

616
00:27:13,450 --> 00:27:14,660
獲得第幾開始。

617
00:27:14,660 --> 00:28:10,410

618
00:28:10,410 --> 00:28:10,959
呵呵。

619
00:28:10,959 --> 00:28:11,459
哎呀。

620
00:28:11,459 --> 00:28:20,940

621
00:28:20,940 --> 00:28:26,950
>> 聽眾：在第二行，為什麼
是不是明星[聽不清]變量？

622
00:28:26,950 --> 00:28:29,410
>> ANDI彭：記得在
運營商，在第一週，

623
00:28:29,410 --> 00:28:31,730
我們談到了如何
如果你這樣做等於加，

624
00:28:31,730 --> 00:28:35,320
這只是意味著一個等於加C。

625
00:28:35,320 --> 00:28:39,370
在此case--所以這是另一
方式在其中星也可以使用。

626
00:28:39,370 --> 00:28:42,040
除了參考
並聲明指針，

627
00:28:42,040 --> 00:28:44,440
請記住，這也
意味著乘法。

628
00:28:44,440 --> 00:28:46,575
因此，在這種情況下，剛剛
是等於C時代。

629
00:28:46,575 --> 00:28:48,450
這只是不同
編寫方式。

630
00:28:48,450 --> 00:28:49,776
>> 聽眾：一等於C時代。

631
00:28:49,776 --> 00:28:50,442
ANDI彭：是的。

632
00:28:50,442 --> 00:30:43,488

633
00:30:43,488 --> 00:30:47,130
>> 聽眾：這是什麼意思，如果
它說，一個符號的信？

634
00:30:47,130 --> 00:30:50,900
>> ANDI彭：＆符號的手段
你要that--你

635
00:30:50,900 --> 00:30:54,760
要指針的地方
指向和拉動的地址。

636
00:30:54,760 --> 00:31:01,270
因此，符號給你的地址，
明星給你那裡的實際值。

637
00:31:01,270 --> 00:31:03,090
>> 聽眾：難道我們
通過線建設上線？

638
00:31:03,090 --> 00:31:04,881
>> ANDI彭：你
通過線的基礎上線。

639
00:31:04,881 --> 00:31:07,260
所以只是去一行
一時間和then--你

640
00:31:07,260 --> 00:31:08,470
不必擔心
完成整個事情。

641
00:31:08,470 --> 00:31:10,428
讓我們試著打通
也許二，三線

642
00:31:10,428 --> 00:31:12,445
然後，我們將召集和完成這一點。

643
00:31:12,445 --> 00:31:15,530

644
00:31:15,530 --> 00:31:17,470
>> 這是完全確定的，如果你們都將丟失。

645
00:31:17,470 --> 00:31:19,334
這是一個很艱難的概念。

646
00:31:19,334 --> 00:31:22,500
如果你們是擔心類
是這樣的像大衛說，

647
00:31:22,500 --> 00:31:23,190
它沒有。

648
00:31:23,190 --> 00:31:25,949
我們到達
困難的概念性高峰

649
00:31:25,949 --> 00:31:27,740
然後它會
向下傾斜。

650
00:31:27,740 --> 00:31:29,110
所以你們幾乎沒有。

651
00:31:29,110 --> 00:31:31,080
我們有很多的糖果來獲得
你們通過駝峰。

652
00:31:31,080 --> 00:31:32,940
我認為倒台後幾乎
打破我們會渡過了難關

653
00:31:32,940 --> 00:31:34,220
和生活都會好起來。

654
00:31:34,220 --> 00:31:36,580
所以不用擔心的。

655
00:31:36,580 --> 00:32:30,732

656
00:32:30,732 --> 00:32:31,232
好的。

657
00:32:31,232 --> 00:32:33,650
我給你們20
多秒的收官。

658
00:32:33,650 --> 00:33:12,560

659
00:33:12,560 --> 00:33:13,330
確定。

660
00:33:13,330 --> 00:33:13,830
好的。

661
00:33:13,830 --> 00:33:16,370
讓我們一捅這個。

662
00:33:16,370 --> 00:33:19,430
正如你們給我的答案，
我只是要他們輸入。

663
00:33:19,430 --> 00:33:22,140
並希望we--可以嗎？

664
00:33:22,140 --> 00:33:23,317
我其實不能輸入。

665
00:33:23,317 --> 00:33:24,400
我就畫在黑板上。

666
00:33:24,400 --> 00:33:31,420

667
00:33:31,420 --> 00:33:35,900
>> 因此，這裡的這個第一線
我們有一個等於B型星溫度。

668
00:33:35,900 --> 00:33:38,060
此外艾略特提出了一個
真的，真的好點。

669
00:33:38,060 --> 00:33:42,500
因為我忘了，除了
兩種方法，我們可以使用星號，

670
00:33:42,500 --> 00:33:43,750
這事實上是在第三條道路。

671
00:33:43,750 --> 00:33:44,990
乘法。

672
00:33:44,990 --> 00:33:51,380
所以，只是沒有得到困惑，因為
這是利用明星的第一種方式。

673
00:33:51,380 --> 00:33:54,470
它只是告訴電腦
我是要創建一個指針。

674
00:33:54,470 --> 00:34:00,600
>> 通過做第二種方法
Star的指針，

675
00:34:00,600 --> 00:34:04,320
告訴你想要的指針
在該指針來訪問該數據。

676
00:34:04,320 --> 00:34:06,710
然後，當然，還有
只是簡單的乘法

677
00:34:06,710 --> 00:34:09,564
兩個數字之間，告訴你
我想乘兩個。

678
00:34:09,564 --> 00:34:11,730
因此，有很多的方法
我們可以使用星號。

679
00:34:11,730 --> 00:34:13,830
不要混淆。

680
00:34:13,830 --> 00:34:16,991
只要確保你們理解
正是他們三個

681
00:34:16,991 --> 00:34:18,630
在做什麼。

682
00:34:18,630 --> 00:34:22,920
>> 因此，在這個第一線，
a等於b乘以℃。

683
00:34:22,920 --> 00:34:26,850
所以，讓我們通過什麼
是，什麼是B，什麼是C？

684
00:34:26,850 --> 00:34:32,600
什麼是一個指針時，
指針為b，並且指針到c？

685
00:34:32,600 --> 00:34:34,050
那些是什麼都等於？

686
00:34:34,050 --> 00:34:34,600
確定。

687
00:34:34,600 --> 00:34:38,650
>> 因此，我們開始了與一個等於3，
b等於c 4，和C等於5，對不對？

688
00:34:38,650 --> 00:34:42,230
所以這第一行之後，就可以
有人告訴我，什麼是？

689
00:34:42,230 --> 00:34:42,730
是啊。

690
00:34:42,730 --> 00:34:44,229
隨意剛喊出答案。

691
00:34:44,229 --> 00:34:44,929
20。

692
00:34:44,929 --> 00:34:45,550
好。

693
00:34:45,550 --> 00:34:46,410
什麼是B'

694
00:34:46,410 --> 00:34:47,777
>> 聽眾：4。

695
00:34:47,777 --> 00:34:48,610
ANDI彭：什麼是C嗎？

696
00:34:48,610 --> 00:34:49,659
聽眾：5。

697
00:34:49,659 --> 00:34:50,770
ANDI彭：耶。

698
00:34:50,770 --> 00:34:51,639
好。

699
00:34:51,639 --> 00:34:55,707
什麼是PA，PB和PC？

700
00:34:55,707 --> 00:34:58,564
>> 聽眾：000001和002？

701
00:34:58,564 --> 00:34:59,230
ANDI彭：是的。

702
00:34:59,230 --> 00:35:02,390
這麼樣的腦筋急轉彎
但不是真的，因為在這裡我

703
00:35:02,390 --> 00:35:04,760
抽出實際的回憶。

704
00:35:04,760 --> 00:35:08,520
但是，因為對於一個例子，我們不
其實知道這些數字是，

705
00:35:08,520 --> 00:35:10,326
我們只能說符號。

706
00:35:10,326 --> 00:35:12,200
我甚至不知道我是否
可以得出一個符號。

707
00:35:12,200 --> 00:35:18,022
這是like--你怎麼辦呢？

708
00:35:18,022 --> 00:35:19,790
>> 聽眾：喜歡畫畫八。

709
00:35:19,790 --> 00:35:20,870
>> ANDI彭：像八。

710
00:35:20,870 --> 00:35:21,580
喜歡這一點。

711
00:35:21,580 --> 00:35:22,080
確定。

712
00:35:22,080 --> 00:35:23,446
聽眾：賓果。

713
00:35:23,446 --> 00:35:25,350
>> ANDI彭：殺死它。

714
00:35:25,350 --> 00:35:28,202
所以AMPERSAND一個，你可以做到這一點。

715
00:35:28,202 --> 00:35:30,410
因為我們實際上並不
關心的是，值

716
00:35:30,410 --> 00:35:32,880
是，這是一些長
屁股價值反正，

717
00:35:32,880 --> 00:35:35,220
我們只用榕
說一個符號。

718
00:35:35,220 --> 00:35:37,024
那麼什麼是PB？

719
00:35:37,024 --> 00:35:37,940
聽眾：[聽不清]。

720
00:35:37,940 --> 00:35:38,606
ANDI彭：是的。

721
00:35:38,606 --> 00:35:42,490

722
00:35:42,490 --> 00:35:43,500
酷。

723
00:35:43,500 --> 00:35:44,010
好的。

724
00:35:44,010 --> 00:35:44,770
先易行。

725
00:35:44,770 --> 00:35:45,270
我們得到了這一點。

726
00:35:45,270 --> 00:35:46,330
指針很容易。

727
00:35:46,330 --> 00:35:47,450
這是確定的。

728
00:35:47,450 --> 00:35:48,740
>> 第二道防線。

729
00:35:48,740 --> 00:35:52,400
所以明星等於是一樣的
話說一件事等於C時代。

730
00:35:52,400 --> 00:35:54,730
這是寫的只是一個更簡單的方法。

731
00:35:54,730 --> 00:35:57,170
因此，我們不試圖使
一個點或任何東西。

732
00:35:57,170 --> 00:36:00,600
因此，與第一線完成。

733
00:36:00,600 --> 00:36:05,144
什麼是在第二行上
以後你做了等於C時代？

734
00:36:05,144 --> 00:36:05,777
>> 聽眾：100？

735
00:36:05,777 --> 00:36:06,610
ANDI彭：這是100。

736
00:36:06,610 --> 00:36:07,795
好。

737
00:36:07,795 --> 00:36:08,864
如何關於B？

738
00:36:08,864 --> 00:36:10,256
>> 聽眾：[聽不清]。

739
00:36:10,256 --> 00:36:11,335
>> ANDI彭：如何C嗎？

740
00:36:11,335 --> 00:36:12,490
>> 聽眾：[聽不清]。

741
00:36:12,490 --> 00:36:14,530
>> ANDI彭：又有怎樣的指針？

742
00:36:14,530 --> 00:36:15,800
是否they--一樣的，對不對？

743
00:36:15,800 --> 00:36:20,640

744
00:36:20,640 --> 00:36:21,940
確定。

745
00:36:21,940 --> 00:36:23,820
現在，第三行。

746
00:36:23,820 --> 00:36:26,400

747
00:36:26,400 --> 00:36:27,350
有點麻煩。

748
00:36:27,350 --> 00:36:29,760
b等於c星PA。

749
00:36:29,760 --> 00:36:34,189
誰能告訴我，第一，
哪些呢星級PA平等嗎？

750
00:36:34,189 --> 00:36:36,159
>> 聽眾：這是值
一個儲存在。

751
00:36:36,159 --> 00:36:36,950
ANDI鵬：沒錯。

752
00:36:36,950 --> 00:36:38,070
什麼是價值
一個儲存在？

753
00:36:38,070 --> 00:36:38,860
>> 聽眾：100。

754
00:36:38,860 --> 00:36:39,660
>> ANDI彭：OK。

755
00:36:39,660 --> 00:36:43,462
那麼，什麼會是一個後
執行該行代碼？

756
00:36:43,462 --> 00:36:44,760
>> 聽眾：[聽不清]。

757
00:36:44,760 --> 00:36:45,870
>> ANDI彭：什麼關於B？

758
00:36:45,870 --> 00:36:46,780
>> 聽眾：100。

759
00:36:46,780 --> 00:36:47,620
>> ANDI彭：是的。

760
00:36:47,620 --> 00:36:49,995
然後一切是
幾乎不變的，對不對？

761
00:36:49,995 --> 00:36:51,239
因為我們沒有觸及它。

762
00:36:51,239 --> 00:36:55,370

763
00:36:55,370 --> 00:36:57,010
酷。

764
00:36:57,010 --> 00:36:58,390
第四行。

765
00:36:58,390 --> 00:37:00,390
稍微複雜一些。

766
00:37:00,390 --> 00:37:06,910
所以pc--再次，PC是指針
這指出C--等於年利率。

767
00:37:06,910 --> 00:37:11,520

768
00:37:11,520 --> 00:37:12,360
什麼是？

769
00:37:12,360 --> 00:37:14,525
>> 聽眾：100。

770
00:37:14,525 --> 00:37:15,400
ANDI彭：什麼為b？

771
00:37:15,400 --> 00:37:17,920
聽眾：100。

772
00:37:17,920 --> 00:37:18,862
ANDI彭：什麼是C？

773
00:37:18,862 --> 00:37:19,993
聽眾：5。

774
00:37:19,993 --> 00:37:20,867
ANDI彭：什麼是PA？

775
00:37:20,867 --> 00:37:22,775
聽眾：與符號一個。

776
00:37:22,775 --> 00:37:23,730
ANDI彭：PB？

777
00:37:23,730 --> 00:37:26,010
聽眾：與號灣

778
00:37:26,010 --> 00:37:27,730
ANDI彭：和棘手的，什麼是電腦嗎？

779
00:37:27,730 --> 00:37:28,410
聽眾：與符號一個。

780
00:37:28,410 --> 00:37:29,034
ANDI彭：耶。

781
00:37:29,034 --> 00:37:31,790
宇豪。

782
00:37:31,790 --> 00:37:32,500
你們看到了嗎？

783
00:37:32,500 --> 00:37:33,282
這是所有的權利。

784
00:37:33,282 --> 00:37:33,990
這不是太糟糕了。

785
00:37:33,990 --> 00:37:38,730
我們有更多的糖果，如果這還不是全部
正確的，但我認為它的一切權利。

786
00:37:38,730 --> 00:37:41,900
我們打算走過去只有一個
之前，我們就越難打的人多。

787
00:37:41,900 --> 00:37:43,710
這些問題的答案我在這裡。

788
00:37:43,710 --> 00:37:47,050
>> 從本質上講，知道這是
就像數學在這一點上。

789
00:37:47,050 --> 00:37:53,240
當你有簡單的公式像
再加上B，A C時代，這是很容易做到。

790
00:37:53,240 --> 00:37:56,390
當你開始擴大後，
它，只是為了去操作的。

791
00:37:56,390 --> 00:37:57,830
同樣的事情了。

792
00:37:57,830 --> 00:38:00,030
>> 保持跟踪，如果你的
明星是什麼了。

793
00:38:00,030 --> 00:38:01,640
這告訴你的價值。

794
00:38:01,640 --> 00:38:04,640
如果你有一個和之前
東西，它會告訴你地址。

795
00:38:04,640 --> 00:38:07,860
你應該分配任
的指針或該值。

796
00:38:07,860 --> 00:38:11,260
所以，讓我們在這個
最後一個真正的快。

797
00:38:11,260 --> 00:38:12,520
這不是最後一個，對不起。

798
00:38:12,520 --> 00:38:13,340
其實，你們可以挑選。

799
00:38:13,340 --> 00:38:16,006
哪一個做你們想要去
過出剩餘的三個的

800
00:38:16,006 --> 00:38:17,449
我們有嗎？

801
00:38:17,449 --> 00:38:20,490
我不認為我們可以做的
因為我們不能只是跳轉到該行。

802
00:38:20,490 --> 00:38:21,000
確定。

803
00:38:21,000 --> 00:38:25,700
你們沒有選擇，
這僅僅是三分之一到最後一個。

804
00:38:25,700 --> 00:38:29,228
>> 星PC等於b乘以℃。

805
00:38:29,228 --> 00:38:30,144
>> 聽眾：星PB？

806
00:38:30,144 --> 00:38:32,117
>> 聽眾：星PB。

807
00:38:32,117 --> 00:38:32,825
ANDI彭：對不起？

808
00:38:32,825 --> 00:38:33,599
聽眾：星PB。

809
00:38:33,599 --> 00:38:34,390
ANDI彭：星PB。

810
00:38:34,390 --> 00:38:35,100
哦，我的壞。

811
00:38:35,100 --> 00:38:38,647
星PB等於b乘以℃。

812
00:38:38,647 --> 00:38:40,230
我想給你們10秒。

813
00:38:40,230 --> 00:38:41,140
只是很快的想法。

814
00:38:41,140 --> 00:38:43,450
這是我們有這麼
到目前為止，什麼後，我們發生

815
00:38:43,450 --> 00:38:46,770
執行該第五行權呢？

816
00:38:46,770 --> 00:38:54,030

817
00:38:54,030 --> 00:38:55,980
確定。

818
00:38:55,980 --> 00:38:58,720
什麼是？

819
00:38:58,720 --> 00:38:59,560
>> 聽眾：100。

820
00:38:59,560 --> 00:39:02,470
>> ANDI彭：100。

821
00:39:02,470 --> 00:39:03,610
什麼為b呢？

822
00:39:03,610 --> 00:39:04,330
>> 聽眾：500。

823
00:39:04,330 --> 00:39:05,250
>> ANDI鵬：好的。

824
00:39:05,250 --> 00:39:08,570
是否有人想解釋
對我來說這是為什麼500？

825
00:39:08,570 --> 00:39:10,540
我不覺得我們
實際上碰過灣

826
00:39:10,540 --> 00:39:13,950
我們是怎麼改
的B不接觸B值？

827
00:39:13,950 --> 00:39:15,090
是嗎？

828
00:39:15,090 --> 00:39:18,239
>> 聽眾：因為星PB
是指在pb--價值

829
00:39:18,239 --> 00:39:19,030
ANDI鵬：沒錯。

830
00:39:19,030 --> 00:39:19,790
聽眾：可呈現為b。

831
00:39:19,790 --> 00:39:20,581
ANDI鵬：沒錯。

832
00:39:20,581 --> 00:39:26,880
所以在這裡我們的圖中，我們的指針
PB實際上是指向這一權利

833
00:39:26,880 --> 00:39:28,690
在這裡，這是實際的物理灣

834
00:39:28,690 --> 00:39:31,340
所以，如果你去
你做明星PB，這是

835
00:39:31,340 --> 00:39:36,080
下面您將鼠標指針箭頭
和物理上改變b的值。

836
00:39:36,080 --> 00:39:39,532
所以這就是為什麼我們B改變為
500沒有實際接觸灣

837
00:39:39,532 --> 00:39:42,490
然後一切依舊
同樣的，因為我們沒有觸及這一點。

838
00:39:42,490 --> 00:39:47,060

839
00:39:47,060 --> 00:39:48,530
這是灣

840
00:39:48,530 --> 00:39:49,420
酷。

841
00:39:49,420 --> 00:39:50,485
而then--

842
00:39:50,485 --> 00:39:51,910
>> 觀眾：我只是有一個問題。

843
00:39:51,910 --> 00:39:52,730
>> ANDI彭：是嗎？

844
00:39:52,730 --> 00:39:56,000
>> 聽眾：因為we've--
不再有符號C，

845
00:39:56,000 --> 00:39:59,620
這是否意味著一個符號
重定向到現在同樣的事情？

846
00:39:59,620 --> 00:40:00,520
>> ANDI彭：是的。

847
00:40:00,520 --> 00:40:01,582
So--

848
00:40:01,582 --> 00:40:03,540
聽眾：所以箭頭
那種只是移動和 - 

849
00:40:03,540 --> 00:40:04,030
ANDI彭：所以essentially--

850
00:40:04,030 --> 00:40:05,405
聽眾：--now我們不能access--

851
00:40:05,405 --> 00:40:08,387
ANDI彭： - 當我們
提領Çon--我偽造。

852
00:40:08,387 --> 00:40:08,970
那是什麼？

853
00:40:08,970 --> 00:40:09,560
第三行？

854
00:40:09,560 --> 00:40:10,060
四。

855
00:40:10,060 --> 00:40:11,490
第四行。

856
00:40:11,490 --> 00:40:14,910
所有我們所做的是，從本質上講，
改變這種箭頭

857
00:40:14,910 --> 00:40:16,680
並將它指向了一個來代替。

858
00:40:16,680 --> 00:40:19,480
>> 聽眾：所以我們不能訪問Ç了。

859
00:40:19,480 --> 00:40:22,520
>> ANDI彭：如果你有這個確切
號碼，你可以訪問它。

860
00:40:22,520 --> 00:40:23,260
但是，沒有。

861
00:40:23,260 --> 00:40:25,680
我們沒有一個指針
指向Ç了。

862
00:40:25,680 --> 00:40:27,430
我認為，如果你想
再次訪問它，你

863
00:40:27,430 --> 00:40:30,390
將創建另一個
指針重新指向到c

864
00:40:30,390 --> 00:40:32,856
或提領這一點，並指出回來。

865
00:40:32,856 --> 00:40:35,730
所以，不，截至目前，三
三分球，他們沒有指向C。

866
00:40:35,730 --> 00:40:38,800

867
00:40:38,800 --> 00:40:40,110
>> 每個人都好？

868
00:40:40,110 --> 00:40:41,440
答案是否在線。

869
00:40:41,440 --> 00:40:45,210
隨意，節後，去了
過去兩年和測試自己。

870
00:40:45,210 --> 00:40:47,840
同樣的概念，只是一個
有點棘手。

871
00:40:47,840 --> 00:40:51,860
通過對邏輯只要按照
為什麼事情是不同的東西。

872
00:40:51,860 --> 00:40:54,530
並且暗示，指針
我們愛的話題

873
00:40:54,530 --> 00:40:58,780
對測驗覆蓋，因為他們
概念上非常具有挑戰性。

874
00:40:58,780 --> 00:41:01,360
因此，我建議你
傢伙都評論此圖

875
00:41:01,360 --> 00:41:05,916
或斜線類似概念
這是你的測驗之前下週。

876
00:41:05,916 --> 00:41:06,864
>> 聽眾：對不起。

877
00:41:06,864 --> 00:41:07,530
>> ANDI彭：是嗎？

878
00:41:07,530 --> 00:41:09,708
聽眾：[聽不清]
最後埃德蒙頓[聽不清]。

879
00:41:09,708 --> 00:41:12,710

880
00:41:12,710 --> 00:41:15,770
>> ANDI彭：50,000？

881
00:41:15,770 --> 00:41:17,850
我需要遵循它背下來。

882
00:41:17,850 --> 00:41:22,530
但somewhere--我覺得行
之前，你創造巨大的c值。

883
00:41:22,530 --> 00:41:26,250
c等於這個巨大的東西
也就是100倍500。

884
00:41:26,250 --> 00:41:27,006
第

885
00:41:27,006 --> 00:41:28,000
>> 聽眾：[聽不清]。

886
00:41:28,000 --> 00:41:28,625
>> ANDI彭：是的。

887
00:41:28,625 --> 00:41:30,620
100乘以100是10,000。

888
00:41:30,620 --> 00:41:32,020
這是10,000。

889
00:41:32,020 --> 00:41:35,410
所以背下來有你
乘b和c。

890
00:41:35,410 --> 00:41:43,165
使得指向b--指針
這是500--倍的值A--

891
00:41:43,165 --> 00:41:44,480
>> 聽眾：[聽不清]。

892
00:41:44,480 --> 00:41:45,730
ANDI彭：也許這是錯誤的。

893
00:41:45,730 --> 00:41:49,514
聽眾：不，不，不是這樣的。 [聽不清]
指針位於c現在指向A--

894
00:41:49,514 --> 00:41:50,180
ANDI彭：是的。

895
00:41:50,180 --> 00:41:50,840
他是對的。

896
00:41:50,840 --> 00:41:56,477
>> 聽眾：--IT是其在平等
一個times--這是c的值。

897
00:41:56,477 --> 00:41:59,560
ANDI彭：你能說一點點
位高​​漲所以每個人都可以聽到你？

898
00:41:59,560 --> 00:42:04,879
聽眾：所以指針C現在點
到什麼用的一個指針指向

899
00:42:04,879 --> 00:42:09,460
用於：仍然does--，但它們指向
同樣的事情，這是一個，對不對？

900
00:42:09,460 --> 00:42:12,925
值的，但是
它被重新定義。

901
00:42:12,925 --> 00:42:17,875
而在那開始你
說一個是以前的100倍

902
00:42:17,875 --> 00:42:21,340
在B的值是500。

903
00:42:21,340 --> 00:42:24,305
所以這就是不過多是。

904
00:42:24,305 --> 00:42:24,805
50,000。

905
00:42:24,805 --> 00:42:32,860
他們你重新分配，要什麼
在C內存空間is--指針位於c

906
00:42:32,860 --> 00:42:34,510
指向其是。

907
00:42:34,510 --> 00:42:38,460
所以你重新定義為50,000。

908
00:42:38,460 --> 00:42:40,210
ANDI彭：她能
教節對我來說。

909
00:42:40,210 --> 00:42:41,260
下一次，這一切都屬於你。

910
00:42:41,260 --> 00:42:41,440
在這裡。

911
00:42:41,440 --> 00:42:42,564
下面是更多的糖果。

912
00:42:42,564 --> 00:42:45,790
你應該得到糖果的。

913
00:42:45,790 --> 00:42:47,260
>> 聽眾：我幾乎趕上了。

914
00:42:47,260 --> 00:42:47,660
>> ANDI彭：你幾乎趕上了。

915
00:42:47,660 --> 00:42:48,450
沒問題。

916
00:42:48,450 --> 00:42:48,950
是啊。

917
00:42:48,950 --> 00:42:50,033
但她是完全正確的。

918
00:42:50,033 --> 00:42:54,469
所以，你必須做的事
是that--我想我們

919
00:42:54,469 --> 00:42:56,510
必須遵循的事實
該指針是現在

920
00:42:56,510 --> 00:42:57,880
指向不同的值。

921
00:42:57,880 --> 00:43:01,785
所以value--很抱歉，
的C指針重新瞄準到。

922
00:43:01,785 --> 00:43:04,390
而且使轉向我們所有的數字。

923
00:43:04,390 --> 00:43:08,930
這就是為什麼，當你訪問
值存放在那裡，這是不同的。

924
00:43:08,930 --> 00:43:10,490
這是否有意義？

925
00:43:10,490 --> 00:43:11,380
確定。

926
00:43:11,380 --> 00:43:12,820
酷。

927
00:43:12,820 --> 00:43:16,635
大家好，我才繼續前進？

928
00:43:16,635 --> 00:43:25,332
>> 聽眾：請問the--時，你會
向下在左側列中的行，

929
00:43:25,332 --> 00:43:30,494
並在第一行影響第二次排
然後second--等，它們也all--

930
00:43:30,494 --> 00:43:31,160
ANDI彭：是的。

931
00:43:31,160 --> 00:43:37,610
所以，想像這就是我剛才輸入的代碼
在一個等於b乘以C，明星等於C。

932
00:43:37,610 --> 00:43:40,290
試想一下，我已經
只是跑這個代碼

933
00:43:40,290 --> 00:43:42,710
我沒有打印出什麼
所有這些事情。

934
00:43:42,710 --> 00:43:46,200
如果我只是打印第一
在上面的東西，它會在這裡。

935
00:43:46,200 --> 00:43:48,510
如果以後我跑了所有的
這些代碼行，

936
00:43:48,510 --> 00:43:51,160
這些值的應
是在末端是。

937
00:43:51,160 --> 00:43:53,290
>> 所以，其實我已經寫了一個程序在這裡。

938
00:43:53,290 --> 00:43:55,840
我沒有做過的所有的
乘法。

939
00:43:55,840 --> 00:43:58,310
但就可想而知了。

940
00:43:58,310 --> 00:44:00,370
所以在這裡我只是有一個
程序調用指針。

941
00:44:00,370 --> 00:44:04,190
我會，如果你guys--確定進行放大。

942
00:44:04,190 --> 00:44:07,580
所以，我創建變量a，b和c。

943
00:44:07,580 --> 00:44:09,640
我已經將它們等於
3，4和5，我已經

944
00:44:09,640 --> 00:44:11,770
創建了相應的指針。

945
00:44:11,770 --> 00:44:14,550
然後，在這裡我只是去
打印出那是什麼。

946
00:44:14,550 --> 00:44:15,833
因此，讓我跑了。

947
00:44:15,833 --> 00:44:21,520

948
00:44:21,520 --> 00:44:24,750
>> 難道你們see--廢話。

949
00:44:24,750 --> 00:44:28,150
難道你們看如何，
b和c是那些值

950
00:44:28,150 --> 00:44:33,530
但他們的指針是這個巨人
垃圾的價值，我們不關心？

951
00:44:33,530 --> 00:44:36,690
所以，如果我是真正堵塞
在所有的乘法

952
00:44:36,690 --> 00:44:39,770
然後重新打印所有的
這一點，將執行了

953
00:44:39,770 --> 00:44:44,509
到位於底部什麼。

954
00:44:44,509 --> 00:44:47,300
所以，如果你們想要玩
與實際的物理編碼，

955
00:44:47,300 --> 00:44:49,000
你們只需插上所有的。

956
00:44:49,000 --> 00:44:52,860
該代碼將在網上，然後你
值應打印到這事後。

957
00:44:52,860 --> 00:44:56,170
>> 然後你會看到如何指針
地址實際上重新分配。

958
00:44:56,170 --> 00:44:59,190
所以，你會怎麼看
的C地址實際上變成

959
00:44:59,190 --> 00:45:00,920
等於什麼的地址了。

960
00:45:00,920 --> 00:45:04,140
他們會匹配任何
這大量的。

961
00:45:04,140 --> 00:45:06,530
好問題。

962
00:45:06,530 --> 00:45:07,550
大家都沒事吧？

963
00:45:07,550 --> 00:45:10,300
最後一個電話的問題。

964
00:45:10,300 --> 00:45:11,590
確定。

965
00:45:11,590 --> 00:45:12,090
好的。

966
00:45:12,090 --> 00:45:15,940
所以準備讓你的心
吹稍微多一點。

967
00:45:15,940 --> 00:45:18,000
數組實際上只是指針。

968
00:45:18,000 --> 00:45:19,010
這就是它們。

969
00:45:19,010 --> 00:45:20,410
請記住，什麼是字符串？

970
00:45:20,410 --> 00:45:21,630
他們還數組。

971
00:45:21,630 --> 00:45:23,110
那麼，什麼是字符串真的嗎？

972
00:45:23,110 --> 00:45:27,100
他們就像指針到
開始更多的字符一個字符的。

973
00:45:27,100 --> 00:45:29,970
>> 所以，這只是概念開始
建立在彼此的頂部。

974
00:45:29,970 --> 00:45:32,030
所以這是why--您
記得在講座中，大衛，

975
00:45:32,030 --> 00:45:34,990
當他有這樣的比較
對INT字符串媽媽

976
00:45:34,990 --> 00:45:37,640
是什麼，然後
另一個字符串媽媽和你

977
00:45:37,640 --> 00:45:41,240
盡量等同兩人給對方，
他們給你不同的價值觀。

978
00:45:41,240 --> 00:45:44,370
這是因為字符串
本身不值。

979
00:45:44,370 --> 00:45:48,860
所有卻已是內存地址char--
他們是字符和數組的數組

980
00:45:48,860 --> 00:45:50,050
只是指針。

981
00:45:50,050 --> 00:45:54,022
>> 因此，在本質上，當
大衛comparing--

982
00:45:54,022 --> 00:45:55,355
那是正確的，如果我抹去這一切？

983
00:45:55,355 --> 00:46:02,320

984
00:46:02,320 --> 00:46:09,750
所以在講課時，大衛·
有媽等於等於媽，

985
00:46:09,750 --> 00:46:11,630
我們這似乎是同一件事。

986
00:46:11,630 --> 00:46:12,317
對嗎？

987
00:46:12,317 --> 00:46:15,150
但是，在下面的計算機
油煙機，實際發生的事情

988
00:46:15,150 --> 00:46:18,380
的是，這串，
所有這些都是是一個數組。

989
00:46:18,380 --> 00:46:21,420

990
00:46:21,420 --> 00:46:25,390
隨著ampersand--或者，對不起，
使用空終止底。

991
00:46:25,390 --> 00:46:28,311

992
00:46:28,311 --> 00:46:28,810
對嗎？

993
00:46:28,810 --> 00:46:29,940
反斜杠0。

994
00:46:29,940 --> 00:46:32,900
錯誤的反斜杠。

995
00:46:32,900 --> 00:46:35,960
>> 因此，所有這些were--所有
這兩個字符串were--

996
00:46:35,960 --> 00:46:40,360
是四肢大小的數組
媽媽和媽媽的信。

997
00:46:40,360 --> 00:46:44,780
但陣列真的只是
指針在存儲器中的特定位置

998
00:46:44,780 --> 00:46:47,140
告訴你開始你的陣列。

999
00:46:47,140 --> 00:46:52,370
所以在這種情況下，這一切是
只是一些垃圾的價值，

1000
00:46:52,370 --> 00:46:54,230
一些隨機指針。

1001
00:46:54,230 --> 00:46:56,330
而這一切都被
其他一些垃圾的價值。

1002
00:46:56,330 --> 00:46:59,830
遠的不說為0x200。

1003
00:46:59,830 --> 00:47:02,410
>> 所以，當您嘗試平等
它們兩彼此

1004
00:47:02,410 --> 00:47:06,130
他們評估為false，因為
在addresses--指針

1005
00:47:06,130 --> 00:47:08,390
它們were--是不同的。

1006
00:47:08,390 --> 00:47:11,400
雖然它是不同的，如果你
試圖比較實際的整數。

1007
00:47:11,400 --> 00:47:15,820
就像如果你想compare--
在最後example-- INT a到b，

1008
00:47:15,820 --> 00:47:17,640
他們將評估
要真正為艾略特說

1009
00:47:17,640 --> 00:47:19,431
因為他們是
被存儲在該整數

1010
00:47:19,431 --> 00:47:21,320
和你正在評估只值。

1011
00:47:21,320 --> 00:47:25,090
在這裡，因為字符串數組
和所有的數組的指針，

1012
00:47:25,090 --> 00:47:28,080
這就是為什麼他們不
彼此相等。

1013
00:47:28,080 --> 00:47:31,210
>> 所以，那種混亂的，該圖形。

1014
00:47:31,210 --> 00:47:32,450
但是，讓我們想像。

1015
00:47:32,450 --> 00:47:38,110
我們已經創建大小的數組
3從0索引到2-- 0，

1016
00:47:38,110 --> 00:47:41,530
1，2為1的值，
2，和3存儲在其中。

1017
00:47:41,530 --> 00:47:43,820
所有的陣列真
does--在這裡，我們只

1018
00:47:43,820 --> 00:47:46,720
說我創造一個指針
該陣列是

1019
00:47:46,720 --> 00:47:50,810
訪問的值
該數組的第一個索引。

1020
00:47:50,810 --> 00:47:52,890
所以在這裡這將是0。

1021
00:47:52,890 --> 00:47:53,390
對嗎？

1022
00:47:53,390 --> 00:47:56,820
大家是否明白如何
即第一行評估？

1023
00:47:56,820 --> 00:47:57,420
太好了。

1024
00:47:57,420 --> 00:48:00,800
>> 所以，如果你想進行初始化
在那之後的附加價值，

1025
00:48:00,800 --> 00:48:04,390
所有我們正在做的是重新分配。

1026
00:48:04,390 --> 00:48:08,810
所以0，1，2，1。

1027
00:48:08,810 --> 00:48:12,770
所以這個指針，曾經
指著在這裡，我們所做的

1028
00:48:12,770 --> 00:48:15,540
正在向下移動。

1029
00:48:15,540 --> 00:48:16,970
這就是加1在做什麼。

1030
00:48:16,970 --> 00:48:18,500
然後我們就可以把2中。

1031
00:48:18,500 --> 00:48:23,250
如果我們希望把3一
之後，我們會刪除該指針，

1032
00:48:23,250 --> 00:48:25,170
把3在那裡。

1033
00:48:25,170 --> 00:48:26,420
這是否有意義每個人？

1034
00:48:26,420 --> 00:48:26,920
是啊。

1035
00:48:26,920 --> 00:48:28,086
你有問題嗎？

1036
00:48:28,086 --> 00:48:30,711
聽眾：這是[聽不清]有
一個問題，我反正說了吧。

1037
00:48:30,711 --> 00:48:35,496
我不認為它實際上是一個
但是 - 在英語的問題，陣列

1038
00:48:35,496 --> 00:48:37,448
等於1是有道理的。

1039
00:48:37,448 --> 00:48:39,888
我們想，好，第一件事情。

1040
00:48:39,888 --> 00:48:44,280
但事情0指數
[聽不清]數組等於0

1041
00:48:44,280 --> 00:48:48,024
以指示第一點。

1042
00:48:48,024 --> 00:48:48,690
ANDI彭：是的。

1043
00:48:48,690 --> 00:48:53,740
所以，其實我在做什麼在這裡
我沒有訪問的第一個索引。

1044
00:48:53,740 --> 00:48:57,930
所有我doing--所以首先，
告訴我是什麼星陣呢？

1045
00:48:57,930 --> 00:48:59,480
什麼是一個指針之前，一個明星嗎？

1046
00:48:59,480 --> 00:49:00,855
>> 聽眾：它表示一個指針。

1047
00:49:00,855 --> 00:49:02,910
那你聲明的指針。

1048
00:49:02,910 --> 00:49:04,380
它de--

1049
00:49:04,380 --> 00:49:07,520
>> ANDI彭：它解引用此裝置
它會與實際獲取的價值。

1050
00:49:07,520 --> 00:49:08,020
對嗎？

1051
00:49:08,020 --> 00:49:13,030
所以在這種情況下，要得到
這裡，並設置為1的值。

1052
00:49:13,030 --> 00:49:13,800
是嗎？

1053
00:49:13,800 --> 00:49:17,050
所以我不actually--我不
真正關心的這個指標，

1054
00:49:17,050 --> 00:49:21,406
我做的僅僅是迭代下降
通過移動指針我向下排列。

1055
00:49:21,406 --> 00:49:23,280
然後最終我
要阻止它，對嗎？

1056
00:49:23,280 --> 00:49:26,750
而且我停止方式
是我擊球的時候，在案件

1057
00:49:26,750 --> 00:49:28,750
一個字符串，一個空終止的。

1058
00:49:28,750 --> 00:49:32,710
我知道，哦，如果我打一個back--如果我看到
反斜線0，我知道我做過這個

1059
00:49:32,710 --> 00:49:35,270
我知道我可以只
停止迭代通過。

1060
00:49:35,270 --> 00:49:36,200
非常好的問題。

1061
00:49:36,200 --> 00:49:40,210
>> 我們真的會走的更遠
在深入這個下週

1062
00:49:40,210 --> 00:49:43,990
因為一塊，那將
涉及到很多指針的使用。

1063
00:49:43,990 --> 00:49:48,459
但只知道，現在，
這只是一個不同的緩慢 - 

1064
00:49:48,459 --> 00:49:51,250
這只是一種不同的方式進行
電腦寫，從本質上講，

1065
00:49:51,250 --> 00:49:52,470
我們一直在做的。

1066
00:49:52,470 --> 00:49:54,900
就像大衛說
講課的樣子，我們

1067
00:49:54,900 --> 00:50:01,720
訪問數組只是做
陣列0，托架0，如果我們只是

1068
00:50:01,720 --> 00:50:04,050
想訪問的第一個值。

1069
00:50:04,050 --> 00:50:10,280
>> 所有計算機的工作正在轉向
那成和迭代本身。

1070
00:50:10,280 --> 00:50:13,580
因此，我們把它叫做句法
糖這只是

1071
00:50:13,580 --> 00:50:18,420
的話說用戶友好的一個奇特的方式
我們如何知道如何編程。

1072
00:50:18,420 --> 00:50:21,560
但是電腦
下面，它在做什麼，

1073
00:50:21,560 --> 00:50:23,997
它實際上只是有
指針多數民眾贊成調整。

1074
00:50:23,997 --> 00:50:26,330
但是，我們寫的方式，
因為它更容易為我們

1075
00:50:26,330 --> 00:50:30,240
考慮事情的角度
盒和如何移動向下拖曳，

1076
00:50:30,240 --> 00:50:32,190
是由具有括號。

1077
00:50:32,190 --> 00:50:36,394
對不起，這是真的，
真正但是 - 不好呀。

1078
00:50:36,394 --> 00:50:38,310
聽眾：那麼，如何會
你比較兩個字符串

1079
00:50:38,310 --> 00:50:40,560
看它們是否彼此相等的？

1080
00:50:40,560 --> 00:50:42,690
>> ANDI彭：大衛寫道：
這一計劃講座

1081
00:50:42,690 --> 00:50:45,274
所以我只是要去
在快速並簡單。

1082
00:50:45,274 --> 00:50:47,440
你會做這件事的方法
是，你實際上會

1083
00:50:47,440 --> 00:50:51,300
需要去比較
addresses--或值

1084
00:50:51,300 --> 00:50:52,810
從指針獲得。

1085
00:50:52,810 --> 00:50:55,140
所以請記住，你怎麼了
這裡獲得的價值？

1086
00:50:55,140 --> 00:50:56,825
我不關心地址在這裡。

1087
00:50:56,825 --> 00:50:58,950
我如何真正得到的
任何的價值在這裡？

1088
00:50:58,950 --> 00:50:59,470
>> 聽眾：[聽不清]。

1089
00:50:59,470 --> 00:51:00,261
>> ANDI鵬：沒錯。

1090
00:51:00,261 --> 00:51:05,090
所以，你比較的明星
這裡與這裡的明星。

1091
00:51:05,090 --> 00:51:06,150
那些是相等的。

1092
00:51:06,150 --> 00:51:07,690
然後你去。

1093
00:51:07,690 --> 00:51:09,530
是這裡的明星，
明星在這裡一樣的嗎？

1094
00:51:09,530 --> 00:51:10,030
確定。

1095
00:51:10,030 --> 00:51:10,283
他們是平等的。

1096
00:51:10,283 --> 00:51:12,866
而你只是保持下去
直到你擊中雙方的結束。

1097
00:51:12,866 --> 00:51:16,190
如果所有的人都是平等的，那麼
你知道你的字符串是相等的。

1098
00:51:16,190 --> 00:51:18,130
與C實際上有一個
功能書面叫

1099
00:51:18,130 --> 00:51:20,713
字符串比較這其實只是
這是否給你，讓你不“

1100
00:51:20,713 --> 00:51:22,140
要自己寫。

1101
00:51:22,140 --> 00:51:23,274
是嗎？

1102
00:51:23,274 --> 00:51:26,970
>> 聽眾：我想在講座
當我們做了比較。

1103
00:51:26,970 --> 00:51:29,520
我們並不真正需要一個
如pi櫃檯，對不對？

1104
00:51:29,520 --> 00:51:34,310
>> ANDI彭：你不
因為我們真的不關心

1105
00:51:34,310 --> 00:51:36,250
我們已經多少盒通過迭代。

1106
00:51:36,250 --> 00:51:39,580
我們所關心的是，我們要
繼續下去，直到我知道停下來。

1107
00:51:39,580 --> 00:51:41,990
你知道停止的時候
有某種指示

1108
00:51:41,990 --> 00:51:45,310
你是在一個空終止。

1109
00:51:45,310 --> 00:51:45,930
是啊。

1110
00:51:45,930 --> 00:51:47,154
So--

1111
00:51:47,154 --> 00:51:48,070
聽眾：[聽不清]。

1112
00:51:48,070 --> 00:51:48,736
ANDI彭：是的。

1113
00:51:48,736 --> 00:51:51,950
因此，在比較的情況下
串，我真的不

1114
00:51:51,950 --> 00:51:54,207
關心多少個字母
are--我需要比較

1115
00:51:54,207 --> 00:51:56,540
如果他們是真的還是假的，如果
它們彼此相等。

1116
00:51:56,540 --> 00:51:58,914
我不在乎多少個字母
在他們每個人的，對吧？

1117
00:51:58,914 --> 00:52:01,130
我只關心這個
與此和所述一個匹配

1118
00:52:01,130 --> 00:52:05,311
火柴和之後的一個接
比賽一路上揚，直到結束。

1119
00:52:05,311 --> 00:52:05,810
對嗎？

1120
00:52:05,810 --> 00:52:07,000
這是否有意義？

1121
00:52:07,000 --> 00:52:10,166
>> 所以，我真的不關心有多少信件，
我只關心，所有的字母

1122
00:52:10,166 --> 00:52:11,050
匹配。

1123
00:52:11,050 --> 00:52:12,910
是啊。

1124
00:52:12,910 --> 00:52:13,920
確定。

1125
00:52:13,920 --> 00:52:16,840
我可以從這個感動嗎？

1126
00:52:16,840 --> 00:52:18,489
太好了。

1127
00:52:18,489 --> 00:52:21,280
我們正在運行有點短上
時間，所以我將只允許你

1128
00:52:21,280 --> 00:52:23,670
球員簡要回顧一下這個。

1129
00:52:23,670 --> 00:52:26,430
運行到你的ID，如果
你們是好奇。

1130
00:52:26,430 --> 00:52:30,030
而且你們可以看到什麼
這將被打印出。

1131
00:52:30,030 --> 00:52:30,640
確定。

1132
00:52:30,640 --> 00:52:34,990
>> 所以的東西，我們也將觸及一個
位指針運算的想法。

1133
00:52:34,990 --> 00:52:38,180
其中，所有的都好，就是
而不是調整

1134
00:52:38,180 --> 00:52:42,610
的所存儲的值
在您的指針的地址，

1135
00:52:42,610 --> 00:52:45,030
它只是實際改變
地址本身。

1136
00:52:45,030 --> 00:52:49,420
所以，如果你作為人的通緝
手動調整指針，

1137
00:52:49,420 --> 00:52:52,700
你會做到這一點的方法就是
做指針的n倍的大小。

1138
00:52:52,700 --> 00:52:53,240
對嗎？

1139
00:52:53,240 --> 00:52:54,810
>> 因此，一個int。

1140
00:52:54,810 --> 00:52:58,580
一個int--多少字節
在內存中是一個int？

1141
00:52:58,580 --> 00:52:59,640
這是四，對不對？

1142
00:52:59,640 --> 00:53:03,520
所以，如果我知道，我把所有的數組
整數，我希望它指向一個

1143
00:53:03,520 --> 00:53:08,470
後來，我知道，我只是要
移動我的指針下四個字節，對不對？

1144
00:53:08,470 --> 00:53:12,440
因此n次的大小
的指針字節

1145
00:53:12,440 --> 00:53:15,890
然而，多少字節，你只是
要通過移動鼠標指針向下。

1146
00:53:15,890 --> 00:53:20,350
>> 因此，例如，如果我們有一個數組
整數，第一個，我們只能說，

1147
00:53:20,350 --> 00:53:22,280
被存儲為0x00。

1148
00:53:22,280 --> 00:53:26,150
你知道下一次將是在
0×04，因為這四個字節後面。

1149
00:53:26,150 --> 00:53:31,030
而在這之後的人會
為0x08等等等等。

1150
00:53:31,030 --> 00:53:33,830
所以，伙計們，一起來看看。

1151
00:53:33,830 --> 00:53:36,640
>> 所有你在這裡所做的是
你有一個指針ÿ

1152
00:53:36,640 --> 00:53:43,700
而你還說你
內存，讓您可以向下移動

1153
00:53:43,700 --> 00:53:45,559
的存儲器塊進行分配。

1154
00:53:45,559 --> 00:53:46,850
樣的一個更高層次的概念。

1155
00:53:46,850 --> 00:53:48,820
你們將不再需要
要知道，本週，

1156
00:53:48,820 --> 00:53:51,290
但是這一切都在做那裡。

1157
00:53:51,290 --> 00:53:55,190

1158
00:53:55,190 --> 00:53:55,900
確定。

1159
00:53:55,900 --> 00:53:56,710
>> 另一個笑話時間。

1160
00:53:56,710 --> 00:54:01,360

1161
00:54:01,360 --> 00:54:02,780
兩串走進一間酒吧。

1162
00:54:02,780 --> 00:54:05,713
一個人說，我想一個朗姆酒
可樂垃圾值。

1163
00:54:05,713 --> 00:54:08,796
另一個人說，你得原諒
我的朋友，他沒有空值終止。

1164
00:54:08,796 --> 00:54:10,390
你們得到它。

1165
00:54:10,390 --> 00:54:10,890
抱歉。

1166
00:54:10,890 --> 00:54:13,490
這就是我如何保持自己
當我預習的節會

1167
00:54:13,490 --> 00:54:15,650
是我插入了幾個笑話幻燈片。

1168
00:54:15,650 --> 00:54:16,150
反正。

1169
00:54:16,150 --> 00:54:21,460

1170
00:54:21,460 --> 00:54:21,960
確定。

1171
00:54:21,960 --> 00:54:24,290
之前，我謹on--
因此，從本質上講，我們已經

1172
00:54:24,290 --> 00:54:30,600
涵蓋了所有的概念
有關指針的問題。

1173
00:54:30,600 --> 00:54:34,090
然後，我們將talk--移動
更多的，說說為什麼這很重要

1174
00:54:34,090 --> 00:54:37,810
以及如何裝配到
理念的內存管理。

1175
00:54:37,810 --> 00:54:39,810
但在此之前我繼續前進，
有沒有人有問題

1176
00:54:39,810 --> 00:54:43,880
關於指針使用，這是​​怎麼回事
當你創建的指針上，

1177
00:54:43,880 --> 00:54:47,540
如何引用各
另外，它們是怎樣被提領？

1178
00:54:47,540 --> 00:54:51,760
有關的任何問題
之前，我繼續前進？

1179
00:54:51,760 --> 00:54:53,060
確定。

1180
00:54:53,060 --> 00:54:54,770
太好了。

1181
00:54:54,770 --> 00:54:58,170
>> 因此，這給我們帶來了這個
較大的更高層次的概念

1182
00:54:58,170 --> 00:55:00,310
內存管理的全過程。

1183
00:55:00,310 --> 00:55:02,720
因此，基本上，在
您的計算機，有

1184
00:55:02,720 --> 00:55:06,300
兩種基本類型的存儲器或
在其中的存儲區域被存儲。

1185
00:55:06,300 --> 00:55:10,210
您這裡有什麼所謂
堆和你在這兒

1186
00:55:10,210 --> 00:55:11,550
什麼叫做堆棧。

1187
00:55:11,550 --> 00:55:13,966
而且我們要談談
棧首先是因為它是

1188
00:55:13,966 --> 00:55:16,910
更finagley一個你
有一種概念

1189
00:55:16,910 --> 00:55:18,570
明白這是怎麼回事。

1190
00:55:18,570 --> 00:55:23,930
>> 因此，所有的堆疊is--想到的
它作為存儲器中的物理棧

1191
00:55:23,930 --> 00:55:28,880
那就是你有一個內存塊
多數民眾贊成預留程序

1192
00:55:28,880 --> 00:55:30,180
而它的運行。

1193
00:55:30,180 --> 00:55:34,480
這是在哪裡，基本上，所有的
您的局部變量的存儲位置。

1194
00:55:34,480 --> 00:55:38,300
所以這只是一個放大
在那一疊照片。

1195
00:55:38,300 --> 00:55:41,060
堆棧那裡，我
只是放大了一點。

1196
00:55:41,060 --> 00:55:46,170
>> 因此，基本上，在堆疊有
在你的程序了一堆功能。

1197
00:55:46,170 --> 00:55:48,250
所以，就讓我們回去
到本週二的例子

1198
00:55:48,250 --> 00:55:51,450
在這裡，我們有我們的主要功能
以及一個立方體功能

1199
00:55:51,450 --> 00:55:56,410
在這裡我們試圖建立一個函數，
cubed--是把參數作為輸入，

1200
00:55:56,410 --> 00:55:59,110
立方他們返回
他們回到主。

1201
00:55:59,110 --> 00:56:02,459
這樣的方式，一個儲存在存儲器
是，你有你的主要功能

1202
00:56:02,459 --> 00:56:03,250
這裡在底部。

1203
00:56:03,250 --> 00:56:06,630
然後用每個附加功能
您致電，並添加最重要的是，

1204
00:56:06,630 --> 00:56:07,960
內存只是堆在上面。

1205
00:56:07,960 --> 00:56:10,190
把它看成是一個物理堆疊。

1206
00:56:10,190 --> 00:56:13,570
>> 所以，你有在座的各位主要
你的主要函數的變量，

1207
00:56:13,570 --> 00:56:15,260
一切是怎麼回事，存儲。

1208
00:56:15,260 --> 00:56:17,440
然後當你打電話
立方體，它會和它

1209
00:56:17,440 --> 00:56:20,810
創建的所有副本
參數和它們存儲

1210
00:56:20,810 --> 00:56:23,010
上面在不同的地方。

1211
00:56:23,010 --> 00:56:24,280
所以，我們為什麼要在乎？

1212
00:56:24,280 --> 00:56:29,220
我們關心的原因是，我們不能只
使用的參數這裡 - 變量

1213
00:56:29,220 --> 00:56:33,080
這裡 - 我們改變它們，我們預計
他們還可以在這裡改變了，對不對？

1214
00:56:33,080 --> 00:56:35,910
>> 的想法是，他們保存的
在存儲器不同的地方

1215
00:56:35,910 --> 00:56:40,540
這樣一來，當你訪問不同
功能，你的想法正在發生的事情

1216
00:56:40,540 --> 00:56:45,520
實際上並沒有發生，因為
存儲器位未互連。

1217
00:56:45,520 --> 00:56:50,530
這樣一來，問題是真的
重要的是我們那種理解

1218
00:56:50,530 --> 00:56:54,100
是，如果，當我們運行
程序，函數的大小

1219
00:56:54,100 --> 00:56:57,159
堆棧frame--這樣的身體，怎麼
多少內存？我們給它？

1220
00:56:57,159 --> 00:56:59,950
也許這是一個巨大的功能，所以我們
必須給它那麼多的內存。

1221
00:56:59,950 --> 00:57:02,230
但如果是小的，我們會
需要一個小點點。

1222
00:57:02,230 --> 00:57:05,980
>> 這樣的想法是，我們正在運行時
一個程序，函數的大小

1223
00:57:05,980 --> 00:57:09,100
取決於多少
變量和變量的類型

1224
00:57:09,100 --> 00:57:10,940
我們想給它。

1225
00:57:10,940 --> 00:57:13,910
但是，如果數量
variables--及其大小，

1226
00:57:13,910 --> 00:57:16,140
多數民眾贊成堅決不
通過你的編碼器，但

1227
00:57:16,140 --> 00:57:20,580
是由實際確定的
用戶程序的。

1228
00:57:20,580 --> 00:57:24,240
所以，如果我想創建一個函數
這把字符串從用戶，

1229
00:57:24,240 --> 00:57:27,630
但我真的不知道有多大
這些字符串是，這對我來說很難

1230
00:57:27,630 --> 00:57:30,220
以配發的具體
所需的內存量。

1231
00:57:30,220 --> 00:57:30,920
對嗎？

1232
00:57:30,920 --> 00:57:35,234
>> 因為如果這個function--如果
該用戶輸入一個巨大的字符串，

1233
00:57:35,234 --> 00:57:37,650
它會創建一個錯誤
什麼叫基本

1234
00:57:37,650 --> 00:57:42,190
堆棧溢出，你超越
你有內存的邊界。

1235
00:57:42,190 --> 00:57:44,250
所以，那麼我們該怎麼辦？

1236
00:57:44,250 --> 00:57:47,290
如果我們不能創造這個巨人
堆疊，可以節省一切，

1237
00:57:47,290 --> 00:57:50,260
我們怎麼做才能解決這個問題？

1238
00:57:50,260 --> 00:57:54,364
>> 因此，我們要繼續前進和談話
關於此第二類型的存儲器

1239
00:57:54,364 --> 00:57:56,780
然後我們可以談論如何
我們可以使用兩者結合起來

1240
00:57:56,780 --> 00:57:58,550
要解決這個問題。

1241
00:57:58,550 --> 00:58:01,024
所以，現在我們要動起來
到的存儲器的不同部分

1242
00:58:01,024 --> 00:58:01,690
在我們的電腦。

1243
00:58:01,690 --> 00:58:03,215
這就是所謂的堆。

1244
00:58:03,215 --> 00:58:07,150
因此，所有的堆是一個游泳池
可用內存

1245
00:58:07,150 --> 00:58:08,690
可動態分配。

1246
00:58:08,690 --> 00:58:12,420
這樣，可以改變，同時
你的程序正在運行。

1247
00:58:12,420 --> 00:58:15,160
>> 等的區域
未使用的內存，可以

1248
00:58:15,160 --> 00:58:18,200
是allowed--，可以是
分配與功能

1249
00:58:18,200 --> 00:58:20,490
所謂的malloc或內存分配。

1250
00:58:20,490 --> 00:58:23,110
因此，本質上，當
你正在運行的程序，

1251
00:58:23,110 --> 00:58:29,560
你可以動態創建的內存
堆和使用，所有到這裡。

1252
00:58:29,560 --> 00:58:34,280
因此然後，所有的功能
在這裡可以訪問堆。

1253
00:58:34,280 --> 00:58:37,960
>> 所以malloc的，這種想法，大衛·
一種快速，簡單地掩蓋

1254
00:58:37,960 --> 00:58:41,570
在講座中，僅僅是一種方式，
你控制你的記憶。

1255
00:58:41,570 --> 00:58:45,470
就像，當你剛剛創建
堆疊功能，當你剛

1256
00:58:45,470 --> 00:58:48,290
讓您的主要功能
與您的隨機函數，

1257
00:58:48,290 --> 00:58:52,270
你認為他們是孩子，僅僅
逃跑的時候，你已經做完了他們。

1258
00:58:52,270 --> 00:58:53,690
他們真的壞事兒。

1259
00:58:53,690 --> 00:58:55,515
創建它們，你
教給他們的東西，

1260
00:58:55,515 --> 00:58:57,640
然後當你想
再次訪問他們，他們是

1261
00:58:57,640 --> 00:58:59,850
不存在，因為你的
內存剛剛跑掉了。

1262
00:58:59,850 --> 00:59:04,140
>> 但malloc或堆，是一種
具有較好的兒童，在那裡

1263
00:59:04,140 --> 00:59:07,090
一種可以創建
他們，將它們分配值，

1264
00:59:07,090 --> 00:59:11,080
使用them--聽起來真
bad--使用它們不過你想要的，

1265
00:59:11,080 --> 00:59:14,002
但能夠控制
他們，然後釋放內存

1266
00:59:14,002 --> 00:59:14,960
每當你需要他們。

1267
00:59:14,960 --> 00:59:18,085
那麼，當你和你做
功能，孩子們回來找你

1268
00:59:18,085 --> 00:59:20,290
你仍然有數據存在。

1269
00:59:20,290 --> 00:59:25,690
>> 因此，我們的malloc，或創建方式，
內存是由函數void明星

1270
00:59:25,690 --> 00:59:26,790
malloc的大小以字節為單位。

1271
00:59:26,790 --> 00:59:29,730
所以，這只是原型
為什麼我們這樣做。

1272
00:59:29,730 --> 00:59:35,800
因此，一個例子就是我們創建一個指針
類型int-- INT星級pointer--平等

1273
00:59:35,800 --> 00:59:38,120
整型malloc的大小。

1274
00:59:38,120 --> 00:59:41,734
那麼，為什麼我們做大小的原因
的，而不是只是一個number--

1275
00:59:41,734 --> 00:59:43,650
因為大家都知道，
一個int四個字節，

1276
00:59:43,650 --> 00:59:48,310
right--而是一個int是只有四
字節在某些操作系統。

1277
00:59:48,310 --> 00:59:50,410
>> 作為這個想法對我們來說
程序員是我們

1278
00:59:50,410 --> 00:59:53,160
要創建代碼，可以
運行中的所有計算機，而不僅僅是

1279
00:59:53,160 --> 00:59:54,860
我們簡單的電腦。

1280
00:59:54,860 --> 00:59:58,350
所以這就是為什麼我們喜歡用
的大小，而不是只數4。

1281
00:59:58,350 --> 00:59:59,970
這是否有意義給大家？

1282
00:59:59,970 --> 01:00:03,930
因此，大小of--所有它是一個C
函數或運算符

1283
01:00:03,930 --> 01:00:09,350
告訴你多少字節的內存呢
某種類型的變量佔用。

1284
01:00:09,350 --> 01:00:11,150
所以在這種情況下，一個int的尺寸為四。

1285
01:00:11,150 --> 01:00:12,090
四個字節。

1286
01:00:12,090 --> 01:00:15,490
和malloc是要釋放
在你的堆四個字節，

1287
01:00:15,490 --> 01:00:18,790
然後你就可以在你的主要用途
功能，以便能夠存儲存儲器。

1288
01:00:18,790 --> 01:00:22,460

1289
01:00:22,460 --> 01:00:24,860
是每個人都在說清楚這麼遠嗎？

1290
01:00:24,860 --> 01:00:25,918
是嗎？

1291
01:00:25,918 --> 01:00:28,122
>> 聽眾：我很清楚，但
剛剛結束clear--

1292
01:00:28,122 --> 01:00:28,705
ANDI彭：OK。

1293
01:00:28,705 --> 01:00:29,246
完全罰款。

1294
01:00:29,246 --> 01:00:32,176
聽眾：--size是[聽不清]
實際上可以[聽不清]

1295
01:00:32,176 --> 01:00:34,384
它會怎麼做的
我們希望它的東西。

1296
01:00:34,384 --> 01:00:35,380
這不是一些偽代碼。

1297
01:00:35,380 --> 01:00:35,878
>> ANDI彭：沒有。

1298
01:00:35,878 --> 01:00:36,874
>> 聽眾：這就像一個真正件事 - 

1299
01:00:36,874 --> 01:00:37,372
>> ANDI彭：這是真正的代碼。

1300
01:00:37,372 --> 01:00:38,455
>> 聽眾： - 我們可以使用它。

1301
01:00:38,455 --> 01:00:39,862
這是實際的。

1302
01:00:39,862 --> 01:00:40,418
酷。

1303
01:00:40,418 --> 01:00:41,751
ANDI彭：尺寸自帶C.

1304
01:00:41,751 --> 01:00:43,475
聽眾：那讓我的生活更幸福。

1305
01:00:43,475 --> 01:00:45,550
ANDI彭：是的。

1306
01:00:45,550 --> 01:00:48,610
所以，如果你是一個懶惰的程序員
有點像我，有時，

1307
01:00:48,610 --> 01:00:50,402
我不喜歡記憶
什麼尺寸的一個int

1308
01:00:50,402 --> 01:00:52,734
是的，我不喜歡記憶
有一個浮動的大小。

1309
01:00:52,734 --> 01:00:55,160
只是尺寸告訴你什麼
這是，這是一個容易得多。

1310
01:00:55,160 --> 01:00:59,880

1311
01:00:59,880 --> 01:01:00,440
>> 好的。

1312
01:01:00,440 --> 01:01:02,160
因此，一個重要的事情
那你們都想要

1313
01:01:02,160 --> 01:01:04,620
要記住，當你
使用malloc是您永遠

1314
01:01:04,620 --> 01:01:06,400
必須進行檢查，看它是否為空。

1315
01:01:06,400 --> 01:01:08,630
所以，就像我說的，回
該照片的堆。

1316
01:01:08,630 --> 01:01:11,390
堆就是這個巨人
內存堆棧，你有。

1317
01:01:11,390 --> 01:01:16,740
而你要能夠把塊
從它的內存並使用它，對嗎？

1318
01:01:16,740 --> 01:01:19,750
>> 但是，如果你沒有
在這堆更多的內存？

1319
01:01:19,750 --> 01:01:23,650
如果我已經用什麼都
它和我嘗試對malloc更多？

1320
01:01:23,650 --> 01:01:24,864
不存在。

1321
01:01:24,864 --> 01:01:26,780
嗯，這就是為什麼你
要得到一個錯誤。

1322
01:01:26,780 --> 01:01:29,220
你會賽格故障。你會
有段錯誤，你

1323
01:01:29,220 --> 01:01:30,940
嘗試訪問的東西都是不存在的。

1324
01:01:30,940 --> 01:01:33,180
這樣一來，這樣我們做
那和方式，我們

1325
01:01:33,180 --> 01:01:36,120
防止的是，我們檢查
以查看是否指針的空。

1326
01:01:36,120 --> 01:01:41,650
>> 所以，如果我是對malloc的東西
我沒有更多的內存，

1327
01:01:41,650 --> 01:01:45,501
這將打印，因為一個錯誤
指針回到你只是空。

1328
01:01:45,501 --> 01:01:47,750
這樣一來，這樣我們做this--
這下好了設計，

1329
01:01:47,750 --> 01:01:52,140
只是記住this--是任何
一次嘗試的malloc什麼，

1330
01:01:52,140 --> 01:01:55,300
你將需要
檢查，看它是否是空。

1331
01:01:55,300 --> 01:01:58,257
因為每當你嘗試
從堆中獲取內存，

1332
01:01:58,257 --> 01:02:00,340
你總是要做出
確保您有記憶。

1333
01:02:00,340 --> 01:02:01,350
這就是它。

1334
01:02:01,350 --> 01:02:04,980
>> 因此，相當多這三個
行代碼，熟記。

1335
01:02:04,980 --> 01:02:06,830
每次你的malloc，撲通一聲他們進來。

1336
01:02:06,830 --> 01:02:08,190
你會需要它們。

1337
01:02:08,190 --> 01:02:10,540
因為我向你保證，我們將
測試你的情況，你的電腦

1338
01:02:10,540 --> 01:02:13,498
會爆炸，因為你
要嘗試存取存儲器的

1339
01:02:13,498 --> 01:02:16,680
不存在，事情將要
偶們這不會是好的。

1340
01:02:16,680 --> 01:02:19,290
因此，只要鑽取到你的大腦。

1341
01:02:19,290 --> 01:02:21,370
malloc的，無效。

1342
01:02:21,370 --> 01:02:22,360
好。

1343
01:02:22,360 --> 01:02:22,860
好的。

1344
01:02:22,860 --> 01:02:26,280

1345
01:02:26,280 --> 01:02:28,340
>> 那麼這生子;
發生了什麼問題

1346
01:02:28,340 --> 01:02:30,550
我們正在使用的內存後完成。

1347
01:02:30,550 --> 01:02:32,390
因為整個的想法
具有的malloc是

1348
01:02:32,390 --> 01:02:36,460
我們有這樣的堆，我們可以採取
從內存中，然後我們可以使用它。

1349
01:02:36,460 --> 01:02:37,220
對嗎？

1350
01:02:37,220 --> 01:02:40,550
然後，我們要記住
在這之後，我們用它做，

1351
01:02:40,550 --> 01:02:41,900
那麼我們就可以釋放它。

1352
01:02:41,900 --> 01:02:42,400
隨它去吧。

1353
01:02:42,400 --> 01:02:43,979
我們可以讓他走了。

1354
01:02:43,979 --> 01:02:47,020
要不然你也將洩漏
內存和更壞的事情會發生。

1355
01:02:47,020 --> 01:02:49,010
>> 從本質上講，只要
你觸摸存儲器，

1356
01:02:49,010 --> 01:02:51,800
如果不好的事情會發生
不正確地做事情。

1357
01:02:51,800 --> 01:02:55,150
所以，你必須檢查，首先，
如果您有可用的存儲空間。

1358
01:02:55,150 --> 01:02:58,700
然後就大功告成了之後，你要
釋放它，讓你的操作系統

1359
01:02:58,700 --> 01:03:00,690
把它收回。

1360
01:03:00,690 --> 01:03:04,870
所以我們這樣做的方式就是這樣
功能，無空隙，指針

1361
01:03:04,870 --> 01:03:06,370
以內存堆。

1362
01:03:06,370 --> 01:03:08,680
>> 所以這個例子是自由指針。

1363
01:03:08,680 --> 01:03:11,580
這是很容易，操作簡單，
不要忘記它。

1364
01:03:11,580 --> 01:03:14,687
因此，檢查，看它是否為null，免費的。

1365
01:03:14,687 --> 01:03:15,270
每個人都好？

1366
01:03:15,270 --> 01:03:22,660

1367
01:03:22,660 --> 01:03:27,325
所以再次，代碼，你們
可以種迅速採取了一眼。

1368
01:03:27,325 --> 01:03:34,964

1369
01:03:34,964 --> 01:03:37,880
我知道這是一個很多新的語法和
它的所有權利，如果你喜歡啊，

1370
01:03:37,880 --> 01:03:38,963
這是什麼意思了嗎？

1371
01:03:38,963 --> 01:03:40,250
無後顧之憂。

1372
01:03:40,250 --> 01:03:46,785
所有這一切都意味著要被顯示
一個動作，如何將所有這些東西

1373
01:03:46,785 --> 01:03:47,660
可以一起使用。

1374
01:03:47,660 --> 01:03:52,190

1375
01:03:52,190 --> 01:03:54,190
所以這是放在一起
就像一群過去

1376
01:03:54,190 --> 01:03:56,532
幻燈片，我們只是去
通過到一個程序。

1377
01:03:56,532 --> 01:03:58,240
聽眾：在某種程度上
我們可以actually--

1378
01:03:58,240 --> 01:03:59,570
ANDI彭：在一個方式，
我們實際上可以使用。

1379
01:03:59,570 --> 01:04:02,379
你可以放下了到您的ID，
你可以運行它，它會工作。

1380
01:04:02,379 --> 01:04:02,920
聽眾：OK。

1381
01:04:02,920 --> 01:04:04,140
所以這是真的嗎？

1382
01:04:04,140 --> 01:04:05,580
>> ANDI彭：這是真實的。

1383
01:04:05,580 --> 01:04:06,430
是啊。

1384
01:04:06,430 --> 01:04:08,690
我盡量做到讓
字體是不同的，因此

1385
01:04:08,690 --> 01:04:11,770
每當我鍵入真實的
代碼中的字體是字體代碼

1386
01:04:11,770 --> 01:04:15,471
而我記的代碼是不同的，但
我不知道是否實際工作。

1387
01:04:15,471 --> 01:04:16,012
聽眾：第

1388
01:04:16,012 --> 01:04:17,190
我想that--

1389
01:04:17,190 --> 01:04:18,213
>> ANDI彭：OK。

1390
01:04:18,213 --> 01:04:20,578
>> 聽眾：--sometimes
[聽不清]和我

1391
01:04:20,578 --> 01:04:23,416
像，這將是真的很可愛
如果它實際上是一個有用的事

1392
01:04:23,416 --> 01:04:24,812
但它不是一個有用的東西。

1393
01:04:24,812 --> 01:04:26,270
我想，這是一個有用的事情。

1394
01:04:26,270 --> 01:04:27,010
>> ANDI彭：OK。

1395
01:04:27,010 --> 01:04:27,510
是啊。

1396
01:04:27,510 --> 01:04:28,430
我會通過沿。

1397
01:04:28,430 --> 01:04:33,266
要像大衛，孩子真的
傷心的時候你寫假的代碼。

1398
01:04:33,266 --> 01:04:34,240
好的。

1399
01:04:34,240 --> 01:04:34,740
是嗎？

1400
01:04:34,740 --> 01:04:37,686
>> 聽眾：所以這裡的PTR
實際上不是一個指針，

1401
01:04:37,686 --> 01:04:41,130
它的內存塊？

1402
01:04:41,130 --> 01:04:45,130
>> ANDI彭：所以你在說什麼
第一行或一跌嗎？

1403
01:04:45,130 --> 01:04:48,170
你說的是這個嗎？

1404
01:04:48,170 --> 01:04:50,910
>> 聽眾：在PTR是
in--不同的東西

1405
01:04:50,910 --> 01:04:53,230
>> ANDI彭：嗯，所以在這裡
我所實際doing--，

1406
01:04:53,230 --> 01:04:54,660
讓我們只經過這裡。

1407
01:04:54,660 --> 01:04:57,120
這種關係在
所有很好的概念。

1408
01:04:57,120 --> 01:05:01,840
所以在這裡，我們有INT明星PTR。

1409
01:05:01,840 --> 01:05:04,160
所以詮釋的指針，這就是
我們實際上創建

1410
01:05:04,160 --> 01:05:06,550
一個指針指向一個整數。

1411
01:05:06,550 --> 01:05:08,230
那麼，它會指向一個整數。

1412
01:05:08,230 --> 01:05:12,135
而且我們要malloc或
給它，足夠的內存分配

1413
01:05:12,135 --> 01:05:13,200
存儲的整數。

1414
01:05:13,200 --> 01:05:14,910
在這種情況下，這樣的四個字節。

1415
01:05:14,910 --> 01:05:18,024
>> 然後如果這等於null--平等
等於null--我們要打印。

1416
01:05:18,024 --> 01:05:20,440
哦，你因為一個錯誤
你出的內存，對不對？

1417
01:05:20,440 --> 01:05:22,814
否則，返回之一，
這只是告訴你的程序

1418
01:05:22,814 --> 01:05:24,170
你已經有了一個錯誤。

1419
01:05:24,170 --> 01:05:26,850
然後，如果你這樣做
有記憶，它的

1420
01:05:26,850 --> 01:05:33,230
要存儲什麼讓
INT讓你進入的位置

1421
01:05:33,230 --> 01:05:35,460
並將其設置為指針的值。

1422
01:05:35,460 --> 01:05:38,500
因此，它實際上會
從物理上刪除該值

1423
01:05:38,500 --> 01:05:41,702
並把一切得到int返回。

1424
01:05:41,702 --> 01:05:43,910
然後，你要
無論他們進入打印。

1425
01:05:43,910 --> 01:05:46,080
>> 聽眾：這就是
要在堆？

1426
01:05:46,080 --> 01:05:47,060
>> ANDI彭：這是怎麼回事
將在堆。

1427
01:05:47,060 --> 01:05:48,768
>> 聽眾：所以這
將是可訪問。

1428
01:05:48,768 --> 01:05:51,220
ANDI鵬：沒錯。

1429
01:05:51,220 --> 01:05:52,600
美觀大方。

1430
01:05:52,600 --> 01:05:53,756
好。

1431
01:05:53,756 --> 01:05:59,289
>> 聽眾：所以當我們釋放PTR在這個
最後一步，我們正在釋放指針

1432
01:05:59,289 --> 01:06:00,724
或者我們正在釋放塊？

1433
01:06:00,724 --> 01:06:01,390
ANDI彭：是的。

1434
01:06:01,390 --> 01:06:05,570
因此，我們正在釋放pointer--
好了，釋放的內存塊。

1435
01:06:05,570 --> 01:06:08,780
所以唯一的辦法，我們甚至可以訪問
存儲器是由具有指針。

1436
01:06:08,780 --> 01:06:10,730
如果你沒有指針，你
喜歡的哦，我不知道它在哪裡，

1437
01:06:10,730 --> 01:06:11,290
對不對？

1438
01:06:11,290 --> 01:06:13,956
如果你釋放它的話，你基本上
釋放了整個街區。

1439
01:06:13,956 --> 01:06:16,500
那麼你的計算機知道，哦，
沒有什麼可用的在這裡，

1440
01:06:16,500 --> 01:06:19,396
我可以把垃圾
值回了一遍。

1441
01:06:19,396 --> 01:06:21,590
>> 聽眾：所以整數確實存在的呢？

1442
01:06:21,590 --> 01:06:23,481
>> ANDI彭：不要整數存在嗎？

1443
01:06:23,481 --> 01:06:23,980
抱歉。

1444
01:06:23,980 --> 01:06:25,271
你能否重新表述您的問題嗎？

1445
01:06:25,271 --> 01:06:28,330
聽眾：我的意思是，你釋放後，
指針，整數，你得到的，

1446
01:06:28,330 --> 01:06:29,990
將仍然存在？

1447
01:06:29,990 --> 01:06:31,360
>> ANDI彭：不，不會。

1448
01:06:31,360 --> 01:06:34,070

1449
01:06:34,070 --> 01:06:37,550
或者至少它會存在於你
你的電腦做之前，內存

1450
01:06:37,550 --> 01:06:40,231
不管它，但有
沒辦法讓你拿到。

1451
01:06:40,231 --> 01:06:41,480
因為你釋放的指針。

1452
01:06:41,480 --> 01:06:43,150
你不知道它在哪裡了。

1453
01:06:43,150 --> 01:06:43,650
是啊。

1454
01:06:43,650 --> 01:06:46,500

1455
01:06:46,500 --> 01:06:48,560
>> 我打算在這裡移動。

1456
01:06:48,560 --> 01:06:49,060
唷。

1457
01:06:49,060 --> 01:06:53,012
因此，我們通過大量的概念的
內存管理困難

1458
01:06:53,012 --> 01:06:54,720
我們正要
基本上花

1459
01:06:54,720 --> 01:06:57,090
5，十幾分鐘去
在語法的事情，

1460
01:06:57,090 --> 01:07:03,240
將是可用的，並為你們有用，
但沒有太概念了那裡。

1461
01:07:03,240 --> 01:07:03,740
確定。

1462
01:07:03,740 --> 01:07:06,930
>> 因此，我們這裡完全改變齒輪。

1463
01:07:06,930 --> 01:07:09,360
內存管理，很難。
指針，很難。是。

1464
01:07:09,360 --> 01:07:10,530
這是真的，真的很難。

1465
01:07:10,530 --> 01:07:11,270
完全罰款。

1466
01:07:11,270 --> 01:07:13,800
這就是為什麼你的作品是
將是真的很難。

1467
01:07:13,800 --> 01:07:17,740
但是，如果你去做
的事情，我們是

1468
01:07:17,740 --> 01:07:19,860
應該做的事情，使
確保一切都為空，

1469
01:07:19,860 --> 01:07:21,830
一定要檢查，如果事情是
空，一定要釋放內存，

1470
01:07:21,830 --> 01:07:23,910
確保一切都沒有
漏水，你會好。

1471
01:07:23,910 --> 01:07:25,761
你將被設置。

1472
01:07:25,761 --> 01:07:26,260
好的。

1473
01:07:26,260 --> 01:07:30,870
所以，我們要進入這個
重定向的全新的概念。

1474
01:07:30,870 --> 01:07:33,201
而之前那麼現在，在
我們已經主要途徑

1475
01:07:33,201 --> 01:07:35,700
與被交互我們
程序是通過標準輸入

1476
01:07:35,700 --> 01:07:36,533
和標準輸出。

1477
01:07:36,533 --> 01:07:37,040
對嗎？

1478
01:07:37,040 --> 01:07:39,230
我們為用戶輸入
東西和計算機

1479
01:07:39,230 --> 01:07:42,090
吐回給我們的終端。

1480
01:07:42,090 --> 01:07:44,770
>> 但也有其他
如何讓我們互動

1481
01:07:44,770 --> 01:07:47,810
與計算機與我們的
這不只是我的計劃

1482
01:07:47,810 --> 01:07:50,245
物理打字的東西
在我的時候提示我。

1483
01:07:50,245 --> 01:07:52,620
而我們做到這一點的方法是
通過大於胡蘿蔔

1484
01:07:52,620 --> 01:07:53,453
和管道符號。

1485
01:07:53,453 --> 01:07:55,970

1486
01:07:55,970 --> 01:07:58,630
因此，我們也可以讀取和
編寫使用的文件。

1487
01:07:58,630 --> 01:08:03,230
>> 所以我們這樣做的方式是
大於胡蘿蔔，所有正在做

1488
01:08:03,230 --> 01:08:07,410
正在寫什麼你
文件具有到一個單獨的文件中。

1489
01:08:07,410 --> 01:08:11,870
因此，舉例來說，如果我
想跑的hello world

1490
01:08:11,870 --> 01:08:14,330
我想輸出到
保存在另一個文件

1491
01:08:14,330 --> 01:08:17,359
而不是僅僅打印出來給我，我
可以只比胡蘿蔔做的更大，

1492
01:08:17,359 --> 01:08:18,410
output.txt的。

1493
01:08:18,410 --> 01:08:22,609
因此，所有這一切做的是
我hello.world程序，

1494
01:08:22,609 --> 01:08:26,359
不管其輸出是，它的
保存在一個名為output.txt的文件。

1495
01:08:26,359 --> 01:08:29,850
所以，大衛做了的方式
.csv格式與學生的名字，

1496
01:08:29,850 --> 01:08:32,310
它是相同的，你們可以做的。

1497
01:08:32,310 --> 01:08:35,137
>> 這有什麼特別
有用這裡有更大

1498
01:08:35,137 --> 01:08:38,220
than--兩個大於胡蘿蔔
跡象，您可以追加到一個輸出

1499
01:08:38,220 --> 01:08:40,795
文件，這意味著你
只需添加在它之上。

1500
01:08:40,795 --> 01:08:43,420
你可以只是不斷增加
每增加一點output.txt的

1501
01:08:43,420 --> 01:08:44,490
你正在做的事情。

1502
01:08:44,490 --> 01:08:48,010
或者，如果你開始進入更多
複雜的程序，兩個較大

1503
01:08:48,010 --> 01:08:50,939
比胡蘿蔔，只是打印
出了錯誤信息。

1504
01:08:50,939 --> 01:08:53,340
所以說，你有一個巨大的
錯誤消息量

1505
01:08:53,340 --> 01:08:54,810
和你想讀
通過所有這些，你的

1506
01:08:54,810 --> 01:08:56,450
不希望有滾動
通過你的終端，

1507
01:08:56,450 --> 01:08:58,651
可以真正地做到
大於output.txt的

1508
01:08:58,651 --> 01:09:00,359
並且它要保存
所有的錯誤

1509
01:09:00,359 --> 01:09:02,900
在一個文件名為output.txt的那
你可以通過閱讀。

1510
01:09:02,900 --> 01:09:04,622
聽眾：哪裡是文​​本文件保存？

1511
01:09:04,622 --> 01:09:07,330
ANDI彭：它保存在同一
目錄下，你的程序。

1512
01:09:07,330 --> 01:09:09,830
所以，你只要回去看看吧。

1513
01:09:09,830 --> 01:09:11,930
而同樣的事情，我們
可以輸入做的是

1514
01:09:11,930 --> 01:09:14,300
我們可以採取實際
一些文件的內容

1515
01:09:14,300 --> 01:09:16,380
我們可以輸入該到我們的程序。

1516
01:09:16,380 --> 01:09:19,930
因此，而不是做命令
在那裡你身體行參數

1517
01:09:19,930 --> 01:09:21,680
必須輸入事
每一次，你

1518
01:09:21,680 --> 01:09:27,890
可實際上只是有一個名為
input.txt的，只是把它所有的研究。

1519
01:09:27,890 --> 01:09:31,970
>> 然後通過管道是特別爽，因為
它可以採取一個節目的輸出

1520
01:09:31,970 --> 01:09:34,170
並把它作為輸入
的另一個程序。

1521
01:09:34,170 --> 01:09:38,430
因此，例如，在你的球員“的Vigenere，
有這行代碼，你

1522
01:09:38,430 --> 01:09:42,010
球員正在運行，你也許也許
真的不知道這是什麼doing--

1523
01:09:42,010 --> 01:09:46,910
這./generate 1000年管./42。

1524
01:09:46,910 --> 01:09:47,510
對嗎？

1525
01:09:47,510 --> 01:09:51,100
>> 因此，所有的在做，如果我們只是
看看這一步一步，

1526
01:09:51,100 --> 01:09:55,870
該./generate，這意味著我
運行我的程序產生。

1527
01:09:55,870 --> 01:09:58,850
即採取在1000在它的輸入端。

1528
01:09:58,850 --> 01:10:03,330
所以我想生成1000隨機
數字和我要去管that--

1529
01:10:03,330 --> 01:10:07,790
或者我會用that--輸出
輸入我的程序調用的發現。

1530
01:10:07,790 --> 01:10:12,110
而且我會盡量找42出
從這些1000生成的數字

1531
01:10:12,110 --> 01:10:13,130
數字。

1532
01:10:13,130 --> 01:10:15,410
這是否行代碼，使
有意義的其他人？

1533
01:10:15,410 --> 01:10:17,820
>> 所以在這種方式，我們正在保存
我們一噸的步驟。

1534
01:10:17,820 --> 01:10:21,880
我們沒有運行，保存，
該文件，然後把它放進發現。

1535
01:10:21,880 --> 01:10:23,800
我們可以做這一切在同一行。

1536
01:10:23,800 --> 01:10:28,080
所以，無論是生成輸出，
墜落它右後衛找到。

1537
01:10:28,080 --> 01:10:28,580
是嗎？

1538
01:10:28,580 --> 01:10:32,484
>> 聽眾：而在指揮方面
行參數，是that--那

1539
01:10:32,484 --> 01:10:33,948
三個命令行參數？

1540
01:10:33,948 --> 01:10:38,340
它的產生，find--沒有，four--
產生，1000，查找和42？

1541
01:10:38,340 --> 01:10:39,134
或者是the--

1542
01:10:39,134 --> 01:10:42,050
ANDI彭：這樣的管道並沒有真正
算作一個命令行參數

1543
01:10:42,050 --> 01:10:44,590
因為編譯器或
終端知道該管道，

1544
01:10:44,590 --> 01:10:48,590
哦，我知道我必須看前
管道，因為這是我的輸出

1545
01:10:48,590 --> 01:10:51,220
我必須照顧
管，因為這是我的意見。

1546
01:10:51,220 --> 01:10:54,520
所以它知道that--的
./generate和1000，

1547
01:10:54,520 --> 01:10:57,390
這些都是那麼兩個命令參數
只是為第一程序。

1548
01:10:57,390 --> 01:11:01,760
然後./find 42兩個命令
行參數的第二個項目。

1549
01:11:01,760 --> 01:11:02,980
是啊。

1550
01:11:02,980 --> 01:11:06,150
每個人都好就這個？

1551
01:11:06,150 --> 01:11:10,610
>> 因此，只要真正的快，做什麼
這三行代碼呢？

1552
01:11:10,610 --> 01:11:11,606
很簡單。

1553
01:11:11,606 --> 01:11:13,605
任何人想告訴我
什麼樣的第一行呢？

1554
01:11:13,605 --> 01:11:18,201

1555
01:11:18,201 --> 01:11:19,117
聽眾：[聽不清]。

1556
01:11:19,117 --> 01:11:23,540

1557
01:11:23,540 --> 01:11:26,534
>> ANDI彭：把它看成just--
什麼是大於胡蘿蔔嗎？

1558
01:11:26,534 --> 01:11:29,299
>> 聽眾：它把東西
到下一行。

1559
01:11:29,299 --> 01:11:31,090
ANDI彭：那麼，什麼是
那相反？

1560
01:11:31,090 --> 01:11:33,514
聽眾：它把下一個
事成的第一件事情。

1561
01:11:33,514 --> 01:11:34,180
ANDI彭：是的。

1562
01:11:34,180 --> 01:11:37,550
因此，所有這一切做的是你
運行程序.hello--

1563
01:11:37,550 --> 01:11:40,010
您正在運行一個名為你好程序。

1564
01:11:40,010 --> 01:11:42,960
你打算給它
稱為輸入input.txt的。

1565
01:11:42,960 --> 01:11:43,460
對嗎？

1566
01:11:43,460 --> 01:11:46,250
因為把它看作只是
物理進入打招呼。

1567
01:11:46,250 --> 01:11:50,632
然後，你要保存
在文件輸出名為output.txt的。

1568
01:11:50,632 --> 01:11:51,715
如何下聯？

1569
01:11:51,715 --> 01:11:54,164
想告訴我什麼
第二行呢？

1570
01:11:54,164 --> 01:11:55,080
聽眾：[聽不清]。

1571
01:11:55,080 --> 01:12:00,522

1572
01:12:00,522 --> 01:12:01,230
ANDI彭：對不起。

1573
01:12:01,230 --> 01:12:03,560
再說了。

1574
01:12:03,560 --> 01:12:04,060
艾略特。

1575
01:12:04,060 --> 01:12:06,560
>> 聽眾：所以它把​​一個
數字到查找列表。

1576
01:12:06,560 --> 01:12:07,540
>> ANDI彭：是的。

1577
01:12:07,540 --> 01:12:10,790
所以找到，請記住，在
為了運行找到你

1578
01:12:10,790 --> 01:12:13,209
需要知道你正在尋找。

1579
01:12:13,209 --> 01:12:15,500
所以所有的它做
這裡要說的是它給你

1580
01:12:15,500 --> 01:12:18,720
預先分配的一組的
數字，然後找到是怎麼回事

1581
01:12:18,720 --> 01:12:21,680
以搜索那些為42的數目。

1582
01:12:21,680 --> 01:12:23,620
然後15。

1583
01:12:23,620 --> 01:12:25,870
請記住，你們跑這
當你測試你的代碼。

1584
01:12:25,870 --> 01:12:27,590
現在你明白這是什麼做？

1585
01:12:27,590 --> 01:12:31,069

1586
01:12:31,069 --> 01:12:33,520
>> 聽眾：它的投入
該組指令

1587
01:12:33,520 --> 01:12:38,860
通過三通過向[聽不清]
三，獲得the--贏得比賽。

1588
01:12:38,860 --> 01:12:39,560
>> ANDI彭：是的。

1589
01:12:39,560 --> 01:12:41,480
>> 聽眾：通過輸入那些
指令到程序中。

1590
01:12:41,480 --> 01:12:42,438
>> ANDI彭：差不多。

1591
01:12:42,438 --> 01:12:47,840
所以波浪CS50 / pset3 / 3x3的，所有的
在做的是，我們創建了一個文本

1592
01:12:47,840 --> 01:12:50,700
文件把所有的
遊戲準備好你們。

1593
01:12:50,700 --> 01:12:56,020
所以，你的遊戲玩，你just--
我們只是把那到你的程序。

1594
01:12:56,020 --> 01:12:58,230
因此，我們已經創造了這個
板，然後我們

1595
01:12:58,230 --> 01:13:02,890
把該板到你的程序
跑，並創造了三個瓷磚

1596
01:13:02,890 --> 01:13:03,390
三。

1597
01:13:03,390 --> 01:13:04,730
這就是它在做什麼。

1598
01:13:04,730 --> 01:13:07,331
>> 所以實際上也存在神奇
怎麼回事幕後

1599
01:13:07,331 --> 01:13:09,330
那你們沒
程序，我們編程。

1600
01:13:09,330 --> 01:13:13,120
但是，現在你們明白為什麼
我們這樣做，所以這一切都很好。

1601
01:13:13,120 --> 01:13:15,750
好的。

1602
01:13:15,750 --> 01:13:22,200
>> 因此，儘管重定向是一個非常
有用的，C具有普遍的機制

1603
01:13:22,200 --> 01:13:25,030
用於讀取和寫入
它自己的文件。

1604
01:13:25,030 --> 01:13:26,780
沒有什麼概念
困難在這裡，所以我

1605
01:13:26,780 --> 01:13:28,330
剛準備要經過
真的，真的很快。

1606
01:13:28,330 --> 01:13:30,621
所有這一些記憶
並確保你們

1607
01:13:30,621 --> 01:13:32,680
語法是正確使用它。

1608
01:13:32,680 --> 01:13:35,640
我們會做到這一點的方法是
創建的參考文件，

1609
01:13:35,640 --> 01:13:38,473
我們會打開這個文件，然後我們
會做所有的閱讀和寫作

1610
01:13:38,473 --> 01:13:39,929
然後關閉該文件。

1611
01:13:39,929 --> 01:13:41,720
當你們的事
要記住的是

1612
01:13:41,720 --> 01:13:47,360
雖然這樣做，是因為
我們正在關閉和打開文件，

1613
01:13:47,360 --> 01:13:51,230
所有這些命令包括
在standard--標準I / O

1614
01:13:51,230 --> 01:13:51,730
庫。

1615
01:13:51,730 --> 01:13:54,410
所以一定要確保每當你
這樣做，你已經included--

1616
01:13:54,410 --> 01:13:59,020
＃included--標準I / O點小時。

1617
01:13:59,020 --> 01:14:01,691
>> 所以，真正的快。

1618
01:14:01,691 --> 01:14:03,940
第一步，你要創建
的引用，該文件。

1619
01:14:03,940 --> 01:14:07,670
而現在，我們所做的指針，你
你們能告訴我這是什麼行代碼

1620
01:14:07,670 --> 01:14:08,630
在做什麼。

1621
01:14:08,630 --> 01:14:10,250
對嗎？

1622
01:14:10,250 --> 01:14:15,397
所有這一切它做的是創造一個
指針命名的文件類型的文件。

1623
01:14:15,397 --> 01:14:17,980
因為你知道這是怎麼回事
指向一個文件，你

1624
01:14:17,980 --> 01:14:20,460
要打開該文件。

1625
01:14:20,460 --> 01:14:23,320
那麼你˚Fopen--所有
它的作用是打開文件。

1626
01:14:23,320 --> 01:14:24,560
>> 這是文件名。

1627
01:14:24,560 --> 01:14:26,060
而且有三件事情可以做。

1628
01:14:26,060 --> 01:14:28,195
你可以讀，寫或追加。

1629
01:14:28,195 --> 01:14:30,320
最普遍，你們
將讀取或寫入

1630
01:14:30,320 --> 01:14:33,195
因為你要么將是
輸入文件或輸出之一。

1631
01:14:33,195 --> 01:14:36,500
所以幾乎r和w分別在兩個
你會使用最多的事。

1632
01:14:36,500 --> 01:14:41,722
>> 因此，在這種情況下，所有我所做的就是
創建一個指向一個名為文件。

1633
01:14:41,722 --> 01:14:47,900
我打開它，我reading--我
打開此文件名為file.txt的

1634
01:14:47,900 --> 01:14:49,020
而我讀它。

1635
01:14:49,020 --> 01:14:51,730
這就是我正在做的這一點。

1636
01:14:51,730 --> 01:14:55,270
然後，這些都只是在功能
你可以看不同的東西

1637
01:14:55,270 --> 01:14:57,750
或寫不同的東西
或者跳到不同的地方

1638
01:14:57,750 --> 01:14:59,420
在那裡，你想看看。

1639
01:14:59,420 --> 01:15:01,200
所有這些都是在網上。

1640
01:15:01,200 --> 01:15:02,960
所有這些，你可以只是谷歌。

1641
01:15:02,960 --> 01:15:04,280
無需記住它們。

1642
01:15:04,280 --> 01:15:07,160
他們只是在那裡，
一次性供您使用

1643
01:15:07,160 --> 01:15:09,360
如果您想為
能夠使用它們。

1644
01:15:09,360 --> 01:15:13,210
>> 所以，如果我想剛才讀
在一個字符的時間，

1645
01:15:13,210 --> 01:15:15,360
我會做文件龜etc。

1646
01:15:15,360 --> 01:15:18,850
或者，如果我想讀取一行
文本的時間，我會做與fgets。

1647
01:15:18,850 --> 01:15:19,840
等等，等等。

1648
01:15:19,840 --> 01:15:23,640
所有這些只是做不同
你們的事情可以使用。

1649
01:15:23,640 --> 01:15:25,920
>> 然後最後，經過我
做讀取或寫入，

1650
01:15:25,920 --> 01:15:27,770
我只是要FCLOSE該文件。

1651
01:15:27,770 --> 01:15:31,760
請記住，這是其一
那些，記住，請

1652
01:15:31,760 --> 01:15:34,220
這樣做，否則您的文件
是行不通的。

1653
01:15:34,220 --> 01:15:36,130
之前，請務必打開一個文件
閱讀或閱讀，

1654
01:15:36,130 --> 01:15:38,310
你必須始終
關閉它，如果你打開它。

1655
01:15:38,310 --> 01:15:40,210
同樣的事情與記憶，對不對？

1656
01:15:40,210 --> 01:15:42,390
你必須始終以
內存和釋放它。

1657
01:15:42,390 --> 01:15:45,200
在這裡，你必須始終打開
試圖讀取它之前的文件

1658
01:15:45,200 --> 01:15:47,360
而你總是要
關閉你打開它之後。

1659
01:15:47,360 --> 01:15:50,650

1660
01:15:50,650 --> 01:15:52,190
>> 所以，這也是在網上。

1661
01:15:52,190 --> 01:15:55,590
我要你挑戰傢伙
那種寫一個程序，打印

1662
01:15:55,590 --> 01:15:57,080
hello.world到一個文件。

1663
01:15:57,080 --> 01:15:58,280
這真的很簡單。

1664
01:15:58,280 --> 01:16:00,854
它本質上只是涉及
的代碼的幾行

1665
01:16:00,854 --> 01:16:02,270
這只是以前寫的。

1666
01:16:02,270 --> 01:16:04,311
你打算把他們
一起寫的。

1667
01:16:04,311 --> 01:16:06,630

1668
01:16:06,630 --> 01:16:10,950
>> 因此，一些重要的事情要記住
而你們正試圖利用這一點。

1669
01:16:10,950 --> 01:16:14,410
如果這一切都是非常有用的
本週你的PSET，

1670
01:16:14,410 --> 01:16:18,000
是FOPEN創建一個文件指針。

1671
01:16:18,000 --> 01:16:19,500
這不是真正的物理文件。

1672
01:16:19,500 --> 01:16:22,260
所有它指向該
文件要打開。

1673
01:16:22,260 --> 01:16:26,070
而你從本質上講，只要
您正在使用的任何其他職能

1674
01:16:26,070 --> 01:16:30,130
像FREAD和FWRITE
或龜etc或與fgets，是

1675
01:16:30,130 --> 01:16:33,380
那你只是路過解決此
指針的所有這些功能。

1676
01:16:33,380 --> 01:16:36,510
所以你沒有真正採取這一
文件並使用它為你的功能，

1677
01:16:36,510 --> 01:16:39,540
你只是把指針
並把它這些功能

1678
01:16:39,540 --> 01:16:41,620
這樣就可以使用。

1679
01:16:41,620 --> 01:16:45,360
>> 如果你忘記關閉
您在使用它後的文件，

1680
01:16:45,360 --> 01:16:47,710
你的程序會出現內存洩漏。

1681
01:16:47,710 --> 01:16:50,700
從本質上講，所有的手段
是不好的事情會發生

1682
01:16:50,700 --> 01:16:52,960
和你的程序將
無法正常工作。

1683
01:16:52,960 --> 01:16:54,880
等等PSET中
一開始，我覺得

1684
01:16:54,880 --> 01:16:59,180
有一個短的，在那裡他explained--
內特explained--什麼Valgrind的了。

1685
01:16:59,180 --> 01:17:02,350
所有Valgrind是一個方法可以讓你
確保你不會洩漏內存。

1686
01:17:02,350 --> 01:17:04,433
所以，你們要進行
確保你看，短期

1687
01:17:04,433 --> 01:17:08,771
因為這說明它
真的很好會發生什麼。

1688
01:17:08,771 --> 01:17:09,270
確定。

1689
01:17:09,270 --> 01:17:11,260
於是我通過去真的，
真的很快，因為我​​真的

1690
01:17:11,260 --> 01:17:13,870
想要去談論
處理器集之前，你們離開。

1691
01:17:13,870 --> 01:17:16,690
有沒有人有問題的概念？

1692
01:17:16,690 --> 01:17:20,060
大多都是這只是語法
你可以用它來讀取或寫入文件。

1693
01:17:20,060 --> 01:17:25,090

1694
01:17:25,090 --> 01:17:28,140
>> 最後，大家的喜愛。

1695
01:17:28,140 --> 01:17:31,760
我們要談的pset的現在。

1696
01:17:31,760 --> 01:17:35,990
因此，舉手表決，多少
你們看過規範這個星期？

1697
01:17:35,990 --> 01:17:36,660
噢，那是一半。

1698
01:17:36,660 --> 01:17:38,000
這是很好的。

1699
01:17:38,000 --> 01:17:41,430
因此，這實際上是一個真正的，
真正有趣的PSET的意義

1700
01:17:41,430 --> 01:17:43,889
你覺得自己像一個
偵探，因為你

1701
01:17:43,889 --> 01:17:46,930
做所有這些非常酷的事情
你不知道，你可以做

1702
01:17:46,930 --> 01:17:49,050
但現在它真的很酷
你可以做他們。

1703
01:17:49,050 --> 01:17:52,400
它實際上是一個很大
簡單的比你們想像。

1704
01:17:52,400 --> 01:17:56,640
>> 所以基本半部
這個程序是你

1705
01:17:56,640 --> 01:18:00,330
要下載源代碼或
發行代碼寫的我們。

1706
01:18:00,330 --> 01:18:03,540
而你將有一個文件夾
所謂的BMP和其他文件夾

1707
01:18:03,540 --> 01:18:05,550
所謂的JPG。

1708
01:18:05,550 --> 01:18:08,370
在您的BMP，你
將有三個方案。

1709
01:18:08,370 --> 01:18:10,400
其中之一是已經為你寫的。

1710
01:18:10,400 --> 01:18:12,477
所以CSV模式中有效是一個程序
我們已經寫

1711
01:18:12,477 --> 01:18:14,060
對於你，你要去下載。

1712
01:18:14,060 --> 01:18:19,440
所有這些都需要輸入一張圖片
並使得它的一個副本輸出。

1713
01:18:19,440 --> 01:18:22,150
這是所有的文件在做什麼。

1714
01:18:22,150 --> 01:18:25,260
>> 但是，你想要做什麼
whodunit--所以你們有多少人

1715
01:18:25,260 --> 01:18:30,450
你們還記得在小學五年級或maybe--
你younger--也許三年級，

1716
01:18:30,450 --> 01:18:33,945
當你們有秘密消息，
你不得不把一張紙了它

1717
01:18:33,945 --> 01:18:35,440
解碼消息？

1718
01:18:35,440 --> 01:18:36,000
是嗎？

1719
01:18:36,000 --> 01:18:39,580
所以，這就是我們正在做的
但這次的計算機。

1720
01:18:39,580 --> 01:18:41,832
因此，我們已經給你這個可愛的形象。

1721
01:18:41,832 --> 01:18:43,540
看起來不像
什麼，但下方

1722
01:18:43,540 --> 01:18:49,660
這是一個線索，會幫助你
與回答這個問題，我們問你。

1723
01:18:49,660 --> 01:18:54,170
>> 從本質上講，你想要什麼
要做的就是輸入該文件，

1724
01:18:54,170 --> 01:18:56,610
圍繞調整一些東西，
也許調整顏色，

1725
01:18:56,610 --> 01:19:00,730
轉移的事情，所以，無論
該消息是能安然度過。

1726
01:19:00,730 --> 01:19:03,740
所以裡面有隱藏
像素和信息

1727
01:19:03,740 --> 01:19:07,140
如果你正確地編寫代碼
是要解碼，並告訴你

1728
01:19:07,140 --> 01:19:08,500
這是什麼線索。

1729
01:19:08,500 --> 01:19:12,480
所以一些有用的提示如何
你會去接近這一點。

1730
01:19:12,480 --> 01:19:15,180
>> 你真的想了解
自己與文件I / O

1731
01:19:15,180 --> 01:19:18,760
因為我們從閱讀
文件和寫入文件。

1732
01:19:18,760 --> 01:19:19,260
對嗎？

1733
01:19:19,260 --> 01:19:21,430
所以，每當我們做
即，涉及

1734
01:19:21,430 --> 01:19:25,170
文件I / O。你會
有熟悉

1735
01:19:25,170 --> 01:19:27,450
有，你是怎麼打開的圖片文件？

1736
01:19:27,450 --> 01:19:29,960
你怎麼寫入文件的圖片？

1737
01:19:29,960 --> 01:19:31,640
你怎麼做所有這些事情？

1738
01:19:31,640 --> 01:19:33,660
這將是非常有用的。

1739
01:19:33,660 --> 01:19:36,190
>> 其次，你怎麼樣
要能夠改變

1740
01:19:36,190 --> 01:19:38,140
該清理這幅畫的顏色？

1741
01:19:38,140 --> 01:19:43,660
它可能會涉及到
調整你的像素或RGB值

1742
01:19:43,660 --> 01:19:45,390
地方在那裡，本質上。

1743
01:19:45,390 --> 01:19:47,800
有沒有正確的方式
只要解決這個你

1744
01:19:47,800 --> 01:19:52,560
can--只要你可以種
調整的那些像素，使其

1745
01:19:52,560 --> 01:19:54,640
看起來像你關心的東西。

1746
01:19:54,640 --> 01:19:56,207
這就是我們所關心的為好。

1747
01:19:56,207 --> 01:19:57,540
因此，有很多方法可以做到這一點。

1748
01:19:57,540 --> 01:20:00,039
剛玩它，直到
你會得到一些作品。

1749
01:20:00,039 --> 01:20:02,900
而且你會很
代碼驚奇地發現幾行

1750
01:20:02,900 --> 01:20:04,510
你需要真正做到這一點。

1751
01:20:04,510 --> 01:20:08,700
我說的是像三
代碼總行數

1752
01:20:08,700 --> 01:20:11,310
你需要寫
為了做到這一點。

1753
01:20:11,310 --> 01:20:15,470
所以，如果你發現自己
寫40，30行代碼，

1754
01:20:15,470 --> 01:20:16,960
你可能就錯了。

1755
01:20:16,960 --> 01:20:19,390
所有你需要做的是一種
玩的顏色

1756
01:20:19,390 --> 01:20:22,960
看看該怎麼做了。

1757
01:20:22,960 --> 01:20:27,040
>> 於是我們進入了一點
到的一個問題更難。

1758
01:20:27,040 --> 01:20:30,190
在這裡，我們有調整
我們問你在哪裡

1759
01:20:30,190 --> 01:20:34,210
用於：我們給你輸入
一張圖片，你的大小調整

1760
01:20:34,210 --> 01:20:36,710
這個圖片弄成
或大或小一點

1761
01:20:36,710 --> 01:20:38,500
這取決於我們給你的尺寸。

1762
01:20:38,500 --> 01:20:41,260
所以請記住講座
大衛很快

1763
01:20:41,260 --> 01:20:45,780
瞥了一眼信息如何
通過您的計算機上檢測到

1764
01:20:45,780 --> 01:20:47,590
意味著它是一個類型的文件。

1765
01:20:47,590 --> 01:20:50,530
所以一個Word文件中有特殊的
前面那個字符

1766
01:20:50,530 --> 01:20:52,040
告訴你的電腦是一個Word文件。

1767
01:20:52,040 --> 01:20:53,090
同樣的事情與JPEG格式。

1768
01:20:53,090 --> 01:20:55,131
在這種情況下，我們將
給你一個JPEG文件。

1769
01:20:55,131 --> 01:20:58,300
我們所知道的是，JPEG
文件是一個圖片，對吧？

1770
01:20:58,300 --> 01:21:01,430
但電腦與眾不同之
它非常具體的方式。

1771
01:21:01,430 --> 01:21:04,070
因此，在開始時
任何JPEG文件，你

1772
01:21:04,070 --> 01:21:08,210
將有什麼所謂的位圖
信息報頭和位圖文件頭。

1773
01:21:08,210 --> 01:21:11,080
所有這些都為
不同的數據

1774
01:21:11,080 --> 01:21:14,870
告訴您的計算機，嘿嘿，
聽好了，一個JPEG文件上來

1775
01:21:14,870 --> 01:21:17,820
而這些都是尺寸或
該JPEG的特點。

1776
01:21:17,820 --> 01:21:21,280
>> 所以你們真的想知道
哪些信息內部存儲

1777
01:21:21,280 --> 01:21:23,560
這些標題和
什麼是它們的大小。

1778
01:21:23,560 --> 01:21:25,640
當你運行，因為
通過你們的節目，

1779
01:21:25,640 --> 01:21:27,370
你會想
跳過這一數額。

1780
01:21:27,370 --> 01:21:27,940
對嗎？

1781
01:21:27,940 --> 01:21:29,910
因為你不關心
有關修改標題，

1782
01:21:29,910 --> 01:21:31,493
你關心的修改有什麼後。

1783
01:21:31,493 --> 01:21:32,450
對嗎？

1784
01:21:32,450 --> 01:21:36,040
所以一定要確保你們知道
這些東西有多大。

1785
01:21:36,040 --> 01:21:39,065
>> 其次，在開始之前
試圖調整你的形象，

1786
01:21:39,065 --> 01:21:41,940
你可能會想
保存原始的尺寸。

1787
01:21:41,940 --> 01:21:42,520
對嗎？

1788
01:21:42,520 --> 01:21:45,550
因為如果我告訴你，這幅畫
是100像素乘以100像素，

1789
01:21:45,550 --> 01:21:47,630
我想你做
這四次較大，

1790
01:21:47,630 --> 01:21:50,460
你知道你必須
乘以4的尺寸。

1791
01:21:50,460 --> 01:21:54,960
所以，你想要一個輸出文件
400×400像素，例如。

1792
01:21:54,960 --> 01:21:58,300
因此，它是非常有用的，你們要
保存原始的尺寸。

1793
01:21:58,300 --> 01:22:00,780
再後來，經過
你完成了調整，

1794
01:22:00,780 --> 01:22:06,270
你可以寫新的報頭與
調整後的新維度。

1795
01:22:06,270 --> 01:22:10,750
>> 而方式，你身體
可以創建在大像素

1796
01:22:10,750 --> 01:22:13,380
是，你可以寫
新RGB--記得，RGB，

1797
01:22:13,380 --> 01:22:17,784
所有代表的是紅，綠，
和blue--像素的輸出文件。

1798
01:22:17,784 --> 01:22:20,200
而你會想
有不同量的什麼

1799
01:22:20,200 --> 01:22:21,200
我們稱之為填充。

1800
01:22:21,200 --> 01:22:24,780
所有的填充是有空間
之前和圖片後，

1801
01:22:24,780 --> 01:22:29,265
告訴your--基本上是
告訴你的圖片有多大它

1802
01:22:29,265 --> 01:22:30,589
應佔用。

1803
01:22:30,589 --> 01:22:33,630
這是很抽象了很多
你，如果你還沒有讀過pset的規範，

1804
01:22:33,630 --> 01:22:35,410
但它的將是
因為當非常有用

1805
01:22:35,410 --> 01:22:36,460
你實際上讀通過它。

1806
01:22:36,460 --> 01:22:38,126
你喜歡的哦，是啊，這是有道理的。

1807
01:22:38,126 --> 01:22:39,310
為什麼我要這麼做？

1808
01:22:39,310 --> 01:22:41,830
有道理。

1809
01:22:41,830 --> 01:22:46,900
>> 最後，這可能是一個
最令人沮喪的程序

1810
01:22:46,900 --> 01:22:51,160
曾經只是因為你不能
告訴我們，如果它的工作與否。

1811
01:22:51,160 --> 01:22:54,980
所有這些計劃，恢復，是
做的是，如果正常運行，

1812
01:22:54,980 --> 01:22:59,290
它應該能突然
回收50％的圖像，

1813
01:22:59,290 --> 01:23:01,025
失去了我們的硬盤驅動器上。

1814
01:23:01,025 --> 01:23:03,900
所以，這個程序問題
是，你不能真正測試

1815
01:23:03,900 --> 01:23:06,220
因為無論你恢復
他們或者你沒有。

1816
01:23:06,220 --> 01:23:09,122
所以那種你只要
必須發揮與它周圍，

1817
01:23:09,122 --> 01:23:11,080
如果你的程序是
正常工作，你會

1818
01:23:11,080 --> 01:23:12,829
突然看到，在
您的目錄你已經

1819
01:23:12,829 --> 01:23:17,400
得到了一個巨大的量
照片是現在。

1820
01:23:17,400 --> 01:23:20,490
>> 所以，我怎麼會接近
這個問題，我們

1821
01:23:20,490 --> 01:23:22,860
要給你什麼
被稱為card.raw文件。

1822
01:23:22,860 --> 01:23:25,020
從本質上講，這是
只是損壞的文件

1823
01:23:25,020 --> 01:23:28,870
與所有的圖片存儲在該
你將需要從恢復。

1824
01:23:28,870 --> 01:23:32,330
所以，你可能會想
輸入您的card.raw，或打開，

1825
01:23:32,330 --> 01:23:35,510
您card.raw文件和你
將要處理

1826
01:23:35,510 --> 01:23:37,840
它能夠存儲JPEG文件。

1827
01:23:37,840 --> 01:23:42,830
>> 因此，我將通過跟踪和存儲啟動
每個單獨的JPEG，你找到它。

1828
01:23:42,830 --> 01:23:47,180
你不會單獨所有
突然只創建50個JPEG文件。

1829
01:23:47,180 --> 01:23:50,190
你會想保留
跟踪你打開多少。

1830
01:23:50,190 --> 01:23:52,015
然後你要
要確保，當你

1831
01:23:52,015 --> 01:23:54,640
寫入buffer--你們
會知道我在說什麼

1832
01:23:54,640 --> 01:23:57,806
一旦你讀了spec--要
請確保您使用的是無符號

1833
01:23:57,806 --> 01:23:59,370
字符緩衝區。

1834
01:23:59,370 --> 01:24:01,790
>> 然後你要問
你自己的問題，

1835
01:24:01,790 --> 01:24:05,797
多少字節是在一個
CF--是在一個卡文件？

1836
01:24:05,797 --> 01:24:08,380
這就是你要多少
想讀入您的緩衝區。

1837
01:24:08,380 --> 01:24:11,130
你會希望確保
兩個對齊因為你

1838
01:24:11,130 --> 01:24:12,850
不會有隨機存儲器洩漏。

1839
01:24:12,850 --> 01:24:15,370
你知道到底有多少
字節，你需要多少

1840
01:24:15,370 --> 01:24:18,270
字節，你希望他們有。

1841
01:24:18,270 --> 01:24:21,510
>> 然後最後，你要
使用一種稱為函數sprint--

1842
01:24:21,510 --> 01:24:26,160
■打印F--生成自定義文件
名稱為每一個新的JPEG，你覺得。

1843
01:24:26,160 --> 01:24:29,129
在創建因此和
發現JPEG文件在你的卡，

1844
01:24:29,129 --> 01:24:31,170
你會想
存儲它們並將它們命名。

1845
01:24:31,170 --> 01:24:31,700
對嗎？

1846
01:24:31,700 --> 01:24:33,700
所以，你要
要使用該功能

1847
01:24:33,700 --> 01:24:36,770
創建的名稱
可以存儲所有的JPEG文件。

1848
01:24:36,770 --> 01:24:41,062
>> 最後，不要忘記關閉
每個JPEG圖像後，你就大功告成了。

1849
01:24:41,062 --> 01:24:42,770
因為你在做什麼
要做的就是你

1850
01:24:42,770 --> 01:24:44,728
將可能有
某種循環的那

1851
01:24:44,728 --> 01:24:46,470
通過您的所有JPEG文件的迭代。

1852
01:24:46,470 --> 01:24:50,460
你會寫一個JPEG
並改名為你找到它。

1853
01:24:50,460 --> 01:24:52,870
但是，就大功告成後，
與每一個JPEG，

1854
01:24:52,870 --> 01:24:56,630
你需要關閉它，你就可以開始
過去，在移動到下一個圖像。

1855
01:24:56,630 --> 01:24:58,880
所以東西是
真的很有趣，我們喜歡做的事，

1856
01:24:58,880 --> 01:25:03,430
因為這是這樣一個奇怪的問題集
也是一個古怪令人滿意問題

1857
01:25:03,430 --> 01:25:08,380
集，就是所有的圖片我們
對你，如果你正確恢復，

1858
01:25:08,380 --> 01:25:11,910
所有的圖片是圖片
你的精彩教學人員，無論是

1859
01:25:11,910 --> 01:25:14,240
哈佛，在這裡 - 這裡在耶魯大學。

1860
01:25:14,240 --> 01:25:17,260
如果你碰巧
收回所有這些圖片

1861
01:25:17,260 --> 01:25:20,020
並確定人員
在這些會員卡，

1862
01:25:20,020 --> 01:25:23,040
並採取selfies與我們聯繫，如果
你會發現我們身邊的校園，

1863
01:25:23,040 --> 01:25:28,270
對於每一張照片你提交給我們，我們將
給你的Dropbox空間的千兆字節。

1864
01:25:28,270 --> 01:25:30,060
>> 因此，讓我們做數學題在這裡。

1865
01:25:30,060 --> 01:25:33,010
如果有50張圖片和
50教學工作人員，

1866
01:25:33,010 --> 01:25:37,160
如果你碰巧發現所有50
我們，這是50千兆字節的Dropbox的，

1867
01:25:37,160 --> 01:25:39,000
基本上，我們會給予你們。

1868
01:25:39,000 --> 01:25:42,380
因此，一些額外的附加激勵
如果你們不只是

1869
01:25:42,380 --> 01:25:44,480
關心恢復丟失的圖像。

1870
01:25:44,480 --> 01:25:46,867
還有一些額外的獎勵。

1871
01:25:46,867 --> 01:25:47,825
這是一個有趣的問題集。

1872
01:25:47,825 --> 01:25:48,390
這真的是。

1873
01:25:48,390 --> 01:25:51,980
這是一種令人沮喪，但隨後
當你意識到變得更有趣，

1874
01:25:51,980 --> 01:25:54,230
哇，它的工作，現在我
具有所有的這些照片

1875
01:25:54,230 --> 01:25:55,604
我剛剛被自己創建的。

1876
01:25:55,604 --> 01:25:58,800

1877
01:25:58,800 --> 01:26:00,075
>> 在PSET有任何疑問？

1878
01:26:00,075 --> 01:26:02,408
對於任何人誰的已經
開始，如果您有任何疑問，

1879
01:26:02,408 --> 01:26:06,510
我會在這裡過了幾分鐘
一節，如果你想和我說話。

1880
01:26:06,510 --> 01:26:07,320
幹得好，伙計們。

1881
01:26:07,320 --> 01:26:10,520
我很抱歉，我的信息
傾倒在你們。

1882
01:26:10,520 --> 01:26:13,670
指針是真的，真的
具有挑戰性和令人沮喪的。

1883
01:26:13,670 --> 01:26:16,187
>> 而且我真的很高興，
你們一直伴隨著我。

1884
01:26:16,187 --> 01:26:18,020
我們將討論更深入
關於下週

1885
01:26:18,020 --> 01:26:21,330
當我們開始做哈希表和
更多的功能，讓他們參與。

1886
01:26:21,330 --> 01:26:23,821

1887
01:26:23,821 --> 01:26:24,320
是啊。

1888
01:26:24,320 --> 01:26:26,278
因此，如果任何人有任何
的問題，我就在附近。

1889
01:26:26,278 --> 01:26:29,330
感謝您的到來，並採取更多
糖果，因為有更多的糖果。

1890
01:26:29,330 --> 01:26:32,220

1891
01:26:32,220 --> 01:26:33,770
酷。

1892
01:26:33,770 --> 01:26:35,765