1
00:00:07,420 --> 00:00:08,160
[Powered by Google Translate] DAVID J.馬蘭所有權利。

2
00:00:08,160 --> 00:00:11,170
這是CS50，這是結束2週。

3
00:00:11,170 --> 00:00:14,650
如果您希望明天的這個時候周圍是餓了，知道我們要去

4
00:00:14,650 --> 00:00:18,920
召開會議，明天一小群，週四，1:15 PM。

5
00:00:18,920 --> 00:00:21,460
這個URL，在這裡，如果你想回覆。

6
00:00:21,460 --> 00:00:25,270
空間是有限的，所以請原諒，如果表單的時候，填補了你

7
00:00:25,270 --> 00:00:26,680
填寫。

8
00:00:26,680 --> 00:00:29,400
雖然可能感興趣的另一個URL是這樣的。

9
00:00:29,400 --> 00:00:32,409
>> 因此，在，只是大約一個月的時間，當然是要提供

10
00:00:32,409 --> 00:00:36,090
所有通過EDX，通過更廣泛的人在互聯網上

11
00:00:36,090 --> 00:00:39,580
能夠跟著，從事的過程中，其實相當積極。

12
00:00:39,580 --> 00:00:43,070
他們將使用CS50電器和CS50討論的，大部分的

13
00:00:43,070 --> 00:00:45,840
各種軟件工具，我們已經一直在使用這個學期。

14
00:00:45,840 --> 00:00:49,030
而其中一項措施，我們希望作為一個實驗，今年

15
00:00:49,030 --> 00:00:53,120
我們可以看到多少內容翻譯成其他說

16
00:00:53,120 --> 00:00:54,110
書面語言。

17
00:00:54,110 --> 00:00:58,000
所以，如果你可能有興趣參與該項目，

18
00:00:58,000 --> 00:01:02,090
我們將提供英語課程的成績單及字幕

19
00:01:02,090 --> 00:01:05,190
講座和短褲，研討會及部分和 - 

20
00:01:05,190 --> 00:01:08,700
如果你會講一口流利的或寫流利一些其他的語言，我們會

21
00:01:08,700 --> 00:01:12,240
愛，讓你在這個項目，讓你承擔一個或更多的

22
00:01:12,240 --> 00:01:15,340
視頻，將其轉化為一個語言，你知道得很好。

23
00:01:15,340 --> 00:01:19,050
為了讓你的界面感，還有這個基於Web的用戶界面

24
00:01:19,050 --> 00:01:22,330
我們將使用，將創建基本上是這樣的一個UI。

25
00:01:22,330 --> 00:01:24,520
這是我教一些萬聖節前。

26
00:01:24,520 --> 00:01:27,710
和右手側有黑色旁邊這些時間戳，

27
00:01:27,710 --> 00:01:31,300
你會看到不同的東西，我的嘴裡說出來的那一天。

28
00:01:31,300 --> 00:01:34,660
然後在它下面，你會翻譯成一些其他的語言。

29
00:01:34,660 --> 00:01:37,840
究竟是什麼之間的映射是，在這種情況下，英語

30
00:01:37,840 --> 00:01:38,660
並說，西班牙。

31
00:01:38,660 --> 00:01:40,480
因此，它實際上是一個非常用戶友好的工具。

32
00:01:40,480 --> 00:01:43,690
您可以倒帶，快進，很容易與鍵盤快捷鍵。

33
00:01:43,690 --> 00:01:46,710
所以，如果你想參加這個實驗，你的話

34
00:01:46,710 --> 00:01:50,730
有可能有成千上萬的人看到和閱讀的，請不要感到

35
00:01:50,730 --> 00:01:51,960
免費參加。

36
00:01:51,960 --> 00:01:56,940
>> 現在，一個字約從週一小貓，免得我們已將過於

37
00:01:56,940 --> 00:01:58,120
可怕的消息。

38
00:01:58,120 --> 00:02:02,130
一定要明白，，辦公時間建議和段的建議，

39
00:02:02,130 --> 00:02:05,110
課程的設計是非常有學生的協作和

40
00:02:05,110 --> 00:02:09,250
說一起工作，通過習題集和問題。

41
00:02:09,250 --> 00:02:13,630
真正的行歸結到了，你的工作，最終

42
00:02:13,630 --> 00:02:16,420
應提交的應該是你自己。

43
00:02:16,420 --> 00:02:19,080
所以，坦白地說 - 在辦公時間，這是完全正常的 - 

44
00:02:19,080 --> 00:02:21,560
它完全可以預期的，甚至 - 有一些聊天

45
00:02:21,560 --> 00:02:22,370
你旁邊的朋友。

46
00:02:22,370 --> 00:02:25,240
如果他或她掙扎著一些話題，和你一樣，哦，好讓

47
00:02:25,240 --> 00:02:27,750
我給你看到，我寫了一些代碼行。

48
00:02:27,750 --> 00:02:28,290
這很好。

49
00:02:28,290 --> 00:02:28,700
出現這種情況。

50
00:02:28,700 --> 00:02:31,580
這是非常有利的，我認為，學習的過程中。

51
00:02:31,580 --> 00:02:35,270
在哪裡就行了，再次被越過時，頭是有點歪了

52
00:02:35,270 --> 00:02:38,800
這裡真的有太多秒或分鐘，只

53
00:02:38,800 --> 00:02:41,250
無障礙給你的朋友的機會。

54
00:02:41,250 --> 00:02:43,870
當然，當事情變得交換通過電子郵件和Dropbox

55
00:02:43,870 --> 00:02:45,350
等，也有是行。

56
00:02:45,350 --> 00:02:48,940
因此，通過各種手段，手感舒適，感到鼓舞與朋友聊天

57
00:02:48,940 --> 00:02:51,270
和同學約pset和更多。

58
00:02:51,270 --> 00:02:54,680
而就認識到，真的是你最終提交

59
00:02:54,680 --> 00:02:57,780
你的創造，而不是別人的產品的。

60
00:02:57,780 --> 00:03:01,010
>> 因此，在同樣的可愛的動物，你可能會

61
00:03:01,010 --> 00:03:02,820
知道這傢伙在這裡。

62
00:03:02,820 --> 00:03:06,180
因此，從幾年前的電影，這是驚人的俗氣。

63
00:03:06,180 --> 00:03:08,680
在這裡的任何人都看到“太空砲彈”？

64
00:03:08,680 --> 00:03:09,120
好的。

65
00:03:09,120 --> 00:03:10,220
因此，一個好的號碼。

66
00:03:10,220 --> 00:03:13,840
因此，這是我們今天介紹的最後美妙的學術方式

67
00:03:13,840 --> 00:03:15,130
密碼學的概念。

68
00:03:15,130 --> 00:03:19,010
因此，pset的，這將前來領域特定問題

69
00:03:19,010 --> 00:03:22,770
明天晚上到很晚，是潛入密碼學的世界，

70
00:03:22,770 --> 00:03:26,380
信息的加密和擾碼是一門藝術。

71
00:03:26,380 --> 00:03:30,160
而這最終涉及到世界的安全。

72
00:03:30,160 --> 00:03:34,440
>> 立即安全對於大多數我們的形式相當平凡的機制。

73
00:03:34,440 --> 00:03:36,920
我們所有的用戶名和密碼。

74
00:03:36,920 --> 00:03:41,350
我們所有的人都非常糟糕的用戶名和密碼，最有可能的。

75
00:03:41,350 --> 00:03:45,250
如果您在多個網站上的密碼是相同的，這可能是不

76
00:03:45,250 --> 00:03:47,920
最好的主意，我們將討論對學期結束。

77
00:03:47,920 --> 00:03:51,680
如果您的密碼是寫在一個便簽 - 可不是鬧著玩的 - 你的

78
00:03:51,680 --> 00:03:55,130
顯示器，這也並不一定是最好的設計，而是一個相當普遍的

79
00:03:55,130 --> 00:03:56,140
的現象。

80
00:03:56,140 --> 00:04:00,420
而且，如果你不使用加密技術來加密您的密碼，它們是

81
00:04:00,420 --> 00:04:01,610
特別脆弱。

82
00:04:01,610 --> 00:04:04,670
所以，如果你認為你是超級聰明有一個隱藏的字

83
00:04:04,670 --> 00:04:07,740
在您的硬盤驅動器上有你所有的密碼，但記錄的地方

84
00:04:07,740 --> 00:04:10,550
它是在一個文件夾，沒有人會看，這也不是一個很

85
00:04:10,550 --> 00:04:11,540
安全機制。

86
00:04:11,540 --> 00:04:15,100
還等什麼的pset將介紹這是密碼學藝術的，

87
00:04:15,100 --> 00:04:18,300
擾碼信息，如密碼，這樣的事情是

88
00:04:18,300 --> 00:04:19,500
更安全。

89
00:04:19,500 --> 00:04:24,500
所以這個非常現實世界中的問題，以激勵與非現實世界的

90
00:04:24,500 --> 00:04:28,740
的情況下，讓我給你介紹我們最喜歡的片段之一，從這個

91
00:04:28,740 --> 00:04:29,895
電影，“太空砲彈”。

92
00:04:29,895 --> 00:04:30,565
>> [視頻回放]

93
00:04:30,565 --> 00:04:32,995
頭盔，你的惡魔，什麼是怎麼回事？

94
00:04:32,995 --> 00:04:34,730
你在做什麼我的女兒嗎？

95
00:04:34,730 --> 00:04:38,960
請允許我介紹年輕的整形外科醫生，菲利普博士

96
00:04:38,960 --> 00:04:43,290
Schlotkin，最大的隆鼻的人在整個

97
00:04:43,290 --> 00:04:45,526
宇宙和比佛利山莊。

98
00:04:45,526 --> 00:04:46,450
殿下。

99
00:04:46,450 --> 00:04:47,380
鼻的工作嗎？

100
00:04:47,380 --> 00:04:48,035
我聽不懂。

101
00:04:48,035 --> 00:04:49,480
她已經有鼻子工作。

102
00:04:49,480 --> 00:04:51,490
這是一個甜蜜的16個目前。

103
00:04:51,490 --> 00:04:53,090
不，這不是你的想法。

104
00:04:53,090 --> 00:04:55,150
這是非常，非常糟糕。

105
00:04:55,150 --> 00:04:59,860
如果你不給我組合的空氣盾，博士Schlotkin會

106
00:04:59,860 --> 00:05:04,135
給你女兒回到她的老鼻子了。

107
00:05:04,135 --> 00:05:05,385
 - 不！

108
00:05:08,202 --> 00:05:10,186
你從哪兒弄來的？

109
00:05:10,186 --> 00:05:11,178
 - 所有權利。

110
00:05:11,178 --> 00:05:11,674
我會告訴。

111
00:05:11,674 --> 00:05:12,666
我會告訴。

112
00:05:12,666 --> 00:05:14,154
不，爸爸，沒有。

113
00:05:14,154 --> 00:05:15,150
你別這樣。

114
00:05:15,150 --> 00:05:16,460
 - 你說得對，我親愛的。

115
00:05:16,460 --> 00:05:18,450
我會想念你的新鼻子。

116
00:05:18,450 --> 00:05:21,550
但我不會告訴他們的組合不管是什麼。

117
00:05:21,550 --> 00:05:23,100
 - 好極了。

118
00:05:23,100 --> 00:05:25,510
Schlotkin博士，做最壞的。

119
00:05:25,510 --> 00:05:26,760
是我的榮幸。

120
00:05:30,560 --> 00:05:31,180
 - 不！

121
00:05:31,180 --> 00:05:33,450
等等，等等。

122
00:05:33,450 --> 00:05:34,770
我會告訴。

123
00:05:34,770 --> 00:05:36,400
我會告訴。

124
00:05:36,400 --> 00:05:38,630
我知道它的工作。

125
00:05:38,630 --> 00:05:42,040
好吧，把它給我。

126
00:05:42,040 --> 00:05:46,890
該組合是其中之一。

127
00:05:46,890 --> 00:05:47,290
一。

128
00:05:47,290 --> 00:05:48,183
一。

129
00:05:48,183 --> 00:05:48,950
二。

130
00:05:48,950 --> 00:05:49,370
二。

131
00:05:49,370 --> 00:05:50,450
二。

132
00:05:50,450 --> 00:05:50,715
 - 三

133
00:05:50,715 --> 00:05:51,380
三。

134
00:05:51,380 --> 00:05:52,390
三。

135
00:05:52,390 --> 00:05:53,200
四。

136
00:05:53,200 --> 00:05:53,720
四。

137
00:05:53,720 --> 00:05:55,830
四。

138
00:05:55,830 --> 00:05:56,580
五

139
00:05:56,580 --> 00:05:57,120
五。

140
00:05:57,120 --> 00:05:58,560
五。

141
00:05:58,560 --> 00:06:03,770
所以組合是一個，兩個，三個，四個，五個。

142
00:06:03,770 --> 00:06:06,745
這是我所聽到過的最愚蠢的組合在我的生活中。

143
00:06:06,745 --> 00:06:09,290
那是白痴才會有這樣的事情在他的行李。

144
00:06:09,290 --> 00:06:11,540
謝謝你，你的高度。

145
00:06:11,540 --> 00:06:12,940
你做了什麼？

146
00:06:12,940 --> 00:06:14,230
我關掉了牆上。

147
00:06:14,230 --> 00:06:14,630
不，你沒有。

148
00:06:14,630 --> 00:06:15,430
您關閉了整部影片。

149
00:06:15,430 --> 00:06:16,722
我一定按錯了按鈕。

150
00:06:16,722 --> 00:06:18,078
好了，把它放回去。

151
00:06:18,078 --> 00:06:18,805
把電影。

152
00:06:18,805 --> 00:06:19,080
是的，先生。

153
00:06:19,080 --> 00:06:19,270
是的，先生。

154
00:06:19,270 --> 00:06:19,830
讓我們去，愛爾納。

155
00:06:19,830 --> 00:06:20,270
來吧，格雷琴。

156
00:06:20,270 --> 00:06:22,850
當然，你知道，我還是會向您。

157
00:06:27,400 --> 00:06:28,325
好了，沒有工作？

158
00:06:28,325 --> 00:06:29,550
門在哪裡？

159
00:06:29,550 --> 00:06:29,910
它的工作，先生。

160
00:06:29,910 --> 00:06:30,770
我們的組合。

161
00:06:30,770 --> 00:06:31,390
 - 太好了。

162
00:06:31,390 --> 00:06:35,630
現在，我們可以從地球Druidia每一個呼吸新鮮的空氣。

163
00:06:35,630 --> 00:06:36,550
什麼組合？

164
00:06:36,550 --> 00:06:38,805
一，二，三，四，五。

165
00:06:38,805 --> 00:06:40,610
一，二，三，四，五？

166
00:06:40,610 --> 00:06:41,070
是的。

167
00:06:41,070 --> 00:06:41,760
這是驚人的。

168
00:06:41,760 --> 00:06:45,200
在我的行李，我已經得到了相同的組合。

169
00:06:45,200 --> 00:06:47,800
準備空間球1立即離開。

170
00:06:47,800 --> 00:06:48,536
是的，先生。

171
00:06:48,536 --> 00:06:52,350
和變更的組合在我的行李。

172
00:06:52,350 --> 00:06:53,250
 - 噢！

173
00:06:53,250 --> 00:06:55,020
[END視頻播放]

174
00:06:55,020 --> 00:06:57,470
>> DAVID J.馬蘭：你現在應該看到一個驚人的電影。

175
00:07:00,600 --> 00:07:06,540
因此，這裡的語境是不安全的數據來的機會

176
00:07:06,540 --> 00:07:07,790
加密和爭奪它。

177
00:07:07,790 --> 00:07:11,060
等，例如，是一個加密的消息的一個例子。

178
00:07:11,060 --> 00:07:12,980
這實際上是說英語的東西。

179
00:07:12,980 --> 00:07:14,750
但它顯然不是完全明顯。

180
00:07:14,750 --> 00:07:17,360
我們將兜了一圈，今天捉弄除了這是什麼秘密

181
00:07:17,360 --> 00:07:18,380
這裡的信息是。

182
00:07:18,380 --> 00:07:22,370
但在現實世界中的電腦，事情並不甚至看起來會

183
00:07:22,370 --> 00:07:23,440
是的英語句子。

184
00:07:23,440 --> 00:07:27,500
例如，這是你可能會發現在一個標準的Linux或Mac或

185
00:07:27,500 --> 00:07:32,080
Unix計算機中的文件，是很久很久以前被稱為密碼文件。

186
00:07:32,080 --> 00:07:34,170
如今，它被轉移到其他地方。

187
00:07:34,170 --> 00:07:38,660
但是，如果你的系統上，在正確的地方，你會看到不僅是你的

188
00:07:38,660 --> 00:07:41,430
用戶名或系統上的其他人，但你會看到一個

189
00:07:41,430 --> 00:07:43,410
他們的密碼的加密版本。

190
00:07:43,410 --> 00:07:47,800
事實上，這個詞地下室有以下的東西是加密的。

191
00:07:47,800 --> 00:07:52,030
而這一系列看似隨機的字母和字符和數字，

192
00:07:52,030 --> 00:07:56,370
等等，都可以被解密僅由一般知道的一些秘密 - 

193
00:07:56,370 --> 00:07:58,600
一個秘密的話，一個秘密數字。

194
00:07:58,600 --> 00:08:02,760
事實上，藝術的加密技術最終都歸結到信任的一些

195
00:08:02,760 --> 00:08:05,700
排序和別人不知道的東西。

196
00:08:05,700 --> 00:08:10,010
我們將探討這方面更詳細一點今天在pset中來。

197
00:08:10,010 --> 00:08:11,860
>> 而現在通過/失敗的一個詞。

198
00:08:11,860 --> 00:08:15,250
特別是一些潛入的pset，家電，和

199
00:08:15,250 --> 00:08:18,390
一個很新的世界為自己，認識到挫折和

200
00:08:18,390 --> 00:08:21,340
混亂和技術困難是可以預期的。

201
00:08:21,340 --> 00:08:24,410
特別是隨著第一的pset，那裡有這麼多新的，剛開

202
00:08:24,410 --> 00:08:28,830
熟悉的ls和cd，所有這些神秘的命令在一個新的環境。

203
00:08:28,830 --> 00:08:32,679
這是從實際材料和編程本身分開。

204
00:08:32,679 --> 00:08:35,960
因此，實現，也有一定存在的辦公時間

205
00:08:35,960 --> 00:08:36,770
支承結構上。

206
00:08:36,770 --> 00:08:38,620
節本星期日開始。

207
00:08:38,620 --> 00:08:41,990
但是，最重要的是，如果你只是感覺這是不

208
00:08:41,990 --> 00:08:44,420
你的世界，實現它確實只是需要時間。

209
00:08:44,420 --> 00:08:47,520
，它不給我這個機會，幾年前對我來說，一類

210
00:08:47,520 --> 00:08:50,840
通過/失敗，說實話，我永遠不會甚至踏上在教室裡。

211
00:08:50,840 --> 00:08:53,520
你可以改變這件事，直到說，第五次週一的課程。

212
00:08:53,520 --> 00:08:57,110
所以，如果你對現在的邊緣，而不是頭，實現了一些其他

213
00:08:57,110 --> 00:09:01,000
完全水域，肯定會考慮轉變為通過/失敗。

214
00:09:01,000 --> 00:09:03,750
同樣，有沒有真的這種文化在哈佛考慮的事情

215
00:09:03,750 --> 00:09:08,080
通過/失敗，因為每個人都希望實現或超額完成。

216
00:09:08,080 --> 00:09:11,470
但坦率地說，這是一個美妙的方式嘗試了，可能不

217
00:09:11,470 --> 00:09:13,110
很熟悉的。

218
00:09:13,110 --> 00:09:17,090
你會做在大多數情況下，相當精緻，也許

219
00:09:17,090 --> 00:09:18,040
多給您驚喜。

