1
00:00:00,000 --> 00:00:03,944
>> [音樂播放]

2
00:00:03,944 --> 00:00:10,732

3
00:00:10,732 --> 00:00:11,690
DAVID馬蘭：好的。

4
00:00:11,690 --> 00:00:14,674
這是CS50，這
是2週結束。

5
00:00:14,674 --> 00:00:16,840
我很抱歉，我不能
那裡與你們的今天，

6
00:00:16,840 --> 00:00:18,300
但你在非常良好的手中。

7
00:00:18,300 --> 00:00:21,710
請允許我介紹
CS50自己的羅布·鮑登。

8
00:00:21,710 --> 00:00:29,106

9
00:00:29,106 --> 00:00:31,730
羅伯BOWDEN：當然，那
我們必須做出這樣的事實樂趣

10
00:00:31,730 --> 00:00:36,820
他給我們送來一個垂直
視頻和顯示此。

11
00:00:36,820 --> 00:00:38,320
>> [視頻回放]

12
00:00:38,320 --> 00:00:39,820
>> [音樂播放]

13
00:00:39,820 --> 00:00:42,350
>> [腳步聲]

14
00:00:42,350 --> 00:00:44,730
>>  - 此視頻也沒有
要看看這種方式。

15
00:00:44,730 --> 00:00:46,570
這本來是可以避免的。

16
00:00:46,570 --> 00:00:49,070
說不垂直視頻。

17
00:00:49,070 --> 00:00:53,310
>>  - 垂直視頻發生在你
把你的相機走錯了路。

18
00:00:53,310 --> 00:00:55,880
您的視頻將結束
看起來像廢話。

19
00:00:55,880 --> 00:00:57,650
>>  -  [咕嚕咕嚕]

20
00:00:57,650 --> 00:01:02,240
>>  - 有越來越多的人沉迷
每天做垂直視頻。

21
00:01:02,240 --> 00:01:06,240
它不開裂或沒有，
但它仍然是非常糟糕的。

22
00:01:06,240 --> 00:01:10,410
有兩種不同類型的
人誰是患有VVS。

23
00:01:10,410 --> 00:01:14,160
第一組對待
視頻拍攝他們的照片一樣。

24
00:01:14,160 --> 00:01:15,850
他們並不意味著任何傷害。

25
00:01:15,850 --> 00:01:19,180
他們只是不明白，
而你可以把圖片，

26
00:01:19,180 --> 00:01:20,880
你不能真正把一個視頻。

27
00:01:20,880 --> 00:01:21,880
>> [CRASH]

28
00:01:21,880 --> 00:01:23,460
>>  -  [猴聲音]

29
00:01:23,460 --> 00:01:27,540
>> -The另一組是人
誰不給[嗶]。

30
00:01:27,540 --> 00:01:31,090
>>  - 垂直視頻綜合症是危險的。

31
00:01:31,090 --> 00:01:34,120
動態影像有
一貫水平。

32
00:01:34,120 --> 00:01:35,990
電視水平。

33
00:01:35,990 --> 00:01:38,380
電腦屏幕是水平的。

34
00:01:38,380 --> 00:01:41,580
群眾的眼睛是水平的。

35
00:01:41,580 --> 00:01:45,170
我們不建
觀看垂直視頻。

36
00:01:45,170 --> 00:01:47,600
>>  - 我愛垂直視頻。

37
00:01:47,600 --> 00:01:50,410
>> -Nobody在乎你。

38
00:01:50,410 --> 00:01:53,340
>>  - 如果這個問題的
任其發展，你太

39
00:01:53,340 --> 00:01:57,650
將開始顯示四個視頻
在一次只是為了節省帶寬。

40
00:01:57,650 --> 00:02:02,400
>> -Letterboxed垂直視頻會
是一個郵票大小。

41
00:02:02,400 --> 00:02:04,920
>>  - 和它會到處蔓延。

42
00:02:04,920 --> 00:02:07,670
電影屏幕有
一貫水平。

43
00:02:07,670 --> 00:02:11,200
如果垂直視頻成為
接受，電影院

44
00:02:11,200 --> 00:02:13,930
必須是又高又瘦。

45
00:02:13,930 --> 00:02:17,710
>>  - 和所有的電影院會
必須讓拆掉重建。

46
00:02:17,710 --> 00:02:22,090
而到了時候，他們被重建，
米拉庫尼斯將是又老又醜。

47
00:02:22,090 --> 00:02:24,342
>> -Birds會撞到他們死。

48
00:02:24,342 --> 00:02:26,530
>> -We'll都得到僵
脖子是仰視。

49
00:02:26,530 --> 00:02:29,800
>>  - 和沒有人會坐在
前排再次。

50
00:02:29,800 --> 00:02:37,170
>> -George盧卡斯將重新發布之星
戰爭again--瘦版。

51
00:02:37,170 --> 00:02:41,860
>>  - 我從來沒有真正能夠告訴
我想告訴的故事。

52
00:02:41,860 --> 00:02:46,030
這是一個偉大的機會，我
試驗的新技術。

53
00:02:46,030 --> 00:02:48,150
>> -You're一個混蛋。

54
00:02:48,150 --> 00:02:54,430
>> -Every時間移動裝置是用來
錄製視頻，誘惑是存在的。

55
00:02:54,430 --> 00:02:56,370
只是說沒有。

56
00:02:56,370 --> 00:03:00,116
說不喬治·盧卡斯。

57
00:03:00,116 --> 00:03:04,062
說不老蜜拉庫妮絲。

58
00:03:04,062 --> 00:03:06,600
說不垂直視頻。

59
00:03:06,600 --> 00:03:12,511
>> -and如果你看到有人做出來，說，
“你沒有拍攝的正確的虛！”

60
00:03:12,511 --> 00:03:15,433
>> [音樂播放]

61
00:03:15,433 --> 00:03:18,842

62
00:03:18,842 --> 00:03:19,830
>> [結束播放]

63
00:03:19,830 --> 00:03:23,702
>> [掌聲]

64
00:03:23,702 --> 00:03:27,598
>> [AUDIO OUT]

65
00:03:27,598 --> 00:03:44,041

66
00:03:44,041 --> 00:03:45,790
羅伯BOWDEN：--simple
加密的形式，

67
00:03:45,790 --> 00:03:49,500
這基本上是加密
和解密的秘密信息。

68
00:03:49,500 --> 00:03:52,590
所以在這裡我們有一個非常簡單的玩具。

69
00:03:52,590 --> 00:03:56,900
和想法是外環
旋轉內圈周圍。

70
00:03:56,900 --> 00:04:01,610
你可以看到，也許如果我放大
在，that--很難看到的。

71
00:04:01,610 --> 00:04:05,090
但是，等時，數
1--好，感動。

72
00:04:05,090 --> 00:04:09,120
>> 數字1映射到信
X，2號映射到信

73
00:04:09,120 --> 00:04:11,630
J.極其困難
不能快進。

74
00:04:11,630 --> 00:04:16,100
信2映射到J.
3號映射到D.因此，

75
00:04:16,100 --> 00:04:20,140
這個戒指，你可以給
有人信息1，2，3。

76
00:04:20,140 --> 00:04:22,624
出於某種原因，你
想告訴他們XJD。

77
00:04:22,624 --> 00:04:24,540
但是，你可以給他們
數字的一些消息，

78
00:04:24,540 --> 00:04:28,460
並且，只要它們具有本環，它們
可以解密你想說什麼。

79
00:04:28,460 --> 00:04:32,510
>> 所以，你可能已經看到了這一點
密碼學的具體的例子

80
00:04:32,510 --> 00:04:36,640
之前，如果周圍的聖誕節
你看過聖誕故事。

81
00:04:36,640 --> 00:04:38,520
如果你從來沒有見過
之前，那麼就

82
00:04:38,520 --> 00:04:41,060
打開TBS在字面上
任何時候在聖誕節前夕，

83
00:04:41,060 --> 00:04:44,510
因為他們只是顯示它背靠背
要回背靠背一整天。

84
00:04:44,510 --> 00:04:46,744
而相關的視頻是這樣的。

85
00:04:46,744 --> 00:04:47,410
[視頻回放]

86
00:04:47,410 --> 00:04:50,020
-be是眾所周知的所有雜
拉爾夫·帕克現

87
00:04:50,020 --> 00:04:52,850
任命小的一員
孤兒安妮秘密圈

88
00:04:52,850 --> 00:04:56,490
並有權所有榮譽
而發生的收益於此。

89
00:04:56,490 --> 00:04:59,010
簽名小孤兒安妮。

90
00:04:59,010 --> 00:05:03,120
會簽皮埃爾·安德烈·墨！

91
00:05:03,120 --> 00:05:07,460
榮譽和利益
已經在九歲的時候！

92
00:05:07,460 --> 00:05:12,530
>> [大呼小叫無線電]

93
00:05:12,530 --> 00:05:13,030
-COMe上。

94
00:05:13,030 --> 00:05:14,000
讓我們開始吧。

95
00:05:14,000 --> 00:05:18,274
我不需要所有的爵士樂
關於走私和海盜。

96
00:05:18,274 --> 00:05:20,440
 - 聽明天夜間
結論冒險

97
00:05:20,440 --> 00:05:22,540
的黑色海盜船。

98
00:05:22,540 --> 00:05:25,460
現在，它的時間為
安妮的秘密消息

99
00:05:25,460 --> 00:05:28,620
為你的成員秘社的。

100
00:05:28,620 --> 00:05:32,370
請記住孩子，只有成員
安妮的秘密圈

101
00:05:32,370 --> 00:05:34,880
可以解碼安妮的秘密消息。

102
00:05:34,880 --> 00:05:39,100
請記住，伊能靜取決於你。

