1
00:00:00,000 --> 00:00:06,180

2
00:00:06,180 --> 00:00:07,820
>> JASON HIRSCHHORN：歡迎
到A5，大家好。

3
00:00:07,820 --> 00:00:11,270
我們有一個令人興奮的一周擺在我們面前，
主要是因為有這麼多新

4
00:00:11,270 --> 00:00:12,350
面臨著在這個房間裡。

5
00:00:12,350 --> 00:00:12,920
這是美妙的。

6
00:00:12,920 --> 00:00:15,740
很多你在這裡意外，
這是更好的。

7
00:00:15,740 --> 00:00:18,220
所以希望你會繼續加入我們的行列。

8
00:00:18,220 --> 00:00:20,220
>> 本週我們將花
大頭的部分

9
00:00:20,220 --> 00:00:21,870
準備測驗。

10
00:00:21,870 --> 00:00:26,580
因此，根據我們的議程，我們要談
一點關於該類資源，

11
00:00:26,580 --> 00:00:30,350
而且對測驗，然後，再次
花大量類的說話

12
00:00:30,350 --> 00:00:31,390
有關的問題。

13
00:00:31,390 --> 00:00:33,900
一旦我們做了回答您的
的問題，或者如果您的問題

14
00:00:33,900 --> 00:00:39,010
自然使我們聯想到一些編碼，我
有從期中考試樣題

15
00:00:39,010 --> 00:00:43,180
過去，我們將在部分實時代碼
同時也帶來了一些其他的

16
00:00:43,180 --> 00:00:45,420
好的選題覆蓋。

17
00:00:45,420 --> 00:00:48,280
>> 因此，首先，因為我們已經經歷了
過去幾週來提醒你

18
00:00:48,280 --> 00:00:51,700
伙計們，有一噸的資源
提供此課程。

19
00:00:51,700 --> 00:00:55,020
他們中的許多將是難以置信的幫助
你為你繼續

20
00:00:55,020 --> 00:00:57,280
對於學習測驗0，因為
這是週二下午。

21
00:00:57,280 --> 00:00:59,630
因此，所有的你一直
研究了一下。

22
00:00:59,630 --> 00:01:02,640
>> 有講義和源
代碼，您應該

23
00:01:02,640 --> 00:01:04,050
一定要看看。

24
00:01:04,050 --> 00:01:05,019
觀看短褲。

25
00:01:05,019 --> 00:01:07,470
退房study.cs50.net。

26
00:01:07,470 --> 00:01:11,770
然後，在下面列出，一​​個數
的其他資源。

27
00:01:11,770 --> 00:01:14,020
>> 再次，測驗0就是明天
1點。

28
00:01:14,020 --> 00:01:18,230
如果你還沒有這樣做的話，請檢查
列於本公司測驗0文檔

29
00:01:18,230 --> 00:01:21,370
當然主頁搞清楚
在那裡你正在做測驗。

30
00:01:21,370 --> 00:01:25,770
測驗開始於1:10
端70分鐘後。

31
00:01:25,770 --> 00:01:29,610
所以，如果你1點10之後顯示出來，你是
會得到很多更少分鐘

32
00:01:29,610 --> 00:01:30,940
70比拿測驗。

33
00:01:30,940 --> 00:01:33,570
所以一定要確保你有時間。

34
00:01:33,570 --> 00:01:38,690
如果你是一個擴展學生或有
其他一些測試方面的考慮，它

35
00:01:38,690 --> 00:01:40,400
可能不會在明天1點。

36
00:01:40,400 --> 00:01:43,540
但同樣，檢查關於測驗0
記錄，以確保你知道什麼時候

37
00:01:43,540 --> 00:01:44,760
你服用的測驗。

38
00:01:44,760 --> 00:01:46,440
我寫75分鐘在這裡。

39
00:01:46,440 --> 00:01:48,580
我認為這是正確的，而不是70。

40
00:01:48,580 --> 00:01:53,420
>> 它涵蓋了所有的材料從一個星期0
在週三上週的演講。

41
00:01:53,420 --> 00:01:59,350
再次，這個測驗，即每
文件，你得到一個雙面和8

42
00:01:59,350 --> 00:02:03,770
1/2 11張紙上，你得到
測驗期間，作為筆記使用。

43
00:02:03,770 --> 00:02:08,570
很多人，如果不是大多數人來說，有
發現的一個最有用的方法

44
00:02:08,570 --> 00:02:11,970
以研究為競猜是
做一個研究表，

45
00:02:11,970 --> 00:02:13,730
1-Sider的自己。

46
00:02:13,730 --> 00:02:17,710
所以看過去的，如果
你看過過去的。

47
00:02:17,710 --> 00:02:19,960
接觸到的朋友，看看有什麼
他們穿上他們的。

48
00:02:19,960 --> 00:02:23,610
>> 但實際操作下來，最好的辦法，你可以
學習是要經過的一切，

49
00:02:23,610 --> 00:02:26,530
惠特爾下來到什麼應該或不應該
不屬於重要的是表

50
00:02:26,530 --> 00:02:30,570
紙，因為這只是一個非常
有用的方式為您確保

51
00:02:30,570 --> 00:02:33,620
你正在經歷的一切，
與它有一定的了解。

52
00:02:33,620 --> 00:02:36,690
大多數人來說，我們發現，即使它們
已在紙張右邊坐著

53
00:02:36,690 --> 00:02:39,840
在他們旁邊的測驗，不轉
它，因為，同樣的，這很

54
00:02:39,840 --> 00:02:43,290
在經歷了信息化進程
幫助他們學習。

55
00:02:43,290 --> 00:02:45,370
>> 沒有任何人有任何疑問，
有關測驗0？

56
00:02:45,370 --> 00:02:50,120

57
00:02:50,120 --> 00:02:51,450
有大家 - 

58
00:02:51,450 --> 00:02:53,230
我不會做舉手。

59
00:02:53,230 --> 00:02:53,550
沒關係。

60
00:02:53,550 --> 00:02:54,790
我正想問問誰
開始學習。

61
00:02:54,790 --> 00:02:58,360
但我不想讓你
所有不請舉手。

62
00:02:58,360 --> 00:03:01,290
所以，就像我說的 - 是的，AVI，勇往直前。

63
00:03:01,290 --> 00:03:04,205
>> AVI：什麼會是一個有用的東西
穿上一個尋呼機？

64
00:03:04,205 --> 00:03:05,875
>> 學生：這是給你的。

65
00:03:05,875 --> 00:03:08,210
>> JASON HIRSCHHORN：你得到
使用你的判斷。

66
00:03:08,210 --> 00:03:13,220
有用的東西要放在一個尋呼機，
如果你感到困惑的大O

67
00:03:13,220 --> 00:03:17,510
不同類型的搜索的運行時間
和排序，把那上有一個中

68
00:03:17,510 --> 00:03:18,760
方便的花花公子圖。

69
00:03:18,760 --> 00:03:22,250
這樣一來，如果你問的
小測驗，你不需要嘗試和數字

70
00:03:22,250 --> 00:03:23,560
它或理由通過運行時。

71
00:03:23,560 --> 00:03:24,730
你可以把它複製下來。

72
00:03:24,730 --> 00:03:28,320
如果你看看過去的測驗，很多
次，還有的運行時間問題。

73
00:03:28,320 --> 00:03:34,150
因此，這將是一個很好的一個例子
東西放在你的一個尋呼機。

74
00:03:34,150 --> 00:03:37,450
>> 其他好東西穿上，如果你
困惑如何聲明

75
00:03:37,450 --> 00:03:40,570
功能或什麼的不同部分
函數的聲明是，寫

76
00:03:40,570 --> 00:03:43,400
那在那裡，一個通用版本
然後也許一個例子。

77
00:03:43,400 --> 00:03:47,290
如果你感到困惑的指針，
如何指針工作是示

78
00:03:47,290 --> 00:03:48,660
大概真的很有幫助。

79
00:03:48,660 --> 00:03:52,440
如果你感到困惑遞歸，一個
樣本上有遞歸函數

80
00:03:52,440 --> 00:03:54,980
也可能被證明是真正有用的。

81
00:03:54,980 --> 00:03:57,290
這是否給你一些想法？

82
00:03:57,290 --> 00:04:01,820
>> AVI：你需要了解的
整個編譯過程，就像

83
00:04:01,820 --> 00:04:03,220
怎麼所有的作品？

84
00:04:03,220 --> 00:04:06,620
>> JASON HIRSCHHORN：一切
已經可以覆蓋

85
00:04:06,620 --> 00:04:08,060
顯示的測驗。

86
00:04:08,060 --> 00:04:08,930
問題 - 

87
00:04:08,930 --> 00:04:11,300
但同樣，有些事情會
權重比其他人。

88
00:04:11,300 --> 00:04:14,330
有些事情已經再次出現
並再次在課堂上，在

89
00:04:14,330 --> 00:04:15,590
講座，以及部分。

90
00:04:15,590 --> 00:04:17,220
其他的東西都沒有
想出經常。

91
00:04:17,220 --> 00:04:22,900
>> 我們已經談了很多關於＃include和
-L的東西，這些東西在的意思

92
00:04:22,900 --> 00:04:24,390
編譯過程。

93
00:04:24,390 --> 00:04:29,120
我們已經談了很多關於GDB，保鮮，
那些我們用不同的標誌時，

94
00:04:29,120 --> 00:04:33,100
我們編譯的東西，什麼
make15，例如，真正

95
00:04:33,100 --> 00:04:34,510
手段和確實。

96
00:04:34,510 --> 00:04:38,110
我們還沒有談論的很多關於
在每一個步驟

97
00:04:38,110 --> 00:04:39,240
編譯過程。

98
00:04:39,240 --> 00:04:40,410
我們仍然談論它。

99
00:04:40,410 --> 00:04:42,550
所以它仍然是東西，你
應該熟悉。

100
00:04:42,550 --> 00:04:44,610
但同樣，我們不會是 - 

101
00:04:44,610 --> 00:04:49,140
事情往往拿出在課堂上
更有可能想出更多

102
00:04:49,140 --> 00:04:52,495
常和更重
加權測驗。

103
00:04:52,495 --> 00:04:53,280
>> 涼爽。

104
00:04:53,280 --> 00:04:54,580
有關測驗0沒有其他問題？

105
00:04:54,580 --> 00:04:57,660

106
00:04:57,660 --> 00:05:00,050
>> 好了，我把名單
題目在黑板上。

107
00:05:00,050 --> 00:05:01,550
我通過教學大綱去了。

108
00:05:01,550 --> 00:05:07,340
我通過從審查部分去
昨晚那些幻燈片上來

109
00:05:07,340 --> 00:05:13,710
與主題的不完全清單
我們已經介紹了迄今為止在CS50

110
00:05:13,710 --> 00:05:16,800
而事情可能
出現在測驗。

111
00:05:16,800 --> 00:05:19,900
所以我不打算去通過
這些每一個。

112
00:05:19,900 --> 00:05:22,370
這將需要更多的
時間比我們現在有。

113
00:05:22,370 --> 00:05:26,880
但我要把這段話在這裡希望慢跑
你的內存，以事情，可能

114
00:05:26,880 --> 00:05:28,420
或可能不熟悉你。

115
00:05:28,420 --> 00:05:32,850
>> 而且我很樂意花大量的
部分回答你的問題有關

116
00:05:32,850 --> 00:05:35,130
這些題目，主題，
這裡不包括在內。

117
00:05:35,130 --> 00:05:36,130
我們可以寫偽代碼。

118
00:05:36,130 --> 00:05:40,010
我們可以編寫真正的代碼
以確保您 - 

119
00:05:40,010 --> 00:05:44,280
我可以回答你的問題，並幫助
每個人都從根本上理解

120
00:05:44,280 --> 00:05:48,330
很多這樣的主題讓你會覺得
準備和舒適進入

121
00:05:48,330 --> 00:05:50,150
測驗的明天。

122
00:05:50,150 --> 00:05:52,300
所以，在閱讀列表。

123
00:05:52,300 --> 00:05:54,780
希望你們都來節
有一些問題也是如此。

124
00:05:54,780 --> 00:05:58,480
當你準備好，舉起你的手
我們將開始。

125
00:05:58,480 --> 00:06:01,590

126
00:06:01,590 --> 00:06:05,200
>> 請記住，這些問題你有，
沒有愚蠢的問題。

127
00:06:05,200 --> 00:06:06,250
我們已經聽說了很多。

128
00:06:06,250 --> 00:06:09,490
和你有問題，我願意
打賭，很多人既

129
00:06:09,490 --> 00:06:11,740
坐在這裡，看
網上也一樣。

130
00:06:11,740 --> 00:06:13,770
所以你只能幫助人們
通過提問。

131
00:06:13,770 --> 00:06:15,070
馬庫斯。

132
00:06:15,070 --> 00:06:18,040
>> MARCUS：堆棧之間的
堆，就是有一個預分配

133
00:06:18,040 --> 00:06:22,880
這被定義為內存的百分比
這是堆棧或堆？

134
00:06:22,880 --> 00:06:25,010
或者，請問是怎麼工作的，到底是什麼？

135
00:06:25,010 --> 00:06:26,230
>> JASON HIRSCHHORN：大問題。

136
00:06:26,230 --> 00:06:28,640
我要回追查一點點。

137
00:06:28,640 --> 00:06:30,910
請問大家 - 

138
00:06:30,910 --> 00:06:31,660
請在這裡是誠實的。

139
00:06:31,660 --> 00:06:34,130
我知道我在問你提高你的
手在你同行的前面。

140
00:06:34,130 --> 00:06:38,510
但有沒有人覺得誰
難受的是棧和堆

141
00:06:38,510 --> 00:06:42,980
並想說明一下
和那些什麼意思？

142
00:06:42,980 --> 00:06:43,880
如果舉起你的手 - 

143
00:06:43,880 --> 00:06:44,420
確定。

144
00:06:44,420 --> 00:06:45,120
謝謝。

145
00:06:45,120 --> 00:06:48,420
所以，我們要投奔的堆棧和
堆真的很快，然後

146
00:06:48,420 --> 00:06:50,370
進入回答你的問題。

147
00:06:50,370 --> 00:06:58,250
>> 所以，如果我們畫了一個框來表示
內存在計算機上，都有些什麼

148
00:06:58,250 --> 00:07:02,160
事情往這個盒子？

149
00:07:02,160 --> 00:07:03,630
主。

150
00:07:03,630 --> 00:07:04,020
一個主要功能。

151
00:07:04,020 --> 00:07:05,890
哪裡主去了？

152
00:07:05,890 --> 00:07:08,090
>> 學生：[聽不清]。

153
00:07:08,090 --> 00:07:09,390
>> JASON HIRSCHHORN：所以我們會
把主要這兒吧。

154
00:07:09,390 --> 00:07:12,180

155
00:07:12,180 --> 00:07:13,430
在此框中去還有什麼呢？

156
00:07:13,430 --> 00:07:16,000

157
00:07:16,000 --> 00:07:18,140
>> 學生：你調用的函數。

158
00:07:18,140 --> 00:07:19,020
>> JASON HIRSCHHORN：該功能
我們稱之為。

159
00:07:19,020 --> 00:07:20,440
他們去哪兒去了？

160
00:07:20,440 --> 00:07:21,300
>> 生：在堆棧中。

161
00:07:21,300 --> 00:07:22,380
>> JASON HIRSCHHORN：他們
走在棧中。

162
00:07:22,380 --> 00:07:27,350
所以，我們要調用這個
這兒的事情堆棧。

163
00:07:27,350 --> 00:07:31,880
而往上頂，我們有堆。

164
00:07:31,880 --> 00:07:35,450
所以內存是不是就像這樣一個盒子。

165
00:07:35,450 --> 00:07:37,330
但它實際上是非常相似的。

166
00:07:37,330 --> 00:07:40,840
這將是一個很大的箱子超過
並且，這取決於有多大你

167
00:07:40,840 --> 00:07:43,730
計算機是或有多大你的內存是。

168
00:07:43,730 --> 00:07:46,950
>> 在報價引文結束“底”
是堆棧。

169
00:07:46,950 --> 00:07:50,880
並有多個事
即進入堆疊。

170
00:07:50,880 --> 00:07:53,840
而那些依賴於功能
你在你的代碼。

171
00:07:53,840 --> 00:07:57,780
你總是有一個功能在你的
代碼中調用主，所以總有一個

172
00:07:57,780 --> 00:08:00,480
下節在這裡
堆棧致力於主。

173
00:08:00,480 --> 00:08:03,980
>> 這些部分在堆棧
被稱為堆棧幀。

174
00:08:03,980 --> 00:08:09,580
當你調用另一個函數，主要說
調用一個二進制搜索功能，

175
00:08:09,580 --> 00:08:11,075
我們把另一幀堆棧上。

176
00:08:11,075 --> 00:08:13,830

177
00:08:13,830 --> 00:08:17,320
更具體地說，我們要
捐贈的內存塊在我們的

178
00:08:17,320 --> 00:08:22,960
計算機存儲二進制搜索的地方
變量和運行的二進制

179
00:08:22,960 --> 00:08:24,150
搜索代碼。

180
00:08:24,150 --> 00:08:26,810
>> 所以我們稱之為二進制搜索。

181
00:08:26,810 --> 00:08:30,440

182
00:08:30,440 --> 00:08:33,340
在這種大塊的內存，我們要
來存儲它的局部變量。

183
00:08:33,340 --> 00:08:35,270
我們要存儲其printf的調用。

184
00:08:35,270 --> 00:08:38,159
無論發生什麼事，該函數是
將被存儲在那裡。

185
00:08:38,159 --> 00:08:40,350
二進制搜索是要執行。

186
00:08:40,350 --> 00:08:42,210
它要完成執行。

187
00:08:42,210 --> 00:08:47,450
什麼是C語言的單詞，標誌著
一個函數

188
00:08:47,450 --> 00:08:49,306
完成它的執行？

189
00:08:49,306 --> 00:08:50,040
>> 學生：返回。

190
00:08:50,040 --> 00:08:50,870
>> JASON HIRSCHHORN：返回。

191
00:08:50,870 --> 00:08:53,230
所以每當你看到一個return語句，
函數結束