220
00:09:18,040 --> 00:09:20,850
更具體的，我覺得通過/失敗一般不，

221
00:09:20,850 --> 00:09:23,350
尤其是當你可能經歷過的pset 0，如果你已經把

222
00:09:23,350 --> 00:09:27,200
在10小時，15小時，25小時到一些pset中 - 和你只是撞

223
00:09:27,200 --> 00:09:28,180
你的頭靠在牆上，

224
00:09:28,180 --> 00:09:29,850
它的超級深夜，

225
00:09:29,850 --> 00:09:31,880
但你在pset的方式，如90％，

226
00:09:31,880 --> 00:09:33,780
你知道你只是無法弄清楚一件事 - 

227
00:09:33,780 --> 00:09:36,830
通過/失敗的真正的邊緣，這樣的一類，在這裡你可以排序

228
00:09:36,830 --> 00:09:39,150
高興地說好了，我知道它並不是完美的。

229
00:09:39,150 --> 00:09:40,470
但我的工作我的屁股上。

230
00:09:40,470 --> 00:09:42,410
我很高興就結束了。

231
00:09:42,410 --> 00:09:44,780
將滿足期望通過/失敗。

232
00:09:44,780 --> 00:09:46,850
所以千萬記住這一點。

233
00:09:46,850 --> 00:09:47,140
>> 好的。

234
00:09:47,140 --> 00:09:50,980
因此，那些你們誰一直在努力使用哈佛大學的Wi-Fi知道

235
00:09:50,980 --> 00:09:54,780
該有一CS50 SSID的，通過Wi-Fi連接周圍，漂浮

236
00:09:54,780 --> 00:09:56,520
可能有更好的運氣。

237
00:09:56,520 --> 00:09:59,430
這是一個有點諷刺的密碼 - 如果你想嘗試一下

238
00:09:59,430 --> 00:10:03,080
更好的速度和連接到該讓我們知道，如果沒有更好的 - 

239
00:10:03,080 --> 00:10:09,240
是一，二，三，四，五，一路攀升到8，因為8是

240
00:10:09,240 --> 00:10:10,270
更安全比五。

241
00:10:10,270 --> 00:10:15,520
所以，如果你需要的Wi-Fi密碼，無線連接到CS50這裡。

242
00:10:15,520 --> 00:10:16,950
一，二，三，四，五，六，七，八。

243
00:10:16,950 --> 00:10:20,440
CS50後上討論，如果你仍然有間歇性的連接問題，

244
00:10:20,440 --> 00:10:24,880
我們將讓權力知道這個空間。

245
00:10:24,880 --> 00:10:25,180
>> 好的。

246
00:10:25,180 --> 00:10:30,350
所以簡單的玩笑話，尤其是對於那些你們誰是風扇的男孩或女孩

247
00:10:30,350 --> 00:10:31,900
所有蘋果。

248
00:10:31,900 --> 00:10:37,566
我從幾年前挖了這個文件，ilock.c，只是為了

249
00:10:37,566 --> 00:10:40,930
種更具體，更複雜一些更基本的C

250
00:10:40,930 --> 00:10:42,350
我們一直都在寫程序。

251
00:10:42,350 --> 00:10:44,360
於是，我打開了這個文件，ilock.c。

252
00:10:44,360 --> 00:10:46,830
這是今天的講座頁。

253
00:10:46,830 --> 00:10:49,470
在左側，你會看到一個長長的清單功能。

254
00:10:49,470 --> 00:10:51,860
因此，研究員，這是誰寫的寫了很多的功能，

255
00:10:51,860 --> 00:10:53,290
以上只是主。

256
00:10:53,290 --> 00:10:55,490
在這裡，他用一大堆的庫。

257
00:10:55,490 --> 00:11:00,450
如果我們開始滾動，這實際上是非常

258
00:11:00,450 --> 00:11:04,670
第一，我認為，原來的iPhone破解。

259
00:11:04,670 --> 00:11:08,000
當你想原來的iPhone越獄，這意味著untether

260
00:11:08,000 --> 00:11:11,800
從AT＆T和實際安裝特殊的軟件就可以了，做的事情

261
00:11:11,800 --> 00:11:13,510
蘋果沒有人做 - 

262
00:11:13,510 --> 00:11:17,020
好了，有人花時間來弄清楚他們是如何利用

263
00:11:17,020 --> 00:11:20,880
軟件缺陷，錯誤，錯誤，在蘋果公司的軟件。

264
00:11:20,880 --> 00:11:22,650
從而誕生了ilock.c。

265
00:11:22,650 --> 00:11:26,670
如果你的計算機上編譯它和它的iPhone上安裝

266
00:11:26,670 --> 00:11:29,810
說，通過USB電纜連接到您的計算機，這將給你

267
00:11:29,810 --> 00:11:33,360
行政或root用戶權限在您的iPhone，讓你做很多

268
00:11:33,360 --> 00:11:34,170
任何你想要的。

269
00:11:34,170 --> 00:11:36,740
>> 所以這個迷人的貓捉老鼠的遊戲和蘋果之間的

270
00:11:36,740 --> 00:11:39,920
特別是他們在世界各地的很多企業一樣，試圖鎖定

271
00:11:39,920 --> 00:11:43,220
他們的東西，所以，你只能用它做什麼，他們打算。

272
00:11:43,220 --> 00:11:46,620
但由於這樣的人，他們的低層次的認識

273
00:11:46,620 --> 00:11:50,580
的細節，並在這種情況下，C編程和熟悉的結構的特定

274
00:11:50,580 --> 00:11:54,630
我們已經開始玩，你能夠真正利用

275
00:11:54,630 --> 00:11:59,050
硬件的方式，您認為合適的，而不一定是一些企業實體。

276
00:11:59,050 --> 00:12:01,360
因此，舉例來說，我不知道這是做。

277
00:12:01,360 --> 00:12:03,220
但是，GetVersion聽起來很簡單。

278
00:12:03,220 --> 00:12:05,480
看起來這是一個函數，這個人寫的。

279
00:12:05,480 --> 00:12:09,240
以某種整數作為參數，不返回任何東西，但

280
00:12:09,240 --> 00:12:13,080
一個for循環和循環條件，如果條件下，如果

281
00:12:13,080 --> 00:12:15,620
突破，並以某種方式涉及到的版本號。

282
00:12:15,620 --> 00:12:16,700
如果我們向下滾動 - 

283
00:12:16,700 --> 00:12:19,570
儘管很多這些關鍵字將是新的，並有一個

284
00:12:19,570 --> 00:12:22,590
一大堆的功能在這裡，我們從來沒有見過，可能不會看到超過

285
00:12:22,590 --> 00:12:23,830
本學期的過程中 - 

286
00:12:23,830 --> 00:12:27,150
在一天結束的時候，它遵循相同的規則和邏輯，我們已經

287
00:12:27,150 --> 00:12:28,760
玩迄今。

288
00:12:28,760 --> 00:12:34,220
因此，這是破解你的iPhone 4S或3S或很快5S，這幾天太舊，

289
00:12:34,220 --> 00:12:37,320
但要知道，這一切都非常來源於這個世界，我們已經看到

290
00:12:37,320 --> 00:12:38,430
潛入。

291
00:12:38,430 --> 00:12:41,900
>> 因此，讓我們來看看一個更簡單一點的例子。

292
00:12:41,900 --> 00:12:46,100
這其中，只是為了獲得回暖的一些語法，也有一些其他的數據

293
00:12:46,100 --> 00:12:49,240
類型，我們已經談到了，但還沒有真正出現在C.因此，這是一個

294
00:12:49,240 --> 00:12:51,680
文件名為positive1.c。

295
00:12:51,680 --> 00:12:55,120
每在上面的評論，這只是要求用戶提供一個

296
00:12:55,120 --> 00:12:55,960
正數。

297
00:12:55,960 --> 00:12:59,530
所以這是一個例子，一個do-whil​​e循環，這是很好的用戶交互

298
00:12:59,530 --> 00:13:01,980
程序，你需要告訴用戶做一些事情。

299
00:13:01,980 --> 00:13:05,190
，如果他們不配合，你罵他們，或拒絕他們的意見。

300
00:13:05,190 --> 00:13:11,610
典型的例子，我該怎麼辦第19行到24這麼久的用戶

301
00:13:11,610 --> 00:13:14,310
沒有給我一個正數。

302
00:13:14,310 --> 00:13:20,400
現在，這個細節在這裡的​​第18行，為什麼我宣布這整個Ñ以上

303
00:13:20,400 --> 00:13:24,490
循環結構，而不是右線22我

304
00:13:24,490 --> 00:13:26,880
真正關心得到n？

305
00:13:26,880 --> 00:13:27,330
是嗎？

306
00:13:27,330 --> 00:13:27,780
[聽不清]

307
00:13:27,780 --> 00:13:29,040
>> DAVID J.馬蘭：是啊，所以這個問題的範圍。

308
00:13:29,040 --> 00:13:30,850
在外行人的術語，什麼範圍是指什麼？

309
00:13:34,690 --> 00:13:36,610
是嗎？

310
00:13:36,610 --> 00:13:37,860
[聽不清]

311
00:13:40,040 --> 00:13:41,105
DAVID J.馬蘭：你能不能說大聲一點好嗎？

312
00:13:41,105 --> 00:13:43,450
主講人1：在這裡你可以訪問一個特定的變量。

313
00:13:43,450 --> 00:13:45,170
DAVID J.馬蘭：完美的。

314
00:13:45,170 --> 00:13:47,360
在這裡你可以訪問一個特定的變量。

315
00:13:47,360 --> 00:13:50,400
而且一般的經驗法則迄今為止一直認為，一些人的範圍

316
00:13:50,400 --> 00:13:55,860
變量的定義是，你已經看到最近的花括號。

317
00:13:55,860 --> 00:14:02,010
因此，在這種情況下，如果我犯了個錯誤n在第22行聲明，

318
00:14:02,010 --> 00:14:03,010
該行會的工作。

319
00:14:03,010 --> 00:14:10,990
我會得到一個int，我希望把它變成第22行中的變量n。

320
00:14:10,990 --> 00:14:16,900
但是，這行代碼將不知道我說的是什麼呢？

321
00:14:16,900 --> 00:14:22,650
所以，25，事實證明，24為好，因為在這種情況下，它不屬於

322
00:14:22,650 --> 00:14:23,610
大括號。

323
00:14:23,610 --> 00:14:27,280
因此，只要一點點的滋擾，但很容易解決，只需聲明

324
00:14:27,280 --> 00:14:30,140
變量以外的函數本身。

325
00:14:30,140 --> 00:14:32,600
>> 現在，我們可以看到以後的今天，你可以走了一步。

326
00:14:32,600 --> 00:14:34,860
你甚至可以得到一個有點懶惰 - 

327
00:14:34,860 --> 00:14:37,320
，這是不被推薦的，在一般情況 - 

328
00:14:37,320 --> 00:14:42,260
但你甚至可以偷懶，把一個全局變量，可以這麼說，不

329
00:14:42,260 --> 00:14:46,670
內的一個函數，而不是一個循環的內部，但在文件本身，外

330
00:14:46,670 --> 00:14:49,600
所有的功能，你已經寫了，因為我在這裡的第15行。

331
00:14:49,600 --> 00:14:51,160
但是，這一般是不可取的。

332
00:14:51,160 --> 00:14:55,680
但是，認識到這一點是有時其他問題的解決方案，我們將

333
00:14:55,680 --> 00:14:56,620
最終看到的。

334
00:14:56,620 --> 00:14:58,130
因此，就目前而言，我們將保持這樣的。

335
00:14:58,130 --> 00:15:01,030
但是，讓我們看看我們是否能改寫這只是開始表達自己在一所房子裡

336
00:15:01,030 --> 00:15:01,990
略有不同。

337
00:15:01,990 --> 00:15:05,330
>> 因此這個方案，僅僅是明確的，是陽性。

338
00:15:05,330 --> 00:15:11,810
讓我繼續在這裡，在我的終端窗口陽性，回車。

339
00:15:11,810 --> 00:15:12,740
編譯，沒問題。

340
00:15:12,740 --> 00:15:14,910
我要去，運行positive1，按下回車鍵。

341
00:15:14,910 --> 00:15:16,820
我要求你給我一個正整數。

342
00:15:16,820 --> 00:15:18,260
我會說：-1。

343
00:15:18,260 --> 00:15:18,910
沒有工作。

344
00:15:18,910 --> 00:15:22,150
0，99，這似乎是工作。

345
00:15:22,150 --> 00:15:23,570
也許不是最嚴格的測試。

346
00:15:23,570 --> 00:15:26,480
但至少這是一個不錯的完整性檢查，我們正在正確的軌道上。

347
00:15:26,480 --> 00:15:29,240
所以，現在讓我繼續前進，打開這兩個版本。

348
00:15:29,240 --> 00:15:32,500
有什麼不同了嗎？

349
00:15:32,500 --> 00:15:35,140
它實現了同樣的事情。

350
00:15:35,140 --> 00:15:40,660
但是，什麼是跳出為明顯不同時間？

351
00:15:40,660 --> 00:15:42,560
是啊，所以這個布爾綠色。

352
00:15:42,560 --> 00:15:45,980
gedit有綠色高亮顯示該關鍵字被稱為布爾，

353
00:15:45,980 --> 00:15:47,000
這是一個數據類型。

354
00:15:47,000 --> 00:15:51,080
它不內置於所有版本的C.你需要包含一個

355
00:15:51,080 --> 00:15:52,010
具體的庫。

356
00:15:52,010 --> 00:15:54,770
在我們的例子中，我的CS50庫，使我們

357
00:15:54,770 --> 00:15:56,460
有機會為bool。

358
00:15:56,460 --> 00:15:59,810
但在第18行，我們似乎有一個布爾值，這裡所謂的感謝。

359
00:15:59,810 --> 00:16:01,040
所以，我可以把這種現象稱之為什麼。

360
00:16:01,040 --> 00:16:04,500
但我把它叫做感激只是一種傳達一些語義上的意義。

361
00:16:04,500 --> 00:16:07,930
因此，最初的第18行，我顯然不是感謝，因為

362
00:16:07,930 --> 00:16:12,150
布爾值，感謝在第18行初始化為false。

363
00:16:12,150 --> 00:16:16,890
然後，它似乎是我在這裡做了21行〜23是我剛剛

364
00:16:16,890 --> 00:16:18,610
種重寫我的邏輯。

365
00:16:18,610 --> 00:16:21,020
所以沒有功能不同的。

366
00:16:21,020 --> 00:16:26,940
但在第22行，我現在檢查，如果int用戶提供了大於

367
00:16:26,940 --> 00:16:31,120
0，那麼我只需更改感謝真正的價值。

368
00:16:31,120 --> 00:16:32,290
我為什麼這樣做呢？

369
00:16:32,290 --> 00:16:35,600
因為在第25行，很顯然，我要檢查的條件。

370
00:16:35,600 --> 00:16:39,380
做這個循環，同時感謝是假的。

371
00:16:39,380 --> 00:16:43,610
>> 因此，我建議這是一個版本的替代品，因為它至少一個

372
00:16:43,610 --> 00:16:45,130
更直觀一點，也許吧。

373
00:16:45,130 --> 00:16:46,900
這是一個有點植根於英語。

374
00:16:46,900 --> 00:16:51,710
因此，請執行以下操作，而你不感謝，同時感謝是假的。

375
00:16:51,710 --> 00:16:55,890
而這個時候，我顯然不關心記住用戶輸入的是什麼

376
00:16:55,890 --> 00:16:57,730
因為通知中沒有任何變量n。

377
00:16:57,730 --> 00:16:58,650
因此，實際上，I  - 

378
00:16:58,650 --> 00:17:00,080
一個善意的謊言。

379
00:17:00,080 --> 00:17:02,770
在功能上，該方案是一個有點不同的，一旦我們得到的底部

380
00:17:02,770 --> 00:17:04,819
它，因為我不記得n是什麼。

381
00:17:04,819 --> 00:17:09,579
但我想在這裡展示我們已經看到過，即使調用getInt和

382
00:17:09,579 --> 00:17:13,920
正在使用的右手側的一個等號的GetString迄今，使得

383
00:17:13,920 --> 00:17:17,160
我們記住它們的價值，從技術上講，這不是絕對必要的。

384
00:17:17,160 --> 00:17:20,950
如果由於某種原因，你只是不小心保存的價值，你只是想

385
00:17:20,950 --> 00:17:25,710
檢查該值，請注意，我們可以簡單的寫調用getInt開放

386
00:17:25,710 --> 00:17:27,000
括號，關閉括號。

387
00:17:27,000 --> 00:17:30,460
該函數會返回一個值，因為我們一直在說。

388
00:17:30,460 --> 00:17:32,010
這將會給你一個int。

389
00:17:32,010 --> 00:17:36,450
所以，如果你在精神上認為這種情況發生，當我輸入99，調用getInt

390
00:17:36,450 --> 00:17:38,160
返回數字99。

391
00:17:38,160 --> 00:17:41,330
因此，從理論上講，這是因為雖然我的代碼，其實這。

392
00:17:41,330 --> 00:17:45,880
因此，如果99的確是大於0，然後感謝變為真。

393
00:17:45,880 --> 00:17:50,420
第25行實現哦，我們正在做的，因為我現在感謝。

394
00:17:50,420 --> 00:17:54,590
而在第26行，我們簡單地說，感謝為正整數，不管它

395
00:17:54,590 --> 00:17:55,710
碰巧。

396
00:17:55,710 --> 00:17:58,900
>> 現在，讓我們在這裡做輕微的語法糖，可以這麼說。

397
00:17:58,900 --> 00:18:02,990
讓我們來看看，如果我們可以清理這條線，這第三個和最後的25方差

398
00:18:02,990 --> 00:18:04,640
在positive3。

399
00:18:04,640 --> 00:18:08,250
因此，注意到現在唯一的區別是哪一行代碼？

400
00:18:11,930 --> 00:18:13,260
是啊，所以25。

401
00:18:13,260 --> 00:18:15,520
我們還沒有真正看到這一招只是還沒有。

402
00:18:15,520 --> 00:18:19,510
但是，我們也看到週一的感嘆號，這表示什麼？

403
00:18:19,510 --> 00:18:20,970
因此，沒有或否定。

404
00:18:20,970 --> 00:18:23,460
因此，需要一個布爾值，，並翻轉它的價值。

405
00:18:23,460 --> 00:18:24,390
真亦假。

406
00:18:24,390 --> 00:18:25,500
假變為真。

407
00:18:25,500 --> 00:18:28,910
所以，我建議，即使是一點點的一種方式，更直觀

408
00:18:28,910 --> 00:18:32,200
編寫的代碼，因為我仍然會初始化為false感謝。

409
00:18:32,200 --> 00:18:33,530
我還是做到以下幾點。

410
00:18:33,530 --> 00:18:35,700
我感謝設置為true，在時機成熟時。

411
00:18:35,700 --> 00:18:40,690
但現在你可以真的只是翻譯代碼口頭左到右，

412
00:18:40,690 --> 00:18:42,550
同時感謝。

413
00:18:42,550 --> 00:18:46,170
由於爆炸，或驚嘆號，表示不的概念，因此，雖然

414
00:18:46,170 --> 00:18:47,010
不心存感激。

415
00:18:47,010 --> 00:18:49,740
>> 所以，再一次，我們沒有引入任何新的概念本身。

416
00:18:49,740 --> 00:18:53,230
我們已經討論了布爾值，當我們從頭打了。

417
00:18:53,230 --> 00:18:55,690
但現在認識到，我們就可以開始寫我們的代碼

418
00:18:55,690 --> 00:18:56,550
許多不同的方式。

419
00:18:56,550 --> 00:19:00,010
因此，特別是在pset1移動，如果你有幾分努力找出的方式來

420
00:19:00,010 --> 00:19:03,400
請編寫一些程序，你很幸運，因為有將是任何