103
00:05:39,100 --> 00:05:41,660
設置你的引腳為B2。

104
00:05:41,660 --> 00:05:43,960
這裡是該消息。

105
00:05:43,960 --> 00:05:44,680
12。

106
00:05:44,680 --> 00:05:45,180
11。

107
00:05:45,180 --> 00:05:45,679
2。

108
00:05:45,679 --> 00:05:48,110
 - 我在我的第一次秘密會晤。

109
00:05:48,110 --> 00:05:49,030
>> -25。

110
00:05:49,030 --> 00:05:49,834
14。

111
00:05:49,834 --> 00:05:51,040
11。

112
00:05:51,040 --> 00:05:51,854
18。

113
00:05:51,854 --> 00:05:52,670
16。

114
00:05:52,670 --> 00:05:54,570
>> 哦，皮埃爾在巨大的聲音今晚。

115
00:05:54,570 --> 00:05:57,490
我可以告訴大家，今晚的
信息是非常重要的。

116
00:05:57,490 --> 00:05:57,990
-3。

117
00:05:57,990 --> 00:06:00,080
25。

118
00:06:00,080 --> 00:06:01,580
這與安妮自己的消息。

119
00:06:01,580 --> 00:06:02,880
請記住，不要告訴任何人。

120
00:06:02,880 --> 00:06:07,840

121
00:06:07,840 --> 00:06:11,130
>>  - 五秒鐘後，我的唯一
房間在房子裡的九個男孩

122
00:06:11,130 --> 00:06:15,830
可以坐在隱私和解碼。

123
00:06:15,830 --> 00:06:16,620
啊哈！

124
00:06:16,620 --> 00:06:17,340
乙！

125
00:06:17,340 --> 00:06:20,210
我去了下一個。

126
00:06:20,210 --> 00:06:23,300
E.第一個字是“是”。

127
00:06:23,300 --> 00:06:25,880
S.它現在來了更容易。

128
00:06:25,880 --> 00:06:28,400
U. 25。

129
00:06:28,400 --> 00:06:30,528
這是R.

130
00:06:30,528 --> 00:06:31,278
-COMe上，拉爾夫！

131
00:06:31,278 --> 00:06:31,861
我得走了！

132
00:06:31,861 --> 00:06:33,182
-I'll被降權，馬！

133
00:06:33,182 --> 00:06:36,038
嘖嘖颼颼。

134
00:06:36,038 --> 00:06:42,840
T. O.“一定要” - 一定要什麼呢？

135
00:06:42,840 --> 00:06:44,770
什麼是小孤兒
安妮想說什麼？

136
00:06:44,770 --> 00:06:46,381
一定要什麼？

137
00:06:46,381 --> 00:06:47,825
>> -Randy也得去！

138
00:06:47,825 --> 00:06:48,866
請你出來？

139
00:06:48,866 --> 00:06:49,783
>>  - 所有正確的，媽媽！

140
00:06:49,783 --> 00:06:51,786
我馬上就出來！

141
00:06:51,786 --> 00:06:53,606
我是越來越近了。

142
00:06:53,606 --> 00:06:55,550
張力是可怕的。

143
00:06:55,550 --> 00:06:57,050
那是什麼？

144
00:06:57,050 --> 00:06:59,905
這個星球的命運
可以掛在平衡！

145
00:06:59,905 --> 00:07:01,736
>> -Ralphie，蘭迪得走了！

146
00:07:01,736 --> 00:07:05,680
>> -I'll就出來，哭出聲來！

147
00:07:05,680 --> 00:07:07,170
幾乎沒有！

148
00:07:07,170 --> 00:07:08,150
我的手指飛。

149
00:07:08,150 --> 00:07:09,980
我的心是一個鋼鐵陷阱。

150
00:07:09,980 --> 00:07:11,496
每一個毛孔振動。

151
00:07:11,496 --> 00:07:13,268
這幾乎是清楚的！

152
00:07:13,268 --> 00:07:13,767
是。

153
00:07:13,767 --> 00:07:14,609
是。

154
00:07:14,609 --> 00:07:15,108
是。

155
00:07:15,108 --> 00:07:16,449
是。

156
00:07:16,449 --> 00:07:20,240
一定要喝你的阿華田。

157
00:07:20,240 --> 00:07:20,740
阿華田？

158
00:07:20,740 --> 00:07:26,687

159
00:07:26,687 --> 00:07:27,520
一個最低級的商業？

160
00:07:27,520 --> 00:07:32,040

161
00:07:32,040 --> 00:07:34,920
狗娘養的。

162
00:07:34,920 --> 00:07:35,890
>> [結束播放]

163
00:07:35,890 --> 00:07:39,650
>> 羅伯BOWDEN：所以這就是如何
阿華田涉及到加密。

164
00:07:39,650 --> 00:07:42,290
基本上CS50剛剛公佈
阿華田，所以我們可以

165
00:07:42,290 --> 00:07:44,400
是一個糟糕的商業為阿華田。

166
00:07:44,400 --> 00:07:44,900
好的。

167
00:07:44,900 --> 00:07:47,120
所以現在實際的計算機科學。

168
00:07:47,120 --> 00:07:50,670
還記得在星期一，我們離開
潛水更深的字符串。

169
00:07:50,670 --> 00:07:52,820
因此，我們正在處理
字符串“Zamyla”。

170
00:07:52,820 --> 00:07:55,130
而且我們認識到
事實上，我們可以把

171
00:07:55,130 --> 00:07:57,510
“Zamyla”作為一個字符序列。

172
00:07:57,510 --> 00:07:59,740
請記住，我們學到了
支架符號。

173
00:07:59,740 --> 00:08:01,995
因此，如果該值儲存
在字符串“s”，那麼

174
00:08:01,995 --> 00:08:05,860
如果s表示托架0，這將
指示信資本Z.

175
00:08:05,860 --> 00:08:09,790
如果我們s表示支架1，即
會指示第一小寫一個，

176
00:08:09,790 --> 00:08:14,220
依此類推，直到為s支架5，
這顯示最後一個。

177
00:08:14,220 --> 00:08:17,090
>> 現在，請記住，
此字符串的長度為6，

178
00:08:17,090 --> 00:08:23,220
但是索引到字符串是
0到5，Z通過持續。

179
00:08:23,220 --> 00:08:28,650
所以，現在這個融入一個更大的圖片
您的計算機的內存，您的RAM。

180
00:08:28,650 --> 00:08:32,020
因此，地方的計劃，
你運行你的電腦

181
00:08:32,020 --> 00:08:34,780
需要記住Zamyla
某處存儲器。

182
00:08:34,780 --> 00:08:36,029
因此，我可以有一個志願者？

183
00:08:36,029 --> 00:08:38,840

184
00:08:38,840 --> 00:08:40,181
是的，請。

185
00:08:40,181 --> 00:08:50,120

186
00:08:50,120 --> 00:08:51,500
而你叫什麼名字？

187
00:08:51,500 --> 00:08:52,410
>> 院長：院長。

188
00:08:52,410 --> 00:08:53,550
>> 羅伯BOWDEN：院長？

189
00:08:53,550 --> 00:08:54,910
很高興見到你，院長。

190
00:08:54,910 --> 00:08:58,240
所以來這裡了，
我們要你畫

191
00:08:58,240 --> 00:09:00,740
對我們的好漂亮的內存佈局。

192
00:09:00,740 --> 00:09:05,950
現在，我喜歡把內存
作為一個字節一個長條形，

193
00:09:05,950 --> 00:09:11,090
但只是為了顯示目的，我們將
只是從左至右，從上到下。

194
00:09:11,090 --> 00:09:11,590
OK？

195
00:09:11,590 --> 00:09:22,030
>> 所以，我要表現出
program-- Getstrings.c。

196
00:09:22,030 --> 00:09:25,760
所以，這一切的程序是
做的是要求四根弦

197
00:09:25,760 --> 00:09:28,830
從與用戶
GetString的，然後打印

198
00:09:28,830 --> 00:09:30,950
無論是第一個串進了。

199
00:09:30,950 --> 00:09:32,840
我們忽略了兩個通四人。

200
00:09:32,840 --> 00:09:33,610
確定。

201
00:09:33,610 --> 00:09:38,210
所以，在這裡now--時
我第一次請求S1。

202
00:09:38,210 --> 00:09:39,740
所以你的電腦。

203
00:09:39,740 --> 00:09:41,680
而要實現的GetString。

204
00:09:41,680 --> 00:09:46,710
所以，你請求一個字符串
我，我說好，院長。

205
00:09:46,710 --> 00:09:47,900
給字符串“院長。”

206
00:09:47,900 --> 00:09:50,300
>> 如此在內存，你
需要記住的“院長。”

207
00:09:50,300 --> 00:09:52,160
所以寫到內存的某個地方。

208
00:09:52,160 --> 00:09:58,270

209
00:09:58,270 --> 00:09:59,210
完善。

210
00:09:59,210 --> 00:09:59,880
確定。

211
00:09:59,880 --> 00:10:01,740
所以，現在我們已經S2。

212
00:10:01,740 --> 00:10:03,869
和s2將是
請求給GetString。

213
00:10:03,869 --> 00:10:05,160
所以，我要輸入一個字符串。

214
00:10:05,160 --> 00:10:08,720
我要輸入“漢娜”。

215
00:10:08,720 --> 00:10:10,586
因此，輸入“漢娜”的地方到內存中。

216
00:10:10,586 --> 00:10:18,860

217
00:10:18,860 --> 00:10:19,360
是啊。

218
00:10:19,360 --> 00:10:23,000
A-H。

219
00:10:23,000 --> 00:10:25,550
>> 好了，現在S3。

