1
00:00:00,000 --> 00:00:00,960

2
00:00:00,960 --> 00:00:03,360
>> [音樂播放]

3
00:00:03,360 --> 00:00:11,050

4
00:00:11,050 --> 00:00:12,065
>> DAVIN：好吧，伙計們。

5
00:00:12,065 --> 00:00:13,642

6
00:00:13,642 --> 00:00:15,350
因此，這是審查
對於第一次測驗。

7
00:00:15,350 --> 00:00:17,751
是每個人都準備好了
週三測驗？

8
00:00:17,751 --> 00:00:18,292
艾里遜：嗚！

9
00:00:18,292 --> 00:00:18,743
學生：嗚！

10
00:00:18,743 --> 00:00:19,242
DAVIN：是的。

11
00:00:19,242 --> 00:00:19,920
艾里遜：是啊！

12
00:00:19,920 --> 00:00:20,920
DAVIN：那傢伙的準備。

13
00:00:20,920 --> 00:00:22,200
那傢伙，兩隻手，美觀大方。

14
00:00:22,200 --> 00:00:23,234

15
00:00:23,234 --> 00:00:25,900
所以，今天的測驗審查，這是怎麼回事
為大約一小時半。

16
00:00:25,900 --> 00:00:27,940
我們將繼續在所有主要的
概念你應該知道的知識問答。

17
00:00:27,940 --> 00:00:31,434
我們將通過介紹一些編碼
手的例子，這是每一個測驗。

18
00:00:31,434 --> 00:00:34,350
如果你有任何問題，請隨時
提高你的手，一切

19
00:00:34,350 --> 00:00:34,945
這樣。

20
00:00:34,945 --> 00:00:36,695
好了，關於物流
測驗是否在線。

21
00:00:36,695 --> 00:00:38,450
所以，我們要拆分人
成不同的房間。

22
00:00:38,450 --> 00:00:39,491
它是基於他們的名字。

23
00:00:39,491 --> 00:00:43,630
所以，如果你有什麼地方有任何疑問
去或有關的材料是什麼，等等，

24
00:00:43,630 --> 00:00:46,810
對正在發生的事情的官話
要對競猜，在網上查詢。

25
00:00:46,810 --> 00:00:48,420
而這一切是最新的。

26
00:00:48,420 --> 00:00:51,280
所以，如果沒有問題，以
首先，我們要開始。

27
00:00:51,280 --> 00:00:52,790

28
00:00:52,790 --> 00:00:53,710
和這裡的佳佳。

29
00:00:53,710 --> 00:00:56,060

30
00:00:56,060 --> 00:00:57,000
>> [CLAPS]

31
00:00:57,000 --> 00:00:59,300
>> ALLISON：好的，謝謝，羅布。

32
00:00:59,300 --> 00:01:00,280
欣賞它。

33
00:01:00,280 --> 00:01:01,350

34
00:01:01,350 --> 00:01:03,050
達文應該翻轉此。

35
00:01:03,050 --> 00:01:07,240
這是其中的非窮盡列表
主題，一如既往地為達文剛說。

36
00:01:07,240 --> 00:01:10,860
參考文檔
網上有關測驗為零。

37
00:01:10,860 --> 00:01:13,680
但是，這是相當much--
它是在大綱

38
00:01:13,680 --> 00:01:15,550
是我們已經討論了迄今為止的一切。

39
00:01:15,550 --> 00:01:18,290
這裡的一切都是公平的遊戲，
還有別的

40
00:01:18,290 --> 00:01:21,380
可能被提到的講座。

41
00:01:21,380 --> 00:01:25,070
>> 我的部分，在這裡，
只是很多審查。

42
00:01:25,070 --> 00:01:27,775
有一對夫婦演習
那你們可能會工作。

43
00:01:27,775 --> 00:01:30,650
但在大多數情況下，我們真的
想獲得達文與代碼

44
00:01:30,650 --> 00:01:31,710
手練習。

45
00:01:31,710 --> 00:01:33,940
>> 所以，我要通過這個飛行。

46
00:01:33,940 --> 00:01:36,330
如果您有任何問題，我停下來。

47
00:01:36,330 --> 00:01:37,270
舉起你的手。

48
00:01:37,270 --> 00:01:39,250
我保證我可能會看到你的。

49
00:01:39,250 --> 00:01:41,042
如果沒有，只是揮動它周圍。

50
00:01:41,042 --> 00:01:42,250
我將要說話快。

51
00:01:42,250 --> 00:01:43,950
我希望每個人與確定。

52
00:01:43,950 --> 00:01:48,020
>> OK，特殊的詞，達文明顯
忘了翻閱這些幻燈片。

53
00:01:48,020 --> 00:01:51,880
（笑）你有麻煩了，老兄。

54
00:01:51,880 --> 00:01:55,770
因此，對於競猜零技巧，
練習編碼在紙面上。

55
00:01:55,770 --> 00:01:58,950
你們會得到一些
實踐與現在達文，

56
00:01:58,950 --> 00:02:00,655
所以你不會被自己徹底。

57
00:02:00,655 --> 00:02:03,030
我認為我們實際上會
通過這兩個功能。

58
00:02:03,030 --> 00:02:04,500
所以，你會做好充分的準備在那裡。

59
00:02:04,500 --> 00:02:05,958
>> 熟悉你的習題集。

60
00:02:05,958 --> 00:02:08,150
已經出現的問題
以前的測驗

61
00:02:08,150 --> 00:02:12,680
會問你，例如，代碼
一些東西非常相似，馬里奧。

62
00:02:12,680 --> 00:02:15,060
所以是很熟悉
您的問題集，以及

63
00:02:15,060 --> 00:02:17,827
作為問題，我們問你
在窗體上的開始

64
00:02:17,827 --> 00:02:19,660
您填寫，將
竭誠為您服務很好。

65
00:02:19,660 --> 00:02:20,940

66
00:02:20,940 --> 00:02:23,380
>> 做下以前的測驗
時間的限制。

67
00:02:23,380 --> 00:02:25,430
這些測驗很長。

68
00:02:25,430 --> 00:02:26,850
時間過得真快。

69
00:02:26,850 --> 00:02:30,480
而往往，你不知道怎麼
很快它去，直到你真正

70
00:02:30,480 --> 00:02:32,180
把自己在這些約束條件。

71
00:02:32,180 --> 00:02:36,500
所以，如果你可以能開出，你要知道，
第75分鐘，無論是今晚或明天

72
00:02:36,500 --> 00:02:41,020
把這些測驗中的一個下
這一點，你就會好得多。

73
00:02:41,020 --> 00:02:43,060
>> 而且，創建您的參考表。

74
00:02:43,060 --> 00:02:45,290
請記住，你只有一個
頁正面和背面

75
00:02:45,290 --> 00:02:47,040
為您的測驗上週三的參考。

76
00:02:47,040 --> 00:02:49,074
創造是學習的好方法。

77
00:02:49,074 --> 00:02:51,990
什麼，你有麻煩了
你要包括在那裡。

78
00:02:51,990 --> 00:02:55,627
凡是你的TF一直，
象，這是非常重要的。

79
00:02:55,627 --> 00:02:57,960
你應該知道這一點，是
也許你對那裡的東西

80
00:02:57,960 --> 00:02:59,931
如果你沒有這些記憶。

81
00:02:59,931 --> 00:03:02,680
即使你知道他們真的
還有，有時有它的存在

82
00:03:02,680 --> 00:03:07,030
僅僅是種安慰你，
我知道測驗的壓力。

83
00:03:07,030 --> 00:03:09,260
所以，任何安慰你能有所幫助。

84
00:03:09,260 --> 00:03:13,072
好吧，也讓睡眠和
吃，喜歡正常的事情

85
00:03:13,072 --> 00:03:14,280
我們告訴你的測驗。

86
00:03:14,280 --> 00:03:16,320

87
00:03:16,320 --> 00:03:18,890
>> 所以出發方便，
數據類型和大小。

88
00:03:18,890 --> 00:03:22,720
正如我所說，這只是會
被我扔了很多東西

89
00:03:22,720 --> 00:03:24,320
在這裡，你應該知道。

90
00:03:24,320 --> 00:03:27,600
因此，我們有我們的字符
這是1個字節，整型

91
00:03:27,600 --> 00:03:30,390
這是4個字節，長
長，這是8個字節。

92
00:03:30,390 --> 00:03:33,280
基本上，它只是你
想抱著更大的整數。

93
00:03:33,280 --> 00:03:35,490
彩車，其中有四個，
雙打，這是8。

94
00:03:35,490 --> 00:03:38,150
再次，只是給你更多
空間，為您的花車。

95
00:03:38,150 --> 00:03:41,290
然後鍵入星，所以任何
指針在32位機器上，

96
00:03:41,290 --> 00:03:44,650
這是所有你們需要
以知道，是4個字節。

97
00:03:44,650 --> 00:03:46,542
>> 所以你應該所有的東西
知道了，也許事情

98
00:03:46,542 --> 00:03:48,250
你想有
您的參考表。

99
00:03:48,250 --> 00:03:50,350

100
00:03:50,350 --> 00:03:53,520
OK，二進制轉換
為二進制，轉換

101
00:03:53,520 --> 00:03:56,860
為十六進制，反反复复，
所有的事情你應該知道。

102
00:03:56,860 --> 00:03:59,480
所以從二進制到十進制的。

103
00:03:59,480 --> 00:04:03,309
你們想採取快速分鐘
並嘗試找出每種

104
00:04:03,309 --> 00:04:04,600
然後告訴我他們是什麼？

105
00:04:04,600 --> 00:04:06,500

106
00:04:06,500 --> 00:04:10,240
>> 我也有糖果在我的包裡，所以任何人
誰回答得糖果，順便說一句。

107
00:04:10,240 --> 00:04:13,560

108
00:04:13,560 --> 00:04:14,480
我有很多很多的。

109
00:04:14,480 --> 00:04:15,760

110
00:04:15,760 --> 00:04:16,870
讓我抓住這一點。

111
00:04:16,870 --> 00:04:18,480
我打算把這個交給加布。

112
00:04:18,480 --> 00:04:21,829
所以，你可以把手伸到糖果
誰是很好的合作。

113
00:04:21,829 --> 00:04:23,490
>> OK，我在後面看到一隻手出現。

114
00:04:23,490 --> 00:04:26,418

115
00:04:26,418 --> 00:04:28,370
>> 學生：是啊，第一個是42。

116
00:04:28,370 --> 00:04:30,280
>> ALLISON：是的，第一個是42，正確的。

117
00:04:30,280 --> 00:04:31,163

118
00:04:31,163 --> 00:04:32,038
學生：[聽不清]。

119
00:04:32,038 --> 00:04:34,810
[笑]

120
00:04:34,810 --> 00:04:37,030
艾里遜：第二個，
背部有黃色的？

121
00:04:37,030 --> 00:04:38,910
學生：110010。

122
00:04:38,910 --> 00:04:43,410
ALLISON：正確的，這
最後一個，放在這兒的底部？

123
00:04:43,410 --> 00:04:44,570
此外，啊，你知道想要什麼？

124
00:04:44,570 --> 00:04:45,550
剛剛折騰出來的糖果。

125
00:04:45,550 --> 00:04:46,483
如何糖果給大家？

126
00:04:46,483 --> 00:04:47,510
>> 學生：[聽不清]的時候，我們就大功告成了。

127
00:04:47,510 --> 00:04:48,051
>> 艾里遜：噓。

128
00:04:48,051 --> 00:04:49,380

129
00:04:49,380 --> 00:04:50,910
然後是最後一個。

130
00:04:50,910 --> 00:04:52,000
誰願意回答？

131
00:04:52,000 --> 00:04:52,744
就在那裡。

132
00:04:52,744 --> 00:04:54,480
>> 學生：11100。

133
00:04:54,480 --> 00:04:56,820
>> ALLISON：11100，看那個。

134
00:04:56,820 --> 00:04:58,790
恭喜你，偉大的工作，每個人。

135
00:04:58,790 --> 00:05:03,370
OK，大家種理解
這個過程這樣做？

136
00:05:03,370 --> 00:05:08,700
你已經從二進制前往十進制
我傾向於這樣做的方式，是寫出來

137
00:05:08,700 --> 00:05:09,920
2的冪。

138
00:05:09,920 --> 00:05:18,350
所以我說，OK，0次2比0，所以
這是0，1次2的第一，

139
00:05:18,350 --> 00:05:21,400
2要開始這樣的。

140
00:05:21,400 --> 00:05:25,790
有沒有人要我明確
通過二進制的例子嗎？

141
00:05:25,790 --> 00:05:26,840

142
00:05:26,840 --> 00:05:28,140
OK，爽。

143
00:05:28,140 --> 00:05:30,390
>> 十進制到二進制的非常相似。

144
00:05:30,390 --> 00:05:31,550

145
00:05:31,550 --> 00:05:33,630
我傾向於寫出來的2的冪。

146
00:05:33,630 --> 00:05:38,660
先從一個是最大的，因此
但不走過去的十進制

147
00:05:38,660 --> 00:05:39,710
你正在尋找的。

148
00:05:39,710 --> 00:05:42,870
和種，然後以你的方式
向後加起來的東西是必要的。

149
00:05:42,870 --> 00:05:45,200
>> 然後用另外，它們也
就像正常的加法。

150
00:05:45,200 --> 00:05:51,110
如果你有你從哪來的情況下
加上兩個1，它顯然變成2。

151
00:05:51,110 --> 00:05:56,875
2二進制現在是1 0，所以你需要
攜帶你的1到下一列。

152
00:05:56,875 --> 00:05:57,375
涼爽。

153
00:05:57,375 --> 00:05:59,220

154
00:05:59,220 --> 00:06:03,240
>> 十六進制，這可能是什麼
這是稍微不太熟悉。

155
00:06:03,240 --> 00:06:06,600
因此，作為羅布只是告訴我
事前，他的伎倆本

156
00:06:06,600 --> 00:06:10,210
是只拆了它
成四個字節的塊，好不好？

157
00:06:10,210 --> 00:06:11,050
位，對不起。

158
00:06:11,050 --> 00:06:11,720
看到了嗎？

159
00:06:11,720 --> 00:06:12,220
感謝羅布。

160
00:06:12,220 --> 00:06:15,874
這就是為什麼你在這裡。 [NOISE]
好了，我們只是把它分解

161
00:06:15,874 --> 00:06:16,790
為4位的塊。

162
00:06:16,790 --> 00:06:21,570
所以用二進制代碼為十六進制，
我們看一下前4，

163
00:06:21,570 --> 00:06:25,573
這是如果我們有四個1秒的
行，什麼號碼這是否象徵？

164
00:06:25,573 --> 00:06:26,540
>> 學生：F.

165
00:06:26,540 --> 00:06:32,751
>> ALLISON：因此在這種情況下，
什麼是11111111 or--是嗎？

166
00:06:32,751 --> 00:06:33,250
學生：FF。

167
00:06:33,250 --> 00:06:34,600
ALLISON：完美，FF。

168
00:06:34,600 --> 00:06:36,900
如此之大，糖果給你。

169
00:06:36,900 --> 00:06:41,100
現在，對於如何十六進制為二進制，我們
只是覺得那種相反它。

170
00:06:41,100 --> 00:06:46,420
對於每一個數字或字母
我們在我們的十六進制，

171
00:06:46,420 --> 00:06:53,930
只需將它轉換為它的四個位
（笑）到4位的轉換。

172
00:06:53,930 --> 00:06:58,696
所以如圖5所示，在這種情況下，什麼是5，如果
我們代表這四個位？

173
00:06:58,696 --> 00:06:59,608
>> 學生：010？

174
00:06:59,608 --> 00:07:00,520
嗯。

175
00:07:00,520 --> 00:07:03,605
然後，這是
其實10，會是什麼？

176
00:07:03,605 --> 00:07:06,230

177
00:07:06,230 --> 00:07:08,040
1010。

178
00:07:08,040 --> 00:07:09,670
因此，我們有，在這裡。

179
00:07:09,670 --> 00:07:13,990
因此，十六進制之間的轉換
和二進制其實並不壞。

180
00:07:13,990 --> 00:07:16,565
如果你看它在4位
塊，將是黃金。

181
00:07:16,565 --> 00:07:18,330

182
00:07:18,330 --> 00:07:19,300
Everyone--是嗎？

183
00:07:19,300 --> 00:07:21,903
>> 羅伯：這是愚蠢的，
但我永遠記得

184
00:07:21,903 --> 00:07:23,500
A，因為A的應該是10。

185
00:07:23,500 --> 00:07:26,230
和二進制只是10 10，so--

186
00:07:26,230 --> 00:07:27,310
>> ALLISON：嗯，我們走吧。

187
00:07:27,310 --> 00:07:28,615
>> 羅伯：嘿。

188
00:07:28,615 --> 00:07:30,020
>> ALLISON：嘿，糖果羅布。

189
00:07:30,020 --> 00:07:31,707

190
00:07:31,707 --> 00:07:33,290
有非巧克力的東西在裡面。

191
00:07:33,290 --> 00:07:34,180
所以，你可以有一些。

192
00:07:34,180 --> 00:07:35,790

193
00:07:35,790 --> 00:07:36,760
因此，ASCII數學。

194
00:07:36,760 --> 00:07:38,206

195
00:07:38,206 --> 00:07:38,705
行為方式。

196
00:07:38,705 --> 00:07:40,630

197
00:07:40,630 --> 00:07:44,720
所以ASCII數學，因為你們
大概還記得

198
00:07:44,720 --> 00:07:48,480
P設置2的Visioneer和
凱撒，你做了很多了。

199
00:07:48,480 --> 00:07:49,610

200
00:07:49,610 --> 00:07:51,980
請記住，人物
從根本上只是數字。

201
00:07:51,980 --> 00:07:54,780
因此，我們可以做數學與他們，
就像我們做數學與整數。

202
00:07:54,780 --> 00:07:58,090
>> 因此，我們有一點點
在這裡簡單的事情。

203
00:07:58,090 --> 00:08:00,940
我們有一個在這
初始化為65。

204
00:08:00,940 --> 00:08:07,440
和B等於A的ASCII值
加1，燒焦ç等於d減1，

205
00:08:07,440 --> 00:08:09,060
和焦炭d之比等於68。

206
00:08:09,060 --> 00:08:13,130
那麼接下來我們要打印
所有的人，我們在這裡看到。

207
00:08:13,130 --> 00:08:15,650
而誰能告訴我
這是什麼會打印出來？

208
00:08:15,650 --> 00:08:17,335

209
00:08:17,335 --> 00:08:18,210
學生：[聽不清]。

210
00:08:18,210 --> 00:08:20,540
ALLISON：沒錯，所以
有一點要注意的是

211
00:08:20,540 --> 00:08:22,900
我們要打印出來
每一次，這裡字符。

212
00:08:22,900 --> 00:08:28,290
我們指定，即使A和B
是整數，當我們在上面宣布他們。

213
00:08:28,290 --> 00:08:32,870
我們正在打印它們通過字符
百分比C和我們的printf語句，

214
00:08:32,870 --> 00:08:34,610
所以他們將所有打印的字符。

215
00:08:34,610 --> 00:08:40,730
當然，ASCII值65將
打印為A的加1的ASCII值

216
00:08:40,730 --> 00:08:43,669
將是66，這將
自豪地B.所以，事實上，我們

217
00:08:43,669 --> 00:08:49,107
獲得A B C D。每個人都很好嗎？

218
00:08:49,107 --> 00:08:49,690
有問題嗎？

219
00:08:49,690 --> 00:08:50,721

220
00:08:50,721 --> 00:08:51,220
真棒。

221
00:08:51,220 --> 00:08:52,500

222
00:08:52,500 --> 00:08:53,455
>> OK，範圍。

223
00:08:53,455 --> 00:08:55,090

224
00:08:55,090 --> 00:08:59,950
所以，範圍顯然是一個非常
重要的是要明白，在這裡。

225
00:08:59,950 --> 00:09:03,250
很多的你，如果你
有編譯錯誤，

226
00:09:03,250 --> 00:09:06,085
它說你沒有
訪問某些變量，

227
00:09:06,085 --> 00:09:08,540
這可能是因為你
一個循環內定義它

228
00:09:08,540 --> 00:09:12,210
然後試圖訪問它
出來吧，反之亦然。

229
00:09:12,210 --> 00:09:16,410
>> 所以範圍為核心，
它只是決定在哪裡

230
00:09:16,410 --> 00:09:20,800
我們說一個變量存在，在這裡我們
可以改變它，我們可以訪問它。

231
00:09:20,800 --> 00:09:24,550
種它只是說這些都是
在這裡你可以訪問的唯一場所

232
00:09:24,550 --> 00:09:26,060
這個變量。

233
00:09:26,060 --> 00:09:30,080
>> 所以這兩個領域，我們談談
在課堂上是全局和局部。

234
00:09:30,080 --> 00:09:35,080
我們談了這麼全局變量
當你定義它們上面的主。

235
00:09:35,080 --> 00:09:38,390
這意味著，你的整個
程序可以訪問它，

236
00:09:38,390 --> 00:09:42,090
並且它的存在，只要
在程序運行時，OK？

237
00:09:42,090 --> 00:09:45,100
地方意味著它
更局限的區域。

238
00:09:45,100 --> 00:09:50,520
所以，只要你有特定的功能
類似的交換，我們總是談論。

239
00:09:50,520 --> 00:09:54,380
我們總是在談論交換A和
B. A和B的函數中存在。

240
00:09:54,380 --> 00:09:55,690
它們不存在任何其他地方。

241
00:09:55,690 --> 00:09:56,860

242
00:09:56,860 --> 00:10:00,610
>> 還有，當你有，如果
語句或循環。

243
00:10:00,610 --> 00:10:04,670
每當我們有，例如，在
一個for循環，我們必須INT I等於0。

244
00:10:04,670 --> 00:10:06,630
我們有一些條件，我們對其進行更新。

245
00:10:06,630 --> 00:10:10,270
我只在存在
那for循環括號。

246
00:10:10,270 --> 00:10:13,270
如果您嘗試在其他地方訪問它，
你的編譯器會罵你。

247
00:10:13,270 --> 00:10:14,560
它會像，你想幹什麼？

248
00:10:14,560 --> 00:10:15,400
本不存在。

249
00:10:15,400 --> 00:10:16,644

250
00:10:16,644 --> 00:10:18,435
所以，這兩個
不同類型的範圍。

251
00:10:18,435 --> 00:10:19,486

252
00:10:19,486 --> 00:10:20,860
這是否有意義大家？

253
00:10:20,860 --> 00:10:23,870

254
00:10:23,870 --> 00:10:27,890
>> 因此，對於這裡的例子，此
只是一些簡單的程序。

255
00:10:27,890 --> 00:10:29,120

256
00:10:29,120 --> 00:10:32,890
你們怎麼認為
將要在每一個點

257
00:10:32,890 --> 00:10:34,210
我們嘗試打印？

258
00:10:34,210 --> 00:10:40,150
因此，這一個在這裡，
什麼事情發生？

259
00:10:40,150 --> 00:10:43,047

260
00:10:43,047 --> 00:10:44,255
學生：這將打印三種。

261
00:10:44,255 --> 00:10:44,880
艾里遜：對。

262
00:10:44,880 --> 00:10:45,930
它會打印3。

263
00:10:45,930 --> 00:10:47,272
怎麼樣嗎？

264
00:10:47,272 --> 00:10:48,230
學生：這是行不通的。

265
00:10:48,230 --> 00:10:48,910
艾里遜：這是行不通的。

266
00:10:48,910 --> 00:10:50,290
你超出範圍了吧？

267
00:10:50,290 --> 00:10:55,160
局部變量不存在
這些括號外，沒事吧？

268
00:10:55,160 --> 00:10:56,462
然後怎麼樣嗎？

269
00:10:56,462 --> 00:10:57,850
>> 學生：[聽不清]。

270
00:10:57,850 --> 00:10:59,210
>> 艾里遜：什麼？

271
00:10:59,210 --> 00:10:59,900
搶，走了。

272
00:10:59,900 --> 00:11:00,854
>> 羅伯：我剛才說的。

273
00:11:00,854 --> 00:11:04,200
全局變量應該是
全球下劃線變量。

274
00:11:04,200 --> 00:11:05,660
>> ALLISON：啊，是的，對不起。

275
00:11:05,660 --> 00:11:06,200
謝謝，羅布。

276
00:11:06,200 --> 00:11:07,480

277
00:11:07,480 --> 00:11:10,170
羅布的像我們的居民的編譯器。

278
00:11:10,170 --> 00:11:12,684
他只會罵我們，當我們
需要它。 （笑）是的，

279
00:11:12,684 --> 00:11:14,225
應該是全球性的下劃線變量。

280
00:11:14,225 --> 00:11:15,760

281
00:11:15,760 --> 00:11:18,430
因此，假設該
是全球性的下劃線

282
00:11:18,430 --> 00:11:20,260
可變的，什麼會發生在這裡？

283
00:11:20,260 --> 00:11:21,260
學生：那會工作。

284
00:11:21,260 --> 00:11:22,093
艾里遜：它會工作。

285
00:11:22,093 --> 00:11:24,655
所以它會打印，所以只
一個非常簡單的例子。

286
00:11:24,655 --> 00:11:27,650

287
00:11:27,650 --> 00:11:29,870
OK，原型。

288
00:11:29,870 --> 00:11:33,680
所以，很顯然，我們真的
強調為你們

289
00:11:33,680 --> 00:11:36,460
如果以它的功能
道理在你的程序中。

290
00:11:36,460 --> 00:11:38,460
但當然，當你
使自己的職能，

291
00:11:38,460 --> 00:11:40,930
通常你會經過的主要定義。

292
00:11:40,930 --> 00:11:42,430
你會嘗試打電話給他們的主力。

293
00:11:42,430 --> 00:11:46,030
如果你不使用的原型，
你的編譯器會罵你。

294
00:11:46,030 --> 00:11:49,590
>> 原型基本上是
只是告訴編譯器

295
00:11:49,590 --> 00:11:52,400
我有以下主要這個功能。

296
00:11:52,400 --> 00:11:54,970
我要叫它之前，我定義它。

297
00:11:54,970 --> 00:11:56,360
堅持下去。

298
00:11:56,360 --> 00:12:00,660
我保證，它的定義，你
將有你需要的一切。

299
00:12:00,660 --> 00:12:05,900
>> 所以我們做的方式就是你的回報
類型，你的函數的名字，你的輸入

300
00:12:05,900 --> 00:12:06,400
列表中。

301
00:12:06,400 --> 00:12:09,760
它基本上是在第一行
你的函數聲明。

302
00:12:09,760 --> 00:12:11,510
這一切真的是。

303
00:12:11,510 --> 00:12:14,440
但是，這僅僅是一個
一般的那種格式。

304
00:12:14,440 --> 00:12:17,220
>> 所以，在這裡我們的例子中，
這你們應該

305
00:12:17,220 --> 00:12:19,700
所看到的截面
在某些時候，我們有

306
00:12:19,700 --> 00:12:23,220
一些INT多維數據集
需要輸入一些int類型。

307
00:12:23,220 --> 00:12:25,870
我們有我們的主要
函數，該函數調用的立方體。