421
00:19:03,400 --> 00:19:05,780
的解決方案，您可以發生在數。

422
00:19:05,780 --> 00:19:09,850
舉例來說，即使是最簡單的程序，這僅僅是3。

423
00:19:09,850 --> 00:19:10,180
好的。

424
00:19:10,180 --> 00:19:13,860
現在記得上週一，我們留在這有返回值的注意。

425
00:19:13,860 --> 00:19:18,280
因此，對於第一次，我們寫了一個程序，不只是有主，

426
00:19:18,280 --> 00:19:22,240
它也有它自己的自定義函數，我寫在這裡。

427
00:19:22,240 --> 00:19:26,640
因此，在31〜34行，我已經實現了一個多維數據集函數。

428
00:19:26,640 --> 00:19:27,800
這並不複雜。

429
00:19:27,800 --> 00:19:29,830
這只是一個次次，在這種情況下。

430
00:19:29,830 --> 00:19:34,920
但重要的是它是我輸入的形式

431
00:19:34,920 --> 00:19:38,910
我回輸出的形式的時候，一個次。

432
00:19:38,910 --> 00:19:43,940
>> 所以，現在我有能力，就像我用printf單獨使用，調用

433
00:19:43,940 --> 00:19:47,120
多維數據集函數調用這個函數。

434
00:19:47,120 --> 00:19:49,470
和多維數據集的功能需要一定的投入。

435
00:19:49,470 --> 00:19:52,030
和多維數據集函數返回一些輸出。

436
00:19:52,030 --> 00:19:56,660
因此，相比之下，輸出只是做了一些事情。

437
00:19:56,660 --> 00:19:59,490
它沒有返回任何東西，我們關心的 - 即使作為一個

438
00:19:59,490 --> 00:20:00,820
一旁，它返回一個值。

439
00:20:00,820 --> 00:20:02,650
您通常會忽略它。

440
00:20:02,650 --> 00:20:04,000
的printf只是做了一些事情。

441
00:20:04,000 --> 00:20:06,220
它有打印到屏幕上的副作用。

442
00:20:06,220 --> 00:20:09,480
反差，在這裡，我們有多維數據集的功能，這

443
00:20:09,480 --> 00:20:11,400
實際上返回的東西。

444
00:20:11,400 --> 00:20:12,960
>> 因此，這是一般 - 

445
00:20:12,960 --> 00:20:15,260
對於那些熟悉，這是一個非常簡單的想法。

446
00:20:15,260 --> 00:20:18,460
但是，對於那些不太熟悉這個想法傳遞輸入和

447
00:20:18,460 --> 00:20:21,700
背面輸出，讓我們嘗試只是超級簡單的東西。

448
00:20:21,700 --> 00:20:25,180
是任何人都舒服了舞台上簡單嗎？

449
00:20:25,180 --> 00:20:27,460
你必須是舒適的與你的相機，以及。

450
00:20:27,460 --> 00:20:27,640
是啊。

451
00:20:27,640 --> 00:20:28,610
好了，你叫什麼名字？

452
00:20:28,610 --> 00:20:29,020
KEN：肯。

453
00:20:29,020 --> 00:20:29,420
DAVID J.馬蘭：肯。

454
00:20:29,420 --> 00:20:29,810
所有權利，肯。

455
00:20:29,810 --> 00:20:31,060
上來吧。

456
00:20:31,060 --> 00:20:34,660
所以，肯將是各種各樣的功能，在這裡。

457
00:20:34,660 --> 00:20:35,760
讓我們繼續做到這一點。

458
00:20:35,760 --> 00:20:38,790
讓我們一點點花哨。

459
00:20:38,790 --> 00:20:39,770
認識你很高興。

460
00:20:39,770 --> 00:20:41,010
歡迎來到舞台中央。

461
00:20:41,010 --> 00:20:41,980
好的。

462
00:20:41,980 --> 00:20:45,590
讓打這個按鈕，在這裡。

463
00:20:45,590 --> 00:20:46,420
好的。

464
00:20:46,420 --> 00:20:49,490
所以，在這裡你有一個現代化的黑板上。

465
00:20:49,490 --> 00:20:53,050
我的主要功能是，例如。

466
00:20:53,050 --> 00:20:55,990
我沒有一台iPad拿在手中。

467
00:20:55,990 --> 00:20:59,000
我真的不記得怎麼樣 - 好了，其實，不能說。

468
00:20:59,000 --> 00:21:02,200
我真的沒有很好的筆跡。

469
00:21:02,200 --> 00:21:05,260
所以，我希望你能在屏幕上打印的東西對我來說。

470
00:21:05,260 --> 00:21:07,470
>> 所以我的主要程序。

471
00:21:07,470 --> 00:21:15,060
我要你說，這寫在我的雞從頭開始，

472
00:21:15,060 --> 00:21:16,600
然後將你的輸入。

473
00:21:16,600 --> 00:21:20,000
因此，儘管這項工作是愚蠢的，函數的概念，並調用

474
00:21:20,000 --> 00:21:22,260
功能，並返回一個函數真的歸結到這。

475
00:21:22,260 --> 00:21:23,120
我主要的。

476
00:21:23,120 --> 00:21:26,270
我剛才寫在屏幕上輸出（“東西”）。

477
00:21:26,270 --> 00:21:27,470
我運行這個程序。

478
00:21:27,470 --> 00:21:30,900
如printf被調用，它需要一個參數 - 或一個參數，

479
00:21:30,900 --> 00:21:31,660
有時 - 

480
00:21:31,660 --> 00:21:32,780
雙引號之間。

481
00:21:32,780 --> 00:21:33,960
這裡有這樣的說法。

482
00:21:33,960 --> 00:21:35,740
我把它傳遞給肯。

483
00:21:35,740 --> 00:21:39,390
現在，他寫了一些數年前，顯然是一個黑盒子

484
00:21:39,390 --> 00:21:41,070
只有知道如何打印在屏幕上的東西。

485
00:21:41,070 --> 00:21:42,320
>> 所以，執行。

486
00:21:48,842 --> 00:21:49,900
這是不壞的。

487
00:21:49,900 --> 00:21:50,890
所以，很不錯。

488
00:21:50,890 --> 00:21:52,900
所以，現在肯執行。

489
00:21:52,900 --> 00:21:55,810
他遞給我任何東西嗎？

490
00:21:55,810 --> 00:21:57,240
因此，到目前為止，我們已經看到的。

491
00:21:57,240 --> 00:21:59,230
同樣，printf並返回一個數字。

492
00:21:59,230 --> 00:22:01,640
但是，我們要忽略的是現在，因為我們從來沒有用過它。

493
00:22:01,640 --> 00:22:03,400
所以這是它為肯。

494
00:22:03,400 --> 00:22:06,650
因此，現在主要來執行 - 

495
00:22:06,650 --> 00:22:09,630
主要接管程序的控制，因為這行代碼，

496
00:22:09,630 --> 00:22:11,010
printf中進行執行。

497
00:22:11,010 --> 00:22:13,890
我們去了解我們的方式執行的任何其他線路有。

498
00:22:13,890 --> 00:22:14,130
>> 好的。

499
00:22:14,130 --> 00:22:17,080
現在讓我們嘗試一個稍微不同的例子。

500
00:22:17,080 --> 00:22:22,430
這一次，在這裡，讓我們先來清除屏幕。

501
00:22:22,430 --> 00:22:24,670
而這個時候，我們會做的魔方功能。

502
00:22:24,670 --> 00:22:27,350
但是這一次，我期望的輸出值。

503
00:22:27,350 --> 00:22:28,630
因此，讓我們繼續前進，並做到這一點。

504
00:22:28,630 --> 00:22:35,680
所以，現在我有一個行代碼，說X =立方體（X）。

505
00:22:35,680 --> 00:22:36,930
因此，實際上let's  - 

506
00:22:41,450 --> 00:22:43,940
行的代碼，召回，看起來是這樣的。

507
00:22:43,940 --> 00:22:45,960
X =立方體（X）。

508
00:22:45,960 --> 00:22:48,100
所以，這是怎麼去上班？

509
00:22:48,100 --> 00:22:50,820
因此，讓我們繼續前進，並給你一個白色的屏幕。

510
00:22:50,820 --> 00:22:55,000
我要現在寫下來的x的值，在這一刻

511
00:22:55,000 --> 00:23:01,080
時間發生，讓我們說，2，保持它的簡單。

512
00:23:01,080 --> 00:23:04,890
因此，我已寫在一張紙的價值2，

513
00:23:04,890 --> 00:23:06,100
這是我的x值。

514
00:23:06,100 --> 00:23:08,250
我把它肯。

515
00:23:08,250 --> 00:23:09,200
KEN：我只寫答案是什麼？

516
00:23:09,200 --> 00:23:12,660
DAVID J.馬蘭：是啊，讓我們只寫答案。

517
00:23:12,660 --> 00:23:13,030
好吧。

518
00:23:13,030 --> 00:23:16,280
現在他已經回到我的東西。

519
00:23:16,280 --> 00:23:17,560
所以 - 

520
00:23:17,560 --> 00:23:18,170
完美的。

521
00:23:18,170 --> 00:23:18,840
尼斯SEGUE。

522
00:23:18,840 --> 00:23:21,970
>> 所以，現在他遞給我回值8，在這種情況下。

523
00:23:21,970 --> 00:23:23,220
我該怎麼辦呢？

524
00:23:23,220 --> 00:23:26,130
嗯，其實，讓我們來看看。

525
00:23:26,130 --> 00:23:26,640
得到這個權利。

526
00:23:26,640 --> 00:23:27,880
我會用它做什麼呢？

527
00:23:27,880 --> 00:23:31,900
現在，我將這個值和實際存儲在這些

528
00:23:31,900 --> 00:23:33,400
在存儲器中的相同比特。

529
00:23:33,400 --> 00:23:35,030
但是，請注意，我是那種掙扎在這裡。

530
00:23:35,030 --> 00:23:38,280
我有點困惑，因為我在哪裡寫x的值嗎？

531
00:23:38,280 --> 00:23:41,840
因為我剛剛做的是需要親自肯一張紙

532
00:23:41,840 --> 00:23:44,400
的值是2，這為x。

533
00:23:44,400 --> 00:23:46,300
事實上，這恰恰會發生什麼。

534
00:23:46,300 --> 00:23:50,100
因此，原來，當你調用一個函數，並傳遞參數

535
00:23:50,100 --> 00:23:54,130
喜歡的“Hello World”，或者你傳遞一個參數，如2，一般，你

536
00:23:54,130 --> 00:23:56,720
通過在副本這樣的說法。

537
00:23:56,720 --> 00:24:01,020
所以，正如我寫下的2號這裡，並把它交給肯;

538
00:24:01,020 --> 00:24:04,760
意思是，我仍然有一份價值2的地方。

539
00:24:04,760 --> 00:24:08,140
因為事實上，現在我已經得到了值8，我需要回去

540
00:24:08,140 --> 00:24:12,010
RAM寫下我曾經有過的數字2。

541
00:24:12,010 --> 00:24:15,720
>> 所以，直觀地記住這個概念在字面上通過

542
00:24:15,720 --> 00:24:16,730
值的副本。

543
00:24:16,730 --> 00:24:19,570
肯做他的事，交給我的東西 - 在這種情況下，

544
00:24:19,570 --> 00:24:20,820
這樣的值8。

545
00:24:20,820 --> 00:24:22,660
然後，我與價值的東西，如果我

546
00:24:22,660 --> 00:24:24,880
要保持它的周圍。

547
00:24:24,880 --> 00:24:29,470
因此，所有這一切都將是所有太熟悉了不久。

548
00:24:29,470 --> 00:24:33,082
非常感謝你在這裡演示，肯。

549
00:24:33,082 --> 00:24:34,820
好的。

550
00:24:34,820 --> 00:24:36,720
非常好。

551
00:24:36,720 --> 00:24:40,610
因此，讓我們來看看如何，最終涉及到的一些功能

552
00:24:40,610 --> 00:24:42,270
調用，我們一直在這裡做什麼。

553
00:24:42,270 --> 00:24:47,610
因此，讓我繼續前進，把我們帶回了魔方的例子在這裡。

554
00:24:47,610 --> 00:24:53,080
注意到，如果我們要真正開始採取進一步，我們將

555
00:24:53,080 --> 00:24:57,050
必須注意的一個事實，即數x被傳遞

556
00:24:57,050 --> 00:25:01,390
這裡實際上被傳遞到函數是不同的。

557
00:25:01,390 --> 00:25:03,940
所以，再一次，通過複製將變得相當

558
00:25:03,940 --> 00:25:05,620
鍺在短短的時刻。

559
00:25:05,620 --> 00:25:09,320
>> 所以，讓我們來看看在一些不相當的工作。

560
00:25:09,320 --> 00:25:11,790
我會繼續前進，打開第三個馬車例如，

561
00:25:11,790 --> 00:25:13,560
是有缺陷的性質。

562
00:25:13,560 --> 00:25:18,070
它被稱為buggy3，和它實現了一個交換的功能。

563
00:25:18,070 --> 00:25:23,500
所以，在這裡，我們有一個主函數，x和y的任意初始化為

564
00:25:23,500 --> 00:25:24,720
分別為1和2，。

565
00:25:24,720 --> 00:25:27,590
我們可以使用調用getInt，但我們只需要一個簡單的練習。

566
00:25:27,590 --> 00:25:29,680
因此，它是硬編碼為1和2。

567
00:25:29,680 --> 00:25:35,330
在第21行和22行，我們似乎打印出x和y，每行一個。

568
00:25:35,330 --> 00:25:39,620
然後，在第23行，我要求我交換這些值，點，點，點。

569
00:25:39,620 --> 00:25:43,030
顯然，我在第24行調用一個函數，稱為交換

570
00:25:43,030 --> 00:25:44,000
，它有兩個參數。

571
00:25:44,000 --> 00:25:46,430
這是完全合法的，採取兩個參數的函數。

572
00:25:46,430 --> 00:25:48,220
我們已經看到輸出已經做到這一點了。

573
00:25:48,220 --> 00:25:50,370
所以交換顯然x和y。

574
00:25:50,370 --> 00:25:53,010
正如它的名字所暗示的，我希望這是怎麼回事

575
00:25:53,010 --> 00:25:54,320
交換這兩個值。

576
00:25:54,320 --> 00:25:57,560
因此，我要求在第25行，交換。

577
00:25:57,560 --> 00:26:01,570
我轉載的假設下，x和y

578
00:26:01,570 --> 00:26:02,830
我的確被換。

579
00:26:02,830 --> 00:26:04,370
但是，如果我運行這個程序 - 

580
00:26:04,370 --> 00:26:06,060
讓我打開一個終端窗口。

581
00:26:06,060 --> 00:26:07,750
讓我做buggy3。

582
00:26:07,750 --> 00:26:09,970
正如它的名字所暗示的，這是沒有好下場的。

583
00:26:09,970 --> 00:26:14,690
因為當我按下Enter鍵，注意x是1。

584
00:26:14,690 --> 00:26:15,720
y為2。

585
00:26:15,720 --> 00:26:19,160
但在程序結束時，他們仍，其實，是一樣的。

586
00:26:19,160 --> 00:26:22,760
>> 因此，根據示範與肯，剛才到底發生了什麼？

587
00:26:22,760 --> 00:26:24,660
好吧，讓我們深入到這個交換功能。

588
00:26:24,660 --> 00:26:25,800
它的超級短。

589
00:26:25,800 --> 00:26:28,020
這是只有幾行代碼長。

590
00:26:28,020 --> 00:26:32,810
但是，什麼是最根本的問題的基礎上簡單的故事告訴

591
00:26:32,810 --> 00:26:34,270
在這裡肯嗎？

592
00:26:34,270 --> 00:26:36,115
交換為什麼壞了？

593
00:26:36,115 --> 00:26:37,365
[聽不清]

594
00:26:39,840 --> 00:26:40,460
沒錯。

595
00:26:40,460 --> 00:26:43,610
因此，我們要存儲的副本，而不是變量本身。

596
00:26:43,610 --> 00:26:46,810
換句話說，交換顯然有兩個參數，一個int。

597
00:26:46,810 --> 00:26:49,370
它的任意稱為A和B。

598
00:26:49,370 --> 00:26:54,430
這裡，我已經通過在x和y，分別是1和2。

599
00:26:54,430 --> 00:26:56,580
但我不是真的通過在x。

600
00:26:56,580 --> 00:26:58,410
我不是真的在y傳遞。

601
00:26:58,410 --> 00:27:01,230
我是通過x和y的副本的副本。

602
00:27:01,230 --> 00:27:05,180
這就像幾乎就像交換的值複製和粘貼

603
00:27:05,180 --> 00:27:07,440
你希望它是實際操作。

604
00:27:07,440 --> 00:27:11,970
所以，如果是這樣的話，當我的程序，開始執行

605
00:27:11,970 --> 00:27:14,140
線35，然後36  - 

606
00:27:14,140 --> 00:27:17,740
當我到37行，在這一點上的故事，是什麼值呢？

607
00:27:20,740 --> 00:27:24,850
在這一點上的故事，37號線，在這一點上的價值是什麼？

608
00:27:24,850 --> 00:27:25,980
因此，它應該是1。

609
00:27:25,980 --> 00:27:26,170
對嗎？

610
00:27:26,170 --> 00:27:29,100
因為x的第一個參數中傳遞。

611
00:27:29,100 --> 00:27:33,150
而這個函數只是任意調用它的第一個參數，一個。

612
00:27:33,150 --> 00:27:35,130
同樣，第二個參數為y。

613
00:27:35,130 --> 00:27:37,930
它只是隨意調用的第二個參數b。

614
00:27:37,930 --> 00:27:40,510
>> 現在這種兩分法其實是相當簡單的解釋。

615
00:27:40,510 --> 00:27:40,880
想想吧。

616
00:27:40,880 --> 00:27:42,980
我們沒有見過的人誰寫輸出。

617
00:27:42,980 --> 00:27:49,880
因此，毫無疑問，他或她不知道30年後，我們的變量將

618
00:27:49,880 --> 00:27:50,710
被調用。

619
00:27:50,710 --> 00:27:55,110
所以，必須有區分你調用中的變量

620
00:27:55,110 --> 00:27:59,960
功能，你寫的，你在你的函數調用變量

621
00:27:59,960 --> 00:28:01,770
打電話或使用。

622
00:28:01,770 --> 00:28:05,120
所以，換句話說，我寫了我的變量x和y。

623
00:28:05,120 --> 00:28:08,060
但是，如果別人已經寫了交換功能，他或她肯定

624
00:28:08,060 --> 00:28:10,480
不知道我的變量來調用。

625
00:28:10,480 --> 00:28:13,850
所以認識到，這就是為什麼你有這種二元性的名稱。

626
00:28:13,850 --> 00:28:16,800
從技術上講，我可以做到這一點巧合。

627
00:28:16,800 --> 00:28:19,750
但他們仍然會通過為副本。

628
00:28:19,750 --> 00:28:22,940
這僅僅是一個純粹的巧合美觀，如果那個人是誰寫的

629
00:28:22,940 --> 00:28:25,590
交換使用相同的名稱。

630
00:28:25,590 --> 00:28:25,930
>> 好的。

631
00:28:25,930 --> 00:28:29,010
所以在這一點上故事中的第37行，一個是1。

632
00:28:29,010 --> 00:28:30,410
b是2。

633
00:28:30,410 --> 00:28:32,040
現在我進行交換。

634
00:28:32,040 --> 00:28:34,730
首先，讓我真正做到這一點簡單得多。

635
00:28:34,730 --> 00:28:36,500
我不知道這三行代碼做什麼。

636
00:28:36,500 --> 00:28:37,370
讓我做到這一點。

637
00:28:37,370 --> 00:28:38,850
b得到。

638
00:28:38,850 --> 00:28:40,170
一個得到b。