220
00:10:25,550 --> 00:10:28,380
而這將是另一個
請給GetString。

221
00:10:28,380 --> 00:10:37,020
所以現在進入“瑪麗亞”。

222
00:10:37,020 --> 00:10:37,520
好的。

223
00:10:37,520 --> 00:10:40,980
然後還有最後一個
請求給GetString，S4。

224
00:10:40,980 --> 00:10:42,580
所以，我不知道。

225
00:10:42,580 --> 00:10:45,640
怎麼樣，我們一起去
反政教分離運動。

226
00:10:45,640 --> 00:10:49,460
所以輸入到內存中。

227
00:10:49,460 --> 00:10:50,400
是啊。

228
00:10:50,400 --> 00:10:53,970
所以，只是做“搶”。

229
00:10:53,970 --> 00:10:54,560
>> 確定。

230
00:10:54,560 --> 00:10:58,410
所以，現在explain--何必當初
你離開這些空間？

231
00:10:58,410 --> 00:11:01,340
為什麼你有這樣的空白
空間在這裡，在這裡，並在這裡？

232
00:11:01,340 --> 00:11:05,170

233
00:11:05,170 --> 00:11:05,670
是。

234
00:11:05,670 --> 00:11:09,450
所以，當我去通知
打印s1--所以如果我們

235
00:11:09,450 --> 00:11:11,890
有“漢娜”運行
直到旁邊的“院長”

236
00:11:11,890 --> 00:11:14,360
我們怎麼知道什麼時候
字符串“院長”結束？

237
00:11:14,360 --> 00:11:19,470
因此打印字符串S1可以有
只印有“DeanHannahMariaRob”

238
00:11:19,470 --> 00:11:22,720
如果它不具有任何線索
當“院長”實際上結束。

239
00:11:22,720 --> 00:11:23,240
>> 好的。

240
00:11:23,240 --> 00:11:27,650
因此，在存儲器中的方式，我們實際上
代表的字符串的這一端

241
00:11:27,650 --> 00:11:29,940
是用反斜杠零。

242
00:11:29,940 --> 00:11:32,620
所以這個空間正是我們想要的。

243
00:11:32,620 --> 00:11:34,040
它應該是一個反斜杠為零。

244
00:11:34,040 --> 00:11:37,690
這將是一個反斜杠零，
而這將是一個反斜杠為零。

245
00:11:37,690 --> 00:11:41,585
你可以有一個神話般的獎金
為是一個完美的志願者。

246
00:11:41,585 --> 00:11:44,910

247
00:11:44,910 --> 00:11:45,860
以一個壓力球！

248
00:11:45,860 --> 00:11:49,040

249
00:11:49,040 --> 00:11:49,700
>> 確定。

250
00:11:49,700 --> 00:11:54,420
所以這個人物反斜線為零
我們如何表示字符串的結束。

251
00:11:54,420 --> 00:11:57,120
它是如何在任何給定的程序
要打印的字符串，

252
00:11:57,120 --> 00:11:59,760
這是how--記得我們學
上週strlen函數？

253
00:11:59,760 --> 00:12:00,940
字符串的長度？

254
00:12:00,940 --> 00:12:03,770
它是如何字符串的長度能
確定字符串是多久。

255
00:12:03,770 --> 00:12:05,810
它只是不斷迭代
在人物

256
00:12:05,810 --> 00:12:08,217
直到找到
反斜線零字符。

257
00:12:08,217 --> 00:12:11,050
因此，重要的是要實現
關於反斜線零字符

258
00:12:11,050 --> 00:12:14,950
是它的代表
在位全部為零。

259
00:12:14,950 --> 00:12:18,980
因此注意到，這是明顯的
從零字符。

260
00:12:18,980 --> 00:12:23,010
因此，零字符，如果你還記得
在實施例，他在結束了

261
00:12:23,010 --> 00:12:27,360
講座中，其中的字符映射
用於：像大寫字母A映射到65。

262
00:12:27,360 --> 00:12:29,130
小寫映射到97。

263
00:12:29,130 --> 00:12:30,890
小寫的B。將98。

264
00:12:30,890 --> 00:12:35,220
因此數字0映射用於：我不知道
知道了我的頭頂。

265
00:12:35,220 --> 00:12:36,400
44或45。

266
00:12:36,400 --> 00:12:37,890
某處在該地區。

267
00:12:37,890 --> 00:12:40,850
>> 這樣的字符0是實數。

268
00:12:40,850 --> 00:12:44,350
但是反斜杠零
映射到所有零位。

269
00:12:44,350 --> 00:12:46,380
因此，有區別
反斜線0之間，

270
00:12:46,380 --> 00:12:48,450
我們稱之為空終止。

271
00:12:48,450 --> 00:12:53,210
有區別
反斜線零和字符零。

272
00:12:53,210 --> 00:12:54,350
>> 好的。

273
00:12:54,350 --> 00:12:57,520
所以說話有點了解的字符串。

274
00:12:57,520 --> 00:13:01,470
於是，我們在這裡看到，這是怎麼
它會在內存中進行佈局。

275
00:13:01,470 --> 00:13:07,940
所以這個想法字符串作為一個序列
characters--所以官方電腦

276
00:13:07,940 --> 00:13:10,750
sciency術語序列是一個數組。

277
00:13:10,750 --> 00:13:13,790
所以我們稱之為一個字符串
字符數組。

278
00:13:13,790 --> 00:13:17,770
而實際上有其他數據
類型，我們可以使陣列出來。

279
00:13:17,770 --> 00:13:19,975
>> 因此，要鼓勵這一點，我們來看一個例子。

280
00:13:19,975 --> 00:13:22,810

281
00:13:22,810 --> 00:13:29,812
我們叫它ages0.c我會
複製和粘貼我們的模板。

282
00:13:29,812 --> 00:13:32,470

283
00:13:32,470 --> 00:13:33,410
確定。

284
00:13:33,410 --> 00:13:39,378
因此，這個方案我們
想要做的就是抓住時代

285
00:13:39,378 --> 00:13:45,160
三個學生選修的課程。

286
00:13:45,160 --> 00:13:49,240
因此，我們知道的INT age--
現在我要說0。

287
00:13:49,240 --> 00:13:53,140
所以，你可能要說AGE-1，但
為了我們會看到非常短的，

288
00:13:53,140 --> 00:13:57,187
我會說INT age0等於調用getInt。

289
00:13:57,187 --> 00:13:59,270
因此，同樣的調用調用getInt
我們一直在使用我

290
00:13:59,270 --> 00:14:01,561
沒有發生被提示
他說，“給我的年齡。”

291
00:14:01,561 --> 00:14:03,120
但只是要求它。

292
00:14:03,120 --> 00:14:06,510
>> 而AGE-1等於調用getInt。

293
00:14:06,510 --> 00:14:09,600
和INT age2等於調​​用getInt。

294
00:14:09,600 --> 00:14:14,070
所以，再一次，三個學生，但
最終的變量指標

295
00:14:14,070 --> 00:14:16,890
是age0通過age2。

296
00:14:16,890 --> 00:14:17,550
確定。

297
00:14:17,550 --> 00:14:23,960
因此，這個程序將採取一切
我們希望與age0，AGE-1，和age2，

298
00:14:23,960 --> 00:14:27,670
但這個方案最終
適用於三個學生。

299
00:14:27,670 --> 00:14:28,380
>> 確定。

300
00:14:28,380 --> 00:14:32,110
所以，現在如果我想四名學生？

301
00:14:32,110 --> 00:14:36,000
好吧，我不得不回去
進入我的代碼，更改註釋，

302
00:14:36,000 --> 00:14:39,840
現在我們有一個int
age3等於調用getInt。

303
00:14:39,840 --> 00:14:40,610
確定。

304
00:14:40,610 --> 00:14:43,660
那麼，誰看到了問題嗎？

305
00:14:43,660 --> 00:14:47,310
這是什麼問題
有了這樣的設置呢？

306
00:14:47,310 --> 00:14:47,810
是啊。

307
00:14:47,810 --> 00:14:53,110

308
00:14:53,110 --> 00:14:53,610
是啊。

309
00:14:53,610 --> 00:14:56,360
因此，我們要創建一個
變量為每個學生。

310
00:14:56,360 --> 00:15:00,140
現在的作品，但
最後，如果我現在

311
00:15:00,140 --> 00:15:06,500
說，“我想抓住的年齡
八名學生和16名學生

312
00:15:06,500 --> 00:15:11,340
或將然而，許多學生
在數百名學生在CS50

313
00:15:11,340 --> 00:15:16,750
或者成千上萬的學生在校園裡
或在世界上數十億人？

314
00:15:16,750 --> 00:15:19,130
所以這終究是不可持續的。

315
00:15:19,130 --> 00:15:21,990
你看到自己複製任何時間
而像這樣的粘貼代碼，

316
00:15:21,990 --> 00:15:25,050
你一般應該感到
有一個更好的辦法。

317
00:15:25,050 --> 00:15:31,290
>> 因此，這是我們引入
一個數組聲明。

318
00:15:31,290 --> 00:15:34,564
因此，當你聲明一個數組，
這是一般的格式

319
00:15:34,564 --> 00:15:35,480
是將會是什麼樣的。

320
00:15:35,480 --> 00:15:36,664
我們要說的類型。

321
00:15:36,664 --> 00:15:38,830
然後我們要
給該數組的名稱，

322
00:15:38,830 --> 00:15:41,150
就像我們定義任何給定的變量。

323
00:15:41,150 --> 00:15:43,980
然後最後我們使用
這再次括號符號

324
00:15:43,980 --> 00:15:47,480
但在從不同的上下文
我們如何早期使用它。