308
00:12:25,870 --> 00:12:28,670
和多維數據集的事實後確定。

309
00:12:28,670 --> 00:12:34,450
>> 所以，如果我們沒有整型立方體輸入
在頂部，當我們所謂的魔方

310
00:12:34,450 --> 00:12:36,620
主，我們的編譯器內
會生氣我們。

311
00:12:36,620 --> 00:12:38,890
它會像什麼
你在說什麼？

312
00:12:38,890 --> 00:12:40,360
立方體不存在。

313
00:12:40,360 --> 00:12:41,910
我不知道你在問什麼。

314
00:12:41,910 --> 00:12:43,490
而我只是站。

315
00:12:43,490 --> 00:12:47,330
>> 但是，因為我們做了我們的原型
在上面，我們已經說過了，

316
00:12:47,330 --> 00:12:49,800
你知道，當你看到
立方體，不要擔心。

317
00:12:49,800 --> 00:12:51,990
我保證它的後面定義。

318
00:12:51,990 --> 00:12:53,750
它會讓你做你想做的。

319
00:12:53,750 --> 00:12:57,750
因此，如果你曾經有一個函數
你怎麼稱呼它後聲明

320
00:12:57,750 --> 00:13:00,570
第一次，你需要
有它的原型在頂部。

321
00:13:00,570 --> 00:13:01,640

322
00:13:01,640 --> 00:13:02,720
>> 是嗎？

323
00:13:02,720 --> 00:13:04,412
>> 羅伯：它的平方，而不是魔方。

324
00:13:04,412 --> 00:13:05,855
>> 艾里遜：哦，我的上帝。

325
00:13:05,855 --> 00:13:09,435
我沒有have--加布，我想
你是我們的校對。

326
00:13:09,435 --> 00:13:10,740

327
00:13:10,740 --> 00:13:12,760
OK，大家好，多多包涵，在這裡。

328
00:13:12,760 --> 00:13:14,440
我希望每個人都得到了主意。

329
00:13:14,440 --> 00:13:15,560

330
00:13:15,560 --> 00:13:20,380
OK，所以這應該有
被平方，立方不會。

331
00:13:20,380 --> 00:13:22,700
但思路是一樣的。

332
00:13:22,700 --> 00:13:23,702

333
00:13:23,702 --> 00:13:26,660
我們以後要調用任何函數
事實上應該有一個原型。

334
00:13:26,660 --> 00:13:27,730

335
00:13:27,730 --> 00:13:28,970
每個人都好有嗎？

336
00:13:28,970 --> 00:13:30,730

337
00:13:30,730 --> 00:13:32,310
其他任何錯別字？

338
00:13:32,310 --> 00:13:32,810
行。

339
00:13:32,810 --> 00:13:34,730

340
00:13:34,730 --> 00:13:36,230
在這裡的任何錯別字在我們開始之前，羅布？

341
00:13:36,230 --> 00:13:37,356

342
00:13:37,356 --> 00:13:42,380
（笑）好吧，那麼結構。

343
00:13:42,380 --> 00:13:45,040
基本上，結構允許你
創建自己的數據類型。

344
00:13:45,040 --> 00:13:49,264
那麼像int或char或
花車，它只是另一種類型。

345
00:13:49,264 --> 00:13:51,680
我喜歡把它當作一樣，
創建自己的數據類型。

346
00:13:51,680 --> 00:13:53,740
所以，它可以讓你做到這一點。

347
00:13:53,740 --> 00:13:56,160
和它保持不同類型的數據。

348
00:13:56,160 --> 00:14:01,030
>> 所以，如果你還記得，在一個數組中，我們
只能抱著相似類型的東西。

349
00:14:01,030 --> 00:14:04,660
結構使我們能夠保持多個
不同類型的東西。

350
00:14:04,660 --> 00:14:08,944
因此，在這裡這種情況下，我們
有一個叫學生結構，

351
00:14:08,944 --> 00:14:10,650
這裡命名為底部。

352
00:14:10,650 --> 00:14:13,540
和我們有一些整數ID
還有一些字符串名稱。

353
00:14:13,540 --> 00:14:14,620

354
00:14:14,620 --> 00:14:17,300
所以，這只是另一種數據類型。

355
00:14:17,300 --> 00:14:18,950
我們現在有一個名為學生的數據類型。

356
00:14:18,950 --> 00:14:20,330

357
00:14:20,330 --> 00:14:24,750
>> 是因為我們能想到的
它只是另一種數據類型，

358
00:14:24,750 --> 00:14:27,760
我們可以聲明變量
因為我們任何其他的。

359
00:14:27,760 --> 00:14:32,680
因此，而不是只是有一樣，在
INT學生，我們只是有一個學生，

360
00:14:32,680 --> 00:14:33,390
學生1。

361
00:14:33,390 --> 00:14:33,560
哦，你看。

362
00:14:33,560 --> 00:14:34,059
這是羅布。

363
00:14:34,059 --> 00:14:35,750

364
00:14:35,750 --> 00:14:38,880
所以在這裡我們聲明
一個結構或一個變量

365
00:14:38,880 --> 00:14:40,940
所謂類型學生的學生1。

366
00:14:40,940 --> 00:14:45,370
因此，這將有身份證
和與它相關聯的名稱。

367
00:14:45,370 --> 00:14:48,430
>> 與我們的方式訪問這些
我們的結構中的元素

368
00:14:48,430 --> 00:14:50,100
與點操作符，在這裡。

369
00:14:50,100 --> 00:14:51,910

370
00:14:51,910 --> 00:14:54,660
所以在這種情況下，我們
宣布一些學生1。

371
00:14:54,660 --> 00:14:57,080
我們指定的ID為1。

372
00:14:57,080 --> 00:14:58,840
我們指定的名稱是羅布。

373
00:14:58,840 --> 00:15:03,010

374
00:15:03,010 --> 00:15:04,960
好了，大家都好有嗎？

375
00:15:04,960 --> 00:15:06,787
使用它只是like--是嗎？

376
00:15:06,787 --> 00:15:09,530
>> 學生：是啊，typedef--時
我們需要使用的typedef？

377
00:15:09,530 --> 00:15:13,190
>> 艾里遜：那麼剛才的typedef
說that--羅布，你

378
00:15:13,190 --> 00:15:16,990
可以糾正我在這，如果我wrong--
但類型定義僅僅是實際申報

379
00:15:16,990 --> 00:15:19,330
它可以使用一個類型，對吧？

380
00:15:19,330 --> 00:15:22,550
>> 羅伯：是的，這是基本，
所以它只是創造

381
00:15:22,550 --> 00:15:24,215
別名或綽號的類型。

382
00:15:24,215 --> 00:15:25,590
所以，你可以鍵入[聽不清]。

383
00:15:25,590 --> 00:15:27,140

384
00:15:27,140 --> 00:15:30,350
所以[聽不清]的存在，
現在我們只是有

385
00:15:30,350 --> 00:15:32,090
[聽不清]手段
同樣的事情。

386
00:15:32,090 --> 00:15:37,210
所以在這裡，我們打字，我認為，
某些結構類型2 [聽不清]。

387
00:15:37,210 --> 00:15:40,680
所以它只是一個暱稱
對於給定的類型。

388
00:15:40,680 --> 00:15:44,344
>> 學生：字符串[聽不清]庫
被打完了像燒焦的明星。

389
00:15:44,344 --> 00:15:51,380

390
00:15:51,380 --> 00:15:54,390
>> 艾里遜：對我們來說這裡，
如果你聲明一個結構，

391
00:15:54,390 --> 00:15:55,600
只是做typedef結構。

392
00:15:55,600 --> 00:15:57,680

393
00:15:57,680 --> 00:16:04,490
OK，所以事前，這是
只是一個正常的位置變量。

394
00:16:04,490 --> 00:16:06,390
我們訪問一個點。

395
00:16:06,390 --> 00:16:08,580
如果我們有一個指針指向
一個結構，我們實際上可以

396
00:16:08,580 --> 00:16:10,700
用一個箭頭，這是很酷。

397
00:16:10,700 --> 00:16:17,130
>> 所以在這種情況下，我們有一個指針指向
學生1是類型的學生。

398
00:16:17,130 --> 00:16:19,020
請記住，你的
指針結構，

399
00:16:19,020 --> 00:16:23,710
你要什麼類型的指針
所指向的是在開始時。

400
00:16:23,710 --> 00:16:25,960
因此，我們有一些學生1，點擊這裡。

401
00:16:25,960 --> 00:16:27,370

402
00:16:27,370 --> 00:16:31,050
而且，由於這名學生
1現在是一個尖，

403
00:16:31,050 --> 00:16:36,520
我們其實可以去學生1名箭頭
而不是點，因為它是一個指針，

404
00:16:36,520 --> 00:16:37,640
並分配羅布。

405
00:16:37,640 --> 00:16:40,720
現在，如果我們想
改變搶到達文，

406
00:16:40,720 --> 00:16:43,570
這只是顯示你
用不同的方式來做到這一點。

407
00:16:43,570 --> 00:16:48,850
>> 因此，代替使用方向，則
可以also--我會完成這個再

408
00:16:48,850 --> 00:16:52,860
採取question--你可以
也可做參考的學生1。

409
00:16:52,860 --> 00:16:56,170
這是說喜歡去
無論是在學生的1，這

410
00:16:56,170 --> 00:16:58,840
將是我們的學生結構。

411
00:16:58,840 --> 00:17:03,910
以一個點和元素進行訪問
你想要的，然後再重新分配它。

412
00:17:03,910 --> 00:17:05,326
有一個問題。

413
00:17:05,326 --> 00:17:08,034
學生：是的，所以怎麼來的，你有
使用[聽不清]當你

414
00:17:08,034 --> 00:17:10,367
做學生的沒有明星
[聽不清]學生嗎？

415
00:17:10,367 --> 00:17:12,200
艾里遜：由於此
是創建一個指針。

416
00:17:12,200 --> 00:17:13,616
羅伯：我們要談論它。

417
00:17:13,616 --> 00:17:16,119
艾里遜：我們要談
關於以後的審查。

418
00:17:16,119 --> 00:17:17,660
因此，只要守住這個想法。

419
00:17:17,660 --> 00:17:20,560
如果仍然困擾你的
最後，再來說說我們的一員。

420
00:17:20,560 --> 00:17:23,380
>> 因此，這些做同樣的事情。

421
00:17:23,380 --> 00:17:25,579
我們只是在展示你們兩個
不同的方式來做到這一點。

422
00:17:25,579 --> 00:17:29,470
學生1現在是一個指針，所以
您可以訪問Name元素

423
00:17:29,470 --> 00:17:30,960
內帶箭頭的結構。

424
00:17:30,960 --> 00:17:36,440
或者，你可以取消引用指針，並
然後訪問它，你通常會。

425
00:17:36,440 --> 00:17:38,430
這是否有道理每個人？

426
00:17:38,430 --> 00:17:39,480

427
00:17:39,480 --> 00:17:43,890
如果整個指針的東西都有點
混亂，加布會談論，

428
00:17:43,890 --> 00:17:45,740
然後也許這
會更有意義。

429
00:17:45,740 --> 00:17:46,240
是嗎？

430
00:17:46,240 --> 00:17:48,387
>> 學生：是的，所以怎麼樣
這從不同？

431
00:17:48,387 --> 00:17:49,470
艾里遜：前一個？

432
00:17:49,470 --> 00:17:52,330
所以在這個學生1
案不是指針。

433
00:17:52,330 --> 00:17:54,380
這只是你的實際結構。

434
00:17:54,380 --> 00:17:55,400
>> 學生：OK。

435
00:17:55,400 --> 00:17:57,645
>> 艾里遜：雖然這一個
是一個指向結構體。

436
00:17:57,645 --> 00:17:58,910

437
00:17:58,910 --> 00:18:02,060
>> 學生：OK，但確實它種
結束工作的同[聽不清]。

438
00:18:02,060 --> 00:18:03,310
>> 艾里遜：它有效的工作原理相同。

439
00:18:03,310 --> 00:18:04,560
你的語法只是不同而已。

440
00:18:04,560 --> 00:18:05,185
學生：OK。

441
00:18:05,185 --> 00:18:07,600
>> ALLISON：是的，他們是
實際上是相同的。

442
00:18:07,600 --> 00:18:11,321
這只是根據上下文，
您可能需要一個比其他。

443
00:18:11,321 --> 00:18:11,820
是嗎？

444
00:18:11,820 --> 00:18:13,956
>> 學生：當你做
引用到1--

445
00:18:13,956 --> 00:18:14,580
艾里遜：嗯？

446
00:18:14,580 --> 00:18:16,880
學生：你為什麼
有括號？

447
00:18:16,880 --> 00:18:19,575
艾里遜：因為學生
圖1是指針。

448
00:18:19,575 --> 00:18:22,200
所以，你需要確保你
剛提領的指針。

449
00:18:22,200 --> 00:18:23,380
>> 學生：OK。

450
00:18:23,380 --> 00:18:26,700
>> 艾里遜：那麼在這裡這種情況下，
它周圍的括號

451
00:18:26,700 --> 00:18:29,875
意味著你提領學生1。

452
00:18:29,875 --> 00:18:35,390
所以，你要去哪裡的學生
1分，這是你的結構。

453
00:18:35,390 --> 00:18:38,010
所以，現在你能想到的
它作為結構，

454
00:18:38,010 --> 00:18:39,785
因此，我們可以利用我們的網點正常運行。

455
00:18:39,785 --> 00:18:42,752

456
00:18:42,752 --> 00:18:43,585
還有沒有其他問題？

457
00:18:43,585 --> 00:18:45,840

458
00:18:45,840 --> 00:18:48,120
酷，真棒。

459
00:18:48,120 --> 00:18:51,359
>> 所以過去的事情，我覺得
是我最後一張幻燈片，嗚！

460
00:18:51,359 --> 00:18:52,775
OK，所以浮點不精確。

461
00:18:52,775 --> 00:18:54,090

462
00:18:54,090 --> 00:18:56,820
我們短暫交談約
本次講座中。

463
00:18:56,820 --> 00:19:00,030
基本上，我們有
無窮多個實數。

464
00:19:00,030 --> 00:19:02,237
如果你的任何球員
喜歡數學，有

465
00:19:02,237 --> 00:19:03,570
各種很酷的東西與我們聯繫。

466
00:19:03,570 --> 00:19:05,010

467
00:19:05,010 --> 00:19:07,190
>> 但也有無限
許多實數。

468
00:19:07,190 --> 00:19:09,850
但他們只有有限
有多少位，我們有。

469
00:19:09,850 --> 00:19:13,240
所以，你總是會
有不精確，僅此而已。

470
00:19:13,240 --> 00:19:16,269
這就是這正中下懷
喜歡的東西你應該知道。

471
00:19:16,269 --> 00:19:19,060
這就像我們可能會問你為什麼
浮點不精確存在嗎？

472
00:19:19,060 --> 00:19:20,004

473
00:19:20,004 --> 00:19:21,420
所以只是你應該知道。

474
00:19:21,420 --> 00:19:23,770
有了這樣的，我翻
它交給指針。

475
00:19:23,770 --> 00:19:27,720

476
00:19:27,720 --> 00:19:28,520
>> 賓基：你好，伙計們。

477
00:19:28,520 --> 00:19:29,616
我叫賓基。

478
00:19:29,616 --> 00:19:30,990
我要談的指針。

479
00:19:30,990 --> 00:19:33,247

480
00:19:33,247 --> 00:19:35,830
是啊，所以指針實際上是
我最喜歡的一部分，在這個過程中。

481
00:19:35,830 --> 00:19:39,740
所以才弄清楚什麼佳佳
在這裡所說的，這樣的理由

482
00:19:39,740 --> 00:19:43,810
這裡why--唯一的區別，
大的差異的方式

483
00:19:43,810 --> 00:19:44,760
我們申報的東西。

484
00:19:44,760 --> 00:19:47,560
因此，學生明星這意味著
是一個指向一個學生。

485
00:19:47,560 --> 00:19:52,960
而幻燈片之前，學生是
實際的結構，像一個真正的學生，

486
00:19:52,960 --> 00:19:54,400
含有這些東​​西。

487
00:19:54,400 --> 00:19:57,050
>> 而我們之所以
想to--是，達文？

488
00:19:57,050 --> 00:19:58,630
>> DAVIN：什麼是箭頭是什麼意思？

489
00:19:58,630 --> 00:20:04,240
>> 賓基：箭頭手段
完全一樣，這一點。

490
00:20:04,240 --> 00:20:06,150
所以，你並不真正需要的箭頭。

491
00:20:06,150 --> 00:20:11,060
就像，如果你只計劃
在C中，你可以用這個。

492
00:20:11,060 --> 00:20:12,850
對不起，我這樣做，是不是。

493
00:20:12,850 --> 00:20:14,920
你可以使用這個語法。

494
00:20:14,920 --> 00:20:17,430
>> 但有些人，當
他們在設計C，

495
00:20:17,430 --> 00:20:19,870
他們想通的人
使用的語法那麼多，

496
00:20:19,870 --> 00:20:23,970
他們會像剛才上來
與語法結構的。

497
00:20:23,970 --> 00:20:26,820
而這發生在
這個箭頭的形式。

498
00:20:26,820 --> 00:20:29,210
而且它是非常好的，因為
它象徵著什麼

499
00:20:29,210 --> 00:20:33,670
就像我們實際上以下
此箭頭，這個指針，

500
00:20:33,670 --> 00:20:35,300
對內存中的一些空間。

501
00:20:35,300 --> 00:20:40,410
當我們到達那裡，我們要
看向那個學生的名字，

502
00:20:40,410 --> 00:20:42,150
如果是有道理的。

503
00:20:42,150 --> 00:20:43,000
行？

504
00:20:43,000 --> 00:20:44,290
>> 因此，這是完全一樣的。

505
00:20:44,290 --> 00:20:46,310
這也正是同樣的事情了。

506
00:20:46,310 --> 00:20:48,130
它們被編譯一模一樣，好不好？

507
00:20:48,130 --> 00:20:50,100

508
00:20:50,100 --> 00:20:55,580
這裡的原因，我們的malloc
東西，是因為在這種情況下，

509
00:20:55,580 --> 00:20:59,120
我們的變量實際上是
只是一個指針變量。

510
00:20:59,120 --> 00:21:02,900
所以，我們只有在一定的空間
內存是抱著一個指針。

511
00:21:02,900 --> 00:21:06,570
我們真的沒有任何空間
保存實際結構。

512
00:21:06,570 --> 00:21:08,660
>> 所以這必須在兩個步驟中完成。

513
00:21:08,660 --> 00:21:11,545
我們要創造的
內存放的結構。

514
00:21:11,545 --> 00:21:14,445
我們必須創建
內存放的指針。

515
00:21:14,445 --> 00:21:16,570
所以他們基本上有兩種
不同的變量，在這裡。

516
00:21:16,570 --> 00:21:19,730
其中之一就是類型的學生，
但它並沒有真正有一個名字。

517
00:21:19,730 --> 00:21:21,900
另一種是
類型學生的明星。

518
00:21:21,900 --> 00:21:24,900
然後學生1分
還有，如果是有意義的。

519
00:21:24,900 --> 00:21:25,871

520
00:21:25,871 --> 00:21:26,370
行？

521
00:21:26,370 --> 00:21:28,160

522
00:21:28,160 --> 00:21:31,860
>> 那麼，為什麼我們使用的原因
指針是因為一切

523
00:21:31,860 --> 00:21:35,510
在計算機中，每個變量
在一台計算機有兩件事。

524
00:21:35,510 --> 00:21:36,580
它有它的價值。

525
00:21:36,580 --> 00:21:38,420
並且它有它的地址。

526
00:21:38,420 --> 00:21:41,390
而一個好辦法
概念化，這是有

527
00:21:41,390 --> 00:21:44,230
很多問題當你
嘗試使用的功能。

528
00:21:44,230 --> 00:21:47,200
我們要去嘗試
看看其中的一個。

529
00:21:47,200 --> 00:21:50,370
也就是說，它要
認為內存盒。

530
00:21:50,370 --> 00:21:52,810
>> 你一直以為變量
當你說吶等於5。

531
00:21:52,810 --> 00:21:54,430
你以為把5成箱。

532
00:21:54,430 --> 00:21:55,520

533
00:21:55,520 --> 00:22:00,030
所以，如果你想傳遞什麼
這個int到一個函數？

534
00:22:00,030 --> 00:22:03,230
你剛才pass--我不
知道 -  X成一個函數。

535
00:22:03,230 --> 00:22:06,090
但是，什麼情況是
通常作為人類，你

536
00:22:06,090 --> 00:22:09,050
會覺得像我
通過盒子的人。

537
00:22:09,050 --> 00:22:12,070
它並沒有真正
發生在計算機上。

538
00:22:12,070 --> 00:22:17,770
會發生什麼事是你複製的價值
對應的複選框以人的箱子。

539
00:22:17,770 --> 00:22:22,440
>> 所以，我想說的是，如果
你有function--這裡sorry--，

540
00:22:22,440 --> 00:22:27,700
如果我們有像到5構成功能
還有，如果你試圖通過一個變量，

541
00:22:27,700 --> 00:22:29,450
它只是去複製。

542
00:22:29,450 --> 00:22:35,771
如果初始化NX等於3，這是怎麼回事
到拷貝該值設定為變量a

543
00:22:35,771 --> 00:22:36,270
在那裡。

544
00:22:36,270 --> 00:22:37,005

545
00:22:37,005 --> 00:22:39,630
OK，這就是種原因
我們為什麼要使用指針。

546
00:22:39,630 --> 00:22:42,550
由於代替
給剛值，

547
00:22:42,550 --> 00:22:44,850
而不是僅僅只是路過
的值以一個函數，

548
00:22:44,850 --> 00:22:46,530
我們希望通過引用傳遞。

549
00:22:46,530 --> 00:22:50,630
我們所說的通過引用傳遞是一種
向功能，給予箱，

550
00:22:50,630 --> 00:22:53,890
因此，該函數也可以
內框更改值。

551
00:22:53,890 --> 00:22:57,280
>> 好了，只是一些基本的指針
東東是創造三分球，

552
00:22:57,280 --> 00:23:00,300
你只需要聲明它的類型和
你把一個明星之後吧。

553
00:23:00,300 --> 00:23:02,307
和類型只是
你所指的地方。

554
00:23:02,307 --> 00:23:04,390
所以，如果它是一個int明星，
你指著一個int。

555
00:23:04,390 --> 00:23:05,940
如果它是一個char明星，
你指著一個圖表。

556
00:23:05,940 --> 00:23:07,790
如果它是一個學生明星，
你指著一個學生。

557
00:23:07,790 --> 00:23:08,770
行？

558
00:23:08,770 --> 00:23:10,510
>> 他們都是4字節長。

559
00:23:10,510 --> 00:23:13,010
因為這個變量
它實際上並不

560
00:23:13,010 --> 00:23:15,380
需要舉行一個char，
一個int或一個學生。

561
00:23:15,380 --> 00:23:16,890
只需要持有一個地址。

562
00:23:16,890 --> 00:23:21,390
這就是為什麼他們都是4個字節
長在一個正常的32位機。

563
00:23:21,390 --> 00:23:21,890
行？

564
00:23:21,890 --> 00:23:25,600
因此，這裡，x是指向一個變量
為int。 Ÿ指向一個字符。點z

565
00:23:25,600 --> 00:23:26,580
為float。

566
00:23:26,580 --> 00:23:27,480
這裡有什麼問題嗎？

567
00:23:27,480 --> 00:23:29,841

568
00:23:29,841 --> 00:23:30,340
涼爽。

569
00:23:30,340 --> 00:23:32,550
並有兩個
它們具有不同的符號

570
00:23:32,550 --> 00:23:34,341
要記住，當
未來的指針。

571
00:23:34,341 --> 00:23:36,540
因此，參考和
非關聯化是大的。

572
00:23:36,540 --> 00:23:38,100

573
00:23:38,100 --> 00:23:41,602
所以在與號
變量名給你的？

574
00:23:41,602 --> 00:23:42,310
學生：地址。

575
00:23:42,310 --> 00:23:43,380
賓基：地址。

576
00:23:43,380 --> 00:23:47,330
所以，如果你聲明一個整型
等於5，那麼符號

577
00:23:47,330 --> 00:23:49,214
一個是要給你的地址。

578
00:23:49,214 --> 00:23:51,130
而實際上你可以試試
打印該看看

579
00:23:51,130 --> 00:23:54,640
什麼樣的內存地址
你變了。

580
00:23:54,640 --> 00:23:57,380
然後dereferencing--
使被引用，

581
00:23:57,380 --> 00:24:00,380
獲得address--反引用
是完全相反的。

582
00:24:00,380 --> 00:24:04,120
OK，就好像時間是
一個部門的對面，

583
00:24:04,120 --> 00:24:06,060
明星是符號相反。

584
00:24:06,060 --> 00:24:09,710
因此，提領方式去那裡。

585
00:24:09,710 --> 00:24:14,280
所以，如果你給我star--
不知道 -  50，這是

586
00:24:14,280 --> 00:24:20,320
要嘗試去的地址
50號在你的電腦中。

587
00:24:20,320 --> 00:24:22,840
確定，為什麼我們看到的
他們是對立的？

588
00:24:22,840 --> 00:24:27,320
因為如果你這樣做會發生什麼
像明星AMPERSAND一個？

589
00:24:27,320 --> 00:24:28,470

590
00:24:28,470 --> 00:24:33,460
那麼，一個符號給你的地址
一個變量，a的地址。

591
00:24:33,460 --> 00:24:35,830
但星意味著去那裡。

592
00:24:35,830 --> 00:24:38,930
>> 如果你恰巧是什麼
去的地址？

593
00:24:38,930 --> 00:24:40,400
你只得到一個，對不對？

594
00:24:40,400 --> 00:24:41,410

595
00:24:41,410 --> 00:24:43,600
所以要的地址
一個是同樣的事情的。

596
00:24:43,600 --> 00:24:47,580
這就是為什麼他們通常
提到了same--這

597
00:24:47,580 --> 00:24:50,480
這被稱為
作為另一運營商。

598
00:24:50,480 --> 00:24:50,980
行？

599
00:24:50,980 --> 00:24:52,780

600
00:24:52,780 --> 00:24:53,790
太酷了。

601
00:24:53,790 --> 00:24:57,240
>> 在內部，例如，
如果我們聲明整數x等於5，

602
00:24:57,240 --> 00:24:58,040
我們有一個變量。

603
00:24:58,040 --> 00:25:00,790
請記住，我說的每一個
變量 - 這是一件好事

604
00:25:00,790 --> 00:25:03,820
保持在mind--它有兩個
不同的事物相關聯。

605
00:25:03,820 --> 00:25:06,460
它的尋址和一個值。

606
00:25:06,460 --> 00:25:07,140
行？

607
00:25:07,140 --> 00:25:09,180
>> 所以在這種情況下，該值是5。

608
00:25:09,180 --> 00:25:12,140
和地址is--比方說，我
使一些up--是0×04。

609
00:25:12,140 --> 00:25:13,180