639
00:28:40,170 --> 00:28:41,450
完成。

640
00:28:41,450 --> 00:28:43,540
為什麼是這個破碎的，邏輯上嗎？

641
00:28:46,980 --> 00:28:48,590
這是一種直觀的東西，對不對？

642
00:28:48,590 --> 00:28:50,640
因此，一個變成了B。

643
00:28:50,640 --> 00:28:52,450
B變成A。

644
00:28:52,450 --> 00:28:55,410
但問題是，盡快執行第37行，有什麼

645
00:28:55,410 --> 00:28:58,170
a和b的值？

646
00:28:58,170 --> 00:28:59,070
相同的是，1。

647
00:28:59,070 --> 00:29:03,460
因為你打一頓，可以這麼說，你已經改變了b為一個。

648
00:29:03,460 --> 00:29:06,000
所以，第37行執行，這是偉大的。

649
00:29:06,000 --> 00:29:09,940
你現在有此功能的號碼1內部的兩個副本。

650
00:29:09,940 --> 00:29:14,720
那麼，當你說在第38行，得到b，好了，你種擰緊。

651
00:29:14,720 --> 00:29:17,370
因為你只是分配1比1。

652
00:29:17,370 --> 00:29:20,400
你失去了你關心的價值。

653
00:29:20,400 --> 00:29:22,910
>> 因此，在原始版本，請注意，我就是這樣做的。

654
00:29:22,910 --> 00:29:26,620
我不是有三分之一的代碼看起來是這樣的。

655
00:29:26,620 --> 00:29:29,910
我聲明了一個臨時變量 -  tmp是一個很常見的名字

656
00:29:29,910 --> 00:29:31,240
一個臨時變量。

657
00:29:31,240 --> 00:29:34,280
它是一個int，因為它符合我要的副本。

658
00:29:34,280 --> 00:29:39,720
存儲副本的tmp目錄內的。因此，一旦線路37條的執行，

659
00:29:39,720 --> 00:29:41,390
a的值是 - 

660
00:29:41,390 --> 00:29:42,970
快速完整性檢查 - 

661
00:29:42,970 --> 00:29:43,460
1。

662
00:29:43,460 --> 00:29:45,780
b的值是2。

663
00:29:45,780 --> 00:29:48,470
TMP的價值也是1。

664
00:29:48,470 --> 00:29:51,470
所以，現在我執行第38行。

665
00:29:51,470 --> 00:29:57,180
因此，一旦執行第38行，一個需要的b的值。

666
00:29:57,180 --> 00:29:58,510
和B是2。

667
00:29:58,510 --> 00:30:00,500
因此，一個現在是2。

668
00:30:00,500 --> 00:30:03,110
所以在這一點上的故事，一個是2，b為2，

669
00:30:03,110 --> 00:30:05,130
tmp是1。

670
00:30:05,130 --> 00:30:09,330
所以，現在從邏輯上講，我們只是撲通TMP到b的值。

671
00:30:09,330 --> 00:30:10,690
我們就大功告成了。

672
00:30:10,690 --> 00:30:12,170
>> 因此，我們已經解決了這個問題。

673
00:30:12,170 --> 00:30:16,040
不幸的是，當我運行這個程序，在這種形式，它並不實際交換

674
00:30:16,040 --> 00:30:17,700
任何值。

675
00:30:17,700 --> 00:30:18,950
但要清楚，為什麼呢？

676
00:30:23,420 --> 00:30:26,310
我剛才固定的邏輯問題。

677
00:30:26,310 --> 00:30:31,150
但同樣，如果我運行這個程序，X和Y保持不變，年底

678
00:30:31,150 --> 00:30:33,834
該計劃的執行。

679
00:30:33,834 --> 00:30:34,760
[聽不清]

680
00:30:34,760 --> 00:30:36,030
DAVID J.馬蘭，因此，我們不返回任何東西。

681
00:30:36,030 --> 00:30:36,960
所以，這是事實。

682
00:30:36,960 --> 00:30:39,880
但事實證明，這裡有一個有點問題，因為到目前為止，

683
00:30:39,880 --> 00:30:42,460
，我們已經能夠返回的唯一的一件事。

684
00:30:42,460 --> 00:30:46,540
這是一個限制，您可以只返回一個真正的價值，

685
00:30:46,540 --> 00:30:48,970
在這種情況下，我被堵到了這裡

686
00:30:48,970 --> 00:30:51,805
因為我可以返回新的x值，否則我可能會返回

687
00:30:51,805 --> 00:30:53,160
新y的值。

688
00:30:53,160 --> 00:30:54,330
不過，我既要回來了。

689
00:30:54,330 --> 00:30:58,010
於是久違這裡沒有簡單的解決方案。

690
00:30:58,010 --> 00:30:59,770
但問題的根本是為什麼呢？

691
00:30:59,770 --> 00:31:03,270
我們有什麼實際交換？

692
00:31:03,270 --> 00:31:04,010
a和b。

693
00:31:04,010 --> 00:31:07,670
但是，a和b的副本的x和y，這意味著我們只是做了這一切

694
00:31:07,670 --> 00:31:10,080
 - 我們只花了像三分鐘談交換

695
00:31:10,080 --> 00:31:11,680
功能和所有這三個變量。

696
00:31:11,680 --> 00:31:15,090
這是偉大的，完全正確的，孤立的。

697
00:31:15,090 --> 00:31:20,230
但是，A和B的範圍不僅是在這些行。

698
00:31:20,230 --> 00:31:24,130
因此，就像一個for循環，如果你聲明一個整數i在for

699
00:31:24,130 --> 00:31:27,400
環 - 同樣，如果你​​聲明a和b裡面的功能，

700
00:31:27,400 --> 00:31:30,550
你寫的，他們是該函數的唯一有效的內部。

701
00:31:30,550 --> 00:31:35,020
這意味著只要交換是執行，我們從線24條，

702
00:31:35,020 --> 00:31:38,380
線25，x和y沒有被改變。

703
00:31:38,380 --> 00:31:42,580
你只是浪費了大量的時間交換的變量的副本。

704
00:31:42,580 --> 00:31:46,490
>> 所以，事實證明，要解決這個實際上是不很明顯。

705
00:31:46,490 --> 00:31:49,210
這不是很充足的返回值，因為我們可以

706
00:31:49,210 --> 00:31:50,320
只返回一個值。

707
00:31:50,320 --> 00:31:53,370
我真的想交換x和y都在相同的時間。

708
00:31:53,370 --> 00:31:55,020
因此，我們要回到這個。

709
00:31:55,020 --> 00:31:58,770
不過，現在認識到這個問題從根本上源於一個事實

710
00:31:58,770 --> 00:32:00,660
a和b的副本。

711
00:32:00,660 --> 00:32:03,450
他們是在自己的範圍內。

712
00:32:03,450 --> 00:32:04,980
好吧，讓我們以某種方式設法解決這個。

713
00:32:04,980 --> 00:32:09,200
讓我真正滾動回到這裡，開拓，讓我們說，第四個變種

714
00:32:09,200 --> 00:32:11,170
此，buggy4。

715
00:32:11,170 --> 00:32:13,230
又是怎麼回事嗎？

716
00:32:13,230 --> 00:32:16,690
這是一個類似，但更簡單的看問題之前，我們採取一捅

717
00:32:16,690 --> 00:32:17,530
解決它。

718
00:32:17,530 --> 00:32:19,440
這項計劃被稱為增量。

719
00:32:19,440 --> 00:32:24,320
它顯然初始化的x為1的整數，在第18行中。

720
00:32:24,320 --> 00:32:25,950
然後，我x是1。

721
00:32:25,950 --> 00:32:28,020
然後，我聲稱遞增，點，點，點。

722
00:32:28,020 --> 00:32:29,460
然後我打電話增量。

723
00:32:29,460 --> 00:32:33,480
但隨後在22日和23線，我要求它已經增加。

724
00:32:33,480 --> 00:32:37,780
我要求x是現在不管它是什麼，大概是2。

725
00:32:37,780 --> 00:32:39,770
>> 但這種方案是不穩定的。

726
00:32:39,770 --> 00:32:41,020
有什麼問題嗎？

727
00:32:43,450 --> 00:32:44,418
是嗎？

728
00:32:44,418 --> 00:32:45,668
[聽不清]

729
00:32:49,260 --> 00:32:49,850
DAVID J.馬蘭：沒錯。

730
00:32:49,850 --> 00:32:52,430
所以X顯然已宣布的第18行。

731
00:32:52,430 --> 00:32:54,410
這是內主要的大括號中。

732
00:32:54,410 --> 00:32:58,470
所以，簡單的答案是，在這裡，x存在。

733
00:32:58,470 --> 00:33:01,510
它不存在於線32。

734
00:33:01,510 --> 00:33:03,710
因此，這個程序實際上不會編譯。

735
00:33:03,710 --> 00:33:07,910
編譯器，當我嘗試編譯這段代碼時，會罵我

736
00:33:07,910 --> 00:33:13,190
一些未聲明的標識符或東西的效果。

737
00:33:13,190 --> 00:33:13,870
事實上，讓我們嘗試。

738
00:33:13,870 --> 00:33:15,235
這是使buggy4。

739
00:33:17,780 --> 00:33:18,190
在那裡，它是。

740
00:33:18,190 --> 00:33:22,030
使用未聲明的標識符x線32。

741
00:33:22,030 --> 00:33:25,700
而實際上，讓我們更加明確，今天在這裡，這是非常有用的

742
00:33:25,700 --> 00:33:27,140
辦公時間和在家裡。

743
00:33:27,140 --> 00:33:29,000
請注意，這是一個有點神秘的書面。

744
00:33:29,000 --> 00:33:31,560
但事實上，鏗鏘有對我們大吼大叫，說

745
00:33:31,560 --> 00:33:36,970
buggy4.c：32:5，實際上是有用的。

746
00:33:36,970 --> 00:33:41,970
這意味著，該錯誤是在字符位置5的線32上。

747
00:33:41,970 --> 00:33:44,670
因此，一，二，三，四，五。

748
00:33:44,670 --> 00:33:46,640
這是，事實上，問題出在哪裡。

749
00:33:46,640 --> 00:33:49,710
同時要記住，在辦公時間，在家裡，我很幸運在這裡。

750
00:33:49,710 --> 00:33:50,740
我有一個錯誤。

751
00:33:50,740 --> 00:33:52,660
這將是比較容易解決的。

752
00:33:52,660 --> 00:33:56,220
但是，如果你獲得壓倒性的錯誤消息，再次充滿整個畫面，

753
00:33:56,220 --> 00:33:59,240
實現最底層的人可能只是對症

754
00:33:59,240 --> 00:34:00,320
最頂層的。

755
00:34:00,320 --> 00:34:03,560
因此，總是追逐你的錯誤，從上而下。

756
00:34:03,560 --> 00:34:06,720
因為有可能只是一個菊花鏈的效果，建議你

757
00:34:06,720 --> 00:34:09,030
有比你實際做的方式更多的問題。

758
00:34:09,030 --> 00:34:14,989
>> 那麼，我們怎麼能解決這個問題，如果我的目標是增加x？

759
00:34:14,989 --> 00:34:15,370
那是什麼？

760
00:34:15,370 --> 00:34:15,620
好吧。

761
00:34:15,620 --> 00:34:16,679
因此，我們可以使X全球。

762
00:34:16,679 --> 00:34:18,860
讓我們走捷徑，我警告早期。

763
00:34:18,860 --> 00:34:20,550
不過，赫克說，我們只需要一個快速解決。

764
00:34:20,550 --> 00:34:23,949
因此，讓我們在這裡說詮釋x。

765
00:34:23,949 --> 00:34:25,600
這使得X全球。

766
00:34:25,600 --> 00:34:28,460
所以，現在主要有訪問它。

767
00:34:28,460 --> 00:34:31,780
而增加的訪問。

768
00:34:31,780 --> 00:34:33,860
因此，讓我繼續前進，現在編譯這個。

769
00:34:33,860 --> 00:34:36,330
，輸入使buggy4。

770
00:34:36,330 --> 00:34:37,440
似乎現在編譯。

771
00:34:37,440 --> 00:34:40,949
讓我們來運行buggy4，它似乎實際工作。

772
00:34:40,949 --> 00:34:42,780
現在，這是這些東西之一 - 

773
00:34:42,780 --> 00:34:45,870
聽我的話，還不如我呢，我剛剛在這裡完成。

774
00:34:45,870 --> 00:34:49,239
因為整體來說，我們的計劃將變得更加有趣，

775
00:34:49,239 --> 00:34:50,440
比這更長的時間。

776
00:34:50,440 --> 00:34:53,199
如果您解決生活中的問題是啊，把所有的

777
00:34:53,199 --> 00:34:57,550
在文件的開頭的變量，很快就做節目得到

778
00:34:57,550 --> 00:34:59,700
驚人，難以管理。

779
00:34:59,700 --> 00:35:02,050
它變得很難想出新的變量名。

780
00:35:02,050 --> 00:35:05,240
它會更難理解變量是做什麼的。

781
00:35:05,240 --> 00:35:08,250
>> ，因此，在一般的，這是不是一個好的解決方案。

782
00:35:08,250 --> 00:35:09,780
因此，讓我們做到這一點。

783
00:35:09,780 --> 00:35:11,920
我們不想在這裡使用一個全局變量。

784
00:35:11,920 --> 00:35:14,050
我想增加x。

785
00:35:14,050 --> 00:35:16,050
所以，我可以很明顯 - 

786
00:35:16,050 --> 00:35:18,450
在一天結束的時候，這是一個愚蠢的故事，因為我們只要做到這一點。

787
00:35:18,450 --> 00:35:22,050
但是，如果我不知道，運營商，或我沒有被允許到

788
00:35:22,050 --> 00:35:27,700
改變它在主本身，怎麼可能我實現了肯在這裡，這

789
00:35:27,700 --> 00:35:31,450
時間到多維數據集，但增加？

790
00:35:31,450 --> 00:35:32,700
我該如何改變這件事情嗎？

791
00:35:32,700 --> 00:35:33,025
是啊。

792
00:35:33,025 --> 00:35:34,275
[聽不清]

793
00:35:37,430 --> 00:35:38,000
DAVID J.馬蘭：好，好。

794
00:35:38,000 --> 00:35:40,490
那麼，為什麼不讓我通過在x？

795
00:35:40,490 --> 00:35:44,390
然後，而不是返回它，為什麼不，我只是做回X + 1？

796
00:35:44,390 --> 00:35:46,370
現在，一對夫婦更多的東西必須改變。

797
00:35:46,370 --> 00:35:47,530
我在正確的軌道上。

798
00:35:47,530 --> 00:35:48,910
還有什麼我需要調整嗎？

799
00:35:48,910 --> 00:35:49,470
別人。

800
00:35:49,470 --> 00:35:49,882
是嗎？

801
00:35:49,882 --> 00:35:51,530
[聽不清]

802
00:35:51,530 --> 00:35:53,520
DAVID J.馬蘭：我需要改變的返回類型增加

803
00:35:53,520 --> 00:35:54,590
因為它並非無效。

804
00:35:54,590 --> 00:35:56,650
虛空意味著什麼也沒有返回。

805
00:35:56,650 --> 00:35:57,600
但顯然，現在是。

806
00:35:57,600 --> 00:36:01,280
因此，這需要改變int以符合任何

807
00:36:01,280 --> 00:36:02,580
實際上，我回來了。

808
00:36:02,580 --> 00:36:04,580
>> 現在別的東西，是大聲喧嘩。

809
00:36:04,580 --> 00:36:04,982
是嗎？

810
00:36:04,982 --> 00:36:06,590
[聽不清]

811
00:36:06,590 --> 00:36:07,630
DAVID J.馬蘭：所以我需要增加x？

812
00:36:07,630 --> 00:36:10,336
[聽不清]

813
00:36:10,336 --> 00:36:11,880
DAVID J.馬蘭：啊，所以我需要傳遞X。

814
00:36:11,880 --> 00:36:13,300
所以我需要在這裡做到這一點。

815
00:36:17,590 --> 00:36:19,690
因此，原型，我必須要改變這個在這裡。

816
00:36:19,690 --> 00:36:21,290
因此，這成為一個int。

817
00:36:21,290 --> 00:36:22,820
這成為 - 

818
00:36:22,820 --> 00:36:23,670
嗯。

819
00:36:23,670 --> 00:36:24,710
其實，我這裡有一個錯誤。

820
00:36:24,710 --> 00:36:25,780
讓我們來解決這個問題第一次。

821
00:36:25,780 --> 00:36:27,990
應該是什麼內容究竟是什麼？

822
00:36:27,990 --> 00:36:29,330
因此，它必須是一個int的東西。

823
00:36:29,330 --> 00:36:30,340
它可以是x。

824
00:36:30,340 --> 00:36:33,120
但是坦率地說，如果你開始調用所有的變量x，它會得到

825
00:36:33,120 --> 00:36:35,250
越來越不清晰哪個是哪個。

826
00:36:35,250 --> 00:36:38,210
因此，讓我們任意選擇一個不同的命名約定為我的

827
00:36:38,210 --> 00:36:40,220
輔助函數，我寫的功能。

828
00:36:40,220 --> 00:36:41,100
我們將調用它。

829
00:36:41,100 --> 00:36:44,500
或者，我們可以把它稱為 - 我們姑且稱之為，它even_number更明確。

830
00:36:44,500 --> 00:36:47,610
於是我返回任何數加1。

831
00:36:47,610 --> 00:36:49,720
現在，我必須要改變一個其他的東西在這裡，一個

832
00:36:49,720 --> 00:36:50,700
其他的東西在這裡。

833
00:36:50,700 --> 00:36:54,150
我有什麼改變第21行第一次嗎？

834
00:36:54,150 --> 00:36:55,390
我有把它分配給x。

835
00:36:55,390 --> 00:36:57,480
這樣我就可以不叫增量x。

836
00:36:57,480 --> 00:37:01,000
通過改變x的值，我需要記住的答案

837
00:37:01,000 --> 00:37:02,020
左手側。

838
00:37:02,020 --> 00:37:04,930
即使x是現在的左，右，這是完全正常的，因為

839
00:37:04,930 --> 00:37:08,370
首先被執行的右手側，然後被撲通進入左

840
00:37:08,370 --> 00:37:10,240
手的事情，x在這種情況下。

841
00:37:10,240 --> 00:37:11,900
最後，這是一個簡單的辦法。

842
00:37:11,900 --> 00:37:15,080
這應該匹配什麼是向下。

843
00:37:15,080 --> 00:37:17,120
詮釋號。

844
00:37:17,120 --> 00:37:17,320
>> 好的。

845
00:37:17,320 --> 00:37:20,290
那麼一大堆的一個非常愚蠢的功能的變化。

846
00:37:20,290 --> 00:37:24,250
但代表，我們將越來越多地想要做的事情。

847
00:37:24,250 --> 00:37:25,490
因此，請buggy4。

848
00:37:25,490 --> 00:37:26,485
我搞砸了的地方。

849
00:37:26,485 --> 00:37:27,520
哦，我的上帝。

850
00:37:27,520 --> 00:37:29,660
五個錯誤一樣，一個六行的計劃。

851
00:37:29,660 --> 00:37:36,500
那麼，什麼是錯的第18行，字符？

852
00:37:36,500 --> 00:37:36,970
好的。

853
00:37:36,970 --> 00:37:39,330
所以，我要聲明這個中斷。

854
00:37:39,330 --> 00:37:39,630
好的。

855
00:37:39,630 --> 00:37:41,790
所以，讓我們來看看，一大堆其他錯誤。

856
00:37:41,790 --> 00:37:42,230
噢，我的上帝。

857
00:37:42,230 --> 00:37:43,880
19，18，21。

858
00:37:43,880 --> 00:37:46,020
再次，讓我們清除屏幕 - 

859
00:37:46,020 --> 00:37:48,660
控制L  - 並重新運行鐺。