325
00:15:47,480 --> 00:15:51,860
>> 所以在這裡，這看起來像一個正常的
我們已經看到變量聲明。

326
00:15:51,860 --> 00:15:54,890
因此，我們以前見過INT×半結腸。

327
00:15:54,890 --> 00:16:00,020
現在好了，我們可能會看到一些東西
如int x托架5。

328
00:16:00,020 --> 00:16:04,020
並把這一想法付諸了
調用getInt程序，我們have--

329
00:16:04,020 --> 00:16:08,850
所以我們可以實現
此以相同的方式。

330
00:16:08,850 --> 00:16:13,630
>> 讓我們在CS說，我們傾向於使用
N作為某物的數目。

331
00:16:13,630 --> 00:16:16,150
所以在這裡我們要
存儲4個學生。

332
00:16:16,150 --> 00:16:25,960
現在，我們可以說INT年齡
支架N--不太明白yet--

333
00:16:25,960 --> 00:16:32,210
宣布4名學生組成的數組。

334
00:16:32,210 --> 00:16:38,050
因此，這將如何看在
內存將與此類似。

335
00:16:38,050 --> 00:16:39,570
清除此。

336
00:16:39,570 --> 00:16:46,606
而我們將要在什麼地方
在memory--我把這個在那裡。

337
00:16:46,606 --> 00:16:52,690

338
00:16:52,690 --> 00:16:53,808
>> 如此在存儲器中。

339
00:16:53,808 --> 00:16:58,760

340
00:16:58,760 --> 00:16:59,727
一，二，三，四。

341
00:16:59,727 --> 00:17:03,383

342
00:17:03,383 --> 00:17:09,849
我們有四個整數一行
對於四個整數數組。

343
00:17:09,849 --> 00:17:13,820
因此，目前，什麼是
其中一個框的大小？

344
00:17:13,820 --> 00:17:17,190

345
00:17:17,190 --> 00:17:17,690
是啊。

346
00:17:17,690 --> 00:17:18,390
這是四個字節。

347
00:17:18,390 --> 00:17:19,690
這是32位。

348
00:17:19,690 --> 00:17:22,310
所以，現在，這是不同的
從陣列，我們

349
00:17:22,310 --> 00:17:24,020
看到人物的前面，數組。

350
00:17:24,020 --> 00:17:28,540
在一個字符串中的每個盒子裡只有一個字節，
因為一個字符中只有一個字節。

351
00:17:28,540 --> 00:17:32,170
但隨著整數數組，每個
盒必須是為了四個字節

352
00:17:32,170 --> 00:17:34,060
以滿足整個整數。

353
00:17:34,060 --> 00:17:37,197
所以這是一個數組
4整數會是什麼樣子。

354
00:17:37,197 --> 00:17:40,510

355
00:17:40,510 --> 00:17:43,870
>> 然後回代碼。

356
00:17:43,870 --> 00:17:47,460
現在，我們要實際存儲
到整數數組。

357
00:17:47,460 --> 00:17:53,470
所以，現在這是一個非常，非常，非常
常見的模式是會在某個點

358
00:17:53,470 --> 00:17:54,680
成為肌肉記憶。

359
00:17:54,680 --> 00:17:56,710
所以，INT I等於0。

360
00:17:56,710 --> 00:17:57,940
我小於n。

361
00:17:57,940 --> 00:18:01,850
我加再加。

362
00:18:01,850 --> 00:18:05,790
年齡段i等於調用getInt。

363
00:18:05,790 --> 00:18:15,100
>> 所以這個循環，這種格式，
你應該得到很習慣。

364
00:18:15,100 --> 00:18:20,010
因此，這是通常我們將如何
遍歷幾乎所有的數組。

365
00:18:20,010 --> 00:18:23,690
現在可以看到這樣的
從一開始就解釋了為什麼

366
00:18:23,690 --> 00:18:29,870
我們沒有for循環去為INT
i等於1，我小於或等於10。

367
00:18:29,870 --> 00:18:34,200
原因是，從開始
零使這項工作很好地與陣列。

368
00:18:34,200 --> 00:18:36,270
所以數組是零索引。

369
00:18:36,270 --> 00:18:40,360
如果該數組的長度為4，
該指數為0至3。

370
00:18:40,360 --> 00:18:42,880
>> 所以通過第一
迭代的for循環

371
00:18:42,880 --> 00:18:49,930
我們將要設置年齡
支架0等於調用調用getInt。

372
00:18:49,930 --> 00:18:52,440
所以，無論我發生了
在鍵盤上輸入。

373
00:18:52,440 --> 00:18:56,970
在第二遍，我們
設置AGE-1等於調用getInt。

374
00:18:56,970 --> 00:18:58,230
第三關，age2。

375
00:18:58,230 --> 00:18:59,880
最後一傳age3。

376
00:18:59,880 --> 00:19:05,750
因此，如果在該循環的第一次通
我輸入號碼4在鍵盤上，

377
00:19:05,750 --> 00:19:07,740
然後我們會在這裡插入4。

378
00:19:07,740 --> 00:19:11,470
如果我進入了第二遍
50，我們就放了50在這裡。

379
00:19:11,470 --> 00:19:15,180
在第三次我可能
進入負1，負1，

380
00:19:15,180 --> 00:19:21,810
然後最後，如果我進入0--和
現在想起來，這是指數三種。

381
00:19:21,810 --> 00:19:25,350
>> 之後，我們回送，我是
將要增加至4。

382
00:19:25,350 --> 00:19:27,770
i是不再小於n，這是4。

383
00:19:27,770 --> 00:19:29,840
我們跳出循環。

384
00:19:29,840 --> 00:19:32,578
那麼，什麼是錯呢？

385
00:19:32,578 --> 00:19:38,140

386
00:19:38,140 --> 00:19:38,729
[聽不清]？

387
00:19:38,729 --> 00:19:39,604
聽眾：[聽不清]

388
00:19:39,604 --> 00:19:45,880

389
00:19:45,880 --> 00:19:46,400
>> 是。

390
00:19:46,400 --> 00:19:51,550
因此，陣列只有四個名額，
這意味著作為索引0至3。

391
00:19:51,550 --> 00:19:55,630
因此，如果是這樣的話，我會
取值4在某些時候。

392
00:19:55,630 --> 00:20:00,910
年齡段4將被設定
無論發生什麼事是在這裡

393
00:20:00,910 --> 00:20:02,920
什麼，我不得不說，進入6。

394
00:20:02,920 --> 00:20:05,010
那將是它設置為6。

395
00:20:05,010 --> 00:20:06,560
>> 但我們不知道什麼是在這裡。

396
00:20:06,560 --> 00:20:08,836
這不是存儲器
我們接觸到。

397
00:20:08,836 --> 00:20:10,710
所以，如果你還記得
以前的講座，

398
00:20:10,710 --> 00:20:14,350
他打印出Zamyla的價值觀和
在某些時候，他打這個細分

399
00:20:14,350 --> 00:20:17,990
故障。所以，你可能會看到
許多段錯誤，你

400
00:20:17,990 --> 00:20:20,530
實施一些習題。

401
00:20:20,530 --> 00:20:24,950
但是，這是一種方式，其中
你可能會遇到一個分割

402
00:20:24,950 --> 00:20:28,540
故障，當你開始訪問
記憶中，你不應該有辦法。

403
00:20:28,540 --> 00:20:34,117
所以我們沒有獲得
這個位置，這是一個錯誤。

404
00:20:34,117 --> 00:20:37,760

405
00:20:37,760 --> 00:20:40,190
>> 因此，這是更好的。

406
00:20:40,190 --> 00:20:45,820
現在還有一個小
問題與此代碼。

407
00:20:45,820 --> 00:20:50,720
而這基本上是我們
還停留在四個學生。

408
00:20:50,720 --> 00:20:52,940
現在，如果我想使用八名學生，確定。

409
00:20:52,940 --> 00:20:54,350
這不是什麼大不了的事。

410
00:20:54,350 --> 00:20:58,120
我可以進去，改變
評論和n更改。

411
00:20:58,120 --> 00:20:59,760
現在，這將與八名學生。

412
00:20:59,760 --> 00:21:02,190
如果我這個編譯並運行
這一點，它會顯示我 - 

413
00:21:02,190 --> 00:21:07,870
它會要求整數八
學生和它只是工作。

414
00:21:07,870 --> 00:21:11,850
但它不到理想的需要
重新編譯程序每一次

415
00:21:11,850 --> 00:21:15,960
我想改變學生人數
我想進入的年齡為。

416
00:21:15,960 --> 00:21:22,990
>> 因此，在最後的改進
這一點，因為我們將看到這裡 - 我們

417
00:21:22,990 --> 00:21:26,177
要請求的人的數目。

418
00:21:26,177 --> 00:21:28,010
在這裡，我們有一些
人在房間

419
00:21:28,010 --> 00:21:29,880
或任何年齡段的人在房間裡。

420
00:21:29,880 --> 00:21:33,300
但是，我們將請求數量
人在房間裡，從用戶。

421
00:21:33,300 --> 00:21:36,171
因此，這是完全一樣的做，而
循環，我們以前見過。

422
00:21:36,171 --> 00:21:37,920
這是完全一樣的
do-whil​​e循環，你

423
00:21:37,920 --> 00:21:40,050
可實現對問題的設置。

424
00:21:40,050 --> 00:21:43,102
因此，只要他們是
輸入的n小於1，

425
00:21:43,102 --> 00:21:45,310
因此，有必須是在
至少有一個人在房間裡。

426
00:21:45,310 --> 00:21:47,407
只要他們是
輸入的n小於1，

427
00:21:47,407 --> 00:21:48,990
那麼我們要不斷地問了。

428
00:21:48,990 --> 00:21:50,906
請輸入號碼
人在房間裡。