610
00:25:13,180 --> 00:25:17,200
而唯一的原因，我們通常
表示十六進制地址

611
00:25:17,200 --> 00:25:19,770
是的，因為它就像好。

612
00:25:19,770 --> 00:25:21,600
它順利二進制。

613
00:25:21,600 --> 00:25:23,500
可以很容易地轉換和從二進制文件。

614
00:25:23,500 --> 00:25:26,890
和它沒有得到太大的話
你有一個非常大的數字。

615
00:25:26,890 --> 00:25:29,990
所以我們喜歡用十六進制
在打印地址。

616
00:25:29,990 --> 00:25:31,890
但我可以代表
這是一個整數。

617
00:25:31,890 --> 00:25:32,750
它的罰款。

618
00:25:32,750 --> 00:25:35,450
>> 因此它具有一個地址
圖4和5的值。

619
00:25:35,450 --> 00:25:38,080
然後我說明星整型指針。

620
00:25:38,080 --> 00:25:40,070
因此，這是一種不同類型的，另行通知。

621
00:25:40,070 --> 00:25:43,220
INT明星指針等於
x的地址。

622
00:25:43,220 --> 00:25:46,425
那麼，什麼將是PTR的價值？

623
00:25:46,425 --> 00:25:47,710

624
00:25:47,710 --> 00:25:51,600
這將是
x的地址，到這裡。

625
00:25:51,600 --> 00:25:54,190
行，因此該值是要
是相同的地址。

626
00:25:54,190 --> 00:25:56,130
這是分配工作，我做的事情。

627
00:25:56,130 --> 00:25:59,380
然後PTR都將有
它自己的地址，該地址的出現，

628
00:25:59,380 --> 00:26:02,050
在這種情況下，如圖8所示，行？

629
00:26:02,050 --> 00:26:03,850

630
00:26:03,850 --> 00:26:05,900
>> 然後我創建一個新的整數副本。

631
00:26:05,900 --> 00:26:08,790
我說INT副本等於去那裡。

632
00:26:08,790 --> 00:26:11,140
所以去什麼PTR指向。

633
00:26:11,140 --> 00:26:13,940
那麼，這是什麼PTR有哪些？

634
00:26:13,940 --> 00:26:14,740
PTR有0×04。

635
00:26:14,740 --> 00:26:16,060

636
00:26:16,060 --> 00:26:18,400
如果我試圖去那裡，會發生什麼？

637
00:26:18,400 --> 00:26:23,650
我會找到那個誰了
地址x和誰擁有的地址4。

638
00:26:23,650 --> 00:26:25,970
而誰擁有解決四個為x。

639
00:26:25,970 --> 00:26:26,950
這是否有道理？

640
00:26:26,950 --> 00:26:28,295

641
00:26:28,295 --> 00:26:28,795
是嗎？

642
00:26:28,795 --> 00:26:32,060
>> 學生：在這種情況下，是
在一個堆棧指針？

643
00:26:32,060 --> 00:26:36,024
>> 賓基：在這種情況下，
it's--很好的問題。

644
00:26:36,024 --> 00:26:38,690
我真的沒有想到這
當彌補這些地址。

645
00:26:38,690 --> 00:26:42,570
但是，如果這是一樣，所有
這些都是局部變量，

646
00:26:42,570 --> 00:26:46,372
那麼x是要住in--一切
打算居住的堆棧。

647
00:26:46,372 --> 00:26:48,330
所以，一切都
是指向堆棧。

648
00:26:48,330 --> 00:26:49,360

649
00:26:49,360 --> 00:26:52,700
你只能堆時
你開始使用malloc，對不對？

650
00:26:52,700 --> 00:26:59,430
>> 所以，如果你還記得堆棧每次
你調用一個函數在程序中，

651
00:26:59,430 --> 00:27:02,800
等，主要用於例如，或任何
其他功能，如printf。

652
00:27:02,800 --> 00:27:06,334
所有的局部變量是
會被放到一個棧幀。

653
00:27:06,334 --> 00:27:08,500
他們會得到
在堆棧中像雪片一樣飛來。

654
00:27:08,500 --> 00:27:09,930
這就是被稱為堆棧。

655
00:27:09,930 --> 00:27:12,200
和所有局部變量
將要出現。

656
00:27:12,200 --> 00:27:14,940
和heap--，我們要
更多地談論這個later--

657
00:27:14,940 --> 00:27:19,050
堆是所有的
動態分配的內存的生命。

658
00:27:19,050 --> 00:27:20,270
很酷吧？

659
00:27:20,270 --> 00:27:21,680
>> 我們去這個幻燈片。

660
00:27:21,680 --> 00:27:22,800
是嗎？

661
00:27:22,800 --> 00:27:25,490
>> 學生：為什麼不是int
複製返回0×04？

662
00:27:25,490 --> 00:27:27,870

663
00:27:27,870 --> 00:27:30,066
>> 賓基：為什麼不是int
複製返回0×04？

664
00:27:30,066 --> 00:27:32,450
>> 學生：為什麼不說[聽不清]？

665
00:27:32,450 --> 00:27:35,530
>> 賓基：原因是什麼PTR的值？

666
00:27:35,530 --> 00:27:37,394

667
00:27:37,394 --> 00:27:38,370
>> 學生：0×04。

668
00:27:38,370 --> 00:27:38,960
>> 賓基：0×04。

669
00:27:38,960 --> 00:27:40,910
如果你去0X04，會發生什麼？

670
00:27:40,910 --> 00:27:41,620
你明白了什麼？

671
00:27:41,620 --> 00:27:42,371
>> 學生：哦，好吧。

672
00:27:42,371 --> 00:27:42,995
賓基：你看到了什麼？

673
00:27:42,995 --> 00:27:43,536
學生：是的。

674
00:27:43,536 --> 00:27:44,890
賓基：所以，你得到5。

675
00:27:44,890 --> 00:27:49,170
所以副本都將有
5，如果是有道理的。

676
00:27:49,170 --> 00:27:49,809
是嗎？

677
00:27:49,809 --> 00:27:52,803
>> 學生：難道我們已經得到了
5，在值框中[聽不清]

678
00:27:52,803 --> 00:27:55,300
如果我們把INT複製[聽不清]。

679
00:27:55,300 --> 00:27:56,710
>> 賓基：Int--我們會的，是的。

680
00:27:56,710 --> 00:27:59,080
這會做
幾乎同樣的事情。

681
00:27:59,080 --> 00:28:02,080
但這樣一來，我們可以通過
要解決功能。

682
00:28:02,080 --> 00:28:05,050
而這也是很酷的事情
我們打算做的事情。

683
00:28:05,050 --> 00:28:06,770

684
00:28:06,770 --> 00:28:13,090
>> 所以這種運動總是出現
on--很一般出現在測驗。

685
00:28:13,090 --> 00:28:15,870
所以這是非常好的嘗試
做這種自己的事情。

686
00:28:15,870 --> 00:28:21,210
所以，盡量保持跟踪什麼地址
是，想要的變量的值

687
00:28:21,210 --> 00:28:22,620
是在每一個點。

688
00:28:22,620 --> 00:28:24,370
因此，這也正是
我們所要做的。

689
00:28:24,370 --> 00:28:26,988
這裡，我們有以下步驟，1，
二，三，四，五。

690
00:28:26,988 --> 00:28:30,530
一，二，三，四，五。

691
00:28:30,530 --> 00:28:33,330
而且我們要跟踪
的x和a的值。

692
00:28:33,330 --> 00:28:34,650

693
00:28:34,650 --> 00:28:40,530
>> 所以，這是什麼做的，如果這是一個
bug的代碼，我們正在試圖做五。

694
00:28:40,530 --> 00:28:43,610
因此，我們試圖獲得一個
變量和它的值更改為5。

695
00:28:43,610 --> 00:28:44,630

696
00:28:44,630 --> 00:28:49,900
而記得我有一個類比
框和遞箱子的人？

697
00:28:49,900 --> 00:28:51,515
因此，主有此框名為x。

698
00:28:51,515 --> 00:28:52,570

699
00:28:52,570 --> 00:28:54,170
它包含的值3。

700
00:28:54,170 --> 00:28:55,230

701
00:28:55,230 --> 00:28:57,455
我試圖用手
此框五。

702
00:28:57,455 --> 00:28:58,560

703
00:28:58,560 --> 00:29:01,510
>> 我想五改
此盒的5個值。

704
00:29:01,510 --> 00:29:03,080

705
00:29:03,080 --> 00:29:05,120
然後，我只是打印x的值。

706
00:29:05,120 --> 00:29:06,475

707
00:29:06,475 --> 00:29:08,850
這是我的function--
這就是我想要做的事情。

708
00:29:08,850 --> 00:29:12,450
我只是想更新
x的5個值。

709
00:29:12,450 --> 00:29:13,512

710
00:29:13,512 --> 00:29:14,970
它是明確的功能做什麼？

711
00:29:14,970 --> 00:29:16,210

712
00:29:16,210 --> 00:29:21,440
>> 好了，什麼都將成為
x和這裡權值，

713
00:29:21,440 --> 00:29:27,734
第一行中，前右第一
line--我say--的程序？

714
00:29:27,734 --> 00:29:28,940
>> 學生：大概垃圾。

715
00:29:28,940 --> 00:29:30,023
>> 賓基：只是垃圾的東西。

716
00:29:30,023 --> 00:29:32,590
所以，我只是把N / A。所以
我們真的不知道。

717
00:29:32,590 --> 00:29:37,400
就像，一個根本不存在呢，
因為我們不叫五。

718
00:29:37,400 --> 00:29:38,980
詮釋一個不宣。

719
00:29:38,980 --> 00:29:40,030

720
00:29:40,030 --> 00:29:42,920
並且x是要存
在這裡，但我們還沒有真正

721
00:29:42,920 --> 00:29:45,370
指定任何值給它，這樣就OK了？

722
00:29:45,370 --> 00:29:46,570

723
00:29:46,570 --> 00:29:52,340
>> 然後，什麼都將成為
X和A的數量兩個值？

724
00:29:52,340 --> 00:29:54,530

725
00:29:54,530 --> 00:29:55,410
>> 學生：[聽不清]。

726
00:29:55,410 --> 00:29:57,540
>> 賓基：所以X將是3。

727
00:29:57,540 --> 00:29:59,650
這很簡單，因為
我們指派3到它。

728
00:29:59,650 --> 00:30:03,500
和靜止不存在
因為只是住在五。

729
00:30:03,500 --> 00:30:05,800
所以，我打算有3個並沒有什麼。

730
00:30:05,800 --> 00:30:08,590
或像垃圾一樣，不管，
沒有真正定義。

731
00:30:08,590 --> 00:30:11,640

732
00:30:11,640 --> 00:30:13,140
而現在，這是最重要的線。

733
00:30:13,140 --> 00:30:14,931
在這裡，我們要
其實叫五。

734
00:30:14,931 --> 00:30:17,140

735
00:30:17,140 --> 00:30:18,680
請記住我說的話。

736
00:30:18,680 --> 00:30:20,240
我們從來沒有過在箱子裡。

737
00:30:20,240 --> 00:30:23,110
我們剛才複製的價值
盒子到另一個盒子。

738
00:30:23,110 --> 00:30:27,000
這是所有的電腦都複製
東西從一個地方到另一個地方。

739
00:30:27,000 --> 00:30:33,550
>> 所以五，其實際作用
是x它複製到一個值。

740
00:30:33,550 --> 00:30:35,130
那麼，什麼會是在這裡？

741
00:30:35,130 --> 00:30:36,210
x和a的值。

742
00:30:36,210 --> 00:30:38,670

743
00:30:38,670 --> 00:30:43,360
3和3，我們只複製
它通過從x到一個。

744
00:30:43,360 --> 00:30:44,710

745
00:30:44,710 --> 00:30:45,320
涼爽。

746
00:30:45,320 --> 00:30:46,140
>> 現在，我們在這裡。

747
00:30:46,140 --> 00:30:47,610

748
00:30:47,610 --> 00:30:49,430
現在我們要去
更新等於5。

749
00:30:49,430 --> 00:30:50,900

750
00:30:50,900 --> 00:30:53,070
怎麼會發生在四個行？

751
00:30:53,070 --> 00:30:55,120

752
00:30:55,120 --> 00:30:56,010
>> 學生：[聽不清]。

753
00:30:56,010 --> 00:30:59,685
>> 賓基：一個被更新，
但X沒有得到更新。

754
00:30:59,685 --> 00:31:02,050

755
00:31:02,050 --> 00:31:05,250
由於X仍住在主，這是一個
完全不同的內存塊。

756
00:31:05,250 --> 00:31:06,970
這是一個不同的變量。

757
00:31:06,970 --> 00:31:07,900
一個是另一個變量。

758
00:31:07,900 --> 00:31:10,000
他們碰巧有
相同的值，因為我

759
00:31:10,000 --> 00:31:13,980
複製通過x的一個值。

760
00:31:13,980 --> 00:31:20,070
但現在，當我做了等於5，它
並沒有真正影響X以任何方式。

761
00:31:20,070 --> 00:31:21,450
這是棘手的部分。

762
00:31:21,450 --> 00:31:23,380
是否有意義給大家？

763
00:31:23,380 --> 00:31:24,093
是嗎？

764
00:31:24,093 --> 00:31:25,717
學生：還有一個問題，你有3個。

765
00:31:25,717 --> 00:31:27,741
為什麼一個already--哦，不，這是3。

766
00:31:27,741 --> 00:31:28,490
對不起，沒關係。

767
00:31:28,490 --> 00:31:29,310
我讀5。

768
00:31:29,310 --> 00:31:30,415
>> 賓基：是的，3，3。

769
00:31:30,415 --> 00:31:31,540
>> 學生：[聽不清]，是啊。

770
00:31:31,540 --> 00:31:35,290
賓基：然後我們分配到5
一，但並沒有真正改變X。

771
00:31:35,290 --> 00:31:36,369
好不好？

772
00:31:36,369 --> 00:31:36,910
學生：是的。

773
00:31:36,910 --> 00:31:37,410
賓基：是的？

774
00:31:37,410 --> 00:31:42,330
你可以再次解釋
一個被複製[聽不清]？

775
00:31:42,330 --> 00:31:48,480
>> 賓基：OK，所以當你調用到五
x的，所以這行代碼在這裡。

776
00:31:48,480 --> 00:31:50,100

777
00:31:50,100 --> 00:31:52,340
五x的，什麼是X？

778
00:31:52,340 --> 00:31:55,160

779
00:31:55,160 --> 00:31:58,340
x是僅有3在這一點上，對不對？

780
00:31:58,340 --> 00:32:03,320
所以，你可能只是想放的
3在這裡，忘記關於x的。

781
00:32:03,320 --> 00:32:04,410
只要把一個3這裡。

782
00:32:04,410 --> 00:32:10,880
就像，我們要複製過來的
x的值到一個整型那是在那裡。

783
00:32:10,880 --> 00:32:12,310

784
00:32:12,310 --> 00:32:13,630
行？

785
00:32:13,630 --> 00:32:14,780
>> 因此x的值是3。

786
00:32:14,780 --> 00:32:17,680
我們要複製在3到。

787
00:32:17,680 --> 00:32:20,040
和所有其他的這個塊
記憶中，這其他的變量

788
00:32:20,040 --> 00:32:22,640
稱為一個將有3，以及。

789
00:32:22,640 --> 00:32:23,580
這是否有道理？

790
00:32:23,580 --> 00:32:24,780

791
00:32:24,780 --> 00:32:25,794
是嗎？

792
00:32:25,794 --> 00:32:31,008
>> 學生：如果你給五象
它作為整數X代替，

793
00:32:31,008 --> 00:32:32,910
這會解決一切嗎？

794
00:32:32,910 --> 00:32:36,290
>> 賓基：如果它是一個integer--沒有，
這不會解決所有問題。

795
00:32:36,290 --> 00:32:37,590
所以這是一個非常好的問題。

796
00:32:37,590 --> 00:32:40,480
它並不真正的問題是什麼
你叫這些變量。

797
00:32:40,480 --> 00:32:44,510
再次，這將是對範圍的問題，請
因為它們不是相同的x。

798
00:32:44,510 --> 00:32:46,526
他們是完全
在內存不同的空間。

799
00:32:46,526 --> 00:32:47,400
學生：[聽不清]。

800
00:32:47,400 --> 00:32:49,020
賓基：所以它並沒有真正
不管你怎麼稱呼他們。

801
00:32:49,020 --> 00:32:50,480
不解決的事情，好不好？

802
00:32:50,480 --> 00:32:53,390

803
00:32:53,390 --> 00:32:54,430
更多問題？

804
00:32:54,430 --> 00:32:55,762
是嗎？

805
00:32:55,762 --> 00:32:58,498
>> 學生：這怎麼回
5 [聽不清]？

806
00:32:58,498 --> 00:32:59,661

807
00:32:59,661 --> 00:33:01,160
賓基：OK，我們還沒有做到這一點呢。

808
00:33:01,160 --> 00:33:03,432
讓我們去第五，然後。

809
00:33:03,432 --> 00:33:04,650
>> 學生：[聽不清]？

810
00:33:04,650 --> 00:33:05,565
>> 賓基：什麼？

811
00:33:05,565 --> 00:33:08,179
>> 學生：你有回報呢？

812
00:33:08,179 --> 00:33:09,970
賓基：我們沒有
一個回報，而不是主要的。

813
00:33:09,970 --> 00:33:12,940
但主要的自動返回0
如果不返回任何東西。

814
00:33:12,940 --> 00:33:14,400

815
00:33:14,400 --> 00:33:15,188
是嗎？

816
00:33:15,188 --> 00:33:22,658
>> 學生：你能不能讓main--或
你能做出5歸路？

817
00:33:22,658 --> 00:33:24,170

818
00:33:24,170 --> 00:33:27,990
>> 賓基：我們可以有
五返回，是的。

819
00:33:27,990 --> 00:33:32,527
但是，我們必須為x
等於五的返回值，

820
00:33:32,527 --> 00:33:34,360
這將是一個略
不同的程序。

821
00:33:34,360 --> 00:33:35,440
它會工作。

822
00:33:35,440 --> 00:33:38,730
但是，我們想要做的是什麼
所謂改變的東西的地方。

823
00:33:38,730 --> 00:33:41,690
因此，我們要真正
更改框，不用擔心

824
00:33:41,690 --> 00:33:44,390
關於有回
值或任何東西。

825
00:33:44,390 --> 00:33:44,890
行？

826
00:33:44,890 --> 00:33:46,490

827
00:33:46,490 --> 00:33:50,150
>> 這就像交換功能
大衛表現在課堂上，除了我

828
00:33:50,150 --> 00:33:51,740
只處理一個變量。

829
00:33:51,740 --> 00:33:55,960
他用了兩個，所以整數a和b
然後臨時變量和諸如此類的東西。

830
00:33:55,960 --> 00:33:57,020
行？

831
00:33:57,020 --> 00:33:58,070
那麼什麼是最後一行？

832
00:33:58,070 --> 00:34:04,400
後到5的回報，這是
簡直就是一個將要消失。

833
00:34:04,400 --> 00:34:06,120

834
00:34:06,120 --> 00:34:10,179
我們將不具有了，並
只有X仍然會生活。

835
00:34:10,179 --> 00:34:12,130
>> 你猜怎麼著？ X
並沒有改變它的值，

836
00:34:12,130 --> 00:34:15,520
畢竟，因為我們
只改變a的值。

837
00:34:15,520 --> 00:34:17,370
這就是為什麼x為3貫穿始終。

838
00:34:17,370 --> 00:34:17,870
行？

839
00:34:17,870 --> 00:34:20,195

840
00:34:20,195 --> 00:34:21,130
不錯。

841
00:34:21,130 --> 00:34:23,560
所以這個方案不
達到我們想要的。

842
00:34:23,560 --> 00:34:24,760
現在讓我們來解決它。

843
00:34:24,760 --> 00:34:27,440
>> 而修復程序是使用指針。

844
00:34:27,440 --> 00:34:32,300
我們做的是我們有三個
線是不同的。

845
00:34:32,300 --> 00:34:34,020
首當其衝是我們不通過X。

846
00:34:34,020 --> 00:34:35,535
我們通過x的地址。

847
00:34:35,535 --> 00:34:37,330

848
00:34:37,330 --> 00:34:40,876
因此，而不是複製過
框的值，

849
00:34:40,876 --> 00:34:42,500
我仍然要複製過來的東西。

850
00:34:42,500 --> 00:34:45,380
不過，我複製了
盒子的地址。

851
00:34:45,380 --> 00:34:48,780
>> 所以，如果我通過的地址
框到五，然後到五

852
00:34:48,780 --> 00:34:51,560
將可以發現，在
內存和改變它的值。

853
00:34:51,560 --> 00:34:53,980

854
00:34:53,980 --> 00:34:59,580
>> 所以，再在那裡，我有
一個不是int了。

855
00:34:59,580 --> 00:35:00,882
a是一個int明星。

856
00:35:00,882 --> 00:35:02,090
這是一個指向整數的指針。

857
00:35:02,090 --> 00:35:03,790

858
00:35:03,790 --> 00:35:07,310
然後，因為我傳遞
在這裡討論，然後我做什麼

859
00:35:07,310 --> 00:35:10,530
是不是等於5，因為
一個是抱著一個地址。

860
00:35:10,530 --> 00:35:16,710
所以，我想要做的是去那裡
更新此地址的內容

861
00:35:16,710 --> 00:35:18,305
5。

862
00:35:18,305 --> 00:35:21,130
>> 好了，讓我們通過
所有的線逐個。

863
00:35:21,130 --> 00:35:22,410

864
00:35:22,410 --> 00:35:26,024
所以，當我從這裡開始，我
還有N / A，N / A，N / A

865
00:35:26,024 --> 00:35:28,440
一切在第一
行，因為我還沒有真正

866
00:35:28,440 --> 00:35:29,390
申報的東西呢。

867
00:35:29,390 --> 00:35:30,980

868
00:35:30,980 --> 00:35:35,110
然後線兩條，我有x等於3。

869
00:35:35,110 --> 00:35:38,020
一個int值，明星不存在，
同樣的事情之前。

870
00:35:38,020 --> 00:35:39,160

871
00:35:39,160 --> 00:35:40,640
>> 現在，它變得有趣。

872
00:35:40,640 --> 00:35:42,300
所以，我要過去。

873
00:35:42,300 --> 00:35:45,720
讓我們假設地址
x的是十六進制12。

874
00:35:45,720 --> 00:35:46,880

875
00:35:46,880 --> 00:35:48,420
讓我們姑且認為此。

876
00:35:48,420 --> 00:35:49,221
我做了起來。

877
00:35:49,221 --> 00:35:51,680

878
00:35:51,680 --> 00:35:53,500
那麼，我路過這裡是一個五。

879
00:35:53,500 --> 00:35:54,460
我路過12。

880
00:35:54,460 --> 00:35:56,390

881
00:35:56,390 --> 00:35:58,610
>> 那麼什麼樣的價值做了有哪些？

882
00:35:58,610 --> 00:36:04,785

883
00:36:04,785 --> 00:36:06,210
>> 學生：[聽不清]。

884
00:36:06,210 --> 00:36:06,950
>> 賓基：對不起？

885
00:36:06,950 --> 00:36:08,145
>> 學生：[聽不清]。

886
00:36:08,145 --> 00:36:10,520
賓基：是啊，像，以讓我們
假設我們在這裡，現在。

887
00:36:10,520 --> 00:36:11,540

888
00:36:11,540 --> 00:36:12,040
我問。

889
00:36:12,040 --> 00:36:12,915
>> 學生：[聽不清]。

890
00:36:12,915 --> 00:36:13,590

891
00:36:13,590 --> 00:36:14,890
>> 賓基：它已被啟動。

892
00:36:14,890 --> 00:36:15,860
>> 學生：[聽不清]。

893
00:36:15,860 --> 00:36:17,985
賓基：因為我們通過
東西向的功能。

894
00:36:17,985 --> 00:36:19,431

895
00:36:19,431 --> 00:36:19,930
是嗎？

896
00:36:19,930 --> 00:36:20,899
>> 學生：x的地址。

897
00:36:20,899 --> 00:36:22,690
賓基：這將
有x的地址。

898
00:36:22,690 --> 00:36:25,800
和x的地址是12，良好。

899
00:36:25,800 --> 00:36:30,990
所以x為將是3，因
我們還沒有真正改變X呢。

900
00:36:30,990 --> 00:36:36,700
然後將是12H處，所以
x的地址，因為這是

901
00:36:36,700 --> 00:36:38,840
我們通過向5什麼。

902
00:36:38,840 --> 00:36:40,940
>> 然後會發生什麼
如果我們試圖去那裡？

903
00:36:40,940 --> 00:36:42,145
我們怎麼找？

904
00:36:42,145 --> 00:36:47,120
因此，如果您嘗試打印一個明星，
我們要按照這個地址，

905
00:36:47,120 --> 00:36:48,620
並得到裡面的值。

906
00:36:48,620 --> 00:36:50,470
和值僅僅是
使得x的值相同

907
00:36:50,470 --> 00:36:53,980
有因為這是
x的地址，這將是3。

908
00:36:53,980 --> 00:36:55,440

909
00:36:55,440 --> 00:36:56,930
我們是好？

910
00:36:56,930 --> 00:36:59,990
>> OK，然後現在，我們實際上去那裡。

911
00:36:59,990 --> 00:37:05,510
我們更新什麼
是在這個地址12。

912
00:37:05,510 --> 00:37:07,390
我們讓5。

913
00:37:07,390 --> 00:37:10,560
所以，現在x和明星有5個。

914
00:37:10,560 --> 00:37:13,170

915
00:37:13,170 --> 00:37:13,680
>> 這是為什麼？

916
00:37:13,680 --> 00:37:17,070
因為x的地址是12。

917
00:37:17,070 --> 00:37:20,920
和一也具有12作為它的值。

918
00:37:20,920 --> 00:37:23,780
所以，如果我們按照12，我們
只是要找到X。

919
00:37:23,780 --> 00:37:27,400
所以，無論我們做
明星會發生什麼

920
00:37:27,400 --> 00:37:30,790
為x，因為一個包含
x的地址。

921
00:37:30,790 --> 00:37:31,918

922
00:37:31,918 --> 00:37:32,418
行？

923
00:37:32,418 --> 00:37:34,090

924
00:37:34,090 --> 00:37:37,750
>> 這就好比修復的關鍵。

925
00:37:37,750 --> 00:37:41,500
所以，現在我們能夠，
從五，實際

926
00:37:41,500 --> 00:37:43,840
存取存儲器住在主。

927
00:37:43,840 --> 00:37:47,980
因此，該內存不能住到
5，像以前一樣，這個地址12。

928
00:37:47,980 --> 00:37:50,980
而我們能夠去那裡
並改變其值設置為5。

929
00:37:50,980 --> 00:37:53,990
>> 然後當我們返回時，
我們忘記了一個。

930
00:37:53,990 --> 00:37:55,720
我們忘記了明星。

931
00:37:55,720 --> 00:37:57,020
和X仍然是5。

932
00:37:57,020 --> 00:37:58,327

933
00:37:58,327 --> 00:38:00,160
所以，如果你想
實現交換功能，