192
00:08:53,230 --> 00:08:54,350
當它擊中了。

193
00:08:54,350 --> 00:08:56,740
所以二進制搜索將達到其返回。

194
00:08:56,740 --> 00:09:01,360
這部分內存基本上會
被釋放了。

195
00:09:01,360 --> 00:09:03,510
而主要將回到執行。

196
00:09:03,510 --> 00:09:07,240
所以主要將暫停的地方是，調用
二進制搜索，得到一些返回值，

197
00:09:07,240 --> 00:09:08,700
並繼續執行。

198
00:09:08,700 --> 00:09:10,840
這個棧幀會自行消失。

199
00:09:10,840 --> 00:09:14,810
>> 如果我們調用一個遞歸函數，該函數
是一個函數調用自身在

200
00:09:14,810 --> 00:09:18,480
並且，我們可能會得到 - 我們說
遞歸做二進制搜索。

201
00:09:18,480 --> 00:09:21,520
我們可能會得到一個二分查找的版本，
二進制搜索二，二分查找

202
00:09:21,520 --> 00:09:24,090
3，二進制搜索4，
二進制搜索五位。

203
00:09:24,090 --> 00:09:27,950
然後這最後的二進制搜索5
將撞擊基的情況下，與層疊

204
00:09:27,950 --> 00:09:31,010
幀會回去，並保持關閉
直到我們回到主。

205
00:09:31,010 --> 00:09:32,530
我們可以走了過來遞歸的一點。

206
00:09:32,530 --> 00:09:35,530
但是，這一切是說，如果你是
調用多種功能的時間，

207
00:09:35,530 --> 00:09:39,250
就會有多個棧
在堆棧幀。

208
00:09:39,250 --> 00:09:42,900
>> 堆，另一方面，升
這裡，不是功能，

209
00:09:42,900 --> 00:09:44,380
不為局部變量。

210
00:09:44,380 --> 00:09:48,920
這是動態分配
變量。

211
00:09:48,920 --> 00:09:57,210
因此，這些變量可以是
在任何主要或初始化

212
00:09:57,210 --> 00:09:58,640
函數主要調用。

213
00:09:58,640 --> 00:10:00,790
在任何地方你的代碼，它們
可以初始化。

214
00:10:00,790 --> 00:10:04,360
並初始化一個動態
分配的變量。

215
00:10:04,360 --> 00:10:06,970
我們使用什麼函數C語言？

216
00:10:06,970 --> 00:10:07,600
>> 學生：malloc的。

217
00:10:07,600 --> 00:10:09,240
>> JASON HIRSCHHORN：malloc的。

218
00:10:09,240 --> 00:10:10,800
你調用malloc。

219
00:10:10,800 --> 00:10:12,260
你得到的內存空間。

220
00:10:12,260 --> 00:10:15,020
和內存空間
是在堆上。

221
00:10:15,020 --> 00:10:18,840
和內存空間保持
在那裡，直到你打電話免費。

222
00:10:18,840 --> 00:10:22,670
>> 在這樣動態分配的變量
將堆，只要存在你

223
00:10:22,670 --> 00:10:25,250
希望他們存在，他們不會
走開，直到您明確

224
00:10:25,250 --> 00:10:26,760
告訴他們走開。

225
00:10:26,760 --> 00:10:29,670
你可以在一個函數中創建它們。

226
00:10:29,670 --> 00:10:31,930
該函數的棧
框架會自動消失。

227
00:10:31,930 --> 00:10:35,490
但該變量仍然存在
在堆中，直到它被釋放，

228
00:10:35,490 --> 00:10:39,650
可能通過調用該函數
二進制搜索或什麼的。

229
00:10:39,650 --> 00:10:42,580
>> 因此，那些堆變量呆在那裡
只要你想

230
00:10:42,580 --> 00:10:43,490
他們呆在那裡。

231
00:10:43,490 --> 00:10:46,090
而他們得到放在這裡。

232
00:10:46,090 --> 00:10:47,450
然後下一個被放在那裡。

233
00:10:47,450 --> 00:10:50,210
他們不斷得到填補，而他們
呆在那裡，直到你調用free。

234
00:10:50,210 --> 00:10:52,870
>> 而且基本上，堆和棧，
讓馬庫斯的問題，

235
00:10:52,870 --> 00:10:54,500
增長向對方。

236
00:10:54,500 --> 00:10:57,730
如果他們碰上彼此，你已經
用完了所有的記憶在你的

237
00:10:57,730 --> 00:11:01,330
電腦，你的程序將退出
因為你沒有任何更多的內存

238
00:11:01,330 --> 00:11:02,420
左邊使用。

239
00:11:02,420 --> 00:11:07,290
在它們之間，有
可能其他的東西。

240
00:11:07,290 --> 00:11:10,980
但對於本課程的範圍，你
不必擔心。

241
00:11:10,980 --> 00:11:12,020
>> 所以這就是答案
你的問題。

242
00:11:12,020 --> 00:11:13,520
不用擔心這個。

243
00:11:13,520 --> 00:11:15,550
但是，這是長遠的答案。

244
00:11:15,550 --> 00:11:17,800
所有你需要知道的是
堆和堆棧 - 

245
00:11:17,800 --> 00:11:18,900
一開始在底部。

246
00:11:18,900 --> 00:11:19,570
堆棧一樣。

247
00:11:19,570 --> 00:11:20,790
堆是在那裡。

248
00:11:20,790 --> 00:11:21,990
他們也會越來越密切彼此。

249
00:11:21,990 --> 00:11:23,110
>> 如果他們碰，這是一個問題。

250
00:11:23,110 --> 00:11:24,500
你耗盡了內存。

251
00:11:24,500 --> 00:11:28,760
但同時，除了知道在哪裡
它們是什麼被存儲在兩個

252
00:11:28,760 --> 00:11:30,512
棧和堆。

253
00:11:30,512 --> 00:11:31,410
柯蒂斯。

254
00:11:31,410 --> 00:11:33,570
>> 柯蒂斯：當他們碰撞，
是一個堆棧溢出？

255
00:11:33,570 --> 00:11:35,670
>> JASON HIRSCHHORN：當他們碰撞，
這不是一個堆棧溢出。

256
00:11:35,670 --> 00:11:38,340
堆棧溢出是一個不同的區域
我們可以走了過來，如果你想。

257
00:11:38,340 --> 00:11:40,020
OK，我們會回來，在一個位。

258
00:11:40,020 --> 00:11:42,730
>> 學生：什麼叫字
當他們擊中對方，

259
00:11:42,730 --> 00:11:44,450
棧和堆？

260
00:11:44,450 --> 00:11:46,640
>> JASON HIRSCHHORN：就目前而言，
不用擔心。

261
00:11:46,640 --> 00:11:47,750
只知道 - 

262
00:11:47,750 --> 00:11:50,530
我會回答這個問題
下課。

263
00:11:50,530 --> 00:11:52,680
如果他們碰上對方，你跑出來
的內存，因為沒有更多的

264
00:11:52,680 --> 00:11:53,330
空間在那裡。

265
00:11:53,330 --> 00:11:55,450
>> 學生：對不起，什麼是賽格故障？

266
00:11:55,450 --> 00:11:58,710
>> JASON HIRSCHHORN：分部
故障可要求 - 

267
00:11:58,710 --> 00:12:02,240
這取決於為什麼賽格故障的調用。

268
00:12:02,240 --> 00:12:06,260
有時候，你的堆棧溢出，它會
說賽格故障的錯誤。

269
00:12:06,260 --> 00:12:08,180
>> 學生：約提領什麼
一個空的變量？

270
00:12:08,180 --> 00:12:10,040
那是段錯誤？

271
00:12:10,040 --> 00:12:11,480
>> JASON HIRSCHHORN：提領
一個空指針 - 

272
00:12:11,480 --> 00:12:17,850
好了，如果你有一個指針，你
設置為null，指針，調用，

273
00:12:17,850 --> 00:12:20,270
存儲內存地址
作為它們的值。

274
00:12:20,270 --> 00:12:23,660
和一個空指針本質上是
存儲0，在第0個

275
00:12:23,660 --> 00:12:26,670
解決該變量。

276
00:12:26,670 --> 00:12:30,010
所以為0x，0，0，0，0，等等。

277
00:12:30,010 --> 00:12:35,030
這0個內存地址，這不是
在我們的畫面，那是在那裡

278
00:12:35,030 --> 00:12:38,800
在某處，這是保留
對於計算機。

279
00:12:38,800 --> 00:12:40,130
我們沒有被允許去觸摸它。

280
00:12:40,130 --> 00:12:44,680
>> 所以，當你的程序的執行，如果
事情是試圖去記憶

281
00:12:44,680 --> 00:12:48,990
地址0時，它知道
那是一個空值。

282
00:12:48,990 --> 00:12:50,820
它什麼都不知道應該在那裡。

283
00:12:50,820 --> 00:12:53,420
所以，如果你嘗試使用的東西有
並把喜歡的東西或有

284
00:12:53,420 --> 00:12:58,355
試圖去那個位置，你是
要得到一個段故障或錯誤。

285
00:12:58,355 --> 00:13:00,520
這是否回答你的問題？

286
00:13:00,520 --> 00:13:03,170
>> 現在我們就回去
堆棧溢出。

287
00:13:03,170 --> 00:13:09,560
事情在棧中，因為你們有
以前看過，在 - 讓我們得出一個接近

288
00:13:09,560 --> 00:13:11,966
一個堆棧幀。

289
00:13:11,966 --> 00:13:15,050
可大家都看到了嗎？

290
00:13:15,050 --> 00:13:16,650
因此，我們有我們的堆棧幀。

291
00:13:16,650 --> 00:13:23,260
是在拯救一個數組作為一個地方
變量在該函數。

292
00:13:23,260 --> 00:13:29,510
所以說，我們的陣列有五點。

293
00:13:29,510 --> 00:13:33,230
所有5的那些將被存儲
在堆棧幀。

294
00:13:33,230 --> 00:13:37,540
>> 如果我們開始編寫超越
這個數組越界 - 

295
00:13:37,540 --> 00:13:43,990
因此，如果我們開始寫進去，
讓我們說這是0。

296
00:13:43,990 --> 00:13:46,800
這些都是五項指標
我們的數組。

297
00:13:46,800 --> 00:13:50,980
如果我們開始編寫成指標5，其中
我們沒有，當我們有一個

298
00:13:50,980 --> 00:13:55,900
大小為5的數組，我們開始編寫成
指標6，7，8，9，我們可以得到一個堆棧

299
00:13:55,900 --> 00:13:57,960
溢出錯誤。

300
00:13:57,960 --> 00:14:00,510
>> 通常它不是 - 

301
00:14:00,510 --> 00:14:04,910
你可能會惹上麻煩
如果你一走了過來。

302
00:14:04,910 --> 00:14:08,640
但是總體來說，您將獲得進入
如果你有很多去了最麻煩

303
00:14:08,640 --> 00:14:12,770
和你這麼遠了，你去寫
超過了返回地址

304
00:14:12,770 --> 00:14:16,080
函數，它是位於
棧幀的底部。

305
00:14:16,080 --> 00:14:16,520
>> 因為，對不對？

306
00:14:16,520 --> 00:14:17,670
你 - 在 - 對不起。

307
00:14:17,670 --> 00:14:18,550
不“，因為正確的。”

308
00:14:18,550 --> 00:14:20,470
>> 在棧幀中，你有
你的局部變量。

309
00:14:20,470 --> 00:14:27,090
在堆棧的最底層
幀的返回地址。

310
00:14:27,090 --> 00:14:28,790
這其中的功能
去當它結束了。

311
00:14:28,790 --> 00:14:33,750
如果你覆寫回報
地址，那麼當這個堆棧幀，

312
00:14:33,750 --> 00:14:36,680
當你正在經歷的堆棧
框架和執行的每一行，你

313
00:14:36,680 --> 00:14:40,350
會去你的新的返回地址
這是寫的，而不是有

314
00:14:40,350 --> 00:14:40,910
實際之一。

315
00:14:40,910 --> 00:14:45,050
這就是我們如何見過
一些安全漏洞

316
00:14:45,050 --> 00:14:46,780
可以與計算機發生。

317
00:14:46,780 --> 00:14:52,760
>> 所以堆棧溢出，總之，是當
您覆蓋的部分在堆棧

318
00:14:52,760 --> 00:14:55,440
你應該使用的地方
變量你應該使用，並

319
00:14:55,440 --> 00:14:58,070
特別是當你開始覆蓋
像重要的事情

320
00:14:58,070 --> 00:14:59,100
返回地址。

321
00:14:59,100 --> 00:15:00,090
而這也正是你會得到一個錯誤。

322
00:15:00,090 --> 00:15:03,980
或者甚至你可以開始
即使寫入 - 

323
00:15:03,980 --> 00:15:05,370
說二進制搜索是
正上方主。

324
00:15:05,370 --> 00:15:07,790
如果覆蓋了很多，你
可以寫為主力。

325
00:15:07,790 --> 00:15:10,230
但是總體來說，你以前得到一個錯誤
然後，由於計算機知道

326
00:15:10,230 --> 00:15:12,270
你正在做的事情你
不應該做的事情。

327
00:15:12,270 --> 00:15:12,560
是啊。

328
00:15:12,560 --> 00:15:13,910
>> 學生：有什麼區別
堆棧溢出之間

329
00:15:13,910 --> 00:15:16,940
和緩衝區溢出？

330
00:15:16,940 --> 00:15:19,420
>> JASON HIRSCHHORN：緩衝區溢出
是一個更通用的類型

331
00:15:19,420 --> 00:15:20,395
我剛剛描述。

332
00:15:20,395 --> 00:15:22,610
>> 學生：所以一個堆棧溢出是一種
例如緩衝區溢出。

333
00:15:22,610 --> 00:15:23,420
>> JASON HIRSCHHORN：沒錯。

334
00:15:23,420 --> 00:15:28,700
這是一個數組，我們可以認為，作為一個
緩衝，事情進去的空間

335
00:15:28,700 --> 00:15:30,600
這是一個堆棧緩衝區溢出。

336
00:15:30,600 --> 00:15:33,210
我們可以有一個堆緩衝區溢出。

337
00:15:33,210 --> 00:15:36,870
如果有一個緩衝器，它有常
是一個數組堆，而我們

338
00:15:36,870 --> 00:15:40,600
重寫了這些界限，那麼我們會
有一個堆緩衝區溢出。

339
00:15:40,600 --> 00:15:44,870
>> 和不在本課程的範圍，
他們發現有點不同。

340
00:15:44,870 --> 00:15:48,040
編譯器有特殊
方法檢測各。

341
00:15:48,040 --> 00:15:50,660
但緩衝區溢出是一種更通用的
型我描述的，

342
00:15:50,660 --> 00:15:54,090
這是一個堆棧緩衝區溢出。

343
00:15:54,090 --> 00:15:56,240
這是否回答你的問題？

344
00:15:56,240 --> 00:15:57,910
甜蜜。

345
00:15:57,910 --> 00:16:01,850
>> 有沒有什麼其他的相關問題
到堆棧或堆？

346
00:16:01,850 --> 00:16:04,920

347
00:16:04,920 --> 00:16:05,510
是啊。

348
00:16:05,510 --> 00:16:08,220
>> 學生：我知道你有免費的字符串
因為他們是在堆

349
00:16:08,220 --> 00:16:09,305
而你不想洩漏內存。

350
00:16:09,305 --> 00:16:12,240
但你必須釋放全局變量
和類似的東西？

351
00:16:12,240 --> 00:16:14,335
或者他們會自動釋放？

352
00:16:14,335 --> 00:16:15,700
>> JASON HIRSCHHORN：好問題。

353
00:16:15,700 --> 00:16:22,340
所以在CS50.H，我們創建這個東西
你叫一個字符串。

354
00:16:22,340 --> 00:16:23,800
字符串是真的麼？

355
00:16:23,800 --> 00:16:24,810
>> 學生：字數明星。

356
00:16:24,810 --> 00:16:29,180
>> JASON HIRSCHHORN：一個char明星，一個指針
到一個字符，一個指針到

357
00:16:29,180 --> 00:16:30,650
字符數組。

358
00:16:30,650 --> 00:16:32,210
這是該字符串是什麼。

359
00:16:32,210 --> 00:16:36,050
因此，我們需要釋放它，因為
GetString的，我們用了很多 - 

360
00:16:36,050 --> 00:16:38,370
字符串名稱等於GetString的 - 

361
00:16:38,370 --> 00:16:43,560
這mallocs對我們的一些記憶
堆，然後返回一個指向

362
00:16:43,560 --> 00:16:47,230
那第一個字符
字符串，一個char明星。

363
00:16:47,230 --> 00:16:52,760
>> 所以表面上，如果你還沒有
您的任何字符串的自由寫作

364
00:16:52,760 --> 00:16:55,600
那你叫到目前為止，你有
被洩露一些內存。

365
00:16:55,600 --> 00:16:57,430
當然，我們還沒有談到
它，所以沒有人在得到

366
00:16:57,430 --> 00:16:58,520
對於這樣做的麻煩。

367
00:16:58,520 --> 00:16:59,980
但展望未來，是的。

368
00:16:59,980 --> 00:17:03,990
當你調用GetString的，你
mallocing一些空間在堆上。

369
00:17:03,990 --> 00:17:07,640
如果你不打電話免費以後的
字符串，你有內存洩漏。

370
00:17:07,640 --> 00:17:09,440
這回答你的問題？

371
00:17:09,440 --> 00:17:10,606
>> 是啊

372
00:17:10,606 --> 00:17:15,020
>> 學生：所以要做到這一點，我們使用
返回之前免費對不對？

373
00:17:15,020 --> 00:17:18,510
象，範圍內的，我想，如果
我們說的一樣，INT為主，內

374
00:17:18,510 --> 00:17:24,410
該代碼是在那些範圍
大括號，右前 - 

375
00:17:24,410 --> 00:17:26,140
你知道你會
通常把回報。

376
00:17:26,140 --> 00:17:27,950
你把自由之前？

377
00:17:27,950 --> 00:17:31,000
>> JASON HIRSCHHORN：所以，你可以把免費
無論你想要把自由。

