1
00:00:00,000 --> 00:00:02,670
>> [主題曲]

2
00:00:02,670 --> 00:00:11,834

3
00:00:11,834 --> 00:00:13,365
>> 揚聲器1：嗨，大家好。

4
00:00:13,365 --> 00:00:14,365
歡迎回到一節。

5
00:00:14,365 --> 00:00:15,700

6
00:00:15,700 --> 00:00:18,700
美好的一天out--這是為什麼，我
當然，也有只有你們四個在這裡

7
00:00:18,700 --> 00:00:21,180
而不是我們平常包。

8
00:00:21,180 --> 00:00:22,670
我一直在生病這個週末。

9
00:00:22,670 --> 00:00:24,294
所以，我沒有對星爆你們。

10
00:00:24,294 --> 00:00:26,400
我可能會開始咳嗽
可怕的整個。

11
00:00:26,400 --> 00:00:27,790
因此，只要多多包涵。

12
00:00:27,790 --> 00:00:30,624
我要真正嘗試
並通過這個獲得第一，

13
00:00:30,624 --> 00:00:32,290
雖然，之前我有咳嗽發作。

14
00:00:32,290 --> 00:00:33,410

15
00:00:33,410 --> 00:00:37,390
但是，僅僅是簡單的對我
小bit--這就是我問。

16
00:00:37,390 --> 00:00:39,370

17
00:00:39,370 --> 00:00:44,289
>> 因此，我們對today--議程只是一個
下週reminder--你測驗是。

18
00:00:44,289 --> 00:00:46,830
我告訴你，這最後一周，因此
會不會抓住你措手不及。

19
00:00:46,830 --> 00:00:47,954
所以我再次提醒你。

20
00:00:47,954 --> 00:00:49,180
下週的測驗。

21
00:00:49,180 --> 00:00:52,730
為此，下週的
節會更

22
00:00:52,730 --> 00:00:55,180
of--我會試著在一些審核工作。

23
00:00:55,180 --> 00:00:58,130
所以，如果你們能
幫我出了送我

24
00:00:58,130 --> 00:01:00,990
的東西，你是舒服
有，那你擔心，

25
00:01:00,990 --> 00:01:03,530
你想的主題
我來遮蓋，那簡直太好了。

26
00:01:03,530 --> 00:01:05,740
所以，我可以嘗試和他們的工作
到下週我們的部分

27
00:01:05,740 --> 00:01:11,540
或向您發送額外的材料或準備
你可能不會得到其他地方。

28
00:01:11,540 --> 00:01:12,150
>> 是啊！

29
00:01:12,150 --> 00:01:13,520
越來越多的人來了！

30
00:01:13,520 --> 00:01:17,320
我想，我做的不好最後
本週，沒有人願意回來嗎？

31
00:01:17,320 --> 00:01:18,065
我很害怕。

32
00:01:18,065 --> 00:01:18,892

33
00:01:18,892 --> 00:01:21,100
所以其他的三件事
我們打算走了過來

34
00:01:21,100 --> 00:01:24,850
是重定向，文件I / O，以及
然後指針和動態內存。

35
00:01:24,850 --> 00:01:29,160
我敢肯定你們都超興奮
pointers--大家最喜歡的話題，

36
00:01:29,160 --> 00:01:31,310
所以簡單的理解。

37
00:01:31,310 --> 00:01:33,130
我敢肯定你們都明白了吧？

38
00:01:33,130 --> 00:01:39,510
>> 所以首先第一件事情，redirection--
這基本上只是一個方式

39
00:01:39,510 --> 00:01:42,920
控制如何輸入
事到你的程序，

40
00:01:42,920 --> 00:01:44,606
你是如何從你的程序輸出的東西。

41
00:01:44,606 --> 00:01:46,980
主要的方式，你們
已經與它交互

42
00:01:46,980 --> 00:01:51,650
僅僅是通過標準輸出
在這裡您打印屏幕。

43
00:01:51,650 --> 00:01:55,940
但有辦法
pipe--我們在這裡看到

44
00:01:55,940 --> 00:01:58,980
我們words--獨一無二的
管道的信息

45
00:01:58,980 --> 00:02:02,850
或者該數據轉換成從一個文件中的一個文件。

46
00:02:02,850 --> 00:02:05,820
這只是不同的方式
收拾東西到你的程序

47
00:02:05,820 --> 00:02:10,681
而你的程序，而不是
只是打印他們這個屏幕

48
00:02:10,681 --> 00:02:12,430
或輸入的東西
在命令行中。

49
00:02:12,430 --> 00:02:13,760

50
00:02:13,760 --> 00:02:18,030
>> 所以，第一個是小
比插入符更大。

51
00:02:18,030 --> 00:02:22,085
所以output--它只是打印輸出
到文件，而不是你的屏幕。

52
00:02:22,085 --> 00:02:23,620

53
00:02:23,620 --> 00:02:29,500
所以，如果你有一些印刷
“你好，世界！”到屏幕上，

54
00:02:29,500 --> 00:02:32,400
如果你把它改為
到output.text，那

55
00:02:32,400 --> 00:02:35,220
創建此文件名為output.text。

56
00:02:35,220 --> 00:02:38,550
當你打開它時，它會
說“你好，世界！”在那裡。

57
00:02:38,550 --> 00:02:41,410
這可能是超好用
如果你有一噸的錯誤

58
00:02:41,410 --> 00:02:43,430
實際上，正如我們看到的這一個。

59
00:02:43,430 --> 00:02:46,810
如果你做兩插入符號，它會
打印的錯誤信息。

60
00:02:46,810 --> 00:02:52,090
>> 所以，如果你有一個問題
編譯，它有很多的錯誤

61
00:02:52,090 --> 00:02:56,770
而你要在努力陷入困境
在命令行滾動

62
00:02:56,770 --> 00:02:59,110
通過所有這些，你可以
只是它們打印到文件，

63
00:02:59,110 --> 00:03:02,130
打開該文件，這樣您
可以通過他們比較容易滾動。

64
00:03:02,130 --> 00:03:05,160
其實我用了一個
很多時候我在調試

65
00:03:05,160 --> 00:03:07,970
我的181 pset中的機器學習。

66
00:03:07,970 --> 00:03:10,000
所以可以超好用以後。

67
00:03:10,000 --> 00:03:18,370
它也是有用的，如果你有一個程序
這也許是生成一個圖書館

68
00:03:18,370 --> 00:03:20,430
或產生一些集
字符串，你

69
00:03:20,430 --> 00:03:22,846
需要能夠看到
它的正確生成它們。

70
00:03:22,846 --> 00:03:23,860

71
00:03:23,860 --> 00:03:25,160
這是做到這一點的方法。

72
00:03:25,160 --> 00:03:28,280
>> 所以，如果你把它們打印到文件，你
可以更容易地檢查它們，對嗎？

73
00:03:28,280 --> 00:03:30,930
與試圖滾動
通過你的命令行。

74
00:03:30,930 --> 00:03:32,740

75
00:03:32,740 --> 00:03:35,820
再有一點要注意
是，只用更大

76
00:03:35,820 --> 00:03:40,090
比插入符號，如果你正在寫
到已exists--一個文件

77
00:03:40,090 --> 00:03:44,990
這樣一樣，如果我們跑這第一
一次，我們把它output.text，

78
00:03:44,990 --> 00:03:49,970
然後我們有了第二個節目
該印刷這是方案二

79
00:03:49,970 --> 00:03:54,250
並做了比output.text更大，
它將覆蓋that--這樣

80
00:03:54,250 --> 00:03:56,715
覆蓋了什麼是有史以來在
該文件開始。

81
00:03:56,715 --> 00:03:57,720

82
00:03:57,720 --> 00:04:00,750
>> 所以，如果你想追加
到一個文件，我們在這裡看到，

83
00:04:00,750 --> 00:04:04,779
你只要做的比跡象2大。

84
00:04:04,779 --> 00:04:05,820
而且將追加到它。

85
00:04:05,820 --> 00:04:06,750
它不會覆蓋它。

86
00:04:06,750 --> 00:04:09,770
所以，如果你需要運行多個
計劃和種不斷

87
00:04:09,770 --> 00:04:13,170
跟踪什麼所有的人都
返回到您的文件，

88
00:04:13,170 --> 00:04:14,190
這是一個辦法做到這一點。

89
00:04:14,190 --> 00:04:17,231
如果你不在乎什麼在你的文件
並且它允許被覆蓋，

90
00:04:17,231 --> 00:04:19,204
你可以使用比單一更大。

91
00:04:19,204 --> 00:04:20,600
這是否有意義大家？

92
00:04:20,600 --> 00:04:23,205

93
00:04:23,205 --> 00:04:31,140
>> 聽眾：像點斜線你好更大
比輸出點的文字，像兩次，

94
00:04:31,140 --> 00:04:34,030
它會僅僅只顯示輸出
點文本第二時間 - 

95
00:04:34,030 --> 00:04:34,810
>> 揚聲器1：沒錯。

96
00:04:34,810 --> 00:04:40,450
所以它基本上是完全
覆蓋是什麼在那裡開始。

97
00:04:40,450 --> 00:04:44,260
如果在這裡，在此文件
output.text已

98
00:04:44,260 --> 00:04:48,230
存在，基本上無論你怎麼稱呼
這再次用一個較大

99
00:04:48,230 --> 00:04:51,920
比你可以把它
因為喜歡它替換的文件。

100
00:04:51,920 --> 00:04:54,824
當你保存一個Word喜歡
文檔和你另存為，

101
00:04:54,824 --> 00:04:57,365
與你保持相同的名稱，
它完全覆蓋它 - 

102
00:04:57,365 --> 00:04:58,680
這是同樣的事情。

103
00:04:58,680 --> 00:05:00,380

104
00:05:00,380 --> 00:05:03,550
任何人有任何問題，
只是輸出到一個文件？

105
00:05:03,550 --> 00:05:05,051

106
00:05:05,051 --> 00:05:05,550
真棒。

107
00:05:05,550 --> 00:05:11,440
>> 所以，很顯然，如果你扭轉，
箭頭方向，它可以做輸入。

108
00:05:11,440 --> 00:05:13,090

109
00:05:13,090 --> 00:05:19,960
所以，當你們有
像愷撒和的Visioneer

110
00:05:19,960 --> 00:05:23,195
你必須輸入一些東西，
你有一個命令行參數

111
00:05:23,195 --> 00:05:24,960
實際上它的輸入。

112
00:05:24,960 --> 00:05:27,410
這是另一種方式來做到這一點。

113
00:05:27,410 --> 00:05:30,520
因此，而不是等待
對於命令行提示，

114
00:05:30,520 --> 00:05:33,800
就像當你問你的
在愷撒或消息的Visioneer，

115
00:05:33,800 --> 00:05:36,490
如果你有一個文本文件
那有你的消息，

116
00:05:36,490 --> 00:05:38,280
你可以只需鍵入它變成。

117
00:05:38,280 --> 00:05:44,930
>> 因此，如果這是像點斜線撒
3小於箭頭輸入文本，這

118
00:05:44,930 --> 00:05:47,240
是你的訊息，也
會運行得很好。

119
00:05:47,240 --> 00:05:51,310

120
00:05:51,310 --> 00:05:54,020
當你的凱撒程序實際上
要求來自用戶的輸入，

121
00:05:54,020 --> 00:05:57,360
那就已經擁有了它，因為
你輸入的這個文件。

122
00:05:57,360 --> 00:05:58,830
這只是另一種方式。

123
00:05:58,830 --> 00:06:02,445
的output--只是一個反向
只需輸入您的數據。

124
00:06:02,445 --> 00:06:04,570

125
00:06:04,570 --> 00:06:06,680
>> 然後，最後一個是管。

126
00:06:06,680 --> 00:06:07,780
所以這一塊的很酷。

127
00:06:07,780 --> 00:06:09,890
因為它可以讓你
取一個的輸出

128
00:06:09,890 --> 00:06:13,695
程序，並把它作為
輸入到其他程序。

129
00:06:13,695 --> 00:06:15,250

130
00:06:15,250 --> 00:06:18,630
我不知道你們中的任何
玩解密

131
00:06:18,630 --> 00:06:20,590
這CS50可能
給你的，但它會

132
00:06:20,590 --> 00:06:27,380
讓你花一些樣品
文件，將其輸入到加密，

133
00:06:27,380 --> 00:06:30,350
然後從那裡輸入
那到你解密

134
00:06:30,350 --> 00:06:32,470
以確保它竟然是一樣的。

135
00:06:32,470 --> 00:06:34,050
因此，它是一種像三路循環。

136
00:06:34,050 --> 00:06:38,400

137
00:06:38,400 --> 00:06:39,423
去了。

138
00:06:39,423 --> 00:06:41,785
>> 聽眾：如果一個程序
具有多個輸入，

139
00:06:41,785 --> 00:06:47,646
有沒有辦法來告訴它哪個輸入
使用文本文件或輸出？

140
00:06:47,646 --> 00:06:49,325
>> 揚聲器1：它有多個輸入。

141
00:06:49,325 --> 00:06:52,190

142
00:06:52,190 --> 00:07:00,430
無論你的文件input--時，它的
要求輸入的第一次，這是

143
00:07:00,430 --> 00:07:03,240
要承擔，我認為，這是
將管在整個文件中。

144
00:07:03,240 --> 00:07:03,979

145
00:07:03,979 --> 00:07:07,145
所以，如果你有多個輸入，你
將要通過管道中的多個文件。

146
00:07:07,145 --> 00:07:08,190

147
00:07:08,190 --> 00:07:12,390
所以，如果你問的消息
在你的代碼三次，

148
00:07:12,390 --> 00:07:15,230
你將要放
在三個不同的文件。

149
00:07:15,230 --> 00:07:15,980
它得到瘋狂。

150
00:07:15,980 --> 00:07:18,188
你不應該
擔心現在。

151
00:07:18,188 --> 00:07:19,150
但是，這是這個想法。

152
00:07:19,150 --> 00:07:20,680

153
00:07:20,680 --> 00:07:26,822
>> 所以呀，管是一種只輸出
程序使用輸入到其它。

154
00:07:26,822 --> 00:07:27,665
每個人都很好嗎？

155
00:07:27,665 --> 00:07:28,565

156
00:07:28,565 --> 00:07:29,065
涼爽。

157
00:07:29,065 --> 00:07:30,170

158
00:07:30,170 --> 00:07:30,932
行。

159
00:07:30,932 --> 00:07:32,890
你可能不會有
做太多吧。

160
00:07:32,890 --> 00:07:35,670
但是，你應該明白
方法可以用這個。

161
00:07:35,670 --> 00:07:38,910
並且在某些情況該
你可能想使用它。

162
00:07:38,910 --> 00:07:44,590
>> 所以，文件I / O--我知道你在做什麼
saying--我們已經習慣了從閱讀

163
00:07:44,590 --> 00:07:50,500
並寫入我們的屏幕出現，
這是標準和標準輸出。

164
00:07:50,500 --> 00:07:54,370
而這正是你們一直
因為上課開始在這裡做什麼。

165
00:07:54,370 --> 00:07:58,220
但你也可以讀取和寫入文件，
這是所有的I / O--所以文件輸入文件，

166
00:07:58,220 --> 00:07:59,850
輸出是所有代表。

167
00:07:59,850 --> 00:08:00,930

168
00:08:00,930 --> 00:08:04,360
因此，這基本上意味著，
您現在可以存儲你的數據。

169
00:08:04,360 --> 00:08:08,460
>> 當你只需將它打印到
屏幕上，它基本上消失了，對不對？

170
00:08:08,460 --> 00:08:12,507
只要你做的“Hello
世界“並運行的”Hello world“

171
00:08:12,507 --> 00:08:14,090
它打印的“Hello world”到屏幕上。

172
00:08:14,090 --> 00:08:16,370
但你不能真正做到
任何與它從那裡。

173
00:08:16,370 --> 00:08:18,950
如果您在文本存儲
文件中，然後突然

174
00:08:18,950 --> 00:08:22,789
你有你允許該數據
操縱或把它放到一個文件中，

175
00:08:22,789 --> 00:08:24,080
或者把它變成一個程序後。

176
00:08:24,080 --> 00:08:26,370

177
00:08:26,370 --> 00:08:29,290
其中的一個原因
為什麼我們這樣做僅僅是

178
00:08:29,290 --> 00:08:31,560
作為一種方法來存儲數據以供以後使用。

179
00:08:31,560 --> 00:08:34,790