934
00:38:00,160 --> 00:38:05,010
你只需做同樣的事情，
除非你需要在這裡詮釋星，

935
00:38:05,010 --> 00:38:06,140
等，等等。

936
00:38:06,140 --> 00:38:06,976
行？

937
00:38:06,976 --> 00:38:07,475
我們是好？

938
00:38:07,475 --> 00:38:09,860

939
00:38:09,860 --> 00:38:10,610
涼爽。

940
00:38:10,610 --> 00:38:12,410
>> 所以，指針運算。

941
00:38:12,410 --> 00:38:13,960
這是一個稍微棘手的話題。

942
00:38:13,960 --> 00:38:16,554
所以，事實證明，
指針只是整數。

943
00:38:16,554 --> 00:38:17,970
你可以把它們看作整數。

944
00:38:17,970 --> 00:38:21,080
由於在內存中，你有一個像
存儲器地址的零個，一個，兩個，三個，

945
00:38:21,080 --> 00:38:21,900
四，五。

946
00:38:21,900 --> 00:38:23,900
因此，我們可以總結的內存地址。

947
00:38:23,900 --> 00:38:27,230
>> 而這通常是你做了什麼時
你在與陣列，例如。

948
00:38:27,230 --> 00:38:30,540
陣列就像是一個連續的
地段字符的內存塊，

949
00:38:30,540 --> 00:38:31,840
例如，大量的整數。

950
00:38:31,840 --> 00:38:34,420
所以，如果你想要去的
第二個int或到第三INT，

951
00:38:34,420 --> 00:38:37,830
你可以總結一些東西到第一
地址，你會到達那裡。

952
00:38:37,830 --> 00:38:39,620
所以這是真正有用的。

953
00:38:39,620 --> 00:38:41,850
>> 而事情保持
記住，雖然是

954
00:38:41,850 --> 00:38:45,140
它不只是喜歡
在這個意義上正常算術

955
00:38:45,140 --> 00:38:50,304
如果你正在處理的，說，
一個int明星，你把它加1，

956
00:38:50,304 --> 00:38:52,220
那麼你不會
加1到地址，

957
00:38:52,220 --> 00:38:53,950
你要添加4到地址。

958
00:38:53,950 --> 00:38:55,030

959
00:38:55,030 --> 00:38:56,670
因為int是4個字節。

960
00:38:56,670 --> 00:38:57,720

961
00:38:57,720 --> 00:38:59,540
>> 因此，這就像
走在陣列上。

962
00:38:59,540 --> 00:39:05,260
如果我們有大量的int數組和
那麼我們嘗試去到第二個，

963
00:39:05,260 --> 00:39:08,790
它基本上只是求和
第1加1的地址。

964
00:39:08,790 --> 00:39:10,040

965
00:39:10,040 --> 00:39:13,425
但是，這不會be--只是假設
這是第一個的地址是4。

966
00:39:13,425 --> 00:39:14,560

967
00:39:14,560 --> 00:39:16,250
這裡，在這種情況下。

968
00:39:16,250 --> 00:39:19,780

969
00:39:19,780 --> 00:39:22,850
如果我們總結，所以這
是發生了什麼。

970
00:39:22,850 --> 00:39:23,530
我們有一個int。

971
00:39:23,530 --> 00:39:25,640
詮釋x等於5。

972
00:39:25,640 --> 00:39:26,950
X有一個值5。

973
00:39:26,950 --> 00:39:31,240
我們初始化這個指針，整型
ÿ整數明星Y等於X的地址。

974
00:39:31,240 --> 00:39:33,660
>> 讓我們假定x的地址為4。

975
00:39:33,660 --> 00:39:36,960
有什麼事情發生
現在如果我總結加1到y？

976
00:39:36,960 --> 00:39:39,110

977
00:39:39,110 --> 00:39:44,790
這將實際
之4，而不是僅僅1。

978
00:39:44,790 --> 00:39:50,920
所以我添加了一個1，但它實際上
加4，由於計算機的智能。

979
00:39:50,920 --> 00:39:55,275
因此，它會實際上是由我添加時間
指針的類型的大小。

980
00:39:55,275 --> 00:39:56,340

981
00:39:56,340 --> 00:39:56,840
行？

982
00:39:56,840 --> 00:39:58,030

983
00:39:58,030 --> 00:40:02,440
>> 所以，如果它是一個字符，例如，
如果這是一個char明星Y，

984
00:40:02,440 --> 00:40:07,141
如果我們增加1，那麼這將
是如圖5所示，因為char是1字節長。

985
00:40:07,141 --> 00:40:07,640
好不好？

986
00:40:07,640 --> 00:40:10,560

987
00:40:10,560 --> 00:40:13,190
>> 終於，我們到了
指針和數組。

988
00:40:13,190 --> 00:40:16,451
事實證明，每一次
你正在處理一個數組，

989
00:40:16,451 --> 00:40:18,075
你實際上是在處理一個指針。

990
00:40:18,075 --> 00:40:19,720

991
00:40:19,720 --> 00:40:24,777
非常漂亮的概念的理由
這是一個數組是非常大的。

992
00:40:24,777 --> 00:40:27,360
因此請記住我說，
每次你繞過的東西的時候，

993
00:40:27,360 --> 00:40:29,097
您複製的一切。

994
00:40:29,097 --> 00:40:31,180
所以，如果你有一個數組
這是真的，真的大了，

995
00:40:31,180 --> 00:40:32,990
你真的不想要
複製一切，每次

996
00:40:32,990 --> 00:40:35,710
你把它傳遞給身邊的另一
功能，因為這只是

997
00:40:35,710 --> 00:40:37,190
大量的工作。

998
00:40:37,190 --> 00:40:39,710
所以你要做的就是剛剛過去的
的第一個字節的地址。

999
00:40:39,710 --> 00:40:40,969

1000
00:40:40,969 --> 00:40:44,010
然後該函數將可
在該數組中的所有元素。

1001
00:40:44,010 --> 00:40:48,670
所以，你通過了數組的地址，
這樣的第一個字節的地址。

1002
00:40:48,670 --> 00:40:53,010
>> 因此，如果我們宣布INT
排列3，在這裡，我們知道

1003
00:40:53,010 --> 00:40:57,470
如何訪問所述第一元件
用括號表示法。

1004
00:40:57,470 --> 00:41:02,410
如果你還記得的支架
符號，陣列支架0等於1。

1005
00:41:02,410 --> 00:41:06,330
那麼，這將是完全
一樣的只是去那裡，把1。

1006
00:41:06,330 --> 00:41:07,370

1007
00:41:07,370 --> 00:41:09,110
OK，是完全一樣的東西。

1008
00:41:09,110 --> 00:41:13,010
所以在這裡括號表示法
將是相同的，因為這行。

1009
00:41:13,010 --> 00:41:18,600
>> 你猜怎麼的括號表示法
對於陣列支架1會是什麼？

1010
00:41:18,600 --> 00:41:20,440
這也只是同樣的事情，因為這。

1011
00:41:20,440 --> 00:41:22,500
所以，增加一個陣列。

1012
00:41:22,500 --> 00:41:24,370
移動一個沿在內存中。

1013
00:41:24,370 --> 00:41:26,310
去那裡，並把2。

1014
00:41:26,310 --> 00:41:28,050

1015
00:41:28,050 --> 00:41:28,579
行？

1016
00:41:28,579 --> 00:41:29,870
而這條線是一回事。

1017
00:41:29,870 --> 00:41:34,860
我們要進入第三
中，所以數組加2。

1018
00:41:34,860 --> 00:41:37,465
去那裡，並把3。

1019
00:41:37,465 --> 00:41:39,340
所以在內存中，什麼是
事情發生是我們

1020
00:41:39,340 --> 00:41:44,400
將有1，2和3作為
這個數組的三個元素。

1021
00:41:44,400 --> 00:41:46,970
>> 我們可以做這樣使用
我們熟悉的括號符號。

1022
00:41:46,970 --> 00:41:49,410
我只想你們知道
他們是同樣的事情。

1023
00:41:49,410 --> 00:41:50,530

1024
00:41:50,530 --> 00:41:53,010
好了，關於這個問題嗎？

1025
00:41:53,010 --> 00:41:56,115

1026
00:41:56,115 --> 00:41:56,615
不錯。

1027
00:41:56,615 --> 00:41:57,990

1028
00:41:57,990 --> 00:41:59,880
現在，我要出手
它交給漢娜，

1029
00:41:59,880 --> 00:42:00,330
>> 漢娜：耶，飴，山楂。

1030
00:42:00,330 --> 00:42:02,246
>> 賓基：談
內存條的東西。

1031
00:42:02,246 --> 00:42:06,554
[掌聲]

1032
00:42:06,554 --> 00:42:10,150
>> 漢娜：你好，性涼，所以我們
要談多一點

1033
00:42:10,150 --> 00:42:13,090
關於內存，這是我們剛剛
解決使用指針。

1034
00:42:13,090 --> 00:42:16,060
因此，有兩個主要部分
記憶是我們關心的。

1035
00:42:16,060 --> 00:42:18,830
我們具有層疊，生長
在底部，堆，其

1036
00:42:18,830 --> 00:42:20,600
隨著從頂端向下。

1037
00:42:20,600 --> 00:42:24,690
和棧將舉辦
我們所有的實例變量。

1038
00:42:24,690 --> 00:42:28,860
因此，每個調用一個函數獲取
自己的小幀在堆棧中。

1039
00:42:28,860 --> 00:42:32,160
因此，作為加布前面提到的，如果我們
一次次調用該函數，

1040
00:42:32,160 --> 00:42:34,180
我們將堆棧
事情在堆棧中。

1041
00:42:34,180 --> 00:42:35,220

1042
00:42:35,220 --> 00:42:38,570
>> 同樣，堆，
這開始於頂端

1043
00:42:38,570 --> 00:42:42,660
將要舉辦的所有記憶
我們動態分配。

1044
00:42:42,660 --> 00:42:45,110
所以當我們動態
分配內存，

1045
00:42:45,110 --> 00:42:47,580
這將回落走向底部。

1046
00:42:47,580 --> 00:42:51,340
幾件事情要注意的時
我們使用了棧和堆，

1047
00:42:51,340 --> 00:42:55,200
與堆棧，如果我們有太
many--讓我們say--遞歸調用，

1048
00:42:55,200 --> 00:42:58,392
而且我們再次調用一個函數，
又一次，又一次，又一次，

1049
00:42:58,392 --> 00:43:00,350
而且它疊加起來，
堆放，堆放。

1050
00:43:00,350 --> 00:43:01,570
而且它要撞上了堆。

1051
00:43:01,570 --> 00:43:03,040
我們將耗盡內存。

1052
00:43:03,040 --> 00:43:05,100
這是怎麼回事引起
問題的計算機。

1053
00:43:05,100 --> 00:43:06,770
這就是所謂的堆棧溢出。

1054
00:43:06,770 --> 00:43:09,728
所以，這絕對是你
應該認識到，並盡量避免。

1055
00:43:09,728 --> 00:43:10,228

1056
00:43:10,228 --> 00:43:14,050
和堆，一定要記住
不小心洩露內存。

1057
00:43:14,050 --> 00:43:17,950
您使用的malloc任何時候，不要
忘記釋放內存。

1058
00:43:17,950 --> 00:43:20,040
否則，它會只
上浪費了一堆，

1059
00:43:20,040 --> 00:43:23,230
和電腦將不知道
它是可以自由地使用該存儲器。

1060
00:43:23,230 --> 00:43:25,810
因此，這些都是有兩件事情
要非常小心，當

1061
00:43:25,810 --> 00:43:28,580
你處理
棧和堆。

1062
00:43:28,580 --> 00:43:30,412
這個有問題嗎？

1063
00:43:30,412 --> 00:43:31,304
真棒。

1064
00:43:31,304 --> 00:43:31,900
>> OK，爽。

1065
00:43:31,900 --> 00:43:32,940

1066
00:43:32,940 --> 00:43:36,810
所以這類具有相同的
想法是堆棧溢出，在那裡

1067
00:43:36,810 --> 00:43:39,850
我們要超越
什麼內存邊界

1068
00:43:39,850 --> 00:43:41,960
是我們應該能夠使用。

1069
00:43:41,960 --> 00:43:45,077
因此採取，例如，緩衝液，或者你
可以只把它看作是一個數組。

1070
00:43:45,077 --> 00:43:47,660
和我們說，好了，我們要
創建這個可愛的小陣。

1071
00:43:47,660 --> 00:43:49,140
這將是一個字符串。

1072
00:43:49,140 --> 00:43:50,630
或者，它會存儲字符。

1073
00:43:50,630 --> 00:43:51,720
它只是會打個招呼。

1074
00:43:51,720 --> 00:43:52,678
而且它是不確定的。

1075
00:43:52,678 --> 00:43:53,990
就是這樣。

1076
00:43:53,990 --> 00:43:58,240
>> 但如果我是邪惡的人，想
做壞事與此陣，是什麼

1077
00:43:58,240 --> 00:44:02,310
我所能做的就是盡量寫
過去的字符串的末尾。

1078
00:44:02,310 --> 00:44:04,490
正如你所看到的，如果
我寫的遠遠不夠，

1079
00:44:04,490 --> 00:44:06,980
其實我可以影響
返回地址。

1080
00:44:06,980 --> 00:44:09,530
如果我開始影響
的返回地址，

1081
00:44:09,530 --> 00:44:11,730
我影響程序的實際運行方式。

1082
00:44:11,730 --> 00:44:15,900
而不是和返回，你
眾所周知，一個幸福的串像你好，我

1083
00:44:15,900 --> 00:44:19,460
可以做壞事一樣去
其他地方的計算機，仍然

1084
00:44:19,460 --> 00:44:22,146
記憶，改變它，
無論我想做的事情。

1085
00:44:22,146 --> 00:44:25,020
所以，這就是這個看起來像
是正中下懷，如果我填起來

1086
00:44:25,020 --> 00:44:27,400
隨機垃圾的價值，
在這種情況下，僅僅一個。

1087
00:44:27,400 --> 00:44:30,490
然後其實我
到了存儲器地址，

1088
00:44:30,490 --> 00:44:33,740
我開始與一些加油吧
這確實是我想要做的事。

1089
00:44:33,740 --> 00:44:34,952

1090
00:44:34,952 --> 00:44:36,410
與緩衝區溢出的問題嗎？

1091
00:44:36,410 --> 00:44:38,450

1092
00:44:38,450 --> 00:44:40,730
真棒，飛行權
通過這個東西。

1093
00:44:40,730 --> 00:44:43,530
>> 好了，我們談了很多
約在終場前加布。

1094
00:44:43,530 --> 00:44:45,790
我們如何真正得到一個指針？

1095
00:44:45,790 --> 00:44:48,070
我們怎樣才能在內存中的地址？

1096
00:44:48,070 --> 00:44:51,040
好了，我們可以使用這個漂亮
函數調用malloc的，這

1097
00:44:51,040 --> 00:44:53,370
是會得到一個
小片的內存，

1098
00:44:53,370 --> 00:44:55,480
特別是在
堆，正如我們所討論的，

1099
00:44:55,480 --> 00:44:59,780
而且它會給你回
指針在存儲器中的地址。

1100
00:44:59,780 --> 00:45:01,950
和參數，我們
不得不放棄對malloc

1101
00:45:01,950 --> 00:45:04,280
是我們多大的空間在內存中想要的。

1102
00:45:04,280 --> 00:45:06,100
>> 所以，你可以看到在字節大小。

1103
00:45:06,100 --> 00:45:08,670
比方說，例如，或
實際上，在這個例子中，

1104
00:45:08,670 --> 00:45:12,040
我們分配足夠的
空間10的整數。

1105
00:45:12,040 --> 00:45:15,640
所以可能我們會想
把這裡的10個整數組成的數組。

1106
00:45:15,640 --> 00:45:19,641
所以我們給它int的大小，這
我們學到了多少字節？

1107
00:45:19,641 --> 00:45:20,140
學生：4。

1108
00:45:20,140 --> 00:45:22,920
漢娜：4，美觀，而且我們
要10中的那些行，

1109
00:45:22,920 --> 00:45:28,050
因此，我們有足夠的空間來
存儲所有的10個整數，在這種情況下。

1110
00:45:28,050 --> 00:45:31,290
一些超級重要的，
任何時候你調用malloc，

1111
00:45:31,290 --> 00:45:32,880
你要檢查空。

1112
00:45:32,880 --> 00:45:37,310
如果你不檢查空，好了，
malloc的，如果它運行的空間

1113
00:45:37,310 --> 00:45:40,400
並且再也不能給你任何
更多的內存，它會返回null。

1114
00:45:40,400 --> 00:45:42,060

1115
00:45:42,060 --> 00:45:45,630
所以，如果你不檢查，
malloc的可能返回null。

1116
00:45:45,630 --> 00:45:51,265
然後，如果我們試圖
取消引用空指針，

1117
00:45:51,265 --> 00:45:54,960
我們將得到一個段錯誤，
我們將談論現在。

1118
00:45:54,960 --> 00:45:56,150

1119
00:45:56,150 --> 00:45:56,650
真棒。

1120
00:45:56,650 --> 00:45:58,300
>> OK，使用malloc問題？

1121
00:45:58,300 --> 00:46:00,044

1122
00:46:00,044 --> 00:46:00,544
是嗎？

1123
00:46:00,544 --> 00:46:05,460
>> 學生：檢查是否為空
[聽不清]不要在測驗做呢？

1124
00:46:05,460 --> 00:46:08,100
>> 漢娜：當然，問題是
它matter--的測驗，

1125
00:46:08,100 --> 00:46:10,420
你會獲得積分，如果關閉
你不檢查空？

1126
00:46:10,420 --> 00:46:12,794
是的，你會得到點關閉
如果你不檢查空。

1127
00:46:12,794 --> 00:46:16,030
任何時候你調用malloc，無論在
測驗和你的pset和在現實生活中，

1128
00:46:16,030 --> 00:46:17,155
你要檢查空。

1129
00:46:17,155 --> 00:46:18,330
很好的問題。

1130
00:46:18,330 --> 00:46:19,689
>> 蓋柏：如果我不自由是什麼？

1131
00:46:19,689 --> 00:46:21,730
漢娜：加布想知道
如果我們做的不是免費的。

1132
00:46:21,730 --> 00:46:25,030
然後，我們將有一個
在我們的堆內存洩漏。

1133
00:46:25,030 --> 00:46:26,140
還有沒有其他問題？

1134
00:46:26,140 --> 00:46:27,550
是嗎？

1135
00:46:27,550 --> 00:46:30,120
>> 學生：你 - 可以走了
緩衝區溢出一次真正的快？

1136
00:46:30,120 --> 00:46:30,530
>> 漢娜：當然。

1137
00:46:30,530 --> 00:46:33,071
現在的問題是，我們可以走了過來
緩衝區溢出的真快。

1138
00:46:33,071 --> 00:46:35,050
讓我們回到那些幻燈片。

1139
00:46:35,050 --> 00:46:37,430
所以緩衝區，你可以
認為它是一個數組，對不對？

1140
00:46:37,430 --> 00:46:39,360
你必須在內存中的一些空間。

1141
00:46:39,360 --> 00:46:43,580
當我們第一次創建我們的數組，
我們知道數組有固定的大小，

1142
00:46:43,580 --> 00:46:45,470
或者我們的緩衝區具有固定大小。

1143
00:46:45,470 --> 00:46:51,360
>> 所以我們說在這種情況下，我們剛
足夠的空間來寫字符串hello。

1144
00:46:51,360 --> 00:46:57,340
如果我們走過去的束縛，如果我們走過去
什麼我們的數組，我們說，它可能保持，

1145
00:46:57,340 --> 00:46:59,780
我們可以真正開始
寫入到內存

1146
00:46:59,780 --> 00:47:01,780
該計算機不
要我們寫進去。

1147
00:47:01,780 --> 00:47:02,810

1148
00:47:02,810 --> 00:47:05,580
具體而言，如果我們打
類似的回報

1149
00:47:05,580 --> 00:47:08,700
該函數的地址，其中
像任何其它塊的存儲器，

1150
00:47:08,700 --> 00:47:11,420
只是放在你的
電腦，你其實可以

1151
00:47:11,420 --> 00:47:14,080
改變這種狀況，並開始做邪惡的事情。

1152
00:47:14,080 --> 00:47:15,272
回答你的問題？

1153
00:47:15,272 --> 00:47:16,230
真棒，什麼事嗎？

1154
00:47:16,230 --> 00:47:17,466
是嗎？

1155
00:47:17,466 --> 00:47:21,948
>> 學生：所以棧[聽不清]，你
從底部所說的去往上走。

1156
00:47:21,948 --> 00:47:25,434
在堆棧範圍，不
從一樣的內存去，

1157
00:47:25,434 --> 00:47:27,230
自上而下涉及各個擊破？

1158
00:47:27,230 --> 00:47:28,646

1159
00:47:28,646 --> 00:47:32,100
>> 漢娜：如何看待你 - 
推遲搶在這一個。

1160
00:47:32,100 --> 00:47:35,370

1161
00:47:35,370 --> 00:47:38,213
>> 羅伯：這將在同一生長
方向堆棧增長。

1162
00:47:38,213 --> 00:47:38,712
漢娜：OK。

1163
00:47:38,712 --> 00:47:40,967
羅伯：所以我感到困惑。

1164
00:47:40,967 --> 00:47:42,331
這將是抽象。

1165
00:47:42,331 --> 00:47:42,831
漢娜：OK。

1166
00:47:42,831 --> 00:47:44,000
羅伯：這是正確的。

1167
00:47:44,000 --> 00:47:49,420
因此，如果堆棧的增長
起來，然後generally--它

1168
00:47:49,420 --> 00:47:52,380
並不一定是這樣。
但是你可以聲明INT X。

1169
00:47:52,380 --> 00:47:54,120
然後，您聲明整數年。

1170
00:47:54,120 --> 00:47:57,300
然後整數x將通常是
較低的堆棧比INT Y開。

1171
00:47:57,300 --> 00:47:59,300
但是，這只是一個事實。

1172
00:47:59,300 --> 00:48:02,410
這不像一個重要種子的事情。

1173
00:48:02,410 --> 00:48:06,800
>> 羅伯：所以問題又是剛剛
發生什麼事每一幀積聚。

1174
00:48:06,800 --> 00:48:08,960
因此，每個函數獲取
小片疊。

1175
00:48:08,960 --> 00:48:13,030
正如你走了，內
小片，該幀之內，

1176
00:48:13,030 --> 00:48:16,710
我們說的變量
該框架內也動了起來。

1177
00:48:16,710 --> 00:48:17,473
問題？

1178
00:48:17,473 --> 00:48:18,688
>> 羅伯：只是要對麥克風。

1179
00:48:18,688 --> 00:48:19,396
漢娜：哦，是的。

1180
00:48:19,396 --> 00:48:20,440
羅伯：我會對著你。

1181
00:48:20,440 --> 00:48:21,410
漢娜：哦，是的，確定。

1182
00:48:21,410 --> 00:48:24,150
羅伯：是個例外
對於數組和結構，

1183
00:48:24,150 --> 00:48:27,470
其中陣列，低級
索引數組中，

1184
00:48:27,470 --> 00:48:29,930
而在結構中以較高的
在結構領域

1185
00:48:29,930 --> 00:48:35,040
保證是在低地址
比陣列中的購買值。

1186
00:48:35,040 --> 00:48:36,720
因此，這些都是保證。

1187
00:48:36,720 --> 00:48:40,310
但是在任何特定的變量，
如int x和函數中的INT Y，

1188
00:48:40,310 --> 00:48:43,030
有沒有必然的關係
他們的地址之間。

1189
00:48:43,030 --> 00:48:44,882

1190
00:48:44,882 --> 00:48:46,340
漢娜：在這裡還有一個問題？

1191
00:48:46,340 --> 00:48:51,620
學生：所以在緩衝
流，只有緩衝區溢出

1192
00:48:51,620 --> 00:48:54,980
只有當發生了你
有一樣，分配

1193
00:48:54,980 --> 00:49:01,056
陣列的量
說那麼大？

1194
00:49:01,056 --> 00:49:03,230
就像，你能嗎？

1195
00:49:03,230 --> 00:49:05,435
所以，如果你問了
從user--東西

1196
00:49:05,435 --> 00:49:06,018
>> 漢娜：嗯。

1197
00:49:06,018 --> 00:49:08,600
學生：他們能強行
給你的東西回來

1198
00:49:08,600 --> 00:49:11,777
這比任何大
你已經分配給他們呢？

1199
00:49:11,777 --> 00:49:13,610
漢娜：當然，這樣的
問題是根本，

1200
00:49:13,610 --> 00:49:16,217
可以在用戶給你
比你要求什麼呢？

1201
00:49:16,217 --> 00:49:16,800
學生：是啊。

1202
00:49:16,800 --> 00:49:18,480
漢娜：嗯，你可以阻止
從做用戶。

1203
00:49:18,480 --> 00:49:21,350
你能具體說了不
給我更多的不是通過字節×號

1204
00:49:21,350 --> 00:49:24,330
我只給你空間X號
字節，X字符數。

1205
00:49:24,330 --> 00:49:25,700
所以這是要防止的東西。

1206
00:49:25,700 --> 00:49:26,199
是嗎？

1207
00:49:26,199 --> 00:49:30,270
之間的區別是什麼
堆棧溢出，緩衝區溢出？

1208
00:49:30,270 --> 00:49:32,140
>> 漢娜：OK，所以堆棧
overflow--哦，是什麼

1209
00:49:32,140 --> 00:49:34,790
是堆棧之間的差
溢出，緩衝區溢出？

1210
00:49:34,790 --> 00:49:37,581
因此，我們要思考的堆棧溢出
發生的事情，當我們真正

1211
00:49:37,581 --> 00:49:39,530
堆放這些函數調用。

1212
00:49:39,530 --> 00:49:42,991
比方說，你有一個遞歸函數，
因為我們知道，你的每一次

1213
00:49:42,991 --> 00:49:45,240
調用一個函數，它得到
自己的幀在堆棧中。

1214
00:49:45,240 --> 00:49:47,950
>> 因此，我們堆起來太高了，
然後我們開始溢出。

1215
00:49:47,950 --> 00:49:50,530
而我們使用太多的內存，並且
我們沒有在任何地方留下。

1216
00:49:50,530 --> 00:49:51,590
我們得到這個錯誤。

1217
00:49:51,590 --> 00:49:53,930
>> 緩衝區溢出是程序中。

1218
00:49:53,930 --> 00:49:57,180
我們想未必有
以相同的方式運行的內存

1219
00:49:57,180 --> 00:50:00,080
我們可能如果我們疊放
這麼多的函數調用，

1220
00:50:00,080 --> 00:50:04,540
但是我們過去寫的記憶
我們知道我們可以使用。

1221
00:50:04,540 --> 00:50:06,170
並允許我們做邪惡的事情。

1222
00:50:06,170 --> 00:50:08,060

1223
00:50:08,060 --> 00:50:08,560
是嗎？

1224
00:50:08,560 --> 00:50:10,950
>> 羅伯：是的，你可能想
只是重複這一點，