429
00:21:50,906 --> 00:21:53,550
現在，當我們有多少
人在room--

430
00:21:53,550 --> 00:21:58,020
所以我可能進入有
有200人在這個房間裡。

431
00:21:58,020 --> 00:22:05,480
然後到這裡，我們要來了
並宣布尺寸200的數組。

432
00:22:05,480 --> 00:22:10,220
我們聲明數組的
大到足以容納200歲。

433
00:22:10,220 --> 00:22:15,370
下來，它的循環
你會得到非常習慣。

434
00:22:15,370 --> 00:22:19,490
所以遍歷數組，
分配給每個位置

435
00:22:19,490 --> 00:22:23,020
在該陣列的整數，和
那麼最終我們在這裡

436
00:22:23,020 --> 00:22:28,340
剛開迭代的例子
通過該數組，而不是分配價值，

437
00:22:28,340 --> 00:22:30,150
但訪問值。

438
00:22:30,150 --> 00:22:33,810
>> 所以，在這裡我們可以看到，我們
從現在說，一年的時間，

439
00:22:33,810 --> 00:22:40,470
人％我將％I歲，
其中第一個％i是我加1。

440
00:22:40,470 --> 00:22:43,010
所以，我是這樣的指標變量。

441
00:22:43,010 --> 00:22:49,420
而第二個％我會是
值存儲在陣列年齡加1。

442
00:22:49,420 --> 00:22:54,217
所以這個加1僅僅是因為我們
saying--這種加1，我加1歲。

443
00:22:54,217 --> 00:22:57,050
這加1僅僅是因為我們
從現在的人說，一年

444
00:22:57,050 --> 00:22:58,280
將這個老。

445
00:22:58,280 --> 00:23:01,080
>> 那麼，為什麼是這樣的我加1？

446
00:23:01,080 --> 00:23:04,064
為什麼我們有一個加1呢？

447
00:23:04,064 --> 00:23:04,564
是啊。

448
00:23:04,564 --> 00:23:07,410

449
00:23:07,410 --> 00:23:07,930
是。

450
00:23:07,930 --> 00:23:10,510
所以請記住陣列零索引。

451
00:23:10,510 --> 00:23:14,840
因此，如果我們打印這個出來
有人剛讀輸出，

452
00:23:14,840 --> 00:23:19,380
那麼很可能他們想看到的東西
喜歡的人之一，個人排名第一，

453
00:23:19,380 --> 00:23:21,160
將20歲。

454
00:23:21,160 --> 00:23:23,570
人二號將是15歲。

455
00:23:23,570 --> 00:23:27,420
他們不想看到的人
零號是15歲。

456
00:23:27,420 --> 00:23:36,460
>> 因此，編譯這一點，只是看到什麼
它看起來like--創建一些空間。

457
00:23:36,460 --> 00:23:43,560
讓年齡編譯。

458
00:23:43,560 --> 00:23:45,080
運行青睞。

459
00:23:45,080 --> 00:23:46,580
我們看到在房間裡的人數。

460
00:23:46,580 --> 00:23:48,850
所以我會說有
三個人在房間裡。

461
00:23:48,850 --> 00:23:54,000
人的頭號年齡，
讓我們說15，20，25。

462
00:23:54,000 --> 00:23:59,680
現在我會說每年從
現在，他們將16，21，26。

463
00:23:59,680 --> 00:24:02,900
讓我們來看看這個作品
的n不等於3。

464
00:24:02,900 --> 00:24:07,940
所以，如果我說的人數是5，一，
二，三，二，一，從現在起一年

465
00:24:07,940 --> 00:24:11,170
他們會是兩個，三個，
四，三，二十歲。

466
00:24:11,170 --> 00:24:16,500
所以，我可以只為
輕易n為10,000。

467
00:24:16,500 --> 00:24:21,270
現在，我會坐在這裡很
一個在進入老齡化，但這個工程。

468
00:24:21,270 --> 00:24:26,000
>> 所以，現在在內存的某個地方，我們
有大小萬的陣列，

469
00:24:26,000 --> 00:24:28,830
所以最終40000
字節，因為有

470
00:24:28,830 --> 00:24:31,222
四個字節為每個整數。

471
00:24:31,222 --> 00:24:33,180
因此，有一組
尺寸萬，我們可以

472
00:24:33,180 --> 00:24:36,201
存儲這些10000人的青睞。

473
00:24:36,201 --> 00:24:36,700
好的。

474
00:24:36,700 --> 00:24:40,070
任何有關這個問題？

475
00:24:40,070 --> 00:24:41,892
是啊。

476
00:24:41,892 --> 00:24:43,350
如果你給一個負數？

477
00:24:43,350 --> 00:24:44,870
讓我們看看會發生什麼。

478
00:24:44,870 --> 00:24:49,320
所以在這個特定case--數
人在房間裡，消極的。

479
00:24:49,320 --> 00:24:52,580
它拒絕了，
因為在這裡，我們發生

480
00:24:52,580 --> 00:24:57,180
待處理的事實，如果n是
不到一個我們要再次問。

481
00:24:57,180 --> 00:25:01,780
如果您嘗試聲明
大小為負的數組，

482
00:25:01,780 --> 00:25:03,950
它通常是行不通的。

483
00:25:03,950 --> 00:25:05,570
>> 所以讓我們試試。

484
00:25:05,570 --> 00:25:08,000
讓我們忽略了什麼
他們的價值輸入n個

485
00:25:08,000 --> 00:25:10,571
而只是說INT年齡負值。

486
00:25:10,571 --> 00:25:12,410
讓我們來看看它甚至編譯。

487
00:25:12,410 --> 00:25:14,100
我不知道。

488
00:25:14,100 --> 00:25:14,920
第

489
00:25:14,920 --> 00:25:18,280
因此，年齡聲明為
陣列具有負大小。

490
00:25:18,280 --> 00:25:22,540
所以前期就識別到陣列不能
為負數的大小和拒絕。

491
00:25:22,540 --> 00:25:26,840
現在，如果我們不處理
這do-whil​​e循環正常，

492
00:25:26,840 --> 00:25:28,810
如果我們不檢查
如果n小於1--

493
00:25:28,810 --> 00:25:32,690
比方說，我們只是
沒有這在所有

494
00:25:32,690 --> 00:25:35,940
相反，我們只要抓住一個整數。

495
00:25:35,940 --> 00:25:40,710
不管是什麼整數，
我們聲明大小的數組。

496
00:25:40,710 --> 00:25:44,250
>> 因此，編譯器不能
可能抱怨現在。

497
00:25:44,250 --> 00:25:48,780
如果我編譯this--
因此它不能抱怨，

498
00:25:48,780 --> 00:25:51,480
因為它無法知道我
要輸入一個負數，

499
00:25:51,480 --> 00:25:52,550
這可能是無效的。

500
00:25:52,550 --> 00:25:54,633
對於所有它知道，我可能
輸入一個正數，

501
00:25:54,633 --> 00:25:56,000
這是完全有效的。

502
00:25:56,000 --> 00:26:01,090
所以我想，如果我進入負1
房間裡的人，分段錯誤。

503
00:26:01,090 --> 00:26:06,040
>> 因此，確定。

504
00:26:06,040 --> 00:26:13,160
因此，讓我們加入這回只是
保持它原來是什麼。

505
00:26:13,160 --> 00:26:15,640
因此，請青睞。

506
00:26:15,640 --> 00:26:18,120
現在，如果我想嘗試
負age--讓我們

507
00:26:18,120 --> 00:26:19,710
說，有五人在房間裡。

508
00:26:19,710 --> 00:26:23,180
人的頭號年齡
為負4，人3

509
00:26:23,180 --> 00:26:26,500
是零，人three--行。

510
00:26:26,500 --> 00:26:29,850
所以在這裡，一年後的今天，人的數量
一會是負的3歲。

511
00:26:29,850 --> 00:26:32,830
所以，很可能是沒有意義的。

512
00:26:32,830 --> 00:26:37,220
但是，這僅僅是因為看
在代碼中所有我們正在做的

513
00:26:37,220 --> 00:26:40,260
請求調用getInt。

514
00:26:40,260 --> 00:26:44,110
>> 現在，如果我們曾經有過
GetPositiveInt功能

515
00:26:44,110 --> 00:26:49,690
或者我們剛剛只是做到了這一點
排序一致，而循環出現了下滑，

516
00:26:49,690 --> 00:26:52,340
那麼這將完全正常工作。

517
00:26:52,340 --> 00:26:54,200
但在這個特殊的
情況下，我們只是不

518
00:26:54,200 --> 00:26:57,772
碰巧是處理負值。

519
00:26:57,772 --> 00:26:59,147
有關數組的任何其他問題？

520
00:26:59,147 --> 00:27:02,290

521
00:27:02,290 --> 00:27:03,250
確定。

522
00:27:03,250 --> 00:27:09,380
>> 所以，我們現在已經看到陣列。

523
00:27:09,380 --> 00:27:12,500
而我們將需要使用
本作的命令行參數。

524
00:27:12,500 --> 00:27:14,680
因此，在問題設置two--
我知道你們許多人

525
00:27:14,680 --> 00:27:18,040
可能仍在工作的問題集
之一，但問題設置兩個快到了。

526
00:27:18,040 --> 00:27:22,260
在問題設置兩個，你要
必須處理字符串，數組，

527
00:27:22,260 --> 00:27:23,950
和命令行參數。

528
00:27:23,950 --> 00:27:26,270
>> 那麼，什麼是命令行參數？

529
00:27:26,270 --> 00:27:29,570
現在，你可以看到到這裡一
小傳情什麼的

530
00:27:29,570 --> 00:27:30,950
將要發生的事情。