860
00:37:48,660 --> 00:37:51,340
因此，五個方面的問題是實際上只是一個。

861
00:37:51,340 --> 00:37:53,500
所以，現在讓我們來運行buggy4，回車。

862
00:37:53,500 --> 00:37:54,150
哇！

863
00:37:54,150 --> 00:37:57,434
x已經被正確地遞增。

864
00:37:57,434 --> 00:37:58,420
>> 好的。

865
00:37:58,420 --> 00:38:01,700
如何增加數字的任何問題？

866
00:38:01,700 --> 00:38:02,896
是嗎？

867
00:38:02,896 --> 00:38:06,864
主講人2：為什麼是它，你可以只改變x的變量數

868
00:38:06,864 --> 00:38:08,860
命名，它會知道你是什麼意思？

869
00:38:08,860 --> 00:38:09,600
DAVID J.馬蘭：好問題。

870
00:38:09,600 --> 00:38:13,130
它是如何，我可以只改變x的數量，程序將知道

871
00:38:13,130 --> 00:38:13,990
立即嗎？

872
00:38:13,990 --> 00:38:16,120
所以，再一次，把它作為這個抽象。

873
00:38:16,120 --> 00:38:20,110
所以，如果我主要和Ken是漸進式的，坦率地說，我不關心

874
00:38:20,110 --> 00:38:21,540
什麼肯稱，他的iPad。

875
00:38:21,540 --> 00:38:25,350
我不在乎他所說的什麼，做他的執行

876
00:38:25,350 --> 00:38:26,550
這個功能。

877
00:38:26,550 --> 00:38:32,130
所以這是一個實現細節，我，主，不

878
00:38:32,130 --> 00:38:33,010
有關心。

879
00:38:33,010 --> 00:38:37,440
因此，簡單地改變它一貫裡面的功能，號

880
00:38:37,440 --> 00:38:41,340
和數量，是需要很長時間，我重新編譯。

881
00:38:41,340 --> 00:38:43,820
這是有點像，如果你認為的 - 很多人來說，你的驅動程序的

882
00:38:43,820 --> 00:38:46,590
許可所驅動，或者如果你即使在汽車驅動 - 

883
00:38:46,590 --> 00:38:50,710
我們大多數人不知道如何汽車引擎蓋下的。

884
00:38:50,710 --> 00:38:54,710
從字面上看，如果你打開引擎蓋，我們大多數人 - 包括我自己 - 

885
00:38:54,710 --> 00:38:56,580
不會真正了解我們正在尋找。

886
00:38:56,580 --> 00:38:58,850
有點像你可能會覺得現在的東西，如這項權利。

887
00:38:58,850 --> 00:39:01,380
但是，我們真的不關心汽車是如何工作的。

888
00:39:01,380 --> 00:39:05,000
我們不必關心所有內部的桿和活塞和電纜

889
00:39:05,000 --> 00:39:07,700
汽車實際上是在做什麼。

890
00:39:07,700 --> 00:39:11,360
>> 所以像你所說的活塞無所謂

891
00:39:11,360 --> 00:39:11,920
這裡在這種情況下。

892
00:39:11,920 --> 00:39:12,490
同樣的想法。

893
00:39:12,490 --> 00:39:12,670
是嗎？

894
00:39:12,670 --> 00:39:13,920
[聽不清]

895
00:39:25,250 --> 00:39:29,530
DAVID J.馬蘭：如果有更多的用途的變量XA時刻前，

896
00:39:29,530 --> 00:39:32,220
作為程序員，你將不得不改變他們無處不在。

897
00:39:32,220 --> 00:39:35,230
或者你可以從字面上文件，菜單，然後查找/替換，

898
00:39:35,230 --> 00:39:36,270
類似的東西。

899
00:39:36,270 --> 00:39:40,110
但是你將不得不讓自己的這些變化。

900
00:39:40,110 --> 00:39:41,200
你必須是一致的。

901
00:39:41,200 --> 00:39:42,450
[聽不清]

902
00:39:47,200 --> 00:39:48,960
DAVID J.馬蘭特定的順序：A喜歡這裡嗎？

903
00:39:48,960 --> 00:39:52,660
如果這是int的另一個電話號碼嗎？

904
00:39:52,660 --> 00:39:52,940
是啊。

905
00:39:52,940 --> 00:39:56,430
因此，為了重要的，當你調用該函數。

906
00:39:56,430 --> 00:40:00,350
所以，如果我在這裡呼籲增加的東西逗號東西，

907
00:40:00,350 --> 00:40:01,400
有一個直接的映射。

908
00:40:01,400 --> 00:40:04,490
第一可變，無論它的名字，作出了第一個副本

909
00:40:04,490 --> 00:40:05,480
在這裡的論點。

910
00:40:05,480 --> 00:40:07,280
對不起，這不應該是一個括號。

911
00:40:07,280 --> 00:40:09,300
第二個參數與第二個。

912
00:40:09,300 --> 00:40:11,220
>> ，是的，所以，為了事宜。

913
00:40:11,220 --> 00:40:11,490
好的。

914
00:40:11,490 --> 00:40:13,360
對不起，我花了很長的路到那裡。

915
00:40:13,360 --> 00:40:14,610
其他問題嗎？

916
00:40:16,460 --> 00:40:16,850
好的。

917
00:40:16,850 --> 00:40:20,300
因此，讓我們來看看，如果我們不能畫一幅畫，實際上

918
00:40:20,300 --> 00:40:22,160
引擎蓋下的，可以這麼說。

919
00:40:22,160 --> 00:40:26,310
因此，這是一個矩形，可能代表你的計算機的內存。

920
00:40:26,310 --> 00:40:31,240
所以，即使你不知道如何記憶或RAM作品如何，至少

921
00:40:31,240 --> 00:40:33,590
假設你有束的這些天。

922
00:40:33,590 --> 00:40:34,740
你得到了它的兆字節。

923
00:40:34,740 --> 00:40:35,760
你有GB的。

924
00:40:35,760 --> 00:40:40,690
我們知道，從週零一個字節是什麼？

925
00:40:40,690 --> 00:40:41,280
8位。

926
00:40:41,280 --> 00:40:42,730
對，所以8 0和1。

927
00:40:42,730 --> 00:40:46,300
所以，如果你的計算機有一個演出的RAM，2個演出的RAM這些日子裡，你有一個

928
00:40:46,300 --> 00:40:54,450
億或2億字節的內存，或大約8億美元或16億美元

929
00:40:54,450 --> 00:40:56,560
位，您的計算機內。

930
00:40:56,560 --> 00:40:59,710
現在不像的小綿威利例如，它沒有磁性粒子

931
00:40:59,710 --> 00:41:00,560
典型的了。

932
00:41:00,560 --> 00:41:04,470
越來越多的，至少在筆記本電腦，它的固態硬盤，固態硬盤，

933
00:41:04,470 --> 00:41:05,560
只是沒有移動部件。

934
00:41:05,560 --> 00:41:06,710
這是所有的電子。

935
00:41:06,710 --> 00:41:08,070
這是所有的電力基礎。

936
00:41:08,070 --> 00:41:12,360
因此認為，雖然，這個矩形代表一個或兩個

937
00:41:12,360 --> 00:41:13,930
GB的記憶體，你有。

938
00:41:13,930 --> 00:41:15,500
>> 因此，它是一個內存塊。

939
00:41:15,500 --> 00:41:20,460
現在世界上的計算機科學類的分區塊

940
00:41:20,460 --> 00:41:22,570
內存做不同的事情。

941
00:41:22,570 --> 00:41:25,930
因此，舉例來說，如果這是您的計算機的內存 - 所建議的

942
00:41:25,930 --> 00:41:30,400
矩形 - 原來，按照慣例，在您的RAM的頂部，所以

943
00:41:30,400 --> 00:41:33,170
說，一般是什麼所謂的文本段。

944
00:41:33,170 --> 00:41:35,910
這些都是零和的，你已經編譯。

945
00:41:35,910 --> 00:41:39,040
因此，當我們已經看到引擎蓋下的a.out是什麼，所有

946
00:41:39,040 --> 00:41:40,360
0和1  - 

947
00:41:40,360 --> 00:41:44,000
當你運行一個程序時，這些0和1，從您的硬盤裝入

948
00:41:44,000 --> 00:41:46,290
到一些所謂的RAM驅動器。

949
00:41:46,290 --> 00:41:48,950
在RAM中，他們把在頂部。

950
00:41:48,950 --> 00:41:50,330
同時，你還有其他的事情。

951
00:41:50,330 --> 00:41:53,060
初始化數據，未初始化的數據。

952
00:41:53,060 --> 00:41:56,440
這兩個大片的內存是指為全局變量，

953
00:41:56,440 --> 00:41:57,530
你不經常使用。

954
00:41:57,530 --> 00:42:00,630
但有時如果你這樣做，他們結束了在那裡為好。

955
00:42:00,630 --> 00:42:01,620
此外，還有一些其他的東西。

956
00:42:01,620 --> 00:42:04,130
環境變量，我們不會花太多的時間。

957
00:42:04,130 --> 00:42:06,120
但隨後的兩件重要的事情會回來整個

958
00:42:06,120 --> 00:42:08,130
學期，堆棧和堆。

959
00:42:08,130 --> 00:42:12,280
>> 因此，大多數您的計算機的內存中運行的程序時保留

960
00:42:12,280 --> 00:42:14,880
一些所謂的堆棧，稱為堆的東西。

961
00:42:14,880 --> 00:42:16,940
我們不會談論堆，但我們會

962
00:42:16,940 --> 00:42:18,180
談論的堆棧。

963
00:42:18,180 --> 00:42:22,910
和堆棧是為了喚起了視覺像食堂

964
00:42:22,910 --> 00:42:26,120
餐托盤Mather中樓，或任何你碰巧是，這裡的

965
00:42:26,120 --> 00:42:27,810
食堂的工作人員清理他們的每一天。

966
00:42:27,810 --> 00:42:30,180
它們堆疊起來，從地板上起來。

967
00:42:30,180 --> 00:42:33,800
同樣在內存中，有這種想法，把一些在

968
00:42:33,800 --> 00:42:36,740
疊加，將在棧上的東西，把東西在棧上。

969
00:42:36,740 --> 00:42:38,000
是什麼意思呢？

970
00:42:38,000 --> 00:42:41,430
好吧，讓我們放大只是這張照片的下半部分，您的電腦

971
00:42:41,430 --> 00:42:43,990
RAM，提出以下建議。

972
00:42:43,990 --> 00:42:48,300
原來，當你運行一個程序，如a.out格式“或”你好，什麼

973
00:42:48,300 --> 00:42:49,920
該程序是你寫的，

974
00:42:49,920 --> 00:42:53,030
再次，從您的硬盤驅動器加載這些0和1  - 

975
00:42:53,030 --> 00:42:56,190
長期儲存，在那裡停留，即使你拔掉插頭 - 

976
00:42:56,190 --> 00:42:57,220
加載到RAM中。

977
00:42:57,220 --> 00:42:59,020
RAM的速度比硬盤驅動器。

978
00:42:59,020 --> 00:43:00,700
這是小於硬盤驅動器。

979
00:43:00,700 --> 00:43:03,490
但它的節目直播，當你運行它們。

980
00:43:03,490 --> 00:43:06,380
>> 所以，你雙擊一個Mac或PC上的程序 - 它裝載

981
00:43:06,380 --> 00:43:07,750
到RAM中的硬盤驅動器。

982
00:43:07,750 --> 00:43:11,760
只要它加載到內存中，0和1的方式上，

983
00:43:11,760 --> 00:43:13,130
所謂的文本段。

984
00:43:13,130 --> 00:43:17,040
但是，當你的程序啟動運行，主要

985
00:43:17,040 --> 00:43:18,140
函數被調用。

986
00:43:18,140 --> 00:43:21,070
為主，正如我們已經看到的那樣，經常有局部變量。

987
00:43:21,070 --> 00:43:24,560
它有整型和字符串和字符之類的。

988
00:43:24,560 --> 00:43:28,300
所以，如果你的程序，你寫的程序，你有

989
00:43:28,300 --> 00:43:33,680
雙擊內主要使用的一些變量，他們最終在

990
00:43:33,680 --> 00:43:37,020
你的內存堆棧的底部，可以這麼說。

991
00:43:37,020 --> 00:43:39,160
現在更具體地說，這是什麼究竟是什麼意思？

992
00:43:39,160 --> 00:43:44,080
這也就意味著，如果我們要怎樣數算自己的事情 - 

993
00:43:44,080 --> 00:43:49,380
如果我們要在您的計算機數量的字節RAM，請注意，

994
00:43:49,380 --> 00:43:51,650
這可能是字節數為0。

995
00:43:51,650 --> 00:43:56,130
這可能是字節數一，二，三，四，五，六，所有

996
00:43:56,130 --> 00:43:57,290
喜歡 - 

997
00:43:57,290 --> 00:44:01,520
2億美元將一路攀升，在頂部。

998
00:44:01,520 --> 00:44:05,960
所以，換句話說，當我們談論RAM或內存中的字節，

999
00:44:05,960 --> 00:44:09,680
只是意味著有人已經決定號每

1000
00:44:09,680 --> 00:44:11,110
這些內存塊。

1001
00:44:11,110 --> 00:44:16,950
>> 所以，當你需要32位的int，或者你需要一個字符的8位，其中

1002
00:44:16,950 --> 00:44:18,320
他們結束了在內存裡？

1003
00:44:18,320 --> 00:44:20,650
那麼從理論上講，他們剛剛結束了在底部的

1004
00:44:20,650 --> 00:44:21,780
東西叫堆棧。

1005
00:44:21,780 --> 00:44:25,670
但現在有什麼有趣的是，當主調用一個函數。

1006
00:44:25,670 --> 00:44:28,830
假設一個函數調用foo的，只是一個任意的名稱。

1007
00:44:28,830 --> 00:44:32,480
會發生什麼更主要的是在這個堆棧的底部的內存。

1008
00:44:32,480 --> 00:44:35,630
美孚現在被放置在頂部的主內存中。

1009
00:44:35,630 --> 00:44:40,020
因此，任何局部變量foo的最終排序的概念上以上

1010
00:44:40,020 --> 00:44:40,770
在主。

1011
00:44:40,770 --> 00:44:46,920
如果foo調用另一個函數調用酒吧，這些變量在這裡結束。

1012
00:44:46,920 --> 00:44:49,790
如果酒吧調用別的東西，在這裡，這裡，這裡。

1013
00:44:49,790 --> 00:44:53,900
那麼，在運行了一個程序很有意思的是，當你調用函數，

1014
00:44:53,900 --> 00:44:57,720
那些函數調用的函數，這些函數調用功能，

1015
00:44:57,720 --> 00:45:00,980
你建立了這個堆棧在內存中的功能。

1016
00:45:00,980 --> 00:45:06,740
而只有一個函數返回後，你開始，內存。

1017
00:45:06,740 --> 00:45:11,190
因此耗盡內存在計算機程序中最簡單的方法之一是

1018
00:45:11,190 --> 00:45:14,170
寫函數從不返回。

1019
00:45:14,170 --> 00:45:16,650
>> 因此，舉例來說，讓盡可能多的展示與

1020
00:45:16,650 --> 00:45:18,460
故意錯誤的程序。

1021
00:45:18,460 --> 00:45:24,690
讓我繼續前進，不要＃包括<stdio.h>的，詮釋的主要（無效）。

1022
00:45:24,690 --> 00:45:31,270
我該怎麼辦（2​​> 1），這可能將永遠不會

1023
00:45:31,270 --> 00:45:33,370
改變我們。

1024
00:45:33,370 --> 00:45:37,720
讓我繼續做輸出。

1025
00:45:37,720 --> 00:45:39,950
事實上，這將是在視覺有趣的。

1026
00:45:39,950 --> 00:45:40,460
讓我們這樣做。

1027
00:45:40,460 --> 00:45:44,840
為Int（i = 0; I> 0）。

1028
00:45:44,840 --> 00:45:49,740
讓我們犯這樣的錯誤，我+ +。

1029
00:45:49,740 --> 00:45:51,150
讓我們在這裡不是printf。

1030
00:45:51,150 --> 00:45:52,550
我們的做法是我的說教。

1031
00:45:52,550 --> 00:45:54,090
讓我們在這裡有一個方法。

1032
00:45:54,090 --> 00:46:00,860
虛空的合唱，我們會說INT I。

1033
00:46:00,860 --> 00:46:02,295
然後我會說，輸出 - 

1034
00:46:04,871 --> 00:46:06,790
哦，讓我們使這更有趣的。

1035
00:46:06,790 --> 00:46:08,350
讓實際不打印任何東西，在所有。

1036
00:46:08,350 --> 00:46:10,530
我們只要做到這一點。

1037
00:46:10,530 --> 00:46:11,780
合唱團（I）。

1038
00:46:16,630 --> 00:46:17,000
>> 好的。

1039
00:46:17,000 --> 00:46:20,040
因此，這是越野車，因為為什麼呢？

1040
00:46:20,040 --> 00:46:22,850
我正在做這件事，因為我去的，因為該計劃實際上並沒有做什麼

1041
00:46:22,850 --> 00:46:23,420
的興趣。

1042
00:46:23,420 --> 00:46:24,670
但是，這不是目標。

1043
00:46:24,670 --> 00:46:30,440
我們的目標是編寫一個程序，做什麼，顯然，其主要功能？

1044
00:46:30,440 --> 00:46:31,370
調用自身。

1045
00:46:31,370 --> 00:46:32,600
實際上，我們並不需要循環。

1046
00:46:32,600 --> 00:46:36,070
讓我們甚至簡化這只是因此，不要忽視真正的

1047
00:46:36,070 --> 00:46:37,310
根本的問題。

1048
00:46:37,310 --> 00:46:39,200
主要調用合唱團唱一些合唱。

1049
00:46:39,200 --> 00:46:41,760
然後我做了一些愚蠢的事情，和我有合唱的呼叫合唱團，因為我假定

1050
00:46:41,760 --> 00:46:43,550
別人可能實現它。

1051
00:46:43,550 --> 00:46:45,960
現在，這是不會還來編譯。

1052
00:46:45,960 --> 00:46:48,340
我需要做什麼？

1053
00:46:48,340 --> 00:46:49,700
我需要的原型，記住了。

1054
00:46:49,700 --> 00:46:55,520
所以我需要在這裡有無效合唱團（int i）的。

1055
00:46:55,520 --> 00:46:57,470
>> 所以，現在，如果我去這裡 - 

1056
00:46:57,470 --> 00:46:59,030
其實，讓我們用更大的窗口。

1057
00:46:59,030 --> 00:47:01,670
讓我們繼續前進，並合唱。

1058
00:47:01,670 --> 00:47:06,000
讓我們繼續前進，並合唱。

1059
00:47:06,000 --> 00:47:08,302
使用身份不明申報我。

1060
00:47:08,302 --> 00:47:09,860
哦，那是愚蠢的。

1061
00:47:09,860 --> 00:47:11,020
我們並不需要的參數。

1062
00:47:11,020 --> 00:47:13,680
我們只要做到這一點。

1063
00:47:13,680 --> 00:47:14,550
希望我們能有這樣開始。

1064
00:47:14,550 --> 00:47:16,160
這本來是一個更簡單的程序編寫。

1065
00:47:16,160 --> 00:47:20,100
這樣出現了。

1066
00:47:20,100 --> 00:47:23,870
現在，讓我們去到我的終端窗口，再次運行鐺。

1067
00:47:23,870 --> 00:47:26,900
在這裡，我們走了。

1068
00:47:26,900 --> 00:47:28,020
這是真快。

1069
00:47:28,020 --> 00:47:30,690
究竟剛發生時，有關係嗎？

1070
00:47:30,690 --> 00:47:33,430
好了，現在我將添加打印線，這樣我們就可以看到。

1071
00:47:33,430 --> 00:47:41,330
因此，讓我輸出，比方說，我在這裡。

