1
00:00:00,000 --> 00:00:00,980

2
00:00:00,980 --> 00:00:04,410
>> [音樂播放]

3
00:00:04,410 --> 00:00:11,147

4
00:00:11,147 --> 00:00:12,230
戴維·J·馬蘭：好吧。

5
00:00:12,230 --> 00:00:16,440
這是CS50，這
是第2週的端部。

6
00:00:16,440 --> 00:00:18,480
所以，今天，我們要
繼續我們的樣子

7
00:00:18,480 --> 00:00:21,150
我們是如何表現的東西
下面的hood--搬走

8
00:00:21,150 --> 00:00:23,520
從喜歡整數的數字
和浮點值

9
00:00:23,520 --> 00:00:26,810
並專注於字符串和
最終更有趣的節目。

10
00:00:26,810 --> 00:00:30,140
但是，我們也將看看在
夫婦域專用problems--的

11
00:00:30,140 --> 00:00:33,620
其中第一個將在
是涉及到密碼學中，

12
00:00:33,620 --> 00:00:36,570
藝術加擾的信息，
你上面的看這裡

13
00:00:36,570 --> 00:00:41,480
是無線電孤兒安妮的圖片
秘密的解碼器環從昔日。

14
00:00:41,480 --> 00:00:46,490
>> 其實，這是很原始的形式
和cryptopgraphy兒童友好的形式

15
00:00:46,490 --> 00:00:50,590
由此該環有兩個disks--
1內1外。

16
00:00:50,590 --> 00:00:54,740
並通過旋轉其中的一個，就可以
本質上線像一個字母

17
00:00:54,740 --> 00:00:59,520
到Z與其他字母
像通過A.乙換句話說，

18
00:00:59,520 --> 00:01:03,730
你可以從字面上旋轉的字母，
從而想出的一個映射

19
00:01:03,730 --> 00:01:07,820
信件，信件，這樣，如果你
想送一個秘密消息

20
00:01:07,820 --> 00:01:11,820
到有人喜歡安妮，你可以寫
您的消息，然後旋轉

21
00:01:11,820 --> 00:01:15,370
字母，即，如果您的意思是
說“A”，而不是你說的“B”

22
00:01:15,370 --> 00:01:17,280
你的意思是說“B”
你不是說“C” - 

23
00:01:17,280 --> 00:01:20,240
或一些更聰明
比that--然後，最終

24
00:01:20,240 --> 00:01:24,630
只要安妮有此解碼器
環，她可以解碼該消息。

25
00:01:24,630 --> 00:01:28,540
現在，你可能還記得，其實，這
在一個非常有名的電影，是使用

26
00:01:28,540 --> 00:01:31,140
在播放廣告nauseum
聖誕季節。

27
00:01:31,140 --> 00:01:32,650
讓我們來看看這裡。

28
00:01:32,650 --> 00:01:35,294

29
00:01:35,294 --> 00:01:37,210
拉爾夫PARKER：“無論是
眾所周知，在匯總

30
00:01:37,210 --> 00:01:41,000
拉爾夫·帕克茲委任
小孤兒安妮秘密的一員

31
00:01:41,000 --> 00:01:44,860
圓，有權全部
其發生的榮譽和利益。“

32
00:01:44,860 --> 00:01:47,410
>> 拉爾夫·帕克（話外音）：
簽名小孤兒安妮。

33
00:01:47,410 --> 00:01:50,070
會簽，皮埃爾·安德烈！

34
00:01:50,070 --> 00:01:51,490
在油墨。

35
00:01:51,490 --> 00:01:55,494
榮譽和利益，
已經在九歲的時候。

36
00:01:55,494 --> 00:01:57,402
>> [音樂播放]

37
00:01:57,402 --> 00:02:00,470
>> [無線電聊天]

38
00:02:00,470 --> 00:02:01,470
拉爾夫PARKER：來吧。

39
00:02:01,470 --> 00:02:02,344
讓我們開始吧。

40
00:02:02,344 --> 00:02:06,029
我不需要所有的爵士樂
關於走私者和海盜。

41
00:02:06,029 --> 00:02:08,820
播音員：聽明天
晚上的最後冒險

42
00:02:08,820 --> 00:02:11,060
的黑色海盜船。

43
00:02:11,060 --> 00:02:14,740
現在，是時候讓安妮
秘密信息給你的成員

44
00:02:14,740 --> 00:02:17,110
的秘密圈。

45
00:02:17,110 --> 00:02:20,700
記住孩子，只有會員
安妮的秘密圈

46
00:02:20,700 --> 00:02:23,270
可以解碼安妮的秘密信息。

47
00:02:23,270 --> 00:02:27,270
>> 請記住，安妮取決於你。

48
00:02:27,270 --> 00:02:30,060
設置您的銷到B-2。

49
00:02:30,060 --> 00:02:34,004
這裡是message-- 12，11，2--

50
00:02:34,004 --> 00:02:36,503
拉爾夫·帕克（話外音）：我
我在我的第一次秘密會晤。

51
00:02:36,503 --> 00:02:40,041
電台播音員：--25，14，11，18，16--

52
00:02:40,041 --> 00:02:42,790
拉爾夫·帕克（話外音）：哦，
皮埃爾是偉大的聲音在今晚。

53
00:02:42,790 --> 00:02:46,110
我可以告訴大家，今晚的
信息是非常重要的。

54
00:02:46,110 --> 00:02:47,930
>> 電台播音員：--3，25。

55
00:02:47,930 --> 00:02:49,940
這是從伊能靜自己的消息。

56
00:02:49,940 --> 00:02:52,182
記住，不要告訴任何人。

57
00:02:52,182 --> 00:02:55,077
>> [喘氣]

58
00:02:55,077 --> 00:02:57,285
拉爾夫·帕克（話外音）：
90秒後，我

59
00:02:57,285 --> 00:03:00,090
在唯一的房間
房子裡的9個孩子

60
00:03:00,090 --> 00:03:04,380
可以坐在隱私和解碼。

61
00:03:04,380 --> 00:03:04,990
啊。

62
00:03:04,990 --> 00:03:05,680
“B”。

63
00:03:05,680 --> 00:03:06,524
>> [笑]

64
00:03:06,524 --> 00:03:08,684
>> 拉爾夫·帕克（話外音）：
我去到下一個。

65
00:03:08,684 --> 00:03:09,610
“E”。

66
00:03:09,610 --> 00:03:11,641
第一個字是“是”。

67
00:03:11,641 --> 00:03:12,140
是的！

68
00:03:12,140 --> 00:03:14,293
現在來了更容易。

69
00:03:14,293 --> 00:03:15,259
“U”。

70
00:03:15,259 --> 00:03:16,225
>> [笑]

71
00:03:16,225 --> 00:03:18,157
>> RANDY PARKER：噢，來吧，拉爾夫。

72
00:03:18,157 --> 00:03:19,606
我得走了！

73
00:03:19,606 --> 00:03:21,538
>> 拉爾夫PARKER：我馬上下來，馬。

74
00:03:21,538 --> 00:03:22,504
嘖嘖颼颼。

75
00:03:22,504 --> 00:03:25,402

76
00:03:25,402 --> 00:03:31,220
“T” “O”。 “一定
以“。”一定要“是什麼？

77
00:03:31,220 --> 00:03:33,981
什麼是小孤兒安妮
想說什麼？ “一定要”是什麼？

78
00:03:33,981 --> 00:03:35,522
母親：拉爾夫，蘭迪得走了。

79
00:03:35,522 --> 00:03:36,735
請你出來？

80
00:03:36,735 --> 00:03:38,190
>> 拉爾夫PARKER：好吧，媽媽！

81
00:03:38,190 --> 00:03:39,787
我馬上就出來了！

82
00:03:39,787 --> 00:03:41,995
拉爾夫·帕克（話外音）：
我越來越近了。

83
00:03:41,995 --> 00:03:43,370
張力是可怕的。

84
00:03:43,370 --> 00:03:44,794
那是什麼？

85
00:03:44,794 --> 00:03:47,656
地球的命運
可以掛在平衡。

86
00:03:47,656 --> 00:03:50,518
>> 母親：拉爾夫，蘭迪的得走了！

87
00:03:50,518 --> 00:03:53,635
>> 拉爾夫PARKER：我馬上就
出來，哭出聲來！

88
00:03:53,635 --> 00:03:55,343
拉爾夫PARKER
（話外音）：幾乎沒有！

89
00:03:55,343 --> 00:03:56,520
我的手指飛了！

90
00:03:56,520 --> 00:03:58,500
我的心是鋼的陷阱。

91
00:03:58,500 --> 00:03:59,850
每一個毛孔振動。

92
00:03:59,850 --> 00:04:01,806
這幾乎是清楚的！

93
00:04:01,806 --> 00:04:02,773
是的！

94
00:04:02,773 --> 00:04:03,273
是的！

95
00:04:03,273 --> 00:04:03,773
是的！

96
00:04:03,773 --> 00:04:04,740
是的！

97
00:04:04,740 --> 00:04:10,250
>> 拉爾夫PARKER：“一定
喝你的阿華田。“

98
00:04:10,250 --> 00:04:10,750
阿華田？

99
00:04:10,750 --> 00:04:14,864

100
00:04:14,864 --> 00:04:17,539
à照出的商業？

101
00:04:17,539 --> 00:04:19,439
>> [音樂播放]

102
00:04:19,439 --> 00:04:21,724
>> 拉爾夫PARKER：狗娘養的。

103
00:04:21,724 --> 00:04:23,460
>> （笑）

104
00:04:23,460 --> 00:04:27,070
>> 戴維·J·馬蘭：所以這則是
驚鴻一瞥的密碼是什麼

105
00:04:27,070 --> 00:04:29,880
可以為this--à
喝從昔日。

106
00:04:29,880 --> 00:04:30,900
所以簡單公告。

107
00:04:30,900 --> 00:04:33,410
如果你是自由的這
週五下午1點15分，並會

108
00:04:33,410 --> 00:04:36,610
想加入我們CS50
午餐前往該網址在這裡。

109
00:04:36,610 --> 00:04:38,080
先來先服務如常。

110
00:04:38,080 --> 00:04:41,840
但隨著時間的推移，我們將確保
大多數人誰願意參加

111
00:04:41,840 --> 00:04:43,640
可安排明智的。

112
00:04:43,640 --> 00:04:45,170
>> 所以字符串。

113
00:04:45,170 --> 00:04:47,940
我們有Zamyla--人
你現在見過最有可能

114
00:04:47,940 --> 00:04:50,750
在習題集1--的
名字是這樣拼寫。

115
00:04:50,750 --> 00:04:53,570
並假設你輸入她的名字
成計算機程序，是

116
00:04:53,570 --> 00:04:55,710
使用類似的getString。

117
00:04:55,710 --> 00:04:57,890
為了檢索
這些按鍵，怎麼

118
00:04:57,890 --> 00:05:01,620
做才好較
字符串，一句話，一個段落，

119
00:05:01,620 --> 00:05:03,960
或多個字母這樣的嗎？

120
00:05:03,960 --> 00:05:06,790
>> 我們談最後一次約
整數和問題

121
00:05:06,790 --> 00:05:09,960
出現整數溢出
和浮點值

122
00:05:09,960 --> 00:05:12,190
和問題
出現在精度範圍內。

123
00:05:12,190 --> 00:05:16,080
隨著弦，我們至少
有一點更靈活

124
00:05:16,080 --> 00:05:17,970
因為strings--剛
在現實天下 - 

125
00:05:17,970 --> 00:05:19,790
可以是一個漂亮的任意長度。

126
00:05:19,790 --> 00:05:21,055
很短的，長的漂亮。

127
00:05:21,055 --> 00:05:23,680
但即便如此，我們要
發現電腦有時可以

128
00:05:23,680 --> 00:05:27,200
運行內存不足，甚至沒有
存儲一個足夠大的字符串。

129
00:05:27,200 --> 00:05:30,840
>> 但現在，讓我們開始顯現
字符串的東西在這些箱子

130
00:05:30,840 --> 00:05:31,340
這裡。

131
00:05:31,340 --> 00:05:36,410
所以六個這樣的盒，其中每個
代表一個字符或“字符”。

132
00:05:36,410 --> 00:05:40,646
所以記得“字符” -  C-H-A-R--是
在C中的內置的數據類型中的一種

133
00:05:40,646 --> 00:05:43,520
這有什麼好看的，你可以用
之類的，作為一個構建塊，

134
00:05:43,520 --> 00:05:47,880
一塊拼圖，如果你願意，形成
較大的數據類型，我們將繼續

135
00:05:47,880 --> 00:05:49,410
調用“弦”。

136
00:05:49,410 --> 00:05:53,650
>> 現在，是關於思維有用
這樣的事情在這樣的字符串？

137
00:05:53,650 --> 00:05:57,720
嗯，事實證明，我們可以
實際利用這種結構

138
00:05:57,720 --> 00:06:01,420
實際訪問單個字符
在一個非常簡單的方法。

139
00:06:01,420 --> 00:06:04,099
我要繼續前進，創造
一個名為“stringzero.c”

140
00:06:04,099 --> 00:06:05,765
但你可以把它叫做任何你願意的話​​。

141
00:06:05,765 --> 00:06:08,500
而在球場上的網站是
已經是這個例子中前進，

142
00:06:08,500 --> 00:06:10,430
所以你不需要
輸入所有的東西。

143
00:06:10,430 --> 00:06:13,820
>> 而且我要繼續前進
和第一次做INT主要作廢。

144
00:06:13,820 --> 00:06:15,980
而在幾天之內，
我們將開始捉弄分開

145
00:06:15,980 --> 00:06:19,070
虛空是什麼在這裡，為什麼它的
整型旁邊主，等等。

146
00:06:19,070 --> 00:06:21,180
但現在，讓我們繼續
複製粘貼。

147
00:06:21,180 --> 00:06:23,455
>> 我要宣布一個名為s字符串。

148
00:06:23,455 --> 00:06:26,920
而我要的回報
GetString的在任何用戶類型。

149
00:06:26,920 --> 00:06:29,170
這將是一個簡單的
程序，沒有說明，

150
00:06:29,170 --> 00:06:31,336
我只是盲目地
期望用戶知道

151
00:06:31,336 --> 00:06:32,600
怎樣做才能保持它的簡單。