531
00:27:30,950 --> 00:27:32,950
我們看到INT為主，INC ARGC，
字符串argv的括號內。

532
00:27:32,950 --> 00:27:34,560

533
00:27:34,560 --> 00:27:38,130
因此，首先讓我們來試著解讀
是什麼，它盡可能地說。

534
00:27:38,130 --> 00:27:40,800
如今，OK。

535
00:27:40,800 --> 00:27:44,637
>> 因此，在命令行中，你應該
已經習慣了某些命令

536
00:27:44,637 --> 00:27:48,580
現在，你可能已經運行
CD在終端前。

537
00:27:48,580 --> 00:27:52,100
因此，如果我們說的CD PSET1，
你知道，這應該

538
00:27:52,100 --> 00:27:55,050
要改變到PSET1目錄。

539
00:27:55,050 --> 00:27:59,120
>> 現在發現，你從來沒有
之前寫的這樣的程序。

540
00:27:59,120 --> 00:28:03,120
你寫的每個程序，
你會跑，說，點斜線馬里奧，

541
00:28:03,120 --> 00:28:06,779
點斜線貪婪，然後
可能會提示您輸入。

542
00:28:06,779 --> 00:28:08,570
現在，這不是
更改目錄一樣。

543
00:28:08,570 --> 00:28:12,770
當你運行光盤，它並沒有那麼說，
該目錄下你想cd到？

544
00:28:12,770 --> 00:28:17,200
相反，你剛才說，CD PSET1和
它只是進入PSET1目錄。

545
00:28:17,200 --> 00:28:20,430
>> 所以類似地，我們有其它例子。

546
00:28:20,430 --> 00:28:21,540
讓你好。

547
00:28:21,540 --> 00:28:25,760
當你運行make，它並沒有那麼說，
該方案將你喜歡做什麼？

548
00:28:25,760 --> 00:28:29,620
你剛才說，在
命令行讓你好。

549
00:28:29,620 --> 00:28:31,060
>> 此舉是另一個例子。

550
00:28:31,060 --> 00:28:34,840
這一次，我們正在移動的
mario.c文件上一級目錄。

551
00:28:34,840 --> 00:28:38,060
所以，現在我們知道這個例子
我們真正傳遞了兩個參數。

552
00:28:38,060 --> 00:28:42,090
有mario.c作為第一個參數，
和點點是第二個參數。

553
00:28:42,090 --> 00:28:46,140
然後當你運行make，你
看到很長的命令line--

554
00:28:46,140 --> 00:28:50,580
真的長的命令
印在命令行。

555
00:28:50,580 --> 00:28:53,590
因此，長期command--這
是它只有很短的一部分，

556
00:28:53,590 --> 00:28:56,090
但現在我們有三個
命令行參數。

557
00:28:56,090 --> 00:28:59,750
點短跑零，你好，和hello.c的。

558
00:28:59,750 --> 00:29:03,497
>> 因此，這些都是命令行
論點，論據

559
00:29:03,497 --> 00:29:05,580
那你傳遞的
命令行，以便它

560
00:29:05,580 --> 00:29:08,680
不必被提示
當你運行該程序。

561
00:29:08,680 --> 00:29:13,090
這將是令人沮喪，如果當
您運行鐺它說：“好，

562
00:29:13,090 --> 00:29:15,630
這program--這
文件是在編譯？

563
00:29:15,630 --> 00:29:17,010
HELLO.C。

564
00:29:17,010 --> 00:29:19,440
什麼標誌你會
想進入？破折號O操作。

565
00:29:19,440 --> 00:29:21,190
你要什麼
該文件被稱為？

566
00:29:21,190 --> 00:29:21,690
你好。

567
00:29:21,690 --> 00:29:25,290
不，你只要運行鐺
衝Ø你好hello.c的。

568
00:29:25,290 --> 00:29:28,820
>> 因此，在回顧這個。

569
00:29:28,820 --> 00:29:32,920
現在argc-- ARGC是參數計數。

570
00:29:32,920 --> 00:29:36,620
它的命令行的數量
輸入參數在命令行。

571
00:29:36,620 --> 00:29:39,720
那麼，argv--技術
在V代表矢量，

572
00:29:39,720 --> 00:29:41,460
這基本上意味著陣列。

573
00:29:41,460 --> 00:29:42,680
但是你可以忽略。

574
00:29:42,680 --> 00:29:47,540
Argv--我們有串argv的，
所以字符串argv的括號內。

575
00:29:47,540 --> 00:29:50,150
因此，這是另一種形式的
括號你以前沒有見過。

576
00:29:50,150 --> 00:29:52,300
所以，我們看到的支架
符號時，我們已經說過了，

577
00:29:52,300 --> 00:29:53,970
像，字符串s等於Zamyla。

578
00:29:53,970 --> 00:29:56,910
小號托架0訪問字符Z.

579
00:29:56,910 --> 00:30:00,720
>> 我們也看到括號時
我們說INT年齡支架5。

580
00:30:00,720 --> 00:30:03,160
這個聲明的大小5陣列。

581
00:30:03,160 --> 00:30:06,280
因此，這裡是一個版本的
我們以前沒見過括號。

582
00:30:06,280 --> 00:30:09,630
因此，這類字符串的argv的
將完全熟悉

583
00:30:09,630 --> 00:30:12,050
這將只是一個字符串。

584
00:30:12,050 --> 00:30:14,520
現在括號表示
這是一個數組。

585
00:30:14,520 --> 00:30:19,920
所以字符串argv的括號手段
這ARGV是一個字符串數組。

586
00:30:19,920 --> 00:30:22,540
現在技術上的字符串
是字符數組。

587
00:30:22,540 --> 00:30:26,400
所以，這是現在一個數組
字符數組的。

588
00:30:26,400 --> 00:30:31,490
但它更容易去思考
串這只是作為一個陣列。

589
00:30:31,490 --> 00:30:34,900
>> 那麼，為什麼會在括號內是空的？

590
00:30:34,900 --> 00:30:38,170
就像，為什麼我們不能說，
支架5，支架N +

591
00:30:38,170 --> 00:30:40,700

592
00:30:40,700 --> 00:30:41,200
是啊。

593
00:30:41,200 --> 00:30:43,731

594
00:30:43,731 --> 00:30:44,230
是啊。

595
00:30:44,230 --> 00:30:46,396
我們不知道有多少
輸入有將要。

596
00:30:46,396 --> 00:30:53,560
因此，如果我們看一下鐺的例子，
我們說鐺破折號Ø你好hello.c的。

597
00:30:53,560 --> 00:30:56,710
在這種特殊情況下，有發生
是三個命令行參數。

598
00:30:56,710 --> 00:31:00,522
這樣一來，brackets--我們拭目以待
在第二它不會是三種。

599
00:31:00,522 --> 00:31:01,730
它在技術上的數字是4。

600
00:31:01,730 --> 00:31:04,030
但支架，我們會
比方說，有三種。

601
00:31:04,030 --> 00:31:08,220
但是現在，如果我們看招
mario.c點點，括號

602
00:31:08,220 --> 00:31:09,760
我們希望把兩個他們。

603
00:31:09,760 --> 00:31:12,884
>> 這裡面有很多的命令是
具有可變數量的命令行

604
00:31:12,884 --> 00:31:13,620
參數。

605
00:31:13,620 --> 00:31:17,430
那麼這個版本的
括號符號表示

606
00:31:17,430 --> 00:31:20,820
是的argv是一個字符串數組。

607
00:31:20,820 --> 00:31:24,360
但是，我們不知道有多少
字符串的數組。

608
00:31:24,360 --> 00:31:27,090
我們如何然後知道如何
許多字符串數組中？

609
00:31:27,090 --> 00:31:28,870
這是整點ARGC。

610
00:31:28,870 --> 00:31:32,300
ARGC告訴我們的argv有多長。

611
00:31:32,300 --> 00:31:36,500
>> 所以，過去的事情保持
頭腦是，從技術上，

612
00:31:36,500 --> 00:31:40,820
命令本身視為一個
的命令行參數。

613
00:31:40,820 --> 00:31:45,330
所以光盤PSET1，有兩種
命令行參數。

614
00:31:45,330 --> 00:31:50,260
在本身的程序，光盤，然後
它的實際參數部分，PSET1。

615
00:31:50,260 --> 00:31:54,490
任何你寫迄今程序
已經有一個命令行argument--點

616
00:31:54,490 --> 00:31:55,320
斜線馬里奧。

617
00:31:55,320 --> 00:31:57,350
這是唯一的命令行參數。

618
00:31:57,350 --> 00:32:00,900
>> 所以，現在看著鐺
衝Ø你好hello.c的。

619
00:32:00,900 --> 00:32:01,905
那麼，什麼是ARGC？

620
00:32:01,905 --> 00:32:05,260

621
00:32:05,260 --> 00:32:06,080
4。

622
00:32:06,080 --> 00:32:08,140
所以ARGC為4。

623
00:32:08,140 --> 00:32:12,140
鐺，所以argv的支架0是鏗鏘。

624
00:32:12,140 --> 00:32:15,630
argv的支架1是衝刺0。

625
00:32:15,630 --> 00:32:21,870
argv的支架2個招呼，
argv的支架3 hello.c的。

626
00:32:21,870 --> 00:32:26,813
好了，問題在這，然後我們會
看一些編程的例子。

627
00:32:26,813 --> 00:32:29,460

628
00:32:29,460 --> 00:32:30,480
>> 確定。

629
00:32:30,480 --> 00:32:36,260
因此，我們將看看hello3.c。

630
00:32:36,260 --> 00:32:41,890
所以這應該是由熟悉
的第一個C的例子之一