1072
00:47:41,330 --> 00:47:43,470
好了，沒有變量，我們會留下這樣的。

1073
00:47:43,470 --> 00:47:44,860
讓我重新運行。

1074
00:47:44,860 --> 00:47:47,940
讓我重新運行合唱團。

1075
00:47:47,940 --> 00:47:51,235
。

1076
00:47:53,880 --> 00:47:55,130
繼續下去。

1077
00:47:57,630 --> 00:47:59,750
順便說一句，為什麼它沒有崩潰嗎？

1078
00:47:59,750 --> 00:48:02,050
分割故障發生前超級快。

1079
00:48:02,050 --> 00:48:04,250
[聽不清]

1080
00:48:04,250 --> 00:48:04,830
DAVID J.馬蘭：沒錯。

1081
00:48:04,830 --> 00:48:06,350
因此，它需要一定的時間來打印。

1082
00:48:06,350 --> 00:48:08,370
它只是需要更多的工作在計算機的一部分。

1083
00:48:08,370 --> 00:48:09,550
有。

1084
00:48:09,550 --> 00:48:10,620
分割故障。

1085
00:48:10,620 --> 00:48:12,140
>> 因此，發現是多麼快的程序運行。

1086
00:48:12,140 --> 00:48:14,110
如果你沒有打印任何東西，超級快。

1087
00:48:14,110 --> 00:48:18,100
但是，我們仍然得到了該段故障，因為發生了什麼事？

1088
00:48:18,100 --> 00:48:21,310
好吧，如果你認為您的計算機的內存，這

1089
00:48:21,310 --> 00:48:22,890
恰好是主要的。

1090
00:48:22,890 --> 00:48:23,800
但在這裡 - 

1091
00:48:23,800 --> 00:48:28,670
我們只需要調用這個合唱之中，讓我們這個合唱團。

1092
00:48:28,670 --> 00:48:33,420
現在，如果我做我的美學，這只是說合唱，

1093
00:48:33,420 --> 00:48:38,060
合唱團，合唱團，合唱團，合唱團，合唱團，合唱團，廣告nauseum。

1094
00:48:38,060 --> 00:48:39,920
最終，會發生什麼呢？

1095
00:48:39,920 --> 00:48:46,690
如果大的畫面字面意思是這樣的，這是發生在概念上嗎？

1096
00:48:46,690 --> 00:48:48,320
該協議棧溢出堆。

1097
00:48:48,320 --> 00:48:52,400
更糟糕的是，你只是溢出的一切，包括文本段，這是

1098
00:48:52,400 --> 00:48:54,530
0和1代表你的程序。

1099
00:48:54,530 --> 00:48:56,690
總之，這僅僅是超級，超級壞。

1100
00:48:56,690 --> 00:48:56,860
對嗎？

1101
00:48:56,860 --> 00:48:58,620
你的程序已失去控制。

1102
00:48:58,620 --> 00:49:02,840
您使用的是比你打算一切都是因為一個愚蠢的方式更多的內存

1103
00:49:02,840 --> 00:49:03,920
錯誤，在這種情況下。

1104
00:49:03,920 --> 00:49:08,160
或者，在這種情況下，故意做的函數調用自己。

1105
00:49:08,160 --> 00:49:09,210
現在，這並不全是壞事。

1106
00:49:09,210 --> 00:49:12,540
調用自己的函數實際上擁有極大的權力

1107
00:49:12,540 --> 00:49:13,700
當你正確地使用它。

1108
00:49:13,700 --> 00:49:15,650
我還沒有正確地使用它在這裡。

1109
00:49:15,650 --> 00:49:16,940
>> 因此，這並不全是壞事。

1110
00:49:16,940 --> 00:49:20,620
但事實上，我從來沒有真正停止稱自己是一個基本的

1111
00:49:20,620 --> 00:49:23,050
這一方案的弱點在這裡。

1112
00:49:23,050 --> 00:49:25,090
那麼，我們要與所有這一切嗎？

1113
00:49:25,090 --> 00:49:26,230
那麼，到底發生了什麼？

1114
00:49:26,230 --> 00:49:30,010
當我打電話的增量功能，像我們所做的是在那些例子，

1115
00:49:30,010 --> 00:49:33,290
我有一個值，如1，我傳進去

1116
00:49:33,290 --> 00:49:35,820
我通過在副本的頭號。

1117
00:49:35,820 --> 00:49:37,080
因此，發生以下情況。

1118
00:49:37,080 --> 00:49:40,390
因此，讓進入的增量例子。

1119
00:49:40,390 --> 00:49:44,230
而且這傢伙就在這裡。

1120
00:49:44,230 --> 00:49:46,800
因此，這裡實際上發生了什麼。

1121
00:49:46,800 --> 00:49:50,770
當我打電話的增量，和我通過在X，形象地什麼

1122
00:49:50,770 --> 00:49:53,660
在這裡是這樣的 - 

1123
00:49:53,660 --> 00:50:00,240
如果我有1的值保存在這裡，和其實我打電話增量，這

1124
00:50:00,240 --> 00:50:02,680
現在被稱為合唱團 - 

1125
00:50:02,680 --> 00:50:04,010
是啊，把我關在這裡。

1126
00:50:04,010 --> 00:50:06,750
所以，讓我們把這個增量。

1127
00:50:06,750 --> 00:50:09,420
我們不知道這是什麼下一個功能將是。

1128
00:50:09,420 --> 00:50:14,270
那麼，什麼是實際發生的事情是這裡的某個地方，我有一個在主塊的

1129
00:50:14,270 --> 00:50:16,670
存儲器，存儲數字1。

1130
00:50:16,670 --> 00:50:19,730
當我打電話給增量，我使用其他的內存塊，但現在我

1131
00:50:19,730 --> 00:50:20,840
有副本1。

1132
00:50:20,840 --> 00:50:25,480
當我增加值，這將成為2  - 可怕的寫在

1133
00:50:25,480 --> 00:50:26,420
屏幕在這裡。

1134
00:50:26,420 --> 00:50:30,550
但後​​來，發生了什麼，盡快增加回報嗎？

1135
00:50:30,550 --> 00:50:34,610
內存只是被交還給操作系統，這意味著所有

1136
00:50:34,610 --> 00:50:37,470
你這樣做是沒有什麼用處。

1137
00:50:37,470 --> 00:50:43,460
實際上仍然是存在的，最初是包含在主。

1138
00:50:43,460 --> 00:50:44,650
>> 所以，我們要這個嗎？

1139
00:50:44,650 --> 00:50:49,400
好了，事實證明，在內存中，你有這個背靠背序列

1140
00:50:49,400 --> 00:50:50,940
字節，你可以把東西英寸

1141
00:50:50,940 --> 00:50:53,760
而事實證明，我們已經看到的東西，包括把

1142
00:50:53,760 --> 00:50:55,100
事情背靠背背靠背。

1143
00:50:55,100 --> 00:51:00,170
什麼是一個字符串，第一個星期，現在在本週二的基礎上嗎？

1144
00:51:00,170 --> 00:51:01,840
所以它只是一個字符集合。

1145
00:51:01,840 --> 00:51:05,290
因此，原來，就像你可以把數字在內存中，同樣你也可以

1146
00:51:05,290 --> 00:51:06,900
把字符在內存中。

1147
00:51:06,900 --> 00:51:09,810
一旦我們開始把字符在內存中背靠背

1148
00:51:09,810 --> 00:51:12,800
回來，事實證明，使用最簡單的事情，比如一個for循環

1149
00:51:12,800 --> 00:51:14,510
while循環中，我們可以遍歷 - 

1150
00:51:14,510 --> 00:51:17,130
從左至右在字符串中的字符 - 

1151
00:51:17,130 --> 00:51:20,720
開始按摩到完全不同的字符。

1152
00:51:20,720 --> 00:51:25,550
A可能變為B。有可能成為C.所以，最終，我們可以採取一個

1153
00:51:25,550 --> 00:51:28,830
英語句子，其實是有道理的，每個人轉換

1154
00:51:28,830 --> 00:51:32,440
一次一個步行通過我們的計算機的內存離開

1155
00:51:32,440 --> 00:51:34,300
實際上加密的權利。

1156
00:51:34,300 --> 00:51:36,590
>> 因此，讓我們在這裡，我們五分鐘的休息時間，當我們回來時，我們會

1157
00:51:36,590 --> 00:51:39,060
啟動這一進程的擾碼信息。

1158
00:51:41,640 --> 00:51:43,180
>> 好的。

1159
00:51:43,180 --> 00:51:48,440
所以，在我們深入到一些加密，這些東西稱為“陣列”，讓我

1160
00:51:48,440 --> 00:51:51,610
暫停任何問題，因為我覺得我是那種混亂的一些

1161
00:51:51,610 --> 00:51:52,230
這些議題。

1162
00:51:52,230 --> 00:51:53,940
所以現在，如果我們可以讓我們來解決。

1163
00:51:53,940 --> 00:51:56,480
所以，我們剛才講的返回值。

1164
00:51:56,480 --> 00:51:58,630
我們談論的論點。

1165
00:51:58,630 --> 00:52:02,330
我們談論這個概念，我們回來在週

1166
00:52:02,330 --> 00:52:07,140
來，這些堆積一大堆的查看內存

1167
00:52:07,140 --> 00:52:08,540
托盤，可以這麼說。

1168
00:52:08,540 --> 00:52:13,460
從底部上起來，使得每個托盤會在棧上代表

1169
00:52:13,460 --> 00:52:15,160
的功能，這是目前被調用。

1170
00:52:17,970 --> 00:52:20,300
有什麼問題嗎？

1171
00:52:20,300 --> 00:52:22,890
因此，如何對 - 讓我試著問了一個問題。

1172
00:52:22,890 --> 00:52:25,520
我一直在破壞，但現在it's  - 地一下男孩的臉。

1173
00:52:25,520 --> 00:52:27,020
因此，我們將回來。

1174
00:52:27,020 --> 00:52:29,700
>> 因此，讓我在這裡問一個問題。

1175
00:52:29,700 --> 00:52:34,810
讓我簡化這回它是什麼之前，我們早期的Q＆A.

1176
00:52:34,810 --> 00:52:41,730
而事實上，增量左括號，INT數，關閉

1177
00:52:41,730 --> 00:52:42,260
括號內。

1178
00:52:42,260 --> 00:52:46,370
整數數字代表什麼？

1179
00:52:46,370 --> 00:52:47,250
[聽不清]

1180
00:52:47,250 --> 00:52:47,870
DAVID J.馬蘭的說法。

1181
00:52:47,870 --> 00:52:50,732
好了，但什麼是參數？

1182
00:52:50,732 --> 00:52:51,620
[聽不清]

1183
00:52:51,620 --> 00:52:52,500
DAVID J.馬蘭：對不起，那是什麼？

1184
00:52:52,500 --> 00:52:53,150
主講人3：你傳進去的東西

1185
00:52:53,150 --> 00:52:53,570
DAVID J.馬蘭：好吧。

1186
00:52:53,570 --> 00:52:54,780
所以，你傳進去的東西

1187
00:52:54,780 --> 00:52:56,560
更一般地，它僅僅是輸入。

1188
00:52:56,560 --> 00:52:59,860
如果你在生活中寫一個函數，該函數的目的是做

1189
00:52:59,860 --> 00:53:03,290
有點不同的東西，每次你使用它，那麼唯一的辦法

1190
00:53:03,290 --> 00:53:07,710
要做到這一點真的會似乎是為它提供輸入，所以它

1191
00:53:07,710 --> 00:53:10,180
可以做不同的事情，每次輸入。

1192
00:53:10,180 --> 00:53:13,590
>> 所以，你需要指定兩件事情，當一個函數需要輸入。

1193
00:53:13,590 --> 00:53:17,240
你需要指定你想給，輸入的名稱，純粹是為了

1194
00:53:17,240 --> 00:53:20,790
自己的方便，所以，你可以參考它的功能

1195
00:53:20,790 --> 00:53:23,610
自己寫作，我在這裡的第32行。

1196
00:53:23,610 --> 00:53:27,840
但是，你還需要指定它的類型，因為C是一種編程語言

1197
00:53:27,840 --> 00:53:28,840
只需要

1198
00:53:28,840 --> 00:53:31,810
如果你想要一個變量，你必須告訴計算機

1199
00:53:31,810 --> 00:53:32,790
數據類型是，

1200
00:53:32,790 --> 00:53:35,540
在很大程度上，以便它知道多少位

1201
00:53:35,540 --> 00:53:37,230
分配給該變量。

1202
00:53:37,230 --> 00:53:38,600
因為它可能是6  - 

1203
00:53:38,600 --> 00:53:39,990
對不起，它不會是6。

1204
00:53:39,990 --> 00:53:41,050
它也可以是16。

1205
00:53:41,050 --> 00:53:41,630
它可以是8位。

1206
00:53:41,630 --> 00:53:44,410
它可以是32個，甚至64。

1207
00:53:44,410 --> 00:53:45,820
但是，計算機需要知道。

1208
00:53:45,820 --> 00:53:49,110
現在，在左邊的int代表著什麼，與此相反呢？

1209
00:53:52,825 --> 00:53:53,780
[聽不清]

1210
00:53:53,780 --> 00:53:54,570
DAVID J.馬蘭：那是什麼？

1211
00:53:54,570 --> 00:53:55,390
[聽不清]

1212
00:53:55,390 --> 00:53:57,920
DAVID J. MALAN：類型的函數，並更具體地，在

1213
00:53:57,920 --> 00:53:59,755
其輸出的類型。

1214
00:53:59,755 --> 00:54:00,220
右。

1215
00:54:00,220 --> 00:54:04,220
因此，而括號中的東西代表的輸入，如果有的話，

1216
00:54:04,220 --> 00:54:06,640
事情左邊表示其輸出端。

1217
00:54:06,640 --> 00:54:10,560
在這種情況下，增量顯然是返回一個int。

1218
00:54:10,560 --> 00:54:14,590
所以int是這個函數的返回類型。

1219
00:54:14,590 --> 00:54:16,090
>> 要返回的是什麼意思？

1220
00:54:16,090 --> 00:54:19,810
從字面上看，，使用關鍵字回報。

1221
00:54:19,810 --> 00:54:24,640
然後，如果你返回到正確的關鍵字是

1222
00:54:24,640 --> 00:54:28,340
整數，那麼這確實是符合我們所承諾的。

1223
00:54:28,340 --> 00:54:31,110
你不能做這樣的事情 - 

1224
00:54:31,110 --> 00:54:32,280
你好，世界 - 

1225
00:54:32,280 --> 00:54:33,500
因為這是一個字符串。

1226
00:54:33,500 --> 00:54:35,440
很明顯，這不是一個整數。

1227
00:54:35,440 --> 00:54:40,450
因此，在短，真的是對我們的負擔，程序員，具體為

1228
00:54:40,450 --> 00:54:44,730
我們回國，然後返回。

1229
00:54:44,730 --> 00:54:49,030
一點點，然後作出更明確的背景下 - 

1230
00:54:49,030 --> 00:54:50,080
他又出來了。

1231
00:54:50,080 --> 00:54:51,060
背景 - 

1232
00:54:51,060 --> 00:54:52,830
大驚喜，在短短的時刻。

1233
00:54:52,830 --> 00:54:57,720
這裡的背景是，現在是您的計算機的內存中，再次，

1234
00:54:57,720 --> 00:54:59,070
技嘉，2千兆字節，什麼都好。

1235
00:54:59,070 --> 00:54:59,630
也許是更重要的。

1236
00:54:59,630 --> 00:55:00,540
也許它的不足。

1237
00:55:00,540 --> 00:55:03,750
但電腦的看法有不同的部分。

1238
00:55:03,750 --> 00:55:04,860
出現下降。

1239
00:55:04,860 --> 00:55:06,020
別的東西。

1240
00:55:06,020 --> 00:55:07,540
不同的東西在中間。

1241
00:55:07,540 --> 00:55:09,300
今天，我們就開始講這個故事。

1242
00:55:09,300 --> 00:55:11,130
>> 但我們會回來到這個隨著時間的推移。

1243
00:55:11,130 --> 00:55:15,000
現在，唯一的一塊內存中，我們真正關心的是文本段

1244
00:55:15,000 --> 00:55:17,160
因為這只是代表了0和1

1245
00:55:17,160 --> 00:55:18,460
，鐺輸出。

1246
00:55:18,460 --> 00:55:21,570
所以，當你在鍵盤上像a.out的運行命令，或者雙擊

1247
00:55:21,570 --> 00:55:25,350
在Mac OS或Windows點擊一個圖標，你的程序從硬盤裝入

1248
00:55:25,350 --> 00:55:26,930
開車到RAM中。

1249
00:55:26,930 --> 00:55:30,850
它的屁股在您的計算機的RAM的頂部，可以這麼說。

1250
00:55:30,850 --> 00:55:35,470
同時，為您的程序開始運行，並在被稱為​​主

1251
00:55:35,470 --> 00:55:39,240
程序，你寫的程序微軟和蘋果寫道，任何其

1252
00:55:39,240 --> 00:55:42,930
局部變量結束了在那裡降落的底部，您的計算機的內存中。

1253
00:55:42,930 --> 00:55:46,490
但是，如果主本身調用另一個函數，變量或

1254
00:55:46,490 --> 00:55:48,340
參數，它們最終會在它的上面。

1255
00:55:48,340 --> 00:55:50,670
如果該函數調用的東西，他們最終在它上面，

1256
00:55:50,670 --> 00:55:51,840
在它上面，在它之上。

1257
00:55:51,840 --> 00:55:56,100
只有一次是執行不托盤堆疊，所以

1258
00:55:56,100 --> 00:55:58,320
說話，開始越來越低。

1259
00:55:58,320 --> 00:56:03,370
這是什麼話，概括地說，解釋了為什麼當你調用立方體 - 

1260
00:56:03,370 --> 00:56:04,660
還是你打的增量 - 

1261
00:56:04,660 --> 00:56:06,490
你在副本的價值傳遞。

1262
00:56:06,490 --> 00:56:09,840
是什麼意思形象地是，你從字面上寫

1263
00:56:09,840 --> 00:56:14,540
號1中的存儲器的另一部分，改變一個1至2，在箱子的

1264
00:56:14,540 --> 00:56:15,360
增量 - 

1265
00:56:15,360 --> 00:56:17,450
或8，在多維數據集的情況下 - 

1266
00:56:17,450 --> 00:56:21,450
然後投擲，內存只要增加或多維數據集

1267
00:56:21,450 --> 00:56:23,410
函數返回。

1268
00:56:23,410 --> 00:56:24,267
>> 問題。

1269
00:56:24,267 --> 00:56:25,517
[聽不清]

1270
00:56:28,090 --> 00:56:29,970
DAVID J.馬蘭：凡 - 全局變量中存儲的是什麼

1271
00:56:29,970 --> 00:56:32,960
目前被稱為初始化的數據和未初始化的數據。

1272
00:56:32,960 --> 00:56:35,900
區別在於，如果你有一個全局變量，並賦予它

1273
00:56:35,900 --> 00:56:39,530
立即等號的值，它結束了在頂部。

1274
00:56:39,530 --> 00:56:43,390
如果你只是說沒有價值的詮釋x分號，它最終小幅上漲

1275
00:56:43,390 --> 00:56:46,670
簡單地按照慣例，在RAM。

1276
00:56:46,670 --> 00:56:49,308
其他的問題。

1277
00:56:49,308 --> 00:56:49,750
好的。

1278
00:56:49,750 --> 00:56:53,040
>> 因此，這幅畫會回來的，因為我們變得更強大，我們能做些什麼

1279
00:56:53,040 --> 00:56:53,830
與計算機。

1280
00:56:53,830 --> 00:56:58,790
但現在，讓我們有一個簡短的介紹，特定類型的加密技術，