378
00:17:31,000 --> 00:17:33,810
因為這些都是動態分配
變量，因為他們可以

379
00:17:33,810 --> 00:17:39,170
活過一個特定的範圍
功能，如果你調用malloc在

380
00:17:39,170 --> 00:17:44,140
獨立的功能，例如
GetString的，你可以在主調用free。

381
00:17:44,140 --> 00:17:46,050
你不需要調用它
在所述特定功能

382
00:17:46,050 --> 00:17:47,570
其中調用malloc。

383
00:17:47,570 --> 00:17:50,340
但是，你需要調用它
之前主要的回報。

384
00:17:50,340 --> 00:17:51,120
>> 它實際上取決於。

385
00:17:51,120 --> 00:17:54,960
這要看你為什麼malloced的
空間擺在首位。

386
00:17:54,960 --> 00:17:57,320
有些人會打電話
釋放很快。

387
00:17:57,320 --> 00:17:59,220
有些人會不叫自由，直到
他們的節目的結束。

388
00:17:59,220 --> 00:18:00,660
而且他們會通過
和自由的一切。

389
00:18:00,660 --> 00:18:03,597
這要看你為什麼叫malloc的。

390
00:18:03,597 --> 00:18:11,270
>> 學生：你會說什麼
如果你用所謂的GetString？

391
00:18:11,270 --> 00:18:13,320
你會說什麼自由？

392
00:18:13,320 --> 00:18:20,040
>> JASON HIRSCHHORN：所以語法免費
簡直是免費的，開放的括號，關閉

393
00:18:20,040 --> 00:18:22,130
括號，並且指針的名稱。

394
00:18:22,130 --> 00:18:26,410
所以，如果你寫的字符串名稱等於
GetString的，你把名字在這裡。

395
00:18:26,410 --> 00:18:27,760
這就是指針的名稱。

396
00:18:27,760 --> 00:18:30,570
它知道來釋放內存。

397
00:18:30,570 --> 00:18:33,920
>> 學生：所以，當它釋放內存，
指針仍然指向那個地方

398
00:18:33,920 --> 00:18:34,970
在內存中？

399
00:18:34,970 --> 00:18:39,020
或者是指針也走光
它指向的地址。

400
00:18:39,020 --> 00:18:40,290
>> JASON HIRSCHHORN：我們應該嘗試一下。

401
00:18:40,290 --> 00:18:41,430
我們要編寫的。

402
00:18:41,430 --> 00:18:43,880
讓我們回來的時候，我們得到
編碼，並且讓代碼的。

403
00:18:43,880 --> 00:18:46,000
如果你想找出答案
這一點，你也可以代碼

404
00:18:46,000 --> 00:18:46,690
在此期間。

405
00:18:46,690 --> 00:18:49,100
但是，這是一個很大的問題。

406
00:18:49,100 --> 00:18:53,480
>> 學生：有沒有可能
免費的東西太快？

407
00:18:53,480 --> 00:18:58,530
所以你仍然需要它為你的程序，
而你釋放內存空間？

408
00:18:58,530 --> 00:18:59,200
>> JASON HIRSCHHORN：是的。

409
00:18:59,200 --> 00:19:03,020
這是可能的，如果你免費的東西
然後你再次使用它，你會

410
00:19:03,020 --> 00:19:06,890
碰到一個錯誤。

411
00:19:06,890 --> 00:19:10,810
但是，這對你，因為你釋放
的東西，再後來把它稱為。

412
00:19:10,810 --> 00:19:13,940
所以這是一個程序員的失誤。

413
00:19:13,940 --> 00:19:14,780
但肯定的。

414
00:19:14,780 --> 00:19:17,760
你可以寫。

415
00:19:17,760 --> 00:19:19,240
>> 任何更多的問題 - 

416
00:19:19,240 --> 00:19:19,760
是。

417
00:19:19,760 --> 00:19:22,820
>> 學生：所以，如果你都應該只是
釋放它一般前

418
00:19:22,820 --> 00:19:25,490
程序結束，是否意味著如果
程序結束，你不釋放它，

419
00:19:25,490 --> 00:19:27,580
該內存仍分配呢？

420
00:19:27,580 --> 00:19:31,330
>> JASON HIRSCHHORN：如果你的程序結束
你忘記釋放的東西，那麼

421
00:19:31,330 --> 00:19:34,390
這整個內存分配
你的程序的生命週期。

422
00:19:34,390 --> 00:19:37,670
當你的程序完全關閉，
該內存是不會

423
00:19:37,670 --> 00:19:39,490
要永遠呆在那裡。

424
00:19:39,490 --> 00:19:42,080
計算機是足夠聰明，知道
該程序關閉時，它

425
00:19:42,080 --> 00:19:46,440
要擺脫所有的內存的那
是與該程序相關聯。

426
00:19:46,440 --> 00:19:51,240
>> 不過，也有可以運行的工具
在一個程序來檢測，如果當

427
00:19:51,240 --> 00:19:54,720
程序完成後，您忘了
以釋放一些內存。

428
00:19:54,720 --> 00:19:57,960
並為你的下一個問題集，其中
您將要使用的malloc和使用

429
00:19:57,960 --> 00:20:02,610
指針，你將要運行此
編寫你的程序，如果看到，

430
00:20:02,610 --> 00:20:06,530
當主的回報，你有一些
所剩下未釋放的東西。

431
00:20:06,530 --> 00:20:09,130
>> 所以他們不會留malloced
永遠留在你的電腦上。

432
00:20:09,130 --> 00:20:11,720
這將是浪費的，因為
很快，電腦

433
00:20:11,720 --> 00:20:12,960
會耗盡內存。

434
00:20:12,960 --> 00:20:16,450
但是，如果他們跑，直到你的結尾
編程和他們不釋放，你的

435
00:20:16,450 --> 00:20:20,260
程序退出，這仍然是一個問題
這一工具將幫助您解決。

436
00:20:20,260 --> 00:20:21,520
>> 學生：那是Valgrind的？

437
00:20:21,520 --> 00:20:22,910
>> JASON HIRSCHHORN：這是
所謂Valgrind的。

438
00:20:22,910 --> 00:20:23,520
，你會 - 

439
00:20:23,520 --> 00:20:25,780
>> 學生：但是，我們不必知道
對於測驗有關係嗎？

440
00:20:25,780 --> 00:20:27,600
我的意思是，有人談到了
在演講一點點。

441
00:20:27,600 --> 00:20:33,600
>> JASON HIRSCHHORN：所以Valgrind的
是，工具的名稱。

442
00:20:33,600 --> 00:20:37,180
知道它的作用是
足夠的測驗。

443
00:20:37,180 --> 00:20:40,200
可是你有沒有使用它在您的
問題的設置，因為我們還沒有一個

444
00:20:40,200 --> 00:20:43,520
已明確處理問題集
使用malloc或您使用malloc。

445
00:20:43,520 --> 00:20:45,330
所以，你還沒有使用Valgrind的呢。

446
00:20:45,330 --> 00:20:47,760
但你遲早會使用它
而不是以後。

447
00:20:47,760 --> 00:20:48,710
>> 學生：你能重複
什麼Valgrind是？

448
00:20:48,710 --> 00:20:49,190
>> JASON HIRSCHHORN：對不起？

449
00:20:49,190 --> 00:20:51,240
>> 學生：你能重複
Valgring的目的是什麼？

450
00:20:51,240 --> 00:20:53,100
>> JASON HIRSCHHORN：Valgrind的
是名稱 - 

451
00:20:53,100 --> 00:20:59,890
像GDB可以幫助你調試你的程序，
Valgrind的可以幫助你計算出，如果

452
00:20:59,890 --> 00:21:03,210
事情還沒有被釋放
當你的程序關閉。

453
00:21:03,210 --> 00:21:05,110
所以，你會在你的程序運行它。

454
00:21:05,110 --> 00:21:09,230
和你的程序退出時，它會說
你的程序調用malloc的這麼多

455
00:21:09,230 --> 00:21:13,670
時間這麼多字節，而你
只有所謂的自由很多次。

456
00:21:13,670 --> 00:21:16,520
所以你離開了這些多少字節
沒有被釋放。

457
00:21:16,520 --> 00:21:18,050
或者，它會說你已經釋放了一切。

458
00:21:18,050 --> 00:21:19,070
幹得好。

459
00:21:19,070 --> 00:21:19,480
>> 學生：確定。

460
00:21:19,480 --> 00:21:21,060
它叫做Valgring？

461
00:21:21,060 --> 00:21:24,940
>> JASON HIRSCHHORN：V-A-L-G-R-I-N-D。

462
00:21:24,940 --> 00:21:25,970
>> 學生：關於指針的一個問題。

463
00:21:25,970 --> 00:21:30,080
所以說你有N個明星
x等於什麼。

464
00:21:30,080 --> 00:21:33,330
這相當於，不管你把
還有，是什麼正在裡面放

465
00:21:33,330 --> 00:21:36,120
X是什麼指向，
或x的指針？

466
00:21:36,120 --> 00:21:37,690
>> JASON HIRSCHHORN：你能
重複的問題？

467
00:21:37,690 --> 00:21:39,340
我們可以借鑒它，而你說了嗎？

468
00:21:39,340 --> 00:21:42,710
>> 學生：在測驗，其實，
一個你給我們送來，就好像，燒焦

469
00:21:42,710 --> 00:21:46,520
星級真相等於CS50岩石，對不對？

470
00:21:46,520 --> 00:21:52,190
那麼，這是否意味著該CS50岩石
是什麼樣的真相是指向？

471
00:21:52,190 --> 00:21:55,810
>> JASON HIRSCHHORN：所以你說
大約一個char明星在一個字符串中，如何

472
00:21:55,810 --> 00:21:56,460
的作品？

473
00:21:56,460 --> 00:21:56,890
是啊。

474
00:21:56,890 --> 00:21:57,700
確定。

475
00:21:57,700 --> 00:21:59,140
讓我們得出這樣的在這裡。

476
00:21:59,140 --> 00:22:07,100
>> [SIDE會話]

477
00:22:07,100 --> 00:22:11,130
>> JASON HIRSCHHORN：所以這個變量
將是char類型的明星。

478
00:22:11,130 --> 00:22:14,580
多大是一個變量
的char類型的明星？

479
00:22:14,580 --> 00:22:15,510
有多少字節？

480
00:22:15,510 --> 00:22:16,450
>> 學生：四。

481
00:22:16,450 --> 00:22:18,210
>> JASON HIRSCHHORN：這是四個字節。

482
00:22:18,210 --> 00:22:21,420
有多少權利是一個變量
int類型的明星？

483
00:22:21,420 --> 00:22:22,210
>> 學生：四。

484
00:22:22,210 --> 00:22:24,910
>> JASON HIRSCHHORN：四個字節。

485
00:22:24,910 --> 00:22:28,280
如果它是一個指針，那麼它始終是
4個字節，因為指針，其

486
00:22:28,280 --> 00:22:30,070
值是一個存儲器地址。

487
00:22:30,070 --> 00:22:35,160
而在CS50內存地址
家電是四個字節長。

488
00:22:35,160 --> 00:22:42,900
因此，當我們需要調用getString，或當我們
也就是說，字符串名稱等於，然後在

489
00:22:42,900 --> 00:22:46,140
雙引號把一個字符串，
我們正在把 - 

490
00:22:46,140 --> 00:22:46,920
好了，這是一個有點不同。

491
00:22:46,920 --> 00:22:48,630
我們會做的GetString為例。

492
00:22:48,630 --> 00:22:52,150
或char星級東西
等於字符串。

493
00:22:52,150 --> 00:22:54,360
對不起，給我的例子
你讀？

494
00:22:54,360 --> 00:22:57,590
>> 學生：字符星級等於真相
在雙引號“CS50石頭”。

495
00:22:57,590 --> 00:23:02,260
>> JASON HIRSCHHORN：那麼這顆星，這
我們將調用這個變量x為

496
00:23:02,260 --> 00:23:04,060
通用的目的。

497
00:23:04,060 --> 00:23:05,970
我們已經創建了一個變量x。

498
00:23:05,970 --> 00:23:07,610
這是char類型的明星。

499
00:23:07,610 --> 00:23:10,950
它是一個指向一個系列
字符。

500
00:23:10,950 --> 00:23:12,200
這樣下來在這裡 - 

501
00:23:12,200 --> 00:23:23,710

502
00:23:23,710 --> 00:23:25,890
>> 因此，這是該會怎樣
在內存中運行。

503
00:23:25,890 --> 00:23:27,410
這將存儲的存儲器地址。

504
00:23:27,410 --> 00:23:31,770
將存儲的存儲器地址
陣列中的第一個字符。

505
00:23:31,770 --> 00:23:33,830
然後你按照時
指針，你會

506
00:23:33,830 --> 00:23:35,200
得到第一個字符。

507
00:23:35,200 --> 00:23:38,780
>> 如果你正在讀這篇東西一樣
一個字符串，你的電腦是智能

508
00:23:38,780 --> 00:23:42,930
足以知道，閱讀這件事
直到它到達一個反彈0。

509
00:23:42,930 --> 00:23:45,530
但是，如果你正在閱讀這一個字符
一時間，所以你通過迭代

510
00:23:45,530 --> 00:23:49,910
這個字符串，那麼你將只是一個讀
字符一次，直到你到達

511
00:23:49,910 --> 00:23:50,850
反斜杠0。

512
00:23:50,850 --> 00:23:52,335
可能不會回答你的
的問題，雖然。

513
00:23:52,335 --> 00:23:55,610
>> 學生：是啊，但你有沒有
malloced的空間

514
00:23:55,610 --> 00:23:58,400
但對於該指針。

515
00:23:58,400 --> 00:24:02,510
>> JASON HIRSCHHORN：所以我不太清楚
正是你要找什麼，

516
00:24:02,510 --> 00:24:03,640
因為我沒有作出這樣的測驗。

517
00:24:03,640 --> 00:24:06,370
這應該是一個有益的
從另一個TF資源。

518
00:24:06,370 --> 00:24:11,380
如果你是在創建一個字符串
堆棧或局部變量，它會

519
00:24:11,380 --> 00:24:16,920
只是數組的費用，而不是
一般一個char星級指向

520
00:24:16,920 --> 00:24:18,600
另一個字符串。

521
00:24:18,600 --> 00:24:20,550
但我不知道。

522
00:24:20,550 --> 00:24:25,065
這可能是一個指向另一個
在堆棧上字符串。

523
00:24:25,065 --> 00:24:27,240
是啊。

524
00:24:27,240 --> 00:24:31,116
>> 學生：我知道你需要
分配內存，如果指針

525
00:24:31,116 --> 00:24:33,360
越來越聲明內
另一個函數。

526
00:24:33,360 --> 00:24:36,740
你需要做同樣的事情，如果是
主內被宣布，

527
00:24:36,740 --> 00:24:39,570
你使用它的主內？

528
00:24:39,570 --> 00:24:43,590
>> JASON HIRSCHHORN：所以，是的。

529
00:24:43,590 --> 00:24:46,670
你可以聲明一個指向任何
在內存中的內存地址。

530
00:24:46,670 --> 00:24:51,440
它可以是一個本地的存儲器地址
變，但通常情況下，

531
00:24:51,440 --> 00:24:55,760
人不申報的內存地址
局部變量，因為他們去

532
00:24:55,760 --> 00:24:59,890
一旦離開該函數返回，這
所以我們一般用malloc的東西。

533
00:24:59,890 --> 00:25:04,630
但是，是的，你可以聲明一個指針
另一個局部變量。

534
00:25:04,630 --> 00:25:06,360
這只是一般沒有這樣做。

535
00:25:06,360 --> 00:25:09,480
但是我可以看看那個
下課後具體的事情。

536
00:25:09,480 --> 00:25:10,650
是啊。

537
00:25:10,650 --> 00:25:12,350
>> 學生：我認為這是排序
什麼的被問。

538
00:25:12,350 --> 00:25:16,930
它似乎奇怪進行初始化
一個指針而不是作為一個

539
00:25:16,930 --> 00:25:20,760
地址，但正如
似乎是一個值。

540
00:25:20,760 --> 00:25:25,970
這似乎是CS50是裡面有什麼
事情被指向和

541
00:25:25,970 --> 00:25:28,820
沒有實際的地址，對吧？

542
00:25:28,820 --> 00:25:30,520
>> JASON HIRSCHHORN：所以這是
不是這種情況，雖然。

543
00:25:30,520 --> 00:25:32,470
這不是發生了什麼。

544
00:25:32,470 --> 00:25:35,910
當你聲明一個char星，
這是一個內存地址。

545
00:25:35,910 --> 00:25:38,860
指針是所有的內存地址
指著別的東西。

546
00:25:38,860 --> 00:25:41,480
別的東西可能是在
棧，但幾乎總是是在

547
00:25:41,480 --> 00:25:43,440
堆在我們將看到它的使用方式。

548
00:25:43,440 --> 00:25:46,860

549
00:25:46,860 --> 00:25:53,500
但字符串名稱等於雙引號
“GetString的，”我們可以看到，和我們

550
00:25:53,500 --> 00:25:55,010
可以看看通過和代碼。

551
00:25:55,010 --> 00:26:01,190
GetString的字符串沒有被保存在
該變量，或任何字符串

552
00:26:01,190 --> 00:26:04,580
名字沒有被保存在
變量，因為這不是如何

553
00:26:04,580 --> 00:26:06,070
指針工作。

554
00:26:06,070 --> 00:26:06,770
這是否有道理？

555
00:26:06,770 --> 00:26:07,170
>> 學生：是啊。

556
00:26:07,170 --> 00:26:08,570
>> JASON HIRSCHHORN：確定。

557
00:26:08,570 --> 00:26:11,690
但願，這不是
混亂給任何人。

558
00:26:11,690 --> 00:26:15,732
但如果是，我們可以再看看它
在一個位，因為我們實際上會

559
00:26:15,732 --> 00:26:19,240
以代碼的東西，希望能
處理字符串的工作和讓你感覺

560
00:26:19,240 --> 00:26:22,170
更舒適的他們。