152
00:06:32,600 --> 00:06:34,220
>> 而現在，我將有一個for循環。

153
00:06:34,220 --> 00:06:37,450
我的for循環裡面，我
將有INT I變零。

154
00:06:37,450 --> 00:06:40,660
我是，也只是一個慣例，
索引變量計數，

155
00:06:40,660 --> 00:06:42,350
但我可以把這個我想做的事情。

156
00:06:42,350 --> 00:06:46,275
我要做的i小於than--好
Zamyla的名字是6個字母。

157
00:06:46,275 --> 00:06:48,150
所以我要努力
代碼那裡了。

158
00:06:48,150 --> 00:06:49,730
>> 然後對我有用。

159
00:06:49,730 --> 00:06:53,190
而現在這裡面的捲髮
括號我會做的printf，

160
00:06:53,190 --> 00:06:55,460
我想打印一個
字符一次。

161
00:06:55,460 --> 00:06:58,227
所以我打算用％下
也許是第一次。

162
00:06:58,227 --> 00:07:00,560
然後，我要打印的每張
性格上自己的路線。

163
00:07:00,560 --> 00:07:02,550
所以我要放
小反斜杠Ñ那裡。

164
00:07:02,550 --> 00:07:03,640
關閉股票。

165
00:07:03,640 --> 00:07:06,250
>> 現在我想要做的東西在這裡。

166
00:07:06,250 --> 00:07:10,610
我想打印出來的
在字符串中的特定字母，

167
00:07:10,610 --> 00:07:13,670
S，因為我遍歷
從零上多達六個。

168
00:07:13,670 --> 00:07:17,150
換句話說，我要
打印s的第i個字符。

169
00:07:17,150 --> 00:07:18,420
現在我該怎麼辦呢？

170
00:07:18,420 --> 00:07:21,550
>> 嗯很像箱子
這表示在這裡，

171
00:07:21,550 --> 00:07:25,560
種，想起了拳擊的概念
在信中，您同樣可以做到這一點

172
00:07:25,560 --> 00:07:32,630
語法簡單的通過指定在C中，
我想打印輸出S的第i個字符。

173
00:07:32,630 --> 00:07:35,640
使用方括號
您的計算機鍵盤上

174
00:07:35,640 --> 00:07:38,910
在美式鍵盤上的
一般在你的返回鍵。

175
00:07:38,910 --> 00:07:42,630
>> 因此，這是不完全正確
然而，正如你可能已經注意到了。

176
00:07:42,630 --> 00:07:44,780
不過，我要種
一味地在這裡開拓進取。

177
00:07:44,780 --> 00:07:47,020
而我要做的事情做出字符串0。

178
00:07:47,020 --> 00:07:50,860
但我沒有這樣做的，如果讓我們看看
無法預料的一些常見的錯誤。

179
00:07:50,860 --> 00:07:52,844
這是怎麼回事編譯？

180
00:07:52,844 --> 00:07:54,510
不，我錯過了一大堆東西。

181
00:07:54,510 --> 00:07:55,280
圖書館聽說。

182
00:07:55,280 --> 00:07:58,480
>> 那麼，哪頭文件
我可能要在這裡補充的嗎？

183
00:07:58,480 --> 00:07:59,205
是啊。

184
00:07:59,205 --> 00:08:01,580
>> 聽眾：您需要
標準I / O [聽不清]

185
00:08:01,580 --> 00:08:02,663
>> 戴維·J·馬蘭：優秀。

186
00:08:02,663 --> 00:08:06,060
所以，我需要標準I / O。為了什麼
這樣做的目的我想標準的I / O？

187
00:08:06,060 --> 00:08:06,670
對於printf的。

188
00:08:06,670 --> 00:08:09,220
所以，包含了stdio.h。

189
00:08:09,220 --> 00:08:13,490
你也建議我加入
在CS50的圖書館是什麼原因呢？

190
00:08:13,490 --> 00:08:14,650
有字符串。

191
00:08:14,650 --> 00:08:17,780
所以我們會看到什麼
CS50的圖書館正在做

192
00:08:17,780 --> 00:08:19,260
創建一個字符串的這個概念。

193
00:08:19,260 --> 00:08:21,930
但現在，你可以認為
它作為一個實際的數據類型。

194
00:08:21,930 --> 00:08:23,596
>> 因此，這似乎是一點點清理。

195
00:08:23,596 --> 00:08:27,060
現在我要繼續前進
確實做到讓字符串0。

196
00:08:27,060 --> 00:08:27,700
編譯。

197
00:08:27,700 --> 00:08:28,370
所以這是很好的。

198
00:08:28,370 --> 00:08:32,799
所以./string0讓我放大，使我們可以
看到更加緊密地發生了什麼。

199
00:08:32,799 --> 00:08:33,850
輸入。

200
00:08:33,850 --> 00:08:37,789
Z-à-M-Y-L-A輸入。

201
00:08:37,789 --> 00:08:39,440
我們已經印出來Zamyla的名字。

202
00:08:39,440 --> 00:08:40,409
>> 所以這是相當不錯的。

203
00:08:40,409 --> 00:08:43,220
所以，現在讓我們繼續前進，
再次運行此程序，

204
00:08:43,220 --> 00:08:45,659
並輸入了Daven的全名。

205
00:08:45,659 --> 00:08:46,450
驚喜，驚喜。

206
00:08:46,450 --> 00:08:48,021
輸入。

207
00:08:48,021 --> 00:08:48,520
嗯。

208
00:08:48,520 --> 00:08:51,750
我們沒有印刷Daven的
全名字正確。

209
00:08:51,750 --> 00:08:54,250
現在，這應該是顯而易見的
回想起來的原因是什麼，

210
00:08:54,250 --> 00:08:57,010
樣的，愚蠢的設計決定？

211
00:08:57,010 --> 00:08:59,590
>> 是啊，我硬編碼了
6裡面我的for循環。

212
00:08:59,590 --> 00:09:01,610
現在我這樣做只是因為
我知道Zamyla的名字

213
00:09:01,610 --> 00:09:02,776
將是六個字母。

214
00:09:02,776 --> 00:09:04,720
但可以肯定這不是
一般的解決方案。

215
00:09:04,720 --> 00:09:07,720
所以，事實證明，我們可以動態
找出一個字符串的長度

216
00:09:07,720 --> 00:09:10,440
通過調用一個名為的strlen函數。

217
00:09:10,440 --> 00:09:12,840
>> 同樣，故意
簡潔的命名只是

218
00:09:12,840 --> 00:09:14,450
以使其更方便地輸入。

219
00:09:14,450 --> 00:09:17,170
但是，這等同於
得到一個字符串的長度。

220
00:09:17,170 --> 00:09:23,190
我將返​​回到我的終端
窗口並重新編譯運行。

221
00:09:23,190 --> 00:09:24,170
但它吼我。

222
00:09:24,170 --> 00:09:29,130
隱式聲明的庫函數
strlen的使用unsigned int型const--

223
00:09:29,130 --> 00:09:29,780
我迷路了。

224
00:09:29,780 --> 00:09:30,590
完全。

225
00:09:30,590 --> 00:09:32,940
>> 因此，特別是作為
眼神開始呆滯

226
00:09:32,940 --> 00:09:36,000
像這樣的錯誤信息，重點
老老實實的前幾個字。

227
00:09:36,000 --> 00:09:38,590
我們知道問題出在
8號線，如下所示。

228
00:09:38,590 --> 00:09:40,500
而且它是在字符串0.c。

229
00:09:40,500 --> 00:09:43,580
隱式聲明
庫函數strlen的。

230
00:09:43,580 --> 00:09:47,000
使一般要
是錯誤消息的格局。

231
00:09:47,000 --> 00:09:49,190
隱式聲明的東西。

232
00:09:49,190 --> 00:09:53,250
>> 因此，在短期，你有什麼我似乎
這樣做就線8條，在這裡。

233
00:09:53,250 --> 00:09:56,880
什麼可能的解決方案是偶數
如果你從來沒有使用strlen的自己嗎？

234
00:09:56,880 --> 00:09:58,907
>> 聽眾：不同的庫中的一部分？

235
00:09:58,907 --> 00:10:00,740
戴維·J·馬蘭：第一部分
不同的庫。

236
00:10:00,740 --> 00:10:02,400
因此，特此聲明，可以這麼說。

237
00:10:02,400 --> 00:10:07,510
它提到了一些文件
比stdio.h中和CS50.h.其他

238
00:10:07,510 --> 00:10:09,179
現在它在哪兒定義的？

239
00:10:09,179 --> 00:10:12,220
說實話，你要么只是
知道這一關你的頭頂，

240
00:10:12,220 --> 00:10:13,640
或者你google一下，看看。

241
00:10:13,640 --> 00:10:18,150
或者知道這一點，我已經打開了，在CS50
設備上的終端程序，這

242
00:10:18,150 --> 00:10:22,200
是只大，全屏版
什麼是gedit中的窗口的底部。

243
00:10:22,200 --> 00:10:24,970
>> 而事實證明，有一個
同樣簡潔的命令，稱為

244
00:10:24,970 --> 00:10:29,280
男子手冊，在那裡，如果你鍵入
一個函數的名稱，然後按Enter鍵，

245
00:10:29,280 --> 00:10:32,240
你會得到相當
神秘的文檔。

246
00:10:32,240 --> 00:10:35,299
這只是文字一般
看起來有點像這樣。

247
00:10:35,299 --> 00:10:37,090
這是一個有點勢不可擋
乍看之下。

248
00:10:37,090 --> 00:10:39,048
但是，坦率地說我要去
讓我的目光呆滯

249
00:10:39,048 --> 00:10:41,930
而只專注於部分
我關心的時刻。

250
00:10:41,930 --> 00:10:42,780
>> 這是這樣的。

251
00:10:42,780 --> 00:10:45,470
它看起來像結構
東西我很熟悉。

252
00:10:45,470 --> 00:10:48,080
事實上，手冊頁，所以
說話，會告訴你

253
00:10:48,080 --> 00:10:51,590
在什麼頭文件中的函數
像strlen的定義。

254
00:10:51,590 --> 00:10:54,170
所以我現在要回去gedit的。

255
00:10:54,170 --> 00:10:59,070
而且我要繼續前進，
加上這裡的#in​​clude

256
00:10:59,070 --> 00:11:00,480
並保存文件。

257
00:11:00,480 --> 00:11:04,300
>> 我要清除屏幕
控制L如果你一直想知道。

258
00:11:04,300 --> 00:11:08,210
而我要重新運行make
string.0，編譯這個時候。

259
00:11:08,210 --> 00:11:11,790
./string.0 Zamyla。

260
00:11:11,790 --> 00:11:15,020
這似乎工作讓我走
進取，與達文波特重新運行它。

261
00:11:15,020 --> 00:11:15,860
輸入。

262
00:11:15,860 --> 00:11:17,730
而這也似乎工作。

263
00:11:17,730 --> 00:11:21,220
>> 因此，我們可以做得比這好一點，
不過，我們可以開始整理東西

264
00:11:21,220 --> 00:11:23,257
最多只是一點點。

265
00:11:23,257 --> 00:11:25,590
我要去實際
下面介紹一件事。

266
00:11:25,590 --> 00:11:28,930
我要繼續前進，
它保存在不同的文件。

267
00:11:28,930 --> 00:11:31,770
我要去打電話
此文件string1.c剛

268
00:11:31,770 --> 00:11:34,620
為與代碼一致
你可以在網上找到。

269
00:11:34,620 --> 00:11:37,050
>> 讓我們集中在
完全相同的代碼。

270
00:11:37,050 --> 00:11:39,000
事實證明，我已經
是一種了結

271
00:11:39,000 --> 00:11:42,600
理所當然的是，我的筆記本電腦，
並且反過來，CS50器具

272
00:11:42,600 --> 00:11:47,450
有很多記憶，很多
內存，有很大的空間的字節

273
00:11:47,450 --> 00:11:48,920
我在其中可以存儲字符串。

274
00:11:48,920 --> 00:11:53,560
>> 但現實的情況，如果我輸入長
夠了，夠按鍵，

275
00:11:53,560 --> 00:11:56,170
我可以在理論上類型
在多個字符

276
00:11:56,170 --> 00:11:58,830
比我的電腦
實際擁有的內存。

277
00:11:58,830 --> 00:11:59,830
這是有問題的。

278
00:11:59,830 --> 00:12:03,050
就像一個int只能
算如此之高，從理論上講，

279
00:12:03,050 --> 00:12:06,600
你只能塞進這麼多字
到您的計算機的RAM或隨機

280
00:12:06,600 --> 00:12:07,920
存取記憶體。

281
00:12:07,920 --> 00:12:11,140
>> 所以我不得不更好地預測
這個問題，甚至

282
00:12:11,140 --> 00:12:13,660
雖然它可能是一個罕見的
角落裡的情況下，可以這麼說。

283
00:12:13,660 --> 00:12:15,670
不會發生的時候，可能會發生。

284
00:12:15,670 --> 00:12:18,815
如果它發生，我不
預測和計劃吧，

285
00:12:18,815 --> 00:12:20,300
我的程序可以做誰知道。

286
00:12:20,300 --> 00:12:22,220
凍結，死機重啟，等等。

287
00:12:22,220 --> 00:12:24,490
一些預期可能會發生。

288
00:12:24,490 --> 00:12:27,120
>> 那麼，我該怎麼辦
現在，今後真的，

289
00:12:27,120 --> 00:12:31,630
之前我曾經盲目
使用一個變量，比如s的

290
00:12:31,630 --> 00:12:36,790
已分配的返回值
其他一些功能如GetString的，

291
00:12:36,790 --> 00:12:40,200
我要確保
它的值是有效的。

292
00:12:40,200 --> 00:12:44,280
所以，我只知道，從已經閱讀
CS50的文檔的GetString，

293
00:12:44,280 --> 00:12:49,020
最終，我們將會為你在，
該形式返回一個特殊的符號

294
00:12:49,020 --> 00:12:53,610
稱為NULL，N-U-L-L中的所有
帽子，一旦出了問題。

295
00:12:53,610 --> 00:12:55,650
>> 所以通常情況下，它返回一個字符串。

296
00:12:55,650 --> 00:12:59,700
但除此之外，如果它返回n-U-L-L--
我們最終會看到什麼是真正的