1281
00:56:58,790 --> 00:57:01,910
密碼學不解決世界上所有的問題，但沒有解決

1282
00:57:01,910 --> 00:57:02,480
其中的一些。

1283
00:57:02,480 --> 00:57:06,090
在這種情況下，在這裡，我們有一些所謂的密鑰加密。

1284
00:57:06,090 --> 00:57:10,430
密鑰加密，顧名思義，源於它的安全性

1285
00:57:10,430 --> 00:57:11,330
從一個秘密。

1286
00:57:11,330 --> 00:57:14,720
因此，舉例來說，如果你是在小學和你通過一個

1287
00:57:14,720 --> 00:57:18,040
小秘密情書的男孩或女孩，你破碎 - 如果你

1288
00:57:18,040 --> 00:57:20,820
想通過貫穿全場的，你可能不會寫

1289
00:57:20,820 --> 00:57:24,120
英語中的註釋，或任何你的母語，而是你

1290
00:57:24,120 --> 00:57:25,800
可以對它進行加密。

1291
00:57:25,800 --> 00:57:27,820
或者你可能只是給他們一個文本消息，這些天。

1292
00:57:27,820 --> 00:57:30,310
但你實際上可能會通過他們在教室。

1293
00:57:30,310 --> 00:57:33,820
而要做到這安全地，以這樣一種方式，您的朋友和教師

1294
00:57:33,820 --> 00:57:36,820
不知道你寫的東西，你可能會想出一個相當簡單的

1295
00:57:36,820 --> 00:57:37,800
算法 - 

1296
00:57:37,800 --> 00:57:39,290
年輕人雖然你可能是 - 

1297
00:57:39,290 --> 00:57:40,780
只是爭奪的話。

1298
00:57:40,780 --> 00:57:44,390
因此，而不是寫一個，你可能會寫B.而不是B，你可以寫

1299
00:57:44,390 --> 00:57:46,670
C.而不是C，你可能會寫D，等等。

1300
00:57:46,670 --> 00:57:50,020
或者，你能想出一個更複雜的字母翻譯

1301
00:57:50,020 --> 00:57:51,300
以不同的字母。

1302
00:57:51,300 --> 00:57:55,440
但美中不足的是男孩還是女孩，你發送此說明需要

1303
00:57:55,440 --> 00:57:56,850
知道的東西。

1304
00:57:56,850 --> 00:57:59,620
這是什麼，很明顯嗎？

1305
00:57:59,620 --> 00:58:01,400
一樣，你的秘密是什麼。

1306
00:58:01,400 --> 00:58:04,620
喜歡什麼，是AS和BS和CS和DS之間的映射？

1307
00:58:04,620 --> 00:58:08,780
難道僅僅是增加一個，可以這麼說，每一個字母去從

1308
00:58:08,780 --> 00:58:09,730
A到B，從B到C？

1309
00:58:09,730 --> 00:58:11,350
它是比這更複雜嗎？

1310
00:58:11,350 --> 00:58:16,450
所以，你和你的美眉需要有這個秘密的信息。

1311
00:58:16,450 --> 00:58:18,170
但有一個catch-22在這裡種。

1312
00:58:18,170 --> 00:58:20,760
如果這是第一次通過你這封情書

1313
00:58:20,760 --> 00:58:25,590
類的是男孩還是女孩，怎麼會知道這個秘密，甚至是嗎？

1314
00:58:25,590 --> 00:58:28,450
因此秘密密鑰加密並不能解決世界上所有的問題。

1315
00:58:28,450 --> 00:58:30,490
其實有關係，我們再回過頭來朝

1316
00:58:30,490 --> 00:58:31,370
學期結束。

1317
00:58:31,370 --> 00:58:35,970
>> 同樣，我們有沒有可能發送過 - 

1318
00:58:35,970 --> 00:58:39,453
同樣，我們大多數人不知道的人的作品，例如，在

1319
00:58:39,453 --> 00:58:40,300
Amazon.com。

1320
00:58:40,300 --> 00:58:43,130
然而，我們很多人可能買的東西在Amazon.com。

1321
00:58:43,130 --> 00:58:45,670
我們一直被教導要承擔這些電子商務

1322
00:58:45,670 --> 00:58:47,060
交易是安全的。

1323
00:58:47,060 --> 00:58:47,210
對嗎？

1324
00:58:47,210 --> 00:58:49,310
HTTPS URL可能說。

1325
00:58:49,310 --> 00:58:51,590
有可能一個愚蠢的小掛鎖圖標的地方。

1326
00:58:51,590 --> 00:58:54,680
有某種形式的加密技術保護您的信用卡信息

1327
00:58:54,680 --> 00:58:56,980
你和亞馬遜（Amazon.com）之間。

1328
00:58:56,980 --> 00:59:00,410
然而，如果密碼學需要知道一些秘密，但我不

1329
00:59:00,410 --> 00:59:03,330
知道在亞馬遜的人，而且我肯定不會安排任何形式的

1330
00:59:03,330 --> 00:59:07,350
有人在亞馬遜的秘密，我的電腦或瀏覽器這樣做呢？

1331
00:59:07,350 --> 00:59:10,100
好了，原來有其他類型的加密技術完全解決

1332
00:59:10,100 --> 00:59:10,740
那樣的問題。

1333
00:59:10,740 --> 00:59:13,610
但是今天，我們將重點放在簡單的一個，在那裡你可以安排在

1334
00:59:13,610 --> 00:59:18,480
提前知道一些秘密，如加1或一些AS和BS之間的映射。

1335
00:59:18,480 --> 00:59:20,710
>> 和加密過程一般涉及這一點。

1336
00:59:20,710 --> 00:59:23,550
你有一些簡單的文字，描繪在左。

1337
00:59:23,550 --> 00:59:26,260
您可以運行它通過某種算法或過程

1338
00:59:26,260 --> 00:59:27,670
加密。

1339
00:59:27,670 --> 00:59:31,390
也許這只是一個變成了B，B變成C。然後你就結束了

1340
00:59:31,390 --> 00:59:32,260
密文。

1341
00:59:32,260 --> 00:59:36,450
同時，一旦你的美眉接收到的秘密紙條，他或她有那麼

1342
00:59:36,450 --> 00:59:39,950
一般扭轉這種算法，從而獲得進行解密

1343
00:59:39,950 --> 00:59:41,640
備份純文本。

1344
00:59:41,640 --> 00:59:43,860
現在有物理的化身。

1345
00:59:43,860 --> 00:59:46,720
舉例來說，這是一個小秘密的解碼器環。

1346
00:59:46,720 --> 00:59:50,060
這是在這個意義上，在這裡兩個錶盤的環。

1347
00:59:50,060 --> 00:59:53,630
在這件事情的外週，有字母A到Z，

1348
00:59:53,630 --> 00:59:55,110
雖然他們以隨機順序。

1349
00:59:55,110 --> 00:59:58,410
在裡面，有一些數字，例如，

1350
00:59:58,410 --> 01:00:02,940
戒指，你可以種翻在外面，但不是內部以排隊

1351
01:00:02,940 --> 01:00:04,110
數字與字母。

1352
01:00:04,110 --> 01:00:08,290
而在剪輯你將要看到的 - 其中有些你可能已經看到24/7

1353
01:00:08,290 --> 01:00:11,120
從一部電影叫聖誕故事在聖誕節前後。

1354
01:00:11,120 --> 01:00:16,050
你會看到那個小拉爾夫是如此渴望要弄清楚什麼的小孤兒

1355
01:00:16,050 --> 01:00:19,810
安妮的秘密是他的消息了溝通，我認為，在

1356
01:00:19,810 --> 01:00:22,810
數字信息串行中形成的。

1357
01:00:22,810 --> 01:00:26,760
你有積累的小卡片，來到

1358
01:00:26,760 --> 01:00:27,480
在麥片盒。

1359
01:00:27,480 --> 01:00:28,320
你必須郵寄他們。

1360
01:00:28,320 --> 01:00:31,060
你有秘密的解碼器環，所以，你終於可以圖

1361
01:00:31,060 --> 01:00:34,190
字母和數字之間的映射是什麼，

1362
01:00:34,190 --> 01:00:35,420
或字母和字母。

1363
01:00:35,420 --> 01:00:39,790
所以，我給你這個短片從一個聖誕節的故事，以激勵的pset 2

1364
01:00:39,790 --> 01:00:42,340
我們的討論，在某一時刻的數組。

1365
01:00:42,340 --> 01:00:43,773
所以在這裡我們拉爾夫。

1366
01:00:43,773 --> 01:00:44,126
>> [視頻回放]

1367
01:00:44,126 --> 01:00:47,470
無論是向所有人拉爾夫·帕克委任一個

1368
01:00:47,470 --> 01:00:50,690
的小孤兒安妮秘密圈的成員，並有權

1369
01:00:50,690 --> 01:00:53,500
榮譽和利益發生於此。

1370
01:00:53,500 --> 01:00:56,040
簽名，小孤兒安妮。

1371
01:00:56,040 --> 01:00:58,730
會簽，皮埃爾·安德烈！

1372
01:00:58,730 --> 01:01:00,150
在油墨中！

1373
01:01:00,150 --> 01:01:02,910
榮譽和利益，已經9歲。

1374
01:01:09,970 --> 01:01:10,730
來吧，讓我們用它。

1375
01:01:10,730 --> 01:01:15,000
我並不需要所有的爵士樂關於走私和海盜。

1376
01:01:15,000 --> 01:01:17,624
 - 聽著明天晚上的結論冒險的黑色

1377
01:01:17,624 --> 01:01:19,710
海盜船。

1378
01:01:19,710 --> 01:01:23,380
現在，是時候為你的成員安妮的秘密消息

1379
01:01:23,380 --> 01:01:25,670
秘密圈。

1380
01:01:25,670 --> 01:01:30,260
請記住，孩子，只有安妮的秘密圈的成員可以解碼

1381
01:01:30,260 --> 01:01:31,660
安妮的秘密消息。

1382
01:01:31,660 --> 01:01:36,230
請記住，安妮得靠你了。

1383
01:01:36,230 --> 01:01:38,720
將你的腳B2。

1384
01:01:38,720 --> 01:01:41,040
這裡的消息。

1385
01:01:41,040 --> 01:01:42,470
12，11  - 

1386
01:01:42,470 --> 01:01:46,000
我在我的第一個秘密的會議。

1387
01:01:46,000 --> 01:01:49,440
-14，11，18，16  - 

1388
01:01:49,440 --> 01:01:51,700
皮埃爾是在今晚很大的發言權。

1389
01:01:51,700 --> 01:01:54,890
我可以告訴大家，今晚的消息是很重要的。

1390
01:01:54,890 --> 01:01:56,750
-3，25。

1391
01:01:56,750 --> 01:01:58,590
這是一個消息，安妮自己。

1392
01:01:58,590 --> 01:01:59,840
記住，千萬不要告訴任何人。

1393
01:02:04,570 --> 01:02:08,750
-90秒後，我在一個房間裡唯一的一個九歲的孩子

1394
01:02:08,750 --> 01:02:12,980
可以坐在隱私和解碼。

1395
01:02:12,980 --> 01:02:17,130
啊哈，B.我去到下一個。

1396
01:02:17,130 --> 01:02:20,330
E.第一個字是。

1397
01:02:20,330 --> 01:02:22,670
S.它現在更容易。

1398
01:02:22,670 --> 01:02:24,590
U.

1399
01:02:24,590 --> 01:02:26,510
哦，來吧，拉爾夫。

1400
01:02:26,510 --> 01:02:28,430
我得走了。

1401
01:02:28,430 --> 01:02:30,350
 - 我是正確的，媽媽。

1402
01:02:30,350 --> 01:02:33,720
 - 嘖嘖奇才。

1403
01:02:33,720 --> 01:02:38,270
-T，O.一定要。

1404
01:02:38,270 --> 01:02:40,000
要確保的是什麼？

1405
01:02:40,000 --> 01:02:42,105
小孤兒安妮想說的是什麼呢？

1406
01:02:42,105 --> 01:02:43,095
要確保的是什麼？

1407
01:02:43,095 --> 01:02:43,590
 - 拉爾夫！

1408
01:02:43,590 --> 01:02:44,580
蘭迪得走了。

1409
01:02:44,580 --> 01:02:45,570
請你出來嗎？

1410
01:02:45,570 --> 01:02:46,560
好吧，馬。

1411
01:02:46,560 --> 01:02:48,540
我馬上就出來。

1412
01:02:48,540 --> 01:02:50,580
我越來越近了。

1413
01:02:50,580 --> 01:02:52,550
張力是可怕的。

1414
01:02:52,550 --> 01:02:53,355
它是什麼？

1415
01:02:53,355 --> 01:02:56,315
這個星球的命運懸而未決。

1416
01:02:56,315 --> 01:02:56,790
 - 拉爾夫！

1417
01:02:56,790 --> 01:02:59,165
蘭迪得走了。

1418
01:02:59,165 --> 01:03:02,310
 - 我就出來，哭出聲來。

1419
01:03:02,310 --> 01:03:04,000
哎呀，幾乎沒有。

1420
01:03:04,000 --> 01:03:05,180
我的手指飛了起來。

1421
01:03:05,180 --> 01:03:07,150
我的心是鋼的陷阱。

1422
01:03:07,150 --> 01:03:08,790
每一個毛孔振動。

1423
01:03:08,790 --> 01:03:10,040
這幾乎是清楚的。

1424
01:03:10,040 --> 01:03:13,400
是的，是的，是的，是的。

1425
01:03:13,400 --> 01:03:18,960
要確保喝阿華田。

1426
01:03:18,960 --> 01:03:20,210
阿華田？

1427
01:03:24,010 --> 01:03:25,260
照出的商業？

1428
01:03:28,200 --> 01:03:29,640
狗娘養的。

1429
01:03:29,640 --> 01:03:33,340
[END視頻播放]

1430
01:03:33,340 --> 01:03:36,040
>> DAVID J.馬蘭：因此，我們有加密技術。

1431
01:03:36,040 --> 01:03:39,670
因此，如何在一台計算機，我們可以去實現，或者

1432
01:03:39,670 --> 01:03:40,950
代表這樣的事情嗎？

1433
01:03:40,950 --> 01:03:44,430
好了，我們需要一種方式表達自己一點更靈活

1434
01:03:44,430 --> 01:03:46,420
因此，我們的變量不允許的。

1435
01:03:46,420 --> 01:03:47,370
我們已經有整數。

1436
01:03:47,370 --> 01:03:48,380
我們已經有個字符。

1437
01:03:48,380 --> 01:03:50,790
我們的花車和雙打和其他幾個人。

1438
01:03:50,790 --> 01:03:55,050
但是，這些都是個人的內存不真的讓我們

1439
01:03:55,050 --> 01:03:58,010
表達的東西，如單詞和句子和短語。

1440
01:03:58,010 --> 01:04:00,200
事實上，我們叫這樣的事情串。

1441
01:04:00,200 --> 01:04:03,650
但我們所承諾的，這是真的只是一個簡化的CS50

1442
01:04:03,650 --> 01:04:07,020
庫，我們打算剝離回來。

1443
01:04:07,020 --> 01:04:08,970
>> 讓我們開始做，在這裡。

1444
01:04:08,970 --> 01:04:11,130
讓我繼續前進，打開一個文件 - 

1445
01:04:11,130 --> 01:04:13,770
所有這些文件都可以像往常一樣在網上 - 

1446
01:04:13,770 --> 01:04:19,120
稱為array.c解決的問題無關字符串，但描繪一個

1447
01:04:19,120 --> 01:04:23,040
的圖片在這裡，我們怎麼可能使用的東西稱為數組。

1448
01:04:23,040 --> 01:04:25,530
數組是一種數據類型。

1449
01:04:25,530 --> 01:04:31,320
這是一個類型的變量，各種各樣的，有多個較小的數據類型

1450
01:04:31,320 --> 01:04:34,150
它裡面的背靠背背靠背。

1451
01:04:34,150 --> 01:04:37,700
因此，舉例來說，如果我們要編寫一個小程序，讓您的

1452
01:04:37,700 --> 01:04:42,110
測驗平均為一療程，有兩個小測驗，你可以很容易像50

1453
01:04:42,110 --> 01:04:45,170
編寫這個程序 - 甚至在一些上週的材料 - 

1454
01:04:45,170 --> 01:04:47,770
通過調用getInt和一對夫婦的變量。

1455
01:04:47,770 --> 01:04:51,920
詮釋quiz1，詮釋quiz2，這是很簡單的。

1456
01:04:51,920 --> 01:04:55,930
這也許是10，20行的代碼，最大，實施程序，要求

1457
01:04:55,930 --> 01:05:01,170
兩個測驗的分數，然後計算它們的平均用戶通過將它們添加

1458
01:05:01,170 --> 01:05:03,850
在一起，除以二，然後打印結果。

1459
01:05:03,850 --> 01:05:06,380
我們或許可以做到這一點很容易現在，

1460
01:05:06,380 --> 01:05:07,510
有些分鐘數。

1461
01:05:07,510 --> 01:05:11,005
>> 但問題是，假設有50有三個測驗或4。

1462
01:05:11,005 --> 01:05:13,510
假設你想使用相同的程序，有一類

1463
01:05:13,510 --> 01:05:14,850
每週測驗。

1464
01:05:14,850 --> 01:05:16,610
想想一個類時，每週測驗。

1465
01:05:16,610 --> 01:05:20,610
如果有像在一個學期16週，現在你有16個變量 - 

1466
01:05:20,610 --> 01:05:24,270
quiz1，詮釋quiz2，詮釋第quiz3，詮釋quiz4。

1467
01:05:24,270 --> 01:05:27,560
只要你開始看到這種冗餘，複製和粘貼

1468
01:05:27,560 --> 01:05:31,390
的代碼，它應該讓你希望有一個更好的辦法。

1469
01:05:31,390 --> 01:05:33,930
幸運的是，因為數組。

1470
01:05:33,930 --> 01:05:34,980
因此，讓我們做到這一點。

1471
01:05:34,980 --> 01:05:38,430
首先，讓我介紹一個非常簡單的事情，我們到目前為止還沒有使用，

1472
01:05:38,430 --> 01:05:40,140
但偶爾你會看到它的代碼。

1473
01:05:40,140 --> 01:05:42,360
這就是通常被稱為一個常數。

1474
01:05:42,360 --> 01:05:45,790
所以在這個意義上，這個值不會改變，它是一個常數。

1475
01:05:45,790 --> 01:05:49,210
創建一個常量時，是使用全部大寫的人的約定

1476
01:05:49,210 --> 01:05:51,940
字母，只是，使其真正站出來，在你的代碼。

1477
01:05:51,940 --> 01:05:55,960
特殊的關鍵字，您使用的C＃定義。

1478
01:05:55,960 --> 01:06:00,250
所以，如果你說的，然後是一個空格，然後你想使用這個詞，

1479
01:06:00,250 --> 01:06:03,260
常量的名稱，然後該常數的值。

1480
01:06:03,260 --> 01:06:06,180
因此，通知，這從一個變量分配的東西是不同的。

1481
01:06:06,180 --> 01:06:07,020
有沒有等號。

1482
01:06:07,020 --> 01:06:08,240
有沒有分號。

1483
01:06:08,240 --> 01:06:11,410
這是通常被稱為預處理器指令，但更多的

1484
01:06:11,410 --> 01:06:12,210
另一個時間。

1485
01:06:12,210 --> 01:06:18,540
>> 就目前而言，這將創建一個不變的值，稱為測驗的實際

1486
01:06:18,540 --> 01:06:19,940
的數值是2。

1487
01:06:19,940 --> 01:06:24,020
因此，任何地方，你看到測驗，測驗，測驗，這是整個文件

1488
01:06:24,020 --> 01:06:25,410
只是數字2。

1489
01:06:25,410 --> 01:06:28,100
現在，如果我看主要現在，讓我們來看看它是如何工作的。