180
00:08:34,790 --> 00:08:37,279
>> 我有幾個步驟，在這裡
通過標準只是走

181
00:08:37,279 --> 00:08:39,450
I / O。在第一步中，您
需要建立一個參考

182
00:08:39,450 --> 00:08:43,480
與所有文件
帽FILE明星的文件。

183
00:08:43,480 --> 00:08:45,740
以便創建一個指針到一個文件中。

184
00:08:45,740 --> 00:08:48,080

185
00:08:48,080 --> 00:08:49,650
所以，你要打開它。

186
00:08:49,650 --> 00:08:52,940
和你說，從字面上看，
只是文件的fopen相等。

187
00:08:52,940 --> 00:08:57,400
並且這將返回一個
指針到剛才打開的文件。

188
00:08:57,400 --> 00:08:59,610

189
00:08:59,610 --> 00:09:01,460
我看到了一對夫婦的你
球員在辦公時間。

190
00:09:01,460 --> 00:09:07,400
>> 不過的事情之一
是remember--指針

191
00:09:07,400 --> 00:09:10,409
可以是一些地址或者為null，對不對？

192
00:09:10,409 --> 00:09:12,700
如果我們曾經有一個情況
東西可以返回null，

193
00:09:12,700 --> 00:09:14,990
我們有什麼做的
之前，我們曾經使用它呢？

194
00:09:14,990 --> 00:09:16,220

195
00:09:16,220 --> 00:09:19,000
我們需要檢查
這是空或不是，對不對？

196
00:09:19,000 --> 00:09:23,600
因為有些人可能有過
的問題，即任何物體

197
00:09:23,600 --> 00:09:26,110
在突圍中被返回為空。

198
00:09:26,110 --> 00:09:28,170
您試圖執行
它的一些功能。

199
00:09:28,170 --> 00:09:29,770
與您的電腦網站出現故障。

200
00:09:29,770 --> 00:09:30,725
對不對？

201
00:09:30,725 --> 00:09:33,640
我敢打賭，一對夫婦的你
可能有這個問題。

202
00:09:33,640 --> 00:09:38,890
>> 所以用的fopen，FOPEN要么
返回一個指向該文件，

203
00:09:38,890 --> 00:09:41,200
或者，如果出了問題，
它會返回null。

204
00:09:41,200 --> 00:09:45,980
所以，你總是需要檢查
它沒有返回null

205
00:09:45,980 --> 00:09:47,880
之前嘗試做別的。

206
00:09:47,880 --> 00:09:49,110

207
00:09:49,110 --> 00:09:51,974
這就像一個標準的範例
那你要在這裡需要。

208
00:09:51,974 --> 00:09:54,390
如果有過一個機會，
事情就可以返回null，

209
00:09:54,390 --> 00:09:56,590
檢查以確保它
不，然後再繼續。

210
00:09:56,590 --> 00:09:58,911
否則，你會
讓可愛的現場故障。

211
00:09:58,911 --> 00:10:00,410
沒有人喜歡處理那些。

212
00:10:00,410 --> 00:10:03,180

213
00:10:03,180 --> 00:10:06,410
>> 所以，我們在這裡看到，第一個參數
僅僅是文件路徑。

214
00:10:06,410 --> 00:10:09,380
如果該文件不存在，則
它會創建一個文件。

215
00:10:09,380 --> 00:10:10,713
它只是將是空白的。

216
00:10:10,713 --> 00:10:10,789

217
00:10:10,789 --> 00:10:13,080
然後第二個參數
是您想要的模式。

218
00:10:13,080 --> 00:10:14,610
我們想從這個文件讀取？

219
00:10:14,610 --> 00:10:15,560
你想要把它寫？

220
00:10:15,560 --> 00:10:16,476
你想追加？

221
00:10:16,476 --> 00:10:17,600

222
00:10:17,600 --> 00:10:20,670
所以實際上我剛才說 - 
如果該文件不存在

223
00:10:20,670 --> 00:10:23,400
而你試圖讀
它，它會拋出一個錯誤。

224
00:10:23,400 --> 00:10:26,890
如果文件名稱 - 如果喜歡
file.text還不存在

225
00:10:26,890 --> 00:10:29,250
你想寫
它，它會創建

226
00:10:29,250 --> 00:10:33,110
所謂file.text你一個空白文件。

227
00:10:33,110 --> 00:10:36,612
如果你想追加，
你應該做同樣的事情。

228
00:10:36,612 --> 00:10:38,081
這是否有道理？

229
00:10:38,081 --> 00:10:40,580
如果你想從閱讀
那還不存在的文件時，

230
00:10:40,580 --> 00:10:41,590
它會拋出一個錯誤。

231
00:10:41,590 --> 00:10:44,340
否則，它會創建文件
為你做什麼，你想要它。

232
00:10:44,340 --> 00:10:45,970

233
00:10:45,970 --> 00:10:46,470
涼爽。

234
00:10:46,470 --> 00:10:47,510

235
00:10:47,510 --> 00:10:48,880
現在我們可以從文件中讀取。

236
00:10:48,880 --> 00:10:52,570
而這僅僅是種會
通過不同的功能

237
00:10:52,570 --> 00:10:58,980
我們對文件I / O操作。這將
有必要在本週的pset中，

238
00:10:58,980 --> 00:11:00,505
如果我沒記錯的話。

239
00:11:00,505 --> 00:11:02,880
是的，這絕對將是
有必要在本週的PSET。

240
00:11:02,880 --> 00:11:04,260

241
00:11:04,260 --> 00:11:07,010
所以龜etc返回下一個字符。

242
00:11:07,010 --> 00:11:08,350

243
00:11:08,350 --> 00:11:10,300
FGETS只返回一行文本。

244
00:11:10,300 --> 00:11:11,790

245
00:11:11,790 --> 00:11:14,610
它會返回任何東西來
一個新的行，這將打破。

246
00:11:14,610 --> 00:11:15,950

247
00:11:15,950 --> 00:11:18,700
所以，用fread讀取某一
字節並將其名額數

248
00:11:18,700 --> 00:11:20,700
成的陣列，其
是你可能會

249
00:11:20,700 --> 00:11:25,485
想要做重新size--
可能是有用的。

250
00:11:25,485 --> 00:11:26,550

251
00:11:26,550 --> 00:11:29,290
>> 有多少人看過
pset的規範，對了？

252
00:11:29,290 --> 00:11:30,980

253
00:11:30,980 --> 00:11:32,261
行。

254
00:11:32,261 --> 00:11:32,760
[聽不清]

255
00:11:32,760 --> 00:11:35,380

256
00:11:35,380 --> 00:11:36,580
>> 揚聲器1：OK。

257
00:11:36,580 --> 00:11:37,530
行。

258
00:11:37,530 --> 00:11:41,940
絕對看that--這是一個有趣的pset。

259
00:11:41,940 --> 00:11:51,320
你去恢復已刪除的記憶
card--時，它的作品真的令人興奮。

260
00:11:51,320 --> 00:11:54,100
但可以肯定，開始讀了。

261
00:11:54,100 --> 00:11:56,280
再來說說我，如果你
有關於它的問題。

262
00:11:56,280 --> 00:11:59,290
>> 好了，因為我說的，FREAD
讀出一定數目的字節。

263
00:11:59,290 --> 00:12:01,340

264
00:12:01,340 --> 00:12:03,590
這是一些任意數量
那你要設置的。

265
00:12:03,590 --> 00:12:05,990

266
00:12:05,990 --> 00:12:08,260
然後FSEEK只是移動
到了一定的位置。

267
00:12:08,260 --> 00:12:11,150
因此，也許你不在乎
關於接下來的10個字節​​。

268
00:12:11,150 --> 00:12:12,880
你只是想跳過前面。

269
00:12:12,880 --> 00:12:14,030
你不關心這些。

270
00:12:14,030 --> 00:12:16,280
你想讀的起始字節11。

271
00:12:16,280 --> 00:12:18,252
fseek的可以讓你做到這一點。

272
00:12:18,252 --> 00:12:20,710
所以，它可以讓你有所選擇
你在看什麼書。

273
00:12:20,710 --> 00:12:25,880
因為龜etc，與fgets，並用fread讀
從該文件中的某個地方。

274
00:12:25,880 --> 00:12:27,260

275
00:12:27,260 --> 00:12:35,090
>> 一種方法去思考，這是如果這
是我們的文件，當你第一次打開它，

276
00:12:35,090 --> 00:12:41,140
你在文件中這個位置
這開始於開始。

277
00:12:41,140 --> 00:12:45,040
每當你打電話
龜etc，fgetf，或用fread，

278
00:12:45,040 --> 00:12:48,875
它會從開始
這個位置標記。

279
00:12:48,875 --> 00:12:51,340

280
00:12:51,340 --> 00:12:55,245
比方說，你只是想讀
這一段記憶在這裡。

281
00:12:55,245 --> 00:12:56,300

282
00:12:56,300 --> 00:12:57,960
你不能只是打電話。

283
00:12:57,960 --> 00:13:02,430
你必須尋求看過來
然後從那裡讀

284
00:13:02,430 --> 00:13:06,540
或閱讀，獲取，或getc的，
這取決於你想要什麼。

285
00:13:06,540 --> 00:13:09,310
因此，尋求公正，您可以
跳過存儲器的部分。

286
00:13:09,310 --> 00:13:11,590
而這是唯一的
這樣，你可以跳過的東西

287
00:13:11,590 --> 00:13:14,012
沒有閱讀到您的緩衝區。

288
00:13:14,012 --> 00:13:15,470
這是否有意義大家？

289
00:13:15,470 --> 00:13:21,110

290
00:13:21,110 --> 00:13:24,780
>> 很顯然，有一個
很多並行這裡 - 的

291
00:13:24,780 --> 00:13:27,780
我們的輸出或輸入重定向，
您已經閱讀並書寫。

292
00:13:27,780 --> 00:13:31,800
所以的fputc只是寫了一個
字符到該文件中。

293
00:13:31,800 --> 00:13:33,655
fputs將寫入一條線。

294
00:13:33,655 --> 00:13:35,030

295
00:13:35,030 --> 00:13:37,420
fprintf中打印一個格式化的輸出。

296
00:13:37,420 --> 00:13:41,190
所以，如果你有標籤，
或空間，或諸如此類的東西。

297
00:13:41,190 --> 00:13:44,180
然後fwrite的寫一些
字節數組到一個文件中。

298
00:13:44,180 --> 00:13:48,860
因此，這是同樣的方式
FWRITE和FREAD類似於

299
00:13:48,860 --> 00:13:57,550
opposites--與fgets，fputs函數和
隨後的fputc和fgetc--地段

300
00:13:57,550 --> 00:14:00,710
瘋狂的，快速的東西。

301
00:14:00,710 --> 00:14:05,300
>> 剛種保持這個handy--
您將有不同的時間

302
00:14:05,300 --> 00:14:08,680
在那裡，也許你只是想
一個字符的時間。

303
00:14:08,680 --> 00:14:09,890
也許你想一整行。

304
00:14:09,890 --> 00:14:14,320
隨著你的字典pset--
這是在2 pset時，

305
00:14:14,320 --> 00:14:19,690
我相信，我們給你一個整體
字典中的文本格式

306
00:14:19,690 --> 00:14:22,252
其中有每一個字
由一個行分隔。

307
00:14:22,252 --> 00:14:24,210
所以，如果你想讀
在一次一個字，

308
00:14:24,210 --> 00:14:31,769
也許你用什麼，如果你正在閱讀
而且他們都分開上新的生產線，

309
00:14:31,769 --> 00:14:33,310
只是想和你在一個時間一個字？

310
00:14:33,310 --> 00:14:35,320

311
00:14:35,320 --> 00:14:36,040
>> 聽眾：FGETS

312
00:14:36,040 --> 00:14:36,748
>> 揚聲器1：沒錯。

313
00:14:36,748 --> 00:14:39,960
Fgets--因為返回
無論是在一行上。

314
00:14:39,960 --> 00:14:42,750
如果每一個字是它的
自己的路線，我們可以使用與fgets。

315
00:14:42,750 --> 00:14:44,511

316
00:14:44,511 --> 00:14:45,010
涼爽。

317
00:14:45,010 --> 00:14:47,290
這是否有意義，大家？

318
00:14:47,290 --> 00:14:48,020
很酷吧？

319
00:14:48,020 --> 00:14:50,020
是啊，我們要得到
最有趣的部分與指針

320
00:14:50,020 --> 00:14:51,728
很快，在那裡你
可以做一些數學。

321
00:14:51,728 --> 00:14:52,776
而這將是巨大的。

322
00:14:52,776 --> 00:14:55,690

323
00:14:55,690 --> 00:14:57,740
>> 最後step--關閉您的文件。

324
00:14:57,740 --> 00:15:01,090
在這裡這麼多的事情，
我們的範式之一

325
00:15:01,090 --> 00:15:03,550
是，如果它可以返回
空，檢查空。

326
00:15:03,550 --> 00:15:06,160
如果你打開的東西，
你最好將其關閉。

327
00:15:06,160 --> 00:15:10,419
OK，這樣你就不會做了，直到你
這樣做，除非你已經關閉了它。

328
00:15:10,419 --> 00:15:12,585
有點像這還沒有結束
直到胖女人唱歌。

329
00:15:12,585 --> 00:15:14,130
這就像關閉文件。

330
00:15:14,130 --> 00:15:16,860

331
00:15:16,860 --> 00:15:19,190
因為它說，在這裡，只
再次重申，永遠

332
00:15:19,190 --> 00:15:21,750
打開您的文件你之前
讀取或寫入數據。

333
00:15:21,750 --> 00:15:24,450
並始終將其關閉，如果你已經打開了它。

334
00:15:24,450 --> 00:15:25,460
行？

335
00:15:25,460 --> 00:15:25,960
涼爽。

336
00:15:25,960 --> 00:15:26,835
>> 因此，這裡是一個例子。

337
00:15:26,835 --> 00:15:29,250

338
00:15:29,250 --> 00:15:34,330
所以tiny--我不知道，如果你
你們可以看到，非常好。

339
00:15:34,330 --> 00:15:36,805
如果我們能提高
亮度莫名其妙。

340
00:15:36,805 --> 00:15:40,430

341
00:15:40,430 --> 00:15:45,030
讓我真正做到這一點，如果我能。

342
00:15:45,030 --> 00:15:48,020

343
00:15:48,020 --> 00:15:51,470
OK，你們真的不能
看得出來，所有的，可以嗎？

344
00:15:51,470 --> 00:15:52,905
好了，我們要做到這一點，那麼。

345
00:15:52,905 --> 00:16:35,094

346
00:16:35,094 --> 00:16:35,594
[聽不清]

347
00:16:35,594 --> 00:16:56,670

348
00:16:56,670 --> 00:16:58,605
>> 我認為這是更好的看到。

349
00:16:58,605 --> 00:17:17,330

350
00:17:17,330 --> 00:17:19,455
任何人都可以看到我的
鼠標去是個問題？

351
00:17:19,455 --> 00:17:22,837
啊，還有這is--什麼奮鬥！

352
00:17:22,837 --> 00:17:48,910

353
00:17:48,910 --> 00:17:49,520
>> 行。

354
00:17:49,520 --> 00:17:53,845
基本上，你們應該有一種
什麼這一個想法在做什麼。

355
00:17:53,845 --> 00:17:56,740

356
00:17:56,740 --> 00:17:57,600
它並不完美。

357
00:17:57,600 --> 00:17:58,851

358
00:17:58,851 --> 00:18:02,425
但我寧願解釋它不是花
更多的時間來正確地格式化。

359
00:18:02,425 --> 00:18:03,610

360
00:18:03,610 --> 00:18:07,280
基本上，你在這裡看到，
我們首先打開文件。

361
00:18:07,280 --> 00:18:09,620
和我們有一些
我們是數據庫文件

362
00:18:09,620 --> 00:18:12,300
打開該說這是我們的學生。

363
00:18:12,300 --> 00:18:14,020
我們要去寫它。

364
00:18:14,020 --> 00:18:15,060

365
00:18:15,060 --> 00:18:17,720
所以，當然，返回null。

366
00:18:17,720 --> 00:18:19,650
因此，我們要檢查空。

367
00:18:19,650 --> 00:18:22,930
然後，如果它不是
空，我們去。

368
00:18:22,930 --> 00:18:25,660
正如你看到的，我們
循環經過這裡。

369
00:18:25,660 --> 00:18:26,960
還有的學生。