297
00:12:59,700 --> 00:13:01,790
是指：這只是意味著
壞事發生。

298
00:13:01,790 --> 00:13:05,560
現在，這意味著，就像在刮，
我可以在這裡查詢的條件在C中，

299
00:13:05,560 --> 00:13:08,830
如果s不等於NULL。

300
00:13:08,830 --> 00:13:11,930
所以，如果你還沒有見過這個，
這也就意味著不等於。

301
00:13:11,930 --> 00:13:15,290
>> 所以它的對立面
平等的平等，其中還記得，

302
00:13:15,290 --> 00:13:18,940
從單一的不同
等於，這是分配。

303
00:13:18,940 --> 00:13:23,030
所以如果s不等於
空，才做

304
00:13:23,030 --> 00:13:25,980
我想執行的代碼行。

305
00:13:25,980 --> 00:13:28,080
因此，換句話說，
之前，我在潛水盲目

306
00:13:28,080 --> 00:13:30,919
並開始迭代
在S和處理它

307
00:13:30,919 --> 00:13:33,710
就好像它是一個序列
人物，我會先檢查，

308
00:13:33,710 --> 00:13:37,900
等一下，是絕對不是
等於這個特殊值，空值？

309
00:13:37,900 --> 00:13:40,030
>> 因為如果是這樣，壞的事情都可能發生。

310
00:13:40,030 --> 00:13:43,080
而現在，假設壞事
發生意味著你的程序崩潰，

311
00:13:43,080 --> 00:13:45,070
而且你不一定能恢復。

312
00:13:45,070 --> 00:13:46,800
所以，坦率地說，它看起來醜陋。

313
00:13:46,800 --> 00:13:48,660
種它現在混亂的看了一眼。

314
00:13:48,660 --> 00:13:50,780
但是，這將變得更
不久熟悉。

315
00:13:50,780 --> 00:13:52,920
>> 但我要提出
現在另外一個改進。

316
00:13:52,920 --> 00:13:54,660
這是一個改善的正確性。

317
00:13:54,660 --> 00:13:58,800
我的計劃是現在比較正確的，因為
在罕見的情況下，沒有足夠的記憶體

318
00:13:58,800 --> 00:14:01,180
存在，我會處理這件事，
而我就什麼也不做。

319
00:14:01,180 --> 00:14:02,680
至少我不會崩潰。

320
00:14:02,680 --> 00:14:05,000
>> 但是，讓我們做一個最終版本在這裡。

321
00:14:05,000 --> 00:14:07,690
和一個文件名為string2.c。

322
00:14:07,690 --> 00:14:10,190
我要粘貼
相同的代碼只是一瞬間，

323
00:14:10,190 --> 00:14:14,210
而我要強調這
線，11日，在這裡，一會兒就好了。

324
00:14:14,210 --> 00:14:18,179
現在的實際情況是，聰明的編譯器
像鏘能夠解決這一問題，我們

325
00:14:18,179 --> 00:14:19,970
幕後
沒有我們曾經知道。

326
00:14:19,970 --> 00:14:24,670
但是讓我們想想這
從根本上是有問題的設計。

327
00:14:24,670 --> 00:14:29,010
>> 這行代碼，當然，
他說，初始化一些變量i為0。

328
00:14:29,010 --> 00:14:30,260
這是非常簡單的。

329
00:14:30,260 --> 00:14:34,691
什麼又是這樣的
聲明中，在這裡，我有用，在做什麼？

330
00:14:34,691 --> 00:14:37,066
我們已經看到過，但我們
沒有真正談論它。

331
00:14:37,066 --> 00:14:37,900
>> 聽眾：遞增島

332
00:14:37,900 --> 00:14:39,191
>> 戴維·J·馬蘭：遞增島

333
00:14:39,191 --> 00:14:41,890
因此，在每次迭代中通過
這個循環中，每一個循環中，

334
00:14:41,890 --> 00:14:43,570
你是遞增i增加1。

335
00:14:43,570 --> 00:14:45,740
所以它變大，大，和
做大，直到循環終止。

336
00:14:45,740 --> 00:14:46,810
它是如何終止？

337
00:14:46,810 --> 00:14:49,430
那麼有這個中間
這是我們以前使用的條件。

338
00:14:49,430 --> 00:14:52,500
你見過在
預排在P組。

339
00:14:52,500 --> 00:14:53,880
>> 但是，這是什麼意思嗎？

340
00:14:53,880 --> 00:14:58,352
請執行下列操作循環，使
只要i小於什麼？

341
00:14:58,352 --> 00:14:59,810
聽眾：字符串的長度。

342
00:14:59,810 --> 00:15:01,518
戴維·J·馬蘭：本
長度的字串。

343
00:15:01,518 --> 00:15:04,300
所以它轉換很乾淨
英語在這個意義上。

344
00:15:04,300 --> 00:15:08,810
現在的問題是，每一次我
通過此循環迭代理論上

345
00:15:08,810 --> 00:15:10,000
我在問這個問題。

346
00:15:10,000 --> 00:15:12,250
為i小於s的字符串的長度？

347
00:15:12,250 --> 00:15:14,500
為i小於s的字符串的長度？

348
00:15:14,500 --> 00:15:18,380
>> 現在也是我改變在每次迭代？

349
00:15:18,380 --> 00:15:18,880
是的。

350
00:15:18,880 --> 00:15:19,629
因為+ +的。

351
00:15:19,629 --> 00:15:21,700
所以，每一次迭代i的越來越大。

352
00:15:21,700 --> 00:15:25,411
但為s挺大的，或
較小，或改變在所有？

353
00:15:25,411 --> 00:15:25,910
號

354
00:15:25,910 --> 00:15:30,240
所以在設計方面，其中一個軸
同時，我們試圖評估代碼

355
00:15:30,240 --> 00:15:32,610
在課堂上，這種感覺有點愚蠢。

356
00:15:32,610 --> 00:15:34,690
>> 就像你從字面上看，
在每一次迭代

357
00:15:34,690 --> 00:15:37,110
這個循環的要求
同樣譴責的問題了，

358
00:15:37,110 --> 00:15:40,770
又一次，又一次，和字面
這是永遠不會改變的。

359
00:15:40,770 --> 00:15:44,220
至少如果我沒有碰s和
試圖改變s的內容。

360
00:15:44,220 --> 00:15:46,610
因此，我可以做得比這更好一點。

361
00:15:46,610 --> 00:15:49,530
>> 而我什麼都做不
聲明只有一個變量i，

362
00:15:49,530 --> 00:15:53,330
但第二個變量我會隨意，
但傳統上，正調用它。

363
00:15:53,330 --> 00:15:55,940
分配N個相等的
第字符串的長度。

364
00:15:55,940 --> 00:15:59,090
然後在這裡，我要
做一個聰明的小優化，使

365
00:15:59,090 --> 00:16:03,460
可以說，在一天結束時
不再是正確的或不正確的少

366
00:16:03,460 --> 00:16:04,260
比以前。

367
00:16:04,260 --> 00:16:05,500
但它是一個更好的設計。

368
00:16:05,500 --> 00:16:09,480
在事實上，我使用
更少的時間，更少的CPU週期，因此

369
00:16:09,480 --> 00:16:14,040
說話，回答同樣的
的問題，但只有一次。

370
00:16:14,040 --> 00:16:17,870
>> 上一般的任何問題
改進的原則，

371
00:16:17,870 --> 00:16:21,294
說，程序的效率？

372
00:16:21,294 --> 00:16:21,991
是嗎？

373
00:16:21,991 --> 00:16:23,699
聽眾：你為什麼
使用[聽不清]？

374
00:16:23,699 --> 00:16:25,760

375
00:16:25,760 --> 00:16:27,010
戴維·J·馬蘭：好問題。

376
00:16:27,010 --> 00:16:30,690
那麼，為什麼我們把+ +上月底
í而不是I的開始？

377
00:16:30,690 --> 00:16:33,070
在這種情況下，它具有
沒有功能的影響。

378
00:16:33,070 --> 00:16:36,670
而在一般情況下，我傾向於
使用後綴運算符

379
00:16:36,670 --> 00:16:41,750
所以，這是一個更加清楚一點的
至當操作正在發生。

380
00:16:41,750 --> 00:16:46,670
>> 對於那些不熟悉的，還有另一種
語句，讓你可以做+ +我。

381
00:16:46,670 --> 00:16:48,747
這些都是功能
在這種情況下，等同

382
00:16:48,747 --> 00:16:51,080
因為沒有什麼別的
周圍的增量。

383
00:16:51,080 --> 00:16:54,435
但是，你能想出
宗和代碼行

384
00:16:54,435 --> 00:16:55,810
其中有差別。

385
00:16:55,810 --> 00:16:57,810
所以一般情況下，我們不
甚至談論這個。

386
00:16:57,810 --> 00:17:00,690
因為坦率地說，它使你的
代碼性感，和排序的雨衣，

387
00:17:00,690 --> 00:17:01,776
和更少的字符。

388
00:17:01,776 --> 00:17:04,859
但現實是它的很多困難，
我想，即使我來包裝我的腦海

389
00:17:04,859 --> 00:17:07,319
周圍有時，
操作的順序。

390
00:17:07,319 --> 00:17:09,750
所以順便說一句，如果你
真的不喜歡這樣，

391
00:17:09,750 --> 00:17:14,650
即使這是種性感
看，你也可以做I + = 1，

392
00:17:14,650 --> 00:17:18,880
這是對的醜陋版
postfix的增量同樣的想法。

393
00:17:18,880 --> 00:17:22,250
>> 我這樣說，你
應該取笑它，

394
00:17:22,250 --> 00:17:25,140
但你會看到代碼
一些之前長的漂亮。

395
00:17:25,140 --> 00:17:27,160
>> [笑]

396
00:17:27,160 --> 00:17:28,410
>> 戴維·J·馬蘭：是嗎？

397
00:17:28,410 --> 00:17:29,360
是啊。

398
00:17:29,360 --> 00:17:30,480
問題在中間。

399
00:17:30,480 --> 00:17:32,146
>> 聽眾：你需要說INT N'

400
00:17:32,146 --> 00:17:34,020
戴維·J·馬蘭：你這樣做
不用說INTñ。

401
00:17:34,020 --> 00:17:37,670
所以，因為我們已經說過詮釋，
你不必說了一遍。

402
00:17:37,670 --> 00:17:41,820
美中不足的是，n具有以
具有相同的數據類型，因為我。

403
00:17:41,820 --> 00:17:43,310
所以，這只是一個在這裡方便。

404
00:17:43,310 --> 00:17:44,058
是啊。

405
00:17:44,058 --> 00:17:47,806
>> 聽眾：你可以去比
打印字符s支架我又？

406
00:17:47,806 --> 00:17:48,930
戴維·J·馬蘭：當然可以。

407
00:17:48,930 --> 00:17:52,110
所以％C，從去年召回
時間，只是一個佔位符。

408
00:17:52,110 --> 00:17:53,930
這意味著把一個char這裡。

409
00:17:53,930 --> 00:17:56,780
反斜杠N，當然，只是
手段把換行符這裡。

410
00:17:56,780 --> 00:17:59,540
所以，剛剛離開，現在，
這片新的語法。

411
00:17:59,540 --> 00:18:03,730
這是從字面上說，搶
字符串稱為S去得到它

412
00:18:03,730 --> 00:18:06,050
第i個字符，可以這麼說。

413
00:18:06,050 --> 00:18:10,590
>> 我一直說的第i個字符
因為在這個循環的每次迭代

414
00:18:10,590 --> 00:18:14,540
這是因為，雖然我們打印
出，頭s支架0，

415
00:18:14,540 --> 00:18:15,780
作為一個程序員可能會說。

416
00:18:15,780 --> 00:18:18,680
那麼S支架1，則S
支架2，然後是3，然後是4。

417
00:18:18,680 --> 00:18:21,610
當然，它是一個變量，
所以我只是表達它與I。

418
00:18:21,610 --> 00:18:23,900
>> 鍵，雖然是實現，
特別是如果你不

419
00:18:23,900 --> 00:18:26,358
被馴化了這個世界
編程時，我們都

420
00:18:26,358 --> 00:18:28,950
似乎從零來算，得
現在就開始從零計數。

421
00:18:28,950 --> 00:18:35,130
因為字符串，第一個字符時，
ž在Zamyla是好還是壞

422
00:18:35,130 --> 00:18:40,490
要住在的位置數為零。

423
00:18:40,490 --> 00:18:48,210
>> 好吧，讓我帶
我們回到這裡Zamyla

424
00:18:48,210 --> 00:18:50,746
看看到底發生了什麼
在引擎蓋下方。

425
00:18:50,746 --> 00:18:52,370
因此，有型鑄造這個概念。

426
00:18:52,370 --> 00:18:53,800
你可能有實際
玩這個已經，

427
00:18:53,800 --> 00:18:55,970
也許對黑客
的P版的設定之一。

428
00:18:55,970 --> 00:19:00,320
但是，類型轉換只是指
在C和能力的其他語言

429
00:19:00,320 --> 00:19:03,170
到一種數據類型轉換成另一種。

430
00:19:03,170 --> 00:19:05,450
>> 現在怎麼可能，我們看到這個
很直截了當？

431
00:19:05,450 --> 00:19:08,530
所以這一點，召回，是開始
的英文字母。

432
00:19:08,530 --> 00:19:11,265
和上下文，還記得，從
就像一個星期前是ASCII碼。

433
00:19:11,265 --> 00:19:13,790
美國標準守則
信息交換。

434
00:19:13,790 --> 00:19:17,080
這只是一個很長的路要走
的說法，從字母的映射

435
00:19:17,080 --> 00:19:19,370
為數字，從數字到字母。

436
00:19:19,370 --> 00:19:22,940
>> 因此通過併購在這裡，點點
點，線了，召回，

437
00:19:22,940 --> 00:19:25,582
十進制數65就到了。

438
00:19:25,582 --> 00:19:27,290
我們沒有談
這個明確的，

439
00:19:27,290 --> 00:19:29,850
但肯定有相似
數字為小寫字母。

440
00:19:29,850 --> 00:19:30,820
事實上，有。

441
00:19:30,820 --> 00:19:33,730
世界決定有些年頭
以前，小A，小寫，

442
00:19:33,730 --> 00:19:35,020
將是97。