1225
00:50:10,950 --> 00:50:12,699
但你也可以認為
堆棧溢出

1226
00:50:12,699 --> 00:50:15,374
如象一個特定類型
緩衝區溢出。

1227
00:50:15,374 --> 00:50:17,665
或者你只是想你
堆棧作為一個非常大的緩衝區。

1228
00:50:17,665 --> 00:50:20,724
然後，當你漫過你疊，
這有點像一個緩衝區溢出。

1229
00:50:20,724 --> 00:50:23,390
但堆棧溢出只是一個
特定術語使用的堆棧時，

1230
00:50:23,390 --> 00:50:24,310
本身的溢出。

1231
00:50:24,310 --> 00:50:27,500
>> 漢娜：對，所以要
重複的視頻，

1232
00:50:27,500 --> 00:50:31,756
它，你能想到的堆棧溢出的
一種特定類型的緩衝區溢出。

1233
00:50:31,756 --> 00:50:33,040
很酷吧？

1234
00:50:33,040 --> 00:50:34,562
任何問題之前，我們去？

1235
00:50:34,562 --> 00:50:35,380

1236
00:50:35,380 --> 00:50:35,880
真棒。

1237
00:50:35,880 --> 00:50:37,130

1238
00:50:37,130 --> 00:50:39,727
>> OK，很酷，所以讓我們來談談
一些常見的錯誤信息。

1239
00:50:39,727 --> 00:50:42,060
這是值得擁有
在多個測驗顯示了，

1240
00:50:42,060 --> 00:50:44,740
這樣的東西，值得
取二看。

1241
00:50:44,740 --> 00:50:46,860
我敢肯定，你已經遇到了
至少其中的一些

1242
00:50:46,860 --> 00:50:48,690
因為你做你的習題集。

1243
00:50:48,690 --> 00:50:50,980
所以一定要確保你可以談
關於他們的測驗。

1244
00:50:50,980 --> 00:50:52,990
>> 所以，第一個是
分段故障。

1245
00:50:52,990 --> 00:50:55,250
這就是任何時候我們
嘗試訪問內存

1246
00:50:55,250 --> 00:50:57,130
那我們不允許訪問。

1247
00:50:57,130 --> 00:51:00,280
所以，你migh已經看到了這一點，
例如，在突破。

1248
00:51:00,280 --> 00:51:03,390
如果檢測到碰撞
返回null，然後你

1249
00:51:03,390 --> 00:51:05,500
嘗試做一些事情
與空值，

1250
00:51:05,500 --> 00:51:08,147
電腦會給
你分段故障。

1251
00:51:08,147 --> 00:51:10,730
所以有一個重要的事情
做才能盡量避免這種

1252
00:51:10,730 --> 00:51:12,000
要經常檢查是否為空。

1253
00:51:12,000 --> 00:51:13,300

1254
00:51:13,300 --> 00:51:16,180
>> 你可能也看到了
函數隱式聲明。

1255
00:51:16,180 --> 00:51:18,370
因此，這是什麼情況
當佳佳向您展示

1256
00:51:18,370 --> 00:51:20,150
我們如何做一個原型，對不對？

1257
00:51:20,150 --> 00:51:23,440
所以我們可以說我們有一些
函數，我們定義。

1258
00:51:23,440 --> 00:51:24,440
比方說，多維數據集。

1259
00:51:24,440 --> 00:51:27,120
而且去底部
我們的功能，在主。

1260
00:51:27,120 --> 00:51:35,205
>> 如果我們忘了告訴電腦
多維數據集，主要在嘗試調用立方體，

1261
00:51:35,205 --> 00:51:36,830
電腦會一樣，哦，我的天哪。

1262
00:51:36,830 --> 00:51:38,300
我不知道這意味著什麼。

1263
00:51:38,300 --> 00:51:39,760
我不知道該怎麼辦，在這裡。

1264
00:51:39,760 --> 00:51:41,594
因此，原型說不用擔心。

1265
00:51:41,594 --> 00:51:42,510
我要告訴你。

1266
00:51:42,510 --> 00:51:43,132
>> 它會來的。

1267
00:51:43,132 --> 00:51:43,840
不要罵我。

1268
00:51:43,840 --> 00:51:46,697
不要給我一個隱含的
申報功能。

1269
00:51:46,697 --> 00:51:49,280
所以，如果你得到這個錯誤，一是
事情你會想要做

1270
00:51:49,280 --> 00:51:50,821
為確保你有你的原型。

1271
00:51:50,821 --> 00:51:52,320

1272
00:51:52,320 --> 00:51:53,230
行？

1273
00:51:53,230 --> 00:51:55,680
>> 最後但並非最不重要的，
未聲明的標識符

1274
00:51:55,680 --> 00:52:00,570
基本上，當您嘗試使用
你沒有聲明的變量。

1275
00:52:00,570 --> 00:52:03,449
所以，突然你開始
他說像n與加。

1276
00:52:03,449 --> 00:52:04,740
和電腦說什麼是N +

1277
00:52:04,740 --> 00:52:06,660
你從來沒有告訴過我ñ是一件事。

1278
00:52:06,660 --> 00:52:10,930
>> 這麼一件事，你必須確保你
所做的是告訴一下，n是計算機。

1279
00:52:10,930 --> 00:52:13,320
因此，例如，n可以是一個整數。

1280
00:52:13,320 --> 00:52:14,999
然後你會避免這個錯誤。

1281
00:52:14,999 --> 00:52:16,290
在常見的錯誤有問題嗎？

1282
00:52:16,290 --> 00:52:17,260
是嗎？

1283
00:52:17,260 --> 00:52:19,344
>> 學生：對於隱
聲明函數，

1284
00:52:19,344 --> 00:52:22,343
難道也是你省略1
圖書館的你應該

1285
00:52:22,343 --> 00:52:24,400
以包括，而不是原型？

1286
00:52:24,400 --> 00:52:26,359
>> 漢娜：對，所以在
問題是，你能不能

1287
00:52:26,359 --> 00:52:28,650
也得到這個錯誤，如果你
忘了包括圖書館。

1288
00:52:28,650 --> 00:52:29,085
>> 學生：是的。

1289
00:52:29,085 --> 00:52:30,876
>> 漢娜：當然，
因為以相同的方式

1290
00:52:30,876 --> 00:52:33,540
我們希望把我們的原型
在main函數之前，

1291
00:52:33,540 --> 00:52:37,717
如果我們有一個庫中，那些打算
基本上包括了原型，

1292
00:52:37,717 --> 00:52:39,425
包括定義
的功能。

1293
00:52:39,425 --> 00:52:40,585
大的問題。

1294
00:52:40,585 --> 00:52:43,230
>> 學生：對於分割
故障，將也

1295
00:52:43,230 --> 00:52:47,350
發生，如果我們一樣，試過
訪問一個變量，

1296
00:52:47,350 --> 00:52:51,947
等，以不同的[聽不清]
比它在聲明？

1297
00:52:51,947 --> 00:52:54,030
漢娜：當然，所以我們會
得到段錯誤

1298
00:52:54,030 --> 00:52:56,270
如果我們試圖訪問一個
變量超出了範圍？

1299
00:52:56,270 --> 00:52:57,104
那是個問題嗎？

1300
00:52:57,104 --> 00:52:57,645
學生：是的。

1301
00:52:57,645 --> 00:52:58,430
漢娜：美麗的。

1302
00:52:58,430 --> 00:53:01,840
所以很可能，你會得到一個
未聲明的標識符錯誤信息。

1303
00:53:01,840 --> 00:53:04,006
所以它只是會說
我不知道那是什麼。

1304
00:53:04,006 --> 00:53:04,920

1305
00:53:04,920 --> 00:53:05,920
爽，什麼事嗎？

1306
00:53:05,920 --> 00:53:07,744

1307
00:53:07,744 --> 00:53:08,980
是啊，好，漂亮。

1308
00:53:08,980 --> 00:53:10,330

1309
00:53:10,330 --> 00:53:12,400
>> 所有用右手，所以遞歸。

1310
00:53:12,400 --> 00:53:15,160
所以我提到幾次
我們可能會得到一個堆棧溢出

1311
00:53:15,160 --> 00:53:17,919
因為我們調用我們
遞歸函數這麼多次。

1312
00:53:17,919 --> 00:53:20,210
我們正在所有這些堆棧
框架，等等，等等，等等。

1313
00:53:20,210 --> 00:53:22,420
什麼甚至是一個遞歸函數？

1314
00:53:22,420 --> 00:53:25,680
那麼，一個遞歸函數是
調用本身的任何功能。

1315
00:53:25,680 --> 00:53:26,820

1316
00:53:26,820 --> 00:53:30,160
>> 有些事情要注意的，當你
正在執行遞歸函數，

1317
00:53:30,160 --> 00:53:31,940
不要忘了包括基本情況。

1318
00:53:31,940 --> 00:53:34,010
一個基本的情況是
點，我們結束了。

1319
00:53:34,010 --> 00:53:38,740
所以，例如，如果我們的編碼，
，說，斐波那契遞歸，

1320
00:53:38,740 --> 00:53:43,210
我們要確保，當我們得到
到0或第一斐波那契數，

1321
00:53:43,210 --> 00:53:46,220
這兩個數字有這些情況下，
因為那些不依賴

1322
00:53:46,220 --> 00:53:47,700
在東西來到之前。

1323
00:53:47,700 --> 00:53:48,990
那些有自己的價值觀。

1324
00:53:48,990 --> 00:53:51,270

1325
00:53:51,270 --> 00:53:55,320
>> 有的優點來遞歸，這是一個
我們已經看到在過去的測驗問題。

1326
00:53:55,320 --> 00:53:57,930
它們可以導致更
簡潔，優雅的代碼。

1327
00:53:57,930 --> 00:54:00,510
和很多功能，一
許多不同的算法，

1328
00:54:00,510 --> 00:54:02,350
其實借給自己遞歸。

1329
00:54:02,350 --> 00:54:05,510
它們的定義可能是
在遞歸本身。

1330
00:54:05,510 --> 00:54:06,980
所以，斐波那契就是其中之一。

1331
00:54:06,980 --> 00:54:07,860
階乘是其中之一。

1332
00:54:07,860 --> 00:54:10,480
合併排序是埃德蒙頓所有
東西，你可以看看。

1333
00:54:10,480 --> 00:54:12,650

1334
00:54:12,650 --> 00:54:13,460
OK，什麼問題？

1335
00:54:13,460 --> 00:54:13,960
是嗎？

1336
00:54:13,960 --> 00:54:15,644

1337
00:54:15,644 --> 00:54:19,612
>> 學生：是的一角情況
類似於基本情況？

1338
00:54:19,612 --> 00:54:22,590
或者是，對於一些其他
種[聽不清]？

1339
00:54:22,590 --> 00:54:25,170
>> 漢娜：當然，這樣一
角落裡的情況是any--如此

1340
00:54:25,170 --> 00:54:27,580
是角落的情況下一樣基本情況？

1341
00:54:27,580 --> 00:54:32,825
一個角落的情況是什麼，你的
代碼的行為可能有點不同。

1342
00:54:32,825 --> 00:54:34,450

1343
00:54:34,450 --> 00:54:38,610
排序的基本情況是相關的，在
他們就像特殊情況

1344
00:54:38,610 --> 00:54:40,240
你想看看。

1345
00:54:40,240 --> 00:54:43,240
但是，一個基本情況的想法是，
你希望你的遞歸函數

1346
00:54:43,240 --> 00:54:44,870
停在某一點。

1347
00:54:44,870 --> 00:54:46,490
它不能讓自稱永遠。

1348
00:54:46,490 --> 00:54:47,781
它需要停止在某一點。

1349
00:54:47,781 --> 00:54:49,340

1350
00:54:49,340 --> 00:54:53,460
>> 羅伯：是的，頻繁的，您的基本情況
可能的轉角鹼的例子。

1351
00:54:53,460 --> 00:54:55,876
>> 漢娜：對，冷靜，什麼？

1352
00:54:55,876 --> 00:54:58,732
>> 學生：你能解釋一下
立足多一點點？

1353
00:54:58,732 --> 00:55:01,600
我不太明白
[聽不清]基地的情況。

1354
00:55:01,600 --> 00:55:02,676
>> 基地情況：漢娜？

1355
00:55:02,676 --> 00:55:03,140
>> 學生：基礎的情況下，是的。

1356
00:55:03,140 --> 00:55:03,770
>> 漢娜：哦，是的，肯定的。

1357
00:55:03,770 --> 00:55:04,270
讓我們來看看。

1358
00:55:04,270 --> 00:55:05,480
我們有粉筆在這裡？

1359
00:55:05,480 --> 00:55:06,690

1360
00:55:06,690 --> 00:55:07,320
是的，我們做的。

1361
00:55:07,320 --> 00:55:09,530
好了，真的很快，我就
試著寫夠大

1362
00:55:09,530 --> 00:55:11,320
這樣你就可以在屏幕上看到。

1363
00:55:11,320 --> 00:55:13,490
讓我們來談談，真的
很快，斐波那契。

1364
00:55:13,490 --> 00:55:15,550
所以，我給你的Fibonacci序列。

1365
00:55:15,550 --> 00:55:17,090
你可以看一下定義。

1366
00:55:17,090 --> 00:55:26,050
>> 本質上，序列中的每個數
是前兩個數字的總和。

1367
00:55:26,050 --> 00:55:29,720
OK，這樣的方式，我
剛才描述的斐波那契，

1368
00:55:29,720 --> 00:55:31,530
你能聽到的遞歸，對不對？

1369
00:55:31,530 --> 00:55:35,280
當我說的每一個號碼是
前兩個數字之和，

1370
00:55:35,280 --> 00:55:36,420
我們可以說OK。

1371
00:55:36,420 --> 00:55:38,570
那麼，第n個斐波納契
number--讓我們

1372
00:55:38,570 --> 00:55:42,260
說我們有這個功能
所謂的n fib-- FIB

1373
00:55:42,260 --> 00:55:48,260
將是等於謊
為n減1 plus--對不起，

1374
00:55:48,260 --> 00:55:51,240
我們將繼續到下一行
在N減去2這裡 -  FIB。

1375
00:55:51,240 --> 00:55:52,790

1376
00:55:52,790 --> 00:55:56,790
>> 好了，這個工程很大，如果你
看，例如，零個，一個

1377
00:55:56,790 --> 00:55:59,410
兩個，三個，四個，
第五斐波那契數，

1378
00:55:59,410 --> 00:56:03,561
在那裡，你可以說，
圖5是等於2加3。

1379
00:56:03,561 --> 00:56:05,060
但是，如果你一開始是什麼？

1380
00:56:05,060 --> 00:56:07,184
如果你只是打什麼
前兩個值？

1381
00:56:07,184 --> 00:56:08,470

1382
00:56:08,470 --> 00:56:11,330
>> 為了得到這個1，你不能
說加了前兩個，

1383
00:56:11,330 --> 00:56:13,930
因為零還有 - 我不知道。

1384
00:56:13,930 --> 00:56:15,390
所以在某些時候，我們需要停止。

1385
00:56:15,390 --> 00:56:21,250
在某些時候，我們需要指出，這些
兩者正好有自己的定義。

1386
00:56:21,250 --> 00:56:23,890
0斐波那契數為0。

1387
00:56:23,890 --> 00:56:26,115
和第一斐波那契數為1。

1388
00:56:26,115 --> 00:56:34,120
>> 因此，這樣我可能會編寫這一點，我
會說，如果n小於2，

1389
00:56:34,120 --> 00:56:35,130
然後就返回否。

1390
00:56:35,130 --> 00:56:36,494
這將是我的基本情況。

1391
00:56:36,494 --> 00:56:38,660
這就是我怎麼知道停止
用一個遞歸函數。

1392
00:56:38,660 --> 00:56:40,640

1393
00:56:40,640 --> 00:56:41,410
清楚了嗎？

1394
00:56:41,410 --> 00:56:41,940
真棒。

1395
00:56:41,940 --> 00:56:43,260
別的遞歸？

1396
00:56:43,260 --> 00:56:44,890

1397
00:56:44,890 --> 00:56:45,930
美麗。

1398
00:56:45,930 --> 00:56:48,750
>> 讓我們趕緊說說
搜索和排序的運行時間。

1399
00:56:48,750 --> 00:56:52,660
然後我會給一些達文
時間談論編碼的例子。

1400
00:56:52,660 --> 00:56:56,490
因此，這裡是主要的搜索和
各種各樣的，你應該知道的。

1401
00:56:56,490 --> 00:56:59,500
Guarantee--我不能保證，
因為我還沒有看到quiz--

1402
00:56:59,500 --> 00:57:01,940
但出現競猜
測驗後，後退出。

1403
00:57:01,940 --> 00:57:04,050
所以肯定使用這個表。

1404
00:57:04,050 --> 00:57:05,682
像，藉此圖。

1405
00:57:05,682 --> 00:57:06,890
把它放到你的備忘單。

1406
00:57:06,890 --> 00:57:07,931
你會成為一個快樂的人。

1407
00:57:07,931 --> 00:57:09,010

1408
00:57:09,010 --> 00:57:12,590
>> 這告訴我們，每一個運行時間
這些排序和搜索算法。

1409
00:57:12,590 --> 00:57:14,020

1410
00:57:14,020 --> 00:57:18,850
所以線性搜索，你可以看到運行
時間，並且同樣與二進制搜索。

1411
00:57:18,850 --> 00:57:21,490
去了一下這些算法
這樣做，一般的想法。

1412
00:57:21,490 --> 00:57:24,220
看一些偽代碼，
如果不是代碼本身。

1413
00:57:24,220 --> 00:57:25,610

1414
00:57:25,610 --> 00:57:30,380
>> 你會看到，冒泡排序有上
束縛在n的最壞情況的平方。

1415
00:57:30,380 --> 00:57:31,490

1416
00:57:31,490 --> 00:57:34,680
所以，如果我們的數組是完全
倒退之前，我們想對它進行排序，

1417
00:57:34,680 --> 00:57:37,090
我們會說，這是
要取n的平方的步驟。

1418
00:57:37,090 --> 00:57:38,160

1419
00:57:38,160 --> 00:57:41,730
但是在最好的情況下，這樣的
下界為最好的情況下

1420
00:57:41,730 --> 00:57:44,300
將是，如果它是
已經完全排序。

1421
00:57:44,300 --> 00:57:46,671
那麼我們需要做的就是
檢查它的排序。

1422
00:57:46,671 --> 00:57:47,921
有一個問題在這裡？

1423
00:57:47,921 --> 00:57:49,805
>> 學生：什麼時候
要使用排序？

1424
00:57:49,805 --> 00:57:50,747
排序。

1425
00:57:50,747 --> 00:57:52,160
我只是好奇。

1426
00:57:52,160 --> 00:57:53,510
>> 漢娜：當你
要使用選擇排序？

1427
00:57:53,510 --> 00:57:54,010
這本嗎？

1428
00:57:54,010 --> 00:57:55,705
即n值的平方在這兩種情況下的人嗎？

1429
00:57:55,705 --> 00:57:56,860
>> 學生：[聽不清]。

1430
00:57:56,860 --> 00:57:58,151
>> 漢娜：所以這是非常不同的。

1431
00:57:58,151 --> 00:58:00,760
如果您有具體
為您的程序要求，

1432
00:58:00,760 --> 00:58:04,887
喜歡的東西，如果我們剛才說的一樣
實施搜索 -  sorry--

1433
00:58:04,887 --> 00:58:06,720
實現一個排序，你會
大概想去

1434
00:58:06,720 --> 00:58:09,950
對於那些一說
具有n個最好的情況下，

1435
00:58:09,950 --> 00:58:12,410
或下界中n的最佳情況。

1436
00:58:12,410 --> 00:58:14,790
但也有可能是
喜歡，比方說某些事情，

1437
00:58:14,790 --> 00:58:16,767
掉期交易是真的
昂貴的某些原因。

1438
00:58:16,767 --> 00:58:18,850
然後，你會想要做的
冒泡排序，因為你

1439
00:58:18,850 --> 00:58:20,641
有這麼多
掉期之類的東西。

1440
00:58:20,641 --> 00:58:21,710

1441
00:58:21,710 --> 00:58:23,098
任何other--是嗎？

1442
00:58:23,098 --> 00:58:25,488
>> 學生：難道[聽不清]
說[聽不清]？

1443
00:58:25,488 --> 00:58:30,077

1444
00:58:30,077 --> 00:58:31,910
漢娜：這是一件事
這將告訴你

1445
00:58:31,910 --> 00:58:33,670
如果你正在尋找的實施。

1446
00:58:33,670 --> 00:58:35,850
順便我真的
想想為什麼它的ñ

1447
00:58:35,850 --> 00:58:40,840
方是我們必須要運行
通過我們的長度為n的數組，

1448
00:58:40,840 --> 00:58:42,765
每次做最多，正掉。

1449
00:58:42,765 --> 00:58:43,980

1450
00:58:43,980 --> 00:58:46,220
而我們要做的這個過程n次。

1451
00:58:46,220 --> 00:58:51,130
>> 所以，當你必須做出最多，正
掉期和n個貫穿陣列，

1452
00:58:51,130 --> 00:58:52,380
還有的要為n的平方。

1453
00:58:52,380 --> 00:58:55,480
但是，是的，這將揭示
通過這種雙重for循環，

1454
00:58:55,480 --> 00:58:59,428
因為這個問題asked--或
嵌套的循環，我應該說。

1455
00:58:59,428 --> 00:59:00,890
行？

1456
00:59:00,890 --> 00:59:03,375
>> 然後歸併排序，其中
是最快的排序，我們現在，

1457
00:59:03,375 --> 00:59:07,560
或者說，我們已經介紹了在CS50，
知道主算法是

1458
00:59:07,560 --> 00:59:10,150
這個想法闖入了
排序的片，然後

1459
00:59:10,150 --> 00:59:11,980
這些分類的位合併在一起。

1460
00:59:11,980 --> 00:59:14,170
並讓我們日誌N日誌N。

1461
00:59:14,170 --> 00:59:17,110
在搜索任何疑問和
排序之前，我通過它？

1462
00:59:17,110 --> 00:59:19,840

1463
00:59:19,840 --> 00:59:21,040
讓我們來看看。

1464
00:59:21,040 --> 00:59:21,800
>> 哦，鍊錶。

1465
00:59:21,800 --> 00:59:23,210
對不起，我多了一個話題。

1466
00:59:23,210 --> 00:59:25,000
OK，真棒，鍊錶。

1467
00:59:25,000 --> 00:59:27,900
問題的陣列，
它們具有固定的大小。

1468
00:59:27,900 --> 00:59:30,634
所以，如果你不知道有多大
您輸入的將是，

1469
00:59:30,634 --> 00:59:32,050
你不想創建一個數組。

1470
00:59:32,050 --> 00:59:34,080
因為如果我們創建一個
數組太小，

1471
00:59:34,080 --> 00:59:35,930
我們可能會遇到緩衝區溢出。

1472
00:59:35,930 --> 00:59:38,890
>> 因此，不是，我們可以做些什麼
用鍊錶，這

1473
00:59:38,890 --> 00:59:44,280
使我們能夠動態有
大數據結構

1474
00:59:44,280 --> 00:59:48,970
這將允許我們存儲
更靈活的數據量。

1475
00:59:48,970 --> 00:59:54,030
因此，在每個節點中我們
鍊錶，我們有兩件。

1476
00:59:54,030 --> 00:59:56,820
我們有它存儲的實際值。

1477
00:59:56,820 --> 00:59:59,530
所以這就是剛才的事情你會
看該陣列中，例如。

1478
00:59:59,530 --> 01:00:04,600
然後我們也跟踪了
指針在內存中的下一件事。

1479
01:00:04,600 --> 01:00:06,430
>> 不像數組，
我們知道都去

1480
01:00:06,430 --> 01:00:10,890
以be--數組元素都是一個
相繼在memory--鏈接

1481
01:00:10,890 --> 01:00:13,300
列表可以在內存中的任何地方。

1482
01:00:13,300 --> 01:00:14,590
他們的任意位置。

1483
01:00:14,590 --> 01:00:16,410
所以，如果我們要
實際上去找他們，我們

1484
01:00:16,410 --> 01:00:19,770
需要跟踪的
在我們的名單接下來的事情。

1485
01:00:19,770 --> 01:00:22,840
>> 然後才能知道
如該表作為一個整體，

1486
01:00:22,840 --> 01:00:26,276
我們所跟踪的是
在我們的鍊錶的第一個元素。

1487
01:00:26,276 --> 01:00:27,900
而這將讓我們能夠堅持到底。

1488
01:00:27,900 --> 01:00:31,020

1489
01:00:31,020 --> 01:00:33,070
>> 因此，這是你如何可以定義一個模式。

1490
01:00:33,070 --> 01:00:36,160
這是一個很好的機會
採取結構的優勢。

1491
01:00:36,160 --> 01:00:39,660
因為你有這樣的想法，那麼，
對於給定的節點，我有兩件。

1492
01:00:39,660 --> 01:00:41,770
我本身的實際價值。

1493
01:00:41,770 --> 01:00:45,610
然後，我有一個指針
在鍊錶中的下一個元素。

1494
01:00:45,610 --> 01:00:49,150
所以你看，我們有一個整數n，
這將是實際值，

1495
01:00:49,150 --> 01:00:53,150
然後指針
一個節點，稱為下一個。

1496
01:00:53,150 --> 01:00:56,431
所以這將是下一個
元素在我們的鍊錶。

1497
01:00:56,431 --> 01:00:56,972
學生：是的？

1498
01:00:56,972 --> 01:01:01,920
你有沒有指定
明星就像是一個結構？

1499
01:01:01,920 --> 01:01:05,620
>> 漢娜：是的，所以因為這
幾乎就像一種，

1500
01:01:05,620 --> 01:01:07,980
這似乎是一個遞歸
在我們的定義

1501
01:01:07,980 --> 01:01:12,080
需要知道什麼是節點
內找到一個節點。

1502
01:01:12,080 --> 01:01:14,450
因為它實際上並不
知道一個節點是完全

1503
01:01:14,450 --> 01:01:17,283
直到我們得到this--年底
而在此之後，我們可以叫它

1504
01:01:17,283 --> 01:01:21,935
本定義內的node--，
我們需要把它稱為一個結構節點。

1505
01:01:21,935 --> 01:01:22,560
大的問題。

1506
01:01:22,560 --> 01:01:23,580

1507
01:01:23,580 --> 01:01:25,214
還要別的嗎？

1508
01:01:25,214 --> 01:01:26,198
是嗎？

1509
01:01:26,198 --> 01:01:29,150
>> 學生：為什麼我們
不得不說結了兩次？

1510
01:01:29,150 --> 01:01:33,578
因為當我們在[聽不清]
我們剛剛做的分號，

1511
01:01:33,578 --> 01:01:37,352
但現在我們必須找到
結構節點？ [聽不清]。

1512
01:01:37,352 --> 01:01:39,060
漢娜：所以我相信
在最後一個例子，

1513
01:01:39,060 --> 01:01:42,110
我們只是創造任何時候你
希望之後，要使用一個學生，你