561
00:26:22,170 --> 00:26:24,869
>> 與這些其他問題
主題或其他主題，

562
00:26:24,869 --> 00:26:26,119
我要把備份？

563
00:26:26,119 --> 00:26:32,280

564
00:26:32,280 --> 00:26:34,840
和 - 

565
00:26:34,840 --> 00:26:36,310
現在。

566
00:26:36,310 --> 00:26:37,630
是的，奧爾登。

567
00:26:37,630 --> 00:26:39,860
>> 奧爾登：所以這是完全不相關的，
但我們只是去了

568
00:26:39,860 --> 00:26:42,760
真的很快我們所需要知道的
大約32和之間的差

569
00:26:42,760 --> 00:26:46,345
64位機？

570
00:26:46,345 --> 00:26:47,740
>> JASON HIRSCHHORN：是的。

571
00:26:47,740 --> 00:26:52,111
因此，32位是多少字節？

572
00:26:52,111 --> 00:26:53,060
>> 奧爾登：這是四個字節。

573
00:26:53,060 --> 00:26:54,360
>> JASON HIRSCHHORN：這是四個字節。

574
00:26:54,360 --> 00:26:58,420
和64位是多少字節？

575
00:26:58,420 --> 00:26:59,112
>> 學生：八。

576
00:26:59,112 --> 00:27:00,610
>> JASON HIRSCHHORN：8個字節。

577
00:27:00,610 --> 00:27:03,980
如此反复，八位為一字節。

578
00:27:03,980 --> 00:27:08,340
您的CS50設備是
一個32位的機器。

579
00:27:08,340 --> 00:27:13,650
因此，內存地址
四字節長。

580
00:27:13,650 --> 00:27:17,460
有2到32個
內存地址。

581
00:27:17,460 --> 00:27:21,310
0到2至32減去1。

582
00:27:21,310 --> 00:27:27,630
而我不是正面的，但是這
什麼，你需要大概的範圍

583
00:27:27,630 --> 00:27:35,230
知道一個32位的機器，該內存
地址是，再次，四字節長，

584
00:27:35,230 --> 00:27:39,620
這就是最高金額
內存地址。

585
00:27:39,620 --> 00:27:41,680
>> 此外，數據類型 - 

586
00:27:41,680 --> 00:27:45,020
這可能是由於東西
那麼這是值得注意的。

587
00:27:45,020 --> 00:27:49,610
一個數據類型的大小取決於
您正在使用的機器。

588
00:27:49,610 --> 00:27:56,760
因此，一個字符，一個字符，是怎麼
多少個字節我們CS50設備？

589
00:27:56,760 --> 00:27:57,980
一個字節。

590
00:27:57,980 --> 00:28:02,310
它實際上是一個字節作為
以及一個64位的機器上。

591
00:28:02,310 --> 00:28:05,920
>> 和大多數數​​據類型是相同的數
的字節在兩台機器上。

592
00:28:05,920 --> 00:28:11,620
但某些數據類型會有所不同
在兩台機器上。

593
00:28:11,620 --> 00:28:14,590
所以這將是可能的
只有你需要知道的事情。

594
00:28:14,590 --> 00:28:16,710
>> 但即使這樣，我認為，
超出了界限 - 

595
00:28:16,710 --> 00:28:20,990
我幾乎可以肯定，如果你回頭看
在舊的測驗，它說，承擔

596
00:28:20,990 --> 00:28:24,090
編碼你使用的問題
一個32位的機器。

597
00:28:24,090 --> 00:28:26,620

598
00:28:26,620 --> 00:28:30,620
但也有，一起去，在
如果你有興趣，有

599
00:28:30,620 --> 00:28:35,920
是相同的數據類型
尺寸上的所有機器。

600
00:28:35,920 --> 00:28:42,670
>> 如果你看過類似的東西
uint32_t的，你可能會或可能

601
00:28:42,670 --> 00:28:43,260
沒有看到這一點。

602
00:28:43,260 --> 00:28:44,290
這是一個數據類型。

603
00:28:44,290 --> 00:28:47,570
這是說，有32位不管
什麼機器，這是上。

604
00:28:47,570 --> 00:28:50,350
所以，當人們編寫可移植
代碼，他們可能不會使用int類型。

605
00:28:50,350 --> 00:28:53,260
他們會轉而使用其他這些數據
他們知道類型將是相同的

606
00:28:53,260 --> 00:28:54,780
大小每一個機器上。

607
00:28:54,780 --> 00:28:58,080

608
00:28:58,080 --> 00:28:58,250
馬杜。

609
00:28:58,250 --> 00:29:00,150
>> MADHU：我有一個問題是關於
編譯過程。

610
00:29:00,150 --> 00:29:04,110
所以，如果你正在編寫一個使用程序
像CS50什麼的圖書館

611
00:29:04,110 --> 00:29:06,840
這樣，我知道該庫
有，在某些時候，可

612
00:29:06,840 --> 00:29:08,590
編譯和鏈接英寸

613
00:29:08,590 --> 00:29:13,380
但其中有多少過程中發生
你的程序的編譯？

614
00:29:13,380 --> 00:29:15,880
該庫程序的哪一部分
當你出現

615
00:29:15,880 --> 00:29:18,560
編譯你自己的程序？

616
00:29:18,560 --> 00:29:24,020
>> JASON HIRSCHHORN：讓我們去了
通常的步驟這一過程的。

617
00:29:24,020 --> 00:29:26,280
你寫你的c文件。

618
00:29:26,280 --> 00:29:33,530
在你的c文件，你的＃include你
頭的庫，例如，cs50.h.

619
00:29:33,530 --> 00:29:39,480
什麼是尖銳的，包括
行做你的計劃嗎？

620
00:29:39,480 --> 00:29:40,525
Akchar。

621
00:29:40,525 --> 00:29:43,350
>> AKCHAR：它增加的原型
從標題中的功能

622
00:29:43,350 --> 00:29:45,120
在庫中的文件。

623
00:29:45,120 --> 00:29:45,600
>> JASON HIRSCHHORN：沒錯。

624
00:29:45,600 --> 00:29:49,870
它增加了這些函數原型
你的代碼。

625
00:29:49,870 --> 00:29:55,230
所以，當你的代碼被編譯
在早期階段，編譯器知道

626
00:29:55,230 --> 00:29:59,250
這些功能真的存在，
在某個地方，他們已經確定。

627
00:29:59,250 --> 00:30:02,460
h文件不包含
定義這些函數或如何

628
00:30:02,460 --> 00:30:03,950
他們的實際工作。

629
00:30:03,950 --> 00:30:07,960
Cs50.h只是包括一些說
GetString的是一個真正的東西，

630
00:30:07,960 --> 00:30:09,270
可能發生。

631
00:30:09,270 --> 00:30:14,240
和standardio.h說printf的是
一個真實的東西，可以發生。

632
00:30:14,240 --> 00:30:23,190
>> 所以用這個你的c語言實現。頭
文件被變成了一些

633
00:30:23,190 --> 00:30:27,750
機器可讀的代碼，最終
被轉換為二進制

634
00:30:27,750 --> 00:30:30,030
代碼0和1。

635
00:30:30,030 --> 00:30:33,590
這就是代碼，最終
被執行。

636
00:30:33,590 --> 00:30:38,550
使用-l CS50線 - 例如，
當你寫鏘 - 

637
00:30:38,550 --> 00:30:41,830
然後就包括-L CS50，
你鍵入英寸

638
00:30:41,830 --> 00:30:42,180
你可以看到這一點。

639
00:30:42,180 --> 00:30:43,890
當你寫做，你會
看到這條線在這裡。

640
00:30:43,890 --> 00:30:47,740
我們將看到，在第二個時
我們的代碼或當我們的代碼以後。

641
00:30:47,740 --> 00:30:50,390
>> 但這-L CS50線做一些事情
比有點不同

642
00:30:50,390 --> 00:30:52,440
＃包括cs50.h.

643
00:30:52,440 --> 00:30:56,300
這是什麼-L CS50行嗎？

644
00:30:56,300 --> 00:30:56,820
阿維？

645
00:30:56,820 --> 00:31:00,310
>> AVI：我想說的是，它鏈接
圖書館的功能

646
00:31:00,310 --> 00:31:02,710
打電話，像。o文件。

647
00:31:02,710 --> 00:31:08,200
>> JASON HIRSCHHORN：所以很
接近，如果不是當場上。

648
00:31:08,200 --> 00:31:16,220
使用-l CS50採用的二進制文件，
與您的二進制文件將其合併。

649
00:31:16,220 --> 00:31:21,410
所以cs50.h，有車削沒有點
從C語言cs50.h為二進制每

650
00:31:21,410 --> 00:31:23,130
單一次它被使用。

651
00:31:23,130 --> 00:31:26,650
那將是愚蠢的，因為這
會浪費很多時間。

652
00:31:26,650 --> 00:31:30,420
所以它已經被編譯
，變成一個可執行文件。

653
00:31:30,420 --> 00:31:35,430
現在它要被合併
與您的文件結尾。

654
00:31:35,430 --> 00:31:38,370
因此，那些1和0的打算
與您的那些合併

655
00:31:38,370 --> 00:31:39,150
和0結尾。

656
00:31:39,150 --> 00:31:43,670
所以，現在你會真正有實際
1和0的定義如何GetString的，

657
00:31:43,670 --> 00:31:47,890
例如，工作，還是怎麼的printf，
例如，工作。

658
00:31:47,890 --> 00:31:52,750
>> 而對於更多的信息，有一個
總之編譯器內特給出了

659
00:31:52,750 --> 00:31:55,410
你應該檢查出雲
通過這些步驟。

660
00:31:55,410 --> 00:31:56,050
但是 - 

661
00:31:56,050 --> 00:31:56,560
是。

662
00:31:56,560 --> 00:32:01,700
>> 學生：他們總是在o文件。
當他們在圖書館的形式，

663
00:32:01,700 --> 00:32:06,764
準備合併，鏈接 - 像
他們在二進制代碼嗎？

664
00:32:06,764 --> 00:32:07,600
>> JASON HIRSCHHORN：確定。

665
00:32:07,600 --> 00:32:08,420
什麼 - 

666
00:32:08,420 --> 00:32:11,780
>> 學生：那是經常的情況下，
該庫時將它們鏈接？

667
00:32:11,780 --> 00:32:12,500
>> JASON HIRSCHHORN：是的。

668
00:32:12,500 --> 00:32:17,300
因此，有。s個文件，這將是
機代碼，這也將是

669
00:32:17,300 --> 00:32:17,975
神秘的給你。

670
00:32:17,975 --> 00:32:19,410
你不必擔心這些。

671
00:32:19,410 --> 00:32:24,930
但是總體來說，是的，他們會
是。o文件準備好了。

672
00:32:24,930 --> 00:32:27,170
>> 學生：所以，當你運送到
一個庫，你只船

673
00:32:27,170 --> 00:32:28,880
的，H和。Ö？

674
00:32:28,880 --> 00:32:32,210
你不出貨。c或。秒。

675
00:32:32,210 --> 00:32:33,070
>> JASON HIRSCHHORN：那麼 - 

676
00:32:33,070 --> 00:32:36,260
這就是在這短短的為好，如果
這一信息似乎是一個未來

677
00:32:36,260 --> 00:32:36,700
快一點。

678
00:32:36,700 --> 00:32:39,870
但短期的編譯器
關於這個談判也是如此。

679
00:32:39,870 --> 00:32:43,290
當你船庫，如果你出貨
在H，頭文件，這些

680
00:32:43,290 --> 00:32:46,290
函數原型，以及1和
0的，這就是你需要給。

681
00:32:46,290 --> 00:32:50,640
你並不需要給該如何
函數的工作原理，在c文件。

682
00:32:50,640 --> 00:32:56,360
因為該點的抽象，或
點的API，該點在這個SPL，

683
00:32:56,360 --> 00:32:59,650
斯坦福便攜圖書館，它的
讓你不用擔心如何將新

684
00:32:59,650 --> 00:33:04,220
GRect工作，或如何移動工作，
或如何添加工作。

685
00:33:04,220 --> 00:33:06,520
所有你需要知道的是，加
是一個函數，你可以

686
00:33:06,520 --> 00:33:08,880
使用，並且它這樣做。

687
00:33:08,880 --> 00:33:12,760
所以，你真的不需要知道如何
它是用C編寫的，您只需要

688
00:33:12,760 --> 00:33:15,460
知道，這裡是函數，他們
做的，這裡是1和0

689
00:33:15,460 --> 00:33:18,870
當你真的想使用它們。

690
00:33:18,870 --> 00:33:19,530
>> 涼爽。

691
00:33:19,530 --> 00:33:26,980
在編譯器的任何其他問題
或電路板上的其他議題是什麼？

692
00:33:26,980 --> 00:33:30,300
>> 學生：我有一個問題
實現遞歸函數。

693
00:33:30,300 --> 00:33:31,170
關於遞歸的一個問題。

694
00:33:31,170 --> 00:33:33,030
我會想出一個感覺。

695
00:33:33,030 --> 00:33:38,310
因此，讓我們快速瀏覽一下
遞歸與特定

696
00:33:38,310 --> 00:33:40,690
例如，階乘函數。

697
00:33:40,690 --> 00:33:44,920
因為這是一個例子，
經常出現或使用

698
00:33:44,920 --> 00:33:46,170
來說明遞歸。

699
00:33:46,170 --> 00:33:52,390

700
00:33:52,390 --> 00:33:56,410
>> 因此，“4！”讀作4的階乘。

701
00:33:56,410 --> 00:33:59,120
又是什麼4的階乘是什麼意思？

702
00:33:59,120 --> 00:34:00,696
那是什麼呢？

703
00:34:00,696 --> 00:34:02,235
如何計算4的階乘？

704
00:34:02,235 --> 00:34:05,250

705
00:34:05,250 --> 00:34:07,960
4倍3倍2倍1。

706
00:34:07,960 --> 00:34:11,889
>> 因此，另一種方式來寫4的階乘
就是寫這個。

707
00:34:11,889 --> 00:34:16,780

708
00:34:16,780 --> 00:34:19,022
4次3的階乘。

709
00:34:19,022 --> 00:34:22,080
因為3是階乘
3倍2倍1。

710
00:34:22,080 --> 00:34:27,580
所以，4次3因子為4
倍3倍2倍1。

711
00:34:27,580 --> 00:34:32,679
這就是為什麼階乘是一個偉大的
候選人遞歸，因為它是

712
00:34:32,679 --> 00:34:36,630
顯然，有一些東西，
發生一遍又一遍又一遍的

713
00:34:36,630 --> 00:34:39,820
更小的一些事情，直到
你到達終點。

714
00:34:39,820 --> 00:34:42,570
當你達到1,1的階乘為1。

715
00:34:42,570 --> 00:34:43,719
你不能走得更遠。

716
00:34:43,719 --> 00:34:47,219
0階乘也被定義為1。

717
00:34:47,219 --> 00:34:50,679
所以，當你到達1或0，你
在最後，你可以

718
00:34:50,679 --> 00:34:53,219
就回去了。

719
00:34:53,219 --> 00:34:59,540
因此，如果我們想寫一個遞歸
函數來計算階乘，

720
00:34:59,540 --> 00:35:02,170
我們將編寫一些
偽不動了。

721
00:35:02,170 --> 00:35:03,300
在我們寫的偽代碼 - 

722
00:35:03,300 --> 00:35:05,660
我給你們一，兩分鐘
寫的偽代碼或者只是想

723
00:35:05,660 --> 00:35:09,600
它 - 有兩件事情每
遞歸函數需要。

724
00:35:09,600 --> 00:35:12,530
什麼是這兩件事情？

725
00:35:12,530 --> 00:35:13,220
>> 傑克：它調用自身。

726
00:35:13,220 --> 00:35:13,680
>> JASON HIRSCHHORN：諾亞？

727
00:35:13,680 --> 00:35:14,460
噢，傑克。

728
00:35:14,460 --> 00:35:15,100
來吧。

729
00:35:15,100 --> 00:35:16,640
>> 傑克：它調用自身。

730
00:35:16,640 --> 00:35:19,220
>> JASON HIRSCHHORN：所以遞歸
函數需要一個遞歸調用，

731
00:35:19,220 --> 00:35:20,220
打電話給自己。

732
00:35:20,220 --> 00:35:20,770
這是一。

733
00:35:20,770 --> 00:35:21,510
這有什麼其他的事情？

734
00:35:21,510 --> 00:35:22,250
>> 傑克：一個基本情況。

735
00:35:22,250 --> 00:35:23,780
>> JASON HIRSCHHORN：一個基本情況。

736
00:35:23,780 --> 00:35:26,940
一個基本的情況是，當我們停在這裡的。

737
00:35:26,940 --> 00:35:29,510
所以，你的函數被調用。

738
00:35:29,510 --> 00:35:31,410
基本情況是第一位的。

739
00:35:31,410 --> 00:35:33,710
你要知道，如果你在最後。

740
00:35:33,710 --> 00:35:37,110
如果你不是在結束時，你
讓你的遞歸調用。

741
00:35:37,110 --> 00:35:39,880
和你又來了通過這個功能，
再次檢查你的基本情況。

742
00:35:39,880 --> 00:35:42,575
如果你還沒結束，你做
另一個遞歸調用，

743
00:35:42,575 --> 00:35:44,130
等等，等等。

744
00:35:44,130 --> 00:35:47,110
>> 這就是為什麼遞歸函數總是
需要這些基礎情況和那些

745
00:35:47,110 --> 00:35:48,210
遞歸調用。

746
00:35:48,210 --> 00:35:51,280
如果你沒有一個遞歸調用，它
不會是一個遞歸函數。

747
00:35:51,280 --> 00:35:53,210
如果你沒有一個基本情況，
如果你想走到永遠

748
00:35:53,210 --> 00:35:54,780
不會有什麼結局。

749
00:35:54,780 --> 00:35:57,870
和基本情況永遠是第一位，
因為你永遠要檢查

750
00:35:57,870 --> 00:36:00,420
如果你在結束第一。

751
00:36:00,420 --> 00:36:04,770
所以在我們做一些偽代碼，為什麼
你不花一分鐘思考