443
00:19:35,020 --> 00:19:38,010
和小B是怎麼回事
為98，依此類推。

444
00:19:38,010 --> 00:19:40,200
>> 和任何其他關鍵
您的鍵盤，還有

445
00:19:40,200 --> 00:19:42,190
會是位類似的模式。

446
00:19:42,190 --> 00:19:44,540
或者等價地，一個十進制數。

447
00:19:44,540 --> 00:19:47,110
因此，在手頭上的問題，
那麼，我們怎樣才能

448
00:19:47,110 --> 00:19:49,400
其實看到這個引擎蓋底下？

449
00:19:49,400 --> 00:19:51,539
所以，我打算去到gedit的一次。

450
00:19:51,539 --> 00:19:53,330
而非類型
這一個從無到有，

451
00:19:53,330 --> 00:19:55,330
我要繼續前進，
剛剛開放的東西

452
00:19:55,330 --> 00:19:58,350
從今天的代碼稱為ASCII碼為零。

453
00:19:58,350 --> 00:20:01,210
>> 和ASCII零看起來是這樣的。

454
00:20:01,210 --> 00:20:02,710
因此，讓我們環繞這是我們的想法。

455
00:20:02,710 --> 00:20:04,969
因此，首先，我已經評論
代碼，這是很好的。

456
00:20:04,969 --> 00:20:07,010
因為它的字面意思
告訴我會發生什麼，

457
00:20:07,010 --> 00:20:08,950
顯示大寫字母的映射。

458
00:20:08,950 --> 00:20:13,690
現在，我不太知道我
那是什麼意思，所以讓我們推斷。

459
00:20:13,690 --> 00:20:16,870
>> 在英語中，也許
有些技術人員英語，

460
00:20:16,870 --> 00:20:20,660
什麼呢行18出現
在做我們呢？

461
00:20:20,660 --> 00:20:21,500
就在第18行。

462
00:20:21,500 --> 00:20:22,430
它是什麼引起？

463
00:20:22,430 --> 00:20:25,192
什麼是它要在這裡揭開序幕？

464
00:20:25,192 --> 00:20:26,100
>> 聽眾：一個循環。

465
00:20:26,100 --> 00:20:26,630
>> 戴維·J·馬蘭：一個循環。

466
00:20:26,630 --> 00:20:28,463
又有多少次是
要去迭代？

467
00:20:28,463 --> 00:20:31,562

468
00:20:31,562 --> 00:20:33,270
聽眾：[插入VOICES]
六次。

469
00:20:33,270 --> 00:20:34,830
戴維·J·馬蘭：不六倍。

470
00:20:34,830 --> 00:20:35,840
聽眾：26次。

471
00:20:35,840 --> 00:20:36,560
戴維·J·馬蘭：26次。

472
00:20:36,560 --> 00:20:37,060
是啊，對不起。

473
00:20:37,060 --> 00:20:37,960
26倍。

474
00:20:37,960 --> 00:20:38,460
為什麼呢？

475
00:20:38,460 --> 00:20:41,590
嗯，這是一個有點怪異，但
我已經開始從65計數。

476
00:20:41,590 --> 00:20:43,300
這是奇怪的，但不是錯了。

477
00:20:43,300 --> 00:20:44,610
這不是每個說不好。

478
00:20:44,610 --> 00:20:46,980
而我做的，只有
因為，在這個例子中，

479
00:20:46,980 --> 00:20:50,455
我有點期待
資本A為65。

480
00:20:50,455 --> 00:20:53,330
現在這不是最優雅
的方式來做到這一點，來樣硬編碼

481
00:20:53,330 --> 00:20:56,130
深奧的價值觀，沒有人
是意想不到的記憶。

482
00:20:56,130 --> 00:21:00,155
>> 但是現在，請注意，我
這樣做起來，通過65加26。

483
00:21:00,155 --> 00:21:03,030
因為顯然我什至不希望
做算術在我的腦海。

484
00:21:03,030 --> 00:21:04,440
因此，我將讓編譯器做。

485
00:21:04,440 --> 00:21:08,600
但是在每個循環中，每次迭代
循環的，我遞增島

486
00:21:08,600 --> 00:21:10,196
>> 所以，現在這個看起來有點神秘。

487
00:21:10,196 --> 00:21:13,320
但是，我們應該具備的基本建築
與塊明白這一點。

488
00:21:13,320 --> 00:21:15,510
％C只是一個佔位符字符。

489
00:21:15,510 --> 00:21:19,010
％i是一個佔位符，一個int。

490
00:21:19,010 --> 00:21:23,310
而事實證明，通過使用該
新的語法，這個括號，所以

491
00:21:23,310 --> 00:21:26,100
可以說，這樣的數據類型
圓括號內，

492
00:21:26,100 --> 00:21:32,270
我可以強制編譯器把
我豈不是一個整數，但作為一個字符。

493
00:21:32,270 --> 00:21:35,520
>> 從而表明了我的性格
相當於這個數字的。

494
00:21:35,520 --> 00:21:37,986
現在到這裡，這個代碼
幾乎是相同的。

495
00:21:37,986 --> 00:21:39,860
我只是想讓
超清晰的事實

496
00:21:39,860 --> 00:21:42,095
那我開始在97，
這是小寫。

497
00:21:42,095 --> 00:21:44,080
在經過了26個字母。

498
00:21:44,080 --> 00:21:46,970
而我doing--一遍，
鑄我可以這麼說。

499
00:21:46,970 --> 00:21:49,160
或類型轉換我可以這麼說。

500
00:21:49,160 --> 00:21:51,420
>> 從一個int為char。

501
00:21:51,420 --> 00:21:55,760
這樣最終的結果將是，
坦率地說，我們的信息已經知道了。

502
00:21:55,760 --> 00:21:59,411
我要作
ASCII-0 dot--不是C點。

503
00:21:59,411 --> 00:22:02,160
請注意，你可能做了
錯誤，因為我只是做了意外。

504
00:22:02,160 --> 00:22:03,820
請ASCII-0。

505
00:22:03,820 --> 00:22:06,090
現在我該怎麼辦./ascii-0。

506
00:22:06,090 --> 00:22:09,050
我就放大了，可惜
它會在屏幕上滾過。

507
00:22:09,050 --> 00:22:15,060
但是我們看到整個圖上
Google地圖97，B映射到98，

508
00:22:15,060 --> 00:22:18,931
如果我們進一步向上滾動
A，當然，映射到65。

509
00:22:18,931 --> 00:22:21,180
所以這只是說
我們一直在鼓吹，

510
00:22:21,180 --> 00:22:25,310
有這個對等，是
事實上在實際的情況。

511
00:22:25,310 --> 00:22:28,000
所以這是一個快速修改。

512
00:22:28,000 --> 00:22:31,220
讓我打開ASCII-1.C。

513
00:22:31,220 --> 00:22:38,070
並請注意這個聰明，排序
的，澄清這一點。

514
00:22:38,070 --> 00:22:41,770
這是ASCII-1.C，並
看到這個瘋狂的事情。

515
00:22:41,770 --> 00:22:45,120
>> 這真正得到的心臟
什麼樣的電腦在幹什麼。

516
00:22:45,120 --> 00:22:48,150
雖然我們人類會
在letters--而言不算

517
00:22:48,150 --> 00:22:50,380
我不開始思考，
沒事A則B，

518
00:22:50,380 --> 00:22:52,590
並使用它們來計算物體。

519
00:22:52,590 --> 00:22:58,680
你當然可以說，我要
初始化一些變量稱為C--

520
00:22:58,680 --> 00:23:03,220
但我可以把這種現象稱之為anything--
所以C初始化為資本A.

521
00:23:03,220 --> 00:23:07,560
>> 因為在一天結束時，計算機
不在乎你存儲的東西，

522
00:23:07,560 --> 00:23:10,170
只在乎你怎麼想
呈現這些信息。

523
00:23:10,170 --> 00:23:13,560
你怎麼要電腦
解讀比特的格局？

524
00:23:13,560 --> 00:23:16,320
因此，這是不是我
一般會建議這樣做。

525
00:23:16,320 --> 00:23:19,500
這真的只是一個例子，
傳達你絕對可以

526
00:23:19,500 --> 00:23:22,049
初始化為char整數。

527
00:23:22,049 --> 00:23:24,090
由於下方的
當然，一個char的引擎蓋，

528
00:23:24,090 --> 00:23:26,170
僅僅是一個數字，從0到255。

529
00:23:26,170 --> 00:23:28,540
>> 所以，你當然可以
把它放在一個int內。

530
00:23:28,540 --> 00:23:30,890
什麼這也
表明的是，我們

531
00:23:30,890 --> 00:23:34,040
可以從一個轉換
鍵入到另一個，在這裡，

532
00:23:34,040 --> 00:23:36,780
最終打印同樣的事情。

533
00:23:36,780 --> 00:23:44,760
而事實上，這一點，我會解決online--
是為了這麼一說，再一次，在這裡。

534
00:23:44,760 --> 00:23:48,610
讓我打掃一下網絡，我們將
看到在網上漫遊的需要，

535
00:23:48,610 --> 00:23:50,280
目的是什麼在那裡。

536
00:23:50,280 --> 00:23:50,960
>> 行。

537
00:23:50,960 --> 00:23:53,892
所以最後一個例子，現在涉及
A和B的，然後我們會

538
00:23:53,892 --> 00:23:54,850
拿東西了一個檔次。

539
00:23:54,850 --> 00:23:58,330
因此，與A和B的並
C'S的資本

540
00:23:58,330 --> 00:24:01,560
和等價物，讓我們
看看這個例子，在這裡。

541
00:24:01,560 --> 00:24:02,752
另一個代碼示例。

542
00:24:02,752 --> 00:24:04,460
我們會開一個的
已經作出，所以我們

543
00:24:04,460 --> 00:24:06,440
不必鍵入它
全力以赴從零開始。

544
00:24:06,440 --> 00:24:09,420
>> 並注意在期待
我們使用多個頭

545
00:24:09,420 --> 00:24:13,240
文件，其中之一是
我們的新朋友，string.h中。

546
00:24:13,240 --> 00:24:15,597
現在這看起來，在第一
一眼望去，有點神秘。

547
00:24:15,597 --> 00:24:18,180
但是，讓我們看看，如果我們不能理性
通過什麼是怎麼回事。

548
00:24:18,180 --> 00:24:21,150
首先，我從用戶得到一個字符串，
我把該字符串中的變量

549
00:24:21,150 --> 00:24:22,286
稱為S。

550
00:24:22,286 --> 00:24:24,090
複製粘貼，從之前。

551
00:24:24,090 --> 00:24:27,250
在第22行，我顯然
做什麼

552
00:24:27,250 --> 00:24:30,760
我做了一個剛才我遍歷
在s中的字符。

553
00:24:30,760 --> 00:24:34,780
>> 這裡的新花樣使用
字符串的長度，優化未成年人

554
00:24:34,780 --> 00:24:37,930
存儲該字符串的長度為n，
而不是調用一次strlen的，

555
00:24:37,930 --> 00:24:38,850
又一次，又一次。

556
00:24:38,850 --> 00:24:41,120
而只是檢查我是小於n。

557
00:24:41,120 --> 00:24:43,330
現在這裡，事情就變得
有點有趣。

558
00:24:43,330 --> 00:24:45,980
但它只是一個應用程序
這種相同的新思路。

559
00:24:45,980 --> 00:24:48,470
什麼英語呢
Š支架我代表？

560
00:24:48,470 --> 00:24:51,772

561
00:24:51,772 --> 00:24:54,260
>> 聽眾：每個計數
人物[聽不清]。

562
00:24:54,260 --> 00:24:55,926
>> 戴維·J·馬蘭：計算每個字符。

563
00:24:55,926 --> 00:24:58,680
甚至更簡潔，
Š支架我代表的是什麼？

564
00:24:58,680 --> 00:25:00,950
你會說。

565
00:25:00,950 --> 00:25:04,084
不要把你當場這裡。

566
00:25:04,084 --> 00:25:06,375
>> 聽眾：Well--

567
00:25:06,375 --> 00:25:09,500
戴維·J·馬蘭：所以，如果這個詞is--如果
該字符串是Zamyla，這starts--

568
00:25:09,500 --> 00:25:12,380
聽眾：--you處理
人物separately--

569
00:25:12,380 --> 00:25:13,690
戴維·J·馬蘭：好。

570
00:25:13,690 --> 00:25:14,190
沒錯。

571
00:25:14,190 --> 00:25:17,940
方括號表示法可以讓你
單獨訪問每個字符，

572
00:25:17,940 --> 00:25:21,120
所以š托架0將是對
字符串中的第一個字符。

573
00:25:21,120 --> 00:25:24,110
š托架1將是
第二，等等。

574
00:25:24,110 --> 00:25:28,050
所以這個問題我問，
這裡，在這種條件下是什麼？

575
00:25:28,050 --> 00:25:33,984
是S更大的第i個字符
大於或等於小寫？

576
00:25:33,984 --> 00:25:36,400
而這是什麼意思，在這裡，
與雙連字號？

577
00:25:36,400 --> 00:25:36,800
聽眾（合）：和。

578
00:25:36,800 --> 00:25:37,210
戴維·J·馬蘭：和。

579
00:25:37,210 --> 00:25:38,418
這只是相當於此。

580
00:25:38,418 --> 00:25:42,310
而不是在C語言的關鍵字，你必須
使用時，煩人，符號與符號。

581
00:25:42,310 --> 00:25:47,520
而這一點，相反，卻要求是
的s的第i個字符小於或等於

582
00:25:47,520 --> 00:25:49,030
為小寫ž？

583
00:25:49,030 --> 00:25:52,440
再次，這裡的地方
理解底層

584
00:25:52,440 --> 00:25:54,550
實施了
電腦是有道理的。

585
00:25:54,550 --> 00:25:57,330
請注意，即使我有
在點點點在那邊，

586
00:25:57,330 --> 00:26:04,410
貌似從a到z的小寫字母
所有連續的值從97上了。

587
00:26:04,410 --> 00:26:07,820
>> 而同樣的大寫開始65。

588
00:26:07,820 --> 00:26:10,410
因此，外賣，然後，
的是，在英國，

589
00:26:10,410 --> 00:26:12,760
你會如何形容
什麼線24是幹什麼的？