370
00:18:26,960 --> 00:18:30,520
學生是被定義為三個散。

371
00:18:30,520 --> 00:18:34,060
我們正在做的事情是我們
打印到文件，對不對？

372
00:18:34,060 --> 00:18:36,975
那麼，我們打印出我們的文件？

373
00:18:36,975 --> 00:18:47,040

374
00:18:47,040 --> 00:18:48,906
>> 聽眾：得分
這是在陣列中？

375
00:18:48,906 --> 00:18:49,680
>> 揚聲器1：是啊。

376
00:18:49,680 --> 00:18:50,980
這是在分數
在array--正好。

377
00:18:50,980 --> 00:18:53,050
因此，我們要打開這個
數據庫文件，該文件

378
00:18:53,050 --> 00:18:56,040
我以為是某種
的成績數據庫。

379
00:18:56,040 --> 00:19:01,100
而我們只是打印出
分數每一個學生到該文件。

380
00:19:01,100 --> 00:19:02,140
很酷吧？

381
00:19:02,140 --> 00:19:02,640
不錯。

382
00:19:02,640 --> 00:19:03,811

383
00:19:03,811 --> 00:19:04,310
真棒。

384
00:19:04,310 --> 00:19:05,100
行。

385
00:19:05,100 --> 00:19:06,950
讓我們回到to--

386
00:19:06,950 --> 00:19:08,646
>> 觀眾：我有一個快速的問題。

387
00:19:08,646 --> 00:19:11,570
是的printf不是在for循環？

388
00:19:11,570 --> 00:19:12,870
這只是在if循環？

389
00:19:12,870 --> 00:19:14,370
揚聲器1：不，這是在for循環。

390
00:19:14,370 --> 00:19:16,150

391
00:19:16,150 --> 00:19:18,810
我看不到我的鼠標非常好了這裡。

392
00:19:18,810 --> 00:19:21,359
所以我在努力
格式正確。

393
00:19:21,359 --> 00:19:22,525
這架應消失。

394
00:19:22,525 --> 00:19:23,610

395
00:19:23,610 --> 00:19:25,130
它應該是到這裡。

396
00:19:25,130 --> 00:19:26,605
這是在你的for循環。

397
00:19:26,605 --> 00:20:10,680

398
00:20:10,680 --> 00:20:11,180
那裡。

399
00:20:11,180 --> 00:20:12,160
現在它的漂亮。

400
00:20:12,160 --> 00:20:16,720
所以這是它應該如何be--除外
對於我被解僱，去年支架。

401
00:20:16,720 --> 00:20:17,220
行。

402
00:20:17,220 --> 00:20:19,491
這是否有意義大家？

403
00:20:19,491 --> 00:20:19,990
行。

404
00:20:19,990 --> 00:20:23,750
我們將繼續前進
在接下來的事情then--

405
00:20:23,750 --> 00:20:26,180
其中，實際上，你會
到需要看到的代碼。

406
00:20:26,180 --> 00:20:28,370
所以我只是要
複製了現在。

407
00:20:28,370 --> 00:20:31,500

408
00:20:31,500 --> 00:20:32,000
行。

409
00:20:32,000 --> 00:20:35,110
所以我要告訴你這傢伙的代碼。

410
00:20:35,110 --> 00:20:38,240
我希望你能嘗試和數字
什麼是應該做的。

411
00:20:38,240 --> 00:20:49,740

412
00:20:49,740 --> 00:20:52,480
>> 所以，有了that--花一分鐘左右。

413
00:20:52,480 --> 00:20:54,440
試圖弄清楚是怎麼回事。

414
00:20:54,440 --> 00:21:58,840

415
00:21:58,840 --> 00:21:59,570
>> 任何想法？

416
00:21:59,570 --> 00:22:08,180

417
00:22:08,180 --> 00:22:12,470
>> 我們知道，我們至少有兩個
在命令行參數，對不對？

418
00:22:12,470 --> 00:22:16,270
我想其中一個將是
那[聽不清]我們的節目是

419
00:22:16,270 --> 00:22:17,530
然後別的東西。

420
00:22:17,530 --> 00:22:19,980
因為如果[聽不清]為少
超過兩個，我們大聲呵責。

421
00:22:19,980 --> 00:22:21,140
對不對？

422
00:22:21,140 --> 00:22:25,300
而從使用，它看起來像
這將是某種形式的文件。

423
00:22:25,300 --> 00:22:26,260
我們都同意這一點？

424
00:22:26,260 --> 00:22:29,110

425
00:22:29,110 --> 00:22:31,570
所以，現在，什麼是循環在做什麼？

426
00:22:31,570 --> 00:22:32,570
它是什麼經歷？

427
00:22:32,570 --> 00:22:35,000

428
00:22:35,000 --> 00:22:36,449
>> 聽眾：所有的文件。

429
00:22:36,449 --> 00:22:37,240
揚聲器1：沒錯。

430
00:22:37,240 --> 00:22:39,650
它會遍歷所有的
我們已經投入存在的文件。

431
00:22:39,650 --> 00:22:40,720

432
00:22:40,720 --> 00:22:46,040
因此，對於每一個文件，它的
開放一些字符串出現。

433
00:22:46,040 --> 00:22:47,560
它開闢了該文件。

434
00:22:47,560 --> 00:22:48,060
對不對？

435
00:22:48,060 --> 00:22:49,140

436
00:22:49,140 --> 00:22:52,380
和它的從中讀取。

437
00:22:52,380 --> 00:22:53,420

438
00:22:53,420 --> 00:22:55,540
當然，檢查它是否為null。

439
00:22:55,540 --> 00:22:57,220
然後它的打印。

440
00:22:57,220 --> 00:23:01,460
如果它是空的，它只是告訴我們
這是不是一個真實存在的文件。

441
00:23:01,460 --> 00:23:04,290
因為記得，有
請閱讀我們的文件必須存在。

442
00:23:04,290 --> 00:23:04,810
對不對？

443
00:23:04,810 --> 00:23:06,870
隨著寫入和追加，
你可以擺脫它。

444
00:23:06,870 --> 00:23:08,970
但是，隨著讀，我們的文件必須存在。

445
00:23:08,970 --> 00:23:10,430

446
00:23:10,430 --> 00:23:13,330
>> 然後，如果它確實存在，
什麼是我們在這裡做什麼？

447
00:23:13,330 --> 00:23:14,810

448
00:23:14,810 --> 00:23:15,780
就讓我們從這裡開始。

449
00:23:15,780 --> 00:23:18,815
這是什麼do--這第一個字符。

450
00:23:18,815 --> 00:23:20,960

451
00:23:20,960 --> 00:23:21,790
它有什麼作用？

452
00:23:21,790 --> 00:23:24,100
他得到一個字符，對不對？

453
00:23:24,100 --> 00:23:25,400
那麼，什麼是該做的？

454
00:23:25,400 --> 00:23:26,775
它獲得的第一個字符。

455
00:23:26,775 --> 00:23:28,860

456
00:23:28,860 --> 00:23:30,200
任何人都知道EOF？

457
00:23:30,200 --> 00:23:31,170
>> 聽眾：文件結尾？

458
00:23:31,170 --> 00:23:32,680
>> SPEAKER 1：file--正好結束。

459
00:23:32,680 --> 00:23:35,310
所以，它要經過
整個文件，對不對？

460
00:23:35,310 --> 00:23:36,710

461
00:23:36,710 --> 00:23:40,780
然後它會被更新
讓每一個後續字符。

462
00:23:40,780 --> 00:23:41,565
對不對？

463
00:23:41,565 --> 00:23:43,636
而且它是什麼做的？

464
00:23:43,636 --> 00:23:44,760
聽眾：把那個in--

465
00:23:44,760 --> 00:23:46,741

466
00:23:46,741 --> 00:23:49,170
>> 揚聲器1：打印的putChar
您的屏幕保護程序。

467
00:23:49,170 --> 00:23:50,867

468
00:23:50,867 --> 00:23:51,950
[聽不清]字符。

469
00:23:51,950 --> 00:23:54,300
然後，當[聽不清]
這將關閉該文件。

470
00:23:54,300 --> 00:23:57,370
>> 聽眾：你並不需要一個[？別的嗎？ ？]

471
00:23:57,370 --> 00:23:59,005
>> 揚聲器1：不一定。

472
00:23:59,005 --> 00:24:01,480
我的意思是，種它暗示這一點。

473
00:24:01,480 --> 00:24:06,780
因為這將返回，不過，只要
因為這不趕上這一點，你的罰款。

474
00:24:06,780 --> 00:24:07,940

475
00:24:07,940 --> 00:24:10,250
我的意思是它可能很好
練習做一個人。

476
00:24:10,250 --> 00:24:15,755
但是，一個否則並不總是
需要特別

477
00:24:15,755 --> 00:24:17,610
如果你有什麼事情
就像一個回報，這

478
00:24:17,610 --> 00:24:20,640
意味著，在這種情況下，如果它捕獲
它，你的程序將要結束

479
00:24:20,640 --> 00:24:21,850
它永遠也沒有機會了。

480
00:24:21,850 --> 00:24:23,030

481
00:24:23,030 --> 00:24:29,190
這多為你從哪來的情況下
不一定回來的東西。

482
00:24:29,190 --> 00:24:31,370
因為，如果這是不
返回任何東西，

483
00:24:31,370 --> 00:24:34,430
這意味著，如果這是真的，
這樣做的其餘部分將繼續運行。

484
00:24:34,430 --> 00:24:36,138
在此情況下，你
希望假。

485
00:24:36,138 --> 00:24:38,240
如果它回來，
你的程序的結束，

486
00:24:38,240 --> 00:24:41,960
還有一種是沒有必要全部
的時間，這取決於上下文。

487
00:24:41,960 --> 00:24:43,084

488
00:24:43,084 --> 00:24:44,375
雅各，你有問題嗎？

489
00:24:44,375 --> 00:24:46,100
聽眾：是的。

490
00:24:46,100 --> 00:24:49,300
所以，做龜etc得到下一個字符？

491
00:24:49,300 --> 00:24:50,734
怎樣的性格會增加嗎？

492
00:24:50,734 --> 00:24:51,400
揚聲器1：是啊。

493
00:24:51,400 --> 00:24:52,774
所以龜etc得到下一個字符。

494
00:24:52,774 --> 00:24:54,140

495
00:24:54,140 --> 00:24:56,866
你可以認為它像C ++中的感覺。

496
00:24:56,866 --> 00:24:58,350
>> 聽眾：那麼什麼是EOF？

497
00:24:58,350 --> 00:25:00,877
>> 揚聲器1：EOF是文件結束。

498
00:25:00,877 --> 00:25:03,960
這只是一個標記，讓你知道
那你在你的文件的末尾。

499
00:25:03,960 --> 00:25:06,742
所以，這是怎麼回事打印
以你的標準了。

500
00:25:06,742 --> 00:25:08,950
然後它會關閉
當它這樣做的文件。

501
00:25:08,950 --> 00:25:10,700
然後讓我們去
下一個文件，對不對？

502
00:25:10,700 --> 00:25:12,660
所以，總體來說，這是什麼節目呢？

503
00:25:12,660 --> 00:25:15,402

504
00:25:15,402 --> 00:25:16,090
>> [聽不清]

505
00:25:16,090 --> 00:25:16,900
>> 揚聲器1：是啊。

506
00:25:16,900 --> 00:25:18,770
它只是打印出那​​裡的一切。

507
00:25:18,770 --> 00:25:23,270
所以，如果你們曾經使用CAT
一些file--中，然後將名

508
00:25:23,270 --> 00:25:26,240
我不知道如果你們有
做過你的終端上。

509
00:25:26,240 --> 00:25:29,630
但是，如果你曾經使用
命令CAT-- C-A-T--

510
00:25:29,630 --> 00:25:31,880
然後任何文件
你那裡 - 它

511
00:25:31,880 --> 00:25:37,260
打印出來給你的終端，這
可超方便的一些事情。

512
00:25:37,260 --> 00:25:38,746
我用了很多。

513
00:25:38,746 --> 00:25:40,120
這是否有意義大家？

514
00:25:40,120 --> 00:25:41,480

515
00:25:41,480 --> 00:25:42,100
很酷吧？

516
00:25:42,100 --> 00:25:46,530
>> 行，所以你的任務now--無論是
自己或身邊你 - 人

517
00:25:46,530 --> 00:25:54,930
是只寫一個簡單的程序
這將只寫“你好，世界！”

518
00:25:54,930 --> 00:25:56,255
出到文件。

519
00:25:56,255 --> 00:26:00,215
>> [聽不清]

520
00:26:00,215 --> 00:26:56,210

521
00:26:56,210 --> 00:26:57,040
>> [聽不清]

522
00:26:57,040 --> 00:26:59,248
>> 揚聲器1：我當時想，做
我說不好，上週做什麼？

523
00:26:59,248 --> 00:27:00,201

524
00:27:00,201 --> 00:27:01,492
我不認為這是不好的。

525
00:27:01,492 --> 00:27:02,479

526
00:27:02,479 --> 00:27:03,520
我很高興你在這裡。

527
00:27:03,520 --> 00:27:04,655
這真的讓我很高興。

528
00:27:04,655 --> 00:27:07,565

529
00:27:07,565 --> 00:27:10,160
我的簡單的快樂女孩。

530
00:27:10,160 --> 00:27:11,688
我只是想，當我的部分參加。

531
00:27:11,688 --> 00:27:13,830

532
00:27:13,830 --> 00:27:18,270
所以我剛剛得到這個開始為
你們讓我們可以編寫在一起。

533
00:27:18,270 --> 00:27:22,290
我不喜歡把任何人
現貨，除非你想要的。

534
00:27:22,290 --> 00:27:26,486

535
00:27:26,486 --> 00:27:30,086
>> 顧客：測驗，做
我們要編寫一個程序？

536
00:27:30,086 --> 00:27:33,260
>> 揚聲器1：您可能會被要求
手工編寫簡單的程序。

537
00:27:33,260 --> 00:27:35,940

538
00:27:35,940 --> 00:27:36,590
是啊。

539
00:27:36,590 --> 00:27:38,510
>> 聽眾：測驗是下週，對不對？

540
00:27:38,510 --> 00:27:40,108
>> 揚聲器1：本測驗是下週三。

541
00:27:40,108 --> 00:27:40,855

542
00:27:40,855 --> 00:27:43,730
這意味著有一個可愛的[？ CSE？]
黨的分級之後，這

543
00:27:43,730 --> 00:27:50,390
意味著你將得到你的分數
回來的night--在什麼時候？

544
00:27:50,390 --> 00:27:50,890
誰知道？

545
00:27:50,890 --> 00:27:51,973
但是，這將是夜晚。

546
00:27:51,973 --> 00:28:02,020

547
00:28:02,020 --> 00:28:02,855
>> 行。

548
00:28:02,855 --> 00:28:04,250
我們想得到怎樣的開始呢？

549
00:28:04,250 --> 00:28:07,964

550
00:28:07,964 --> 00:28:09,630
我給你一個hint--開始與此有關。

551
00:28:09,630 --> 00:28:11,455
>> 聽眾：你要打開一個文件。

552
00:28:11,455 --> 00:28:12,250
>> 揚聲器1：是啊。

553
00:28:12,250 --> 00:28:14,060
那麼你想打電話嗎？

554
00:28:14,060 --> 00:28:16,150
你只想把它稱為“文件”？

555
00:28:16,150 --> 00:28:17,480
我們可以很容易。

556
00:28:17,480 --> 00:28:26,752
所以fopen--什麼是我們的
輸出測試將是？

557
00:28:26,752 --> 00:28:36,130
稱之為“你好。”

558
00:28:36,130 --> 00:28:37,810
什麼是我們的模式？

559
00:28:37,810 --> 00:28:39,764

560
00:28:39,764 --> 00:28:41,055
什麼是我們做的這個文件？

561
00:28:41,055 --> 00:28:42,676

562
00:28:42,676 --> 00:28:43,500
>> 聽眾：閱讀。

563
00:28:43,500 --> 00:28:44,401

564
00:28:44,401 --> 00:28:44,900
寫作。

565
00:28:44,900 --> 00:28:46,191
揚聲器1：我們正在寫它。

566
00:28:46,191 --> 00:28:47,360

567
00:28:47,360 --> 00:28:47,860
可愛的。

568
00:28:47,860 --> 00:28:50,330

569
00:28:50,330 --> 00:28:52,860
好了，我們現在有這個文件。