752
00:36:04,770 --> 00:36:09,360
如何遞歸階乘函數
會寫的？

753
00:36:09,360 --> 00:36:23,340

754
00:36:23,340 --> 00:36:26,010
>> 此外，多達你在做什麼，寫
它列於一張紙是

755
00:36:26,010 --> 00:36:27,960
你要什麼有
做測驗的明天。

756
00:36:27,960 --> 00:36:32,160
所以大概好的做法，使
確保你寫的代碼

757
00:36:32,160 --> 00:36:34,420
倒在紙上 - 

758
00:36:34,420 --> 00:36:35,160
或者你可以做到這一點。

759
00:36:35,160 --> 00:36:36,710
你知道哪裡有分號。

760
00:36:36,710 --> 00:36:37,660
你還記得的語法。

761
00:36:37,660 --> 00:36:40,400
因為你不能夠有一個
編譯器告訴你犯了一個錯誤。

762
00:36:40,400 --> 00:37:02,356

763
00:37:02,356 --> 00:37:07,240
>> 此外，沿著這些線路，明天，當
您已編碼的問題，如果你

764
00:37:07,240 --> 00:37:11,490
都衝了時間，或者如果你是非常
困惑，如何你應該

765
00:37:11,490 --> 00:37:16,030
寫特別的事情在C，它
會理所當然你寫的偽代碼

766
00:37:16,030 --> 00:37:18,160
或寫評論為好。

767
00:37:18,160 --> 00:37:21,940
因為有一部份信貸
很多對測驗的問題。

768
00:37:21,940 --> 00:37:24,840
所以，你可能操之過急，否則你
可能只是混淆。

769
00:37:24,840 --> 00:37:28,030
寫在註釋或偽代碼
通常的方式，你

770
00:37:28,030 --> 00:37:29,360
可以得到部分分數。

771
00:37:29,360 --> 00:37:31,440
>> 所以，不要留下遺憾
在測驗的空白。

772
00:37:31,440 --> 00:37:33,490
有沒有處罰
把東西英寸

773
00:37:33,490 --> 00:37:37,650
實際上，投入在偽碼或
意見是要幫助的平地機

774
00:37:37,650 --> 00:37:40,410
搞清楚，如果你真的知道什麼
你在說什麼，或許大獎

775
00:37:40,410 --> 00:37:42,030
你為一些局部的信用。

776
00:37:42,030 --> 00:37:44,510
>> 還沿著這些線路，寫清楚。

777
00:37:44,510 --> 00:37:47,650
如果我們真的不能你寫的東西，
我們不會給你打電話

778
00:37:47,650 --> 00:37:49,900
在明天午​​夜圖
出你寫什麼。

779
00:37:49,900 --> 00:37:51,520
我們只是要起飛點。

780
00:37:51,520 --> 00:37:56,570
寫清楚，以便我們能聽到，或者更確切地說，
我們可以讀你寫的。

781
00:37:56,570 --> 00:38:00,230
>> 如果它說兩句話，
不寫的一段話。

782
00:38:00,230 --> 00:38:02,280
按照說明進行操作。

783
00:38:02,280 --> 00:38:03,500
寫清楚。

784
00:38:03,500 --> 00:38:07,720
寫這些意見或
偽代碼的問題，可能

785
00:38:07,720 --> 00:38:10,270
獎勵部分信貸。

786
00:38:10,270 --> 00:38:12,520
>> 好了，讓我們去階乘。

787
00:38:12,520 --> 00:38:15,000
所以我們有一個函數階乘。

788
00:38:15,000 --> 00:38:18,400

789
00:38:18,400 --> 00:38:21,550
如果我真正寫在C，
我需要什麼名字前放

790
00:38:21,550 --> 00:38:22,800
函數？

791
00:38:22,800 --> 00:38:24,880

792
00:38:24,880 --> 00:38:30,060
返回類型，其中，在該
情況下，我們會給它詮釋。

793
00:38:30,060 --> 00:38:35,450
然後在大括號內，是
善有善報花括號內為

794
00:38:35,450 --> 00:38:36,850
一個函數？

795
00:38:36,850 --> 00:38:37,950
>> 學生：參數類型。

796
00:38:37,950 --> 00:38:39,150
>> JASON HIRSCHHORN：它的參數。

797
00:38:39,150 --> 00:38:42,680
所以階乘大概會
帶參數。

798
00:38:42,680 --> 00:38:44,500
它很可能只需要一個參數。

799
00:38:44,500 --> 00:38:49,450
我們會說這會帶
一個整數名為x。

800
00:38:49,450 --> 00:38:52,770
再次，寫的原型時，
一個功能或記錄的功能

801
00:38:52,770 --> 00:38:57,110
在定義它，你在你的代碼
寫的數據類型和名稱

802
00:38:57,110 --> 00:39:01,370
該變量的函數只。

803
00:39:01,370 --> 00:39:06,350
所以，你可以通過一些數字到這個
功能，它會被稱為X

804
00:39:06,350 --> 00:39:07,340
在內部。

805
00:39:07,340 --> 00:39:08,755
>> 我們有我們的階乘函數。

806
00:39:08,755 --> 00:39:12,030

807
00:39:12,030 --> 00:39:15,850
我們需要兩個東西，一個基本情況
和遞歸調用。

808
00:39:15,850 --> 00:39:20,900
是什麼樣的基本情況進行階乘？

809
00:39:20,900 --> 00:39:24,850
有人誰寫出來誰沒有
講的是，什麼是基礎

810
00:39:24,850 --> 00:39:26,100
案例階乘？

811
00:39:26,100 --> 00:39:28,400

812
00:39:28,400 --> 00:39:30,930
>> 學生：如果n小於
大於2，則返回1。

813
00:39:30,930 --> 00:39:33,520
>> JASON HIRSCHHORN：如果n
小於2，則返回1。

814
00:39:33,520 --> 00:39:37,216
我喜歡這樣，因為這
取0和1的照顧。

815
00:39:37,216 --> 00:39:45,290
所以我們會先去做x <2，則返回1。

816
00:39:45,290 --> 00:39:47,870
如果獲得通過0，如果我們得到
通過1，此功能將

817
00:39:47,870 --> 00:39:49,790
立即返回1。

818
00:39:49,790 --> 00:39:54,020
如果我們通過一些數量較大的
大於或等於2，我們要

819
00:39:54,020 --> 00:39:55,370
有我們的遞歸調用。

820
00:39:55,370 --> 00:39:57,855
>> 所以這是怎麼去上班？

821
00:39:57,855 --> 00:40:01,070
可別人誰曾在此
誰一直沒有發言，給我的

822
00:40:01,070 --> 00:40:07,380
遞歸調用此函數
在偽代碼？

823
00:40:07,380 --> 00:40:10,770
如果我們傳遞一個數x
而且它大於2，什麼

824
00:40:10,770 --> 00:40:13,370
我們想幹什麼？

825
00:40:13,370 --> 00:40:17,930
我們也有一個例子寫在
一面，可能會給你一個提示。

826
00:40:17,930 --> 00:40:20,770
>> 學生：調用x次的
x的減1階乘？

827
00:40:20,770 --> 00:40:22,020
>> JASON HIRSCHHORN：完全正確。

828
00:40:22,020 --> 00:40:24,610

829
00:40:24,610 --> 00:40:37,750
我們要返回x次
的X減去1的階乘。

830
00:40:37,750 --> 00:40:41,810
而且，即使我寫了，
基本上，你用英語說的話，

831
00:40:41,810 --> 00:40:44,580
這個階乘函數
將得到再次調用。

832
00:40:44,580 --> 00:40:46,320
這將X減1上執行。

833
00:40:46,320 --> 00:40:49,320
它會返回一些整數，
然後它會乘這兩個

834
00:40:49,320 --> 00:40:52,050
在一起，並且該值將是
回到什麼叫這個

835
00:40:52,050 --> 00:40:55,010
階乘函數，這可能
是的另一個實例

836
00:40:55,010 --> 00:40:58,420
這個階乘函數。

837
00:40:58,420 --> 00:41:01,360
>> 所以這是一個遞歸的一個例子
功能，一個非常

838
00:41:01,360 --> 00:41:02,530
簡單的遞歸函數。

839
00:41:02,530 --> 00:41:04,530
但他們大多會是這樣。

840
00:41:04,530 --> 00:41:11,170
如果你想一個很好的遞歸
為競猜挑戰，嘗試編碼

841
00:41:11,170 --> 00:41:13,230
二進制搜索遞歸。

842
00:41:13,230 --> 00:41:18,950
因為如果你做二進制搜索
問題設定了三個，你可能做到了

843
00:41:18,950 --> 00:41:21,730
反复在一個while循環。

844
00:41:21,730 --> 00:41:23,700
>> 但它也可以寫成
遞歸。

845
00:41:23,700 --> 00:41:26,310
你將需要寫你自己的
單獨的函數，需要一些

846
00:41:26,310 --> 00:41:29,020
不同的命令行參數 - 或
沒有命令行參數，一些

847
00:41:29,020 --> 00:41:30,910
不同的只是普通的論點。

848
00:41:30,910 --> 00:41:33,870
但你可以寫二進制搜索
遞歸地為好。

849
00:41:33,870 --> 00:41:36,190
>> 學生：所以你可能也寫，
代替X減1，則

850
00:41:36,190 --> 00:41:39,502
本來也寫X減
減號，或者你可以有

851
00:41:39,502 --> 00:41:40,830
書面減減x。

852
00:41:40,830 --> 00:41:44,740
你可以解釋得真快，為什麼
這些將是不同的東西，

853
00:41:44,740 --> 00:41:49,510
喜歡的區別是什麼之間
X減減和減減x？

854
00:41:49,510 --> 00:41:51,320
>> JASON HIRSCHHORN：不，我不
要進入那個。

855
00:41:51,320 --> 00:41:55,500
不過，我以後會和你談談這件事
類。 X減，減，減減x

856
00:41:55,500 --> 00:41:57,780
由1減小量X。

857
00:41:57,780 --> 00:41:59,090
但他們這樣做有點不同。

858
00:41:59,090 --> 00:42:00,340
但我不想去考慮這樣做。

859
00:42:00,340 --> 00:42:04,330

860
00:42:04,330 --> 00:42:09,090
關於遞歸其他問題
或者這個功能呢？

861
00:42:09,090 --> 00:42:10,140
這不是真的連偽代碼。

862
00:42:10,140 --> 00:42:15,060
這基本上是在代碼
c您會寫這個。

863
00:42:15,060 --> 00:42:19,393
>> 好了，其他問題
的話題在這裡？

864
00:42:19,393 --> 00:42:19,864
是啊。

865
00:42:19,864 --> 00:42:23,130
>> 學生：我有一個快速的破敗
浮點和精度。

866
00:42:23,130 --> 00:42:24,260
>> JASON HIRSCHHORN：浮動
點和精度。

867
00:42:24,260 --> 00:42:26,920
可有人真的很快
給我一個破敗

868
00:42:26,920 --> 00:42:28,210
浮點和精度？

869
00:42:28,210 --> 00:42:30,420
你都必須做到這一點你
問題集，所以你的所有

870
00:42:30,420 --> 00:42:31,700
熟悉它。

871
00:42:31,700 --> 00:42:35,090
或者，也許不是所有的你。

872
00:42:35,090 --> 00:42:36,602
任何人嗎？

873
00:42:36,602 --> 00:42:39,530
給我一個開始的地方。

874
00:42:39,530 --> 00:42:40,750
浮點和精度。

875
00:42:40,750 --> 00:42:42,380
這是什麼問題？

876
00:42:42,380 --> 00:42:42,960
是。

877
00:42:42,960 --> 00:42:43,680
維多利亞？

878
00:42:43,680 --> 00:42:44,480
>> 雲妮：凡妮莎。

879
00:42:44,480 --> 00:42:45,285
>> JASON HIRSCHHORN：凡妮莎。

880
00:42:45,285 --> 00:42:45,680
抱歉。

881
00:42:45,680 --> 00:42:51,550
>> 雲妮：這裡只有有限數量的
可以表示數字

882
00:42:51,550 --> 00:42:57,930
因為你是在，在我們的
情況下，32位的系統。

883
00:42:57,930 --> 00:43:03,080
那種讓你不得不
彌補了一些數字。

884
00:43:03,080 --> 00:43:03,910
>> JASON HIRSCHHORN：所以這是
完全正確。

885
00:43:03,910 --> 00:43:08,110
有僅一定量的
可表示數字。

886
00:43:08,110 --> 00:43:11,770
如果你將兩個非常大的數字，
它可能會溢出量

887
00:43:11,770 --> 00:43:13,950
的空間，你必須代表
的整數。

888
00:43:13,950 --> 00:43:17,930
這就是為什麼有時候我們使用
長，而不是一個int長。

889
00:43:17,930 --> 00:43:19,210
有更多的空間。

890
00:43:19,210 --> 00:43:21,210
可容納一個更大的數字。

891
00:43:21,210 --> 00:43:24,310
>> 浮點精度，是因為有
這一點，但也有做的

892
00:43:24,310 --> 00:43:29,300
事實是十進制數是
並不總是代表。

893
00:43:29,300 --> 00:43:29,540
抱歉。

894
00:43:29,540 --> 00:43:31,280
讓我把這個備份。

895
00:43:31,280 --> 00:43:36,610
十進制數1.0並不總是
代表像你所期望的，

896
00:43:36,610 --> 00:43:40,770
1.000000000。

897
00:43:40,770 --> 00:43:50,360
它有時被表示為
1.000000001或0.999999999。

898
00:43:50,360 --> 00:43:52,780
它可能是89甚至拋出
在那裡的某個地方。

899
00:43:52,780 --> 00:43:56,560
因此，這些十進制數字是不
代表酷似你會

900
00:43:56,560 --> 00:43:58,430
希望他們能來表示。

901
00:43:58,430 --> 00:44:00,010
>> 所以在問題設置 - 

902
00:44:00,010 --> 00:44:00,860
是兩份？ - 

903
00:44:00,860 --> 00:44:05,290
問題設置兩個，在這裡我們處理
浮點數，當我們想

904
00:44:05,290 --> 00:44:08,690
他們表示正是我們想要的
他們表示，數

905
00:44:08,690 --> 00:44:12,860
便士，或仙的數量，
我們用100乘以它們。

906
00:44:12,860 --> 00:44:14,750
我們繞過他們。

907
00:44:14,750 --> 00:44:18,660
然後，我們切斷了​​一切
後面的小數點。

908
00:44:18,660 --> 00:44:22,020
這是為了確保他們
實際上等於正是我們想要的

909
00:44:22,020 --> 00:44:22,410
他們相等。

910
00:44:22,410 --> 00:44:26,870
>> 因為當你把東西的
一個float和把它變成一個int，你

911
00:44:26,870 --> 00:44:29,860
切斷一切的權利
的小數點。

912
00:44:29,860 --> 00:44:33,900
因為有一些浮點
不精確，100.000可能是

913
00:44:33,900 --> 00:44:37,440
表示為99.999999999。

914
00:44:37,440 --> 00:44:40,350
如果你只是切斷了一切
右邊向右走，你要

915
00:44:40,350 --> 00:44:41,600
得到錯誤的號碼。

916
00:44:41,600 --> 00:44:44,050

917
00:44:44,050 --> 00:44:44,180
是啊。

918
00:44:44,180 --> 00:44:45,290
>> 學生：我有一個問題
有關轉換。

919
00:44:45,290 --> 00:44:47,500
什麼為了它發生在？

920
00:44:47,500 --> 00:44:54,480
如果你願意做浮動，支架，1分
10，它做1除以10，

921
00:44:54,480 --> 00:44:58,910
然後得到0.1，然後打開
它變成一個浮動？

922
00:44:58,910 --> 00:45:01,470
>> JASON HIRSCHHORN：如果你這樣做
浮動1除以10  - 

923
00:45:01,470 --> 00:45:02,550
>> 學生：是啊，然後等於 - 

924
00:45:02,550 --> 00:45:04,240
好了，它通常會
有它在平等的 - 

925
00:45:04,240 --> 00:45:04,690
是啊。

926
00:45:04,690 --> 00:45:06,760
你想成為一個浮動，對不對？

927
00:45:06,760 --> 00:45:12,790
>> JASON HIRSCHHORN：好了，我們要
用它來Segue公司進入搞清楚

928
00:45:12,790 --> 00:45:15,390
在這些問題的答案
通過編碼。

929
00:45:15,390 --> 00:45:18,180
因為你可能有很多的
這些細微問題，一個很好的方法

930
00:45:18,180 --> 00:45:19,100
解決這些問題是通過編碼。

931
00:45:19,100 --> 00:45:21,320
因此，我們現在要編寫這一權利，
然後我們要回去

932
00:45:21,320 --> 00:45:24,020
你的代碼有問題。

933
00:45:24,020 --> 00:45:24,950
>> 所以第一線 - 

934
00:45:24,950 --> 00:45:29,390
我不應該寫它 - 什麼是
我們要做的第一件事情，當我們

935
00:45:29,390 --> 00:45:32,250
打開gedit中一個新的文件？

936
00:45:32,250 --> 00:45:34,190
>> 學生：包括。

937
00:45:34,190 --> 00:45:35,920
>> JASON HIRSCHHORN：包括什麼？

938
00:45:35,920 --> 00:45:37,952
>> 學生：CS50庫。

939
00:45:37,952 --> 00:45:39,920
>> JASON HIRSCHHORN：確定。

940
00:45:39,920 --> 00:45:42,590
我們還應該包括哪些內容？

941
00:45:42,590 --> 00:45:46,820
我們只是要檢查發生了什麼
當你施放的東西為float。

942
00:45:46,820 --> 00:45:48,605
但是，我們需要包括，如果我們
打算寫一個C程序？

943
00:45:48,605 --> 00:45:49,300
>> 學生：標準I / O。

944
00:45:49,300 --> 00:45:50,625
>> JASON HIRSCHHORN：stdio.h中。

945
00:45:50,625 --> 00:45:54,880
我們其實並不需要，這
程序，cs50.h，即使它的

946
00:45:54,880 --> 00:45:55,920
總是有幫助的，包括它。