1490
01:06:28,100 --> 01:06:29,500
起初，這看起來有點神秘。

1491
01:06:29,500 --> 01:06:31,340
但它是從第一個星期，所有的東西。

1492
01:06:31,340 --> 01:06:32,710
詢問用戶的等級。

1493
01:06:32,710 --> 01:06:33,630
如何才能做到這一點呢？

1494
01:06:33,630 --> 01:06:35,470
那麼，在第22行 - 

1495
01:06:35,470 --> 01:06:37,210
這是真的的多汁的一部分 - 

1496
01:06:37,210 --> 01:06:40,960
我聲明了一個浮動，但是不只是一個單一的浮動。

1497
01:06:40,960 --> 01:06:44,620
我聲明，而是一個浮點值數組。

1498
01:06:44,620 --> 01:06:49,100
這個變量將被稱為檔次，這裡暗示。

1499
01:06:49,100 --> 01:06:53,080
但唯一的一塊新的語法，那麼這些方括號中，其實

1500
01:06:53,080 --> 01:06:59,350
我已經說過了浮動等級，然後打開支架，然後一個數字。

1501
01:06:59,350 --> 01:07:02,460
請注意，如果這是一個常數，這是像我們這樣做。

1502
01:07:02,460 --> 01:07:06,890
這意味著哎電腦，給我兩個花車，讓我們共同呼籲

1503
01:07:06,890 --> 01:07:08,220
他們的成績。

1504
01:07:08,220 --> 01:07:11,920
這是更繁瑣的過程，這樣的對比。

1505
01:07:11,920 --> 01:07:15,850
浮法級1，浮動grade2“，等等。

1506
01:07:15,850 --> 01:07:20,010
因此，一個陣列，使我們能夠實現這個想法，但要少得多亂七八糟，在

1507
01:07:20,010 --> 01:07:24,630
這樣的方式，我們可以寫一行代碼，而不是，比方說，一個16 16

1508
01:07:24,630 --> 01:07:25,740
週的學期。

1509
01:07:25,740 --> 01:07:29,950
所以我不想硬編碼，因為，如果你認為現在

1510
01:07:29,950 --> 01:07:34,160
假設明年邏輯 -  CS50更改為3，而不是測驗。

1511
01:07:34,160 --> 01:07:35,510
我有2號。

1512
01:07:35,510 --> 01:07:36,600
在這裡，我有2號。

1513
01:07:36,600 --> 01:07:37,580
在這裡，我有2號。

1514
01:07:37,580 --> 01:07:38,560
在這裡，我有2號。

1515
01:07:38,560 --> 01:07:43,180
它變得非常乏味，很容易搞砸了，不小心改變

1516
01:07:43,180 --> 01:07:47,690
一個值，錯過了一些其他值2。

1517
01:07:47,690 --> 01:07:52,460
所以我要這個距離，而不是抽象的，並使用此常量，其

1518
01:07:52,460 --> 01:07:54,120
顧名思義，永遠不會改變。

1519
01:07:54,120 --> 01:07:57,710
而現在，無論我們有不同的測驗今年或明年，我

1520
01:07:57,710 --> 01:08:01,210
只需要改變它在一個地方，在這裡頂部。

1521
01:08:01,210 --> 01:08:02,720
>> 所以這是所有不變的是。

1522
01:08:02,720 --> 01:08:08,680
同時，新概念的特點是一個數組。

1523
01:08:08,680 --> 01:08:14,660
因此，在方括號給我這麼多的花車，讓我集體

1524
01:08:14,660 --> 01:08:16,630
他們成績在這裡。

1525
01:08:16,630 --> 01:08:17,990
所以，現在讓我們來看看我會做什麼。

1526
01:08:17,990 --> 01:08:20,359
在這裡，在第24行是一個for循環的開始。

1527
01:08:20,359 --> 01:08:22,260
這實在是沒有任何幻想。

1528
01:08:22,260 --> 01:08:25,060
這只是使用測驗，而不是硬編碼的數字。

1529
01:08:25,060 --> 01:08:27,790
但也有是沒有從上週智力有不同的。

1530
01:08:27,790 --> 01:08:29,040
這僅僅是printf的。

1531
01:08:29,040 --> 01:08:35,490
因此我們知道printf（“小考數的％d％d”的），因為我只是想打印出來給我測驗

1532
01:08:35,490 --> 01:08:38,050
數之一，兩個，然後兩個兩個。

1533
01:08:38,050 --> 01:08:39,850
因此，這純粹是一種審美的東西。

1534
01:08:39,850 --> 01:08:42,500
但是，現在最有趣的部分是在第27行。

1535
01:08:42,500 --> 01:08:48,310
為了填補的兩個佔位符的浮點

1536
01:08:48,310 --> 01:08:51,029
值，你再使用方括號。

1537
01:08:51,029 --> 01:08:55,620
在這種情況下，我使用的是我，因為for循環已開始與我等於

1538
01:08:55,620 --> 01:08:57,560
什麼樣的價值，顯然是嗎？

1539
01:08:57,560 --> 01:08:58,279
0。

1540
01:08:58,279 --> 01:09:01,350
>> 因此，在這個循環的第一次迭代，這是因為雖然我

1541
01:09:01,350 --> 01:09:02,689
寫在代碼中。

1542
01:09:02,689 --> 01:09:05,580
但在這個循環中的第二次迭代，這是因為雖然我

1543
01:09:05,580 --> 01:09:07,750
寫在我的代碼。

1544
01:09:07,750 --> 01:09:10,750
但事實上，我使用一個變量是完美的，因為，正如其名

1545
01:09:10,750 --> 01:09:14,300
表明，它改變它的值在每次迭代。

1546
01:09:14,300 --> 01:09:17,370
所以我填充這個數組一個地方的時間。

1547
01:09:17,370 --> 01:09:18,910
陣列看看這是什麼樣的呢？

1548
01:09:18,910 --> 01:09:21,430
好了，我之所以得出這個超級簡單的屏幕上的矩形

1549
01:09:21,430 --> 01:09:23,350
之前是因為這個原因。

1550
01:09:23,350 --> 01:09:27,279
數組是另一塊內存的內存塊，

1551
01:09:27,279 --> 01:09:30,109
其次由另一個的內存塊，等等。

1552
01:09:30,109 --> 01:09:35,260
所以，如果我的數組大小​​為2，在這種情況下，在這裡，所有我會做的

1553
01:09:35,260 --> 01:09:37,590
打字在我測驗成績，喜歡上了這裡。

1554
01:09:37,590 --> 01:09:39,430
我就這一個。

1555
01:09:39,430 --> 01:09:42,020
然後，我得到了99就這一個。

1556
01:09:42,020 --> 01:09:46,040
該內存可能甚至沒有使用，因為我只問

1557
01:09:46,040 --> 01:09:48,689
電腦的數組大小​​為2。

1558
01:09:48,689 --> 01:09:50,180
這些廣場仍然存在。

1559
01:09:50,180 --> 01:09:50,340
對嗎？

1560
01:09:50,340 --> 01:09:52,500
你還有2 GB的RAM，即使你只

1561
01:09:52,500 --> 01:09:53,979
兩個浮點的要求。

1562
01:09:53,979 --> 01:09:58,710
因此，陣列背後的想法是，計算機只需要一個內存塊的

1563
01:09:58,710 --> 01:10:03,230
然後分給更小的碎片背靠背背靠背。

1564
01:10:03,230 --> 01:10:04,740
因此，這是所有的數組。

1565
01:10:04,740 --> 01:10:09,080
這是一個連續的內存塊，這裡面你可以把東西。

1566
01:10:09,080 --> 01:10:12,400
>> 現在發生這種情況，然後做一些無聊的算術。

1567
01:10:12,400 --> 01:10:16,170
如果我向下滾動在這裡，這是我然後遍歷數組中。

1568
01:10:16,170 --> 01:10:19,410
我拿出所有的數組中的值的總和。

1569
01:10:19,410 --> 01:10:22,390
然後，我在這裡使用ROUND函數實際做的

1570
01:10:22,390 --> 01:10:23,940
總結除以測驗。

1571
01:10:23,940 --> 01:10:27,450
但是，讓我揮揮手，作為足夠的算術現在的排序。

1572
01:10:27,450 --> 01:10:30,010
但是，所有為我做的最終計算平均值。

1573
01:10:30,010 --> 01:10:33,640
所以第一次測驗加第二個測驗，再除以2，然後打印

1574
01:10:33,640 --> 01:10:34,700
它作為一個int。

1575
01:10:34,700 --> 01:10:39,030
>> 但現在，讓我們叫字符串轉換到一個不同的例子，

1576
01:10:39,030 --> 01:10:42,370
它描繪了一個類似的畫面，但使用​​字符串。

1577
01:10:42,370 --> 01:10:45,550
讓我繼續前進，簡化這只是一個瞬間。

1578
01:10:45,550 --> 01:10:48,340
現在原諒縮進。

1579
01:10:48,340 --> 01:10:52,280
請注意，在這個例子中的第19行，我收到了來自用戶的字符串。

1580
01:10:52,280 --> 01:10:55,780
但是請注意，我在22日線下做。

1581
01:10:55,780 --> 01:11:00,260
實際上，我遍歷從我 - 這是一個新的伎倆 - 

1582
01:11:00,260 --> 01:11:02,730
strlen的字符串的長度。

1583
01:11:02,730 --> 01:11:07,010
這是一個與C的功能，如果你傳遞一個字符串，它告訴

1584
01:11:07,010 --> 01:11:08,950
你有多少個字符在該字符串中。

1585
01:11:08,950 --> 01:11:09,440
這就是全部。

1586
01:11:09,440 --> 01:11:12,520
事實上，它是strlen的字符串的長度，而不是僅僅是因為它的

1587
01:11:12,520 --> 01:11:13,040
更加簡潔。

1588
01:11:13,040 --> 01:11:17,100
30年前，人們喜歡寫東西盡量簡潔。

1589
01:11:17,100 --> 01:11:19,080
因此，我們已經把該公約。

1590
01:11:19,080 --> 01:11:21,730
我+ +只是意味著我在每次迭代中增加。

1591
01:11:21,730 --> 01:11:24,310
而現在注意到這一點，這是非常有趣的。

1592
01:11:24,310 --> 01:11:28,730
因此，在第24行，我說電腦，給我一個字符，8

1593
01:11:28,730 --> 01:11:30,770
位，並稱之為C。

1594
01:11:30,770 --> 01:11:35,370
不過這到底是上右手邊說？

1595
01:11:35,370 --> 01:11:38,150
在英語中，什麼代表什麼呢？

1596
01:11:38,150 --> 01:11:40,070
[聽不清]

1597
01:11:40,070 --> 01:11:40,490
DAVID J.馬蘭：沒錯。

1598
01:11:40,490 --> 01:11:42,390
給我的第一個字符數組中的。

1599
01:11:42,390 --> 01:11:45,400
或更一般地，給我的陣列中的第i個字符。

1600
01:11:45,400 --> 01:11:48,230
意識到這是重要的，現在，計算機科學家，我們實際上

1601
01:11:48,230 --> 01:11:49,330
從0開始計數。

1602
01:11:49,330 --> 01:11:51,290
你不擁有自由裁量權，現在開始這樣做。

1603
01:11:51,290 --> 01:11:54,580
現在，你必須按照電腦的期望和行為

1604
01:11:54,580 --> 01:11:58,010
從0開始計算，因為[0]將是第一

1605
01:11:58,010 --> 01:11:59,670
字符串中的字符。

1606
01:11:59,670 --> 01:12:01,320
[1]將是第二個。

1607
01:12:01,320 --> 01:12:03,610
[2]將是第三個，等等。

1608
01:12:03,610 --> 01:12:08,840
所以，如果我編譯這個程序 - 這是，再次字符串。

1609
01:12:08,840 --> 01:12:11,040
>> 所以字符串。

1610
01:12:11,040 --> 01:12:16,730
現在，我在我的終端窗口中執行字符串。

1611
01:12:16,730 --> 01:12:19,180
它在等待輸入，所以我要輸入，就說，大衛。

1612
01:12:19,180 --> 01:12:20,080
輸入。

1613
01:12:20,080 --> 01:12:23,350
而現在它打印DAVID在不同線路上，因為

1614
01:12:23,350 --> 01:12:24,430
請注意我在做什麼。

1615
01:12:24,430 --> 01:12:27,510
我一次打印一個字符。

1616
01:12:27,510 --> 01:12:29,100
現在，我們將進入今天。

1617
01:12:29,100 --> 01:12:31,610
但我刪除了剛才在這裡檢查。

1618
01:12:31,610 --> 01:12:36,310
事實證明，如果用戶出現異常，對抗性的，或只是

1619
01:12:36,310 --> 01:12:41,780
混淆，實際上，你可以不給一些長度字符串。

1620
01:12:41,780 --> 01:12:43,640
如果你按錯鍵盤上的鍵，你可以給

1621
01:12:43,640 --> 01:12:44,390
沒有在所有的字符串。

1622
01:12:44,390 --> 01:12:47,790
或者，如果你是惡意的，你可以嘗試將其粘貼在一千兆字節的價值的

1623
01:12:47,790 --> 01:12:49,380
的文章，以填補這個字符串。

1624
01:12:49,380 --> 01:12:52,060
如果計算機運行內存，事實證明，我們將

1625
01:12:52,060 --> 01:12:54,310
這個特殊的值稱為空。

1626
01:12:54,310 --> 01:12:57,550
因此，就目前而言，只是知道有這個特殊的值稱為空

1627
01:12:57,550 --> 01:13:01,000
讓我們來檢查時，我們的記憶，在其他的事情。

1628
01:13:01,000 --> 01:13:07,330
>> 但是，如果我現在打開字符串，請注意區別就在這裡。

1629
01:13:07,330 --> 01:13:09,760
看到一個與字符串的區別就在這裡。

1630
01:13:09,760 --> 01:13:13,260
對於字符串，這個for循環是一個有點不同。

1631
01:13:13,260 --> 01:13:16,350
讓我刪除空值，這樣我們就可以談論其他時間的。

1632
01:13:16,350 --> 01:13:18,460
但是，什麼是不同的for循環？

1633
01:13:21,580 --> 01:13:23,160
我可以回到前面的例子。

1634
01:13:23,160 --> 01:13:24,800
所以這是第二版。

1635
01:13:24,800 --> 01:13:27,020
這是一個版本。

1636
01:13:27,020 --> 01:13:31,935
一，二，一兩個。

1637
01:13:35,030 --> 01:13:38,240
因此，strlen的電話是在哪裡呢？

1638
01:13:38,240 --> 01:13:40,420
這是在for循環的第一部分。

1639
01:13:40,420 --> 01:13:43,060
任何想法，為什麼我這樣做？

1640
01:13:43,060 --> 01:13:43,690
是啊。

1641
01:13:43,690 --> 01:13:46,010
[聽不清]

1642
01:13:46,010 --> 01:13:47,630
DAVID J.馬蘭：所以我們不會每一次調用該函數。

1643
01:13:47,630 --> 01:13:48,040
沒錯。

1644
01:13:48,040 --> 01:13:50,350
回想一下，他們是超級簡單的for循環，一旦你

1645
01:13:50,350 --> 01:13:52,180
明白，這是初始化，

1646
01:13:52,180 --> 01:13:53,330
條件，和更新。

1647
01:13:53,330 --> 01:13:55,430
的問題是，對每個條件發生

1648
01:13:55,430 --> 01:13:56,600
循環的迭代。

1649
01:13:56,600 --> 01:13:59,930
因此，在這個例子中，什麼是壞的事實

1650
01:13:59,930 --> 01:14:03,500
這是我的條件嗎？

1651
01:14:03,500 --> 01:14:05,920
你調用strlen再，再而三。

1652
01:14:05,920 --> 01:14:08,990
但是，一旦我輸入的國寶，該字符串的長度是5個。

1653
01:14:08,990 --> 01:14:11,560
它不會改變，因為在每次迭代循環

1654
01:14:11,560 --> 01:14:15,560
字符串仍然是D-A-V-I-D。所以這是一個暗示了這是怎麼回事成為

1655
01:14:15,560 --> 01:14:19,650
越來越重要思想的設計決策， - 只是不

1656
01:14:19,650 --> 01:14:21,640
使計算機做不必要的工作。

1657
01:14:21,640 --> 01:14:25,630
>> 現在，正如pset的，PSET 2標準版先睹為快

1658
01:14:25,630 --> 01:14:28,850
要挑戰你真正落實一定數量的密碼，一些

1659
01:14:28,850 --> 01:14:32,650
數的加密算法，這樣就可以加密和解密

1660
01:14:32,650 --> 01:14:35,530
秘密消息，就像一個拉爾夫解碼。

1661
01:14:35,530 --> 01:14:38,720
在黑客版的pset 2，我們要去遠一點。

1662
01:14:38,720 --> 01:14:42,010
我們將交給您的文件，其中包含一個實際的計算機系統

1663
01:14:42,010 --> 01:14:45,690
一大堆的用戶名和加密的密碼，和面臨的挑戰

1664
01:14:45,690 --> 01:14:49,110
為黑客版將是破解這些密碼和數字

1665
01:14:49,110 --> 01:14:53,060
出了什麼加密或什麼秘密被用於實際

1666
01:14:53,060 --> 01:14:55,080
產生這些密碼。

1667
01:14:55,080 --> 01:14:58,360
我們要做到這一點，使用一個新的功能，在這裡我給的C

1668
01:14:58,360 --> 01:15:02,200
你只是一個演示，被稱為命令行參數。

1669
01:15:02,200 --> 01:15:05,930
>> 因此，原來，你們有些人可能已經看到在部分或教科書中，

1670
01:15:05,930 --> 01:15:09,850
主並不總是括號中是無效的。

1671
01:15:09,850 --> 01:15:14,060
事實證明，主也可以這樣寫，有兩個參數，

1672
01:15:14,060 --> 01:15:19,690
argc和argv，argc是的話，你輸入後數

1673
01:15:19,690 --> 01:15:21,940
在命令行程序的名稱。

1674
01:15:21,940 --> 01:15:24,550
而argv是實際的話。

1675
01:15:24,550 --> 01:15:29,470
的方括號，顯然，argv是一個數組。

1676
01:15:29,470 --> 01:15:33,720
這將是一個字符串後的字符串後，內存中的字符串。

1677
01:15:33,720 --> 01:15:36,170
所以，我們要能夠做到的，開始的pset 2，

1678
01:15:36,170 --> 01:15:37,310
這樣的事情。

1679
01:15:37,310 --> 01:15:42,450
如果我argv1，這是一個例子，我們會回來（星期一）運行

1680
01:15:42,450 --> 01:15:45,180
，請注意，它似乎並沒有做任何事情。

1681
01:15:45,180 --> 01:15:47,050
它只是打印出自己的名字。

1682
01:15:47,050 --> 01:15:53,220
但是，如果我說再見類，請注意，這個方案顯然迭代

1683
01:15:53,220 --> 01:15:57,030
在每一個的話，在提示符下輸入。

1684
01:15:57,030 --> 01:16:02,050
和手段，我們將獲得用戶的話，

1685
01:16:02,050 --> 01:16:06,780
在提示符下輸入是通過改變為主，本週末開始，從int

1686
01:16:06,780 --> 01:16:10,710
主要（無效），INT主（ARGC ARGV）。

1687
01:16:10,710 --> 01:16:13,700
因此，將要出生的命令行參數。

1688
01:16:13,700 --> 01:16:17,210
而一旦你得到真正的成熟，你就可以寫

1689
01:16:17,210 --> 01:16:21,370
很迷幻的程序，如這一個在這裡，這超出

1690
01:16:21,370 --> 01:16:25,520
我們已經做了一些功能迄今為止，所有功能相當強大。

1691
01:16:25,520 --> 01:16:27,330
>> 因此，我們將離開這個在屏幕上。

1692
01:16:27,330 --> 01:16:29,160
我們星期一見。