570
00:28:52,860 --> 00:28:54,920

571
00:28:54,920 --> 00:28:56,212
什麼是我們需要做什麼？

572
00:28:56,212 --> 00:28:57,420
聽眾：檢查是否為null。

573
00:28:57,420 --> 00:28:59,820
揚聲器1：檢查是否是null--完全吻合。

574
00:28:59,820 --> 00:29:01,980
這就是我喜歡聽。

575
00:29:01,980 --> 00:29:05,930
這應該是自動的，尤其是
幾乎從這點上。

576
00:29:05,930 --> 00:29:07,530

577
00:29:07,530 --> 00:29:10,950
如果你開始段錯誤，您可能
沒有檢查空的地方。

578
00:29:10,950 --> 00:29:12,480
十有八九的，這是
將是你的錯誤。

579
00:29:12,480 --> 00:29:15,400
所以，如果你能得到的
習慣，經常檢查它是否為null，

580
00:29:15,400 --> 00:29:18,150
你的生活將是
不錯，easy--或更容易。

581
00:29:18,150 --> 00:29:19,480
>> 因此，檢查，看它是否為null。

582
00:29:19,480 --> 00:29:21,200

583
00:29:21,200 --> 00:29:24,820
所以，如果它不為空，這
是什麼砰等於

584
00:29:24,820 --> 00:29:26,784
是指：不null--它是有效的。

585
00:29:26,784 --> 00:29:27,700
我們究竟想幹什麼？

586
00:29:27,700 --> 00:29:29,750

587
00:29:29,750 --> 00:29:31,570
我們只是想打印
該文件，對不對？

588
00:29:31,570 --> 00:29:32,923
那麼，我們要使用？

589
00:29:32,923 --> 00:29:34,092
>> 聽眾：fprintf中

590
00:29:34,092 --> 00:29:36,800
>> 揚聲器1：Fprintf--可愛。

591
00:29:36,800 --> 00:29:38,150

592
00:29:38,150 --> 00:29:44,000
和fprintf需要兩個arguments--在哪裡
這是怎麼回事，我們要打印的是什麼。

593
00:29:44,000 --> 00:29:45,820
那麼，什麼是第一位？

594
00:29:45,820 --> 00:29:46,570
在哪裡了？

595
00:29:46,570 --> 00:29:47,490
>> 聽眾：文件。

596
00:29:47,490 --> 00:29:48,785
>> 揚聲器1：這將文件。

597
00:29:48,785 --> 00:29:49,784

598
00:29:49,784 --> 00:29:50,950
？我們要打印的？

599
00:29:50,950 --> 00:29:52,900

600
00:29:52,900 --> 00:29:58,065
“你好，世界！”

601
00:29:58,065 --> 00:29:58,565
行。

602
00:29:58,565 --> 00:30:03,670
我們還有最後一個件事 - 
這裡的另一大模式。

603
00:30:03,670 --> 00:30:04,479

604
00:30:04,479 --> 00:30:05,145
聽眾：關閉。

605
00:30:05,145 --> 00:30:05,853
揚聲器1：關閉。

606
00:30:05,853 --> 00:30:09,990

607
00:30:09,990 --> 00:30:10,540
你去那裡。

608
00:30:10,540 --> 00:30:13,384
>> 聽眾：這是發生
如果文件是空？

609
00:30:13,384 --> 00:30:15,050
揚聲器1：不，這是如果它不為null。

610
00:30:15,050 --> 00:30:16,881
聽眾：哦，如果它是不是 - 確定。

611
00:30:16,881 --> 00:30:21,728

612
00:30:21,728 --> 00:30:25,410
為則fopen然後
這裡面去兩個參數，

613
00:30:25,410 --> 00:30:27,655
什麼是第一個參數又是什麼意思？

614
00:30:27,655 --> 00:30:30,392
>> 揚聲器1：參數是
就像該文件的名稱

615
00:30:30,392 --> 00:30:31,350
你想去。

616
00:30:31,350 --> 00:30:36,020
所以這個運行後，你會
有一個名為“你好”的一些文件

617
00:30:36,020 --> 00:30:38,320
說了“你好，世界”在其中。

618
00:30:38,320 --> 00:30:38,820
就這樣。

619
00:30:38,820 --> 00:30:39,500
只是名稱。

620
00:30:39,500 --> 00:30:42,685

621
00:30:42,685 --> 00:30:48,650
>> 聽眾：由於它的寫作中，
文件不必存在。

622
00:30:48,650 --> 00:30:49,675
這就是你說了什麼？

623
00:30:49,675 --> 00:30:50,410
>> 揚聲器1：沒錯。

624
00:30:50,410 --> 00:30:50,910
沒錯。

625
00:30:50,910 --> 00:30:53,110

626
00:30:53,110 --> 00:30:55,839
如果“你好”作為文件
還不存在，它的

627
00:30:55,839 --> 00:30:58,380
要創建一個名為
你好“，寫它給你。

628
00:30:58,380 --> 00:30:59,631

629
00:30:59,631 --> 00:31:03,610
>> 聽眾：當你告訴
程序寫的文件，

630
00:31:03,610 --> 00:31:08,075
為什麼你寫的“文件”，而不是
文件和fprintf--的名稱

631
00:31:08,075 --> 00:31:13,600
>> 揚聲器1：由於在這種情況下，我們有
大型FILE--所有caps--明星，

632
00:31:13,600 --> 00:31:14,260
文件中。

633
00:31:14,260 --> 00:31:17,370
所以它是一個指向文件
你在說什麼。

634
00:31:17,370 --> 00:31:19,930
這是的方式
我們只是參考一下吧。

635
00:31:19,930 --> 00:31:24,850
所以在這種情況下，你
能想到file--啊哈的，

636
00:31:24,850 --> 00:31:31,271
我們可以在這裡使用this--文件
指的開口“你好”

637
00:31:31,271 --> 00:31:32,145
並讓其寫。