947
00:45:55,920 --> 00:45:58,260
但我們總是需要stdio.h中。

948
00:45:58,260 --> 00:45:59,660
>> 學生：C語言編碼什麼時候？

949
00:45:59,660 --> 00:46:15,770
>> JASON HIRSCHHORN：在C編碼時

950
00:46:15,770 --> 00:46:17,090
>> 所以我將它保存為這個c文件。

951
00:46:17,090 --> 00:46:18,590
我得到了一些不錯的語法高亮。

952
00:46:18,590 --> 00:46:22,890
我裡面主要寫無效。

953
00:46:22,890 --> 00:46:24,792
什麼是無效的呢？

954
00:46:24,792 --> 00:46:26,740
>> 學生：不採取任何
命令行參數。

955
00:46:26,740 --> 00:46:28,900
>> JASON HIRSCHHORN：虛空的手段，在這
情況下，主並沒有採取任何

956
00:46:28,900 --> 00:46:29,700
命令行參數。

957
00:46:29,700 --> 00:46:32,720
在其他情況下，表示該功能
並不需要命令行參數。

958
00:46:32,720 --> 00:46:36,560
或者函數，如果我是寫無效
主要（無效），這可以說主要的

959
00:46:36,560 --> 00:46:38,460
不返回任何東西。

960
00:46:38,460 --> 00:46:39,960
因此作廢只是意味著什麼。

961
00:46:39,960 --> 00:46:42,510
我會怎麼寫，如果我是
採取命令行參數？

962
00:46:42,510 --> 00:46:45,250

963
00:46:45,250 --> 00:46:47,150
>> 學生：詮釋圓弧C字符串弧訴

964
00:46:47,150 --> 00:46:49,055
>> JASON HIRSCHHORN：INT
ARGC ARGV字符串。

965
00:46:49,055 --> 00:46:54,050

966
00:46:54,050 --> 00:46:55,572
是這樣嗎？

967
00:46:55,572 --> 00:46:58,720
>> 學生：這是字符星級argv的括號內。

968
00:46:58,720 --> 00:47:01,730
>> JASON HIRSCHHORN：所以你可以寫
字符串argv的括號或char星級的argv

969
00:47:01,730 --> 00:47:03,710
括號，但你需要的括號內。

970
00:47:03,710 --> 00:47:06,290
因為argv是一個數組
字符串，切記。

971
00:47:06,290 --> 00:47:07,360
這不只是一個字符串。

972
00:47:07,360 --> 00:47:10,350
所以字符串argv是，這裡的
一根弦稱為argv的。

973
00:47:10,350 --> 00:47:13,630
字符串argv的括號是，這裡的
一個字符串數組。

974
00:47:13,630 --> 00:47:17,865
所以整型的argc字符串argv的支架
會是什麼，我

975
00:47:17,865 --> 00:47:18,810
可能會寫。

976
00:47:18,810 --> 00:47:23,050
>> 所以，你想保存一個整數？

977
00:47:23,050 --> 00:47:24,285
>> 學生：是啊，整數。

978
00:47:24,285 --> 00:47:25,840
或者在浮動。

979
00:47:25,840 --> 00:47:26,710
>> JASON HIRSCHHORN：在一個浮動？

980
00:47:26,710 --> 00:47:30,790
像，浮x等於1除以10。

981
00:47:30,790 --> 00:47:32,040
>> JASON HIRSCHHORN：確定。

982
00:47:32,040 --> 00:47:40,160

983
00:47:40,160 --> 00:47:42,240
printf中如何打印出一個浮動？

984
00:47:42,240 --> 00:47:45,100

985
00:47:45,100 --> 00:47:46,714
什麼？

986
00:47:46,714 --> 00:47:47,560
>> 學生：％F。

987
00:47:47,560 --> 00:47:48,300
>> JASON HIRSCHHORN：％F。

988
00:47:48,300 --> 00:47:50,810
什麼是整數？

989
00:47:50,810 --> 00:47:52,110
d或我。

990
00:47:52,110 --> 00:47:53,000
什麼是字符串？

991
00:47:53,000 --> 00:47:54,240
>> 學生：秒。

992
00:47:54,240 --> 00:47:56,140
>> JASON HIRSCHHORN：秒。

993
00:47:56,140 --> 00:47:57,550
我如何獲得一個新行？

994
00:47:57,550 --> 00:47:58,800
>> 學生：反斜杠ñ。

995
00:47:58,800 --> 00:48:04,610

996
00:48:04,610 --> 00:48:07,100
>> JASON HIRSCHHORN：我該怎麼回
如果主要的運行是否正確？

997
00:48:07,100 --> 00:48:08,360
>> 學生：0。

998
00:48:08,360 --> 00:48:09,430
我是否需要寫該行有關係嗎？

999
00:48:09,430 --> 00:48:10,170
>> 學生：

1000
00:48:10,170 --> 00:48:11,513
OK，我們不會寫它，然後。

1001
00:48:11,513 --> 00:48:16,450

1002
00:48:16,450 --> 00:48:17,190
每個人都可以讀嗎？

1003
00:48:17,190 --> 00:48:18,485
它看起來有點小。

1004
00:48:18,485 --> 00:48:20,160
大家可以看到，還是應該
我使它更大？

1005
00:48:20,160 --> 00:48:23,480

1006
00:48:23,480 --> 00:48:25,100
我覺得對於攝像頭，我們會做
它有點大，雖然。

1007
00:48:25,100 --> 00:48:35,750

1008
00:48:35,750 --> 00:48:38,410
>> JASON HIRSCHHORN：如果我想關閉這個
c文件為可執行文件，有什麼

1009
00:48:38,410 --> 00:48:39,260
我寫？

1010
00:48:39,260 --> 00:48:41,610
>> 學生：做測試。

1011
00:48:41,610 --> 00:48:42,080
>> JASON HIRSCHHORN：對不起？

1012
00:48:42,080 --> 00:48:42,790
>> 學生：做測試。

1013
00:48:42,790 --> 00:48:44,040
>> JASON HIRSCHHORN：請測試。

1014
00:48:44,040 --> 00:48:46,700

1015
00:48:46,700 --> 00:48:48,410
我們都在談論
這條線前面。

1016
00:48:48,410 --> 00:48:49,140
鐺。

1017
00:48:49,140 --> 00:48:51,270
什麼是鐺？

1018
00:48:51,270 --> 00:48:52,200
編譯器的名稱。

1019
00:48:52,200 --> 00:48:53,920
這是什麼線？

1020
00:48:53,920 --> 00:48:55,580
>> 學生：設置它為使用gdb的。

1021
00:48:55,580 --> 00:48:59,230
>> JASON HIRSCHHORN：集
它使用的GDB。

1022
00:48:59,230 --> 00:49:02,338
這條線，那是什麼？

1023
00:49:02,338 --> 00:49:03,290
>> 學生：源代碼。

1024
00:49:03,290 --> 00:49:06,010
>> JASON HIRSCHHORN：這就是
源文件，c文件。

1025
00:49:06,010 --> 00:49:08,150
什麼這兩行嗎？

1026
00:49:08,150 --> 00:49:10,245
或者這兩個不是行。

1027
00:49:10,245 --> 00:49:12,300
>> 學生：它的名字來測試。

1028
00:49:12,300 --> 00:49:15,410
>> JASON HIRSCHHORN：所以破折號ø說，
不同命名的東西。

1029
00:49:15,410 --> 00:49:16,790
在這裡，你調用它的測試。

1030
00:49:16,790 --> 00:49:18,900
如果我沒有在，
那會是什麼名字呢？

1031
00:49:18,900 --> 00:49:20,260
>> 學生：為a.out。

1032
00:49:20,260 --> 00:49:22,340
>> JASON HIRSCHHORN：為a.out。

1033
00:49:22,340 --> 00:49:25,366
這是什麼呢？

1034
00:49:25,366 --> 00:49:27,670
>> 學生：友情鏈接數學庫。

1035
00:49:27,670 --> 00:49:29,550
>> JASON HIRSCHHORN：它鏈接
在數學庫。

1036
00:49:29,550 --> 00:49:32,880
我們沒有包括數學庫，但
因為這是如此普遍，他們已經

1037
00:49:32,880 --> 00:49:35,780
寫make來總是包括
數學庫。

1038
00:49:35,780 --> 00:49:39,050
同樣地，這包括
在CS50庫。

1039
00:49:39,050 --> 00:49:43,010
>> 好了，如果我們列出，我們現在有
可執行文件名為test。

1040
00:49:43,010 --> 00:49:45,150
為了執行它，我寫的測試。

1041
00:49:45,150 --> 00:49:48,330
我看到我的浮點運算，
正如所料，等於0。

1042
00:49:48,330 --> 00:49:50,890

1043
00:49:50,890 --> 00:49:51,590
這是否 - 

1044
00:49:51,590 --> 00:49:52,060
所以 - 

1045
00:49:52,060 --> 00:49:55,210
>> 學生：那麼，如果你把現在浮動，
就像你將其轉換為浮動 - 

1046
00:49:55,210 --> 00:49:56,870
>> JASON HIRSCHHORN：鑄鐵
1為float？

1047
00:49:56,870 --> 00:49:59,180
>> 學生：不，投滿的事情 - 

1048
00:49:59,180 --> 00:49:59,500
是的。

1049
00:49:59,500 --> 00:50:02,460
如果你只是這樣做，會
這使它0.1？

1050
00:50:02,460 --> 00:50:07,170
>> JASON HIRSCHHORN：好了，真的很快，
1除以10，這些都是

1051
00:50:07,170 --> 00:50:08,690
整數被分割。

1052
00:50:08,690 --> 00:50:13,580
所以，當你劃分整數，它們是
0，而你節省了0的

1053
00:50:13,580 --> 00:50:17,170
浮動，因為斜線
只是整數除法。

1054
00:50:17,170 --> 00:50:19,180
所以，現在我們正在轉彎的東西
成浮動。

1055
00:50:19,180 --> 00:50:21,650
>> 讓我們看看會發生什麼。

1056
00:50:21,650 --> 00:50:22,900
我們會讓測試。

1057
00:50:22,900 --> 00:50:25,870

1058
00:50:25,870 --> 00:50:31,090
所以，現在我們看到的斜線不
整數除法，它是浮動的

1059
00:50:31,090 --> 00:50:32,640
分點。

1060
00:50:32,640 --> 00:50:35,700
因為它的參數之一
已被轉換為一個浮點數。

1061
00:50:35,700 --> 00:50:38,380
所以，現在有人說，對待這個
師像我們正在處理

1062
00:50:38,380 --> 00:50:40,140
浮動點，不帶整數。

1063
00:50:40,140 --> 00:50:42,760
所以我們得到我們期望的答案。

1064
00:50:42,760 --> 00:50:44,620
>> 讓我們看看會發生什麼 - 

1065
00:50:44,620 --> 00:50:47,103
哎呀。

1066
00:50:47,103 --> 00:50:51,646
如果我想打印更十進制
點，我怎麼能這樣做呢？

1067
00:50:51,646 --> 00:50:55,550
>> 學生：點圓點f或盡可能多的
只要你想的小數位數。

1068
00:50:55,550 --> 00:51:02,280

1069
00:51:02,280 --> 00:51:04,440
>> JASON HIRSCHHORN：所以我打印
10進制的斑點。

1070
00:51:04,440 --> 00:51:06,610
而我們現在看到我們越來越
一些怪異的東西。

1071
00:51:06,610 --> 00:51:09,650
而這又回到你的問題
關於浮點不精確。

1072
00:51:09,650 --> 00:51:10,950
有奇怪的東西存放在這裡。

1073
00:51:10,950 --> 00:51:13,650

1074
00:51:13,650 --> 00:51:15,275
>> 好了，這是否回答你的問題？

1075
00:51:15,275 --> 00:51:18,550

1076
00:51:18,550 --> 00:51:20,200
你想要什麼
快速代碼？

1077
00:51:20,200 --> 00:51:25,470
>> 學生：我只是想看看是否
不，如果你釋放了一些指針，

1078
00:51:25,470 --> 00:51:30,410
該指針是否仍然存儲在
它是什麼它一直是地址

1079
00:51:30,410 --> 00:51:32,170
指著前面。

1080
00:51:32,170 --> 00:51:34,100
>> JASON HIRSCHHORN：OK，
所以讓我們做到這一點。

1081
00:51:34,100 --> 00:51:38,030
字符明星PTR，這將創建一個變量
所謂PTR char類型的明星。

1082
00:51:38,030 --> 00:51:39,280
我怎樣寫的malloc？

1083
00:51:39,280 --> 00:51:40,550
奧爾登？

1084
00:51:40,550 --> 00:51:41,800
>> 奧爾登：只是malloc的。

1085
00:51:41,800 --> 00:51:44,820

1086
00:51:44,820 --> 00:51:51,040
但隨後它必須的尺寸，並
在這種情況下，我想你會

1087
00:51:51,040 --> 00:51:52,465
是指向字符。

1088
00:51:52,465 --> 00:51:54,450
所以它會是char。

1089
00:51:54,450 --> 00:51:57,520
>> JASON HIRSCHHORN：OK，所以更
一般地，內幕 - 

1090
00:51:57,520 --> 00:51:58,770
讓我們編輯。

1091
00:51:58,770 --> 00:52:05,100

1092
00:52:05,100 --> 00:52:09,260
裡面的malloc，你要的號碼
字節的堆。

1093
00:52:09,260 --> 00:52:12,320
一般情況下，我們所看到的，我們是
做的是我們要去用malloc

1094
00:52:12,320 --> 00:52:14,940
字符串，例如，或
整數的數組。

1095
00:52:14,940 --> 00:52:21,600
因此，如果我們想要10的整數，或10
字符，10會給我們10。

1096
00:52:21,600 --> 00:52:24,370
然後字符的大小會給
我們說，字符大小，這在

1097
00:52:24,370 --> 00:52:25,120
這種情況下，是1個字節。

1098
00:52:25,120 --> 00:52:26,250
我們得到了10個字節​​。

1099
00:52:26,250 --> 00:52:28,540
如果我們寫為int的大小，
這會給我們40字節。

1100
00:52:28,540 --> 00:52:31,520
>> 所以更一般地，malloc的內部
是你想要的字節數。

1101
00:52:31,520 --> 00:52:34,620
在這種情況下，我們得到1個字節。

1102
00:52:34,620 --> 00:52:36,900
這似乎是一個奇怪的運用
malloc的，但對於我們的

1103
00:52:36,900 --> 00:52:38,470
目的是有道理的。

1104
00:52:38,470 --> 00:52:40,420
因此，有一點。

1105
00:52:40,420 --> 00:52:43,420
>> 我們要調用free。

1106
00:52:43,420 --> 00:52:47,040
我們擺脫它，我們再次使用PTR。

1107
00:52:47,040 --> 00:52:48,750
和你想要什麼檢查？

1108
00:52:48,750 --> 00:52:50,550
>> 學生：我只是想檢查是否
或不存在是什麼，

1109
00:52:50,550 --> 00:52:51,900
裡面的它。

1110
00:52:51,900 --> 00:52:53,050
>> JASON HIRSCHHORN：所以，無論
它指出了什麼？

1111
00:52:53,050 --> 00:52:57,740
>> 學生：是的，沒錯，無論是
它仍然有一個存儲器地址。

1112
00:52:57,740 --> 00:53:02,220
>> JASON HIRSCHHORN：所以，你想要
檢查ptr的值？

1113
00:53:02,220 --> 00:53:03,470
>> 學生：是的，沒錯。

1114
00:53:03,470 --> 00:53:07,940

1115
00:53:07,940 --> 00:53:10,160
>> JASON HIRSCHHORN：那我寫在這裡
如果我要檢查的價值

1116
00:53:10,160 --> 00:53:11,880
點 - 什麼是，喬丹
說，值？

1117
00:53:11,880 --> 00:53:13,720
或者什麼是存儲PTR裡面？

1118
00:53:13,720 --> 00:53:14,620
>> 學生：一個內存地址。

1119
00:53:14,620 --> 00:53:16,330
>> JASON HIRSCHHORN：一個內存地址。

1120
00:53:16,330 --> 00:53:20,520
所以，如果我寫的只是這一點，它會
給我ptr的值。

1121
00:53:20,520 --> 00:53:22,800
以及如何打印出
一個內存地址？

1122
00:53:22,800 --> 00:53:26,470
什麼是格式字符串
用於存儲器的地址？

1123
00:53:26,470 --> 00:53:27,430
>> 學生：％P。

1124
00:53:27,430 --> 00:53:28,050
>> JASON HIRSCHHORN：％P。

1125
00:53:28,050 --> 00:53:29,500
％s是一個字符串。

1126
00:53:29,500 --> 00:53:30,750
％P的指針。

1127
00:53:30,750 --> 00:53:40,820

1128
00:53:40,820 --> 00:53:43,540
是這樣嗎？

1129
00:53:43,540 --> 00:53:44,790
這是正確的。

1130
00:53:44,790 --> 00:53:49,450

1131
00:53:49,450 --> 00:53:51,040
所以PTR等於 - 

1132
00:53:51,040 --> 00:53:53,350
但仍然有一些東西在裡面。

1133
00:53:53,350 --> 00:53:56,110

1134
00:53:56,110 --> 00:53:57,645
這可能是一個更
有趣的問題。

1135
00:53:57,645 --> 00:53:59,198
這是什麼線路呢？

1136
00:53:59,198 --> 00:54:00,830
>> 學生：賽格故障。

1137
00:54:00,830 --> 00:54:01,310
>> JASON HIRSCHHORN：什麼？

1138
00:54:01,310 --> 00:54:02,678
>> 學生：我覺得這賽格故障。

1139
00:54:02,678 --> 00:54:03,574
>> JASON HIRSCHHORN：嗯？

1140
00:54:03,574 --> 00:54:04,920
>> 學生：我認為它會賽格故障。

1141
00:54:04,920 --> 00:54:08,265
>> JASON HIRSCHHORN：所以這條線
的代碼，明星PTR，是什麼

1142
00:54:08,265 --> 00:54:10,152
沒有星星是什麼意思？

1143
00:54:10,152 --> 00:54:11,240
>> 學生：內容。