590
00:26:12,760 --> 00:26:15,736

591
00:26:15,736 --> 00:26:16,728
是嗎？

592
00:26:16,728 --> 00:26:21,575
>> 聽眾：在24它的檢查，看看
是否每一個字符是小寫。

593
00:26:21,575 --> 00:26:24,700
戴維·J·馬蘭：這是檢查是否
每個字符是小寫字母。

594
00:26:24,700 --> 00:26:28,590
因此，更簡潔，是
Š小寫的第i個字符？

595
00:26:28,590 --> 00:26:30,690
這就是我們
在這裡表達邏輯，

596
00:26:30,690 --> 00:26:33,750
隱晦一點，但
最終很直截了當。

597
00:26:33,750 --> 00:26:36,480
是S的第i個字符小寫？

598
00:26:36,480 --> 00:26:40,130
>> 如果是這樣，這裡的東西在哪裡
得到一點心靈彎曲

599
00:26:40,130 --> 00:26:44,760
就一下，如果是的話，請
前進，打印出的字符。

600
00:26:44,760 --> 00:26:47,360
所以這只是一個佔位符，
但什麼性格？

601
00:26:47,360 --> 00:26:53,710
我為什麼要做Š級別I
減去在這裡體現在哪裡？

602
00:26:53,710 --> 00:26:55,110
>> 那麼這裡看到的格局。

603
00:26:55,110 --> 00:26:57,380
實際數字並不重要，這麼多。

604
00:26:57,380 --> 00:27:02,700
但是請注意，97是
如何遠離65？

605
00:27:02,700 --> 00:27:03,560
>> 聽眾：32。

606
00:27:03,560 --> 00:27:04,480
>> 戴維·J·馬蘭：32。

607
00:27:04,480 --> 00:27:06,890
多遠是98 66？

608
00:27:06,890 --> 00:27:07,740
>> 聽眾：32。

609
00:27:07,740 --> 00:27:09,890
>> 戴維·J·馬蘭：從大C小C 2

610
00:27:09,890 --> 00:27:10,420
32。

611
00:27:10,420 --> 00:27:14,550
因此，有來自32跳
一個字母到另一個。

612
00:27:14,550 --> 00:27:17,790
所以，坦白說，我終於忍不住
簡化這一點。

613
00:27:17,790 --> 00:27:20,400
但後​​來我種硬編碼
這種低級別的理解

614
00:27:20,400 --> 00:27:21,740
沒有讀者是有史以來
要理解。

615
00:27:21,740 --> 00:27:25,080
所以我要推廣它作為我
知道小寫字母越大。

616
00:27:25,080 --> 00:27:28,400
我知道的大寫字母
較小的值，具有諷刺意味的。

617
00:27:28,400 --> 00:27:33,216
>> 但是這實際上等同於
話說減去32從s支架島

618
00:27:33,216 --> 00:27:35,430
因此在這些情況下
信，如果信

619
00:27:35,430 --> 00:27:38,950
恰好是一個字母，小寫字母
A，我減去32，

620
00:27:38,950 --> 00:27:43,442
什麼樣的影響確實有，
在數學上，在小寫？

621
00:27:43,442 --> 00:27:44,400
聽眾：Capitalizes--

622
00:27:44,400 --> 00:27:45,691
戴維·J·馬蘭：以大寫字母了。

623
00:27:45,691 --> 00:27:48,440
事實上，這就是為什麼我們的
程序被稱為利用零。

624
00:27:48,440 --> 00:27:51,590
這個程序不是
大寫字母，

625
00:27:51,590 --> 00:27:54,580
檢查它是否是後
的確是一個小寫字母。

626
00:27:54,580 --> 00:27:59,810
否則，在第30行，我該怎麼辦，如果
它不是一個小寫字母，我很

627
00:27:59,810 --> 00:28:02,852
看著在特定
迭代循環中。

628
00:28:02,852 --> 00:28:03,890
剛剛打印出來。

629
00:28:03,890 --> 00:28:07,010
>> 所以不改變的東西
這甚至不是小寫。

630
00:28:07,010 --> 00:28:10,790
限制自己
通過小Ž稍微。

631
00:28:10,790 --> 00:28:12,730
現在，這是相當神秘的。

632
00:28:12,730 --> 00:28:15,230
但在一天結束時，這
就是我們，曾幾何時，

633
00:28:15,230 --> 00:28:16,460
必須實現的事情。

634
00:28:16,460 --> 00:28:19,780
如果我不是開放的資本
1，哦，感謝上帝。

635
00:28:19,780 --> 00:28:22,320
有一個函數
叫上可

636
00:28:22,320 --> 00:28:25,410
難道我們只是做了一切
在一個相當低的水平。

637
00:28:25,410 --> 00:28:28,752
>> 我們上有趣的是，
因為它是在一個文件中聲明，

638
00:28:28,752 --> 00:28:31,210
你只知道這個
通過檢查文檔，

639
00:28:31,210 --> 00:28:35,730
或者被告知，比方說，在課堂上，在那裡
它的存在，在一個名為文件ctype.h。

640
00:28:35,730 --> 00:28:37,630
因此，這是我們的一位新朋友。

641
00:28:37,630 --> 00:28:40,750
並且上不正是
它的名字所暗示。

642
00:28:40,750 --> 00:28:44,860
>> 您可以通過在，作為一個參數之間
這些括號，一些字符。

643
00:28:44,860 --> 00:28:48,390
我要傳遞的第i個字符
第使用我們看中的新符號

644
00:28:48,390 --> 00:28:49,870
包括方括號。

645
00:28:49,870 --> 00:28:53,391
並採取了猜測，究竟是回歸
對上價值顯然會

646
00:28:53,391 --> 00:28:53,890
要？

647
00:28:53,890 --> 00:28:56,460

648
00:28:56,460 --> 00:28:57,770
大寫字母。

649
00:28:57,770 --> 00:28:58,620
大寫字母。

650
00:28:58,620 --> 00:29:02,330
>> 所以，如果我通過在小寫，
希望，通過對上定義，

651
00:29:02,330 --> 00:29:05,600
它會返回一個
大寫字母A。否則，

652
00:29:05,600 --> 00:29:08,590
如果它不是一個小寫字母
首先，我只是把它打印出來。

653
00:29:08,590 --> 00:29:10,800
事實上，請注意
這裡第二個朋友。

654
00:29:10,800 --> 00:29:13,840
不只是上存在，
但是低，這

655
00:29:13,840 --> 00:29:16,200
實際上回答了這個問題對我來說。

656
00:29:16,200 --> 00:29:19,730
>> 現在，誰寫了這些東西，
以前的10秒裡，你知道嗎？

657
00:29:19,730 --> 00:29:23,840
實施上，是
降低使用這樣的代碼。

658
00:29:23,840 --> 00:29:27,270
但同樣，有一致的
這個想法抽象出來的，

659
00:29:27,270 --> 00:29:29,190
之類的，較低水平
實施細則。

660
00:29:29,190 --> 00:29:32,600
而站在人的肩膀上
誰來到了我們面前，使用功能

661
00:29:32,600 --> 00:29:36,300
像到上部和下部是，這
奇妙的是夠漂亮

662
00:29:36,300 --> 00:29:40,190
命名該說什麼，他們做的是
精彩的範例採用。

663
00:29:40,190 --> 00:29:44,040
>> 現在，事實證明，如果我讀
該手冊頁，說，要上，

664
00:29:44,040 --> 00:29:45,010
我學別的東西。

665
00:29:45,010 --> 00:29:46,890
所以，男人TOUPPER。

666
00:29:46,890 --> 00:29:48,050
這是一個有點勢不可擋。

667
00:29:48,050 --> 00:29:51,110
但注意，這裡的提
我應該使用頭文件。

668
00:29:51,110 --> 00:29:54,460
順便說一句，因為這
是一種誤導，功能

669
00:29:54,460 --> 00:29:59,070
採用整數，而不是字符
錯誤檢查的原因。

670
00:29:59,070 --> 00:30:01,260
但是，我們也許會來
返回到在將來。

671
00:30:01,260 --> 00:30:05,910
>> 但是請注意，在這裡，要上轉換
如果可能的字母C為大寫。

672
00:30:05,910 --> 00:30:07,674
所以這是非常簡單的。

673
00:30:07,674 --> 00:30:09,340
現在，讓我們成為一個更具體一點。

674
00:30:09,340 --> 00:30:12,750
讓我們來看看的部分
根據返回值的手冊頁。

675
00:30:12,750 --> 00:30:15,420
返回的值是
轉換後的字母。

676
00:30:15,420 --> 00:30:18,690
或c，如果轉換
是不可能的，

677
00:30:18,690 --> 00:30:20,250
其中c是原始輸入。

678
00:30:20,250 --> 00:30:24,140
我知道，從這裡，從
該參數來上。

679
00:30:24,140 --> 00:30:25,780
>> 那麼什麼是這個外賣？

680
00:30:25,780 --> 00:30:28,060
返回的值是
轉換的信，

681
00:30:28,060 --> 00:30:32,110
或c，原信，如果
的轉化率是不可能的。

682
00:30:32,110 --> 00:30:36,460
有什麼可以改進，所以我
讓我的代碼的設計嗎？

683
00:30:36,460 --> 00:30:37,146
是嗎？

684
00:30:37,146 --> 00:30:38,810
>> 聽眾：您可以刪除的東西。

685
00:30:38,810 --> 00:30:40,810
戴維·J·馬蘭：我可以
去掉else語句，

686
00:30:40,810 --> 00:30:42,510
而不僅僅是else語句。

687
00:30:42,510 --> 00:30:44,150
>> 聽眾：您可以刪除[聽不清]。

688
00:30:44,150 --> 00:30:46,310
>> 戴維·J·馬蘭：我可以
移除整個叉

689
00:30:46,310 --> 00:30:48,209
在路上，如果其他人乾脆。

690
00:30:48,209 --> 00:30:50,250
因此，我們確實讓我打開
這樣做的最終版本，

691
00:30:50,250 --> 00:30:55,540
利用-2，注意只是怎麼樣，如果
你會，性感，代碼現在越來越，

692
00:30:55,540 --> 00:31:00,040
在我從一些減少
七，所以行短短四年，

693
00:31:00,040 --> 00:31:03,850
我有意的功能
通過簡單地調用到上層，

694
00:31:03,850 --> 00:31:09,410
通過以s支架i和印刷
取出，用佔位符％C，

695
00:31:09,410 --> 00:31:11,090
特定的性格。

696
00:31:11,090 --> 00:31:14,560
>> 現在可以說，有個bug，
或錯誤的，至少風險，

697
00:31:14,560 --> 00:31:15,350
在這個程序中。

698
00:31:15,350 --> 00:31:18,200
所以才回來
到一個較早的外賣，

699
00:31:18,200 --> 00:31:21,820
我應該怎麼可能還做的
這個程序，使其更加堅固，

700
00:31:21,820 --> 00:31:24,974
因此，有沒有辦法它可以
崩潰，甚至在極少數情況下？

701
00:31:24,974 --> 00:31:26,390
聽眾：請確保它是不是NULL。

702
00:31:26,390 --> 00:31:28,056
戴維·J·馬蘭：確保它不為NULL。

703
00:31:28,056 --> 00:31:31,030
所以真的，使這個超級
正確的，我應該這樣做，

704
00:31:31,030 --> 00:31:35,300
如果s不為NULL，則
請繼續執行

705
00:31:35,300 --> 00:31:38,470
這幾行代碼，其中
那麼我可以縮進那樣，

706
00:31:38,470 --> 00:31:39,870
然後把我的右花括號。

707
00:31:39,870 --> 00:31:41,550
因此，良好的搭售在一起的兩個概念。

708
00:31:41,550 --> 00:31:42,429
是嗎？

709
00:31:42,429 --> 00:31:44,470
聽眾：你能不能用
一個do while循環，而不是？

710
00:31:44,470 --> 00:31:47,270
戴維·J·馬蘭：莫非
我做了do while循環？

711
00:31:47,270 --> 00:31:50,020
聽眾：--you要確保
你實際上[聽不清]。

712
00:31:50,020 --> 00:31:51,728
戴維·J·馬蘭：莫非
您使用的是DO WHILE？

713
00:31:51,728 --> 00:31:52,450
簡短的回答，沒有。

714
00:31:52,450 --> 00:31:54,700
因為你即將
引入另一個角落的情況下。

715
00:31:54,700 --> 00:31:56,660
如果該字符串的長度為零。

716
00:31:56,660 --> 00:31:59,600
如果舉例來說，我只是打
輸入，而沒有輸入Zamyla。

717
00:31:59,600 --> 00:32:02,490
我要交給你回一個實際
字符串，因為我們最終會看到，

718
00:32:02,490 --> 00:32:03,780
具有零個字符。

719
00:32:03,780 --> 00:32:05,630
它仍然是一個字符串，
它只是超短。

720
00:32:05,630 --> 00:32:07,960
但是，如果你使用DO WHILE，
你要盲目

721
00:32:07,960 --> 00:32:10,050
嘗試做一些與
對於該字符串，

722
00:32:10,050 --> 00:32:12,537
而什麼也沒有去那裡。

723
00:32:12,537 --> 00:32:18,607
>> 聽眾：嗯，如果你做了
做[聽不清]，而S--

724
00:32:18,607 --> 00:32:21,190
戴維·J·馬蘭：哦，我看看，讓
獲取來自用戶的字符串。

725
00:32:21,190 --> 00:32:23,525
所以，簡單的答案，你
能，並保持糾纏

726
00:32:23,525 --> 00:32:26,150
他們給你一個字符串，它是
短到足以裝入內存。

727
00:32:26,150 --> 00:32:26,700
當然可以。

728
00:32:26,700 --> 00:32:27,630
我只是選擇不。

729
00:32:27,630 --> 00:32:30,505
如果他們不給我的字符串I
希望，我辭職，我放棄了。

730
00:32:30,505 --> 00:32:33,260
但是，絕對，為此目的，
你可以完全做到這一點。

731
00:32:33,260 --> 00:32:37,500
>> 因此，庫的頭文件
我們現在熟悉了這些，在這裡。

732
00:32:37,500 --> 00:32:41,550
標準I / O，CS50.h，string.h中，
文件ctype.h，並有確實，等。