1514
01:01:42,110 --> 01:01:46,430
只好用結構node--
我sorry--結構的學生。

1515
01:01:46,430 --> 01:01:51,575
這使我們能夠，事後，就
使用節點添加一個新的類型，基本上。

1516
01:01:51,575 --> 01:01:53,324

1517
01:01:53,324 --> 01:01:53,990
這有意義嗎？

1518
01:01:53,990 --> 01:01:54,984

1519
01:01:54,984 --> 01:01:57,150
因此，我們不得不回去
之前看一下代碼。

1520
01:01:57,150 --> 01:01:59,025
但我猜想，
我們沒有使用的typedef。

1521
01:01:59,025 --> 01:02:02,050
我們問這個問題，
為什麼我們需要使用的typedef？

1522
01:02:02,050 --> 01:02:05,540
的typedef使我們能夠避免
字結構的開端。

1523
01:02:05,540 --> 01:02:06,221
是嗎？

1524
01:02:06,221 --> 01:02:08,095
學生：是什麼樣
問題就來了

1525
01:02:08,095 --> 01:02:10,400
中在以下方面而言
節點和鍊錶？

1526
01:02:10,400 --> 01:02:15,110
>> 漢娜：那麼有一件事是我們可以說如何
也許你通過一個鍊錶搜索？

1527
01:02:15,110 --> 01:02:16,930
OK，因為它是一個
稍微複雜一點

1528
01:02:16,930 --> 01:02:18,520
比如果我們正在尋找
通過陣列。

1529
01:02:18,520 --> 01:02:21,472
我們只要看一下元素為零，
元素1，元素2，等等，等等，

1530
01:02:21,472 --> 01:02:21,972
等等。

1531
01:02:21,972 --> 01:02:22,629

1532
01:02:22,629 --> 01:02:24,420
如果我們要搜索
通過一個鏈接列表，

1533
01:02:24,420 --> 01:02:27,229
我們會居然要遵循
指針的這個小迷宮。

1534
01:02:27,229 --> 01:02:29,270
因此，讓我們真正去
通過這個真的很快。

1535
01:02:29,270 --> 01:02:30,460

1536
01:02:30,460 --> 01:02:32,860
我們可以做的
訂購to--假設我們

1537
01:02:32,860 --> 01:02:35,430
只想遍歷
我們完全鍊錶。

1538
01:02:35,430 --> 01:02:37,450
我們將開始在頭部。

1539
01:02:37,450 --> 01:02:39,890
然後，以
移動到下一個元素，

1540
01:02:39,890 --> 01:02:43,680
而不是僅增加一
就像我們可能會在經歷一個數組，

1541
01:02:43,680 --> 01:02:45,720
我們究竟要
按照下一個指針，

1542
01:02:45,720 --> 01:02:48,360
因此，我們可以找到在哪裡
內存中的下一個元素。

1543
01:02:48,360 --> 01:02:49,357

1544
01:02:49,357 --> 01:02:51,690
所以，我知道這是不夠的
採取這一切，現在，

1545
01:02:51,690 --> 01:02:52,650
但你有這些幻燈片。

1546
01:02:52,650 --> 01:02:54,730
所以，你可以通過
這一點更慢。

1547
01:02:54,730 --> 01:02:56,890
但實際上，我們想要的
要做的就是遵循這些指針

1548
01:02:56,890 --> 01:02:58,550
通過該鏈接的表中的全部內容。

1549
01:02:58,550 --> 01:03:00,258
因此，這是一個問題
你可能會問。

1550
01:03:00,258 --> 01:03:01,920

1551
01:03:01,920 --> 01:03:03,980
>> 東西要注意
插入，讓我們說

1552
01:03:03,980 --> 01:03:07,925
我們希望把一個新元素
在我們的鏈接列表的前面。

1553
01:03:07,925 --> 01:03:10,800
我們必須非常小心，
關於順序我們

1554
01:03:10,800 --> 01:03:12,760
重新分配的指針。

1555
01:03:12,760 --> 01:03:15,230
因為我們說，我剛才說的確定。

1556
01:03:15,230 --> 01:03:18,930
做頭指向這個新元素。

1557
01:03:18,930 --> 01:03:23,550
只是使它指向1以後，我們
基本上失去了列表的其餘部分，

1558
01:03:23,550 --> 01:03:25,860
因為我不記得在哪裡2的生活。

1559
01:03:25,860 --> 01:03:27,730
>> 所以，我們要做的
非常特定的順序。

1560
01:03:27,730 --> 01:03:31,500
首先，我們提出新的
元素指向頭部。

1561
01:03:31,500 --> 01:03:33,970
然後我們做了頭
指向新的元件。

1562
01:03:33,970 --> 01:03:38,455
所以，讓我們來看看是什麼樣子
與arrows--就這樣。

1563
01:03:38,455 --> 01:03:42,080
所以，你首先得新
元素指向老臉。

1564
01:03:42,080 --> 01:03:45,990
而現在，我們有頭
指向新的第一個元素。

1565
01:03:45,990 --> 01:03:47,187
這個有問題嗎？

1566
01:03:47,187 --> 01:03:49,870

1567
01:03:49,870 --> 01:03:54,350
>> 確定這裡的一些代碼再次，一些
看著有點後。

1568
01:03:54,350 --> 01:03:58,630
現在我會把它交給達文
為GDB和實踐一點點

1569
01:03:58,630 --> 01:03:59,480
編碼在紙面上。

1570
01:03:59,480 --> 01:04:00,597

1571
01:04:00,597 --> 01:04:01,096
美麗。

1572
01:04:01,096 --> 01:04:01,810
>> 羅伯：和Rob。

1573
01:04:01,810 --> 01:04:02,360
>> 漢娜：哦，達文和Rob。

1574
01:04:02,360 --> 01:04:03,055
對不起。

1575
01:04:03,055 --> 01:04:03,596
>> 學生：嗚！

1576
01:04:03,596 --> 01:04:08,140

1577
01:04:08,140 --> 01:04:09,110
>> 羅伯：謝謝。

1578
01:04:09,110 --> 01:04:11,209
>> DAVIN：你想說的話
一切真正的快？

1579
01:04:11,209 --> 01:04:11,875
羅伯：是啊，是啊。

1580
01:04:11,875 --> 01:04:12,845
DAVIN：一旦我了。

1581
01:04:12,845 --> 01:04:16,240

1582
01:04:16,240 --> 01:04:19,520
OK，而羅布放
麥克風，有啥GDB？

1583
01:04:19,520 --> 01:04:23,945
每個人都應該看到在GDB
類以及在辦公時間。

1584
01:04:23,945 --> 01:04:25,070
你應該使用它。

1585
01:04:25,070 --> 01:04:25,750
那麼，什麼是GDB？

1586
01:04:25,750 --> 01:04:28,030

1587
01:04:28,030 --> 01:04:28,850
任何人？

1588
01:04:28,850 --> 01:04:29,540
>> 學生：這是一個調試器。

1589
01:04:29,540 --> 01:04:30,250
>> DAVIN：這是一個調試器。

1590
01:04:30,250 --> 01:04:31,624
又是什麼讓你做什麼？

1591
01:04:31,624 --> 01:04:33,064
喜歡，為什麼我們喜歡GDB？

1592
01:04:33,064 --> 01:04:34,480
學生：要減慢程序。

1593
01:04:34,480 --> 01:04:36,740
DAVIN：對，所以你可以走
通過它像人類的步伐。

1594
01:04:36,740 --> 01:04:38,490
還等什麼一些
命令你可以做什麼？

1595
01:04:38,490 --> 01:04:40,407
好了，休息可能是
你最喜歡的命令。

1596
01:04:40,407 --> 01:04:43,240
因為這可以讓你打破
程序，並通過它實際上走

1597
01:04:43,240 --> 01:04:44,280
一行行。

1598
01:04:44,280 --> 01:04:46,500
>> 運行允許你運行它。

1599
01:04:46,500 --> 01:04:48,210
接著，就像踩著通過。

1600
01:04:48,210 --> 01:04:49,820
下一步做什麼和步驟之間的的？

1601
01:04:49,820 --> 01:04:52,190

1602
01:04:52,190 --> 01:04:53,190
等待，很大聲地說。

1603
01:04:53,190 --> 01:04:54,060
這是正確的。

1604
01:04:54,060 --> 01:04:55,280
>> 學生：[聽不清]。

1605
01:04:55,280 --> 01:04:56,190
>> DAVIN：是的，真棒。

1606
01:04:56,190 --> 01:04:59,210
所以像，旁邊並步，如果you're--
假設你有一個函數，你

1607
01:04:59,210 --> 01:04:59,950
定義。

1608
01:04:59,950 --> 01:05:03,350
比方說，一些在主函數，
而你只是打下一步，下一步，

1609
01:05:03,350 --> 01:05:03,850
下一個。

1610
01:05:03,850 --> 01:05:05,910
你究竟要
執行該功能，

1611
01:05:05,910 --> 01:05:07,285
但你要跳過去。

1612
01:05:07,285 --> 01:05:09,711
如果你打的步驟，或
s或什麼的，你

1613
01:05:09,711 --> 01:05:11,460
要真正跳
進入該功能，

1614
01:05:11,460 --> 01:05:14,110
然後你就可以打到旁邊
看到不同的呼叫

1615
01:05:14,110 --> 01:05:16,170
內的特定功能。

1616
01:05:16,170 --> 01:05:16,670
是嗎？

1617
01:05:16,670 --> 01:05:18,670
>> 學生：有沒有一種方法
跳一樣，退了出去？

1618
01:05:18,670 --> 01:05:20,750
DAVIN：完成，是啊，
與完成跳躍你。

1619
01:05:20,750 --> 01:05:22,570
所以它要完成的
功能，然後你

1620
01:05:22,570 --> 01:05:24,153
將回到在主，例如。

1621
01:05:24,153 --> 01:05:25,250

1622
01:05:25,250 --> 01:05:27,370
打印將其打印出來一次。

1623
01:05:27,370 --> 01:05:29,381
這是我經常使用的顯示器。

1624
01:05:29,381 --> 01:05:31,880
顯示器將它打印出來
不斷地貫穿整個

1625
01:05:31,880 --> 01:05:32,470
你的程序。

1626
01:05:32,470 --> 01:05:33,810
>> 例如，如果你是
在fo​​r循環中，你

1627
01:05:33,810 --> 01:05:37,018
想看看有什麼地方改變，
你不希望一樣，不斷

1628
01:05:37,018 --> 01:05:38,940
可以做這樣的打印，
印刷，打印，顯示

1629
01:05:38,940 --> 01:05:43,230
將顯示該變量
不斷，每次點擊Next。

1630
01:05:43,230 --> 01:05:44,310
並繼續。

1631
01:05:44,310 --> 01:05:45,905
因此GBD，這是GDB。

1632
01:05:45,905 --> 01:05:47,160

1633
01:05:47,160 --> 01:05:49,180
>> 學生：什麼是一個
在這裡你[聽不清]？

1634
01:05:49,180 --> 01:05:50,150

1635
01:05:50,150 --> 01:05:50,900
DAVIN：這是什麼？

1636
01:05:50,900 --> 01:05:52,310

1637
01:05:52,310 --> 01:05:54,390
>> 學生：什麼是the--
的局部變量。

1638
01:05:54,390 --> 01:05:55,364

1639
01:05:55,364 --> 01:05:57,780
羅伯：也有一些是實際
像當地人什麼的。

1640
01:05:57,780 --> 01:05:58,140
我can't--

1641
01:05:58,140 --> 01:05:59,930
>> DAVIN：這可能是
類似的東西，是的。

1642
01:05:59,930 --> 01:06:00,830
>> 漢娜：在當地人？

1643
01:06:00,830 --> 01:06:01,510
>> DAVIN：就是這樣。

1644
01:06:01,510 --> 01:06:02,134
這是一個。

1645
01:06:02,134 --> 01:06:03,040
羅伯：美麗的。

1646
01:06:03,040 --> 01:06:04,030
>> DAVIN：是的。

1647
01:06:04,030 --> 01:06:06,010
>> 學生：這是什麼做的下去？

1648
01:06:06,010 --> 01:06:08,010
>> DAVIN：這continues--所以它只是
要繼續你的節目。

1649
01:06:08,010 --> 01:06:09,843
所以，如果你打破，打
繼續，這是怎麼回事

1650
01:06:09,843 --> 01:06:13,119
只運行該程序，直到
它再次達到了突破。

1651
01:06:13,119 --> 01:06:14,910
因此，例如，如果
打破了一個函數，

1652
01:06:14,910 --> 01:06:16,720
而你要做的像
環或類似的東西，

1653
01:06:16,720 --> 01:06:19,869
而你繼續打，這將
繼續回到那個破。

1654
01:06:19,869 --> 01:06:22,660
或者有沒有突破，這將
繼續並完成該程序。

1655
01:06:22,660 --> 01:06:25,000
>> 羅伯：所以就像停止運行
在第一個斷點

1656
01:06:25,000 --> 01:06:27,010
你打，如果你再
繼續打，它會不斷

1657
01:06:27,010 --> 01:06:28,070
去，直到它的下一個斷點。

1658
01:06:28,070 --> 01:06:30,111
然後繼續會
到下一個斷點。

1659
01:06:30,111 --> 01:06:31,264

1660
01:06:31,264 --> 01:06:32,680
DAVIN：在GDB還有沒有其他問題？

1661
01:06:32,680 --> 01:06:33,577

1662
01:06:33,577 --> 01:06:35,410
所以我認為，在過去，
我們問你什麼

1663
01:06:35,410 --> 01:06:37,690
GDB是，給一個
例如有些事情你

1664
01:06:37,690 --> 01:06:40,770
可以用GDB做，所以
很簡單的，但是，是的。

1665
01:06:40,770 --> 01:06:42,280
你去那裡。

1666
01:06:42,280 --> 01:06:43,250
和節點？

1667
01:06:43,250 --> 01:06:49,571
>> 羅伯：是的，所以它的方向是什麼呢？

1668
01:06:49,571 --> 01:06:50,851

1669
01:06:50,851 --> 01:06:51,726
學生：就是這樣。

1670
01:06:51,726 --> 01:06:52,160
DAVIN：等待。

1671
01:06:52,160 --> 01:06:52,270
羅伯：這傢伙？

1672
01:06:52,270 --> 01:06:52,936
DAVIN：那一個。

1673
01:06:52,936 --> 01:06:54,660
羅伯：這傢伙，哦，我不知道。

1674
01:06:54,660 --> 01:06:56,940
因此，我們並不清楚
對我the--不

1675
01:06:56,940 --> 01:06:58,680
誰知道它was--，但這個問題。

1676
01:06:58,680 --> 01:07:01,180
我們不知道到底是什麼你
在問這個問題，所以只是

1677
01:07:01,180 --> 01:07:04,800
澄清一些事情。

1678
01:07:04,800 --> 01:07:07,750
因此，首先，就像我之前說的，
類型定義你總是只用正

1679
01:07:07,750 --> 01:07:09,305
創建一個暱稱為一個類型。

1680
01:07:09,305 --> 01:07:13,420
所以在這裡，這個綽號我們
創造是這種類型的結構節點。

1681
01:07:13,420 --> 01:07:18,070
>> 因此，首先，忽略此的節點
類型定義，所以這個結構節點捲髮

1682
01:07:18,070 --> 01:07:21,060
振奮下降到下一個捲髮
支架是結構節點類型。

1683
01:07:21,060 --> 01:07:23,470
我們需要的節點
在那裡，因為我們

1684
01:07:23,470 --> 01:07:25,190
需要參考節點位置。

1685
01:07:25,190 --> 01:07:29,380
所以用這種遞歸結構的，
你需要給這個結構的名稱，

1686
01:07:29,380 --> 01:07:31,340
否則你不能
說結構節點在了這裡。

1687
01:07:31,340 --> 01:07:33,340
而與之前的學生
當我們打字，我認為，

1688
01:07:33,340 --> 01:07:35,423
我們沒得說
學生在那裡，因為我們

1689
01:07:35,423 --> 01:07:40,370
沒得說的結構
學生本身的結構裡面。

1690
01:07:40,370 --> 01:07:43,730
因此，它是遞歸的
迫使我們要說的節點出現。

1691
01:07:43,730 --> 01:07:46,610
>> 這個節點僅僅是我們的名字
給節點的類型定義。

1692
01:07:46,610 --> 01:07:48,520
使節點不
相同的節點。

1693
01:07:48,520 --> 01:07:51,567
但這種結構節點是
相同結構的節點。

1694
01:07:51,567 --> 01:07:54,150
DAVIN：所以每當你打電話，
像，在主功能節點，

1695
01:07:54,150 --> 01:07:55,350
你不會
不得不說結構節點。

1696
01:07:55,350 --> 01:07:58,360
你可以說節點，因為
節點是一個different--基本上

1697
01:07:58,360 --> 01:07:59,440
你說好不好。

1698
01:07:59,440 --> 01:08:01,490
而不必調用
在我的代碼結構的節點，

1699
01:08:01,490 --> 01:08:04,050
我只是想將其重命名
作為節點，使其更容易。

1700
01:08:04,050 --> 01:08:06,800
>> 羅伯：如果你總是
使用的typedef，那麼這

1701
01:08:06,800 --> 01:08:11,240
是你要擁有的唯一的地方
申報與結構節點變量

1702
01:08:11,240 --> 01:08:11,740
明星，是的。

1703
01:08:11,740 --> 01:08:14,650

1704
01:08:14,650 --> 01:08:20,801
>> DAVIN：OK，所以最後一部分
是很難教因為 - 

1705
01:08:20,801 --> 01:08:22,185

1706
01:08:22,185 --> 01:08:22,685
羅伯：什麼？

1707
01:08:22,685 --> 01:08:24,098

1708
01:08:24,098 --> 01:08:25,649
>> DAVIN：因為它的編碼在紙面上。

1709
01:08:25,649 --> 01:08:28,689
所以每年我們
在紙上的問題代碼。

1710
01:08:28,689 --> 01:08:32,510
所以我認為，去年12出
80分是在紙上的代碼。

1711
01:08:32,510 --> 01:08:36,720
一年之前，10出80，
一年之前，20（總分100）

1712
01:08:36,720 --> 01:08:37,939
所以相當多的這些。

1713
01:08:37,939 --> 01:08:40,970
所以，你要必須能
手工編寫向上這些功能。

1714
01:08:40,970 --> 01:08:45,340
>> 所以我想我們可能會經歷一個
他們夫婦，看別人怎麼做，

1715
01:08:45,340 --> 01:08:47,340
通過種行走
他們慢慢地與人交往。

1716
01:08:47,340 --> 01:08:48,790

1717
01:08:48,790 --> 01:08:52,420
所以一般情況下，strlen的和
ATOI已經非常流行。

1718
01:08:52,420 --> 01:08:55,670
去年，我覺得我們有
GetPositiveInt和RandomInt。

1719
01:08:55,670 --> 01:08:58,591
但POW，所以功率，也
一個積極的了。

1720
01:08:58,591 --> 01:09:00,965
就讓我們通過可能
一個或兩個這些在一起。

1721
01:09:00,965 --> 01:09:02,510

1722
01:09:02,510 --> 01:09:03,729
什麼人想看？

1723
01:09:03,729 --> 01:09:05,037

1724
01:09:05,037 --> 01:09:05,767
>> 學生：ATOI。

1725
01:09:05,767 --> 01:09:06,350
學生：是啊。

1726
01:09:06,350 --> 01:09:06,859
DAVIN：ATOI？

1727
01:09:06,859 --> 01:09:07,800
學生：[聽不清]。

1728
01:09:07,800 --> 01:09:09,682
DAVIN：OK，我要去
這樣做在黑板上。

1729
01:09:09,682 --> 01:09:11,765
你有偏好
如果我在這裡或那裡做呢？

1730
01:09:11,765 --> 01:09:13,580

1731
01:09:13,580 --> 01:09:14,550
在那裡，加布說，有。

1732
01:09:14,550 --> 01:09:16,729

1733
01:09:16,729 --> 01:09:19,580
>> 羅伯：這是一般的想法
在這些編碼的問題。

1734
01:09:19,580 --> 01:09:21,705
嘗試寫一些東西。

1735
01:09:21,705 --> 01:09:22,580
不要讓它空白。

1736
01:09:22,580 --> 01:09:23,080
>> DAVIN：是的。

1737
01:09:23,080 --> 01:09:25,520
羅伯：如果你能得到的
返回類型正確，

1738
01:09:25,520 --> 01:09:27,090
也許我們可以給它
你，但如果你能一樣，

1739
01:09:27,090 --> 01:09:30,256
寫一般的函數簽名，
如果你能得到基礎的情況下正確的，

1740
01:09:30,256 --> 01:09:32,244
或角的情況下，或
記憶的空檢查，

1741
01:09:32,244 --> 01:09:34,160
只要你有一定的
事情的話，說不定我們

1742
01:09:34,160 --> 01:09:35,880
可以給你一對夫婦
分的問題。

1743
01:09:35,880 --> 01:09:36,810
不要讓它空白。

1744
01:09:36,810 --> 01:09:38,560
>> DAVIN：是的，如果你
只是完全

1745
01:09:38,560 --> 01:09:40,580
難倒在如何
居然變成代碼。

1746
01:09:40,580 --> 01:09:43,140
如果你寫的偽代碼，
這是相當不錯的了。

1747
01:09:43,140 --> 01:09:46,390
所以它的樣子，它是一個6點的問題，
你寫出正確的偽代碼，

1748
01:09:46,390 --> 01:09:47,858
你會得到至少兩分。

1749
01:09:47,858 --> 01:09:49,149
所以，不要只是將其留空。

1750
01:09:49,149 --> 01:09:50,279
盡量把一些東西。

1751
01:09:50,279 --> 01:09:51,770
>> 羅伯：它需要的
正確的偽代碼，但。

1752
01:09:51,770 --> 01:09:52,270
>> DAVIN：是的。

1753
01:09:52,270 --> 01:09:55,381
羅伯：所以我們一般都不太
寬大的偽代碼的bug。

1754
01:09:55,381 --> 01:09:57,130
DAVIN：好了，你們
想看看ATOI。

1755
01:09:57,130 --> 01:09:58,480

1756
01:09:58,480 --> 01:10:02,820
OK，所以才really--
所以你想要做什麼

1757
01:10:02,820 --> 01:10:04,969
是你要會
鑑於某種數量。

1758
01:10:04,969 --> 01:10:07,010
但這個數目是不
將是一個int，不是嗎？

1759
01:10:07,010 --> 01:10:08,574
它是什麼打算呢？

1760
01:10:08,574 --> 01:10:09,480
>> 學生：[聽不清]。

1761
01:10:09,480 --> 01:10:11,146
>> DAVIN：這將是一個字符串，對不對？

1762
01:10:11,146 --> 01:10:13,160
所以，如果你被給予
一個string--讓我們say--

1763
01:10:13,160 --> 01:10:15,228
>> 羅伯：我應該拉了一個編輯器？

1764
01:10:15,228 --> 01:10:16,200
我可以拉up--

1765
01:10:16,200 --> 01:10:16,800
>> DAVIN：哦，你想這樣做on--

1766
01:10:16,800 --> 01:10:17,420
>> 羅伯：你寧願板？

1767
01:10:17,420 --> 01:10:18,800
>> DAVIN：你想怎麼辦？

1768
01:10:18,800 --> 01:10:19,900
我的意思是，你想不想做手工嗎？

1769
01:10:19,900 --> 01:10:21,460
或者你想用電腦做呢？

1770
01:10:21,460 --> 01:10:22,180
>> 羅伯：手工做的。

1771
01:10:22,180 --> 01:10:22,805
>> DAVIN：[笑]

1772
01:10:22,805 --> 01:10:23,950
羅伯：手工做的。

1773
01:10:23,950 --> 01:10:25,469
>> DAVIN：OK，所以這將是ATOI。

1774
01:10:25,469 --> 01:10:27,760
那麼，什麼是它 - 我的意思是，我們將
可能是你給這個。

1775
01:10:27,760 --> 01:10:29,106
但是，什麼是它要回來嗎？

1776
01:10:29,106 --> 01:10:29,452
>> 學生：詮釋。

1777
01:10:29,452 --> 01:10:31,076
>> DAVIN：這將返回整型，對不對？

1778
01:10:31,076 --> 01:10:33,772
So--我並不想這樣做在那裡。

1779
01:10:33,772 --> 01:10:34,510
我會在這裡做。

1780
01:10:34,510 --> 01:10:36,596
>> 羅伯：你可以拉下來
然後向上推就可以了。

1781
01:10:36,596 --> 01:10:38,500

1782
01:10:38,500 --> 01:10:40,385
>> DAVIN：是啊。

1783
01:10:40,385 --> 01:10:43,880
[笑]遊戲的變化。

1784
01:10:43,880 --> 01:10:50,950
好了，這將是int ATOI，
，什麼是它要採取？

1785
01:10:50,950 --> 01:10:52,180

1786
01:10:52,180 --> 01:10:57,780
一個char明星，所以只是一
串，星星S，這樣的。

1787
01:10:57,780 --> 01:10:59,240
>> 羅伯：尼斯明星，漂亮。

1788
01:10:59,240 --> 01:11:02,582

1789
01:11:02,582 --> 01:11:04,040
DAVIN：這可能不是沒有，OK。

1790
01:11:04,040 --> 01:11:04,540
羅伯：是啊。

1791
01:11:04,540 --> 01:11:06,670
DAVIN：OK，所以第一
事情要do--我

1792
01:11:06,670 --> 01:11:08,490
不知道有沒有人看
在實踐中solutions--

1793
01:11:08,490 --> 01:11:10,150
但是你要什麼
想要做的就是你

1794
01:11:10,150 --> 01:11:11,570
會希望有
一個循環，因為你

1795
01:11:11,570 --> 01:11:14,100
會想實際
單步執行該字符串。

1796
01:11:14,100 --> 01:11:18,880
所以helpful--所以我們說
我們要一個for循環，

1797
01:11:18,880 --> 01:11:22,270
而且我們要通過一步
串中的每個元素。

1798
01:11:22,270 --> 01:11:23,470
是多久呢？

1799
01:11:23,470 --> 01:11:26,464
多少次我們要
在fo​​r循環遍歷？

1800
01:11:26,464 --> 01:11:27,130
學生：Sterln？

1801
01:11:27,130 --> 01:11:27,963
DAVIN：Sterln，是的。

1802
01:11:27,963 --> 01:11:29,350

1803
01:11:29,350 --> 01:11:41,294
所以我們可以說INT長度等於sterln秒。

1804
01:11:41,294 --> 01:11:44,240

1805
01:11:44,240 --> 01:11:48,740
而只是好奇，為什麼它總是一種
更好的做到循環這外面？

1806
01:11:48,740 --> 01:11:52,277
像，為什麼它更好地叫
一環以外的這個功能？

1807
01:11:52,277 --> 01:11:53,360
只是一個快速合理性檢查？

1808
01:11:53,360 --> 01:11:55,810

1809
01:11:55,810 --> 01:11:56,311
是嗎？

1810
01:11:56,311 --> 01:11:58,268
學生：所以你不
要繼續檢查它。