631
00:32:41,890 --> 00:32:45,800
我們有，我們只想說，你好
世界，但現在這個就比較一般了。

632
00:32:45,800 --> 00:32:52,300
因此，我們在這裡打個招呼
％S反斜線ñargv的支架1。

633
00:32:52,300 --> 00:32:57,440
Notice--所以直至這一點，這是
什麼我的模板文件看起來像。

634
00:32:57,440 --> 00:33:01,800
我有INT主要（無效），然後我會
做一些在主函數。

635
00:33:01,800 --> 00:33:05,100
現在相反，一旦我們開始處理
使用命令行參數，

636
00:33:05,100 --> 00:33:07,890
我們要說明一個
不同的形式為主。

637
00:33:07,890 --> 00:33:11,930
>> 所以在看hello3
再次，主要會

638
00:33:11,930 --> 00:33:15,990
拿兩個參數now-- INT ARGC，
命令行參數的個數，

639
00:33:15,990 --> 00:33:20,970
和字符串argv的支架，實際
輸入字符串在命令行。

640
00:33:20,970 --> 00:33:26,560
所以我要改變這種狀況
模板來反映這一事實。

641
00:33:26,560 --> 00:33:29,060
現在，只要你寫
一個程序，如果你不

642
00:33:29,060 --> 00:33:33,720
需要採取的任何命令行
參數，那麼就使用int主要（無效）。

643
00:33:33,720 --> 00:33:37,070
但是現在，當你寫
命令行參數的程序，其中

644
00:33:37,070 --> 00:33:40,350
你會做的問題
設置two--所以現在你正在運行

645
00:33:40,350 --> 00:33:42,630
需要採取的方案
命令行參數，

646
00:33:42,630 --> 00:33:45,250
你需要有主要的這種形式。

647
00:33:45,250 --> 00:33:51,290
>> 所以這裡 - 這是大用途
的命令行參數。

648
00:33:51,290 --> 00:33:54,100
所以打印的argv 1。

649
00:33:54,100 --> 00:33:59,180
好讓我們編譯
並運行此程序。

650
00:33:59,180 --> 00:34:02,440
讓hello3。

651
00:34:02,440 --> 00:34:03,570
編譯。

652
00:34:03,570 --> 00:34:06,870
點斜線hello3。

653
00:34:06,870 --> 00:34:08,920
而讓我們說，“搶”。

654
00:34:08,920 --> 00:34:10,760
您好羅布。

655
00:34:10,760 --> 00:34:14,940
如果我說，“你好瑪麗亞，”你好瑪麗亞。

656
00:34:14,940 --> 00:34:15,719
您好瑪麗亞。

657
00:34:15,719 --> 00:34:18,639
漢娜還稱，“你好
瑪麗亞，“因為我不是

658
00:34:18,639 --> 00:34:21,340
做我們的argv 2東西。

659
00:34:21,340 --> 00:34:22,590
ARGV 2現在是“漢娜”。

660
00:34:22,590 --> 00:34:25,030
ARGC將是3。

661
00:34:25,030 --> 00:34:27,735
如果我這樣做？

662
00:34:27,735 --> 00:34:31,980

663
00:34:31,980 --> 00:34:34,679
所以，你好空。

664
00:34:34,679 --> 00:34:38,760
>> 他簡要介紹了這一事實
，從技術上，GetString的

665
00:34:38,760 --> 00:34:42,429
可能返回null，但我們會得到一個
很多成什麼空實際上是。

666
00:34:42,429 --> 00:34:47,449
但把它當作的事
事實上，沒有一般是不好的。

667
00:34:47,449 --> 00:34:50,179
我們做錯了什麼，如果
它的輸出“Hello空。”

668
00:34:50,179 --> 00:34:52,179
其原因我們做了
有些不對勁is--好，

669
00:34:52,179 --> 00:34:56,179
當我跑點斜線hello3，ARGC為1。

670
00:34:56,179 --> 00:34:59,680
因此，這意味著argv的長度為1。

671
00:34:59,680 --> 00:35:05,110
如果數組的長度為1，
唯一有效的指標是零。

672
00:35:05,110 --> 00:35:08,550
所以，這裡的argv 1是外
此數組的範圍。

673
00:35:08,550 --> 00:35:13,410
這是類似於以前，當我試圖
存儲6陣列的端外。

674
00:35:13,410 --> 00:35:18,100
所以我想訪問什麼
在argv數之外，

675
00:35:18,100 --> 00:35:21,340
而我們得到空。

676
00:35:21,340 --> 00:35:24,360
>> 所以一個更好的版本
此，一種改進，

677
00:35:24,360 --> 00:35:27,010
明確檢查ARGC。

678
00:35:27,010 --> 00:35:33,580
因此，如果ARGC等於2，這意味著我們跑
像點斜線hello3羅布。

679
00:35:33,580 --> 00:35:36,840
它會打印“你好搶。”

680
00:35:36,840 --> 00:35:39,850
如果ARGC不等於
2，那麼它只是將

681
00:35:39,850 --> 00:35:42,560
忽略不管你把
在命令行參數

682
00:35:42,560 --> 00:35:43,960
作為命令行參數。

683
00:35:43,960 --> 00:35:47,168
或者，如果你沒有把所有的一切，這是
只是要忽略這一點，只是說，

684
00:35:47,168 --> 00:35:47,960
“你好，你。”

685
00:35:47,960 --> 00:35:51,490
>> 因此，編制本。

686
00:35:51,490 --> 00:35:54,500
讓hello4。

687
00:35:54,500 --> 00:35:56,790
而運行hello4。

688
00:35:56,790 --> 00:36:00,010
跑步是這樣，
應該怎樣打印？

689
00:36:00,010 --> 00:36:01,330
“你好，你。”

690
00:36:01,330 --> 00:36:02,810
你好，你。

691
00:36:02,810 --> 00:36:05,870
那麼hello4羅布？

692
00:36:05,870 --> 00:36:06,950
“你好搶。”

693
00:36:06,950 --> 00:36:10,580
最後，你好羅布·瑪麗亞·
僅僅是“你好，你”了，

694
00:36:10,580 --> 00:36:13,677
因為你沒有真正進入
東西，它的預期。

695
00:36:13,677 --> 00:36:15,510
您輸入了更多的名字
比它可以處理，

696
00:36:15,510 --> 00:36:19,500
所以它只是默認為
你好，你的行為。

697
00:36:19,500 --> 00:36:23,040
因此，在這個問題嗎？

698
00:36:23,040 --> 00:36:26,290
或者命令行參數？

699
00:36:26,290 --> 00:36:28,690
>> 好了，縱觀一
利用夫婦更多的例子

700
00:36:28,690 --> 00:36:34,230
命令行arguments--第一
我們的argv破折號1點溫度。

701
00:36:34,230 --> 00:36:38,510
因此，意見白送什麼
這個程序應該做的。

702
00:36:38,510 --> 00:36:42,460
但是請注意now-- for循環，
這匹配的精確模式

703
00:36:42,460 --> 00:36:43,390
我說了。

704
00:36:43,390 --> 00:36:46,240
我們恰好是
用n個ARGC代替。

705
00:36:46,240 --> 00:36:48,880
現在ARGC真的是n個。

706
00:36:48,880 --> 00:36:51,260
它的argv數組的長度。

707
00:36:51,260 --> 00:36:59,600
因此，在遍歷ARGV
陣列的printf  - 荷蘭國際集團各argv的值。

708
00:36:59,600 --> 00:37:04,730
>> 所以，如果我做這個。

709
00:37:04,730 --> 00:37:08,232
請ARGV 1。

710
00:37:08,232 --> 00:37:09,940
它編譯。

711
00:37:09,940 --> 00:37:11,620
點斜線的argv 1。

712
00:37:11,620 --> 00:37:15,530
就在運行這一點，
打印點斜線的argv 1

713
00:37:15,530 --> 00:37:18,500
因為這是唯一的命令行
argument--程序名稱。

714
00:37:18,500 --> 00:37:22,080
總是會有在least--
的argc不能小於1，

715
00:37:22,080 --> 00:37:25,910
因為總會有至少
是程序名運行。

716
00:37:25,910 --> 00:37:32,040
所以argv的1羅布將打印的argv 1
然後在新行“搶”。

717
00:37:32,040 --> 00:37:36,350
>> 因此在第一次迭代
此循環中，i是0。

718
00:37:36,350 --> 00:37:39,090
ARGV 0是程序名。

719
00:37:39,090 --> 00:37:40,010
點斜線的argv 1。

720
00:37:40,010 --> 00:37:43,770
然後的argv 1是我第一次
命令行參數，這是羅布。

721
00:37:43,770 --> 00:37:45,920
在這一點上，我們是平等的像argc。

722
00:37:45,920 --> 00:37:48,210
我們跳出循環，我們就大功告成了。

723
00:37:48,210 --> 00:37:53,940
因此，這將適用於任意
命令行參數的數目。

724
00:37:53,940 --> 00:37:58,550
請注意，它打印的argv 0，argv的
1，ARGV 2，ARGV 3，argv的4。

725
00:37:58,550 --> 00:38:00,150
而且沒有ARGV 5。

726
00:38:00,150 --> 00:38:01,460
的argc等於5。

727
00:38:01,460 --> 00:38:06,960
因此，在argc--在i等於5，
我們跳出循環。

728
00:38:06,960 --> 00:38:07,950
確定。

729
00:38:07,950 --> 00:38:11,315
因此，我們之前的問題上
看一個更複雜的例子？

730
00:38:11,315 --> 00:38:14,190

731
00:38:14,190 --> 00:38:16,860
>> 所以ARGV 2。

732
00:38:16,860 --> 00:38:17,830
好的。