733
00:32:41,550 --> 00:32:44,460
你們當中有些人已經發現
在math.h.數學庫

734
00:32:44,460 --> 00:32:48,200
不過，讓我介紹一下，現在，到
這個資源是CS50的工作人員，達文，

735
00:32:48,200 --> 00:32:50,630
和Rob，以及加布特別
有放在一起。

736
00:32:50,630 --> 00:32:52,630
這將很快鏈接
該課程的網站。

737
00:32:52,630 --> 00:32:54,870
這就是所謂的CS50參考。

738
00:32:54,870 --> 00:32:58,230
>> 這只是給你一個快速
它的味道，工作原理如下。

739
00:32:58,230 --> 00:33:00,740
讓我去reference.cs50.net。

740
00:33:00,740 --> 00:33:02,990
在左手上，你會看到
方壓倒性列表

741
00:33:02,990 --> 00:33:04,595
功能附帶℃。

742
00:33:04,595 --> 00:33:07,790
但是，如果我不管，就目前而言，
關於類似的strlen，

743
00:33:07,790 --> 00:33:08,746
我可以輸入它。

744
00:33:08,746 --> 00:33:10,870
它過濾下來的名單
只是我所關心的。

745
00:33:10,870 --> 00:33:11,940
我會點擊它。

746
00:33:11,940 --> 00:33:14,740
而現在在左邊，
你會看到什麼，我們希望

747
00:33:14,740 --> 00:33:18,290
是一個比較簡單的，人
如何友好的解釋

748
00:33:18,290 --> 00:33:19,170
該功能的工作原理。

749
00:33:19,170 --> 00:33:20,600
>> 返回字符串的長度。

750
00:33:20,600 --> 00:33:24,060
這裡有一個故事大綱，這裡是你如何
用它在頭文件而言，

751
00:33:24,060 --> 00:33:27,430
以及在什麼樣的功能方面
看起來像它的參數條件。

752
00:33:27,430 --> 00:33:30,250
然後在這裡，退貨
字符串的長度。

753
00:33:30,250 --> 00:33:34,280
但是，對於那些你更舒適，
實際上你可以點擊更多的舒適，

754
00:33:34,280 --> 00:33:37,070
與此內容
頁，現在，將改變

755
00:33:37,070 --> 00:33:41,660
是什麼樣的默認值
你所使用的手冊頁。

756
00:33:41,660 --> 00:33:44,100
>> 換句話說，CS50
引用是一個簡化

757
00:33:44,100 --> 00:33:46,220
手冊頁的工作人員，為​​學生。

758
00:33:46,220 --> 00:33:49,320
特別是那些不太舒服
和在之間，這樣就

759
00:33:49,320 --> 00:33:51,660
不必嘗試包裹
你的頭腦身邊，坦率地說，

760
00:33:51,660 --> 00:33:55,030
一些相當神秘的語法
和文檔的某個時候。

761
00:33:55,030 --> 00:33:57,650
>> 所以，記住這一點
在未來的日子裡。

762
00:33:57,650 --> 00:33:59,560
所以在這裡，再次，是Zamyla。

763
00:33:59,560 --> 00:34:03,255
現在，讓我們提出一個問題，那就是
多一點人訪問。

764
00:34:03,255 --> 00:34:05,380
由於長安，誰是被
印刷更多的大象

765
00:34:05,380 --> 00:34:07,090
馬不停蹄的這幾天。

766
00:34:07,090 --> 00:34:09,730
我們有一個機會，給
客場至少其中之一。

767
00:34:09,730 --> 00:34:13,239
如果我們能夠得到的只是一名志願者
來在最多繪製在屏幕上。

768
00:34:13,239 --> 00:34:14,530
怎麼在這裡？

769
00:34:14,530 --> 00:34:15,340
>> 上來吧。

770
00:34:15,340 --> 00:34:16,720
你叫什麼名字？

771
00:34:16,720 --> 00:34:17,219
亞歷克斯：亞歷克斯。

772
00:34:17,219 --> 00:34:17,760
戴維·J·馬蘭：亞歷克斯。

773
00:34:17,760 --> 00:34:18,259
好吧。

774
00:34:18,259 --> 00:34:19,388
亞歷克斯，上來吧。

775
00:34:19,388 --> 00:34:21,679
我們即將看到你
手寫在屏幕上的位置。

776
00:34:21,679 --> 00:34:24,325

777
00:34:24,325 --> 00:34:25,570
好吧，很高興認識你。

778
00:34:25,570 --> 00:34:26,429
>> 亞歷克斯：你很高興見到你。

779
00:34:26,429 --> 00:34:27,512
>> 戴維·J·馬蘭：好吧。

780
00:34:27,512 --> 00:34:28,969
因此，超級簡單的運動。

781
00:34:28,969 --> 00:34:31,440
酒吧是不高
讓大象今天。

782
00:34:31,440 --> 00:34:33,439
你在玩的GetString的作用。

783
00:34:33,439 --> 00:34:35,980
而且我會直接告訴你
你已經得到的字符串。

784
00:34:35,980 --> 00:34:38,080
並假設你，
GetString的，被稱為。

785
00:34:38,080 --> 00:34:42,480
和人，和我一樣，有
鍵入Zamyla，Z-A-M-Y-L-A。

786
00:34:42,480 --> 00:34:45,650
只是繼續前進，就寫Zamyla
屏幕雖然你得到它

787
00:34:45,650 --> 00:34:47,250
並將其存儲在某個地方存儲。

788
00:34:47,250 --> 00:34:52,370

789
00:34:52,370 --> 00:34:55,570
>> 什麼將是幾個留有餘地
其他words--沒關係，堅持下去。

790
00:34:55,570 --> 00:34:59,620
>> [笑]

791
00:34:59,620 --> 00:35:00,800
>> 所以Zamyla，優秀。

792
00:35:00,800 --> 00:35:04,880
所以，現在假設你，
GetString的，被再次調用。

793
00:35:04,880 --> 00:35:09,350
因此，我為您提供，在
鍵盤，使用其他名稱，貝琳達。

794
00:35:09,350 --> 00:35:17,560

795
00:35:17,560 --> 00:35:18,060
好吧。

796
00:35:18,060 --> 00:35:22,380
而現在，下一次的GetString是
叫我輸入類似加布，

797
00:35:22,380 --> 00:35:27,560
G-A-B-C。你真的走
到心臟的隨機存取存儲器。

798
00:35:27,560 --> 00:35:29,631
這是借鑒一切
完全隨機。

799
00:35:29,631 --> 00:35:30,130
行。

800
00:35:30,130 --> 00:35:31,104
>> [笑]

801
00:35:31,104 --> 00:35:32,520
亞歷克斯：對不起，我的筆跡是壞的。

802
00:35:32,520 --> 00:35:33,770
戴維·J·馬蘭：不，沒關係。

803
00:35:33,770 --> 00:35:40,480
又有怎樣的羅布，R-O-B。行。

804
00:35:40,480 --> 00:35:41,020
好。

805
00:35:41,020 --> 00:35:43,853
所以，我沒想到你會
種打下的東西出來是這樣的。

806
00:35:43,853 --> 00:35:45,020
但是，我們可以使這項工作。

807
00:35:45,020 --> 00:35:48,810
那你怎麼去鋪設
這些字符在內存中？

808
00:35:48,810 --> 00:35:51,310
換句話說，如果我們想
這個長方形的黑色畫面

809
00:35:51,310 --> 00:35:53,550
作為代表
計算機的RAM或內存。

810
00:35:53,550 --> 00:35:55,850
>> 並記得RAM是剛
一大堆的字節，

811
00:35:55,850 --> 00:35:57,480
和字節是一大堆位。

812
00:35:57,480 --> 00:35:59,350
而位在某種程度上
實施一般

813
00:35:59,350 --> 00:36:01,119
用某種形式的
電力硬件。

814
00:36:01,119 --> 00:36:03,160
所以這是排序的
分層，我們已經討論過

815
00:36:03,160 --> 00:36:04,510
現在可以理所當然的。

816
00:36:04,510 --> 00:36:07,020
你怎麼去
決定在哪裡寫

817
00:36:07,020 --> 00:36:11,634
羅布對加布與
貝琳達與Zamyla？

818
00:36:11,634 --> 00:36:14,020
>> 亞歷克斯：我只是做了它在
命令你告訴我。

819
00:36:14,020 --> 00:36:15,650
>> 戴維·J·馬蘭：這是事實。

820
00:36:15,650 --> 00:36:20,100
但管轄，你把
貝琳達的名字和Gabe的名字嗎？

821
00:36:20,100 --> 00:36:20,764
>> 亞歷克斯：什麼都沒有？

822
00:36:20,764 --> 00:36:22,930
戴維·J·馬蘭：[笑]
那麼這樣的作品，這很好。

823
00:36:22,930 --> 00:36:25,290
所以，電腦是小
比這更有序。

824
00:36:25,290 --> 00:36:29,000
所以，當我們implement--呆在那裡
在短短moment--當我們真正

825
00:36:29,000 --> 00:36:31,470
實現類似
GetString的在一台電腦，

826
00:36:31,470 --> 00:36:34,480
Zamyla可能會奠定了相當多
像你這樣在屏幕上，在那裡。

827
00:36:34,480 --> 00:36:36,660
>> 什麼是關鍵要注意
在這裡，有什麼亞歷克斯做了，

828
00:36:36,660 --> 00:36:40,260
有是怎樣的一個分界
其中每一項的話，對不對？

829
00:36:40,260 --> 00:36:46,580
你沒寫
Z-A-M-Y型L-A-B-C-L-I-N-D-A-G-A-B--

830
00:36:46,580 --> 00:36:49,740
換句話說，有一些樣
劃界這似乎是，

831
00:36:49,740 --> 00:36:52,370
之類的，隨機的間距
這些不同的單詞之間。

832
00:36:52,370 --> 00:36:54,120
但是，這是很好的，因為
我們人類現在可以

833
00:36:54,120 --> 00:36:56,470
可視化，這些都是
四個不同的字符串。

834
00:36:56,470 --> 00:36:59,540
這不只是一個序列
地段字符。

835
00:36:59,540 --> 00:37:04,190
所以一台電腦的話，同時，
可能需要一個字符串，如Zamyla，

836
00:37:04,190 --> 00:37:07,220
把每一個這些信件
裡面的內存字節。

837
00:37:07,220 --> 00:37:10,400
不過，這個數字要大得多，
當然，大於6位。

838
00:37:10,400 --> 00:37:11,690
>> 有一大堆的RAM。

839
00:37:11,690 --> 00:37:15,330
所以，從今以後，這
箱格會

840
00:37:15,330 --> 00:37:17,560
代表什麼亞歷克斯剛
在這裡做在屏幕上。

841
00:37:17,560 --> 00:37:20,937
而現在，亞歷克斯，我們可以為您提供
藍色或從長安橙色大象。

842
00:37:20,937 --> 00:37:22,270
亞歷克斯：我要一個藍色的大象。

843
00:37:22,270 --> 00:37:23,120
戴維·J·馬蘭：一個藍色的大象。

844
00:37:23,120 --> 00:37:25,580
因此，一個熱烈的掌聲，
如果我們可以，亞歷克斯在這裡。

845
00:37:25,580 --> 00:37:26,100
>> [掌聲]

846
00:37:26,100 --> 00:37:26,766
>> 亞歷克斯：謝謝。

847
00:37:26,766 --> 00:37:28,820
戴維·J·馬蘭：謝謝。

848
00:37:28,820 --> 00:37:36,230
這樣的外賣的是，即使
種模式隨時間變化的，在這裡

849
00:37:36,230 --> 00:37:40,430
在黑板上，有這
各串之間的分界

850
00:37:40,430 --> 00:37:42,610
亞歷克斯得到了我們。

851
00:37:42,610 --> 00:37:45,230
現在的電腦，坦率地說，
可以做同樣的事情。

852
00:37:45,230 --> 00:37:48,210
種他們可以噗通
字符串的任何地方在RAM中。

853
00:37:48,210 --> 00:37:50,710
在這裡，在這裡，
在這兒，在這兒。

854
00:37:50,710 --> 00:37:52,020
>> 他們可以這樣做。

855
00:37:52,020 --> 00:37:54,280
但是，當然，這是
可能不是最好的規劃。

856
00:37:54,280 --> 00:37:54,780
對不對？

857
00:37:54,780 --> 00:37:57,340
如果我一直在問亞歷克斯
得到的名字，也許他會

858
00:37:57,340 --> 00:38:01,370
多放些到這裡，也許最多
在這裡，看過來，看過來，最終

859
00:38:01,370 --> 00:38:02,211
在這裡。

860
00:38:02,211 --> 00:38:05,460
但有更多的規劃，當然，
我們可以打好的事情了更乾淨。

861
00:38:05,460 --> 00:38:07,350
事實上，這就是一台電腦一樣。

862
00:38:07,350 --> 00:38:10,720
>> 但美中不足的是，
如果下一個字符串，我得到

863
00:38:10,720 --> 00:38:14,050
後Zamyla是什麼
像貝琳達，

864
00:38:14,050 --> 00:38:17,929
建議我們會寫
字母b相對於該網格？

865
00:38:17,929 --> 00:38:18,720
你會去哪裡？

866
00:38:18,720 --> 00:38:21,480
為a的右側，
下面的Z，下面有一把？

867
00:38:21,480 --> 00:38:23,204
什麼你的第一直覺是什麼？

868
00:38:23,204 --> 00:38:24,120
聽眾：下面的Z。

869
00:38:24,120 --> 00:38:25,100
戴維·J·馬蘭：所以Z軸下方。

870
00:38:25,100 --> 00:38:26,530
這就是美麗的
簡單吧？

871
00:38:26,530 --> 00:38:29,321
這是一種整齊，這是我們做什麼
在鍵盤上，當我們按下回車鍵，

872
00:38:29,321 --> 00:38:31,770
或電子郵件時作出
物聯網項目符號列表。

873
00:38:31,770 --> 00:38:34,310
但現實的情況是，電腦
嘗試更有效率，

874
00:38:34,310 --> 00:38:37,170
和補習班肯定之多
數據到RAM成為可能，

875
00:38:37,170 --> 00:38:38,890
這樣你就不會浪費任何字節。

876
00:38:38,890 --> 00:38:41,545
這樣你就不會浪費
任何屏幕房地產。