1811
01:11:58,268 --> 01:11:59,400
你可以[聽不清]。

1812
01:11:59,400 --> 01:12:01,560
>> DAVIN：沒錯，所以是的，
她究竟說了什麼​​。

1813
01:12:01,560 --> 01:12:03,101
所以，我們沒有繼續檢查它。

1814
01:12:03,101 --> 01:12:05,690
因此，舉例來說，如果我打電話
這個功能在循環中，

1815
01:12:05,690 --> 01:12:08,050
然後我會不斷的打電話
這個函數多次。

1816
01:12:08,050 --> 01:12:10,080
而這將降低
你的程序的效率。

1817
01:12:10,080 --> 01:12:12,370
因此，它總是有用
對外界宣稱它。

1818
01:12:12,370 --> 01:12:14,370
>> 羅伯：這是說，在
任何這些問題，

1819
01:12:14,370 --> 01:12:17,940
幾乎只要你得到一個
工作液，你得滿分。

1820
01:12:17,940 --> 01:12:20,820
所以，如果你的設計不用擔心
絕對是可怕的。

1821
01:12:20,820 --> 01:12:22,120

1822
01:12:22,120 --> 01:12:25,230
它可能使我們心煩
閱讀你的代碼。

1823
01:12:25,230 --> 01:12:28,160
但只要它的工作原理，
你會得到積分。

1824
01:12:28,160 --> 01:12:29,302
>> DAVIN：是的。

1825
01:12:29,302 --> 01:12:31,260
好了，然後我要去
聲明一些變量。

1826
01:12:31,260 --> 01:12:33,900
它只是要調用int總和。

1827
01:12:33,900 --> 01:12:37,031
而且我要設置這個
等於零，那樣。

1828
01:12:37,031 --> 01:12:38,780
而這只是要
是一個佔位符。

1829
01:12:38,780 --> 01:12:40,960
所以這將是
我什麼都返回。

1830
01:12:40,960 --> 01:12:43,730
所以我打算最終
返回總和這一計劃的。

1831
01:12:43,730 --> 01:12:44,980
所以，我有這兩個變量。

1832
01:12:44,980 --> 01:12:45,563
我有長度。

1833
01:12:45,563 --> 01:12:46,500
我有一筆。

1834
01:12:46,500 --> 01:12:48,290
現在，讓我們跳進我們的字符串。

1835
01:12:48,290 --> 01:12:49,510
>> 所以讓我們有我們的for循環。

1836
01:12:49,510 --> 01:13:06,520
所以4 INT I等於0 W，而
我是小於長度我加再加。

1837
01:13:06,520 --> 01:13:07,150
和now--

1838
01:13:07,150 --> 01:13:10,920

1839
01:13:10,920 --> 01:13:11,420
羅伯：尼斯。

1840
01:13:11,420 --> 01:13:14,030
DAVIN：OK，現在這裡
說到我們的代碼肉。

1841
01:13:14,030 --> 01:13:17,380
所以，你實際上可以做
這基本上是在同一行。

1842
01:13:17,380 --> 01:13:20,702
因此，沒有任何人有一個想法
是什麼，我們要怎麼做？

1843
01:13:20,702 --> 01:13:23,680

1844
01:13:23,680 --> 01:13:25,380
好吧，沒關係。

1845
01:13:25,380 --> 01:13:35,860
因此，我們正在做的說的總和equals--
讓我飛奔這over--總和

1846
01:13:35,860 --> 01:13:50,010
等於總和乘以10 plus--我們
要帶的I減一

1847
01:13:50,010 --> 01:13:54,787
報價1報價完成的，這樣的。

1848
01:13:54,787 --> 01:13:55,620
羅伯：非常直觀。

1849
01:13:55,620 --> 01:13:56,980

1850
01:13:56,980 --> 01:13:57,880
>> DAVIN：粉碎它。

1851
01:13:57,880 --> 01:14:01,438
好了，someone--我得到了它，我得到了它。

1852
01:14:01,438 --> 01:14:03,680

1853
01:14:03,680 --> 01:14:06,960
好了，這顯然是往上走。

1854
01:14:06,960 --> 01:14:08,320

1855
01:14:08,320 --> 01:14:09,450
這是什麼意思？

1856
01:14:09,450 --> 01:14:12,120
因此，沒有任何人知道這是什麼意思？

1857
01:14:12,120 --> 01:14:13,826
大家可以看到這個？

1858
01:14:13,826 --> 01:14:16,088
不，沒有人能看到這一點，OK。

1859
01:14:16,088 --> 01:14:17,390

1860
01:14:17,390 --> 01:14:18,340
我要去to--

1861
01:14:18,340 --> 01:14:20,506
>> 羅伯：我打算寫的
公式只是在這裡。

1862
01:14:20,506 --> 01:14:23,140
DAVIN：OK，羅布的要做到這一點
在電腦上，這是有趣的。

1863
01:14:23,140 --> 01:14:26,889

1864
01:14:26,889 --> 01:14:27,514
羅伯：哦，我的上帝。

1865
01:14:27,514 --> 01:14:34,340

1866
01:14:34,340 --> 01:14:35,010
不然我不會。

1867
01:14:35,010 --> 01:14:36,288

1868
01:14:36,288 --> 01:14:36,954
DAVIN：待機。

1869
01:14:36,954 --> 01:14:42,300

1870
01:14:42,300 --> 01:14:44,260
學生：我有一個問題。

1871
01:14:44,260 --> 01:14:45,348
DAVIN：是的，當然。

1872
01:14:45,348 --> 01:14:46,223
學生：[聽不清]？

1873
01:14:46,223 --> 01:14:52,529

1874
01:14:52,529 --> 01:14:54,570
DAVIN：OK，所以它實際上是，
像，只是在一般情況下，

1875
01:14:54,570 --> 01:14:56,710
如果你把一樣，
在此聲明INT

1876
01:14:56,710 --> 01:14:59,770
我等於0逗號長度
等於sterln，that--

1877
01:14:59,770 --> 01:15:01,200
>> 學生：[聽不清]。

1878
01:15:01,200 --> 01:15:03,585
>> DAVIN：這很好，因為that--

1879
01:15:03,585 --> 01:15:05,543
學生：你為什麼會
即使需要使用長度是多少？

1880
01:15:05,543 --> 01:15:08,620
我們為什麼不能只是[聽不清] sterln
S，就像整個時間[聽不清]？

1881
01:15:08,620 --> 01:15:09,460
>> DAVIN：你的意思是在這裡？

1882
01:15:09,460 --> 01:15:10,001
>> 學生：是的。

1883
01:15:10,001 --> 01:15:12,630
DAVIN：因為每
這個時間循環運行，

1884
01:15:12,630 --> 01:15:14,295
它要評估這種狀況。

1885
01:15:14,295 --> 01:15:14,920
學生：對。

1886
01:15:14,920 --> 01:15:16,836
DAVIN：如果你有
sterln存在，那麼它的

1887
01:15:16,836 --> 01:15:19,510
不得不實際調用
該函數每一次。

1888
01:15:19,510 --> 01:15:21,090
因此，而不是只
它比較為int，

1889
01:15:21,090 --> 01:15:23,548
你會被調用
函數，然後比較它

1890
01:15:23,548 --> 01:15:24,510
到的返回值。

1891
01:15:24,510 --> 01:15:25,860
是啊，所以它的公正，是啊。

1892
01:15:25,860 --> 01:15:28,860

1893
01:15:28,860 --> 01:15:30,770
>> 不錯，好了，現在每個人都可以看到它。

1894
01:15:30,770 --> 01:15:33,400
什麼does--這就像，這是它。

1895
01:15:33,400 --> 01:15:34,580
這是果醬，就在這裡。

1896
01:15:34,580 --> 01:15:37,030

1897
01:15:37,030 --> 01:15:37,930
這意味著什麼？

1898
01:15:37,930 --> 01:15:39,250

1899
01:15:39,250 --> 01:15:39,970
我在做什麼？

1900
01:15:39,970 --> 01:15:41,890

1901
01:15:41,890 --> 01:15:42,880
是啊，一個想法？

1902
01:15:42,880 --> 01:15:43,482
是嗎？

1903
01:15:43,482 --> 01:15:45,692
>> 學生：嗯，所以當
你進入一個數組，

1904
01:15:45,692 --> 01:15:47,525
你將要去
從左至右，

1905
01:15:47,525 --> 01:15:51,786
所以你將要前往的
從按下[聽不清]小數。

1906
01:15:51,786 --> 01:15:52,410
DAVIN：沒錯。

1907
01:15:52,410 --> 01:15:55,063
學生：所以每一個
你要乘

1908
01:15:55,063 --> 01:15:59,490
你看到的整型的值
到時候你就會繼續前進，超過1。

1909
01:15:59,490 --> 01:16:01,590
>> DAVIN：完美的，完美的，
因此，例如，讓我們

1910
01:16:01,590 --> 01:16:05,376
說我給你 - 我
會寫在這裡了。

1911
01:16:05,376 --> 01:16:06,480
不，我不是。

1912
01:16:06,480 --> 01:16:08,640
我要在這裡寫了。

1913
01:16:08,640 --> 01:16:12,080
比方說，我給你76吧？

1914
01:16:12,080 --> 01:16:13,380
比方說，我給你76。

1915
01:16:13,380 --> 01:16:15,360
這是一個字符串開始，好不好？

1916
01:16:15,360 --> 01:16:16,840
>> 那麼長的是什麼？

1917
01:16:16,840 --> 01:16:18,060

1918
01:16:18,060 --> 01:16:19,060
2，對吧？

1919
01:16:19,060 --> 01:16:20,290
總和為0。

1920
01:16:20,290 --> 01:16:21,600
然後，我們在跳躍的循環。

1921
01:16:21,600 --> 01:16:24,187
行中，在第一次迭代
這一點，它是什麼打算呢？

1922
01:16:24,187 --> 01:16:25,270
這將是總和為0。

1923
01:16:25,270 --> 01:16:27,180
所以，綜上所述次10 0。

1924
01:16:27,180 --> 01:16:28,500
這是毫無意義的。

1925
01:16:28,500 --> 01:16:29,880
那麼，這是什麼呢？

1926
01:16:29,880 --> 01:16:30,845

1927
01:16:30,845 --> 01:16:31,720
學生：[聽不清]。

1928
01:16:31,720 --> 01:16:33,110

1929
01:16:33,110 --> 01:16:37,430
>> DAVIN：這將反過來說
字符轉換為整數，對吧？

1930
01:16:37,430 --> 01:16:42,160
這有點像你
set--這個light--問題

1931
01:16:42,160 --> 01:16:44,170
它有點像用
問題設置的Visioneer。

1932
01:16:44,170 --> 01:16:45,980
你正在處理的ASCII值。

1933
01:16:45,980 --> 01:16:48,520
所以，如果我給你一樣，一
7，但它是一個字符，

1934
01:16:48,520 --> 01:16:50,965
你想知道，
OK，有什麼數字是什麼？

1935
01:16:50,965 --> 01:16:53,540

1936
01:16:53,540 --> 01:16:54,910
是的，你可以，是的。

1937
01:16:54,910 --> 01:16:55,900
那麼，什麼數字是什麼？

1938
01:16:55,900 --> 01:16:59,550
你可以減去0的，但你
必須減去0，字符。

1939
01:16:59,550 --> 01:17:01,425
>> 並在一些人
得到絆倒，他們

1940
01:17:01,425 --> 01:17:04,260
就像，OK，好了，我必須要知道
ASCII碼值這個測驗？

1941
01:17:04,260 --> 01:17:06,218
不，你絕對不
需要知道的ASCII

1942
01:17:06,218 --> 01:17:09,520
的一樣，小寫值
一，大寫的A，為零。

1943
01:17:09,520 --> 01:17:12,060
>> 羅伯：我們沒有理由永遠
立此備忘單。

1944
01:17:12,060 --> 01:17:14,226
>> DAVIN：絕對不
廢物這是你的空間。

1945
01:17:14,226 --> 01:17:18,090
您可以literally--只是代替
說法48，如直到

1946
01:17:18,090 --> 01:17:24,630
還有，也就是等同於
說一，一撇號，

1947
01:17:24,630 --> 01:17:27,680
這樣，如出一轍。

1948
01:17:27,680 --> 01:17:34,106
>> 羅伯：你幾乎可以認為
它作為if--上帝，我需要我的，

1949
01:17:34,106 --> 01:17:37,490
oops--你幾乎可以把它
因為如果我們有類似的東西散

1950
01:17:37,490 --> 01:17:39,755
0定義為48。

1951
01:17:39,755 --> 01:17:41,320

1952
01:17:41,320 --> 01:17:42,030
這是行不通的。

1953
01:17:42,030 --> 01:17:45,502
但把它看作是單引號0
單引號，並為所有字符。

1954
01:17:45,502 --> 01:17:47,960
把它看成是一個常數，
表示ASCII值。

1955
01:17:47,960 --> 01:17:49,080
>> DAVIN：是的。

1956
01:17:49,080 --> 01:17:52,820
好了，第一次通過，所以
與76--所以第一次通過，

1957
01:17:52,820 --> 01:17:57,260
這僅僅是一個字符
7減去字符0，

1958
01:17:57,260 --> 01:18:00,420
而這些都是7
integers--好，那些

1959
01:18:00,420 --> 01:18:04,030
有7位相距
其他ASCII表或其他的。

1960
01:18:04,030 --> 01:18:06,770
所以這是要返回7的整數。

1961
01:18:06,770 --> 01:18:08,720
所以，現在，和等於7。

1962
01:18:08,720 --> 01:18:10,830
>> 好了，好了，讓我們跳
這個for循環一次。

1963
01:18:10,830 --> 01:18:13,010
好了，現在它的總和乘以10。

1964
01:18:13,010 --> 01:18:15,800
所以你有效
移動7至左側。

1965
01:18:15,800 --> 01:18:17,542
這是否有道理？

1966
01:18:17,542 --> 01:18:19,250
你是有效的
它移動到左邊。

1967
01:18:19,250 --> 01:18:21,790
>> 然後你add--這
將是6減去0。

1968
01:18:21,790 --> 01:18:22,650
這是6。

1969
01:18:22,650 --> 01:18:24,752
因此，這將是70加6。

1970
01:18:24,752 --> 01:18:25,996
76，這是你的電話號碼。

1971
01:18:25,996 --> 01:18:28,370
所以，不管是什麼數
我給你的，它是慢慢地只

1972
01:18:28,370 --> 01:18:31,610
要轉移的較大值
到左側，1 10因子

1973
01:18:31,610 --> 01:18:35,525
在fo​​r循環中，每次，
然後添加必要的。

1974
01:18:35,525 --> 01:18:37,350

1975
01:18:37,350 --> 01:18:37,865
>> 在後面？

1976
01:18:37,865 --> 01:18:40,240
學生：我們沒有做
在程序的任何檢查？

1977
01:18:40,240 --> 01:18:41,580

1978
01:18:41,580 --> 01:18:44,302
>> 羅伯：所以只要檢查
無二的程序，

1979
01:18:44,302 --> 01:18:46,510
我們會告訴你漂亮
很多東西你需要檢查。

1980
01:18:46,510 --> 01:18:48,670
如果我們不告訴你
任何事情的話，一般

1981
01:18:48,670 --> 01:18:50,320
假設你要檢查的大多數事情。

1982
01:18:50,320 --> 01:18:54,772
就像你可能，為了安全起見，你
也許應該檢查哎，是S空？

1983
01:18:54,772 --> 01:18:56,230
然後，我不知道該怎麼回報。

1984
01:18:56,230 --> 01:18:58,814
但是，我們會告訴你
這樣的事情。

1985
01:18:58,814 --> 01:18:59,480
0，我不知道。

1986
01:18:59,480 --> 01:19:02,786
>> DAVIN：為什麼你要
如果s等於null重新檢查？

1987
01:19:02,786 --> 01:19:03,660
學生：[聽不清]。

1988
01:19:03,660 --> 01:19:04,880
DAVIN：由於CHAR星。

1989
01:19:04,880 --> 01:19:05,510
這是一個指針。

1990
01:19:05,510 --> 01:19:09,240
因此，一個完全可以接受的
聲明，我可以說，OK，

1991
01:19:09,240 --> 01:19:11,917
上的equals空，因為它
可以是一個指針為NULL。

1992
01:19:11,917 --> 01:19:14,250
所以，只要你有指針
在這樣的路徑中，

1993
01:19:14,250 --> 01:19:15,420
你應該檢查一下。

1994
01:19:15,420 --> 01:19:18,461
因為如果你不檢查，並
然後你再進入你的for循環，

1995
01:19:18,461 --> 01:19:20,100
而你doing--就跑了下來。

1996
01:19:20,100 --> 01:19:21,980

1997
01:19:21,980 --> 01:19:22,920
SCOOT下來。

1998
01:19:22,920 --> 01:19:23,860
>> 羅伯：對不起，僅此而已。

1999
01:19:23,860 --> 01:19:25,860
>> DAVIN：所以，就像，如果
它是空的，那麼你

2000
01:19:25,860 --> 01:19:28,267
這樣做，有什麼錯誤
你要得到什麼？

2001
01:19:28,267 --> 01:19:29,850
學生：你會得到一組故障。

2002
01:19:29,850 --> 01:19:31,250
DAVIN：你要設置
錯，正確的，因為你

2003
01:19:31,250 --> 01:19:32,616
試圖索引空。

2004
01:19:32,616 --> 01:19:35,240
所以你要盡量指數
到你沒有自己的內存。

2005
01:19:35,240 --> 01:19:39,550
所以這一點，如果這是空值，和
你這樣做，你會週期。

2006
01:19:39,550 --> 01:19:43,656
>> 羅伯：我也覺得在考試中
我們問到這個問題，我們告訴你

2007
01:19:43,656 --> 01:19:45,655
你可以只是假設
它是一個正數。

2008
01:19:45,655 --> 01:19:48,270
由於ATOI也有望
處理負數，

2009
01:19:48,270 --> 01:19:49,686
所以你將不得不特例。

2010
01:19:49,686 --> 01:19:53,080
嘿，是第一個字符
一個破折號，在這種情況下，OK，

2011
01:19:53,080 --> 01:19:54,839
現在它是一個負整數。

2012
01:19:54,839 --> 01:19:56,380
我們會告訴你這些事情。

2013
01:19:56,380 --> 01:19:58,005
我們將告訴你什麼是你需要處理。

2014
01:19:58,005 --> 01:19:59,310
DAVIN：是的。

2015
01:19:59,310 --> 01:20:02,530
所以，我敢肯定，有些人可能會have--
如果你開始尋找舊的考試，

2016
01:20:02,530 --> 01:20:03,900
你見過sterln。

2017
01:20:03,900 --> 01:20:05,120
這是一個流行的一種。

2018
01:20:05,120 --> 01:20:09,790
而且我覺得在sterln，你必須
做此項檢查為空，則返回

2019
01:20:09,790 --> 01:20:10,950
0或類似的東西。

2020
01:20:10,950 --> 01:20:11,940
就像，你必須檢查null。

2021
01:20:11,940 --> 01:20:14,230
如果你沒有，那
是在測驗點關閉。

2022
01:20:14,230 --> 01:20:16,750

2023
01:20:16,750 --> 01:20:19,500
所以無論如何，每個人都做
感覺跟ATOI OK？

2024
01:20:19,500 --> 01:20:21,112

2025
01:20:21,112 --> 01:20:22,820
有誰想
再說明一下部分？

2026
01:20:22,820 --> 01:20:23,815

2027
01:20:23,815 --> 01:20:25,565
羅伯：哦，是的，我認為
我們告訴你

2028
01:20:25,565 --> 01:20:28,565
可以假設，一切is--那
他們實際上是輸入號碼，

2029
01:20:28,565 --> 01:20:32,821
你不必擔心，
喜歡，英文字母的字符串中，所以。

2030
01:20:32,821 --> 01:20:33,320
DAVIN：是的。

2031
01:20:33,320 --> 01:20:33,922
是嗎？

2032
01:20:33,922 --> 01:20:35,713
學生：你可以去
在一次的時候

2033
01:20:35,713 --> 01:20:37,860
您使用雙引號和單引號？

2034
01:20:37,860 --> 01:20:41,290
>> DAVIN：當然，這樣的雙引號，很
簡單地說，就是雙引號的字符串。

2035
01:20:41,290 --> 01:20:43,370
所以，如果你雙引號
任何事情，這是一個字符串。

2036
01:20:43,370 --> 01:20:48,270
所以，就像，如果我有這個0在這裡，
我這樣做，這是一個字符串。

2037
01:20:48,270 --> 01:20:50,060
這不再是一個字符。

2038
01:20:50,060 --> 01:20:54,816
所以，我找不到我的ASCII值這個
圖表，因為它是一個字符串，是的。

2039
01:20:54,816 --> 01:20:57,770

2040
01:20:57,770 --> 01:20:59,480
>> 好了，其他問題嗎？

2041
01:20:59,480 --> 01:21:00,405
是嗎？

2042
01:21:00,405 --> 01:21:02,345
>> 學生：所以，你
已經回答了這個，

2043
01:21:02,345 --> 01:21:05,255
但像，當我們真正
在測驗寫這個，

2044
01:21:05,255 --> 01:21:08,165
你要我們寫
斜線零[聽不清]？

2045
01:21:08,165 --> 01:21:11,041

2046
01:21:11,041 --> 01:21:11,540
DAVIN：第

2047
01:21:11,540 --> 01:21:13,800
現在的問題是，你應該
把一個斜線通過零

2048
01:21:13,800 --> 01:21:14,890
以表明他們是否為零？

2049
01:21:14,890 --> 01:21:15,890
不，我們要搞清楚。

2050
01:21:15,890 --> 01:21:16,940

2051
01:21:16,940 --> 01:21:19,530
是啊，謝謝，他們是很好的。

2052
01:21:19,530 --> 01:21:20,860
好了，別的什麼嗎？

2053
01:21:20,860 --> 01:21:25,060
有誰想to--所以我想
我們已經運行了一點點時間。

2054
01:21:25,060 --> 01:21:27,305
難道你想看到一個又一個，還是？

2055
01:21:27,305 --> 01:21:28,096
學生：RandomInt。

2056
01:21:28,096 --> 01:21:29,230

2057
01:21:29,230 --> 01:21:30,750
>> DAVIN：RandomInt，OK，沒錯。

2058
01:21:30,750 --> 01:21:32,975
因此，讓我們做RandomInt。

2059
01:21:32,975 --> 01:21:34,395

2060
01:21:34,395 --> 01:21:35,270
我在這裡做了。

2061
01:21:35,270 --> 01:21:36,770

2062
01:21:36,770 --> 01:21:39,210
所以RandomInt實際上是要簡單得多。

2063
01:21:39,210 --> 01:21:43,578
我覺得ATOI可能是最難的
我們問過往年。

2064
01:21:43,578 --> 01:21:44,453
學生：[聽不清]。

2065
01:21:44,453 --> 01:21:46,660

2066
01:21:46,660 --> 01:21:47,161
>> DAVIN：什麼？

2067
01:21:47,161 --> 01:21:49,493
羅伯：我看到的，如果它是一種
可查看來自這裡。

2068
01:21:49,493 --> 01:21:50,040
DAVIN：是嗎？

2069
01:21:50,040 --> 01:21:52,500
羅伯：我不認為這是going--我想
它會向右跑了出去。

2070
01:21:52,500 --> 01:21:53,791
DAVIN：OK，所以我會做這個。

2071
01:21:53,791 --> 01:21:56,250
然後你只要把它在屏幕上。

2072
01:21:56,250 --> 01:21:57,150
>> 羅伯：好吧。

2073
01:21:57,150 --> 01:21:58,190
>> DAVIN：你想成為我的文士？

2074
01:21:58,190 --> 01:21:58,600
>> 羅伯：是啊。

2075
01:21:58,600 --> 01:21:59,100
>> DAVIN：尼斯。

2076
01:21:59,100 --> 01:22:01,210

2077
01:22:01,210 --> 01:22:02,727
OK，我可以抹掉呢？

2078
01:22:02,727 --> 01:22:04,188
>> 學生：是啊。

2079
01:22:04,188 --> 01:22:05,162
>> DAVIN：這是如此艱難。

2080
01:22:05,162 --> 01:22:10,032

2081
01:22:10,032 --> 01:22:12,062
（唱）你正在做的
你在做什麼。

2082
01:22:12,062 --> 01:22:14,454
而在做什麼，你不知道。

2083
01:22:14,454 --> 01:22:14,954
行。

2084
01:22:14,954 --> 01:22:19,790

2085
01:22:19,790 --> 01:22:22,930
>> 好吧，如果我沒記錯的話，上
測驗的RandomInt很喜歡，

2086
01:22:22,930 --> 01:22:26,190
好吧，我去給你2
號，像一個和第b。

2087
01:22:26,190 --> 01:22:30,380
我要你給我一個
這些數字之間RandomInt。

2088
01:22:30,380 --> 01:22:33,440
所以RandomInt是怎麼回事
取兩numbers--

2089
01:22:33,440 --> 01:22:41,690
所以RandomInt--和它的
會返回一個int。

2090
01:22:41,690 --> 01:22:42,930
>> 那麼什麼是返回值？

2091
01:22:42,930 --> 01:22:44,151
我只是告訴你。

2092
01:22:44,151 --> 01:22:44,650
詮釋，對不對？

2093
01:22:44,650 --> 01:22:46,400

2094
01:22:46,400 --> 01:22:49,260
像這樣的，然後它
要採取兩個整數。

2095
01:22:49,260 --> 01:22:56,301
因此，要採取INT
一個和INT B，這樣。

2096
01:22:56,301 --> 01:22:58,217
那麼，什麼是RandomInt
要做的是它會

2097
01:22:58,217 --> 01:23:02,440
返回一些隨機值
在這兩個值之間。

2098
01:23:02,440 --> 01:23:05,140
因此，這將是更大的
比，小於b。

2099
01:23:05,140 --> 01:23:09,020
所以，我想你大概可以假設
一個是兩個值中的較小者。

2100
01:23:09,020 --> 01:23:12,210
所以，如果我們正在處理
隨機性，有什麼功能

2101
01:23:12,210 --> 01:23:14,825
我們已經看到，
讓我們隨意的事情？

2102
01:23:14,825 --> 01:23:15,450
學生：Drand。

2103
01:23:15,450 --> 01:23:16,506
DAVIN：Drand，正好。

2104
01:23:16,506 --> 01:23:18,630
所以，你要大概
想用你的drand。

2105
01:23:18,630 --> 01:23:19,940

2106
01:23:19,940 --> 01:23:29,160
所以，你可以說INT隨機的，我們將
只是說等於0，現在。

2107
01:23:29,160 --> 01:23:30,170

2108
01:23:30,170 --> 01:23:38,690
而且他們我們會說，
OK，隨機平等drand 48。

2109
01:23:38,690 --> 01:23:39,747

2110
01:23:39,747 --> 01:23:40,830
而且，這是什麼回報？

2111
01:23:40,830 --> 01:23:43,742
這是什麼功能給你？

2112
01:23:43,742 --> 01:23:45,610
>> 學生：在0和1。