638
00:31:32,145 --> 00:31:34,728
>> 聽眾：我們可以把“你好”
代替[？只是？F的文件？

639
00:31:34,728 --> 00:31:40,160
揚聲器1：沒有，因為“你好”
必須是開放的，可寫的。

640
00:31:40,160 --> 00:31:41,820

641
00:31:41,820 --> 00:31:45,980
文件在這裡就像是一個
標誌，說好了，我們

642
00:31:45,980 --> 00:31:49,190
有這樣的file-- hello--
我們正在尋找。

643
00:31:49,190 --> 00:31:50,680
它已被打開。

644
00:31:50,680 --> 00:31:52,140
而我們將要寫入。

645
00:31:52,140 --> 00:31:55,130
如果你只是用“你好”，
被封裝在其中。

646
00:31:55,130 --> 00:31:56,846
因此，它會發瘋。

647
00:31:56,846 --> 00:31:58,590

648
00:31:58,590 --> 00:32:00,300
我的意思是，你可以把它命名。

649
00:32:00,300 --> 00:32:03,960
你可以做的文件，
明星，“你好”，等於說。

650
00:32:03,960 --> 00:32:07,840
但是整個的一點是，你
需要一個文件指針明星為了

651
00:32:07,840 --> 00:32:09,281
能夠使用這些功能。

652
00:32:09,281 --> 00:32:11,280
聽眾：你能做到
文件，明星，文件，“你好”

653
00:32:11,280 --> 00:32:13,113
或者你必須把
通過它的文件巨星，文件？

654
00:32:13,113 --> 00:32:16,330
揚聲器1：你可以
做好檔案，明星，“你好。”

655
00:32:16,330 --> 00:32:19,790
你可以改變這
無論你想要的名稱。

656
00:32:19,790 --> 00:32:22,114
這是完全任意的
什麼名字是。

657
00:32:22,114 --> 00:32:23,179

658
00:32:23,179 --> 00:32:24,220
你可以使用任何名字。

659
00:32:24,220 --> 00:32:25,501

660
00:32:25,501 --> 00:32:28,020
將它命名為飛意大利麵條，如果你想要的。

661
00:32:28,020 --> 00:32:29,690
>> 聽眾：什麼是“W”的報價？

662
00:32:29,690 --> 00:32:31,540
>> 揚聲器1：在“W”只是模式。

663
00:32:31,540 --> 00:32:33,170
因此，我們寫這個文件。

664
00:32:33,170 --> 00:32:34,410

665
00:32:34,410 --> 00:32:35,320
大家好？

666
00:32:35,320 --> 00:32:36,227
清楚了嗎？

667
00:32:36,227 --> 00:32:36,981
是。

668
00:32:36,981 --> 00:32:40,365
>> 聽眾：所以當它寫這
文件中，我們在哪裡，然後找到那個文件？

669
00:32:40,365 --> 00:32:43,820
>> 揚聲器1：這將是在同
你是在當前目錄中。

670
00:32:43,820 --> 00:32:45,650

671
00:32:45,650 --> 00:32:48,880
如果你在PSET三年
你運行這個，你PSET內

672
00:32:48,880 --> 00:32:52,600
3文件夾將是
該文件名為“你好。”

673
00:32:52,600 --> 00:32:53,160
很酷吧？

674
00:32:53,160 --> 00:32:53,757
大家好？

675
00:32:53,757 --> 00:32:55,840
我覺得你的所有
得到它，這是偉大的。

676
00:32:55,840 --> 00:32:57,290

677
00:32:57,290 --> 00:32:57,790
行。

678
00:32:57,790 --> 00:33:05,960
所以，回到我的幻燈片展示 - 
我喜歡的事情工作。

679
00:33:05,960 --> 00:33:08,674
OK，pointers--是你們興奮嗎？

680
00:33:08,674 --> 00:33:09,465
指針是巨大的。

681
00:33:09,465 --> 00:33:11,581

682
00:33:11,581 --> 00:33:13,580
他們需要一點點
來包裝你的頭左右。

683
00:33:13,580 --> 00:33:15,288
這是我第二年
教學指針。

684
00:33:15,288 --> 00:33:16,850
我想我終於得到它。

685
00:33:16,850 --> 00:33:18,650
所以，如果你掙扎，它的確定。

686
00:33:18,650 --> 00:33:19,940

687
00:33:19,940 --> 00:33:24,070
正如我之前說的，畫畫
幫助了很多的事情在CS，

688
00:33:24,070 --> 00:33:27,400
就像我認為人們傾向於
想想哦，我們是在一台電腦。

689
00:33:27,400 --> 00:33:28,399
我們應該代碼。

690
00:33:28,399 --> 00:33:30,190
No--繪製圖片
將真正幫助你。

691
00:33:30,190 --> 00:33:32,773
我真的鼓勵你
打入你的幼兒園老師邊

692
00:33:32,773 --> 00:33:35,010
並帶出蠟筆
或者標記和抽獎。

693
00:33:35,010 --> 00:33:36,110
因為它會幫助你。

694
00:33:36,110 --> 00:33:39,380
如果你看到我在辦公時間內，我
將隨身攜帶紙堆

695
00:33:39,380 --> 00:33:41,580
用鋼筆畫的東西出來。

696
00:33:41,580 --> 00:33:44,370
>> 因此，特別是
pointers--畫畫。

697
00:33:44,370 --> 00:33:47,970
我敢肯定，我們究竟要
要繪製一些照片也在這裡。

698
00:33:47,970 --> 00:33:51,270
>> 所以你們都找來看看賓基，
這個很酷的claymation的事情。

699
00:33:51,270 --> 00:33:54,720
我們認為這是非常有趣的，當
他爆炸成一堆碎片。

700
00:33:54,720 --> 00:33:56,280

701
00:33:56,280 --> 00:33:57,755
這是一些可笑的安心上課。

702
00:33:57,755 --> 00:34:02,140

703
00:34:02,140 --> 00:34:05,900
C [聽不清]這個偉大的能力
以能夠控制存儲器。

704
00:34:05,900 --> 00:34:10,090
而且它的事情之一是真的
使得它如此強大的語言。

705
00:34:10,090 --> 00:34:13,469
但隨著巨大的動力來自
責任重大。

706
00:34:13,469 --> 00:34:16,230
和瘋狂的事情都可能發生
如果你不小心。

707
00:34:16,230 --> 00:34:18,560
所以，當你使用
指針，你想

708
00:34:18,560 --> 00:34:21,440
確保你真正了解
正是你在做什麼。

709
00:34:21,440 --> 00:34:25,530
的希望下一點點
時間會幫助你真正​​了解

710
00:34:25,530 --> 00:34:27,850
指針，如何使用它們，
以及如何操作它們。

711
00:34:27,850 --> 00:34:29,170

712
00:34:29,170 --> 00:34:33,460
>> 所以memory--我敢肯定，我們已經
以前見過這個圖。

713
00:34:33,460 --> 00:34:38,540
因此，這是只是一個簡單的示意圖
事情怎麼可能存儲內存。

714
00:34:38,540 --> 00:34:43,145
所以，你基本上有這些
中的一個字節的塊巨大陣列

715
00:34:43,145 --> 00:34:46,000
就是我們這裡 - 輕微
遞增1，每次。

716
00:34:46,000 --> 00:34:51,810
這是十六進制[聽不清]
這樣8位的塊。

717
00:34:51,810 --> 00:34:55,510
而每塊關聯
一些十六進制地址。

718
00:34:55,510 --> 00:34:58,750
所以，如果你看到的
0X，這只是notating

719
00:34:58,750 --> 00:35:00,670
這是一個十六進制地址。

720
00:35:00,670 --> 00:35:03,970
你可以假設，這意味著
一些地址在存儲器中。

721
00:35:03,970 --> 00:35:06,935
我們談論的是內存地址
每當你看到十六進制。

722
00:35:06,935 --> 00:35:10,420

723
00:35:10,420 --> 00:35:14,630
>> 我們是整數變量，
彩車是存儲變量。

724
00:35:14,630 --> 00:35:16,260
所以，整數存儲整數。

725
00:35:16,260 --> 00:35:17,430
花車彩車店。

726
00:35:17,430 --> 00:35:20,260
所以，我們也有三分
那家商店的內存地址。

727
00:35:20,260 --> 00:35:21,660
這是一種映射。

728
00:35:21,660 --> 00:35:24,240
指針是完全
為存儲器地址。

729
00:35:24,240 --> 00:35:25,780

730
00:35:25,780 --> 00:35:27,292
所以，這就像你的類型有。

731
00:35:27,292 --> 00:35:29,550

732
00:35:29,550 --> 00:35:34,470
您的設備是32位，這意味著
您的內存地址是4個字節。

733
00:35:34,470 --> 00:35:37,830
讓你有任何的指針
也將是4個字節。

734
00:35:37,830 --> 00:35:43,200
否則，如果它是四個字節，
存儲器是4個字節。

735
00:35:43,200 --> 00:35:44,790
指針存儲內存。

736
00:35:44,790 --> 00:35:46,430
因此，它們是四個字節。

737
00:35:46,430 --> 00:35:48,460
Cool--只是想加強這一點。

738
00:35:48,460 --> 00:35:50,120

739
00:35:50,120 --> 00:35:52,220
>> 現在你應該得到這個漫畫。

740
00:35:52,220 --> 00:35:55,040
我不知道你們有多少人
XKCD是球迷，但我喜歡XKCD。

741
00:35:55,040 --> 00:35:55,780
這很棒。

742
00:35:55,780 --> 00:35:57,290

743
00:35:57,290 --> 00:35:57,790
>> 行。

744
00:35:57,790 --> 00:36:01,640
所以創建pointers--正如我所說，這是
非常簡單，只是想別的。

745
00:36:01,640 --> 00:36:02,930
你有一個類型。

746
00:36:02,930 --> 00:36:04,050
你有一個名字。

747
00:36:04,050 --> 00:36:04,810
對不對？

748
00:36:04,810 --> 00:36:10,410
這就是我們必須在那裡。
[？十六進制？]星意味著它是一個指針，

749
00:36:10,410 --> 00:36:12,250
然後隨便你怎麼稱呼它。

750
00:36:12,250 --> 00:36:15,770
因此，類型代表
你可以存儲。

751
00:36:15,770 --> 00:36:16,850

752
00:36:16,850 --> 00:36:17,990
行？

753
00:36:17,990 --> 00:36:24,350
以同樣的方式，如果我們做整數，
我們知道，我們要存儲一個int那裡。

754
00:36:24,350 --> 00:36:25,990

755
00:36:25,990 --> 00:36:30,280
用一個指針，它
保存的存儲器地址。

756
00:36:30,280 --> 00:36:34,240
但是，它的意思是that--這裡的地​​方
圖紙是要派上用場了。

757
00:36:34,240 --> 00:36:36,170

758
00:36:36,170 --> 00:36:45,980
所以在這種情況下，我們有
一些value--假設4。

759
00:36:45,980 --> 00:36:49,306
四是在地址之一。

760
00:36:49,306 --> 00:36:49,805
行？

761
00:36:49,805 --> 00:36:51,550

762
00:36:51,550 --> 00:36:56,170
>> 在這裡第一個指
這是一個指針2倍。

763
00:36:56,170 --> 00:36:56,740
對不對？

764
00:36:56,740 --> 00:36:57,628
這是一些指針X。

765
00:36:57,628 --> 00:36:58,852

766
00:36:58,852 --> 00:37:00,940
x可以是什麼，等等。

767
00:37:00,940 --> 00:37:01,960

768
00:37:01,960 --> 00:37:05,130
無論X is--說x是4。

769
00:37:05,130 --> 00:37:07,280
這是怎麼回事存儲
此處的存儲器地址。

770
00:37:07,280 --> 00:37:12,260
因此INT，明星，x--這是
在memory--其他插槽

771
00:37:12,260 --> 00:37:13,590
誰知道這是什麼。

772
00:37:13,590 --> 00:37:15,430
但它要在這裡存放的地址。

773
00:37:15,430 --> 00:37:27,040
因此，這將是like--
在這種情況下，無論什麼，

774
00:37:27,040 --> 00:37:32,630
被存儲在0x1--任何存儲
在我們的指針保存地址，

775
00:37:32,630 --> 00:37:35,280
有與匹配
我們所指定的。

776
00:37:35,280 --> 00:37:40,330
所以在0x1，則在這種情況下，此為x。

777
00:37:40,330 --> 00:37:42,500

778
00:37:42,500 --> 00:37:49,340
這永遠只能是一個
我們使用這個，而詮釋。

779
00:37:49,340 --> 00:37:52,950
>> 同樣，如果我們有
另外1Y，不管

780
00:37:52,950 --> 00:37:59,130
地址存儲用y具有
是一個char--同樣的事情態。

781
00:37:59,130 --> 00:38:05,840
以同樣的方式，只要你
嘗試做的INTx等於0.4，

782
00:38:05,840 --> 00:38:09,275
它會罵你，是
好像沒有，你說你想要一個int。

783
00:38:09,275 --> 00:38:10,525
這應該是一個int。

784
00:38:10,525 --> 00:38:11,900
停止努力，使之成為浮動。

785
00:38:11,900 --> 00:38:14,150
>> 因此，讓事情是他們想要的。

786
00:38:14,150 --> 00:38:15,159

787
00:38:15,159 --> 00:38:16,200
讓事情自己做主。

788
00:38:16,200 --> 00:38:19,380

789
00:38:19,380 --> 00:38:23,450
這麼大的事情就是
指針的任何類型

790
00:38:23,450 --> 00:38:26,101
這是，這是唯一的
你可以存儲在那裡的事情。

791
00:38:26,101 --> 00:38:26,600
行？

792
00:38:26,600 --> 00:38:27,910

793
00:38:27,910 --> 00:38:31,160
通過練習，與
上週，應有盡有

794
00:38:31,160 --> 00:38:32,817
看來真的是種抽象的。

795
00:38:32,817 --> 00:38:34,150
我們要做一些練習。

796
00:38:34,150 --> 00:38:36,760
它應該更有意義。

797
00:38:36,760 --> 00:38:44,580
>> 因此，參考和dereferencing--它的
真正重要的是讓這些直線。

798
00:38:44,580 --> 00:38:46,630
我還是要刷新
飄飛。

799
00:38:46,630 --> 00:38:48,450
我很喜歡等待，我想要哪一個？

800
00:38:48,450 --> 00:38:56,080
因此，符號，實際上給
您的參考或地址。

801
00:38:56,080 --> 00:39:00,100
所以它返回到地址
該變量的存儲器存儲。

802
00:39:00,100 --> 00:39:01,170

803
00:39:01,170 --> 00:39:07,020
所以它要真正恢復到您
十六進制，而它提領

804
00:39:07,020 --> 00:39:10,641
實際上是要給你
被存儲在那裡的數據。

805
00:39:10,641 --> 00:39:11,140
行？

806
00:39:11,140 --> 00:39:12,680

807
00:39:12,680 --> 00:39:16,060
所以，我們要來看一個例子
真快，居然還是旁邊。

808
00:39:16,060 --> 00:39:18,050

809
00:39:18,050 --> 00:39:19,150
>> 行。

810
00:39:19,150 --> 00:39:21,790
因此，我們必須想想真
小心這一點。

811
00:39:21,790 --> 00:39:23,860
所以在這裡我們有一些整數x。

812
00:39:23,860 --> 00:39:26,485
我要去嘗試，並得出這樣的
出盡我的能力。

813
00:39:26,485 --> 00:39:30,230

814
00:39:30,230 --> 00:39:32,410
因此，我們將這個插槽x。

815
00:39:32,410 --> 00:39:35,850

816
00:39:35,850 --> 00:39:37,315
它的存儲5。

817
00:39:37,315 --> 00:39:38,640

818
00:39:38,640 --> 00:39:40,090
它的地址是為0x4。

819
00:39:40,090 --> 00:39:41,920

820
00:39:41,920 --> 00:39:43,160
很酷吧？

821
00:39:43,160 --> 00:39:44,100
都不錯。

822
00:39:44,100 --> 00:39:45,470
>> 所以，現在我們有這個指針。

823
00:39:45,470 --> 00:39:46,916

824
00:39:46,916 --> 00:39:47,990
正是在這裡。

825
00:39:47,990 --> 00:39:52,130

826
00:39:52,130 --> 00:39:57,560
和符號給我們
某事的地址。

827
00:39:57,560 --> 00:40:00,780
所以，在這種情況下，它是x的地址。

828
00:40:00,780 --> 00:40:01,875
什麼是x的地址？

829
00:40:01,875 --> 00:40:05,660

830
00:40:05,660 --> 00:40:12,590
04  - 而這個指針是0x08的。

831
00:40:12,590 --> 00:40:14,490

832
00:40:14,490 --> 00:40:14,990
很酷吧？

833
00:40:14,990 --> 00:40:16,570

834
00:40:16,570 --> 00:40:21,570
所以，你可以考慮一下這個
指針04，只是點在這裡。

835
00:40:21,570 --> 00:40:22,840

836
00:40:22,840 --> 00:40:25,740
而他們所謂的指針
因為當我們得到更多成這樣，

837
00:40:25,740 --> 00:40:28,450
你會看到指向的東西。

838
00:40:28,450 --> 00:40:31,470
和一個塊指向另一個
塊將使得很多更有意義。

839
00:40:31,470 --> 00:40:32,760

840
00:40:32,760 --> 00:40:33,890
因此，這裡有兩個。

841
00:40:33,890 --> 00:40:38,230
然後我們有一些
副本，這是what-- 0x0C的。

842
00:40:38,230 --> 00:40:41,290

843
00:40:41,290 --> 00:40:43,420
而這將
我們取消引用指針。

844
00:40:43,420 --> 00:40:46,790
>> 那麼，它的意思是
好了，這裡是我們的指針。

845
00:40:46,790 --> 00:40:53,090
它存儲的值是0×04，什麼
它說是去這個地址

846
00:40:53,090 --> 00:40:54,300
並告訴我，什麼是它。

847
00:40:54,300 --> 00:40:55,520

848
00:40:55,520 --> 00:40:57,710
所以這是有效的
這是什麼方向做。

849
00:40:57,710 --> 00:40:58,750

850
00:40:58,750 --> 00:41:01,280
你可以認為這就像你的明星。

851
00:41:01,280 --> 00:41:05,410
這樣就OK了，當我們這樣做的明星，這意味著隨之而來。

852
00:41:05,410 --> 00:41:06,810
去這個地址。

853
00:41:06,810 --> 00:41:11,430
而這基本上就是以下
這個箭頭，這個內存塊。

854
00:41:11,430 --> 00:41:15,380
給我們什麼呢，這是5。

855
00:41:15,380 --> 00:41:18,840
這就是為什麼我們的副本等於5。

856
00:41:18,840 --> 00:41:20,120
這是否有道理？

857
00:41:20,120 --> 00:41:22,769
有沒有人需要我去通過
那一次，或者更慢？

858
00:41:22,769 --> 00:41:24,560
你要我去
通過這一次？

859
00:41:24,560 --> 00:41:25,060
行。

860
00:41:25,060 --> 00:41:27,549

861
00:41:27,549 --> 00:41:28,840
我們要再次重繪。

862
00:41:28,840 --> 00:41:31,930

863
00:41:31,930 --> 00:41:37,205
當我們開始，我們大家都同意，我們有
一些內存塊，這是一個變量

864
00:41:37,205 --> 00:41:40,890
X，我們設定為等於5。

865
00:41:40,890 --> 00:41:42,910
我們不控制它在內存中。

866
00:41:42,910 --> 00:41:45,520
所以，這個地方就是
任意分配。

867
00:41:45,520 --> 00:41:47,770

868
00:41:47,770 --> 00:41:48,731
好的呢？

869
00:41:48,731 --> 00:41:49,230
行。

870
00:41:49,230 --> 00:41:50,420

871
00:41:50,420 --> 00:41:53,330
然後我們初始化一個指向整數的指針。

872
00:41:53,330 --> 00:41:56,900
這就是為什麼它可以指向
X，因為我們在這裡為int。

873
00:41:56,900 --> 00:42:00,840
我們的另一塊
內存，因為這個指針

874
00:42:00,840 --> 00:42:03,485
就像其他任何一個變量。

875
00:42:03,485 --> 00:42:06,615
它任意分配
在內存部分空間。

876
00:42:06,615 --> 00:42:07,630

877
00:42:07,630 --> 00:42:10,830
和它存儲為x的地址。

878
00:42:10,830 --> 00:42:13,200
與符號表示x的地址。

879
00:42:13,200 --> 00:42:14,575
那麼，什麼是x的地址？

880
00:42:14,575 --> 00:42:19,179

881
00:42:19,179 --> 00:42:20,614
>> 聽眾：這是zero--

882
00:42:20,614 --> 00:42:21,280
揚聲器1：0×04。

883
00:42:21,280 --> 00:42:24,350

884
00:42:24,350 --> 00:42:25,940
所以then--最後一個。

885
00:42:25,940 --> 00:42:30,650
我們再次有一些copy--
只是另一個變量。

886
00:42:30,650 --> 00:42:32,520
因此，讓我們分配一些任意的地方。

887
00:42:32,520 --> 00:42:35,260

888
00:42:35,260 --> 00:42:38,080
我們解引用我們的指針。

889
00:42:38,080 --> 00:42:42,490
明星意味著進入
地址保存在我的指針。

890
00:42:42,490 --> 00:42:44,480
告訴我那裡的東西。

891
00:42:44,480 --> 00:42:47,290
因此，存儲地址
在我們的指針為0×04。

892
00:42:47,290 --> 00:42:49,070

893
00:42:49,070 --> 00:42:51,310
所以，我們去那個地址。

894
00:42:51,310 --> 00:42:52,402

895
00:42:52,402 --> 00:42:54,590
它指向該地址。

896
00:42:54,590 --> 00:42:57,481
這是什麼內存塊中？

897
00:42:57,481 --> 00:42:57,980
這是一個五人。

898
00:42:57,980 --> 00:42:59,210

899
00:42:59,210 --> 00:43:01,650
所以，這就是我們給我們的副本。

900
00:43:01,650 --> 00:43:03,430

901
00:43:03,430 --> 00:43:04,860
大家好？

902
00:43:04,860 --> 00:43:05,360
涼爽。

903
00:43:05,360 --> 00:43:07,010

904
00:43:07,010 --> 00:43:08,330
Again--圖片。

905
00:43:08,330 --> 00:43:19,750

906
00:43:19,750 --> 00:43:25,200
>> 因此，跟踪這裡 - 我的價值觀
打算讓你們想一想。

907
00:43:25,200 --> 00:43:26,550

908
00:43:26,550 --> 00:43:27,750
我們可以得出另一張照片。

909
00:43:27,750 --> 00:43:31,260
但我希望你能嘗試的理由
通過這個你自己一分鐘。

910
00:43:31,260 --> 00:44:01,430

911
00:44:01,430 --> 00:44:04,149
>> 由於他們沒有給
我們作出了榜樣地址，

912
00:44:04,149 --> 00:44:06,940
我只是做符號x--
這將有助於推動它帶回家。

913
00:44:06,940 --> 00:44:07,950
＆符號表示的地址。

914
00:44:07,950 --> 00:44:09,540

915
00:44:09,540 --> 00:44:12,360
>> 所以在第一位的，每個人都
去的第一道防線。

916
00:44:12,360 --> 00:44:15,690
一些X設置的一些five--
隨機時隙中的存儲器。

917
00:44:15,690 --> 00:44:17,660

918
00:44:17,660 --> 00:44:23,200
INT明星指針等於
x的地址，對吧？

919
00:44:23,200 --> 00:44:28,180
INT明星指針創建
這個塊，稱之為指針，

920
00:44:28,180 --> 00:44:30,650
並將其分配給x的地址。

921
00:44:30,650 --> 00:44:32,750

922
00:44:32,750 --> 00:44:34,230
我可怕的＆符號。

923
00:44:34,230 --> 00:44:36,460

924
00:44:36,460 --> 00:44:40,550
>> 現在我們正在做的就是我們說
OK，我們解引用指針。

925
00:44:40,550 --> 00:44:42,760
所以，我們去好了，什麼是我們的指針？

926
00:44:42,760 --> 00:44:44,820
它的符號X。

927
00:44:44,820 --> 00:44:49,400
去符號x和重新分配它。

928
00:44:49,400 --> 00:44:51,620

929
00:44:51,620 --> 00:44:57,480
>> 所以，現在，符號X將是35。

930
00:44:57,480 --> 00:45:01,540

931
00:45:01,540 --> 00:45:05,174
所以基本上，當你
提領，你去確定。

932
00:45:05,174 --> 00:45:07,090
你將要繪製
圖片是這樣的。

933
00:45:07,090 --> 00:45:09,423
你將要繪製
你的箭在哪裡。

934
00:45:09,423 --> 00:45:16,030
所以，到這個插槽的內存，要么
給我回值，或改變它。

935
00:45:16,030 --> 00:45:21,620
在這種情況下，因為我們在這
值，我們分配它是35。

936
00:45:21,620 --> 00:45:24,700
而在最後
1，如果你注意到，我們

937
00:45:24,700 --> 00:45:27,680
被指派了什麼
在這裡別的東西。

938
00:45:27,680 --> 00:45:30,450

939
00:45:30,450 --> 00:45:32,245
>> 因此，他們有這個真棒表。

940
00:45:32,245 --> 00:45:35,000

941
00:45:35,000 --> 00:45:36,890
這不是那麼糟糕。

942
00:45:36,890 --> 00:45:37,970
你們的工作就可以了。

943
00:45:37,970 --> 00:45:39,640
我要拔出來在黑板上。

944
00:45:39,640 --> 00:45:41,306
我們要填好在一起，好不好？

945
00:45:41,306 --> 00:45:42,290

946
00:45:42,290 --> 00:45:45,530
因此，抓住一些紙，搶
一個合作夥伴，開始工作。

947
00:45:45,530 --> 00:45:53,897

948
00:45:53,897 --> 00:45:55,605
我要得到一個
更大的粉筆。

949
00:45:55,605 --> 00:45:56,624

950
00:45:56,624 --> 00:45:58,150
因為這將是很多。

951
00:45:58,150 --> 00:45:59,410

952
00:45:59,410 --> 00:45:59,910
行。

953
00:45:59,910 --> 00:48:08,567

954
00:48:08,567 --> 00:48:09,150
教授：OK。

955
00:48:09,150 --> 00:48:11,599

956
00:48:11,599 --> 00:48:12,890
讓我們先從第一排。

957
00:48:12,890 --> 00:48:14,070

958
00:48:14,070 --> 00:48:16,970
我們會從那裡開始，那麼你們
也許可以工作，通過多一些。

959
00:48:16,970 --> 00:48:17,870
行。

960
00:48:17,870 --> 00:48:19,810
一個等於B C時代那麼什麼是？

961
00:48:19,810 --> 00:48:21,420

962
00:48:21,420 --> 00:48:23,260
這不是一個有趣的問題，我保證。

963
00:48:23,260 --> 00:48:24,440
>> 學生：4次5。

964
00:48:24,440 --> 00:48:25,420
>> 教授：4次5。

965
00:48:25,420 --> 00:48:25,920
20。

966
00:48:25,920 --> 00:48:26,730
那麼，什麼是B？

967
00:48:26,730 --> 00:48:27,921

968
00:48:27,921 --> 00:48:28,420
學生：4。

969
00:48:28,420 --> 00:48:30,204

970
00:48:30,204 --> 00:48:31,043
>> 教授：與c？

971
00:48:31,043 --> 00:48:31,542
學生：5。

972
00:48:31,542 --> 00:48:32,083
教授：5。

973
00:48:32,083 --> 00:48:35,960
然後這只是要
將一個＆符號，符號B，

974
00:48:35,960 --> 00:48:38,575
符號C，對不對？

975
00:48:38,575 --> 00:48:39,728

976
00:48:39,728 --> 00:48:40,596
不錯。

977
00:48:40,596 --> 00:48:42,081
這是很簡單的。

978
00:48:42,081 --> 00:48:42,580
行。

979
00:48:42,580 --> 00:48:44,300
因此，下一個。

980
00:48:44,300 --> 00:48:48,725
A等於一時間C，以防
人是不熟悉的。

981
00:48:48,725 --> 00:48:49,812

982
00:48:49,812 --> 00:48:53,300
是大家熟悉的
隨著時代等於？

983
00:48:53,300 --> 00:49:00,105
OK，這一切是指：這是
簡寫為等於C時代。

984
00:49:00,105 --> 00:49:04,840
您還可以劃分做到這一點，
用加法，用減法。

985
00:49:04,840 --> 00:49:12,130
你可以做一個等號，或加等於C
是指等於加C，負同等

986
00:49:12,130 --> 00:49:15,190
C將作為一個等於負溫度。

987
00:49:15,190 --> 00:49:16,690
這只是語法糖。

988
00:49:16,690 --> 00:49:19,380

989
00:49:19,380 --> 00:49:24,140
>> 所以，在這種情況下，a是等於
一個C時代將會給我們帶來什麼？

990
00:49:24,140 --> 00:49:25,910

991
00:49:25,910 --> 00:49:28,186
同樣，沒有一個有趣的問題。

992
00:49:28,186 --> 00:49:28,965
>> 學生：100。

993
00:49:28,965 --> 00:49:29,300
>> 教授：100。

994
00:49:29,300 --> 00:49:30,383
難道別的什麼改變？

995
00:49:30,383 --> 00:49:31,790

996
00:49:31,790 --> 00:49:32,290
號

997
00:49:32,290 --> 00:49:37,380

998
00:49:37,380 --> 00:49:39,850
也許我將最終得到
我的＆符號更好。

999
00:49:39,850 --> 00:49:42,047
>> 學生：OK，對不起，你是怎麼得到100？

1000
00:49:42,047 --> 00:49:42,630
教授：OK。

1001
00:49:42,630 --> 00:49:46,594
這樣一等於一
次C，所以C時代。

1002
00:49:46,594 --> 00:49:48,510
學生：哦，你用
一個用於previous--

1003
00:49:48,510 --> 00:49:49,135
教授：是的。

1004
00:49:49,135 --> 00:49:51,450
因此，這些都是我們的最新值。

1005
00:49:51,450 --> 00:49:53,990
這些都是你應該
用在我們向下移動，OK。

1006
00:49:53,990 --> 00:49:57,290

1007
00:49:57,290 --> 00:50:01,520
所以，B是唯一改變，是吧？

1008
00:50:01,520 --> 00:50:02,910
因此，讓我們填寫一切。

1009
00:50:02,910 --> 00:50:09,110

1010
00:50:09,110 --> 00:50:11,330
B.什麼是B將會是？

1011
00:50:11,330 --> 00:50:13,020

1012
00:50:13,020 --> 00:50:14,140
生存還是毀滅。

1013
00:50:14,140 --> 00:50:18,680

1014
00:50:18,680 --> 00:50:20,240
那麼，什麼是該做的？

1015
00:50:20,240 --> 00:50:21,605
什麼是明星PA在做什麼？

1016
00:50:21,605 --> 00:50:23,280

1017
00:50:23,280 --> 00:50:25,350
>> 學生：代號為PA的位置。

1018
00:50:25,350 --> 00:50:26,390

1019
00:50:26,390 --> 00:50:27,480
>> 學生：不，不完全是。

1020
00:50:27,480 --> 00:50:29,470
所以這是一個d參考。

1021
00:50:29,470 --> 00:50:31,580
>> 學生：所以B是PA的手的價值。

1022
00:50:31,580 --> 00:50:37,340
>> 教授：是的，所以PA是
的地址，對吧？

1023
00:50:37,340 --> 00:50:42,430
因此，它說走到哪裡是一個
存儲，並給它的價值。

1024
00:50:42,430 --> 00:50:43,884
那麼，什麼是B？

1025
00:50:43,884 --> 00:50:44,425
學生：100。

1026
00:50:44,425 --> 00:50:46,534
教授：100。

1027
00:50:46,534 --> 00:50:47,450
完美的。

1028
00:50:47,450 --> 00:50:49,879
好了，電腦是什麼樣的變化。

1029
00:50:49,879 --> 00:50:51,170
其他一切保持不變。

1030
00:50:51,170 --> 00:50:57,160

1031
00:50:57,160 --> 00:50:58,620
什麼是電腦將會是？

1032
00:50:58,620 --> 00:51:00,770

1033
00:51:00,770 --> 00:51:01,580
簡單的賦值。

1034
00:51:01,580 --> 00:51:03,520

1035
00:51:03,520 --> 00:51:05,990
PC等於PA，什麼是PA？

1036
00:51:05,990 --> 00:51:07,049
>> 學生：一個＆符號。

1037
00:51:07,049 --> 00:51:07,840
教授：完美。

1038
00:51:07,840 --> 00:51:09,490

1039
00:51:09,490 --> 00:51:10,740
現在，我們越來越有趣。

1040
00:51:10,740 --> 00:51:12,310

1041
00:51:12,310 --> 00:51:15,230
OK，讓我們打破這一個了。

1042
00:51:15,230 --> 00:51:21,110
首先，什麼是B C時代，因為這是
這一個簡單的部分，對不對？

1043
00:51:21,110 --> 00:51:22,360
B C時代is--

1044
00:51:22,360 --> 00:51:23,320
>> 學生：500。

1045
00:51:23,320 --> 00:51:28,880
>> 教授：是的，所以
什麼是這個做的，

1046
00:51:28,880 --> 00:51:33,705
如果它的明星PB，有什麼變化？

1047
00:51:33,705 --> 00:51:35,320

1048
00:51:35,320 --> 00:51:37,242
>> 學生：是什麼在the--

1049
00:51:37,242 --> 00:51:38,200
教授：是什麼在B？

1050
00:51:38,200 --> 00:51:41,340
學生：什麼是在空間
即PB指向。

1051
00:51:41,340 --> 00:51:43,406
教授：和PB指向to--

1052
00:51:43,406 --> 00:51:43,905
學生：B.

1053
00:51:43,905 --> 00:51:46,740
教授：B.因此，唯一的
事情變化是B，正確。

1054
00:51:46,740 --> 00:51:50,800
所以B次C，500。

1055
00:51:50,800 --> 00:51:52,367
所以這就是現在什麼樣的變化。

1056
00:51:52,367 --> 00:51:59,091

1057
00:51:59,091 --> 00:51:59,590
涼爽。

1058
00:51:59,590 --> 00:52:00,340

1059
00:52:00,340 --> 00:52:00,840
可愛的。

1060
00:52:00,840 --> 00:52:01,905
你們正在做的很好。

1061
00:52:01,905 --> 00:52:03,650

1062
00:52:03,650 --> 00:52:06,740
好吧，打破這一個了。

1063
00:52:06,740 --> 00:52:08,050

1064
00:52:08,050 --> 00:52:09,630
C的變化，對不對？

1065
00:52:09,630 --> 00:52:11,530
因此，我們可以填補一切。

1066
00:52:11,530 --> 00:52:12,540

1067
00:52:12,540 --> 00:52:13,205
讓我們來看看。

1068
00:52:13,205 --> 00:52:19,125

1069
00:52:19,125 --> 00:52:19,625
行。

1070
00:52:19,625 --> 00:52:21,420

1071
00:52:21,420 --> 00:52:24,740
我們知道，C是將成為
產品兩個數字的，對不對？

1072
00:52:24,740 --> 00:52:26,290

1073
00:52:26,290 --> 00:52:27,980
哪兩個數字有關係嗎？

1074
00:52:27,980 --> 00:52:28,970
>> 學生：A和C？

1075
00:52:28,970 --> 00:52:31,930
>> 教授：那麼一個是
右邊的第一個。

1076
00:52:31,930 --> 00:52:34,385
因此，我們ð引用的p，對不對？

1077
00:52:34,385 --> 00:52:35,390

1078
00:52:35,390 --> 00:52:42,870
P的指向，所以我們知道，
這將是100倍是什麼？

1079
00:52:42,870 --> 00:52:46,232
什麼時候做PC點？

1080
00:52:46,232 --> 00:52:47,410

1081
00:52:47,410 --> 00:52:48,740
指向。

1082
00:52:48,740 --> 00:52:55,038
所以，100次100萬。

1083
00:52:55,038 --> 00:52:56,170
這是否有道理？

1084
00:52:56,170 --> 00:52:57,640

1085
00:52:57,640 --> 00:52:58,200
涼爽。

1086
00:52:58,200 --> 00:53:00,500
家庭舒展，伙計們，最後一排。

1087
00:53:00,500 --> 00:53:01,190
行。

1088
00:53:01,190 --> 00:53:02,160
有什麼變化嗎？

1089
00:53:02,160 --> 00:53:05,640

1090
00:53:05,640 --> 00:53:06,935
>> 學生：A.

1091
00:53:06,935 --> 00:53:09,435
教授：A.完美的，所以
一切可以保持不變。

1092
00:53:09,435 --> 00:53:16,210

1093
00:53:16,210 --> 00:53:16,710
行。

1094
00:53:16,710 --> 00:53:17,970
什麼是？

1095
00:53:17,970 --> 00:53:23,610

1096
00:53:23,610 --> 00:53:26,060
所以這是一個什麼時代？

1097
00:53:26,060 --> 00:53:27,120
這是星PB。

1098
00:53:27,120 --> 00:53:29,750

1099
00:53:29,750 --> 00:53:34,490
因此，星PB意味著這裡的
PB，PB點到b。

1100
00:53:34,490 --> 00:53:35,370
>> 學生：500。

1101
00:53:35,370 --> 00:53:36,230
>> 教授：500。

1102
00:53:36,230 --> 00:53:39,236
因此，我們有500次100。

1103
00:53:39,236 --> 00:53:41,758
這是50000。

1104
00:53:41,758 --> 00:53:43,216
呼！

1105
00:53:43,216 --> 00:53:45,646
你看那個。

1106
00:53:45,646 --> 00:53:47,982
>> 學生：為什麼我們
的＆C的last--

1107
00:53:47,982 --> 00:53:48,690
教授：對不起。

1108
00:53:48,690 --> 00:53:50,080
學生：哦，好吧。

1109
00:53:50,080 --> 00:53:51,600
教授：我的壞。

1110
00:53:51,600 --> 00:53:52,890
大量的寫作。

1111
00:53:52,890 --> 00:53:53,917

1112
00:53:53,917 --> 00:53:54,500
大家好？

1113
00:53:54,500 --> 00:53:55,630

1114
00:53:55,630 --> 00:53:56,660
差不太多，對不對？

1115
00:53:56,660 --> 00:53:58,490
只需要一點點
同時工作，通過。

1116
00:53:58,490 --> 00:54:01,080
如果你打破它，
了解每個部分是什麼

1117
00:54:01,080 --> 00:54:03,197
是指to--為
一切是，

1118
00:54:03,197 --> 00:54:05,780
yes--打破它的小
問題，然後重新組合，

1119
00:54:05,780 --> 00:54:07,345
你可以做一些真棒的東西。

1120
00:54:07,345 --> 00:54:08,970
有答案，但我們做到了。

1121
00:54:08,970 --> 00:54:10,324

1122
00:54:10,324 --> 00:54:11,115
指針運算。

1123
00:54:11,115 --> 00:54:13,961

1124
00:54:13,961 --> 00:54:14,460
啊。

1125
00:54:14,460 --> 00:54:15,510
我的手都白堊。

1126
00:54:15,510 --> 00:54:17,970
因此增加或減少
INT調整指針

1127
00:54:17,970 --> 00:54:21,890
通過指針的類型的大小。

1128
00:54:21,890 --> 00:54:22,940

1129
00:54:22,940 --> 00:54:28,390
還記得每一個類型
具有不同的大小？

1130
00:54:28,390 --> 00:54:34,890
因此，像一張雙人床或很長很長就是
八int是4，但焦炭之一。

1131
00:54:34,890 --> 00:54:38,360
>> 所以，你想要做什麼
is--有一點要記住

1132
00:54:38,360 --> 00:54:44,080
就是這樣自己多
指針值實際上改變

1133
00:54:44,080 --> 00:54:46,550
將依賴於
指針的類型是。

1134
00:54:46,550 --> 00:54:50,820

1135
00:54:50,820 --> 00:54:51,820
每個人都好這個？

1136
00:54:51,820 --> 00:54:52,760
我可以刪除嗎？

1137
00:54:52,760 --> 00:54:53,440
我們是好？

1138
00:54:53,440 --> 00:54:53,940
真棒。

1139
00:54:53,940 --> 00:55:01,020

1140
00:55:01,020 --> 00:55:07,501
>> 所以，如果我們有一些指針
that--這是要be--我

1141
00:55:07,501 --> 00:55:08,834
要使它為int的指針。

1142
00:55:08,834 --> 00:55:10,610

1143
00:55:10,610 --> 00:55:12,760
它存儲了這一點。

1144
00:55:12,760 --> 00:55:14,210

1145
00:55:14,210 --> 00:55:20,170
如果你說的指針
加一，它會做

1146
00:55:20,170 --> 00:55:23,420
是它要更新
它由一個int的大小

1147
00:55:23,420 --> 00:55:25,950
因為這是
指針的類型是。

1148
00:55:25,950 --> 00:55:28,260
>> 與C，一切都是
非常嚴格，規範。

1149
00:55:28,260 --> 00:55:29,440

1150
00:55:29,440 --> 00:55:35,260
整型指針會被更新
空間的int會走量。

1151
00:55:35,260 --> 00:55:36,260
一個int是4個字節。

1152
00:55:36,260 --> 00:55:37,650

1153
00:55:37,650 --> 00:55:39,060
>> 那麼，這會變成？

1154
00:55:39,060 --> 00:55:40,876

1155
00:55:40,876 --> 00:55:44,390
你只需添加4到這一點。

1156
00:55:44,390 --> 00:55:50,040
現在，鼠標指針會be--確定。

1157
00:55:50,040 --> 00:55:51,820

1158
00:55:51,820 --> 00:55:55,380
>> 所以，如果它是一個字符，我們做了指針
加一，那會是什麼呢？

1159
00:55:55,380 --> 00:56:00,300

1160
00:56:00,300 --> 00:56:03,330
如果started--假裝我們
started--現在它0x08的。

1161
00:56:03,330 --> 00:56:04,850

1162
00:56:04,850 --> 00:56:10,850
現在，讓我們說這是一個
字符指針，我們增加了一個。

1163
00:56:10,850 --> 00:56:11,850
會是什麼改變？

1164
00:56:11,850 --> 00:56:14,989

1165
00:56:14,989 --> 00:56:16,030
多少個字節是一個字符？

1166
00:56:16,030 --> 00:56:16,680
>> 聽眾：一。

1167
00:56:16,680 --> 00:56:17,304
>> 揚聲器1：一。

1168
00:56:17,304 --> 00:56:18,309
聽眾：那麼0×09。

1169
00:56:18,309 --> 00:56:19,600
揚聲器1：那麼這將是9。

1170
00:56:19,600 --> 00:56:22,571

1171
00:56:22,571 --> 00:56:23,820
所以，只是要記住。

1172
00:56:23,820 --> 00:56:28,340
只是當你添加一個，它不是
增加一個，除非它是一個字符。

1173
00:56:28,340 --> 00:56:34,190
它增加多少
字節，它是類型，

1174
00:56:34,190 --> 00:56:36,960
這就是為什麼我們有
這個等式在這裡。

1175
00:56:36,960 --> 00:56:40,190
所以它的整數倍大
指針的類型。

1176
00:56:40,190 --> 00:56:42,850

1177
00:56:42,850 --> 00:56:44,730
>> 所以我們這裡的例子。

1178
00:56:44,730 --> 00:56:47,250

1179
00:56:47,250 --> 00:56:54,430
y為分配給該值，為0x4，
當我們做y加等於一。

1180
00:56:54,430 --> 00:56:56,830
是什麼在這，什麼是
x中，不改變。

1181
00:56:56,830 --> 00:56:58,610
是什麼改變是什麼y中。

1182
00:56:58,610 --> 00:57:04,980
存儲在Y中的地址更新的四
因為有四個字節的整數

1183
00:57:04,980 --> 00:57:06,097
它是一個int指針。

1184
00:57:06,097 --> 00:57:07,290

1185
00:57:07,290 --> 00:57:07,790
>> 行。

1186
00:57:07,790 --> 00:57:09,123
所以現在我們有另一個練習。

1187
00:57:09,123 --> 00:57:11,140

1188
00:57:11,140 --> 00:57:13,500
所以，問題是怎樣將打印。

1189
00:57:13,500 --> 00:57:36,710

1190
00:57:36,710 --> 00:57:37,650
任何想法？

1191
00:57:37,650 --> 00:57:41,690

1192
00:57:41,690 --> 00:57:43,699
>> 聽眾：數
在快樂的貓字符？

1193
00:57:43,699 --> 00:57:44,490
揚聲器1：沒錯。

1194
00:57:44,490 --> 00:57:45,531
所以想用你的字符串。

1195
00:57:45,531 --> 00:57:47,302

1196
00:57:47,302 --> 00:57:48,260
大家都明白了嗎？

1197
00:57:48,260 --> 00:57:49,509
我們希望通過它走？

1198
00:57:49,509 --> 00:57:50,300

1199
00:57:50,300 --> 00:57:52,010
>> 是的，確定。

1200
00:57:52,010 --> 00:57:57,385
所以，我們這裡 - 我
像這樣這麼多。

1201
00:57:57,385 --> 00:57:59,340
我不必
[聽不清]可笑。

1202
00:57:59,340 --> 00:58:01,690
>> 因此，我們有我們的字符串在這裡，快樂的貓。

1203
00:58:01,690 --> 00:58:02,950
可愛的。

1204
00:58:02,950 --> 00:58:05,080
我們有一些計數器
我們跟踪的。

1205
00:58:05,080 --> 00:58:11,430
因此，我們有一些的char *指針
剛剛被設定為等於為str。

1206
00:58:11,430 --> 00:58:14,320
這是什麼做的是它的
分配一些指針

1207
00:58:14,320 --> 00:58:16,380
給您的字符串的開頭。

1208
00:58:16,380 --> 00:58:19,840
因為我敢肯定，因為它
提到在講座中，

1209
00:58:19,840 --> 00:58:22,290
我們已經給了你們這
所謂的字符串數據類型。

1210
00:58:22,290 --> 00:58:29,070
>> 但真正的字符串只是
數組of--喜歡的char *。

1211
00:58:29,070 --> 00:58:32,330
這是一個指向一串字符
這是連續的內存中。

1212
00:58:32,330 --> 00:58:33,680

1213
00:58:33,680 --> 00:58:36,280
因此，這只是設置它
等於任何字符串

1214
00:58:36,280 --> 00:58:38,980
確定在哪裡
它的第一個字符是。

1215
00:58:38,980 --> 00:58:42,710
所以這只是設置一些點
等於該字符串的開頭。

1216
00:58:42,710 --> 00:58:44,130
每個人都很好嗎？

1217
00:58:44,130 --> 00:58:44,960
涼爽。

1218
00:58:44,960 --> 00:58:49,840
>> 因此，這是我們的提領的指針。

1219
00:58:49,840 --> 00:58:53,760
因此，它實際上會
給我們一些價值在這裡，

1220
00:58:53,760 --> 00:58:55,610
在我們的字符串，我們正在談論的。

1221
00:58:55,610 --> 00:58:58,342
和我們說，只要
它不是空終止。

1222
00:58:58,342 --> 00:59:00,550
因此，繼續下去，直到你得到
到字符串的末尾。

1223
00:59:00,550 --> 00:59:02,180

1224
00:59:02,180 --> 00:59:04,190
一個更新的指針。

1225
00:59:04,190 --> 00:59:09,250
以r，它實際上由一個更新
每一次，因為這是一個char，

1226
00:59:09,250 --> 00:59:09,820
將char *。

1227
00:59:09,820 --> 00:59:10,930

1228
00:59:10,930 --> 00:59:12,340
>> 因此，它會去。

1229
00:59:12,340 --> 00:59:13,290
這將更新。

1230
00:59:13,290 --> 00:59:16,705
因此，首次運行時，
這將是在這裡小時。

1231
00:59:16,705 --> 00:59:17,590
這將更新。

1232
00:59:17,590 --> 00:59:18,185
>> 這將是一個。

1233
00:59:18,185 --> 00:59:21,310
這將是一個P，Y，等等等等。

1234
00:59:21,310 --> 00:59:22,300
我們將更新計數器。

1235
00:59:22,300 --> 00:59:26,160
當到達結束時，它
只是打印多遠它得到。

1236
00:59:26,160 --> 00:59:27,550

1237
00:59:27,550 --> 00:59:28,050
是。

1238
00:59:28,050 --> 00:59:31,475
>> 聽眾：所以它統計
空間為一體，對不對？

1239
00:59:31,475 --> 00:59:31,974
行。

1240
00:59:31,974 --> 00:59:34,294

1241
00:59:34,294 --> 00:59:35,222
>> 揚聲器1：這樣認為。

1242
00:59:35,222 --> 00:59:36,830
那是一個question--

1243
00:59:36,830 --> 00:59:37,746
>> 聽眾：[聽不清]。

1244
00:59:37,746 --> 00:59:37,968

1245
00:59:37,968 --> 00:59:38,884
>> 揚聲器1：不用擔心。

1246
00:59:38,884 --> 00:59:39,720

1247
00:59:39,720 --> 00:59:42,736
這是我做的。

1248
00:59:42,736 --> 00:59:47,710
好吧，這麼一件事我
不解的是，有一個數組，

1249
00:59:47,710 --> 00:59:51,736
你也可以把它當作一個
因為指針數組只是

1250
00:59:51,736 --> 00:59:52,860
的存儲器連續斑點。

1251
00:59:52,860 --> 00:59:53,970

1252
00:59:53,970 --> 00:59:56,380
>> 所以，你可以把它以同樣的方式。

1253
00:59:56,380 --> 00:59:59,000
你可以操縱他們
用指針了。

1254
00:59:59,000 --> 01:00:04,770
這樣做時，而不是在本
情況下，類似的東西

1255
01:00:04,770 --> 01:00:07,490
將數組0等於1。

1256
01:00:07,490 --> 01:00:08,760

1257
01:00:08,760 --> 01:00:15,210
>> 但是在以同樣的方式
一個字符串確定

1258
01:00:15,210 --> 01:00:18,740
通過在何處開始
它的第一個字符是，

1259
01:00:18,740 --> 01:00:22,270
陣列由下式確定
其中，它的第一個元素是。

1260
01:00:22,270 --> 01:00:25,120
因為我們知道，我們是
保證的是，這些

1261
01:00:25,120 --> 01:00:27,985
將要連續
的存儲器塊。

1262
01:00:27,985 --> 01:00:29,360
這就是使我們能夠做到這一點。

1263
01:00:29,360 --> 01:00:31,193
我們知道他們是連續的
的存儲器塊。

1264
01:00:31,193 --> 01:00:32,230

1265
01:00:32,230 --> 01:00:36,500
>> 所以在這種情況下，通過解引用
只是數組，它告訴我們，

1266
01:00:36,500 --> 01:00:40,800
OK，去開始
您的陣列，這是在這裡。

1267
01:00:40,800 --> 01:00:42,640
所以，你可以將其設置等於一體。

1268
01:00:42,640 --> 01:00:48,610
在這種情況下，無論你的陣列
類型是，當你一更新，

1269
01:00:48,610 --> 01:00:50,830
這就像更新
它的下一個索引。

1270
01:00:50,830 --> 01:00:52,760

1271
01:00:52,760 --> 01:00:56,360
你可以這樣做，因為你
知道什麼是您的陣列中。

1272
01:00:56,360 --> 01:00:59,770
所以它知道多少
通過更新您的指針，

1273
01:00:59,770 --> 01:01:02,925
什麼地址以更新其為這樣
你是下一個插槽。

1274
01:01:02,925 --> 01:01:04,740

1275
01:01:04,740 --> 01:01:09,400
>> 所以這只是一種不同的方式
寫作陣列0等於1，

1276
01:01:09,400 --> 01:01:15,114
陣列1等於2，陣列
支架2等於3。

1277
01:01:15,114 --> 01:01:16,780
這只是另一種方式去思考它。

1278
01:01:16,780 --> 01:01:19,600
因為它們是連續的
在內存塊，

1279
01:01:19,600 --> 01:01:21,830
你可以參考他們要么
通過notation--陣列

1280
01:01:21,830 --> 01:01:24,390
我個人
找到easier--但也許

1281
01:01:24,390 --> 01:01:27,347
你需要對其進行操作
嚴格的內存地址。

1282
01:01:27,347 --> 01:01:28,930
這是你會做的方式。

1283
01:01:28,930 --> 01:01:30,630

1284
01:01:30,630 --> 01:01:32,630
那種比較像一個
很酷的事情你可以做

1285
01:01:32,630 --> 01:01:35,213
對，也許不是你
究竟要執行。

1286
01:01:35,213 --> 01:01:36,960

1287
01:01:36,960 --> 01:01:38,630
>> 我在61中使用它。

1288
01:01:38,630 --> 01:01:41,710
你們也許並不需要
不用擔心太多。

1289
01:01:41,710 --> 01:01:43,693
但是，如果你有興趣，
取61來年。

1290
01:01:43,693 --> 01:01:45,269

1291
01:01:45,269 --> 01:01:46,560
我們在家裡舒展的傢伙。

1292
01:01:46,560 --> 01:01:47,510
我知道，這是很長。

1293
01:01:47,510 --> 01:01:50,570

1294
01:01:50,570 --> 01:01:58,880
動態內存Allocation--
所以我們知道，一個

1295
01:01:58,880 --> 01:02:01,790
事情過程中，當我們談到
我們的第一款一起，

1296
01:02:01,790 --> 01:02:04,560
我們看一個交換
功能它是

1297
01:02:04,560 --> 01:02:08,010
外我們的主要功能範圍。

1298
01:02:08,010 --> 01:02:14,370
和我們傳遞這些價值
這是有效的副本。

1299
01:02:14,370 --> 01:02:20,570
>> 而一旦交換完成
執行時，它只是留下了一個堆棧。

1300
01:02:20,570 --> 01:02:22,830
請記住，我們有一個
堆棧幀的交換。

1301
01:02:22,830 --> 01:02:26,070
它的葉子和那些
數值離開它。

1302
01:02:26,070 --> 01:02:27,050
他們都走了。

1303
01:02:27,050 --> 01:02:28,615
我們不能做任何事情
他們和我們是悲哀

1304
01:02:28,615 --> 01:02:29,989
因為我們不能交換我們的價值觀。

1305
01:02:29,989 --> 01:02:31,070

1306
01:02:31,070 --> 01:02:36,560
>> 但隨著C，正如我所說，你
有很多的力量在內存中。

1307
01:02:36,560 --> 01:02:43,310
所以，你可以做的是，你可以
分配在堆上的東西在這裡

1308
01:02:43,310 --> 01:02:46,830
將呆在那裡，直到
你告訴他們，否則。

1309
01:02:46,830 --> 01:02:48,280
>> 他們就像好兒女。

1310
01:02:48,280 --> 01:02:49,150
他們呆在那裡。

1311
01:02:49,150 --> 01:02:50,270
他們不離開。

1312
01:02:50,270 --> 01:02:52,750
他們將呆在那裡，直到你
就像，OK，你可以走開。

1313
01:02:52,750 --> 01:02:55,920
>> 而在堆棧上的東西，who--
他們就像頑皮的孩子。

1314
01:02:55,920 --> 01:02:59,160
他們只會逃跑，當你想
在那裡，然後他們走了。

1315
01:02:59,160 --> 01:03:00,160
你不能讓他們回來。

1316
01:03:00,160 --> 01:03:01,350

1317
01:03:01,350 --> 01:03:07,187
>> 所以is--我們要堆
談談malloc和free，這

1318
01:03:07,187 --> 01:03:08,895
我敢肯定你們
聽說了講座。

1319
01:03:08,895 --> 01:03:10,270

1320
01:03:10,270 --> 01:03:14,210
而這基本上是一個辦法
有很執著的數據。

1321
01:03:14,210 --> 01:03:18,920
這樣你就可以保持數據
各地，只要你想要的。

1322
01:03:18,920 --> 01:03:19,546
MHM。

1323
01:03:19,546 --> 01:03:21,475
>> 聽眾：您可以定義堆和棧？

1324
01:03:21,475 --> 01:03:24,030
是他們喜歡的地方放東西？

1325
01:03:24,030 --> 01:03:26,630
>> 揚聲器1：因此，他們
基本上just--他們

1326
01:03:26,630 --> 01:03:29,530
我們指的只是內存的方式。

1327
01:03:29,530 --> 01:03:37,300
所以堆只是地方
存儲器是動態分配的，

1328
01:03:37,300 --> 01:03:40,960
而堆棧指
更多的堆棧幀

1329
01:03:40,960 --> 01:03:45,950
這是更核心的
這是實際運行的功能。

1330
01:03:45,950 --> 01:03:47,200
你真的沒有控制權。

1331
01:03:47,200 --> 01:03:50,690
>> 最大的區別，你必須控制
在堆，如果你想。

1332
01:03:50,690 --> 01:03:52,710
你有過協議棧的控制較少。

1333
01:03:52,710 --> 01:03:55,030
堆棧取決於
功能正在運行，

1334
01:03:55,030 --> 01:03:58,320
和順序，其中它們
運行，以及事情是如何返回。

1335
01:03:58,320 --> 01:04:01,290
而隨著堆，為
我們會看到，你可以說，

1336
01:04:01,290 --> 01:04:06,639
好吧，我想這個值是
各地，直到我告訴你，否則。

1337
01:04:06,639 --> 01:04:08,180
你不准擺脫它。

1338
01:04:08,180 --> 01:04:09,300
你不能覆蓋它。

1339
01:04:09,300 --> 01:04:11,675
你要保持它的周圍
只要我告訴你。

1340
01:04:11,675 --> 01:04:15,780
你是老闆堆中，
而stack--也許，如果你

1341
01:04:15,780 --> 01:04:18,080
像finagle你的方式
你可以成為老闆。

1342
01:04:18,080 --> 01:04:19,340
但並不完全。

1343
01:04:19,340 --> 01:04:20,480

1344
01:04:20,480 --> 01:04:22,070
這真的只是存儲器。

1345
01:04:22,070 --> 01:04:24,260
這只是不同的方式
的參考存儲器。

1346
01:04:24,260 --> 01:04:25,800

1347
01:04:25,800 --> 01:04:26,400
>> 涼爽。

1348
01:04:26,400 --> 01:04:28,630
因此，與那，怎麼
控制你的記憶。

1349
01:04:28,630 --> 01:04:32,070
這是使用malloc，這
你會去用。

1350
01:04:32,070 --> 01:04:37,100
因此，這只是短期
內存分配。

1351
01:04:37,100 --> 01:04:38,459
這就是它。

1352
01:04:38,459 --> 01:04:41,250
還有一堆其他很酷的
功能有頁頭底，

1353
01:04:41,250 --> 01:04:42,750
他們代表不同的東西。

1354
01:04:42,750 --> 01:04:43,550

1355
01:04:43,550 --> 01:04:49,050
>> 所以，當你需要的存儲需要
拖垮你的當前功能，使

1356
01:04:49,050 --> 01:04:51,010
當你的當前
功能跑掉，

1357
01:04:51,010 --> 01:04:55,774
你仍然有數據，你
從中得到的，你要使用的malloc。

1358
01:04:55,774 --> 01:04:57,190
這將初始化它在堆上。

1359
01:04:57,190 --> 01:05:00,140
就像我說的，守
他說，你會繼續在那裡

1360
01:05:00,140 --> 01:05:03,050
直到你告訴它，否則，
這是這裡最重要的事情。

1361
01:05:03,050 --> 01:05:08,450
>> 所以，有一點要注意，和
這是典型的非常重要的，

1362
01:05:08,450 --> 01:05:13,620
的是，這和sizeof
就是用超級有用

1363
01:05:13,620 --> 01:05:16,440
因為根據其種類
機器你正在運行，

1364
01:05:16,440 --> 01:05:22,470
它可以具有不同的量
內存，它需要。

1365
01:05:22,470 --> 01:05:26,870
所以，你總是希望用這樣的尺寸
你不是依賴於機器，

1366
01:05:26,870 --> 01:05:30,300
讓你的代碼
運行在任何機器上。

1367
01:05:30,300 --> 01:05:32,360
>> 而這只是其中的一部分
編寫好的代碼。

1368
01:05:32,360 --> 01:05:34,610
如果它可以在一台機器上，
但不是任何其他人，

1369
01:05:34,610 --> 01:05:36,440
多麼有用是你的計劃嗎？

1370
01:05:36,440 --> 01:05:38,420
所以，你總是希望
確保並用sizeof運算。

1371
01:05:38,420 --> 01:05:41,306
>> 聽眾：那就是像
10英寸[聽不清]大小？

1372
01:05:41,306 --> 01:05:43,698
>> 揚聲器1：這是由10個整數的大小。

1373
01:05:43,698 --> 01:05:44,197
是啊。

1374
01:05:44,197 --> 01:05:45,360

1375
01:05:45,360 --> 01:05:48,830
所以，整數的大小將返回
多少錢1取整數。

1376
01:05:48,830 --> 01:05:51,530
或字符的大小，如何
做多一個字符起飛。

1377
01:05:51,530 --> 01:05:54,150
然後多少塊
那你想要什麼？

1378
01:05:54,150 --> 01:05:57,590
>> 所以在這種情況下，我們想要的東西
我們可以存儲10個整數來。

1379
01:05:57,590 --> 01:06:00,240
它會不顧工作
機，這是很酷。

1380
01:06:00,240 --> 01:06:01,720

1381
01:06:01,720 --> 01:06:04,846
那麼有多少字節將
這實際上給你嗎？

1382
01:06:04,846 --> 01:06:06,190
快速數學運算。

1383
01:06:06,190 --> 01:06:06,787
>> 聽眾：40。

1384
01:06:06,787 --> 01:06:07,370
揚聲器1：40。

1385
01:06:07,370 --> 01:06:07,869
沒錯。

1386
01:06:07,869 --> 01:06:09,520

1387
01:06:09,520 --> 01:06:12,030
所以，再大的事情。

1388
01:06:12,030 --> 01:06:14,840
指針或內存分配可以返回null。

1389
01:06:14,840 --> 01:06:17,910
>> 如此反复，經常檢查，
看它是否返回null

1390
01:06:17,910 --> 01:06:19,620
之前你嘗試做任何事情吧。

1391
01:06:19,620 --> 01:06:23,430

1392
01:06:23,430 --> 01:06:27,350
如果您嘗試取消引用
這個指針現在，

1393
01:06:27,350 --> 01:06:29,720
它只是將段錯誤
因為你去，並試圖

1394
01:06:29,720 --> 01:06:31,730
觸摸空的時候，你不應該有。

1395
01:06:31,730 --> 01:06:34,000
因此，經常檢查空。

1396
01:06:34,000 --> 01:06:36,075
同樣，你所能做的。

1397
01:06:36,075 --> 01:06:38,300

1398
01:06:38,300 --> 01:06:39,720
>> 它可能返回null。

1399
01:06:39,720 --> 01:06:42,740
如果你要么它會返回null
出的空間，或者因任何原因

1400
01:06:42,740 --> 01:06:44,350
它遇到了一些內存錯誤。

1401
01:06:44,350 --> 01:06:45,890

1402
01:06:45,890 --> 01:06:47,510
它有時只是返回null。

1403
01:06:47,510 --> 01:06:48,990
所以，你只需要檢查它。

1404
01:06:48,990 --> 01:06:51,050
這就是這張幻燈片是說。

1405
01:06:51,050 --> 01:06:53,366

1406
01:06:53,366 --> 01:06:55,240
然後，我們所擁有的
這裡是一個調用free。

1407
01:06:55,240 --> 01:07:00,550
所以用同樣的方式，如果
打開一個文件，你必須關閉文件，

1408
01:07:00,550 --> 01:07:04,340
如果你的malloc內存，
你必須釋放內存。

1409
01:07:04,340 --> 01:07:06,530
而你們將得到
做很酷的東西。

1410
01:07:06,530 --> 01:07:09,624
>> 並有一個程序，你可以運行
看看你曾經洩漏內存。

1411
01:07:09,624 --> 01:07:11,040
但你不希望出現內存洩漏。

1412
01:07:11,040 --> 01:07:11,820
這是非常糟糕的。

1413
01:07:11,820 --> 01:07:13,191

1414
01:07:13,191 --> 01:07:15,020
剛剛陷入困境的事情。

1415
01:07:15,020 --> 01:07:20,939
>> 這是不好做，就像編程
明智的設計效率。

1416
01:07:20,939 --> 01:07:22,980
但它也只是一種
壞了你的電腦。

1417
01:07:22,980 --> 01:07:26,780
所以只是免費的東西
當你的malloc他們。

1418
01:07:26,780 --> 01:07:28,190

1419
01:07:28,190 --> 01:07:30,210
>> 你們看到的對稱性在這裡。

1420
01:07:30,210 --> 01:07:31,180
超級簡單。

1421
01:07:31,180 --> 01:07:33,010
只是免費的，然後
無論你的指針，

1422
01:07:33,010 --> 01:07:34,843
無論名稱
你的指針，它

1423
01:07:34,843 --> 01:07:36,710
將釋放它給你的照顧。

1424
01:07:36,710 --> 01:07:38,200

1425
01:07:38,200 --> 01:07:38,700
涼爽。

1426
01:07:38,700 --> 01:07:40,410

1427
01:07:40,410 --> 01:07:42,530
>> 然後，我們有這個。

1428
01:07:42,530 --> 01:07:44,770
因此，我們只是要
走過這個程序。

1429
01:07:44,770 --> 01:07:46,560
然後你們就完成了。

1430
01:07:46,560 --> 01:07:50,240
>> 所以[聽不清]剛為主。

1431
01:07:50,240 --> 01:07:51,690
因此，我們有一些為int *指針。

1432
01:07:51,690 --> 01:07:53,648
因此，我們有一個指針
這是怎麼回事舉行整數。

1433
01:07:53,648 --> 01:07:54,500

1434
01:07:54,500 --> 01:07:56,170
又有多少個整數是打算舉行？

1435
01:07:56,170 --> 01:07:57,400

1436
01:07:57,400 --> 01:07:58,170
只有一個。

1437
01:07:58,170 --> 01:07:59,400

1438
01:07:59,400 --> 01:08:01,100
大小int的。

1439
01:08:01,100 --> 01:08:03,900
>> 我們檢查，看
指針是空的，因為它

1440
01:08:03,900 --> 01:08:06,130
是，我們想說什麼也不做。

1441
01:08:06,130 --> 01:08:07,065
這是不好的。

1442
01:08:07,065 --> 01:08:08,130

1443
01:08:08,130 --> 01:08:12,130
因此，我們打印了一些錯誤出
存儲器，最多返回1，

1444
01:08:12,130 --> 01:08:14,260
因為你們都習慣了。

1445
01:08:14,260 --> 01:08:17,390
>> 然後，我們在這裡，我們
我們取消引用指針。

1446
01:08:17,390 --> 01:08:22,840
因此，這意味著我們將要存儲
什麼在給我們的位置。

1447
01:08:22,840 --> 01:08:24,350

1448
01:08:24,350 --> 01:08:30,830
為int *指針，或者malloc的，返回
它拋開這個地址

1449
01:08:30,830 --> 01:08:31,750
內存給你。

1450
01:08:31,750 --> 01:08:32,830

1451
01:08:32,830 --> 01:08:34,800
因此，它基本上
給你like--，如果你

1452
01:08:34,800 --> 01:08:38,149
想想一堆
房子在附近

1453
01:08:38,149 --> 01:08:40,640
要放
你的家具，malloc的

1454
01:08:40,640 --> 01:08:43,850
就像是OK，你得到
去容納三人。

1455
01:08:43,850 --> 01:08:45,800
和它給你的
房子3的地址。

1456
01:08:45,800 --> 01:08:48,775
>> 所以，現在這個權利，這
指針存儲地址，

1457
01:08:48,775 --> 01:08:50,149
存儲你的房子的地址。

1458
01:08:50,149 --> 01:08:51,470

1459
01:08:51,470 --> 01:08:54,640
* PTR手段，OK，我在我家。

1460
01:08:54,640 --> 01:08:55,326
涼爽。

1461
01:08:55,326 --> 01:08:56,580
我需要得到一些整數。

1462
01:08:56,580 --> 01:08:59,229
>> 所以，你問的人
現在給你的家具。

1463
01:08:59,229 --> 01:09:00,430
所以，你得到一些int類型。

1464
01:09:00,430 --> 01:09:05,100
它把它在你的指針
它的指向。

1465
01:09:05,100 --> 01:09:08,670
>> 然後它只是打印
出來，你只要進入。

1466
01:09:08,670 --> 01:09:11,060
並且再次，參考。

1467
01:09:11,060 --> 01:09:15,649
所以，這就像你去這個
針對你所看到的在那裡。

1468
01:09:15,649 --> 01:09:17,120

1469
01:09:17,120 --> 01:09:17,630
很酷吧？

1470
01:09:17,630 --> 01:09:20,174
>> 然後，當然，我們釋放了指針。

1471
01:09:20,174 --> 01:09:21,590
不要忘了釋放你的指針。

1472
01:09:21,590 --> 01:09:22,933
不要忘了檢查空。

1473
01:09:22,933 --> 01:09:24,349
不要忘了釋放你的指針。

1474
01:09:24,349 --> 01:09:27,270
你有兩件事情你還記得
這一點，或者說你應該記住。

1475
01:09:27,270 --> 01:09:27,770
是。

1476
01:09:27,770 --> 01:09:31,590
聽眾：[聽不清]東東
這樣，該字符* S。

1477
01:09:31,590 --> 01:09:33,760
為什麼我們從來沒有免費的？

1478
01:09:33,760 --> 01:09:34,529
>> 揚聲器1：嗯？

1479
01:09:34,529 --> 01:09:36,450
>> 聽眾：是那些像琴弦？

1480
01:09:36,450 --> 01:09:39,160
你說的字符串
就像字符* S，對不對？

1481
01:09:39,160 --> 01:09:41,200
那麼，為什麼我們不自由的字符串？

1482
01:09:41,200 --> 01:09:43,204
>> 揚聲器1：您只
免費的，如果你mallocing。

1483
01:09:43,204 --> 01:09:44,620
聽眾：哦，如果你mallocing。

1484
01:09:44,620 --> 01:09:47,399
揚聲器1：所以的malloc
自由是兩回事

1485
01:09:47,399 --> 01:09:49,000
你應該總是在一起。

1486
01:09:49,000 --> 01:09:51,630
f開，女接近，兩件事情
你應該在一起。

1487
01:09:51,630 --> 01:09:54,471
在這兩個情況下，檢查空。

1488
01:09:54,471 --> 01:09:54,971
是。

1489
01:09:54,971 --> 01:09:57,130
>> 聽眾：那麼自由就是
讓別的東西

1490
01:09:57,130 --> 01:09:59,690
之後被存儲在那裡
這個方案使用了嗎？

1491
01:09:59,690 --> 01:10:01,946
>> 揚聲器1：這只是說，
好吧，我做了這個。

1492
01:10:01,946 --> 01:10:03,320
你並不需要保持它周圍。

1493
01:10:03,320 --> 01:10:05,340

1494
01:10:05,340 --> 01:10:08,190
否則，您的計算機將
只是喜歡嘗試，並保持它在那裡。

1495
01:10:08,190 --> 01:10:10,910
然後你can't--運行
到後來內存問題。

1496
01:10:10,910 --> 01:10:13,660
你總是想釋放它，因為
它告訴你的電腦，OK，我

1497
01:10:13,660 --> 01:10:15,190
隨著內存這個地方完成的。

1498
01:10:15,190 --> 01:10:17,190
你可以把它背
我以後使用。

1499
01:10:17,190 --> 01:10:19,250

1500
01:10:19,250 --> 01:10:20,500
很酷吧？

1501
01:10:20,500 --> 01:10:21,320
是。

1502
01:10:21,320 --> 01:10:26,950
>> 聽眾：所以我們使用了％D剛剛
因為兩倍的回來了，

1503
01:10:26,950 --> 01:10:28,330
為什麼is-- [聽不清]。

1504
01:10:28,330 --> 01:10:30,170

1505
01:10:30,170 --> 01:10:31,620
>> 聽眾：您可以使用％嗎？

1506
01:10:31,620 --> 01:10:32,760
>> 揚聲器1：您可以使用％我。

1507
01:10:32,760 --> 01:10:35,052

1508
01:10:35,052 --> 01:10:36,135
在最後一分鐘的問題嗎？

1509
01:10:36,135 --> 01:10:38,310

1510
01:10:38,310 --> 01:10:38,985
前進。

1511
01:10:38,985 --> 01:10:40,610
觀眾：我只是有一個快速的問題。

1512
01:10:40,610 --> 01:10:50,200
所以PTR變量，that's--
像，用INT * PTR = malloc的，

1513
01:10:50,200 --> 01:10:54,142
這只是說這是
指著memory--的地方

1514
01:10:54,142 --> 01:10:55,600
揚聲器1：你想[聽不清]？

1515
01:10:55,600 --> 01:10:58,050
聽眾：--that是的
大小of--沒有，沒關係。

1516
01:10:58,050 --> 01:11:01,292
但它只是指向一個地方
內存就像四個字節。

1517
01:11:01,292 --> 01:11:02,000
揚聲器1：沒錯。

1518
01:11:02,000 --> 01:11:03,030

1519
01:11:03,030 --> 01:11:07,070
所以malloc的大小INT說，
好吧，我會去跑了出去，

1520
01:11:07,070 --> 01:11:08,780
發現四個字節的內存為您服務。

1521
01:11:08,780 --> 01:11:10,700
當它發現4
字節的內存，它

1522
01:11:10,700 --> 01:11:14,030
給你回的地址
在那裡開始的，

1523
01:11:14,030 --> 01:11:16,160
這就是存儲
在指針或PTR。

1524
01:11:16,160 --> 01:11:17,510

1525
01:11:17,510 --> 01:11:18,010
不錯。

1526
01:11:18,010 --> 01:11:18,742

1527
01:11:18,742 --> 01:11:21,700
你們看比大多數少困惑
當我談到指針的人，

1528
01:11:21,700 --> 01:11:23,670
所以我感覺很不錯了。

1529
01:11:23,670 --> 01:11:24,520
>> 行。

1530
01:11:24,520 --> 01:11:27,960
與往常一樣，你們應該都
現在得到您的pset2成績。

1531
01:11:27,960 --> 01:11:32,769
我知道發生了一些靠不住的
東西在那裡說，公式無效

1532
01:11:32,769 --> 01:11:33,310
什麼的。

1533
01:11:33,310 --> 01:11:36,166
如果你得到的是，所有的
你的成績都在我的身邊有效。

1534
01:11:36,166 --> 01:11:38,040
所以，我可以送你
你的成績截圖。

1535
01:11:38,040 --> 01:11:39,011

1536
01:11:39,011 --> 01:11:41,760
只是讓我知道，如果你還有
缺少任何等級或某事

1537
01:11:41,760 --> 01:11:43,060
似乎沒有什麼意義。

1538
01:11:43,060 --> 01:11:43,720
到我這裡來。

1539
01:11:43,720 --> 01:11:44,830

1540
01:11:44,830 --> 01:11:48,830
>> 我一直引以為傲的超你
球員了，所以繼續努力吧。

1541
01:11:48,830 --> 01:11:50,640
和你的週末好好休息一下。

1542
01:11:50,640 --> 01:11:53,440
我敢肯定，我會看到一些
你在上班時間。

1543
01:11:53,440 --> 01:11:55,414