877
00:38:41,545 --> 00:38:44,170
與該問題，雖然是
如果我們硬是把信

878
00:38:44,170 --> 00:38:49,940
後B A，我們如何來
知道Zamyla的名稱結尾

879
00:38:49,940 --> 00:38:51,840
和貝琳達的名字開始？

880
00:38:51,840 --> 00:38:55,270
所以，你們人類只是建議，好了，
按下回車鍵，基本上。

881
00:38:55,270 --> 00:38:56,410
把它放在樓下。

882
00:38:56,410 --> 00:38:59,750
甚至亞歷克斯做了，剛開始寫作
低於前一個下一個名稱，

883
00:38:59,750 --> 00:39:01,583
和下面的那一個，並
那麼下面的那一個。

884
00:39:01,583 --> 00:39:02,510
這是一個視覺提示。

885
00:39:02,510 --> 00:39:05,960
>> 電腦有另一種視覺提示，
但它是一個小更簡潔。

886
00:39:05,960 --> 00:39:07,840
正是這種質樸的性格。

887
00:39:07,840 --> 00:39:11,890
反斜線0，這也許是
讓人想起反斜杠n個，

888
00:39:11,890 --> 00:39:12,640
等等，現在。

889
00:39:12,640 --> 00:39:14,120
特殊的轉義序列。

890
00:39:14,120 --> 00:39:19,120
反斜線0的方式
代表捌零位成一排。

891
00:39:19,120 --> 00:39:22,000
0000 0000。

892
00:39:22,000 --> 00:39:26,130
>> 你表達的方式是不
按鍵盤上的數字為零，

893
00:39:26,130 --> 00:39:28,140
因為實際上這是一個ASCII字符。

894
00:39:28,140 --> 00:39:30,990
它看起來像一個數字，但
實際上是一個十進制數

895
00:39:30,990 --> 00:39:35,910
表示圓
字形，圓形字體。

896
00:39:35,910 --> 00:39:38,410
同時，反斜線
零表示，從字面上

897
00:39:38,410 --> 00:39:40,700
把捌零字節來到我身邊。

898
00:39:40,700 --> 00:39:42,136
>> 所以這有點武斷。

899
00:39:42,136 --> 00:39:44,260
我們本可以用任何圖案
位的，但在世界

900
00:39:44,260 --> 00:39:46,610
決定好幾年
以前，該代表

901
00:39:46,610 --> 00:39:49,710
字符串在內存中的端部，
只是把一大堆零。

902
00:39:49,710 --> 00:39:51,000
因為我們可以檢測到。

903
00:39:51,000 --> 00:39:54,790
現在，意味著無信
字母可以表示零。

904
00:39:54,790 --> 00:39:58,480
>> 不過沒關係，我們已經看到了
我們使用的是65在97就到了。

905
00:39:58,480 --> 00:40:00,290
我們沒有取得任何進展
接近為零。

906
00:40:00,290 --> 00:40:03,040

907
00:40:03,040 --> 00:40:06,540
因此，貝琳達在計算機的內存
實際上要去這裡。

908
00:40:06,540 --> 00:40:09,764
我在黃色繪製它只是
要引起我們的注意。

909
00:40:09,764 --> 00:40:11,680
並請注意，同樣，這
完全是任意的。

910
00:40:11,680 --> 00:40:12,680
我畫它作為一個網格。

911
00:40:12,680 --> 00:40:14,460
如，內存只是一些實物。

912
00:40:14,460 --> 00:40:17,300
它不一定
行和列，本身。

913
00:40:17,300 --> 00:40:20,490
它只是得到了一大堆的字節
在硬件某種程度上實現。

914
00:40:20,490 --> 00:40:22,817
但是，如果貝琳達後我
鍵入Gabe的名字，

915
00:40:22,817 --> 00:40:25,650
他將在這裡結束在內存中，
如果我輸入Daven的名字，

916
00:40:25,650 --> 00:40:27,316
比如，他會在這裡結束。

917
00:40:27,316 --> 00:40:29,310
我可以繼續
即使寫的名字。

918
00:40:29,310 --> 00:40:32,100
>> 不幸的是，如果我嘗試
寫一個超長的名字，

919
00:40:32,100 --> 00:40:33,730
我可能最終會耗盡內存。

920
00:40:33,730 --> 00:40:37,810
在這種情況下，GetString的是
將返回NULL，因為我們說。

921
00:40:37,810 --> 00:40:41,720
不過，值得慶幸的是，至少在這個視覺
在這裡，我們沒有得到想像中的那麼遠。

922
00:40:41,720 --> 00:40:45,860
>> 現在有什麼好看的是，這
對待事物的總體思路

923
00:40:45,860 --> 00:40:49,720
在盒子是為
c代表的功能

924
00:40:49,720 --> 00:40:52,690
和很多語言，
已知為陣列。

925
00:40:52,690 --> 00:40:55,490
一個陣列是另一種數據類型。

926
00:40:55,490 --> 00:40:57,380
這是一個數據結構，如果你願意。

927
00:40:57,380 --> 00:41:01,160
在它的結構感真的，
種，看上去就像一個盒子，至少

928
00:41:01,160 --> 00:41:02,320
在你的腦海裡。

929
00:41:02,320 --> 00:41:09,680
數組是一個連續的
相同數據類型的序列，

930
00:41:09,680 --> 00:41:11,330
背靠背背靠背。

931
00:41:11,330 --> 00:41:14,720
>> 所以一個字符串，在其他
也就是說，是字符數組。

932
00:41:14,720 --> 00:41:16,120
字符數組。

933
00:41:16,120 --> 00:41:19,070
但事實證明，你可以有
事情束陣列。

934
00:41:19,070 --> 00:41:21,870
實際上，我們可以把連
在數組編號。

935
00:41:21,870 --> 00:41:23,920
這樣的形式，其中
我們將要開始

936
00:41:23,920 --> 00:41:26,590
聲明這個數據
已知為陣列結構

937
00:41:26,590 --> 00:41:28,250
也正用方括號。

938
00:41:28,250 --> 00:41:31,500
但是這些方括號將要
有不同的含義在此上下文。

939
00:41:31,500 --> 00:41:33,450
>> 讓我們來看看它，如下所示。

940
00:41:33,450 --> 00:41:36,780
假設我打開
在這裡一個新的文件。

941
00:41:36,780 --> 00:41:38,535
我保存這為ages.c.

942
00:41:38,535 --> 00:41:41,280

943
00:41:41,280 --> 00:41:43,470
我會在我的文件夾中保存這個位置。

944
00:41:43,470 --> 00:41:46,130
現在我要繼續前進
並開始鍵入的東西

945
00:41:46,130 --> 00:41:53,940
像包括CS50.h，包括
stdio.h中，詮釋主作廢。

946
00:41:53,940 --> 00:41:57,370
然後這裡裡面，我想
先有所謂的年齡為int。

947
00:41:57,370 --> 00:42:01,371
>> 而且我會用它來獲得
從他或她的年齡的用戶詮釋。

948
00:42:01,371 --> 00:42:04,620
但此方案是指使用由
多的人，不管是什麼背景。

949
00:42:04,620 --> 00:42:05,490
我有一排人。

950
00:42:05,490 --> 00:42:08,281
所有這些都輸入自己的
年齡也許一些，我不知道，

951
00:42:08,281 --> 00:42:10,530
競爭或事件
他們已經到達了。

952
00:42:10,530 --> 00:42:13,030
所以旁邊的人，我
需要另一個變量。

953
00:42:13,030 --> 00:42:15,790
>> 因為如果我只是做
時代變調用getInt，這

954
00:42:15,790 --> 00:42:18,500
要揍，或覆蓋
前面的人的年齡。

955
00:42:18,500 --> 00:42:19,760
所以這是沒有好處的。

956
00:42:19,760 --> 00:42:21,790
所以，我的第一直覺
也許，哦，沒事，

957
00:42:21,790 --> 00:42:26,260
如果我想要得到多人的
ages--我們稱之為age1，

958
00:42:26,260 --> 00:42:31,280
INT age2得到詮釋，詮釋age3得到調用getInt。

959
00:42:31,280 --> 00:42:35,340
現在我要使用
這裡是一些偽代碼。

960
00:42:35,340 --> 00:42:37,679
>> 做一些與這些數字。

961
00:42:37,679 --> 00:42:40,470
我們會離開的另一天是什麼
我們正在做的吧，因為我們只

962
00:42:40,470 --> 00:42:44,200
關愛的時刻
關於age1，age2，age3。

963
00:42:44,200 --> 00:42:46,450
不幸的是，有一次我
編譯這個程序

964
00:42:46,450 --> 00:42:51,140
並把它在實際的用戶面前，
什麼是根本設計不良

965
00:42:51,140 --> 00:42:53,890
我似乎決定了呢？

966
00:42:53,890 --> 00:42:54,624
是嗎？

967
00:42:54,624 --> 00:42:55,499
聽眾：[聽不清]

968
00:42:55,499 --> 00:42:58,071

969
00:42:58,071 --> 00:42:59,820
戴維·J·馬蘭：是啊，
我還沒有嘗試過

970
00:42:59,820 --> 00:43:02,028
要弄清楚有多少年齡
我真正關心？

971
00:43:02,028 --> 00:43:05,380
如果我有少於三個人在這裡，
因此，少於三個年齡段，

972
00:43:05,380 --> 00:43:07,260
我仍然盲目期待3。

973
00:43:07,260 --> 00:43:08,720
上帝保佑4達人秀。

974
00:43:08,720 --> 00:43:10,990
我的計劃是不會甚至支持他們。

975
00:43:10,990 --> 00:43:13,280
>> 所以這個，說來話長
總之，不是一個好習慣。

976
00:43:13,280 --> 00:43:13,780
對不對？

977
00:43:13,780 --> 00:43:16,530
我基本上是複製和
粘貼代碼，只是調整

978
00:43:16,530 --> 00:43:17,430
變量名。

979
00:43:17,430 --> 00:43:22,410
而且，我的上帝，如果你有，不是三
年齡，但10或100，甚至6500

980
00:43:22,410 --> 00:43:23,820
大學生，例如。

981
00:43:23,820 --> 00:43:26,950
這不會是特別
優雅的代碼，或可持續。

982
00:43:26,950 --> 00:43:29,200
你將不得不
每一次重寫程序

983
00:43:29,200 --> 00:43:30,760
你對人的改變數量。

984
00:43:30,760 --> 00:43:35,090
>> 所以，值得慶幸的是，在我們的實際
ages.c文件今天，

985
00:43:35,090 --> 00:43:36,970
我們有更聰明的解決方案。

986
00:43:36,970 --> 00:43:39,800
首先，我要借用
構建我們已經用過幾次，

987
00:43:39,800 --> 00:43:43,744
此做while循環中，為了得到
的人在房間的數目。

988
00:43:43,744 --> 00:43:46,910
我只是去糾纏用戶，再
又一次，直到他或她給我

989
00:43:46,910 --> 00:43:49,260
n的值是一個正整數。

990
00:43:49,260 --> 00:43:51,590
>> 我可以使用，最後
時間的獲得正面的詮釋。

991
00:43:51,590 --> 00:43:53,720
但是，我們沒有這方面的
實，讓我繼續

992
00:43:53,720 --> 00:43:55,660
並重新實現了這個想法。

993
00:43:55,660 --> 00:43:58,410
現在在這兒，這是新的把戲。

994
00:43:58,410 --> 00:44:02,260
在第27行，作為評價
在第26行指出，

995
00:44:02,260 --> 00:44:05,180
聲明一個數組中
存儲每個人的年齡。

996
00:44:05,180 --> 00:44:09,320
>> 所以，如果你想要得到的，而不是一個整數，不
兩個整數，但一大堆的整數。

997
00:44:09,320 --> 00:44:13,800
特別是n個整數，為N可能
有三個，也許是100，也許是1000人。

998
00:44:13,800 --> 00:44:17,570
語法很簡單，就是
比方說，你想要什麼類型的數據？

999
00:44:17,570 --> 00:44:19,620
你想打電話
該內存塊？

1000
00:44:19,620 --> 00:44:23,530
那你要撥打的網格
看起來像這樣形象地？

1001
00:44:23,530 --> 00:44:27,700
>> 而在這裡括號，你說
你要多大的數組是。

1002
00:44:27,700 --> 00:44:30,450
因此更早的時候，我說的
語法是有點不同的位置，

1003
00:44:30,450 --> 00:44:33,614
我們還是用方括號，
但是當我在聲明​​數組，

1004
00:44:33,614 --> 00:44:35,530
內部的數
方括號方式

1005
00:44:35,530 --> 00:44:37,610
要在陣列是多大做的。

1006
00:44:37,610 --> 00:44:42,490
>> 與此相反，當我們使用S
支架剛才我，S，A弦，

1007
00:44:42,490 --> 00:44:46,820
的確是字符數組，但
當你沒有聲明一個變量，

1008
00:44:46,820 --> 00:44:49,760
與此關鍵字在這裡，
你只是得到

1009
00:44:49,760 --> 00:44:54,280
具體的指標，具體的
元素的數組。

1010
00:44:54,280 --> 00:44:57,090
一旦我們知道了，剩下的
這很簡單。

1011
00:44:57,090 --> 00:45:00,765
如果有新的我第一次去打印出來
什麼是人編號i時代。

1012
00:45:00,765 --> 00:45:03,890
在這裡我只想說人排名第一，
人排名第二，個人第三。

1013
00:45:03,890 --> 00:45:06,306
>> 而我只是在做算術，
讓正常人一樣，

1014
00:45:06,306 --> 00:45:09,030
我們從一本算
程序，而不是從零。

1015
00:45:09,030 --> 00:45:13,620
然後我打電話調用getInt，但我存儲
在年齡答案級別I。

1016
00:45:13,620 --> 00:45:16,610
這是第i個年齡在數組中。

1017
00:45:16,610 --> 00:45:21,640
因此，而上一次我們在治療
這些箱子的字符為Zamyla的名字，

1018
00:45:21,640 --> 00:45:22,490
及其他。

1019
00:45:22,490 --> 00:45:26,530
現在，這些方塊代表
32位或4個字節

1020
00:45:26,530 --> 00:45:29,510
我們可以在其中存儲
一個int，一個int，int類型。

1021
00:45:29,510 --> 00:45:31,890
所有這一切，再一次，
具有相同的數據類型。