2113
01:23:45,610 --> 01:23:47,870
>> DAVIN：是的，0和1之間。

2114
01:23:47,870 --> 01:23:48,890
因此，這將be--

2115
01:23:48,890 --> 01:23:51,070
>> 羅伯：這is--我想
我們會告訴你這一點。

2116
01:23:51,070 --> 01:23:52,670
喜歡，你可以使用drand 48。

2117
01:23:52,670 --> 01:23:54,350
您可以在過去的考試驗證這一點。

2118
01:23:54,350 --> 01:23:56,720
但是，我們可能會說，你
可以使用drand 48，該

2119
01:23:56,720 --> 01:23:58,790
返回一個介於0和1之間的浮點數。

2120
01:23:58,790 --> 01:24:00,830
>> DAVIN：是的，是的，我
很肯定的考試

2121
01:24:00,830 --> 01:24:03,860
它說你可能
要使用drand，是的。

2122
01:24:03,860 --> 01:24:07,041
因此，它會返回
0和1之間的某個值。

2123
01:24:07,041 --> 01:24:08,790
然後你是什麼
會想要做什麼？

2124
01:24:08,790 --> 01:24:16,360
那麼，你想乘by--
等等，我覺得是這樣的，對不起。

2125
01:24:16,360 --> 01:24:18,018
我就這樣做。

2126
01:24:18,018 --> 01:24:19,410
我不知道。

2127
01:24:19,410 --> 01:24:22,240
>> 所以B減去。

2128
01:24:22,240 --> 01:24:23,310

2129
01:24:23,310 --> 01:24:24,490
那麼，為什麼B減一？

2130
01:24:24,490 --> 01:24:26,110

2131
01:24:26,110 --> 01:24:30,490
所以我們可以說drand給你回
一個int-- OK，我就做休息，

2132
01:24:30,490 --> 01:24:33,380
所以加了。

2133
01:24:33,380 --> 01:24:36,130
那麼，什麼does-- y是B減一。

2134
01:24:36,130 --> 01:24:40,670
因此，讓我們說，drand給你回
最大值它可能

2135
01:24:40,670 --> 01:24:41,410
給你。

2136
01:24:41,410 --> 01:24:42,409
那是什麼打算呢？

2137
01:24:42,409 --> 01:24:43,010
學生：1。

2138
01:24:43,010 --> 01:24:44,430
>> DAVIN：1，對不對？

2139
01:24:44,430 --> 01:24:47,880
因此，如果此值為1，然後就
它由B減一乘，

2140
01:24:47,880 --> 01:24:50,110
好吧，這只是
減去A之間的區別

2141
01:24:50,110 --> 01:24:52,870
如果你再補充一點，
回來到，那是什麼？

2142
01:24:52,870 --> 01:24:54,290

2143
01:24:54,290 --> 01:24:55,180
它基本上是B。

2144
01:24:55,180 --> 01:24:56,435

2145
01:24:56,435 --> 01:24:57,310
這是否有道理？

2146
01:24:57,310 --> 01:24:57,851
>> 學生：是的。

2147
01:24:57,851 --> 01:24:59,480

2148
01:24:59,480 --> 01:25:02,170
>> DAVIN：因此，如果這是最大
珍惜它可能是，

2149
01:25:02,170 --> 01:25:03,175
這將是1。

2150
01:25:03,175 --> 01:25:04,122

2151
01:25:04,122 --> 01:25:06,330
然後這僅僅是
兩者之間的區別。

2152
01:25:06,330 --> 01:25:11,410
添加上，所以這是
要返回隨機。

2153
01:25:11,410 --> 01:25:15,000

2154
01:25:15,000 --> 01:25:18,620
而在角落裡的情況下，
drand給你回1，

2155
01:25:18,620 --> 01:25:20,970
隨機將只是有效地B。

2156
01:25:20,970 --> 01:25:22,700
但是，這是最大的可以。

2157
01:25:22,700 --> 01:25:27,420
因此，如果它要小於
這一點，所以我們說，它像0.9，

2158
01:25:27,420 --> 01:25:31,080
所以後來的0.9倍B減
一個將是較少

2159
01:25:31,080 --> 01:25:33,230
比B減一之間的差。

2160
01:25:33,230 --> 01:25:35,830
>> 然後，如果你添加一個
到一個，則該值是

2161
01:25:35,830 --> 01:25:38,986
要大於一個，因為
您要添加的東西到了，

2162
01:25:38,986 --> 01:25:40,360
但它的將是小於b。

2163
01:25:40,360 --> 01:25:41,430

2164
01:25:41,430 --> 01:25:44,420
所以，你會得到一個隨機的
數，因為你調用drand。

2165
01:25:44,420 --> 01:25:48,000
而且蘭特，即隨機數
將是介於兩者之間的一個

2166
01:25:48,000 --> 01:25:49,342
和b。

2167
01:25:49,342 --> 01:25:50,780
這是否有道理？

2168
01:25:50,780 --> 01:25:52,990
>> 羅伯：只要把它放在
具體的數字，所以

2169
01:25:52,990 --> 01:25:55,450
讓我們說，我們要選擇一個
在7和10的隨機數。

2170
01:25:55,450 --> 01:25:56,960
所以B減去一個是我們的範圍。

2171
01:25:56,960 --> 01:26:00,150
因此，有一個範圍的三個
數字，我們希望選擇。

2172
01:26:00,150 --> 01:26:03,290
然後乘以
即介於0和1 1中，

2173
01:26:03,290 --> 01:26:07,430
如果這則給了我們some--
讓我們說，讓我們1.5。

2174
01:26:07,430 --> 01:26:10,670
>> 那麼1.5，我們要到7至10。

2175
01:26:10,670 --> 01:26:14,470
所以1.5加7為我們帶來
回到我們的7〜10範圍內。

2176
01:26:14,470 --> 01:26:17,580
然後我們將其存儲內
的整數，因此它截斷下降到8。

2177
01:26:17,580 --> 01:26:18,790
然後我們就返回了。

2178
01:26:18,790 --> 01:26:21,310
所以B減去一個是我們的範圍。

2179
01:26:21,310 --> 01:26:25,770
一個移動它分成數
我們希望在該範圍內。

2180
01:26:25,770 --> 01:26:30,540
所以7至10，然後我們
可以回到我們結束了。

2181
01:26:30,540 --> 01:26:32,684
>> DAVIN：是的，不錯。

2182
01:26:32,684 --> 01:26:34,470
>> 羅伯：謝謝。

2183
01:26:34,470 --> 01:26:35,628
>> DAVIN：是啊，這是怎麼回事？

2184
01:26:35,628 --> 01:26:39,746
>> 學生：我們運行任何類型的
當we're-- ASCII錯誤，如果是drand

2185
01:26:39,746 --> 01:26:40,996
返回一個浮點數[聽不清]。

2186
01:26:40,996 --> 01:26:42,470

2187
01:26:42,470 --> 01:26:45,360
>> 羅伯：所以就像羅布說，
因為隨機的不是一個int，

2188
01:26:45,360 --> 01:26:47,080
所以drand將是一個浮動。

2189
01:26:47,080 --> 01:26:48,470
所以，然後將其乘以出來。

2190
01:26:48,470 --> 01:26:50,507
你可能會得到一些
那種浮​​數。

2191
01:26:50,507 --> 01:26:51,840
然後它會截斷。

2192
01:26:51,840 --> 01:26:52,339
>> 學生：OK。

2193
01:26:52,339 --> 01:26:53,019
DAVIN：是的。

2194
01:26:53,019 --> 01:26:56,060
羅伯：如果編譯器是警告
你大概一樣，精度損失，

2195
01:26:56,060 --> 01:26:58,986
只是拋出一個int
在那裡，然後它的好。

2196
01:26:58,986 --> 01:27:00,398

2197
01:27:00,398 --> 01:27:00,898
DAVIN：是的？

2198
01:27:00,898 --> 01:27:02,332

2199
01:27:02,332 --> 01:27:04,722
>> 學生：它會在
得到的概率相同，

2200
01:27:04,722 --> 01:27:06,156
象，B或A [聽不清]？

2201
01:27:06,156 --> 01:27:08,080

2202
01:27:08,080 --> 01:27:10,980
>> 羅伯：所以is--我其實
wondering--是RandomInt咋辦

2203
01:27:10,980 --> 01:27:14,362
是數字從一個到小於b？

2204
01:27:14,362 --> 01:27:16,820
喜歡，如果是7至
10，什麼是機會？

2205
01:27:16,820 --> 01:27:18,454
7，圖8和9，或7，8，9，10？

2206
01:27:18,454 --> 01:27:19,120
DAVIN：我忘了。

2207
01:27:19,120 --> 01:27:19,880
對這個問題set--

2208
01:27:19,880 --> 01:27:20,570
>> 羅伯：我認為這是7，8，9。

2209
01:27:20,570 --> 01:27:22,785
>> DAVIN：它明確表示，一個人的
包容性和人的排斥。

2210
01:27:22,785 --> 01:27:23,110
>> 羅伯：是啊。

2211
01:27:23,110 --> 01:27:23,670
>> DAVIN：但是我don't--我不是 - 

2212
01:27:23,670 --> 01:27:25,878
>> 羅伯：所以我覺得這是
不包括在內，在這種情況下，

2213
01:27:25,878 --> 01:27:28,152
有一個平等的
概率的7，8和9。

2214
01:27:28,152 --> 01:27:29,360
有10個沒有可能性。

2215
01:27:29,360 --> 01:27:31,770

2216
01:27:31,770 --> 01:27:32,270
DAVIN：是的？

2217
01:27:32,270 --> 01:27:33,395
學生：我有一個問題。

2218
01:27:33,395 --> 01:27:38,090
我們要定義一個函數
返回不是一個值，而是一個數組。

2219
01:27:38,090 --> 01:27:41,020
那麼會是什麼
語法後返回？

2220
01:27:41,020 --> 01:27:44,604
>> DAVIN：好吧，那你
回國後would--？

2221
01:27:44,604 --> 01:27:47,020
因此，讓我們說你已經宣布
數組的地方在那裡。

2222
01:27:47,020 --> 01:27:49,708
然後，你將只返回
該陣列的名稱。

2223
01:27:49,708 --> 01:27:50,676
>> 學生：好的，謝謝。

2224
01:27:50,676 --> 01:27:51,718
然後就返回與A--

2225
01:27:51,718 --> 01:27:52,759
DAVIN：哦，等等，非常抱歉。

2226
01:27:52,759 --> 01:27:54,620
現在的問題是如何
你返回一個數組。

2227
01:27:54,620 --> 01:27:56,170
>> 羅伯：雖然它不能
將數組聲明

2228
01:27:56,170 --> 01:27:57,260
在棧或類似的東西。

2229
01:27:57,260 --> 01:27:59,510
它必須是什麼
malloced，因為的malloc

2230
01:27:59,510 --> 01:28:01,610
你是怎麼得到解決
自動內存分配。

2231
01:28:01,610 --> 01:28:02,109
>> DAVIN：是的。

2232
01:28:02,109 --> 01:28:03,433

2233
01:28:03,433 --> 01:28:04,933
羅伯：你周圍的局部範圍內如何獲得。

2234
01:28:04,933 --> 01:28:09,670

2235
01:28:09,670 --> 01:28:11,550
>> DAVIN：但你會
剛剛返回其名稱 - 

2236
01:28:11,550 --> 01:28:17,890
>> 學生：[聽不清]這不是一
值，例如，2號，所以

2237
01:28:17,890 --> 01:28:18,390
[聽不清]。

2238
01:28:18,390 --> 01:28:19,590
>> DAVIN：您不能返回多個號碼。

2239
01:28:19,590 --> 01:28:20,850
你可以不一樣，return--

2240
01:28:20,850 --> 01:28:23,630
>> 學生：我談回國
一個數組或類似的東西。

2241
01:28:23,630 --> 01:28:26,050
>> DAVIN：是啊，所以這個問題是
我可以返回多個值。

2242
01:28:26,050 --> 01:28:27,460
你不能返回多個值。

2243
01:28:27,460 --> 01:28:30,270
你可以不一樣，返回再
返回b或類似的東西。

2244
01:28:30,270 --> 01:28:32,710
因為在你回來，你
返回該功能的。

2245
01:28:32,710 --> 01:28:35,790
然後該函數完成的，並
像羅布說，是在棧上。

2246
01:28:35,790 --> 01:28:38,260
>> 因此，所有的記憶只會越來越
返回到計算機。

2247
01:28:38,260 --> 01:28:40,025
一切都被遺忘了，基本上是這樣。

2248
01:28:40,025 --> 01:28:41,480

2249
01:28:41,480 --> 01:28:44,430
所以，如果你想返回多個
值，您必須返回一個數組，

2250
01:28:44,430 --> 01:28:45,971
而你做到這一點的辦法就是mallocing。

2251
01:28:45,971 --> 01:28:48,780
然後你會回到X這樣的。

2252
01:28:48,780 --> 01:28:50,280
基本上，你只是回到了名。

2253
01:28:50,280 --> 01:28:51,620
當您返回
這樣的事情，你

2254
01:28:51,620 --> 01:28:53,200
實際上不返回值。

2255
01:28:53,200 --> 01:28:55,430
>> 因此，讓我們說你存儲
在一個數組中的值。

2256
01:28:55,430 --> 01:28:57,910
你不是真正
返回的值。

2257
01:28:57,910 --> 01:29:01,515
類似的，如果我返回一個整型，我
真的返回值的副本。

2258
01:29:01,515 --> 01:29:02,017

2259
01:29:02,017 --> 01:29:03,850
但如果我要返回
這樣的事情，

2260
01:29:03,850 --> 01:29:06,450
我返回一個引用
這些值。

2261
01:29:06,450 --> 01:29:09,090
所以我回國，基本上，一個
存儲器地址的值。

2262
01:29:09,090 --> 01:29:10,079
這是否有道理？

2263
01:29:10,079 --> 01:29:10,620
學生：是的。

2264
01:29:10,620 --> 01:29:11,120
DAVIN：尼斯。

2265
01:29:11,120 --> 01:29:12,760

2266
01:29:12,760 --> 01:29:13,410
是嗎？

2267
01:29:13,410 --> 01:29:15,430
>> 學生：當你
使用drand在這裡，

2268
01:29:15,430 --> 01:29:17,660
你必須把函數srand之前？

2269
01:29:17,660 --> 01:29:20,320
>> DAVIN：不，不，我不這麼認為。

2270
01:29:20,320 --> 01:29:23,040
>> 羅伯：是啊，所以你有
說一下函數srand什麼？

2271
01:29:23,040 --> 01:29:26,900
你默認永不說函數srand
在一切都只是做空的函數srand。

2272
01:29:26,900 --> 01:29:29,350
所以drand自身意志的工作。

2273
01:29:29,350 --> 01:29:33,759
它會自動與種子
當前時間，是它的用途。

2274
01:29:33,759 --> 01:29:35,175

2275
01:29:35,175 --> 01:29:35,675
DAVIN：是的？

2276
01:29:35,675 --> 01:29:40,950
學生：你[聽不清]
隨著數字？

2277
01:29:40,950 --> 01:29:42,570
DAVIN：是的，可以。

2278
01:29:42,570 --> 01:29:46,770
學生：所以，你可以
說的一樣，4次2。

2279
01:29:46,770 --> 01:29:50,280
關鍵是，你不能假設
那麼int是4個字節。

2280
01:29:50,280 --> 01:29:51,020
該only--

2281
01:29:51,020 --> 01:29:53,830
>> DAVIN：我的意思是，對於測驗即可。

2282
01:29:53,830 --> 01:29:54,830
[笑]

2283
01:29:54,830 --> 01:29:55,780
>> 羅伯：嗯，沒有。

2284
01:29:55,780 --> 01:29:56,780
DAVIN：是的，是的，你可以。

2285
01:29:56,780 --> 01:30:00,197
如果他們問你有多大的int是，
你不能一樣，四個或八個。

2286
01:30:00,197 --> 01:30:02,030
羅伯：哦，所以如果
問題是，具體而言，

2287
01:30:02,030 --> 01:30:04,857
等，如果它是一個編碼問題，
你應該說為int的大小。

2288
01:30:04,857 --> 01:30:06,690
如果它是一個表，或
它說多少字節，

2289
01:30:06,690 --> 01:30:08,808
你不應該填個整數的大小。

2290
01:30:08,808 --> 01:30:11,278
>> 學生：[笑]

2291
01:30:11,278 --> 01:30:18,210

2292
01:30:18,210 --> 01:30:20,580
>> DAVIN：對，所以為什麼
在這裡INT重要的尺寸是多少？

2293
01:30:20,580 --> 01:30:23,085
所以像，如果我們要為32位
處理器或類似的東西，

2294
01:30:23,085 --> 01:30:24,300
那將是四個字節。

2295
01:30:24,300 --> 01:30:26,342
但對一些較新的
的東西，它可能是什麼？

2296
01:30:26,342 --> 01:30:27,383
這可能是8，對不對？

2297
01:30:27,383 --> 01:30:30,550
所以this--如果你只是硬編碼4，
然後在一些機器上，它會奏效。

2298
01:30:30,550 --> 01:30:32,180
一些機器，它不會工作。

2299
01:30:32,180 --> 01:30:35,270
但是，如果對我們的測驗
就像有多大是一個int？

2300
01:30:35,270 --> 01:30:35,770
放四個。

2301
01:30:35,770 --> 01:30:38,710

2302
01:30:38,710 --> 01:30:39,210
羅伯：對。

2303
01:30:39,210 --> 01:30:39,790
DAVIN：是嗎？

2304
01:30:39,790 --> 01:30:43,192
學生：所以，因為我們聲明
[聽不清]在函數內部，

2305
01:30:43,192 --> 01:30:45,622
我們應該把3該函數內部？

2306
01:30:45,622 --> 01:30:46,907
或者，我們可以外面使用它呢？

2307
01:30:46,907 --> 01:30:48,740
DAVIN：你可以使用它
以外的功能。

2308
01:30:48,740 --> 01:30:49,890
所以他要求免費。

2309
01:30:49,890 --> 01:30:51,700
>> 學生：失去跟踪
。在哪裡[聽不清]

2310
01:30:51,700 --> 01:30:54,720
>> 羅伯：哦，自由不happen--
這是對的malloc魔法的一部分

2311
01:30:54,720 --> 01:30:57,220
是你不
僅限於本地範圍。

2312
01:30:57,220 --> 01:31:00,700
你在完全控制
你的變量活多久。

2313
01:31:00,700 --> 01:31:05,380
因此，我們調用malloc在這裡，它可能
是一個完全獨立的功能。

2314
01:31:05,380 --> 01:31:08,670
它可能是10小時後進行
我們終於打電話免費。

2315
01:31:08,670 --> 01:31:11,764
>> DAVIN：那麼比如說像，一對夫婦
幾個星期後，當你終於

2316
01:31:11,764 --> 01:31:13,680
做你的拼寫字典
pset時，你會

2317
01:31:13,680 --> 01:31:16,410
有一些函數
創建噸的節點。

2318
01:31:16,410 --> 01:31:18,630
所以你mallocing噸
在此函數中的節點。

2319
01:31:18,630 --> 01:31:20,670
再後來在一個
單獨的函數，你

2320
01:31:20,670 --> 01:31:22,440
將要釋放所有的節點。

2321
01:31:22,440 --> 01:31:25,740
所以，你可以從字面上只是傳遞到
釋放一個指針，這樣的存儲器地址

2322
01:31:25,740 --> 01:31:26,684
你malloced什麼。

2323
01:31:26,684 --> 01:31:27,600
而這將被罰款。

2324
01:31:27,600 --> 01:31:29,725
你沒有自由，
等，在相同的功能。

2325
01:31:29,725 --> 01:31:30,449
是嗎？

2326
01:31:30,449 --> 01:31:36,197
>> 學生：所以一個malloc
變量[聽不清]之外？

2327
01:31:36,197 --> 01:31:37,384
是，你在說什麼？

2328
01:31:37,384 --> 01:31:38,300
DAVIN：等等，這麼說？

2329
01:31:38,300 --> 01:31:38,800
抱歉。

2330
01:31:38,800 --> 01:31:42,300
>> 學生：如果一個變量的malloc
可以是自由的代碼中的任何地方，

2331
01:31:42,300 --> 01:31:44,800
這樣，他們才能進行訪問
在代碼中的任何地方？

2332
01:31:44,800 --> 01:31:45,800
你可以讓他們本地的？

2333
01:31:45,800 --> 01:31:47,880
>> DAVIN：哦，她問，
像，變量，like--

2334
01:31:47,880 --> 01:31:51,300

2335
01:31:51,300 --> 01:31:55,510
>> 羅伯：所以你仍然需要
有某種參考

2336
01:31:55,510 --> 01:31:57,220
到內存的malloc的塊。

2337
01:31:57,220 --> 01:31:58,540
所以在這裡，我們返回X。

2338
01:31:58,540 --> 01:31:59,040
學生：哦。

2339
01:31:59,040 --> 01:32:01,920
羅伯：如果我們不返回X
在這裡，這只是虛空，

2340
01:32:01,920 --> 01:32:04,550
那麼我們都進不去
這是malloced指針，

2341
01:32:04,550 --> 01:32:05,920
它的內存洩露。

2342
01:32:05,920 --> 01:32:06,690
>> 學生：OK。

2343
01:32:06,690 --> 01:32:10,010
>> DAVIN：那麼像，讓我們說你
有這樣的一樣，就在這裡。

2344
01:32:10,010 --> 01:32:10,510
羅伯：第

2345
01:32:10,510 --> 01:32:13,430
DAVIN：在我的主要功能，我不能
只需要調用這個x和是一樣，OK，

2346
01:32:13,430 --> 01:32:14,645
在這個函數中，我這樣做。

2347
01:32:14,645 --> 01:32:14,960
>> 羅伯：對。

2348
01:32:14,960 --> 01:32:17,790
>> DAVIN：所以我要打電話給X中，
象，主要或類似的東西。

2349
01:32:17,790 --> 01:32:18,540
你不能做到這一點。

2350
01:32:18,540 --> 01:32:19,600
你要返回的東西。

2351
01:32:19,600 --> 01:32:21,000
但是，你要回來嗎？

2352
01:32:21,000 --> 01:32:22,130
你會返回一個內存地址。

2353
01:32:22,130 --> 01:32:25,130
因為你恢復記憶
地址，即可以在其他地方進行訪問。

2354
01:32:25,130 --> 01:32:27,262

2355
01:32:27,262 --> 01:32:28,255
還有什麼問題嗎？

2356
01:32:28,255 --> 01:32:28,755
是嗎？

2357
01:32:28,755 --> 01:32:31,213
>> 學生：是上面的函數
被檢查[聽不清]？

2358
01:32:31,213 --> 01:32:33,270

2359
01:32:33,270 --> 01:32:35,005
>> DAVIN：為什麼我沒有必要做呢？

2360
01:32:35,005 --> 01:32:35,880
學生：[聽不清]。

2361
01:32:35,880 --> 01:32:37,755
DAVIN：因為你
不mallocing什麼。

2362
01:32:37,755 --> 01:32:39,640
所以它的不是 - 是的，這是
不喜歡一個字符串s。

2363
01:32:39,640 --> 01:32:41,160
這是一個指針的地方。

2364
01:32:41,160 --> 01:32:42,951
這些只是值。

2365
01:32:42,951 --> 01:32:43,450
學生：OK。

2366
01:32:43,450 --> 01:32:43,949
DAVIN：是的。

2367
01:32:43,949 --> 01:32:47,600

2368
01:32:47,600 --> 01:32:48,470
還要別的嗎？

2369
01:32:48,470 --> 01:32:48,970
羅伯：是的？

2370
01:32:48,970 --> 01:32:50,386
學生：但是當你[聽不清]？

2371
01:32:50,386 --> 01:32:55,050

2372
01:32:55,050 --> 01:32:58,690
>> 羅伯：所以為了釋放
記憶中，我們會在這裡說。

2373
01:32:58,690 --> 01:33:01,350
因此，x是我們的指針
的存儲器塊。

2374
01:33:01,350 --> 01:33:02,845
我們釋放該指針。

2375
01:33:02,845 --> 01:33:04,470
我們不一定會在這裡做。

2376
01:33:04,470 --> 01:33:05,390
我們可以在任何地方。

2377
01:33:05,390 --> 01:33:10,400
但是，你只能撥打免費
一些malloc的回報。

2378
01:33:10,400 --> 01:33:12,940
所以malloc的，在這裡，返回
什麼被存儲x中。

2379
01:33:12,940 --> 01:33:14,802
因此，我們可以調用免費的X。

2380
01:33:14,802 --> 01:33:18,730

2381
01:33:18,730 --> 01:33:20,556
最後還有什麼問題？

2382
01:33:20,556 --> 01:33:21,701
>> DAVIN：最後還有什麼問題？

2383
01:33:21,701 --> 01:33:22,200
是嗎？

2384
01:33:22,200 --> 01:33:25,152
>> 學生：對不起，你能不能再解釋一下
你為什麼會免費嗎？

2385
01:33:25,152 --> 01:33:26,630
為什麼[聽不清]？

2386
01:33:26,630 --> 01:33:27,774
>> DAVIN：在這裡？

2387
01:33:27,774 --> 01:33:29,109
>> 學生：是啊，像權後。

2388
01:33:29,109 --> 01:33:30,900
DAVIN：你可能
不想免費在這裡。

2389
01:33:30,900 --> 01:33:31,630
羅伯：你可能不會。

2390
01:33:31,630 --> 01:33:33,060
DAVIN：是的，這會什麼都不做。

2391
01:33:33,060 --> 01:33:35,220
這一樣，創造
記憶，做的東西給它，

2392
01:33:35,220 --> 01:33:37,390
然後立即
忘掉它，是啊。

2393
01:33:37,390 --> 01:33:39,850
>> 羅伯：但我們可以做的，比如，
在這裡的某些原因。

2394
01:33:39,850 --> 01:33:43,902
我們可能會說INT明星
y等於返回的數組。

2395
01:33:43,902 --> 01:33:47,900
做一些東西與Y，
也許打印的內容。

2396
01:33:47,900 --> 01:33:49,350
然後，終於，我們就大功告成了。

2397
01:33:49,350 --> 01:33:50,626
我們可以免費年。

2398
01:33:50,626 --> 01:33:51,501
學生：[聽不清]。

2399
01:33:51,501 --> 01:33:57,839

2400
01:33:57,839 --> 01:33:59,005
DAVIN：我應該向下滾動？

2401
01:33:59,005 --> 01:34:00,445
謝謝。

2402
01:34:00,445 --> 01:34:00,945
羅伯：尼斯。

2403
01:34:00,945 --> 01:34:02,400

2404
01:34:02,400 --> 01:34:03,646
>> DAVIN：OK，就是這樣。

2405
01:34:03,646 --> 01:34:04,520
羅伯：好吧，好了。

2406
01:34:04,520 --> 01:34:05,070
祝好運。

2407
01:34:05,070 --> 01:34:06,800
>> DAVIN：如果你有問題，給我們發電子郵件。

2408
01:34:06,800 --> 01:34:08,670
祝好運。

2409
01:34:08,670 --> 01:34:10,283