1144
00:54:11,240 --> 00:54:11,560
>> JASON HIRSCHHORN：是啊。

1145
00:54:11,560 --> 00:54:13,910
去得到的內容。

1146
00:54:13,910 --> 00:54:16,830
因此，這是要去記憶
有地址，並讓我說。

1147
00:54:16,830 --> 00:54:21,030
我用％C就在這裡，因為有
存儲有字符。

1148
00:54:21,030 --> 00:54:23,390
因此，我們打算去那個地址我們
剛看到 - 或者它可能會成為一個

1149
00:54:23,390 --> 00:54:25,190
稍微有點不同，這
一次，我們運行該程序。

1150
00:54:25,190 --> 00:54:28,010
但我們會去那個地址
我們知道仍然存在

1151
00:54:28,010 --> 00:54:29,260
看看那裡的東西。

1152
00:54:29,260 --> 00:54:35,640

1153
00:54:35,640 --> 00:54:37,110
>> 所以也沒賽格故障。

1154
00:54:37,110 --> 00:54:38,970
它只是沒有給我們任何東西。

1155
00:54:38,970 --> 00:54:43,350
它可能實際上已經給了我們
東西，我們不能看到它。

1156
00:54:43,350 --> 00:54:45,110
而這又回到這個想法 - 

1157
00:54:45,110 --> 00:54:47,270
並且我們不會得到太多到
這一點，因為這是超越

1158
00:54:47,270 --> 00:54:48,460
本課程的範圍。

1159
00:54:48,460 --> 00:54:51,260
但我們談到這裡吧，如果我們
超出了數組界限由

1160
00:54:51,260 --> 00:54:54,890
1，我們可能不會惹上麻煩。

1161
00:54:54,890 --> 00:54:58,550
>> 有時候，當你只是1熄滅，
你正在做的事情錯了，你

1162
00:54:58,550 --> 00:54:59,220
可能惹上麻煩。

1163
00:54:59,220 --> 00:55:00,820
但你並不總是惹上麻煩。

1164
00:55:00,820 --> 00:55:05,170
這要看怎麼是一件壞事，你得多
這樣做，你會惹上麻煩。

1165
00:55:05,170 --> 00:55:07,790
這是不是說，馬虎
與您的代碼。

1166
00:55:07,790 --> 00:55:12,080
但它說，該計劃將不會
總是跳槽，即使你去的地方

1167
00:55:12,080 --> 00:55:14,130
你不應該去。

1168
00:55:14,130 --> 00:55:18,170
>> 這方面的一個很好的例子是，很多
人們在問題設置3，其中

1169
00:55:18,170 --> 00:55:22,350
15歲，沒有檢查
董事會的界限。

1170
00:55:22,350 --> 00:55:25,860
所以，你看左邊，看向
右，看著頂端，看著

1171
00:55:25,860 --> 00:55:27,000
至底部。

1172
00:55:27,000 --> 00:55:31,540
但你沒有檢查，看看是否頂部
實際上將是在黑板上。

1173
00:55:31,540 --> 00:55:35,220
和很多人誰這樣做了，
原來，在，他們的工作程序

1174
00:55:35,220 --> 00:55:38,960
完美，因為那個地方是板
存儲在內存中，如果你走了一條

1175
00:55:38,960 --> 00:55:42,300
它上面或托運的記憶
地址，有沒有什麼

1176
00:55:42,300 --> 00:55:44,870
尤其可怕的這個，
所以你的程序是不是

1177
00:55:44,870 --> 00:55:45,970
要罵你。

1178
00:55:45,970 --> 00:55:48,870
>> 但是，我們仍然起飛點，如果
你沒有檢查，因為你

1179
00:55:48,870 --> 00:55:50,850
在做一些你不
應該做的，而你可以有

1180
00:55:50,850 --> 00:55:51,860
變得麻煩了。

1181
00:55:51,860 --> 00:55:54,040
奇怪的是，雖然你可能沒有。

1182
00:55:54,040 --> 00:55:57,790
因此，這是證明，是的，
我們仍然可以去它。

1183
00:55:57,790 --> 00:55:59,010
而我們沒有得到的
在這種情況下，麻煩。

1184
00:55:59,010 --> 00:56:04,000
如果我們試圖做閱讀
接下來的100個字，我們就

1185
00:56:04,000 --> 00:56:06,000
可能惹上麻煩。

1186
00:56:06,000 --> 00:56:09,400
而且你可以編寫讀取下一個100
字符，如果你想要做一些

1187
00:56:09,400 --> 00:56:10,110
排序的for循環。

1188
00:56:10,110 --> 00:56:10,850
是啊。

1189
00:56:10,850 --> 00:56:16,250
>> 學生：因為我們被分配了
空間的實際值，我們不會

1190
00:56:16,250 --> 00:56:17,050
居然能看到什麼。

1191
00:56:17,050 --> 00:56:21,740
我們是否應該嘗試用該設置
等於像C什麼的？

1192
00:56:21,740 --> 00:56:22,640
>> JASON HIRSCHHORN：大問題。

1193
00:56:22,640 --> 00:56:25,340
我如何設置該值 - 

1194
00:56:25,340 --> 00:56:28,980
我寫行哪一行代碼
七，你說什麼？

1195
00:56:28,980 --> 00:56:34,040
>> 學生：星PTR等於單
引用C + +期末單引號。

1196
00:56:34,040 --> 00:56:36,970
>> JASON HIRSCHHORN：所以這把
一個字符，C，在該位置，

1197
00:56:36,970 --> 00:56:40,200
因為再次，這顆恆星
意味著去那裡。

1198
00:56:40,200 --> 00:56:43,320
和左手側使用時
賦值運算符，等於

1199
00:56:43,320 --> 00:56:47,270
簽名，我們不會得到那個
值這麼多的設置值。

1200
00:56:47,270 --> 00:56:48,520
現在，讓我們看看會發生什麼。

1201
00:56:48,520 --> 00:56:54,700

1202
00:56:54,700 --> 00:56:56,770
>> 我們把那裡的東西
並且它在那裡。

1203
00:56:56,770 --> 00:56:58,000
我們所謂的自由。

1204
00:56:58,000 --> 00:57:00,100
有些東西可能發生
在堆上。

1205
00:57:00,100 --> 00:57:01,890
因此，它不存在了。

1206
00:57:01,890 --> 00:57:07,440
但同樣，我們沒有得到
在為去那裡的麻煩。

1207
00:57:07,440 --> 00:57:10,260
>> 我這樣做出來的代碼來說明
有很多這些

1208
00:57:10,260 --> 00:57:12,410
您有任何問題，他們是
真的很有趣

1209
00:57:12,410 --> 00:57:13,650
回答了很多時間。

1210
00:57:13,650 --> 00:57:15,260
而且他們真的很好的問題。

1211
00:57:15,260 --> 00:57:19,010
並且你可以計算出來的
自己如果，例如，

1212
00:57:19,010 --> 00:57:19,990
我們不是在一節。

1213
00:57:19,990 --> 00:57:20,940
是啊。

1214
00:57:20,940 --> 00:57:24,430
>> 學生：因為你沒有送
指針的任何地方，你需要

1215
00:57:24,430 --> 00:57:26,530
使用malloc？

1216
00:57:26,530 --> 00:57:28,400
>> JASON HIRSCHHORN：所以這可以追溯到
給你最初的問題。

1217
00:57:28,400 --> 00:57:28,620
[？ ？]

1218
00:57:28,620 --> 00:57:29,980
難道僅僅是一個局部變量？

1219
00:57:29,980 --> 00:57:32,280
這裡的malloc是不是引人注目。

1220
00:57:32,280 --> 00:57:35,260
在使用malloc這裡就不
那引人注目，因為它是

1221
00:57:35,260 --> 00:57:36,500
只是一個局部變量。

1222
00:57:36,500 --> 00:57:40,970
>> 學生：所以你能做到的char
明星PTR等於你好？

1223
00:57:40,970 --> 00:57:41,400
>> JASON HIRSCHHORN：哦。

1224
00:57:41,400 --> 00:57:43,300
所以，我們要拿回
給你最初的問題。

1225
00:57:43,300 --> 00:57:46,885
我覺得你不滿意
我的回答。

1226
00:57:46,885 --> 00:57:48,220
好不好？

1227
00:57:48,220 --> 00:57:49,226
喜歡嗎？

1228
00:57:49,226 --> 00:57:49,682
>> 學生：是啊。

1229
00:57:49,682 --> 00:57:50,932
等待。

1230
00:57:50,932 --> 00:57:54,090

1231
00:57:54,090 --> 00:57:57,850
>> JASON HIRSCHHORN：在哪裡
你想打印出來？

1232
00:57:57,850 --> 00:58:00,026
因此，我們將打印出一個這樣的字符串？

1233
00:58:00,026 --> 00:58:06,380

1234
00:58:06,380 --> 00:58:07,630
>> 學生：有趣。

1235
00:58:07,630 --> 00:58:09,900

1236
00:58:09,900 --> 00:58:14,285
>> JASON HIRSCHHORN：所以這個說，這
參數有一個字符的類型。

1237
00:58:14,285 --> 00:58:17,200

1238
00:58:17,200 --> 00:58:18,620
所以這應該是一個字符。

1239
00:58:18,620 --> 00:58:25,170

1240
00:58:25,170 --> 00:58:26,280
>> 學生：只需要第一個。

1241
00:58:26,280 --> 00:58:28,610
>> JASON HIRSCHHORN：所以這
就是我之前說的。

1242
00:58:28,610 --> 00:58:34,240
就像我說的，它不是存儲
字符串變量的指針裡面。

1243
00:58:34,240 --> 00:58:35,120
它的存儲 - 

1244
00:58:35,120 --> 00:58:36,350
>> 學生：第一個值
的字符串。

1245
00:58:36,350 --> 00:58:40,810
>> JASON HIRSCHHORN：的地址
字符串的第一個值。

1246
00:58:40,810 --> 00:58:46,940
如果我們要打印出這一點，我們
進入內部指針的值。

1247
00:58:46,940 --> 00:58:51,005
我們會看到它確實是，
的存儲器地址。

1248
00:58:51,005 --> 00:58:53,595

1249
00:58:53,595 --> 00:58:56,440
>> 這是否有道理？

1250
00:58:56,440 --> 00:58:56,940
抱歉。

1251
00:58:56,940 --> 00:58:58,996
等等，這是否回答你
問題有關係嗎？

1252
00:58:58,996 --> 00:58:59,790
>> 學生：是啊。

1253
00:58:59,790 --> 00:59:05,830
>> JASON HIRSCHHORN：這行代碼是
創建一個字符串，然後再

1254
00:59:05,830 --> 00:59:09,115
變量指針的指向
該字符串，數組。

1255
00:59:09,115 --> 00:59:14,320

1256
00:59:14,320 --> 00:59:14,980
是啊。

1257
00:59:14,980 --> 00:59:19,200
>> 學生：所以，如果我們去一個內存
進一步解決，我們將得到的H？

1258
00:59:19,200 --> 00:59:21,990

1259
00:59:21,990 --> 00:59:23,150
有沒有被存儲為一個字符串？

1260
00:59:23,150 --> 00:59:24,400
>> JASON HIRSCHHORN：像我們所做的 - 

1261
00:59:24,400 --> 00:59:28,540

1262
00:59:28,540 --> 00:59:30,790
所以這是有價值的事情。

1263
00:59:30,790 --> 00:59:33,780
這是第一點運算，這你們
以前見過，應該是

1264
00:59:33,780 --> 00:59:35,550
比較舒服。

1265
00:59:35,550 --> 00:59:36,905
這類似於寫 - 

1266
00:59:36,905 --> 00:59:41,980

1267
00:59:41,980 --> 00:59:46,350
如果我們寫這行代碼，
我們以前見過數組符號。

1268
00:59:46,350 --> 00:59:55,900
這應該給我們的第二個
在這個數組，H值。

1269
00:59:55,900 --> 01:00:05,010
>> 如果我們這樣做，這也應該給
我們在該數組的第二個值。

1270
01:00:05,010 --> 01:00:08,320
因為它是將不向存儲器
的第一件事地址，但

1271
01:00:08,320 --> 01:00:10,530
的事情之一，在內存地址。

1272
01:00:10,530 --> 01:00:14,360
然後恆星取消引用運算符
該指針。

1273
01:00:14,360 --> 01:00:16,940
再次，讓我們來看看。

1274
01:00:16,940 --> 01:00:18,664
我們再次拿到小時。

1275
01:00:18,664 --> 01:00:20,980
>> 學生：這到底是什麼
解引用是什麼意思？

1276
01:00:20,980 --> 01:00:23,650
>> JASON HIRSCHHORN：取消引用
是看中字去。

1277
01:00:23,650 --> 01:00:26,390
去那個並獲得那裡的東西
是取消引用指針。

1278
01:00:26,390 --> 01:00:28,240
這只是一個花哨的字的。

1279
01:00:28,240 --> 01:00:29,986
>> 學生：如果我們想打印
整個字符串，我們可以

1280
01:00:29,986 --> 01:00:31,930
做符號指針？

1281
01:00:31,930 --> 01:00:33,490
>> JASON HIRSCHHORN：OK，我們都
要在這裡暫停。

1282
01:00:33,490 --> 01:00:35,480
我們將在這裡結束。

1283
01:00:35,480 --> 01:00:41,760
符號給你一個地址
位置，所以你做的時候符號

1284
01:00:41,760 --> 01:00:44,080
一個變量，它給你的地址
其中的變量存儲。

1285
01:00:44,080 --> 01:00:48,580
符號指針會給你
PTR其中ptr是在內存中的地址。

1286
01:00:48,580 --> 01:00:50,140
>> 我們不會去
用這個例子。

1287
01:00:50,140 --> 01:00:52,640
你能弄清楚這些
自己的東西。

1288
01:00:52,640 --> 01:00:55,740
但是，這甚至可能是一個瀕臨
超越你需要知道的一點

1289
01:00:55,740 --> 01:00:58,000
這次中期的範圍 - 

1290
01:00:58,000 --> 01:00:59,070
或本測驗，而。

1291
01:00:59,070 --> 01:01:00,270
抱歉。

1292
01:01:00,270 --> 01:01:03,770
>> 我們要繼續前進，因為我會
喜歡做一個編碼問題

1293
01:01:03,770 --> 01:01:05,100
之前的時間到了。

1294
01:01:05,100 --> 01:01:09,340
而我們將要編寫什麼，我認為
是目前最引人注目的這些

1295
01:01:09,340 --> 01:01:11,020
例子，atoi的。

1296
01:01:11,020 --> 01:01:14,520
所以這是一個問題
測驗兩年前。

1297
01:01:14,520 --> 01:01:17,810
我有它的董事會這裡。

1298
01:01:17,810 --> 01:01:20,680
>> 人們被要求在測驗 - 

1299
01:01:20,680 --> 01:01:23,640
他們得到多一點tesxt在
的問題，但我消滅了

1300
01:01:23,640 --> 01:01:26,640
文本，因為它是不必要的
我們的目的了。

1301
01:01:26,640 --> 01:01:29,180
這只是一些背景
什麼是atoi一樣。

1302
01:01:29,180 --> 01:01:31,425
但大家都知道，是非常
熟悉的atoi。

1303
01:01:31,425 --> 01:01:35,620
>> 我建議你這個代碼
上一張紙。

1304
01:01:35,620 --> 01:01:39,310
我也建議你使用策略
我們已經討論了

1305
01:01:39,310 --> 01:01:41,040
很多在我們的一節。

1306
01:01:41,040 --> 01:01:44,130
首先，確保你理解
什麼是atoi的做。

1307
01:01:44,130 --> 01:01:47,580
畫一幅畫或想出一些
它在你的腦袋的精神形象。

1308
01:01:47,580 --> 01:01:51,120
接下來，寫出偽代碼這一點。

1309
01:01:51,120 --> 01:01:53,120
在測驗，如果你得到的是
偽代碼，至少你

1310
01:01:53,120 --> 01:01:54,550
裝上去了下來。

1311
01:01:54,550 --> 01:02:00,070
然後是偽代碼映射到
C.如果你有一個檢查在你的

1312
01:02:00,070 --> 01:02:03,760
偽代碼，就像檢查什麼
是1，即映射到如果一個

1313
01:02:03,760 --> 01:02:05,750
條件等等。

1314
01:02:05,750 --> 01:02:07,850
最後，代碼在C程序

1315
01:02:07,850 --> 01:02:15,000
>> 所以回去的atoi和需要五分鐘
編寫本上的紙

1316
01:02:15,000 --> 01:02:19,480
紙，這可能是關於
的時候，你會採取一個量

1317
01:02:19,480 --> 01:02:21,260
測驗代碼atoi的。

1318
01:02:21,260 --> 01:02:27,060
5至15分鐘，5至12個，5到
10分鐘後，大約的量

1319
01:02:27,060 --> 01:02:30,150
時間你會在這上面花
問題的問答。

1320
01:02:30,150 --> 01:02:31,670
因此，需要五分鐘的話，請。

1321
01:02:31,670 --> 01:02:35,957
如果您有任何問題，提高
你的手，我會回到你身邊。

1322
01:02:35,957 --> 01:06:39,570

1323
01:06:39,570 --> 01:06:41,066
>> [私下交談]

1324
01:06:41,066 --> 01:08:35,279

1325
01:08:35,279 --> 01:08:37,580
>> JASON HIRSCHHORN：好了，
那是五分鐘。

1326
01:08:37,580 --> 01:08:39,880
這是大概的金額
你最好花了一個測驗，

1327
01:08:39,880 --> 01:08:42,120
那個時候，也許低端。

1328
01:08:42,120 --> 01:08:44,010
我們將回顧一下在一個位。

1329
01:08:44,010 --> 01:08:45,740
讓我們開始編碼了。

1330
01:08:45,740 --> 01:08:49,479
如果我們沒有得到，一路過關斬將，
的答案，這個和這個

1331
01:08:49,479 --> 01:08:54,189
測驗問題的情況下，再一次，
2011年秋季是當這個問題

1332
01:08:54,189 --> 01:08:54,913
出現在測驗。