733
00:38:17,830 --> 00:38:20,610
因此，我們仍然打印
命令行參數。

734
00:38:20,610 --> 00:38:23,170
但現在發現，我們有
一個嵌套的循環。

735
00:38:23,170 --> 00:38:24,670
那麼，什麼是該做的？

736
00:38:24,670 --> 00:38:28,430
因此，第一個循環是做
正是以前一樣。

737
00:38:28,430 --> 00:38:30,950
我們還在遍歷
每一個命令​​行參數，

738
00:38:30,950 --> 00:38:34,260
但現在這第二loop--我們已經
之前也看到了這樣的事情。

739
00:38:34,260 --> 00:38:38,600
當他被遍歷
Zamyla打印出Z-A-M-Y-L-A。

740
00:38:38,600 --> 00:38:44,816
所以這第二個循環對於int j為
0，n等於argv的支架我的strlen的。

741
00:38:44,816 --> 00:38:49,170
>> 因此，讓我們首先想到的
the--讓我們穿行。

742
00:38:49,170 --> 00:38:53,560
讓我們思​​考什麼電腦會
怎麼做，如果我跑這個項目剛才點

743
00:38:53,560 --> 00:38:56,030
斜線的argv衝刺2。

744
00:38:56,030 --> 00:39:03,590
所以，如果我跑這個代碼，然後
的argc將是等於1。

745
00:39:03,590 --> 00:39:07,050
和字符串argv--這裡只有
將是一個索引argv中，

746
00:39:07,050 --> 00:39:12,370
而這將是等於點
斜線的argv 2--程序名稱。

747
00:39:12,370 --> 00:39:19,170
>> 好了，現在我等於0，小於我
1，我加再加對於int j為0，

748
00:39:19,170 --> 00:39:23,880
n等於argv的支架0 strlen的，所以在
此循環的第一次迭代。 ARGV

749
00:39:23,880 --> 00:39:27,250
支架0點斜線的argv 2。

750
00:39:27,250 --> 00:39:29,320
那麼，什麼是該字符串的長度？

751
00:39:29,320 --> 00:39:32,480
好了，點斜線A-R-G-V儀表板2。

752
00:39:32,480 --> 00:39:35,020
這樣的strlen的，這將是8。

753
00:39:35,020 --> 00:39:37,500
所以j為0，n等於8。

754
00:39:37,500 --> 00:39:39,530
只要j是小於8，J ++。

755
00:39:39,530 --> 00:39:44,080
有了這樣的，我們要成為
打印單個字符，它

756
00:39:44,080 --> 00:39:47,350
是argv的支架我括號學家

757
00:39:47,350 --> 00:39:49,826
>> 因此，只有我是零。

758
00:39:49,826 --> 00:39:51,700
我們仍然只有一個
命令行參數。

759
00:39:51,700 --> 00:39:53,890
在這第一次迭代
的for循環，我們

760
00:39:53,890 --> 00:39:56,950
將要印刷
argv的支架0支架0。

761
00:39:56,950 --> 00:39:58,325
然後j被要遞增。

762
00:39:58,325 --> 00:40:01,650
而且我們要打印
argv的支架0支架1。

763
00:40:01,650 --> 00:40:04,150
然後argv的支架0支架2。

764
00:40:04,150 --> 00:40:09,030
>> 所以這是我們第一次遇到
多維數組。

765
00:40:09,030 --> 00:40:12,770
還記得前面我說的
這ARGV在技術上

766
00:40:12,770 --> 00:40:15,950
字符的數組的數組。

767
00:40:15,950 --> 00:40:24,360
所以在這裡，如果我說的一樣
字符串s等於argv的支架我，

768
00:40:24,360 --> 00:40:29,590
然後我說，S支架Ĵ，這
將完成同樣的事情。

769
00:40:29,590 --> 00:40:31,960
現在，你已經看過小號支架學家

770
00:40:31,960 --> 00:40:36,680
這只是訪問的第j個
字符該字符串。

771
00:40:36,680 --> 00:40:48,010
因此，與這一點，我們所得到的
第i個的argv的第j個字符。

772
00:40:48,010 --> 00:40:51,450
>> 那麼，這應該最終輸出？

773
00:40:51,450 --> 00:40:53,210
做的argv 2。

774
00:40:53,210 --> 00:40:54,730
它編譯。

775
00:40:54,730 --> 00:40:56,340
點斜線的argv 2。

776
00:40:56,340 --> 00:41:03,790
“羅布·瑪麗亞·漢娜，”
並給我們一些空間。

777
00:41:03,790 --> 00:41:07,050
所以我們看到，這是輸出
點上了自己的線，斜線

778
00:41:07,050 --> 00:41:08,920
在自己的線路和自己的行。

779
00:41:08,920 --> 00:41:11,260
它打印出的每個
個性

780
00:41:11,260 --> 00:41:12,950
每個命令行參數。

781
00:41:12,950 --> 00:41:15,960
然後在它們之間，
因為這個新線

782
00:41:15,960 --> 00:41:19,380
我們要打印到這裡，在
他們之間它會打印新的生產線。

783
00:41:19,380 --> 00:41:24,540
>> 因此，這是類似於
以前的argv破折號1，

784
00:41:24,540 --> 00:41:26,459
它印在每個
命令行參數，

785
00:41:26,459 --> 00:41:28,500
但現在我們要打印
命令行參數

786
00:41:28,500 --> 00:41:31,950
然後通過每個迭代
每一個命令​​行參數的字符

787
00:41:31,950 --> 00:41:35,400
得到這個輸出。

788
00:41:35,400 --> 00:41:36,870
OK？

789
00:41:36,870 --> 00:41:40,570
因此，在這個問題嗎？

790
00:41:40,570 --> 00:41:45,130
>> 有一點要注意的是，
命令行arguments--

791
00:41:45,130 --> 00:41:49,990
所以它們之間用空格分隔為
你自然會期望他們。

792
00:41:49,990 --> 00:41:53,050
這樣一個串可具有在它的空間。

793
00:41:53,050 --> 00:41:57,380
這不是超級重要，但如果我
希望第三個命令行參數

794
00:41:57,380 --> 00:42:01,226
有一個空間，然後我
可以說這樣的事情。

795
00:42:01,226 --> 00:42:04,470

796
00:42:04,470 --> 00:42:05,550
OK？

797
00:42:05,550 --> 00:42:12,190
所以這個現在還只有三個
命令行arguments--以及4。

798
00:42:12,190 --> 00:42:17,620
點斜線的argv衝刺2，搶，
瑪麗亞和漢娜彭博。

799
00:42:17,620 --> 00:42:18,320
確定。

800
00:42:18,320 --> 00:42:19,310
在這個問題？

801
00:42:19,310 --> 00:42:22,700

802
00:42:22,700 --> 00:42:24,894
>> 沒有什麼特別的
有關空格字符。

803
00:42:24,894 --> 00:42:27,810
這恰好是該
命令行把空格字符

804
00:42:27,810 --> 00:42:29,226
如何你分開每一個參數。

805
00:42:29,226 --> 00:42:32,048

806
00:42:32,048 --> 00:42:33,000
好的。

807
00:42:33,000 --> 00:42:39,950
那麼接下來的問題集
two--你將是

808
00:42:39,950 --> 00:42:43,240
看著密鑰加密。

809
00:42:43,240 --> 00:42:47,700
因此，類似於在實施例
我們從聖誕故事看到，

810
00:42:47,700 --> 00:42:52,840
你將要實施的一些
即，給定的消息的算法，

811
00:42:52,840 --> 00:42:55,560
你要能
該消息加密

812
00:42:55,560 --> 00:42:58,730
只有具有這個秘密的人
鍵，用解碼器環，

813
00:42:58,730 --> 00:43:01,090
應該能夠進行解密。

814
00:43:01,090 --> 00:43:04,839
>> 所以這是標​​準版。

815
00:43:04,839 --> 00:43:07,130
你會被執行
兩個不同的版本。

816
00:43:07,130 --> 00:43:09,620
如果你碰巧看看
在現在的黑客版 - 的，

817
00:43:09,620 --> 00:43:12,600
我們打算給
你喜歡這樣的字符串，

818
00:43:12,600 --> 00:43:15,240
它表示一個加密口令。

819
00:43:15,240 --> 00:43:19,990
所以，你的目標是要弄清楚
解密的口令是什麼。

820
00:43:19,990 --> 00:43:26,950
現在，這其實是多麼的密碼
存儲在很多計算機，

821
00:43:26,950 --> 00:43:31,290
它只是存儲此
隨機字符串。

822
00:43:31,290 --> 00:43:34,440
你必須弄清楚如何獲得
從這個隨機字符串

823
00:43:34,440 --> 00:43:36,140
什麼原始密碼了。

824
00:43:36,140 --> 00:43:39,060

825
00:43:39,060 --> 00:43:43,290
>> 最後，在此之後
問題集，你應該

826
00:43:43,290 --> 00:43:46,100
能夠理解這是什麼意思。

827
00:43:46,100 --> 00:43:51,650
所以，您將學習如何解密
這種隨機的字符串。

828
00:43:51,650 --> 00:43:56,390
同樣，如果您從週記
0，你可能已經看到了這個網址。

829
00:43:56,390 --> 00:44:00,210
而且你應該能
最終解密此。

830
00:44:00,210 --> 00:44:04,810
你可能不會開心，當你
解密並點擊鏈接。

831
00:44:04,810 --> 00:44:05,700
好的。

832
00:44:05,700 --> 00:44:06,591
以上就是今天。

833
00:44:06,591 --> 00:44:12,095
所以，看到你下週！

834
00:44:12,095 --> 00:44:18,315
>> [電子音樂播放]

835
00:44:18,315 --> 00:47:15,619