1022
00:45:31,890 --> 00:45:33,890
>> 現在我做一些愚蠢的，
像時間的推移，只是

1023
00:45:33,890 --> 00:45:35,510
證明寫這個程序。

1024
00:45:35,510 --> 00:45:40,050
然後到這裡，我再次重複
在陣列說一年以後，

1025
00:45:40,050 --> 00:45:43,090
人的頭號意志
是什麼歲。

1026
00:45:43,090 --> 00:45:45,010
並弄清楚，
math--我的意思是，這

1027
00:45:45,010 --> 00:45:49,260
不是很複雜算術：
我只是補充自己的年齡。

1028
00:45:49,260 --> 00:45:51,240
只是為了演示，再次，這一點。

1029
00:45:51,240 --> 00:45:57,910
>> 正如我可以索引到一個字符串，S，
這樣我就可以索引到年齡的數組，

1030
00:45:57,910 --> 00:45:59,950
像有。

1031
00:45:59,950 --> 00:46:03,340
那麼，這是怎麼回事要帶我們？

1032
00:46:03,340 --> 00:46:07,070
所以我們會看到，最終，
在天幾件事情來。

1033
00:46:07,070 --> 00:46:09,510
一，這一切的時候，
編寫自己的程序，

1034
00:46:09,510 --> 00:46:11,239
像馬里奧，貪婪，信用。

1035
00:46:11,239 --> 00:46:13,780
你已經輸入的名稱
該程序並按下Enter鍵。

1036
00:46:13,780 --> 00:46:15,610
然後獲取用戶的輸入。

1037
00:46:15,610 --> 00:46:18,137
>> 用的getString，調用getInt，
getLongLong，或類似物。

1038
00:46:18,137 --> 00:46:20,720
但事實證明，C支持
一些所謂的命令行

1039
00:46:20,720 --> 00:46:25,740
爭論，這是怎麼回事，讓我們
實際上得到的是你輸入的話，

1040
00:46:25,740 --> 00:46:28,570
在閃爍提示，
之後，你的程序的名稱。

1041
00:46:28,570 --> 00:46:31,430
>> 因此，在未來的日子裡，你
可以鍵入類似撒，

1042
00:46:31,430 --> 00:46:34,950
或./caesar 13號，此後。

1043
00:46:34,950 --> 00:46:36,070
我們將看到如何工作的。

1044
00:46:36,070 --> 00:46:37,550
因為的確，在
問題設置兩個，我們

1045
00:46:37,550 --> 00:46:39,383
要為您介紹
到了一點東西

1046
00:46:39,383 --> 00:46:42,360
讓人想起拉爾夫年代
挑戰早前製圖。

1047
00:46:42,360 --> 00:46:43,970
藝術爭先恐後的信息。

1048
00:46:43,970 --> 00:46:46,660
這其實是很
不禁讓人想起拉爾夫一樣。

1049
00:46:46,660 --> 00:46:51,380
>> 這是一個加密的例子
算法稱為ROT13，R-O-T 13。

1050
00:46:51,380 --> 00:46:54,910
這只是意味著旋轉
字母在字母表13個地方。

1051
00:46:54,910 --> 00:46:58,309
如果你這樣做，你會看到現在
是什麼，也許，一個熟悉的短語。

1052
00:46:58,309 --> 00:47:01,100
但在路上，我們要使用
這一點，最終是更普遍。

1053
00:47:01,100 --> 00:47:04,390
>> P中設置兩種，標準版，
您將實現一對夫婦的密碼，

1054
00:47:04,390 --> 00:47:06,720
一個叫凱​​撒，一個叫的V @ genere。

1055
00:47:06,720 --> 00:47:10,090
他們兩人都是旋轉
密碼，在某種程度上你

1056
00:47:10,090 --> 00:47:11,826
把一個字母到另一個字母。

1057
00:47:11,826 --> 00:47:12,950
而凱撒是超級簡單。

1058
00:47:12,950 --> 00:47:16,220
你加一個，你加13，
或者一些人數達26。

1059
00:47:16,220 --> 00:47:19,570
的V @ genere不上
每個字母的基礎。

1060
00:47:19,570 --> 00:47:22,140
所以的V @ genere，你會看到
在規範中，是更安全的。

1061
00:47:22,140 --> 00:47:24,973
>> 但在這一天到底是什麼
你將實現和P設置兩個，

1062
00:47:24,973 --> 00:47:29,050
是您同時使用該密鑰
用於加密和解密。

1063
00:47:29,050 --> 00:47:32,160
參照轉彎的過程中
純文本，一些原有的消息，

1064
00:47:32,160 --> 00:47:34,490
成暗號文字，這
什麼是加密的。

1065
00:47:34,490 --> 00:47:36,220
然後再解密它。

1066
00:47:36,220 --> 00:47:38,119
>> 在黑客的版本，
同時，你會

1067
00:47:38,119 --> 00:47:40,660
負責類似的東西
在精神上，我們會給你

1068
00:47:40,660 --> 00:47:44,610
一個文件，從一個典型的Linux，或
Mac或Unix的計算機名為Etsy的

1069
00:47:44,610 --> 00:47:47,800
密碼，其中包含一個全
一串用戶名和密碼。

1070
00:47:47,800 --> 00:47:50,932
而這些密碼都
被加密或散列，

1071
00:47:50,932 --> 00:47:53,140
可以這麼說，更恰當
您將在規範中看到的。

1072
00:47:53,140 --> 00:47:57,090
>> 而黑客版將挑戰
你服用的輸入這樣的，

1073
00:47:57,090 --> 00:47:58,800
和破解密碼。

1074
00:47:58,800 --> 00:48:02,590
也就是說，搞清楚什麼
人的密碼居然是。

1075
00:48:02,590 --> 00:48:05,570
因為，事實上，密碼是
通常不存儲在清晰，

1076
00:48:05,570 --> 00:48:08,260
和一般口令
應該不難猜到。

1077
00:48:08,260 --> 00:48:09,610
這不是常有的事。

1078
00:48:09,610 --> 00:48:12,110
>> 而我認為我們會做的是
總結了幾分鐘

1079
00:48:12,110 --> 00:48:15,160
一眼特別
口令選擇不當

1080
00:48:15,160 --> 00:48:17,260
從電影，你可能還記得深情。

1081
00:48:17,260 --> 00:48:18,915
如果沒有，你應該租房。

1082
00:48:18,915 --> 00:48:20,070
>> [視頻回放]

1083
00:48:20,070 --> 00:48:22,320
>> -Helmet，你惡魔，這是怎麼回事？

1084
00:48:22,320 --> 00:48:24,240
你在做什麼，以我的女兒？

1085
00:48:24,240 --> 00:48:28,010
>> -Permit我介紹
才華橫溢的年輕的整形外科醫生，

1086
00:48:28,010 --> 00:48:30,010
醫生菲利普Schlotkin。

1087
00:48:30,010 --> 00:48:35,020
最大的隆鼻的人在
整個宇宙和比佛利山莊。

1088
00:48:35,020 --> 00:48:36,140
>>  - 您的殿下。

1089
00:48:36,140 --> 00:48:36,820
>>  - 鼻腔的工作嗎？

1090
00:48:36,820 --> 00:48:37,700
我不明白。

1091
00:48:37,700 --> 00:48:39,070
她已經有了一個隆鼻。

1092
00:48:39,070 --> 00:48:40,800
這是她甜美的16本。

1093
00:48:40,800 --> 00:48:42,590
>> 不，這不是你的想法。

1094
00:48:42,590 --> 00:48:44,490
這是非常非常糟糕。

1095
00:48:44,490 --> 00:48:48,160
如果你不給我
組合的氣屏，

1096
00:48:48,160 --> 00:48:52,748
醫生Schlotkin會給你
女兒回她的老鼻子。

1097
00:48:52,748 --> 00:48:53,748
 -  [喘氣] Nooooooooooooo。

1098
00:48:53,748 --> 00:48:57,684

1099
00:48:57,684 --> 00:48:59,652
你從哪裡得到的？

1100
00:48:59,652 --> 00:49:00,640
>>  - 所有權利。

1101
00:49:00,640 --> 00:49:02,506
我要告訴，我會告訴。

1102
00:49:02,506 --> 00:49:03,498
>> 不，爸爸，沒有。

1103
00:49:03,498 --> 00:49:04,490
您不得。

1104
00:49:04,490 --> 00:49:06,090
>> -You're權親愛的。

1105
00:49:06,090 --> 00:49:07,390
我會想念你的新鼻子。

1106
00:49:07,390 --> 00:49:10,990
但我不會告訴他們的
組合不管。

1107
00:49:10,990 --> 00:49:12,450
>>  - 非常好。

1108
00:49:12,450 --> 00:49:14,830
醫生Schlotkin，做你最糟糕的。

1109
00:49:14,830 --> 00:49:15,744
>>  - 我的快樂。

1110
00:49:15,744 --> 00:49:19,860

1111
00:49:19,860 --> 00:49:20,800
>>  - 不！

1112
00:49:20,800 --> 00:49:22,780
等待，等待。

1113
00:49:22,780 --> 00:49:24,000
我會告訴。

1114
00:49:24,000 --> 00:49:25,830
我會告訴。

1115
00:49:25,830 --> 00:49:28,270
>>  - 我知道它是可行的。

1116
00:49:28,270 --> 00:49:31,390
好吧，把它給我。

1117
00:49:31,390 --> 00:49:36,220
>> -The組合之一。

1118
00:49:36,220 --> 00:49:36,740
>>  - 酮。

1119
00:49:36,740 --> 00:49:37,473
>>  - 酮。

1120
00:49:37,473 --> 00:49:37,972
 - 兩個。

1121
00:49:37,972 --> 00:49:38,471
 - 兩個。

1122
00:49:38,471 --> 00:49:39,800
 - 兩個。

1123
00:49:39,800 --> 00:49:40,300
 - 三。

1124
00:49:40,300 --> 00:49:40,800
 - 三。

1125
00:49:40,800 --> 00:49:41,800
 - 三。

1126
00:49:41,800 --> 00:49:42,300
 - 四個。

1127
00:49:42,300 --> 00:49:42,800
 - 四個。

1128
00:49:42,800 --> 00:49:44,707
 - 四個。

1129
00:49:44,707 --> 00:49:45,521
 - 五。

1130
00:49:45,521 --> 00:49:46,430
 - 五。

1131
00:49:46,430 --> 00:49:47,930
 - 五。

1132
00:49:47,930 --> 00:49:53,480
-so的組合之一，
二，三，四，五。

1133
00:49:53,480 --> 00:49:56,140
這是最愚蠢的組合
我曾經聽到了我的生活。

1134
00:49:56,140 --> 00:49:58,640
這就是那種東西的的
白痴不會對他的行李。

1135
00:49:58,640 --> 00:50:00,000
>>  - 謝謝你，你的高度。

1136
00:50:00,000 --> 00:50:01,340
>> [遙控點擊次數]

1137
00:50:01,340 --> 00:50:02,450
>>  - 什麼你做什麼？

1138
00:50:02,450 --> 00:50:03,800
>> -I關掉了壁。

1139
00:50:03,800 --> 00:50:05,010
>> 不，你沒有，你
關掉了整部影片。

1140
00:50:05,010 --> 00:50:06,220
>>  - 我意有所指按錯鍵。

1141
00:50:06,220 --> 00:50:07,064
>>  - 嗯，把它放回去吧！

1142
00:50:07,064 --> 00:50:07,910
放電影回來！

1143
00:50:07,910 --> 00:50:08,300
>>  - 是的，先生！

1144
00:50:08,300 --> 00:50:08,799
是的，先生。

1145
00:50:08,799 --> 00:50:09,660
 - 讓我們走，阿諾德。

1146
00:50:09,660 --> 00:50:10,450
來吧，格雷琴。

1147
00:50:10,450 --> 00:50:12,533
當然，你知道我會
必須向您這一點。

1148
00:50:12,533 --> 00:50:16,720

1149
00:50:16,720 --> 00:50:17,220
 - 嗯？

1150
00:50:17,220 --> 00:50:17,802
沒有工作？

1151
00:50:17,802 --> 00:50:18,510
哪來的王？

1152
00:50:18,510 --> 00:50:20,218
>>  - 它的工作，先生，我們
有組合。

1153
00:50:20,218 --> 00:50:20,740
-Great。

1154
00:50:20,740 --> 00:50:24,810
現在，我們可以把每一個最後一口氣
從地球Druidia新鮮空氣。

1155
00:50:24,810 --> 00:50:25,890
有什麼組合？

1156
00:50:25,890 --> 00:50:28,155
>>  - 酮，二，三，四，五。

1157
00:50:28,155 --> 00:50:29,890
>> 酮，二，三，四，五？

1158
00:50:29,890 --> 00:50:30,390
 - 是的。

1159
00:50:30,390 --> 00:50:31,110
 - 這就是驚人的。

1160
00:50:31,110 --> 00:50:34,550
我有同樣的
結合我的行李。

1161
00:50:34,550 --> 00:50:37,160
準備空間球1
立即離境。

1162
00:50:37,160 --> 00:50:38,160
>>  - 是的，先生。

1163
00:50:38,160 --> 00:50:40,745
>>  - 和改
結合我的行李。

1164
00:50:40,745 --> 00:50:41,578
[關門聲音]

1165
00:50:41,578 --> 00:50:42,064
[CLINK門擊中頭盔]

1166
00:50:42,064 --> 00:50:42,550
-Ahh。

1167
00:50:42,550 --> 00:50:43,383
[完視頻回放]

1168
00:50:43,383 --> 00:50:46,700
戴維·J·馬蘭：這就是它的
CS50，我們會看到你下週。

1169
00:50:46,700 --> 00:50:49,883
旁白：現在，深
思考，通過Daven法納姆。

1170
00:50:49,883 --> 00:50:53,160

1171
00:50:53,160 --> 00:50:55,860
>> DAVEN FARNHAM：編碼中的C是
比刮了這麼多困難。

1172
00:50:55,860 --> 00:50:57,320
printf的，划痕是一個謊言。

1173
00:50:57,320 --> 00:50:59,930

1174
00:50:59,930 --> 00:51:01,430
>> [笑SOUNDBITE]

1175
00:51:01,430 --> 00:51:02,486