1333
01:08:54,913 --> 01:08:57,830
>> 而這是值得八個點
在測驗即可。

1334
01:08:57,830 --> 01:09:01,140
八個點是對的高端
點的東西量是值得的。

1335
01:09:01,140 --> 01:09:04,790
大多數問題都在範圍內
一到六個點。

1336
01:09:04,790 --> 01:09:08,500
所以這是一個更具挑戰性
問題是肯定的。

1337
01:09:08,500 --> 01:09:09,750
誰能讓我開始？

1338
01:09:09,750 --> 01:09:13,260

1339
01:09:13,260 --> 01:09:15,380
>> 一般情況下，究竟是為了什麼
要想做這個

1340
01:09:15,380 --> 01:09:17,550
函數atoi，邏輯？

1341
01:09:17,550 --> 01:09:19,569
我們究竟想幹什麼？

1342
01:09:19,569 --> 01:09:22,279
所以我們要編寫
一些偽代碼。

1343
01:09:22,279 --> 01:09:24,090
>> 學生：轉換字符
成整數。

1344
01:09:24,090 --> 01:09:26,700
>> JASON HIRSCHHORN：轉換字符
成整數。

1345
01:09:26,700 --> 01:09:27,479
確定。

1346
01:09:27,479 --> 01:09:30,870
那麼多少個字，我們都
將需要辦理什麼手續？

1347
01:09:30,870 --> 01:09:32,295
>> 學生：他們全部。

1348
01:09:32,295 --> 01:09:34,100
>> 學生：所有人物
在字符串中。

1349
01:09:34,100 --> 01:09:35,540
>> JASON HIRSCHHORN：所有
字符的字符串。

1350
01:09:35,540 --> 01:09:42,180
因此，如果我們想要去通過每一個
字符的字符串，是什麼東西

1351
01:09:42,180 --> 01:09:44,560
C語言，我們已經看到，已經允許
我們走過的每

1352
01:09:44,560 --> 01:09:45,939
字符在一個字符串？

1353
01:09:45,939 --> 01:09:46,819
>> 學生：一個for循環。

1354
01:09:46,819 --> 01:09:48,069
>> JASON HIRSCHHORN：一個for循環。

1355
01:09:48,069 --> 01:09:52,020

1356
01:09:52,020 --> 01:09:55,330
因此，我們通過將循環
每個字符s中。

1357
01:09:55,330 --> 01:10:00,940
>> 那麼什麼是我們要想做
當我們得到一個特定的字符？

1358
01:10:00,940 --> 01:10:02,480
說我們就要過去了90。

1359
01:10:02,480 --> 01:10:03,460
我們得到了9。

1360
01:10:03,460 --> 01:10:04,240
這是一個字符。

1361
01:10:04,240 --> 01:10:07,440
什麼是我們想要做的
該字符9？

1362
01:10:07,440 --> 01:10:10,082
>> 學生：從字符0中減去了嗎？

1363
01:10:10,082 --> 01:10:11,860
>> 學生：加0？

1364
01:10:11,860 --> 01:10:13,350
>> JASON HIRSCHHORN：減去
它從字符0？

1365
01:10:13,350 --> 01:10:13,800
>> 學生：是啊。

1366
01:10:13,800 --> 01:10:15,573
>> JASON HIRSCHHORN：為什麼
你想這樣做？

1367
01:10:15,573 --> 01:10:16,560
>> 學生：[聽不清]

1368
01:10:16,560 --> 01:10:17,010
值。

1369
01:10:17,010 --> 01:10:18,380
它的int值。

1370
01:10:18,380 --> 01:10:21,580
>> JASON HIRSCHHORN：好了，我們走
字符9，從它減去

1371
01:10:21,580 --> 01:10:25,820
字符0得到一個
實際整數9。

1372
01:10:25,820 --> 01:10:27,070
甜蜜。

1373
01:10:27,070 --> 01:10:31,255

1374
01:10:31,255 --> 01:10:37,000
你怎麼知道字符
9負0字符是9？

1375
01:10:37,000 --> 01:10:39,222
你看什麼圖？

1376
01:10:39,222 --> 01:10:43,130
>> 學生：有邏輯上9
在9和0的地方。

1377
01:10:43,130 --> 01:10:44,620
或者你可以看一下ASCII表。

1378
01:10:44,620 --> 01:10:45,120
>> JASON HIRSCHHORN：ASCII表。

1379
01:10:45,120 --> 01:10:46,490
但是，是的，你是正確的為好。

1380
01:10:46,490 --> 01:10:47,780
所以我們減去0。

1381
01:10:47,780 --> 01:10:49,010
所以，現在我們有整數9。

1382
01:10:49,010 --> 01:10:49,970
什麼我們想要做的是什麼？

1383
01:10:49,970 --> 01:10:54,970
如果我們有90，它是一個整數
我們，就是我們想幹什麼？

1384
01:10:54,970 --> 01:10:58,180
>> 學生：我把一個臨時整數
數組，然後做數學吧

1385
01:10:58,180 --> 01:11:02,088
後來將它做成了盡頭。

1386
01:11:02,088 --> 01:11:03,020
>> JASON HIRSCHHORN：確定。

1387
01:11:03,020 --> 01:11:06,990
>> 學生：您可以開始在年底
該數組，然後向前移動，以便

1388
01:11:06,990 --> 01:11:10,350
你往前走每一次，
你乘以10。

1389
01:11:10,350 --> 01:11:10,830
>> JASON HIRSCHHORN：確定。

1390
01:11:10,830 --> 01:11:12,250
這聽起來像一個漂亮的
引人注目的想法。

1391
01:11:12,250 --> 01:11:16,040
我們可以在我們的數組的末尾開始，
而且我們可以使用strleng。

1392
01:11:16,040 --> 01:11:17,030
我們可以在這裡使用strleng。

1393
01:11:17,030 --> 01:11:18,870
我們會得到我們的字符串的長度。

1394
01:11:18,870 --> 01:11:20,100
首先，我們在最後。

1395
01:11:20,100 --> 01:11:29,170
和+第一位的，我們只取了
整數，也許我們創建一個像

1396
01:11:29,170 --> 01:11:32,270
新的整型變量往上頂，其中
我們要存儲的一切。

1397
01:11:32,270 --> 01:11:37,340
因此，我們通過以s每個字符從環
回到前面，我們減去0，

1398
01:11:37,340 --> 01:11:42,790
然後我們把它，並根據
它在哪裡，我們乘它

1399
01:11:42,790 --> 01:11:45,860
以10的冪。

1400
01:11:45,860 --> 01:11:50,644
因為第一個，我們怎麼辦
乘以最右邊的字符？

1401
01:11:50,644 --> 01:11:51,440
>> 學生：10到0。

1402
01:11:51,440 --> 01:11:53,170
>> JASON HIRSCHHORN：10到0。

1403
01:11:53,170 --> 01:11:56,010
什麼是我們乘第二
最右邊的字符通過？

1404
01:11:56,010 --> 01:11:57,450
>> 學生：[聽不清]。

1405
01:11:57,450 --> 01:11:57,960
>> JASON HIRSCHHORN：什麼？

1406
01:11:57,960 --> 01:11:59,150
>> 學生：10到1。

1407
01:11:59,150 --> 01:12:00,420
>> JASON HIRSCHHORN：10到1。

1408
01:12:00,420 --> 01:12:03,754
第三，最右邊的字符？

1409
01:12:03,754 --> 01:12:04,580
>> 學生：10到2。

1410
01:12:04,580 --> 01:12:05,350
>> 傑森HIRSCHHORN：10至2。

1411
01:12:05,350 --> 01:12:07,200
>> 學生：對不起，我不明白
我們在這裡做的。

1412
01:12:07,200 --> 01:12:08,640
>> JASON HIRSCHHORN：OK，
讓我們回去，然後。

1413
01:12:08,640 --> 01:12:12,500
所以，我們要得到
傳遞的字符串。

1414
01:12:12,500 --> 01:12:14,470
因為我們正在寫的atoi。

1415
01:12:14,470 --> 01:12:15,260
所以我們得到傳遞的字符串。

1416
01:12:15,260 --> 01:12:17,640
說，我們正在獲得通過
在串90。

1417
01:12:17,640 --> 01:12:19,930
>> 我們要做的第一件事就是設置
一個新的整型變量，我們是

1418
01:12:19,930 --> 01:12:22,150
只是要創建
作為我們新的整數。

1419
01:12:22,150 --> 01:12:24,630
這就是我們要去
返回在最後。

1420
01:12:24,630 --> 01:12:30,110
我們需要經過每一個字符
的字符串，因為我們已經確定

1421
01:12:30,110 --> 01:12:34,430
我們需要觸摸每一個和
然後將其添加到我們的新的整數。

1422
01:12:34,430 --> 01:12:36,330
>> 但是，我們不能僅僅將其作為一個數字。

1423
01:12:36,330 --> 01:12:38,270
我們不能只取9和
新增9對我們的整數。

1424
01:12:38,270 --> 01:12:40,560
這要看是什麼地方
它是字符串中。

1425
01:12:40,560 --> 01:12:42,960
我們將需要乘
它由10的冪。

1426
01:12:42,960 --> 01:12:45,580
因為那是基地10件作品。

1427
01:12:45,580 --> 01:12:49,050
>> 所以，我們要獲得實際的
字符，或實際整數

1428
01:12:49,050 --> 01:12:53,860
數，減去字符0
從9字就像我們一樣

1429
01:12:53,860 --> 01:12:57,560
從減去字符大寫A
任何性質我們在一

1430
01:12:57,560 --> 01:12:58,120
這些問題。

1431
01:12:58,120 --> 01:13:04,190
因此，我們將真正得到一個從0到
9保存為一個實數，我們將

1432
01:13:04,190 --> 01:13:07,590
由10根據功率乘以
在我們所處的字符串中。

1433
01:13:07,590 --> 01:13:19,430

1434
01:13:19,430 --> 01:13:22,575
然後我們將其添加回
成我們新的整型變量。

1435
01:13:22,575 --> 01:13:32,840

1436
01:13:32,840 --> 01:13:37,890
>> 那麼，這看起來就像會
可以 - 我們將繪製在這裡。

1437
01:13:37,890 --> 01:13:40,086
如果我們傳遞的字符串90  - 

1438
01:13:40,086 --> 01:13:41,336
>> 學生：[聽不清]。

1439
01:13:41,336 --> 01:13:43,190

1440
01:13:43,190 --> 01:13:45,540
>> JASON HIRSCHHORN：但
atoi的接受一個字符串。

1441
01:13:45,540 --> 01:13:46,350
因此，我們要經過
的控股。

1442
01:13:46,350 --> 01:13:49,900
我們會獲得通過的90。

1443
01:13:49,900 --> 01:13:51,540
我們去從後面到前面。

1444
01:13:51,540 --> 01:13:53,920
我們以0。

1445
01:13:53,920 --> 01:13:55,080
>> 學生：我很抱歉。

1446
01:13:55,080 --> 01:13:55,880
也許這是愚蠢的。

1447
01:13:55,880 --> 01:13:59,440
如果我們得到傳入一個字符串，
為什麼是90我們在做什麼

1448
01:13:59,440 --> 01:14:00,260
獲得通過的？

1449
01:14:00,260 --> 01:14:03,160
因為90是一個整數。

1450
01:14:03,160 --> 01:14:06,820
>> JASON HIRSCHHORN：因為atoi的需要
字符串，並把它變成整數

1451
01:14:06,820 --> 01:14:08,320
該字符串表示形式。

1452
01:14:08,320 --> 01:14:13,650
但是字符串90不是整數
90或90位。

1453
01:14:13,650 --> 01:14:17,920
串90是兩個陣列，或
三個大字，相反，9

1454
01:14:17,920 --> 01:14:22,740
字符，字符0，和
反斜杠字符0。

1455
01:14:22,740 --> 01:14:26,260
>> 我們正在寫的atoi，因為，
例如，當你把命令

1456
01:14:26,260 --> 01:14:30,230
行參數，並且它保存在
argv的，它保存為一個字符串。

1457
01:14:30,230 --> 01:14:32,940
但是如果你想將其視為一個數字，
您需要將其轉換為

1458
01:14:32,940 --> 01:14:34,700
實際的整數。

1459
01:14:34,700 --> 01:14:37,210
我們做了我們的問題集之一。

1460
01:14:37,210 --> 01:14:38,800
我們在一些做
我們的習題集。

1461
01:14:38,800 --> 01:14:41,690
大家，把一個整數
作為命令行參數。

1462
01:14:41,690 --> 01:14:46,490
所以這就是為什麼我們的atoi函數
接受一個字符串。

1463
01:14:46,490 --> 01:14:51,910
>> 所以，再一次，在這裡我們的例子中，我們
要採取最後一個。

1464
01:14:51,910 --> 01:14:55,050
我們要減去字符
0從它，因為字符0

1465
01:14:55,050 --> 01:14:58,810
減去字符0給你
的實際數目為0，根據

1466
01:14:58,810 --> 01:15:00,950
ASCII碼的數學，我們做的。

1467
01:15:00,950 --> 01:15:04,870
>> 因為字符被表示為
不同於他們的實際 - 的

1468
01:15:04,870 --> 01:15:08,830
一個字符，例如
小寫字母a為97。

1469
01:15:08,830 --> 01:15:10,260
這不是 - 糟糕！

1470
01:15:10,260 --> 01:15:13,290
這不是任何你所期望的
它是，例如0。

1471
01:15:13,290 --> 01:15:16,200
所以，你必須減去
字符得到0。

1472
01:15:16,200 --> 01:15:18,950
>> 所以，我們要做的是，這裡
得到的實際數量。

1473
01:15:18,950 --> 01:15:22,560
然後我們將通過乘以它
10的冪取決於它

1474
01:15:22,560 --> 01:15:27,030
是在字符串中，然後採取
並把它添加到我們的佔位符

1475
01:15:27,030 --> 01:15:32,520
變量，所以我們可以拿出
我們最終的新的整數。

1476
01:15:32,520 --> 01:15:35,080
這是否有道理給大家？

1477
01:15:35,080 --> 01:15:37,730
>> 因此，我們不打算這個代碼
現在，因為我們

1478
01:15:37,730 --> 01:15:38,830
越來越短的時間。

1479
01:15:38,830 --> 01:15:40,860
我的，何時道歉。

1480
01:15:40,860 --> 01:15:44,620
但是，這是什麼，希望你會
能夠做的測驗 - 在

1481
01:15:44,620 --> 01:15:47,710
最起碼，得到這個偽代碼
寫出來。

1482
01:15:47,710 --> 01:15:50,840
>> 然後，如果我們寫的
偽代碼，實際上，我們可以這樣做

1483
01:15:50,840 --> 01:15:51,490
很快。

1484
01:15:51,490 --> 01:15:55,230
註釋每一行我們我們寫
在這裡轉化為約

1485
01:15:55,230 --> 01:15:56,970
一行C代碼。

1486
01:15:56,970 --> 01:16:01,780
聲明一個新的變量，寫作
一個循環中，一些減法，一些

1487
01:16:01,780 --> 01:16:07,070
乘法和一些分配。

1488
01:16:07,070 --> 01:16:09,020
我們可能還需要
寫一個返回行。

1489
01:16:09,020 --> 01:16:12,040
我們可能還需要放
一些檢查在這裡。

1490
01:16:12,040 --> 01:16:12,655
是啊。

1491
01:16:12,655 --> 01:16:15,720
>> 學生：所以我們可以把
S作為實際的字符串？

1492
01:16:15,720 --> 01:16:18,730
因為我知道這只是一個地址。

1493
01:16:18,730 --> 01:16:22,090
就像，你會怎麼得到的長度
該字符串被通過？

1494
01:16:22,090 --> 01:16:25,310
>> JASON HIRSCHHORN：那麼，如何做
字符串的長度是多少？

1495
01:16:25,310 --> 01:16:25,830
strlen的。

1496
01:16:25,830 --> 01:16:26,660
>> 學生：strlen的，是的。

1497
01:16:26,660 --> 01:16:30,550
不過你能不能把S作為
論點是什麼？

1498
01:16:30,550 --> 01:16:34,620
>> JASON HIRSCHHORN：所以strlen的
需要一個char明星。

1499
01:16:34,620 --> 01:16:38,090
接下去就是字符明星，它
保持計數，直到它到達一個

1500
01:16:38,090 --> 01:16:41,865
反斜杠0。 strlen的竟是
其他項目之一，我們

1501
01:16:41,865 --> 01:16:42,850
將要的代碼。

1502
01:16:42,850 --> 01:16:44,560
這是另一個很好的一個代碼。

1503
01:16:44,560 --> 01:16:47,270
一個人的更容易一點，因為如果
你要想想，

1504
01:16:47,270 --> 01:16:47,830
概念 - 

1505
01:16:47,830 --> 01:16:51,620
我只是說出來大聲 -  strlen的如下
一個指針，並保持持續和

1506
01:16:51,620 --> 01:16:54,210
計數和跟踪，直到
你達到一個反斜杠0。

1507
01:16:54,210 --> 01:16:56,530
>> 學生：好的，知道了。

1508
01:16:56,530 --> 01:17:00,200
>> JASON HIRSCHHORN：所以最好的
運氣測驗0的明天。

1509
01:17:00,200 --> 01:17:03,170
如果您有任何問題，我會
在此之後在外面。

1510
01:17:03,170 --> 01:17:05,610
請隨時給我發電子郵件。

1511
01:17:05,610 --> 01:17:08,480
伸出自己的TF，如果你
不是在我的部分，或者讓我

1512
01:17:08,480 --> 01:17:10,005
如果你想通過電子郵件發送。

1513
01:17:10,005 --> 01:17:13,140
>> 如果你想發飆了，只是發送
我一個電子郵件，一個FREAKOUT電子郵件，我會

1514
01:17:13,140 --> 01:17:16,710
送你回去，像一個笑臉，
還是一樣，開個玩笑什麼的。

1515
01:17:16,710 --> 01:17:18,190
可以隨意做，也是如此。

1516
01:17:18,190 --> 01:17:20,750
祝你好運再次，我會
見到大家下週。

1517
01:17:20,750 --> 01:17:23,435