1
00:00:00,000 --> 00:00:07,070
[Powered by Google Translate] [♪嗡嗡聲♪]

2
00:00:07,070 --> 00:00:10,380
所以把你介紹給我有什麼在屏幕上;

3
00:00:10,380 --> 00:00:12,710
它是一個在今年夏天，我們開發的工具;

4
00:00:12,710 --> 00:00:15,530
它被稱為CS50空間，

5
00:00:15,530 --> 00:00:18,860
這是我們的合作編碼應用

6
00:00:18,860 --> 00:00:20,180
我們要使用的部分。

7
00:00:20,180 --> 00:00:22,470
這實在是太酷了。

8
00:00:22,470 --> 00:00:26,040
您有任何CS50運行嗎？

9
00:00:26,040 --> 00:00:29,760
讓我拉起來，在另一個選項卡。

10
00:00:29,760 --> 00:00:33,440
Run.cs50.net

11
00:00:33,440 --> 00:00:36,230
所以

12
00:00:36,230 --> 00:00:39,700
如果你去run.cs50.net，

13
00:00:39,700 --> 00:00:43,030
你可以看到這是一個在您的瀏覽器的方式

14
00:00:43,030 --> 00:00:45,940
其實代碼 - 編寫C代碼，

15
00:00:45,940 --> 00:00:47,460
然後運行它，

16
00:00:47,460 --> 00:00:50,960
所以編譯它，運行它，然後返回到你的輸出，

17
00:00:50,960 --> 00:00:53,350
所以這是一個冷靜的方式進行實驗

18
00:00:53,350 --> 00:00:56,060
大衛在課堂上的一些代碼

19
00:00:56,060 --> 00:00:58,640
和我們給你的問題集

20
00:00:58,640 --> 00:01:01,900
沒有真正火起來的家電。

21
00:01:01,900 --> 00:01:04,489
>> 因此，空間做什麼，不同的

22
00:01:04,489 --> 00:01:07,450
如果我切換到該選項卡，

23
00:01:07,450 --> 00:01:11,580
空間是CS50運行，就像你看到這裡，

24
00:01:11,580 --> 00:01:15,380
但是，如果我們滾動，並期待在另一邊的窗口，

25
00:01:15,380 --> 00:01:18,130
你看到的我是唯一的人在這個空間，

26
00:01:18,130 --> 00:01:21,030
但我要問你們加入這個跟我的空間

27
00:01:21,030 --> 00:01:24,590
，我們將所有的代碼在同一個小窗口，

28
00:01:24,590 --> 00:01:26,070
相互共享代碼，

29
00:01:26,070 --> 00:01:28,900
談論我們的代碼之間的差異。

30
00:01:28,900 --> 00:01:31,530
所以這是一件很酷的事情的一種 - 

31
00:01:31,530 --> 00:01:35,770
所以要加入，如果您訪問此鏈接在頂部

32
00:01:35,770 --> 00:01:38,980
我已經強調了，

33
00:01:38,980 --> 00:01:53,860
你可以直接輸入在apps.cs50.net/spaces/vqcspSnO。

34
00:01:53,860 --> 00:01:56,610
>> 好了，所以開始時，

35
00:01:56,610 --> 00:01:59,720
我去給你一點點的參觀。

36
00:01:59,720 --> 00:02:01,720
我們會做一些愚蠢的小編碼與它在第一，

37
00:02:01,720 --> 00:02:06,200
只是讓大家有點的感覺是什麼樣子的，

38
00:02:06,200 --> 00:02:09,000
但我做了什麼 - 

39
00:02:09,000 --> 00:02:11,830
我在這裡做什麼 - 

40
00:02:11,830 --> 00:02:13,480
我要的代碼，我已經寫在這裡，

41
00:02:13,480 --> 00:02:15,800
正如你現在看到的是空的;

42
00:02:15,800 --> 00:02:17,090
它不會做任何事情。

43
00:02:17,090 --> 00:02:21,080
這只是鍋爐板代碼，我們將調用它。

44
00:02:21,080 --> 00:02:23,820
隨著一點點地做評論。

45
00:02:23,820 --> 00:02:27,850
我要通過點擊此“保存”按鈕保存。

46
00:02:27,850 --> 00:02:30,190
是什麼做的是什麼

47
00:02:30,190 --> 00:02:34,400
強調它在這裡簡單 - 修訂版本保存的綠框，

48
00:02:34,400 --> 00:02:37,570
現在，如果你搜索我的空間，

49
00:02:37,570 --> 00:02:40,340
你點擊我的名字，

50
00:02:40,340 --> 00:02:43,370
你可以看到，我已經得到了本次修訂在這裡，

51
00:02:43,370 --> 00:02:45,490
如果你點擊該版本，

52
00:02:45,490 --> 00:02:48,240
它會加載到你的空間的代碼了。

53
00:02:50,510 --> 00:02:54,160
>> 所以每個人都加載了代碼到他們的空間嗎？

54
00:02:54,160 --> 00:02:57,810
好吧，如果你還沒有，去進取，做到這一點，

55
00:02:57,810 --> 00:03:01,120
那麼我希望你們在這個小的辦節

56
00:03:01,120 --> 00:03:05,940
是使用printf自己寫一點點，

57
00:03:05,940 --> 00:03:08,310
例如，我會寫

58
00:03:08,310 --> 00:03:12,270
printf的（“我的名字是Nate”）;

59
00:03:15,140 --> 00:03:17,700
然後我會寫

60
00:03:17,700 --> 00:03:21,660
“我2009年畢業的

61
00:03:21,660 --> 00:03:24,440
從斯坦福大學“

62
00:03:26,050 --> 00:03:28,390
，我很想聽到

63
00:03:28,390 --> 00:03:30,270
你是哪一年在學校裡，

64
00:03:30,270 --> 00:03:33,910
無論你是在大學或商學院

65
00:03:33,910 --> 00:03:36,130
或其他的哈佛學派，

66
00:03:36,130 --> 00:03:39,200
你正在學習什麼，如果它的未知;

67
00:03:39,200 --> 00:03:41,290
如果它不知道，這是很酷的。

68
00:03:41,290 --> 00:03:45,170
我沒有決定，直到我在我大二的時候已經很晚了。

69
00:03:46,910 --> 00:03:49,210
然後我也很想知道

70
00:03:49,210 --> 00:03:51,610
什麼瘋狂的，你要告訴我，或

71
00:03:51,610 --> 00:03:54,790
類或別的什麼。

72
00:03:56,930 --> 00:04:00,370
當你寫完你的小printf的，

73
00:04:00,370 --> 00:04:03,480
如果你能保存修改，或者更確切地說，

74
00:04:03,480 --> 00:04:06,080
首先要確定，你可以運行它

75
00:04:06,080 --> 00:04:10,640
它打印出的正是你想要它打印出來，

76
00:04:14,050 --> 00:04:16,399
然後如果你繼續前進，並保存該修訂

77
00:04:16,399 --> 00:04:21,600
使用修改保存“按鈕，這小傢伙在這裡，

78
00:04:24,080 --> 00:04:27,340
，我們會有點兒經過，這樣做一簡單介紹。

79
00:04:27,340 --> 00:04:30,150
所以，你應該只需要點擊“播放”按鈕，

80
00:04:30,150 --> 00:04:32,550
這是在左上角，

81
00:04:32,550 --> 00:04:35,340
所以這左上角的播放按鈕將

82
00:04:35,340 --> 00:04:39,050
你的代碼發送到我們的服務器，它被編譯，然後運行。

83
00:04:40,600 --> 00:04:43,300
那麼，什麼是有點瘋狂

84
00:04:43,300 --> 00:04:46,550
這段代碼實際上是在計算機上運行;

85
00:04:46,550 --> 00:04:49,290
它實際上是在互聯網上發送。

86
00:04:49,290 --> 00:04:51,240
>> 怎麼樣了，夏洛特？

87
00:04:51,240 --> 00:04:54,810
>>我 - 好了。我 - 我想我

88
00:04:54,810 --> 00:04:57,330
有困難的保存

89
00:04:57,330 --> 00:05:00,530
在服務器上，這樣它可以 - 我可以運行的程序。

90
00:05:02,090 --> 00:05:05,780
然後當我嘗試運行它，它說，有一個錯誤。

91
00:05:05,780 --> 00:05:08,850
聲明為病毒，這是不是在那裡了。

92
00:05:08,850 --> 00:05:11,860
哦，讓我們來看看，你可以點擊保存再？

93
00:05:11,860 --> 00:05:13,770
我看到它在屏幕上。

94
00:05:13,770 --> 00:05:15,120
“對了，好了，所以這是我所擁有的。

95
00:05:15,120 --> 00:05:19,430
我不知道為什麼它不會讓我運行它。

96
00:05:22,990 --> 00:05:24,990
哦，好吧，對不起。

97
00:05:27,930 --> 00:05:31,220
你能解釋為什麼 - 什麼是錯的 - 什麼是不工作？

98
00:05:31,220 --> 00:05:34,760
“是啊，因為我沒有看到，有一個最後一行那裡的仍然是一個變量

99
00:05:34,760 --> 00:05:37,700
我沒有宣布，我不打算為它在那裡。

100
00:05:37,700 --> 00:05:38,730
是的，完美的！

101
00:05:38,730 --> 00:05:40,390
>>現在，如果我保存它，我認為它應該工作。

102
00:05:40,390 --> 00:05:42,970
現在，你已經救了它，它的工作原理;真棒。

103
00:05:42,970 --> 00:05:44,570
>> 所以，是的，我們通過 - 

104
00:05:44,570 --> 00:05:46,690
所以發生了什麼事情，

105
00:05:46,690 --> 00:05:49,130
我只是重複的攝像頭。

106
00:05:49,130 --> 00:05:51,760
發生了什麼事，這個變量s

107
00:05:51,760 --> 00:05:54,310
留在後 - 我想你刪除了一些其他的東西，

108
00:05:54,310 --> 00:05:56,670
你宣布，

109
00:05:56,670 --> 00:05:59,560
，所以這個扔東西了，並沒有讓你運行它。

110
00:05:59,560 --> 00:06:02,540
因此，這正是我們想要做的第

111
00:06:02,540 --> 00:06:05,690
有人嘗試寫不同的代碼塊，

112
00:06:05,690 --> 00:06:08,490
編譯它，看看你的作品，看看有什麼不

113
00:06:08,490 --> 00:06:10,730
然後有點談論這些事情，因為這是跳閘點

114
00:06:10,730 --> 00:06:12,850
我仍然會遇到，

115
00:06:12,850 --> 00:06:15,470
我還是 - 我做很多愚蠢的東西所有的時間，

116
00:06:15,470 --> 00:06:17,820
我不知道為什麼它不工作，

117
00:06:17,820 --> 00:06:22,960
讓我們拉起夏洛特的修訂3，

118
00:06:23,980 --> 00:06:25,380
我們會運行它。

119
00:06:25,380 --> 00:06:28,950
>> 所以，當我運行了，現在我已經拿到了她在這裡的代碼，

120
00:06:28,950 --> 00:06:31,450
我可以放大，打到“運行”按鈕，

121
00:06:31,450 --> 00:06:33,680
上傳它，建立它，運行它，

122
00:06:33,680 --> 00:06:36,980
說，它成功地跑了，如果我向下滾動，

123
00:06:36,980 --> 00:06:39,440
夏洛特是一個大三學生亞當斯房子，

124
00:06:39,440 --> 00:06:42,720
心理學，經濟二次真棒。

125
00:06:42,720 --> 00:06:44,310
很高興見到你！

126
00:06:44,310 --> 00:06:46,550
真棒。

127
00:06:46,550 --> 00:06:49,670
好，繼續，讓我們去丹尼爾，

128
00:06:49,670 --> 00:06:52,710
修訂3，

129
00:06:52,710 --> 00:06:54,180
編譯，運行;

130
00:06:54,180 --> 00:06:56,680
你為什麼不告訴我們一些關於自己，丹尼爾？

131
00:06:56,680 --> 00:06:59,380
給我打電話丹。

132
00:06:59,380 --> 00:07:01,920
我要你們對面的商學院，

133
00:07:01,920 --> 00:07:05,020
我是在海軍陸戰隊員之前，在這裡，

134
00:07:05,020 --> 00:07:08,020
這是我的全部新，所以啊。

135
00:07:08,020 --> 00:07:11,060
不要難過，我30歲，我不知道任何這方面的東西。

136
00:07:11,060 --> 00:07:13,800
真棒，謝謝你，丹！

137
00:07:13,800 --> 00:07:17,300
好了，我們還有丹尼爾。

138
00:07:17,300 --> 00:07:20,930
您的丹尼爾 - 你介紹一下自己，丹尼爾？

139
00:07:20,930 --> 00:07:22,260
>> >>當然，我是丹尼爾。

140
00:07:22,260 --> 00:07:24,330
我是一個大二的學生現在在奧美。

141
00:07:24,330 --> 00:07:25,840
我專注於政府，

142
00:07:25,840 --> 00:07:28,760
但我想藉此CS50，因為我已​​經聽到了巨大的類評論

143
00:07:28,760 --> 00:07:30,750
和我從來沒有嘗試過CS。

144
00:07:30,750 --> 00:07:34,680
向下滾動，並出示此 - 涼。

145
00:07:36,330 --> 00:07:39,090
移動，賈里德。

146
00:07:39,090 --> 00:07:41,990
怎麼了？

147
00:07:41,990 --> 00:07:43,430
>>好，你怎麼樣？

148
00:07:43,430 --> 00:07:47,520
正如你可以看到，我是一個初中理念集中在艾略特，

149
00:07:47,520 --> 00:07:50,260
最初由加利福尼亞州南部，

150
00:07:50,260 --> 00:07:53,100
和我採取CS50很感興趣，因為我喜歡它的邏輯，

151
00:07:53,100 --> 00:07:57,420
它在電腦上做的事情，所以看起來真的很酷。

152
00:07:57,420 --> 00:07:59,570
真棒，你是在南加州嗎？

153
00:07:59,570 --> 00:08:02,340
“關於一個小時[聽不清]的一個小城市[聽不清]。

154
00:08:02,340 --> 00:08:04,850
哦，是的，我爸從雷德蘭茲。

155
00:08:04,850 --> 00:08:07,060
很酷的東西。

156
00:08:07,060 --> 00:08:12,130
>> 好吧，吉米怎麼了，吉米？

157
00:08:12,130 --> 00:08:15,130
>>好，你怎麼樣？

158
00:08:15,130 --> 00:08:16,040
算不錯了！

159
00:08:16,040 --> 00:08:17,710
告訴我們你的。

160
00:08:17,710 --> 00:08:20,840
我是一名大一新生，我不知道我主修

161
00:08:20,840 --> 00:08:22,820
但我有點傾向於經濟學。

162
00:08:22,820 --> 00:08:25,680
像丹尼爾在我面前，我從來沒有做過任何CS，但它聽起來還挺酷的。

163
00:08:25,680 --> 00:08:28,120
我最初來自芝加哥。

164
00:08:28,120 --> 00:08:31,640
真棒。因此，檢查了他的打印輸出。

165
00:08:31,640 --> 00:08:34,630
我想問問，這樣做打印出你所期望的嗎？

166
00:08:34,630 --> 00:08:37,650
>>沒有，我忘了打印新的生產線。

167
00:08:37,650 --> 00:08:41,270
我竟然忘了，當我在寫我的事

168
00:08:41,270 --> 00:08:43,090
為第一次，太。

169
00:08:43,090 --> 00:08:46,330
這是一種痛苦，要記得把那些手動。

170
00:08:46,330 --> 00:08:50,560
它會是不錯的，如果它只是知道這是你想要的。

171
00:08:50,560 --> 00:08:53,630
>> 好吧，凱利。

172
00:08:53,630 --> 00:08:56,050
哇，我們有2個的凱麗; 2丹尼爾斯，2凱麗。

173
00:08:56,050 --> 00:09:00,490
因此，凱利 - 你去凱利任嗎？

174
00:09:00,490 --> 00:09:03,870
好了，真棒。

175
00:09:03,870 --> 00:09:07,270
凱利，我的意思。

176
00:09:07,270 --> 00:09:10,260
“所以呀，所以我凱利。

177
00:09:10,260 --> 00:09:12,930
我大二學生Pfoho。

178
00:09:12,930 --> 00:09:17,000
今天，我仍然有7週宣布我的注意力，我收到一封郵件，

179
00:09:17,000 --> 00:09:20,940
所以我試著不去想它，

180
00:09:20,940 --> 00:09:24,090
和我喜歡烘焙，運行和Craisins。

181
00:09:24,090 --> 00:09:29,110
我沒有經驗，大部分的CS;

182
00:09:29,110 --> 00:09:32,700
我教自己建立的網站，我很年輕的時候，

183
00:09:32,700 --> 00:09:35,750
但我想我可能教自己錯了很多次。

184
00:09:35,750 --> 00:09:39,260
希望我會學多一點點

185
00:09:39,260 --> 00:09:41,450
 - 是的。

186
00:09:41,450 --> 00:09:44,100
>> 真棒，好，謝謝你。

187
00:09:44,100 --> 00:09:47,190
讓我們去其它Kelly;

188
00:09:47,190 --> 00:09:48,880
我沒有什麼 - 你在這裡說些什麼？

189
00:09:48,880 --> 00:09:51,880
>> [聽不清]

190
00:09:51,880 --> 00:09:56,180
在那裡！

191
00:09:56,180 --> 00:09:58,120
太好了！

192
00:09:58,120 --> 00:10:01,400
>>所有權利，所以我凱利。

193
00:10:01,400 --> 00:10:03,980
我是第一年的研究生。

194
00:10:03,980 --> 00:10:05,560
我主修心，腦和教育。

195
00:10:05,560 --> 00:10:07,940
在2008年，我畢業於富蘭克林與馬歇爾學院

196
00:10:07,940 --> 00:10:10,840
在心理學和社會​​學專業

197
00:10:10,840 --> 00:10:13,120
未成年人在法國。

198
00:10:13,120 --> 00:10:15,330
我CS50

199
00:10:15,330 --> 00:10:18,080
因為我有興趣在神經科學中獲得博士學位

200
00:10:18,080 --> 00:10:21,220
我覺得這會幫助我了解正在使用的技術。

201
00:10:21,220 --> 00:10:23,150
真棒。

202
00:10:26,980 --> 00:10:29,390
移動，米凱拉。

203
00:10:29,390 --> 00:10:31,640
那是正確的發音嗎？

204
00:10:31,640 --> 00:10:32,990
好了，真棒。

205
00:10:32,990 --> 00:10:34,640
>> >>，我Mikhaila。

206
00:10:34,640 --> 00:10:36,870
我是一個大二的學生在柯克蘭樓，

207
00:10:36,870 --> 00:10:39,950
我集中在機械工程。

208
00:10:39,950 --> 00:10:43,180
我真的很喜歡騎自行車，自行車在今年夏天建成。

209
00:10:43,180 --> 00:10:46,140
我的CS，其實，

210
00:10:46,140 --> 00:10:48,350
作為的濃度要求，

211
00:10:48,350 --> 00:10:52,550
但你知道，我認為這是尚酷樣的工程類。

212
00:10:52,550 --> 00:10:55,150
真棒 - 你建立了一個自行車今年夏天？

213
00:10:55,150 --> 00:10:56,730
>>呀。

214
00:10:56,730 --> 00:10:58,900
哇，像框架和所有呢？

215
00:10:58,900 --> 00:11:00,120
>> UH-hunh（肯定的）。

216
00:11:00,120 --> 00:11:01,530
哇，這真的很酷。

217
00:11:01,530 --> 00:11:06,370
>> [卡通攝像頭聊天]

218
00:11:06,370 --> 00:11:10,000
[笑聲]

219
00:11:12,640 --> 00:11:14,200
是啊，這是這麼久。

220
00:11:14,200 --> 00:11:16,730
你永遠不知道，對不對？

221
00:11:16,730 --> 00:11:19,420
好了，涼;以及感謝，Mikhaila。

222
00:11:19,420 --> 00:11:21,390
>> 好了，大小姐。

223
00:11:21,390 --> 00:11:23,280
>>我的名字叫大小姐，我是一個大一學生，

224
00:11:23,280 --> 00:11:25,500
因此，這意味著我什麼都不知道！

225
00:11:25,500 --> 00:11:29,180
我想集中在天體物理學。

226
00:11:29,180 --> 00:11:31,220
在CS50，

227
00:11:31,220 --> 00:11:33,350
我覺得肯定會幫助。

228
00:11:33,350 --> 00:11:37,750
我是一個奇怪的事實，我是國家認證的消防隊員。

229
00:11:37,750 --> 00:11:39,960
哇！

230
00:11:39,960 --> 00:11:42,440
這是怎麼回事呢？

231
00:11:42,440 --> 00:11:45,570
>>我參加了學院

232
00:11:45,570 --> 00:11:49,000
經歷了地獄了很多週

233
00:11:49,000 --> 00:11:51,200
並得到我的認證。

234
00:11:51,200 --> 00:11:54,090
哇，恭喜！

235
00:11:54,090 --> 00:11:57,280
這是不小的壯舉，是肯定的。

236
00:11:57,280 --> 00:11:59,070
好了，現在我們要做我。

237
00:11:59,070 --> 00:12:01,290
我行中的下一個。

238
00:12:01,290 --> 00:12:04,510
我 - 運行它。

239
00:12:04,510 --> 00:12:07,580
>> 所以我的名字是Nate。

240
00:12:07,580 --> 00:12:11,160
我是2009級在斯坦福大學。

241
00:12:11,160 --> 00:12:13,840
我是一個符號系統的主要

242
00:12:13,840 --> 00:12:17,370
這是心，腦，行為集中在這裡，

243
00:12:17,370 --> 00:12:19,300
但它是一種混合

244
00:12:19,300 --> 00:12:22,350
計算機科學，語言學，心理學和哲學。

245
00:12:22,350 --> 00:12:26,600
樣的 - 是的，有很多奇怪的東西，但它是偉大的，

246
00:12:26,600 --> 00:12:29,880
，然後我做我的主人在計算機科學，以及。

247
00:12:29,880 --> 00:12:33,250
所以，我到哈佛大學今年。

248
00:12:33,250 --> 00:12:35,750
我真的很想進入教學。

249
00:12:35,750 --> 00:12:39,860
我花了近4年在斯坦福大學的TA-計算機科學類

250
00:12:39,860 --> 00:12:43,370
大衛讓我來吧，

251
00:12:43,370 --> 00:12:45,550
我要幫助CS50，

252
00:12:45,550 --> 00:12:47,890
所以我做到這一點的時候，我不是在讀研究生。

253
00:12:47,890 --> 00:12:50,330
這很有趣。

254
00:12:50,330 --> 00:12:53,130
希望它會繼續是有趣的，我敢肯定會的。

255
00:12:53,130 --> 00:12:56,040
>> 所有權利，山姆。

256
00:13:01,910 --> 00:13:05,470
>>我的名字是山姆，我是在大學二年級，在法律上明確。

257
00:13:05,470 --> 00:13:10,110
我主要將是科學史上的可能，VES二次，

258
00:13:10,110 --> 00:13:13,240
我最喜歡的顏色是黃色的。

259
00:13:18,790 --> 00:13:21,100
沒有必要通過判斷或任何東西，但它是一個很好的顏色！

260
00:13:21,100 --> 00:13:24,780
斯特拉。

261
00:13:24,780 --> 00:13:26,980
>>你好，我是斯特拉，我是一個大一的灰色。

262
00:13:26,980 --> 00:13:30,070
我有沒有什麼線索，我尚未集中，

263
00:13:30,070 --> 00:13:32,500
所以CS50是一種隨機，

264
00:13:32,500 --> 00:13:34,220
這是有趣的。

265
00:13:34,220 --> 00:13:36,080
有趣的事實，吉米是哈佛的第一個朋友，

266
00:13:36,080 --> 00:13:38,360
因為我們倆都從芝加哥。

267
00:13:38,360 --> 00:13:42,450
冷卻，格雷斯 - 這應該是非常好的，對不對？

268
00:13:42,450 --> 00:13:45,220
>>我想[聽不清]。

269
00:13:45,220 --> 00:13:46,690
哦，是的。

270
00:13:46,690 --> 00:13:51,210
[卡通/關閉攝像頭聊天]

271
00:13:51,210 --> 00:13:54,420
好了，我現在還在學習，還在學習。

272
00:13:54,420 --> 00:13:57,800
>> 因此，我們有別的東西，這是一種有趣的。

273
00:13:59,600 --> 00:14:02,870
是啊，我只是想知道，你有一個想法，是怎麼回事？

274
00:14:02,870 --> 00:14:05,890
你知道該如何解釋呢？

275
00:14:05,890 --> 00:14:13,340
>>我本來是要每一行後面的分號。

276
00:14:13,340 --> 00:14:16,370
這是一種痛苦。

277
00:14:16,370 --> 00:14:19,100
有時，這些的分號可以是一個真正的痛苦追查。

278
00:14:19,100 --> 00:14:21,420
所以，事實證明，

279
00:14:21,420 --> 00:14:22,820
我們使用的是今年的特別節目

280
00:14:22,820 --> 00:14:26,670
編譯我們的C代碼被稱為鐺，

281
00:14:26,670 --> 00:14:29,460
的原因，我們已經開始使用鐺今年 - 

282
00:14:29,460 --> 00:14:32,030
因為我們沒有使用該程序在過去的;

283
00:14:32,030 --> 00:14:35,710
我們已經使用了另外一個叫GCC，實在是很受歡迎 - 

284
00:14:35,710 --> 00:14:38,420
鐺實際上是為您提供了有意義的錯誤消息。

285
00:14:38,420 --> 00:14:41,420
這一個說，“預計”，“表達”之後，

286
00:14:41,420 --> 00:14:45,260
它甚至會告訴你之後，你需要一個分號的表達。

287
00:14:45,260 --> 00:14:47,830
那麼，你修復它？

288
00:14:47,830 --> 00:14:48,930
>>是的，沒錯。

289
00:14:48,930 --> 00:14:52,040
真棒，讓我知道，我們將它拉起來，我們將運行它。

290
00:14:52,040 --> 00:14:55,830
但是，是的，把這些分號，是一種痛苦。

291
00:14:55,830 --> 00:14:59,580
我固定的，所以我認為它應該工作。

292
00:14:59,580 --> 00:15:02,760
真棒 - 修訂3。

293
00:15:02,760 --> 00:15:05,250
這看起來像它。

294
00:15:05,250 --> 00:15:08,580
好了，所以現在如果我們運行它，

295
00:15:08,580 --> 00:15:11,020
就這樣吧。

296
00:15:11,020 --> 00:15:13,830
很酷的東西。

297
00:15:13,830 --> 00:15:15,340
>> 好的。

298
00:15:15,340 --> 00:15:18,230
因此，感謝你這樣做。

299
00:15:18,230 --> 00:15:20,210
這極大地滿足了你們。

300
00:15:20,210 --> 00:15:22,880
什麼現在我們要做的就是在接下來的點點

301
00:15:22,880 --> 00:15:24,740
有點潛入的部分問題

302
00:15:24,740 --> 00:15:27,550
從本週的問題來自

303
00:15:27,550 --> 00:15:29,920
我們會做到這一點的大部分路段

304
00:15:29,920 --> 00:15:32,110
的其餘部分的術語，

305
00:15:32,110 --> 00:15:35,580
然後，我們將保存最後15，20分鐘左右

306
00:15:35,580 --> 00:15:38,490
談論的問題本身

307
00:15:38,490 --> 00:15:41,420
，然後就您有任何其他問題，在一般的類。

308
00:15:43,380 --> 00:15:45,670
這就是說，我們真的很想做

309
00:15:45,670 --> 00:15:49,390
有大家參與

310
00:15:49,390 --> 00:15:51,500
使用空間的東西，

311
00:15:51,500 --> 00:15:53,500
在代碼中扔，扔了建議，

312
00:15:53,500 --> 00:15:56,500
和談論這樣的事情休息時，

313
00:15:56,500 --> 00:15:58,360
或不工作，只是因為這些事情，

314
00:15:58,360 --> 00:16:00,870
我知道我遇到了

315
00:16:00,870 --> 00:16:03,180
當我開始編碼，

316
00:16:03,180 --> 00:16:05,490
真的有點令人沮喪次

317
00:16:05,490 --> 00:16:08,690
因為如果它像凌晨2點之前是由於你的習題集，

318
00:16:08,690 --> 00:16:11,330
 - 只為披露，

319
00:16:11,330 --> 00:16:14,590
我並沒有開始編程，直到我是一個大二學生。

320
00:16:14,590 --> 00:16:17,360
這是種奇怪的，未知的事情

321
00:16:17,360 --> 00:16:20,360
我聽到的是有點涼

322
00:16:20,360 --> 00:16:23,590
我還聽說它可能是一個真正的痛苦的對接

323
00:16:23,590 --> 00:16:27,610
如果你錯過了一個分號，使你的程序不能正常工作，這是唯一的錯誤

324
00:16:27,610 --> 00:16:30,890
讓你去睡覺，

325
00:16:30,890 --> 00:16:32,650
所以肯定，

326
00:16:32,650 --> 00:16:34,020
如果你有這樣的問題，

327
00:16:34,020 --> 00:16:37,060
如果你有這樣的問題，讓我知道，

328
00:16:37,060 --> 00:16:40,050
因為我要讓你們這是一個很好的經驗。

329
00:16:40,050 --> 00:16:44,620
>> 因此，有你們所有下載的問題還設置？

330
00:16:44,620 --> 00:16:47,160
均田知道它在哪裡？好吧。

331
00:16:47,160 --> 00:16:51,490
所以，我們去cs50.net，因為我沒有在此帳戶，

332
00:16:51,490 --> 00:16:54,110
拉起來的問題集，

333
00:16:54,110 --> 00:16:57,940
拉起來的問題集2，今天我們來看看標準版。

334
00:16:57,940 --> 00:17:01,190
我們會拉規範。

335
00:17:02,640 --> 00:17:04,420
向下滾動。

336
00:17:06,790 --> 00:17:11,109
因此，我們要的問題，在本節開始尋找。

337
00:17:14,069 --> 00:17:16,710
你們看著這些短褲嗎？

338
00:17:16,710 --> 00:17:18,329
好吧。

339
00:17:18,329 --> 00:17:21,329
所以有循環短褲，

340
00:17:21,329 --> 00:17:24,700
這是由湯米，頭部教學研究員之一。

341
00:17:24,700 --> 00:17:27,230
還有一個關於範圍，

342
00:17:27,230 --> 00:17:30,530
我相信，通過另一個教學名叫大衛的傢伙，

343
00:17:30,530 --> 00:17:33,400
愷撒密碼，然後由大衛也做了。

344
00:17:33,400 --> 00:17:35,550
他們很酷。

345
00:17:35,550 --> 00:17:37,770
你們看他們的短褲這麼遠嗎？

346
00:17:37,770 --> 00:17:39,270
還好嗎他們了？

347
00:17:39,270 --> 00:17:41,490
有幫助嗎？好了，好知道。

348
00:17:41,490 --> 00:17:44,210
如果不是這樣，你可以這麼說。

349
00:17:46,290 --> 00:17:49,870
但在此之前，

350
00:17:49,870 --> 00:17:52,600
有你們看著這些問題，

351
00:17:52,600 --> 00:17:55,430
在所有？

352
00:17:55,430 --> 00:17:57,480
>> 讓我們來談談這有點。

353
00:17:57,480 --> 00:18:00,600
因此，我們已經介紹了在過去的幾個星期

354
00:18:00,600 --> 00:18:02,480
在講座

355
00:18:02,480 --> 00:18:04,910
若干不同的循環。

356
00:18:04,910 --> 00:18:06,140
有for循環，

357
00:18:06,140 --> 00:18:09,570
while循環，do-whil​​e循環，

358
00:18:09,570 --> 00:18:13,100
在講座中，我們已經談論了很多有關

359
00:18:13,100 --> 00:18:16,010
如何將這些循環

360
00:18:16,010 --> 00:18:18,320
相當類似，在很多方面，

361
00:18:18,320 --> 00:18:21,210
和一個while循環，你可以做同樣的事情

362
00:18:21,210 --> 00:18:23,260
你可以用一個for循環。

363
00:18:23,260 --> 00:18:26,300
你只需要種使用正確的組合變量等。

364
00:18:26,300 --> 00:18:28,680
等真的

365
00:18:28,680 --> 00:18:31,200
所有的循環的真正區別是，

366
00:18:31,200 --> 00:18:33,620
有時，他們更多有用的

367
00:18:33,620 --> 00:18:36,930
使用它們比在另一時間在同一時間。

368
00:18:36,930 --> 00:18:39,340
>> 因此，例如，

369
00:18:39,340 --> 00:18:42,260
從do-whil​​e循環while循環不同的。

370
00:18:42,260 --> 00:18:45,680
大家都覺得像他們有一個很好的處理時

371
00:18:45,680 --> 00:18:48,650
一個do-whil​​e循環更

372
00:18:48,650 --> 00:18:50,990
有用的或有什麼區別嗎？

373
00:18:50,990 --> 00:18:53,410
>>我認為所不同的是一個do-whil​​e循環

374
00:18:53,410 --> 00:18:56,960
運行 - 我不知道是怎樣的術語，

375
00:18:56,960 --> 00:18:59,750
但內環路的一系列的功能。

376
00:18:59,750 --> 00:19:02,020
他們自動 - 它至少運行

377
00:19:02,020 --> 00:19:05,390
前檢查的情況下，或在while循環將只運行它時，

378
00:19:05,390 --> 00:19:08,290
連續運行 - 是否得到滿足的條件。

379
00:19:08,290 --> 00:19:11,010
是的，這有意義嗎？

380
00:19:11,010 --> 00:19:14,200
>> 讓我們來看看一點點的代碼。

381
00:19:14,200 --> 00:19:16,930
因此，只要重複的問題，

382
00:19:16,930 --> 00:19:19,230
或答案，而;

383
00:19:19,230 --> 00:19:22,050
得到的答复是，

384
00:19:22,050 --> 00:19:25,850
一個while循環檢查，看看是否條件

385
00:19:25,850 --> 00:19:27,440
您指定的會面

386
00:19:27,440 --> 00:19:31,320
前運行的主體的第一次循環，

387
00:19:31,320 --> 00:19:35,000
而do-whil​​e循環會自動執行循環體，

388
00:19:35,000 --> 00:19:38,450
就是我們所說的 - 這是奇怪的術語，

389
00:19:38,450 --> 00:19:41,460
但如果我說什麼沒有意義的，讓我知道 - 

390
00:19:41,460 --> 00:19:45,360
循環體是，你把花括號之間的東西。

391
00:19:45,360 --> 00:19:47,840
在do-whil​​e循環，

392
00:19:47,840 --> 00:19:50,220
該機構獲得至少運行一次，

393
00:19:50,220 --> 00:19:54,460
檢查的條件，然後被運行之前，每個連續的時間。

394
00:19:54,460 --> 00:19:56,580
>> 因此，實際上，山姆，

395
00:19:56,580 --> 00:20:00,820
你不介意編寫一個簡單的while循環

396
00:20:00,820 --> 00:20:02,840
在空間？

397
00:20:02,840 --> 00:20:05,600
>>你怎麼有點像

398
00:20:05,600 --> 00:20:07,060
一個新的嗎？

399
00:20:07,060 --> 00:20:09,220
我只是刪除了，無論你在那裡。

400
00:20:09,220 --> 00:20:11,300
是啊，就清除它。

401
00:20:11,300 --> 00:20:14,510
>>好吧，我相信我有這個 - 

402
00:20:14,510 --> 00:20:16,640
哪一個你想要的，而你要嗎？

403
00:20:16,640 --> 00:20:19,350
是啊，就做了而真正的，打印的東西。

404
00:20:21,050 --> 00:20:23,140
讓我們來看看。

405
00:20:23,140 --> 00:20:25,850
亞歷山大，我意識到我們從來沒有向你介紹。

406
00:20:25,850 --> 00:20:27,510
“哦，那很好。

407
00:20:27,510 --> 00:20:30,760
你 - 你可以編寫一個do-whil​​e循環的我們嗎？

408
00:20:30,760 --> 00:20:32,520
是的，我會盡力。

409
00:20:32,520 --> 00:20:34,370
好了，我們就拉在屏幕上，

410
00:20:34,370 --> 00:20:38,240
種讓你有一個把手上的差異是什麼。

411
00:20:38,240 --> 00:20:41,280
>> 因此，這裡的山姆做什麼。

412
00:20:41,280 --> 00:20:44,460
他有一個名為i的整數

413
00:20:44,460 --> 00:20:47,480
他的初始化為17。

414
00:20:47,480 --> 00:20:51,570
然後，他說，雖然（INT I = 17）

415
00:20:51,570 --> 00:20:54,230
printf的（“我的名字是山姆”）;

416
00:20:54,230 --> 00:20:57,300
所以我們運行這個代碼時會發生什麼？

417
00:20:57,300 --> 00:21:00,340
有一個錯誤;錯誤說什麼？

418
00:21:00,340 --> 00:21:02,890
讓我們把它和談論它。

419
00:21:02,890 --> 00:21:05,040
發生錯誤，它說。

420
00:21:05,040 --> 00:21:07,400
讓我們向下滾動。

421
00:21:07,400 --> 00:21:09,460
因此，它給了我們這個錯誤，它說，

422
00:21:09,460 --> 00:21:12,690
“嘿，我預計的表達。”

423
00:21:12,690 --> 00:21:16,180
這有點難以理解。

424
00:21:19,160 --> 00:21:23,140
是啊，所以準確 - 再次，

425
00:21:23,140 --> 00:21:27,140
會有另一個小錯誤，我們將趕在第二。

426
00:21:27,140 --> 00:21:31,800
但是，這是另一個那些奇怪的術語的東西，

427
00:21:31,800 --> 00:21:36,150
所以這INT I = 17

428
00:21:36,150 --> 00:21:39,290
是不是一個表達式。

429
00:21:39,290 --> 00:21:41,220
它看起來像它在做什麼，是它的

430
00:21:41,220 --> 00:21:43,410
聲明一個整數叫我

431
00:21:43,410 --> 00:21:45,540
將其設置為等於17

432
00:21:45,540 --> 00:21:48,780
或者說，叫我把17這個int。

433
00:21:50,560 --> 00:21:53,350
這沒有任何意義

434
00:21:53,350 --> 00:21:55,790
在這個while循環的上下文中。

435
00:21:55,790 --> 00:21:58,190
這有一定道理，因為我們可以看到，

436
00:21:58,190 --> 00:22:01,250
for循環的背景下，由於環聲明開始

437
00:22:01,250 --> 00:22:05,800
為int i等於什麼

438
00:22:05,800 --> 00:22:07,830
和。

439
00:22:07,830 --> 00:22:09,500
>> 那你有沒有 - 

440
00:22:09,500 --> 00:22:12,630
修復的東西，所有的權利。

441
00:22:12,630 --> 00:22:15,270
在這裡，它會真棒。

442
00:22:15,270 --> 00:22:17,920
所以，現在的情況看起來有些不同。

443
00:22:17,920 --> 00:22:19,030
一對夫婦的事情發生了變化。

444
00:22:19,030 --> 00:22:21,300
你能告訴我們什麼事情發生了變化？

445
00:22:21,300 --> 00:22:24,950
>>我拿出的int，所以沒有聲明[聽不清]，而不是分配。

446
00:22:24,950 --> 00:22:28,770
一個等號，我把2個等號，這意味著一個等號。

447
00:22:28,770 --> 00:22:30,560
真棒。

448
00:22:30,560 --> 00:22:33,320
是啊，所以什麼山姆沒有他拿出的int

449
00:22:33,320 --> 00:22:35,770
這是在這裡，

450
00:22:35,770 --> 00:22:39,340
所以，如果我只是在看這 - 這是早，故稱INT，

451
00:22:39,340 --> 00:22:41,970
宣布 - 讓我們拿出的類型。

452
00:22:41,970 --> 00:22:44,710
int，char和字符串，短，

453
00:22:44,710 --> 00:22:47,380
那些被稱為類型。

454
00:22:47,380 --> 00:22:49,510
所以，你拿出的類型

455
00:22:49,510 --> 00:22:51,580
然後以前，

456
00:22:51,580 --> 00:22:54,190
他只是單一等號

457
00:22:54,190 --> 00:22:57,300
他說的是問題的有關

458
00:22:57,300 --> 00:22:59,580
當你有1個等號，

459
00:22:59,580 --> 00:23:01,780
這是一個賦值運算符。

460
00:23:01,780 --> 00:23:04,930
這不是測試，是否事情都是平等的。

461
00:23:04,930 --> 00:23:07,920
這實際上是設置的東西的東西。

462
00:23:07,920 --> 00:23:11,110
我們將在17號到變量i。

463
00:23:11,110 --> 00:23:13,850
因此，做這種比較，

464
00:23:13,850 --> 00:23:16,430
你必須使用雙等號，

465
00:23:16,430 --> 00:23:19,640
這是一種一個奇怪的事情

466
00:23:19,640 --> 00:23:22,760
但它是一個相當常見的錯誤。

467
00:23:23,980 --> 00:23:27,830
因此，另一件事情，我會指出，如果你不介意的話，

468
00:23:27,830 --> 00:23:30,610
的是，在

469
00:23:30,610 --> 00:23:33,210
在國際主要功能，

470
00:23:33,210 --> 00:23:36,740
你看，我們的身體功能

471
00:23:36,740 --> 00:23:39,810
從左側偏移

472
00:23:39,810 --> 00:23:42,400
4個空格或製表符。

473
00:23:42,400 --> 00:23:44,730
我們這樣做的原因

474
00:23:44,730 --> 00:23:47,000
僅僅是為了提高可讀性。

475
00:23:47,000 --> 00:23:51,620
正如你可以看到這裡在山姆的while循環中，

476
00:23:51,620 --> 00:23:53,120
他並沒有在所有的縮進，

477
00:23:53,120 --> 00:23:55,390
並且不影響的功能的代碼。

478
00:23:55,390 --> 00:23:57,860
它將運行完全一樣的。

479
00:23:57,860 --> 00:24:00,950
>> 因此，舉例來說，如果我們拿出頂端

480
00:24:00,950 --> 00:24:02,680
，然後按播放按鈕，它會建立，

481
00:24:02,680 --> 00:24:04,470
它會運行它，

482
00:24:04,470 --> 00:24:06,700
什麼事情發生？

483
00:24:06,700 --> 00:24:08,360
為什麼仍然說嗎？

484
00:24:08,360 --> 00:24:10,560
>>，因為它會不斷地重複您好。

485
00:24:10,560 --> 00:24:12,900
沒錯，為什麼它不停地重複您好嗎？

486
00:24:12,900 --> 00:24:15,850
“由於整數永遠不會改變，所以它總是17。

487
00:24:15,850 --> 00:24:18,030
是的，沒錯，所以

488
00:24:18,030 --> 00:24:20,970
讓我們來看看， - 再次提醒我你的名字嗎？

489
00:24:20,970 --> 00:24:24,020
吉米。吉米說，

490
00:24:24,020 --> 00:24:27,340
您好一遍又一遍不斷重複的原因

491
00:24:27,340 --> 00:24:30,510
是因為這種情況下總是如此。

492
00:24:30,510 --> 00:24:33,270
我們永遠不會改變i的值。

493
00:24:33,270 --> 00:24:36,170
我們永遠不會改變該變量中存儲的內容。

494
00:24:36,170 --> 00:24:39,180
因此，在這一點上，我們得到了這個錯誤，

495
00:24:39,180 --> 00:24:42,170
你的程序產生過多的輸出，

496
00:24:42,170 --> 00:24:45,100
如果我們向下滾動，看看這是怎麼回事種，

497
00:24:45,100 --> 00:24:49,160
你可以看到，它是嗨，嗨，嗨，嗨，嗨，嗨，嗨，一路過關斬將。

498
00:24:49,160 --> 00:24:51,200
真棒。

499
00:24:51,200 --> 00:24:53,750
>> 因此，種回原點

500
00:24:53,750 --> 00:24:57,020
有壓痕這裡

501
00:24:57,020 --> 00:25:00,110
在身體的while循環沒有造成任何影響。

502
00:25:00,110 --> 00:25:03,050
該程序仍運行得很好。

503
00:25:03,050 --> 00:25:06,790
通常，對於良好的作風 - 

504
00:25:06,790 --> 00:25:10,210
這是什麼，我們期待在您的問題集 - 

505
00:25:10,210 --> 00:25:13,930
我們希望您能縮進4個空格，你可以做

506
00:25:13,930 --> 00:25:16,440
只需按下Tab鍵

507
00:25:16,440 --> 00:25:18,860
或通過手動把自己的4個空格。

508
00:25:21,880 --> 00:25:25,050
酷，好了，讓我們回去看看

509
00:25:25,050 --> 00:25:30,460
亞歷山大的DO-WHILE。

510
00:25:30,460 --> 00:25:32,980
>>只是有點有點麻煩了。

511
00:25:32,980 --> 00:25:34,390
好了，讓我們的工作。

512
00:25:34,390 --> 00:25:36,400
這很酷？

513
00:25:36,400 --> 00:25:37,430
>>呀。

514
00:25:37,430 --> 00:25:39,200
>> 好了，所以在這裡我們去。

515
00:25:39,200 --> 00:25:41,010
這是代碼，亞歷山大寫道。

516
00:25:41,010 --> 00:25:43,410
你去亞歷克斯 - 好吧。

517
00:25:43,410 --> 00:25:46,380
因此，這裡的亞歷克斯寫的代碼。

518
00:25:46,380 --> 00:25:50,500
所以，我們已經得到了我們的聲明，主要就在這裡，

519
00:25:50,500 --> 00:25:54,410
然後，我們得到了這個整數變量名為i

520
00:25:54,410 --> 00:25:57,320
被宣布就在這裡。

521
00:25:57,320 --> 00:26:01,060
我們已經有了一個do語句

522
00:26:01,060 --> 00:26:04,600
然後身體再次與這些大括號，

523
00:26:04,600 --> 00:26:06,520
因此，這是人體的DO-WHILE  - 

524
00:26:06,520 --> 00:26:09,210
讓我在此放大，因此它更具可讀性 - 

525
00:26:09,210 --> 00:26:12,730
在身，我們正在試圖打印“，這是身體”，

526
00:26:12,730 --> 00:26:14,300
我+ +，

527
00:26:14,300 --> 00:26:17,710
因此，增加的內容，我這樣做

528
00:26:17,710 --> 00:26:19,470
直到i得到為3，

529
00:26:19,470 --> 00:26:22,440
那麼，我們的程序結束。

530
00:26:22,440 --> 00:26:24,680
>> 所以當我們運行這個程序時，會發生什麼呢？

531
00:26:24,680 --> 00:26:27,580
>>我預期的標識符。

532
00:26:27,580 --> 00:26:32,070
好了，因此，建立，運行，就會發生錯誤。

533
00:26:32,070 --> 00:26:34,820
發生了什麼？

534
00:26:34,820 --> 00:26:37,060
我們向下滾動，

535
00:26:37,060 --> 00:26:40,260
我們得到這個有些神秘的東西，

536
00:26:40,260 --> 00:26:43,930
預計分號後的頂級聲明。

537
00:26:43,930 --> 00:26:46,620
這是有點怪異。

538
00:26:46,620 --> 00:26:50,990
沒有任何人有一個想法可能是什麼回事上？

539
00:26:53,080 --> 00:26:54,640
有點不可思議，是的。

540
00:26:54,640 --> 00:26:57,640
>> [聽不清]聲明以外的括號？

541
00:26:57,640 --> 00:27:03,480
那麼，不適用，那麼當您使用括號嗎？

542
00:27:03,480 --> 00:27:07,390
因此，他宣稱這其中括號外的傢伙？

543
00:27:09,670 --> 00:27:12,240
噢，這些傢伙 - 在大括號？

544
00:27:12,240 --> 00:27:13,850
>>呀。

545
00:27:13,850 --> 00:27:15,310
是的，沒錯。

546
00:27:15,310 --> 00:27:17,120
所以，事實證明，

547
00:27:17,120 --> 00:27:21,550
你可以聲明一個變量實際上不是在這裡是這樣的。

548
00:27:23,750 --> 00:27:26,690
你可能一直在試圖做的是 - 

549
00:27:26,690 --> 00:27:30,110
削減它的存在 - 

550
00:27:30,110 --> 00:27:34,330
你可以把它在大括號在這裡

551
00:27:34,330 --> 00:27:37,400
或另一種選擇

552
00:27:37,400 --> 00:27:40,350
是把它完全脫離。

553
00:27:42,480 --> 00:27:46,610
所以，這些 - 這取決於你居然把聲明

554
00:27:46,610 --> 00:27:48,550
該整數變量，

555
00:27:48,550 --> 00:27:53,540
你可以得到2個不同類型的變量;

556
00:27:53,540 --> 00:27:55,100
時，它的主要外，

557
00:27:55,100 --> 00:27:58,240
這就是我們所說的一個全局變量。

558
00:27:58,240 --> 00:28:00,070
它的範圍以外的任何的功能 - 

559
00:28:00,070 --> 00:28:03,420
這是不是在函數 - 

560
00:28:03,420 --> 00:28:07,050
而如果我們把它裡面的主，

561
00:28:07,050 --> 00:28:10,000
喜歡這裡，然後它被稱為局部變量，

562
00:28:10,000 --> 00:28:13,830
因為它是本地的主要範圍。

563
00:28:13,830 --> 00:28:16,720
我們將討論多一點點的區別是什麼

564
00:28:16,720 --> 00:28:20,970
之間的2種類型，以及為什麼要使用不同類型的變量，

565
00:28:20,970 --> 00:28:23,040
但現在，

566
00:28:23,040 --> 00:28:25,070
你可以保持所有的局部變量，

567
00:28:25,070 --> 00:28:28,320
因為我們沒有任何需要全局變量。

568
00:28:28,320 --> 00:28:31,390
>> 好了，所以這是一件事。

569
00:28:31,390 --> 00:28:34,680
讓我們嘗試再次運行這個，看看會發生什麼。

570
00:28:37,420 --> 00:28:40,270
運行“，另一個錯誤。

571
00:28:40,270 --> 00:28:43,320
放大一點，我們都能得到什麼呢？

572
00:28:45,110 --> 00:28:50,000
後做/而我們得到這一預期的括號。

573
00:28:53,660 --> 00:28:55,260
任何想法，這是怎麼回事呢？丹？

574
00:28:55,260 --> 00:28:58,880
“一會兒，然後括號，然後 - 

575
00:28:58,880 --> 00:29:01,990
我不知道，如果你需要重新定義詮釋，

576
00:29:01,990 --> 00:29:04,980
但的do while（i <3的）。

577
00:29:04,980 --> 00:29:06,930
沒錯，是的。

578
00:29:06,930 --> 00:29:08,830
因此，原來，丹完全正確。

579
00:29:08,830 --> 00:29:11,230
我們沒有必要再在這裡把這個類型。

580
00:29:11,230 --> 00:29:14,440
相反，我們可以殺死類型

581
00:29:14,440 --> 00:29:17,220
做到這一點。

582
00:29:19,270 --> 00:29:21,640
好的。

583
00:29:21,640 --> 00:29:24,950
我會放大，嘗試更多的時間。

584
00:29:26,360 --> 00:29:29,580
看它運行成功。

585
00:29:29,580 --> 00:29:33,260
如果我們向下滾動，“這是身體的”打印出來的3倍。

586
00:29:33,260 --> 00:29:35,820
這是非常甜蜜的。

587
00:29:35,820 --> 00:29:38,670
幹得好，幹得好，伙計們。

588
00:29:38,670 --> 00:29:41,080
幹得好。

589
00:29:41,080 --> 00:29:43,250
怎麼這麼遠嗎？

590
00:29:43,250 --> 00:29:46,200
體面的步伐？

591
00:29:46,200 --> 00:29:49,200
好了，爽。

592
00:29:49,200 --> 00:29:52,590
>> 因此，作為一種回到原來的問題，

593
00:29:52,590 --> 00:29:55,430
我們 - 現在如果我們看到了差距，

594
00:29:55,430 --> 00:29:58,240
您看，這do-whil​​e循環，

595
00:29:58,240 --> 00:30:00,030
條件是最後的。

596
00:30:00,030 --> 00:30:02,530
因此，隨著計算機讀取程序

597
00:30:02,530 --> 00:30:06,050
種在這個順序執行C程序，

598
00:30:06,050 --> 00:30:09,450
他們從字面上開始與第一線的主要

599
00:30:09,450 --> 00:30:13,450
然後執行第6行，第7行，第8行，第9行中，

600
00:30:13,450 --> 00:30:16,150
第10行，第11行，

601
00:30:16,150 --> 00:30:18,440
這一切的東西在這裡的右上角

602
00:30:18,440 --> 00:30:20,020
要執行一次

603
00:30:20,020 --> 00:30:23,350
之前我們曾經測試情況，以

604
00:30:23,350 --> 00:30:26,240
是否我 - 的內容我，而 - 

605
00:30:26,240 --> 00:30:29,750
小於數字3。

606
00:30:29,750 --> 00:30:33,300
只有一次，我們到12號線，

607
00:30:33,300 --> 00:30:36,260
的內容的i是小於3

608
00:30:36,260 --> 00:30:39,150
我們跳轉到第7行

609
00:30:39,150 --> 00:30:41,140
然後重複這個過程中，

610
00:30:41,140 --> 00:30:44,620
然後我們測試的條​​件，再一遍又一遍。

611
00:30:44,620 --> 00:30:47,440
>> 因此，我們可以對比

612
00:30:47,440 --> 00:30:50,240
 - 縮放退了出去，

613
00:30:50,240 --> 00:30:56,500
向下滾動到山姆的版本，

614
00:30:56,500 --> 00:31:00,760
我們要看看這個，稍有改變，因此，它不再是一個無限循環 - 

615
00:31:00,760 --> 00:31:03,570
如果我們放大，

616
00:31:03,570 --> 00:31:06,300
我們可以看到，這個程序執行，

617
00:31:06,300 --> 00:31:09,120
它會首先聲明INT I，

618
00:31:09,120 --> 00:31:12,030
設置的i的內容是0，

619
00:31:12,030 --> 00:31:15,820
然後它擊中的while循環的第一條件，

620
00:31:15,820 --> 00:31:19,210
因此，在這種情況下，這個身體，這個printf（“HI”）和i + +

621
00:31:19,210 --> 00:31:21,630
甚至不會執行

622
00:31:21,630 --> 00:31:24,310
除非實際上i是小於或等於2。

623
00:31:24,310 --> 00:31:26,750
因此，如果i是3，例如，

624
00:31:26,750 --> 00:31:28,840
如果我們在這裡

625
00:31:28,840 --> 00:31:32,160
等於4  - 或者我會做，因為我說3  - 

626
00:31:32,160 --> 00:31:34,890
然後運行它，

627
00:31:34,890 --> 00:31:38,320
它會建立，它會運行完全正常，

628
00:31:38,320 --> 00:31:40,530
，但它不會打印出任何東西，

629
00:31:40,530 --> 00:31:43,030
因為它對於第一種情況，測試失敗。

630
00:31:44,780 --> 00:31:47,530
因此，在課堂上，我們談到了為什麼這些do-whil​​e循環

631
00:31:47,530 --> 00:31:49,800
是有用的，有時

632
00:31:49,800 --> 00:31:53,140
為什麼我們會使用它，而不是一個while循環。

633
00:31:53,140 --> 00:31:56,450
>> 在那裡 - 你們有任何的建議

634
00:31:56,450 --> 00:31:59,090
為什麼do-whil​​e循環可能更為有用嗎？

635
00:31:59,090 --> 00:32:02,560
>>嗯，我想do-whil​​e循環是，如果你希望用戶輸入，

636
00:32:02,560 --> 00:32:05,020
因為這樣可以讓他們

637
00:32:05,020 --> 00:32:07,780
把東西一次，如果它是正確的，

638
00:32:07,780 --> 00:32:09,300
我們可以移動到程序的其餘部分，

639
00:32:09,300 --> 00:32:11,250
但如果它是不正確的，那麼你繼續提示用戶

640
00:32:11,250 --> 00:32:13,250
直到你把正確的輸入。

641
00:32:13,250 --> 00:32:14,260
是的，沒錯 - 這正是，

642
00:32:14,260 --> 00:32:16,840
因此do-whil​​e循環是有益的

643
00:32:16,840 --> 00:32:18,930
提示用戶輸入，因為當

644
00:32:18,930 --> 00:32:23,000
因為你需要得到用戶的輸入，才能真正檢查。

645
00:32:23,000 --> 00:32:27,330
在pset中1，在pset中2，

646
00:32:27,330 --> 00:32:29,650
您在何處提示用戶輸入了很多，

647
00:32:29,650 --> 00:32:31,200
這是一個方便的事情

648
00:32:31,200 --> 00:32:33,740
而不是只是一個簡單的while循環。

649
00:32:33,740 --> 00:32:36,780
如果您使用一個while循環，你可以做同樣的事情 - 

650
00:32:36,780 --> 00:32:38,750
你可以做同樣的事情，一個while循環

651
00:32:38,750 --> 00:32:40,580
當你做一個do-whil​​e循環。

652
00:32:40,580 --> 00:32:43,380
你只需要種有這個重複的過程

653
00:32:43,380 --> 00:32:47,010
你在哪裡得到的輸入，然後開始你的while循環。

654
00:32:47,010 --> 00:32:49,800
而一個do-whil​​e循環，你只需要編寫一次

655
00:32:49,800 --> 00:32:52,430
這是一個很大清潔。

656
00:32:52,430 --> 00:32:54,650
>> 好的。

657
00:32:55,970 --> 00:32:57,330
有什麼問題嗎？

658
00:32:59,350 --> 00:33:01,380
有意義嗎？

659
00:33:01,380 --> 00:33:06,200
>>返回0  - 那只是種一檔或者是 - ？

660
00:33:06,200 --> 00:33:08,960
是啊，所以我們可以 - 

661
00:33:08,960 --> 00:33:11,960
好了，我們將討論這有點多了以後

662
00:33:11,960 --> 00:33:13,290
但事實證明，

663
00:33:13,290 --> 00:33:15,720
我們把這個返回0，

664
00:33:15,720 --> 00:33:19,090
結束時的主所有的時間 - 

665
00:33:19,090 --> 00:33:21,980
你可以還挺只是把它作為我們做的事情

666
00:33:21,980 --> 00:33:24,930
暫時。

667
00:33:24,930 --> 00:33:28,860
現在我們開始談論與功能

668
00:33:28,860 --> 00:33:31,600
種在上週結束，本週再次

669
00:33:31,600 --> 00:33:33,550
是，函數

670
00:33:33,550 --> 00:33:37,680
需要輸入括號內的這些東西;

671
00:33:37,680 --> 00:33:41,690
這是2個輸入，參數或參數，

672
00:33:41,690 --> 00:33:44,540
他們也被稱為我們的主要功能，

673
00:33:44,540 --> 00:33:48,510
然後一個函數產生一個輸出

674
00:33:48,510 --> 00:33:51,290
我們調用的返回值。

675
00:33:51,290 --> 00:33:56,260
和返回值的情況下，主要是這樣的詮釋，

676
00:33:56,260 --> 00:33:58,320
這個整數，

677
00:33:58,320 --> 00:34:01,160
告訴函數的方式，“嘿，這是你的輸出

678
00:34:01,160 --> 00:34:05,840
將是“是”回歸“這個詞，

679
00:34:05,840 --> 00:34:07,960
該關鍵字，而

680
00:34:07,960 --> 00:34:11,000
等主返回0

681
00:34:11,000 --> 00:34:13,389
或主輸出0

682
00:34:13,389 --> 00:34:15,139
在C程序中的標準

683
00:34:15,139 --> 00:34:18,110
從主要手段，因為返回0

684
00:34:18,110 --> 00:34:21,600
“嘿，一切執行我的程序就好了。”

685
00:34:21,600 --> 00:34:24,639
如果我們把其他的東西比0，

686
00:34:24,639 --> 00:34:27,440
如1中，例如，

687
00:34:27,440 --> 00:34:31,080
這是用來告訴運行這個程序

688
00:34:31,080 --> 00:34:33,540
出事了。

689
00:34:35,739 --> 00:34:39,989
所以，當我們在這學期更複雜的東西，

690
00:34:39,989 --> 00:34:42,670
如果你曾經可以說，

691
00:34:42,670 --> 00:34:46,650
“哎呀，你知道的，出了這個程序錯誤”

692
00:34:46,650 --> 00:34:49,409
而不是我的程序崩潰，我想通知

693
00:34:49,409 --> 00:34:52,310
亞軍我的程序出現了錯誤，

694
00:34:52,310 --> 00:34:54,530
您可以使用返回值，

695
00:34:54,530 --> 00:34:57,230
我們稱呼它，這是不為0。

696
00:35:00,180 --> 00:35:02,240
>> 所以我們將討論多一點點

697
00:35:02,240 --> 00:35:05,480
一旦我們進入功能。

698
00:35:05,480 --> 00:35:09,030
諸如此類的有道理嗎？

699
00:35:09,030 --> 00:35:11,240
好吧。

700
00:35:11,240 --> 00:35:13,530
函數是一種奇怪的 - 

701
00:35:13,530 --> 00:35:17,270
我認為有很多的數學背景的人，

702
00:35:17,270 --> 00:35:20,100
談到更容易一點，

703
00:35:20,100 --> 00:35:22,540
特別是如果你有一點點抽象的數學背景

704
00:35:22,540 --> 00:35:24,240
和你談論功能

705
00:35:24,240 --> 00:35:27,370
和所有類似的東西。

706
00:35:28,590 --> 00:35:30,610
但我們會盡力並覆蓋

707
00:35:30,610 --> 00:35:33,280
去很好的和緩慢的，因為他們來了。

708
00:35:34,730 --> 00:35:37,870
同樣，這整個的int argc個，

709
00:35:37,870 --> 00:35:41,090
的char * argv的[]

710
00:35:41,090 --> 00:35:44,960
現在，你也可以把它看作鍋爐板。

711
00:35:46,650 --> 00:35:49,050
我們已經開始覆蓋那些在演講一點點

712
00:35:49,050 --> 00:35:53,060
當我們談論到程序中的命令行參數獲得通過，

713
00:35:53,060 --> 00:35:55,700
但在你的習題集和你的程序，

714
00:35:55,700 --> 00:35:58,760
這是完全正常，只是寫作廢，並保持它的簡單。

715
00:35:58,760 --> 00:36:01,490
無效的意思是，

716
00:36:01,490 --> 00:36:04,630
“嘿，主要是不會接受任何輸入;

717
00:36:04,630 --> 00:36:07,440
這僅僅是一個程序，我們會剛剛運行。

718
00:36:07,440 --> 00:36:09,320
我們不會給它任何額外信息。

719
00:36:09,320 --> 00:36:12,420
我們每次啟動運行。“

720
00:36:14,730 --> 00:36:16,600
所以現在，你可以做到這一點;

721
00:36:16,600 --> 00:36:19,710
你甚至也可以省略return 0

722
00:36:19,710 --> 00:36:22,650
您的程序結束時，他們會運行得很好，

723
00:36:22,650 --> 00:36:26,150
但我建議只是保持，在。

724
00:36:26,150 --> 00:36:28,320
在幾個星期中，我們將開始種

725
00:36:28,320 --> 00:36:31,340
拉回來蓋一點點，更多的了解

726
00:36:31,340 --> 00:36:34,380
所有這些不同的小運動部件。

727
00:36:34,380 --> 00:36:38,160
>> 好了，現在讓我們來談談我們在這裡的第二個問題。

728
00:36:38,160 --> 00:36:43,190
那麼什麼是“未聲明的標識符”，則通常表明

729
00:36:43,190 --> 00:36:46,040
如果輸出鐺？

730
00:36:46,040 --> 00:36:49,290
我想我們可能已經看到，今天已經。

731
00:36:51,170 --> 00:36:54,370
有人可以給一個回顧一下這是什麼意思呢？

732
00:36:54,370 --> 00:36:57,680
讓我們來看看，凱利 - 的凱麗之一。

733
00:37:02,580 --> 00:37:05,300
>>  - 

734
00:37:05,300 --> 00:37:07,080
是啊，這是什麼 - 

735
00:37:07,080 --> 00:37:10,140
>>我認為，當你一樣，不聲明變量，並嘗試使用它。

736
00:37:10,140 --> 00:37:13,310
是的，沒錯，沒錯。

737
00:37:13,310 --> 00:37:15,250
所以，如果你看到這樣的輸出

738
00:37:15,250 --> 00:37:17,690
當您嘗試編譯程序，

739
00:37:17,690 --> 00:37:19,470
就像凱利說，

740
00:37:19,470 --> 00:37:24,210
這意味著你使用一個變量，你沒有申報，

741
00:37:24,210 --> 00:37:28,460
所以，如果我回到我們的空間，

742
00:37:28,460 --> 00:37:31,150
我做這樣的事情

743
00:37:31,150 --> 00:37:34,800
輸出（

744
00:37:34,800 --> 00:37:38,260
“您好％s”）

745
00:37:40,070 --> 00:37:42,440
和嘗試，並填寫％s的

746
00:37:42,440 --> 00:37:45,640
，我沒有任何地方聲明一個變量s

747
00:37:45,640 --> 00:37:48,330
我嘗試運行它，

748
00:37:48,330 --> 00:37:51,330
你會看到我所得到的，在這個底部就在這裡：

749
00:37:51,330 --> 00:37:54,010
“使用未聲明的標識符”S“”;

750
00:37:54,010 --> 00:37:57,710
這只是意味著你不聲明你的變量。

751
00:37:57,710 --> 00:38:00,750
同樣的事情發生，如果

752
00:38:00,750 --> 00:38:05,240
你有X，你嘗試和存儲7

753
00:38:05,240 --> 00:38:08,720
和我沒有申報X.

754
00:38:08,720 --> 00:38:10,200
我得到了同樣的錯誤：

755
00:38:10,200 --> 00:38:13,480
“使用未聲明的標識符'X'”。

756
00:38:16,390 --> 00:38:18,250
>> 好吧，

757
00:38:18,250 --> 00:38:21,720
所以愷撒密碼，不是很安全，

758
00:38:21,720 --> 00:38:24,590
我將讓你們看這短短的，一種明白為什麼，

759
00:38:24,590 --> 00:38:27,590
後，希望做這個星期的問題集

760
00:38:27,590 --> 00:38:29,270
在那裡你寫的愷撒密碼，你就會明白一點點

761
00:38:29,270 --> 00:38:32,600
它的意思是什麼一個安全的和不安全 - 

762
00:38:36,180 --> 00:38:38,960
或不安全，我猜 - 不安全略有不同。

763
00:38:40,560 --> 00:38:43,140
另一件事是，我們這些其他的問題在這裡

764
00:38:43,140 --> 00:38:45,470
有關職能

765
00:38:45,470 --> 00:38:47,330
和功能是什麼，

766
00:38:47,330 --> 00:38:52,820
我們種，簡要談到，當我們談到的返回值;

767
00:38:52,820 --> 00:38:54,560
為有人的演講，

768
00:38:54,560 --> 00:38:57,790
你可以回顧一下誰是今天講課的嗎？

769
00:38:57,790 --> 00:38:59,670
好的。

770
00:39:01,210 --> 00:39:04,320
讓我們來看看，讓我們 - 有人可以告訴我們的功能是什麼？

771
00:39:04,320 --> 00:39:06,060
凱利？

772
00:39:07,800 --> 00:39:11,260
>> >>基本上是借鑒的東西，寫的庫

773
00:39:11,260 --> 00:39:14,460
更複雜的那邊，然後你只寫一個簡短的形式，

774
00:39:14,460 --> 00:39:17,360
那麼喜歡你是指該庫，使用

775
00:39:17,360 --> 00:39:19,650
所有的長碼和[聽不清]。

776
00:39:19,650 --> 00:39:22,680
是的，沒錯，然後你想添加的東西嗎？

777
00:39:22,680 --> 00:39:27,050
>>是的，我把它作為類似數學公式的概念

778
00:39:27,050 --> 00:39:30,130
你只寫一個公式，然後你可以插入變量

779
00:39:30,130 --> 00:39:32,660
這就是一個功能是聽不見的。

780
00:39:32,660 --> 00:39:35,390
>> 是啊，所以我們有一對夫婦的答案在這裡

781
00:39:35,390 --> 00:39:38,080
都非常好，右。

782
00:39:38,080 --> 00:39:43,040
有指使你的代碼庫中的某處被寫入

783
00:39:43,040 --> 00:39:45,390
是更複雜的

784
00:39:45,390 --> 00:39:47,130
然後你可以借鑒的代碼

785
00:39:47,130 --> 00:39:50,480
真正地使用它，只是寫的簡短形式 - 

786
00:39:50,480 --> 00:39:54,060
或者說，它的名字 - 

787
00:39:54,060 --> 00:39:57,590
再有就是數學中的公式比較

788
00:39:57,590 --> 00:40:00,400
或物理，所有這樣的東西;

789
00:40:00,400 --> 00:40:02,980
你有一個公式

790
00:40:02,980 --> 00:40:05,690
然後，您可以插入

791
00:40:05,690 --> 00:40:08,100
該公式的變量

792
00:40:08,100 --> 00:40:11,130
然後公式得到的結果，

793
00:40:11,130 --> 00:40:14,580
讓你覺得它像一元二次方程。

794
00:40:14,580 --> 00:40:17,690
試想一下，如果，而不是了解

795
00:40:17,690 --> 00:40:21,310
二次方程求根公式是什麼在數學課上，

796
00:40:21,310 --> 00:40:24,610
你只是有一個小的計算器程序，這樣做是為了你。

797
00:40:24,610 --> 00:40:28,930
有沒有人在高中數學課中使用的計算器程序？

798
00:40:28,930 --> 00:40:31,020
是啊，物理課嗎？

799
00:40:31,020 --> 00:40:34,670
在那裡你可以說，“嘿，二次公式。

800
00:40:34,670 --> 00:40:37,740
這些都是我要輸入的變量。

801
00:40:37,740 --> 00:40:40,250
現在給我答案。“

802
00:40:40,250 --> 00:40:42,170
這是一種功能是什麼。

803
00:40:42,170 --> 00:40:44,850
這是一個方式，讓我們

804
00:40:44,850 --> 00:40:47,720
種寫像一個小的小的子計劃

805
00:40:47,720 --> 00:40:51,700
在我們的程序

806
00:40:51,700 --> 00:40:55,090
並用它一遍又一遍

807
00:40:55,090 --> 00:40:58,380
所以，我們不必複製和粘貼代碼，

808
00:40:58,380 --> 00:41:04,220
我們可以給它不同的輸入和得到不同的輸出，

809
00:41:04,220 --> 00:41:07,090
這是超級方便

810
00:41:07,090 --> 00:41:11,420
當你試圖在不同的時間寫不同的程序。

811
00:41:11,420 --> 00:41:14,580
>> 因此，舉例來說，一個功能，我們已經使用了一遍又一遍，一遍又一遍

812
00:41:14,580 --> 00:41:17,310
整個過程是printf。

813
00:41:17,310 --> 00:41:19,680
printf是本身就是一個函數

814
00:41:19,680 --> 00:41:23,360
事實證明，它實際上是一個相當漫長而複雜的，

815
00:41:23,360 --> 00:41:26,420
討厭的，寫的功能。

816
00:41:26,420 --> 00:41:29,590
因此，簡單的，因為在我們看來，

817
00:41:29,590 --> 00:41:31,810
要打印的東西輸出到屏幕上，

818
00:41:31,810 --> 00:41:34,820
因為我們都只是做節今天開始，

819
00:41:34,820 --> 00:41:36,870
事實證明，它實際上是，你知道，

820
00:41:36,870 --> 00:41:39,900
一個很好的情侶幾百行代碼。

821
00:41:42,030 --> 00:41:45,620
這不是我真的願意寫，可以肯定，

822
00:41:45,620 --> 00:41:47,480
但我們每天都使用它，這是一種很酷的，

823
00:41:47,480 --> 00:41:49,020
所以我們把它分享給對方，

824
00:41:49,020 --> 00:41:51,790
不同的程序，

825
00:41:51,790 --> 00:41:54,520
所以我們就到功能更潛水;

826
00:41:54,520 --> 00:41:56,090
暫時，我們不 - 

827
00:41:56,090 --> 00:41:59,150
我們要編寫的唯一功能是主要的。

828
00:41:59,150 --> 00:42:01,570
主本身也是一個函數，

829
00:42:01,570 --> 00:42:04,270
你可以看到它有它的輸出，

830
00:42:04,270 --> 00:42:06,610
它的輸入就像我們談到，

831
00:42:06,610 --> 00:42:08,930
那麼它的名字，這是主要的。

832
00:42:08,930 --> 00:42:11,800
主要是怎麼樣的 - 那裡是一個特殊的功能。

833
00:42:11,800 --> 00:42:14,800
在你的C程序中，必須有一個主要功能，

834
00:42:14,800 --> 00:42:17,900
所以現在，我們已經遺漏的寫作

835
00:42:17,900 --> 00:42:21,400
的原型，或聲明的，主要的。

836
00:42:21,400 --> 00:42:23,050
我們已經給了你，

837
00:42:23,050 --> 00:42:25,650
我們剛剛有你填寫的空白種。

838
00:42:25,650 --> 00:42:29,120
>> >>因此，對於第二個問題集，我們並不需要

839
00:42:29,120 --> 00:42:31,350
把它寫在第二個功能嗎？

840
00:42:31,350 --> 00:42:34,200
我不這麼認為。

841
00:42:34,200 --> 00:42:37,600
我相信，這一切都在這裡。

842
00:42:37,600 --> 00:42:41,710
是啊，所以愷撒密碼，

843
00:42:41,710 --> 00:42:45,000
你沒有，它看起來並不像，

844
00:42:48,740 --> 00:42:53,150
維瓊內爾，你不要么，

845
00:42:53,150 --> 00:42:56,400
 - 事實證明，你沒有真正寫

846
00:42:56,400 --> 00:42:58,250
的功能，對不對？

847
00:42:58,250 --> 00:43:01,950
你打電話總是把所有的代碼在main，

848
00:43:01,950 --> 00:43:04,500
許多程序員做到這一點。

849
00:43:04,500 --> 00:43:07,130
隨著我們繼續前進，

850
00:43:07,130 --> 00:43:09,480
我們開始引入功能的一種方式

851
00:43:09,480 --> 00:43:11,530
清理你的代碼，

852
00:43:11,530 --> 00:43:13,380
，使其更加優雅，

853
00:43:13,380 --> 00:43:16,890
如果你有當我們談到循環任務 - 有點像，

854
00:43:16,890 --> 00:43:20,400
有時有一些事情你想做的事一而再，再而三，

855
00:43:20,400 --> 00:43:23,510
你有一種天真的方式 - 

856
00:43:23,510 --> 00:43:26,360
也就是我們常稱的“稻草人”的解決方案，

857
00:43:26,360 --> 00:43:29,390
只需複製並粘貼一遍又一遍 - 

858
00:43:29,390 --> 00:43:31,000
你可以做同樣的事情的功能，您只需複製並粘貼

859
00:43:31,000 --> 00:43:33,360
一遍又一遍相同的代碼，

860
00:43:33,360 --> 00:43:35,750
但漲大了你的代碼 - 

861
00:43:35,750 --> 00:43:38,550
最終使你的代碼很長的 - 

862
00:43:38,550 --> 00:43:41,550
它也變得有點混亂，

863
00:43:41,550 --> 00:43:43,470
那麼就意味著，你是不是能夠喜歡 - 

864
00:43:43,470 --> 00:43:45,250
如果你想再次使用該代碼在另一個程序中，

865
00:43:45,250 --> 00:43:48,610
你還堅持再次複製和粘貼，

866
00:43:48,610 --> 00:43:51,170
這樣的事情之一，我們來談談

867
00:43:51,170 --> 00:43:54,960
種你的程序的設計和風格，

868
00:43:54,960 --> 00:43:57,010
因此，當它是有道理的種

869
00:43:57,010 --> 00:43:59,800
包的東西，並把它作為一個單獨的函數，

870
00:43:59,800 --> 00:44:02,080
我們鼓勵你這樣做，

871
00:44:02,080 --> 00:44:04,700
那是，再次

872
00:44:04,700 --> 00:44:07,790
有沒有硬性規定。

873
00:44:07,790 --> 00:44:11,540
我們很少說，你必須寫一個函數調用此，

874
00:44:12,870 --> 00:44:16,320
但更重要的是，一個人的東西，你只是隨著時間的發展

875
00:44:16,320 --> 00:44:19,470
為你寫的節目越來越多。

876
00:44:21,940 --> 00:44:24,790
>> 還有什麼問題嗎？

877
00:44:26,340 --> 00:44:30,610
好吧，讓我們現在

878
00:44:30,610 --> 00:44:34,750
返回這個傢伙在這裡，

879
00:44:34,750 --> 00:44:37,800
所以，我仍然在這部分問題。

880
00:44:37,800 --> 00:44:39,900
我們已經討論了所有這些不同的，

881
00:44:39,900 --> 00:44:42,050
什麼是一個函數，為什麼寫功能，

882
00:44:42,050 --> 00:44:44,700
當你可以複製和粘貼？

883
00:44:44,700 --> 00:44:47,700
希望我們確信你寫功能是一件好事。

884
00:44:47,700 --> 00:44:50,870
所以，現在讓我們繼續這MySpace的計劃，

885
00:44:50,870 --> 00:44:53,080
我們會花一點點的時間這樣做。

886
00:44:54,600 --> 00:44:56,480
>> 所以，讓我們來看看，

887
00:44:56,480 --> 00:45:00,230
我有一個人讀這個嗎？

888
00:45:02,640 --> 00:45:04,660
讓我們Mikhaila  - 你閱讀這篇文章，我們呢？

889
00:45:07,660 --> 00:45:08,890
>>你的意思是回來時，MySpace的 - 

890
00:45:08,890 --> 00:45:10,920
回來時，MySpace是酷。

891
00:45:10,920 --> 00:45:12,070
“返回時，MySpace是涼爽，

892
00:45:12,070 --> 00:45:14,900
這是所有的憤怒，象這樣。

893
00:45:14,900 --> 00:45:17,320
也許它仍然是嗎？我真的不知道。

894
00:45:17,320 --> 00:45:19,990
在任何情況下，使用CS50電器，

895
00:45:19,990 --> 00:45:22,600
CS50運行，或CS50空間的的，

896
00:45:22,600 --> 00:45:25,370
寫一個程序，提示用戶的消息

897
00:45:25,370 --> 00:45:29,350
它的第一個字母大寫，然後輸出信息，

898
00:45:29,350 --> 00:45:31,800
在交替的情況下，與所有其他字母，

899
00:45:31,800 --> 00:45:34,010
如下面的示例輸出，

900
00:45:34,010 --> 00:45:37,060
其中粗體文字表示一些用戶的輸入。

901
00:45:37,060 --> 00:45:39,800
為簡單起見，你可以假設用戶

902
00:45:39,800 --> 00:45:42,810
只能輸入小寫字母和空格。

903
00:45:42,810 --> 00:45:45,900
考慮這個問題的一個練習的機會;

904
00:45:45,900 --> 00:45:48,640
你不會被要求提交這一計劃。“

905
00:45:48,640 --> 00:45:51,640
>> 真棒，謝謝你。

906
00:45:51,640 --> 00:45:54,750
因此，作為Mikhaila說，

907
00:45:54,750 --> 00:45:58,850
我們要編寫一個程序，MySpaces你的代碼。

908
00:45:58,850 --> 00:46:02,230
因此，沒有任何你們使用MySpace上嗎？

909
00:46:02,230 --> 00:46:04,100
你有任何MySpace帳戶？

910
00:46:04,100 --> 00:46:05,920
哦，是啊，是啊！

911
00:46:05,920 --> 00:46:08,300
這是很酷。

912
00:46:08,300 --> 00:46:09,950
[笑聲]

913
00:46:09,950 --> 00:46:12,060
我知道。

914
00:46:12,060 --> 00:46:14,500
約會自己。

915
00:46:15,490 --> 00:46:18,300
所以我們正在試圖做的是寫一個程序，

916
00:46:18,300 --> 00:46:21,110
經過

917
00:46:21,110 --> 00:46:24,490
的首字母大寫

918
00:46:24,490 --> 00:46:27,140
然後此後的每一個字母 - 

919
00:46:27,140 --> 00:46:29,350
其後或其他字母，對不起。

920
00:46:29,350 --> 00:46:32,910
>> 所以 - 你可以看到在這個例子中，

921
00:46:32,910 --> 00:46:35,260
這是怎麼了，我們運行程序，

922
00:46:35,260 --> 00:46:38,780
所以這只是說，“我們正在運行一個名為a.out的程序。

923
00:46:41,490 --> 00:46:44,630
我們要賦予它的輸入，

924
00:46:44,630 --> 00:46:47,090
將被提示。

925
00:46:47,090 --> 00:46:51,150
我們不是讓你去提供在命令行上輸入“。

926
00:46:51,150 --> 00:46:54,100
如果你一直遵循所有的演講

927
00:46:54,100 --> 00:46:56,710
和聽到的命令行參數，

928
00:46:57,810 --> 00:47:00,080
這是種者 - 那時髦的語法

929
00:47:00,080 --> 00:47:04,530
在主要的用int argc個，所有的東西，

930
00:47:04,530 --> 00:47:07,630
所以在這裡我們沒有使用;我們並沒有任何的處理。

931
00:47:09,400 --> 00:47:12,650
我們只是得到這類型的用戶，

932
00:47:12,650 --> 00:47:15,700
那麼這第二個行與時髦的資本

933
00:47:15,700 --> 00:47:18,550
是什麼，我們希望我們的程序輸出。

934
00:47:19,790 --> 00:47:22,860
>> 因此，而不是使用設備或運行中，我們將使用空間，

935
00:47:22,860 --> 00:47:25,360
因為我們有空間，

936
00:47:25,360 --> 00:47:28,640
因此，如果你們會

937
00:47:28,640 --> 00:47:32,380
讓你的代碼看起來像這樣，

938
00:47:32,380 --> 00:47:35,930
所以我要救這個修訂

939
00:47:35,930 --> 00:47:38,390
只是讓你在這裡得到了鍋爐板

940
00:47:38,390 --> 00:47:42,840
像這樣的，詮釋的主要（無效），什麼​​也沒有。

941
00:47:44,480 --> 00:47:48,460
其實，我們要做的是，我們只是刪除一切。

942
00:47:48,460 --> 00:47:50,330
我們希望有一個空白的石板，

943
00:47:50,330 --> 00:47:52,470
因為我們不會開始編寫代碼;

944
00:47:52,470 --> 00:47:55,380
相反，我們要去嘗試寫一些偽代碼

945
00:47:55,380 --> 00:47:58,580
這真的只是意味著我們將寫的東西，這不是代碼

946
00:47:58,580 --> 00:48:01,010
這樣的描述，我們想要做的是什麼，

947
00:48:01,010 --> 00:48:05,180
有點像大衛那樣在第一天的演講，

948
00:48:05,180 --> 00:48:08,310
我想是第二天的演講時，他做了整個襪子演示。

949
00:48:08,310 --> 00:48:10,990
你們還記得 - 看到襪子呢？

950
00:48:10,990 --> 00:48:13,300
約瑟夫是在那裡種輸入中英文嗎？

951
00:48:13,300 --> 00:48:16,300
所以，我們要做同樣的事情。

952
00:48:16,300 --> 00:48:18,380
>> 所以，當我開始寫偽代碼，

953
00:48:18,380 --> 00:48:22,640
我喜歡的輸入將是開始。

954
00:48:22,640 --> 00:48:24,950
我給自己一個樣品的情況下，

955
00:48:24,950 --> 00:48:28,780
所以像添加“謝謝！”

956
00:48:35,030 --> 00:48:38,010
然後我也寫的是什麼，我想要的輸出，

957
00:48:38,010 --> 00:48:42,210
在這種情況下是這樣的事情。

958
00:48:53,790 --> 00:48:56,050
給了我一個這樣的好事，比如，開始認為，

959
00:48:56,050 --> 00:48:59,730
“好吧，我想採取1號線

960
00:48:59,730 --> 00:49:03,560
我想將其改造成2行，“

961
00:49:03,560 --> 00:49:06,570
而這種幫助引導我的思想。

962
00:49:06,570 --> 00:49:09,990
這是一個良好的開端。

963
00:49:09,990 --> 00:49:12,190
另一種思考方式，也為我們還挺移動

964
00:49:12,190 --> 00:49:15,020
和你這樣做，是在自己的程序

965
00:49:15,020 --> 00:49:18,530
認為像邊緣的情況下，這是什麼樣的呢？

966
00:49:18,530 --> 00:49:20,740
是什麼樣的怪異的情景嗎？

967
00:49:20,740 --> 00:49:23,660
奇怪的投入，我們可能會得到什麼？

968
00:49:23,660 --> 00:49:26,550
這些產出應該是什麼樣子？

969
00:49:26,550 --> 00:49:29,670
例如，一個奇怪的輸入

970
00:49:29,670 --> 00:49:33,200
會是這一個，

971
00:49:33,200 --> 00:49:35,630
創建絕對沒問題，

972
00:49:35,630 --> 00:49:37,840
像我們在這種情況下，輸出嗎？

973
00:49:37,840 --> 00:49:40,530
我們想要的東西去思考，太。

974
00:49:40,530 --> 00:49:44,450
>> 因此，正如一個問題，

975
00:49:44,450 --> 00:49:46,870
我們可能要輸出什麼？

976
00:49:46,870 --> 00:49:50,740
如果我們沒有得到任何輸入，如果我們的程序輸出？

977
00:49:53,740 --> 00:49:54,860
“什麼也沒有。

978
00:49:54,860 --> 00:49:57,340
什麼都沒有？聽起來很不錯。

979
00:49:57,340 --> 00:49:59,280
因此，我們要確保我們不寫任何東西

980
00:49:59,280 --> 00:50:01,500
如果我們沒有得到任何東西英寸

981
00:50:01,500 --> 00:50:04,320
酷。好吧。

982
00:50:04,320 --> 00:50:07,370
所以

983
00:50:07,370 --> 00:50:09,380
我要叫上幾個人，我們去通過

984
00:50:09,380 --> 00:50:12,790
只是有點像一般的算法是什麼

985
00:50:12,790 --> 00:50:15,250
樣開始，我們會一起度過這次難關。

986
00:50:16,240 --> 00:50:19,710
>> 所以，讓我們來看看。大小姐。

987
00:50:19,710 --> 00:50:21,220
您如何看待我們就開始嗎？

988
00:50:21,220 --> 00:50:24,830
這將是一個好地方，從這裡開始

989
00:50:24,830 --> 00:50:27,900
如果我們要進行改造，比如，1號線

990
00:50:27,900 --> 00:50:29,440
到第2行嗎？

991
00:50:29,440 --> 00:50:32,650
你能種只是向我解釋，英語，你在想什麼？

992
00:50:32,650 --> 00:50:34,770
不要擔心代碼。

993
00:50:34,770 --> 00:50:38,250
>>我會做的第一件事情將是

994
00:50:38,250 --> 00:50:41,170
種直接用戶，告訴他們你想要什麼。

995
00:50:41,170 --> 00:50:44,730
好了，所以，比如說，

996
00:50:44,730 --> 00:50:47,450
“嘿，用戶，我想

997
00:50:47,450 --> 00:50:50,560
一個字符串“ - 真棒。

998
00:50:50,560 --> 00:50:52,990
因此，讓我們把這個寫下來。

999
00:50:52,990 --> 00:50:56,140
提示用戶輸入一個字符串。

1000
00:50:56,140 --> 00:50:59,270
這聽起來像一個良好的開端。

1001
00:51:03,920 --> 00:51:06,460
好的。

1002
00:51:06,460 --> 00:51:09,750
讓我們問凱利任。

1003
00:51:09,750 --> 00:51:11,580
什麼我們願意做的事嗎？

1004
00:51:11,580 --> 00:51:14,220
我們的未來是什麼樣的 - ？

1005
00:51:14,220 --> 00:51:18,080
>>收集他們的意見，並將其存儲為一個變量。

1006
00:51:18,080 --> 00:51:20,470
大。

1007
00:51:20,470 --> 00:51:24,280
因此，收集的字符串，

1008
00:51:25,450 --> 00:51:27,880
它存儲在變量中。

1009
00:51:34,840 --> 00:51:36,460
那麼，有沒有什麼特別的，我們要在這裡做嗎？

1010
00:51:36,460 --> 00:51:39,700
我們要檢查他們的意見

1011
00:51:39,700 --> 00:51:42,260
前 - ？

1012
00:51:42,260 --> 00:51:43,790
>>呀。

1013
00:51:43,790 --> 00:51:46,330
我們可能要檢查什麼？

1014
00:51:46,330 --> 00:51:48,980
>>嗯，你說我們沒有檢查它是否是一個數字，對嗎？

1015
00:51:48,980 --> 00:51:52,400
因為它會假設它是小寫嗎？

1016
00:51:52,400 --> 00:51:55,650
是啊。

1017
00:51:56,380 --> 00:51:58,920
>> 因此，原來， - 是啊。

1018
00:51:58,920 --> 00:52:01,850
因此，保證返回一個字符串的getString。

1019
00:52:01,850 --> 00:52:05,050
它不會返回一個數字或類似的東西。

1020
00:52:05,050 --> 00:52:09,140
有可能是數字字符在該字符串。

1021
00:52:09,140 --> 00:52:13,460
而這些，我們可以忽略，因為我們沒有資本化。

1022
00:52:13,460 --> 00:52:16,620
但一個空字符串是完全正常的，

1023
00:52:16,620 --> 00:52:19,900
這樣的情況下，於4日和5號線在這裡，

1024
00:52:19,900 --> 00:52:22,020
正確的，那裡沒有輸入，

1025
00:52:22,020 --> 00:52:25,190
我們已經把什麼作為輸出。

1026
00:52:25,190 --> 00:52:28,730
我們不必擔心肯定有什麼東西在字符串中

1027
00:52:28,730 --> 00:52:31,840
該字符串是至少4個字符長;

1028
00:52:31,840 --> 00:52:34,190
什麼是好的。

1029
00:52:34,190 --> 00:52:38,270
因此，這是對比，例如，像便士你寫的程序，

1030
00:52:38,270 --> 00:52:42,340
其中，以確保你得到非負數;

1031
00:52:42,340 --> 00:52:46,430
你必須確保你得到正確的天數在一個月內。

1032
00:52:46,430 --> 00:52:49,630
如何你們這樣做嗎？

1033
00:52:49,630 --> 00:52:51,470
你將如何做這個測試嗎？

1034
00:52:51,470 --> 00:52:54,090
那是什麼要求你使用嗎？

1035
00:52:54,090 --> 00:52:55,650
>> do-whil​​e循環。

1036
00:52:55,650 --> 00:53:00,840
do-whil​​e循環，其他類型的循環，太多，是的。

1037
00:53:02,190 --> 00:53:04,520
因此，原來，我們沒有在這種情況下，使用一個循環，

1038
00:53:04,520 --> 00:53:07,360
當我們提示的字符串，這是一種不錯的。

1039
00:53:08,280 --> 00:53:10,620
>> 好吧，繼續前進。

1040
00:53:12,410 --> 00:53:14,270
所以，斯特拉。

1041
00:53:14,270 --> 00:53:17,530
你能告訴我們什麼，我們下一步應該做的一點點嗎？

1042
00:53:17,530 --> 00:53:20,270
現在，我們已經得到的字符串，我們已經有了它存儲在一個變量;

1043
00:53:20,270 --> 00:53:23,360
的字符串，我們需要做的是什麼？

1044
00:53:26,790 --> 00:53:33,530
>>我們需要 - 

1045
00:53:33,530 --> 00:53:36,550
識別的2  - 

1046
00:53:36,550 --> 00:53:39,290
是啊，就用英語說，這是真棒。

1047
00:53:39,290 --> 00:53:42,670
>>確定[聽不清]首都 - 或大寫字母。

1048
00:53:44,420 --> 00:53:48,130
是啊，所以你識別哪些是大寫和小寫。

1049
00:53:50,020 --> 00:53:54,180
我們可以沒有他們，直到我們已經確定了哪些大寫或小寫。

1050
00:54:03,790 --> 00:54:06,350
因此，我們將在這裡。

1051
00:54:06,350 --> 00:54:10,210
>> 所以，只要一想到這個過程中，

1052
00:54:10,210 --> 00:54:13,200
我們怎麼做這個鑑定呢？

1053
00:54:13,200 --> 00:54:15,050
你知道嗎，丹？

1054
00:54:15,050 --> 00:54:18,120
種什麼，我們 - 我們不得不使用我們的工具箱裡什麼工具？

1055
00:54:18,120 --> 00:54:22,500
>>我把它在某種方式中像一個數組或每行

1056
00:54:22,500 --> 00:54:24,240
是它自己的小盒子，

1057
00:54:24,240 --> 00:54:27,240
然後大寫有或沒有。

1058
00:54:27,240 --> 00:54:30,440
好了，所以我們可以利用的一個工具，是一個數組。

1059
00:54:30,440 --> 00:54:33,760
我們有什麼看在字符串中的，

1060
00:54:33,760 --> 00:54:36,680
不過，要弄清楚 - 我們有看的字符。

1061
00:54:36,680 --> 00:54:40,890
“所以，你得看在字符串的長度？

1062
00:54:40,890 --> 00:54:43,880
是啊，所以得到的字符串的長度。

1063
00:54:50,450 --> 00:54:54,150
只是出於好奇，我們用它來得到一個字符串的長度？

1064
00:54:54,150 --> 00:54:58,080
>> strlen的？

1065
00:54:58,080 --> 00:55:02,870
是啊，strlen的，我們稱之為“strlen的”

1066
00:55:04,180 --> 00:55:08,620
所有這些字符串函數，所以strlen的是一個函數，

1067
00:55:08,620 --> 00:55:10,670
這是超級方便的，因為我們可以用它來只是說，

1068
00:55:10,670 --> 00:55:13,430
嘿，strlen的：這是一個字符串，你能告訴我它有多長。

1069
00:55:13,430 --> 00:55:17,350
在今天的演講中，大衛談了很多關於如何strlen的實施，

1070
00:55:17,350 --> 00:55:20,370
幕後到底發生了什麼。

1071
00:55:20,370 --> 00:55:25,450
但是這是一個非常超級方便的。

1072
00:55:25,450 --> 00:55:29,170
有也字符串中的庫的其他那些，

1073
00:55:29,170 --> 00:55:34,690
如STRCMP的拼寫是“STRCMP”，

1074
00:55:34,690 --> 00:55:38,010
這是用來相互比較字符串。

1075
00:55:41,220 --> 00:55:45,020
您將使用函數strstr一樣，

1076
00:55:45,020 --> 00:55:48,770
這是很好的發現子串等。

1077
00:55:48,770 --> 00:55:53,380
在大多數情況下，他們開始用str，然後去別的東西。

1078
00:55:53,380 --> 00:55:57,080
的原因，他們沒有實際拼寫，如字符串，等等

1079
00:55:57,080 --> 00:56:00,260
因為早在初期的C一樣，

1080
00:56:00,260 --> 00:56:04,100
當人們第一次寫操作，這一切，

1081
00:56:04,100 --> 00:56:07,580
他們，你可以使用的字符數限制

1082
00:56:07,580 --> 00:56:09,950
函數名和變量名，

1083
00:56:09,950 --> 00:56:12,620
所以，一切都像超濃縮。

1084
00:56:12,620 --> 00:56:15,750
但是，任何時候，你看到的東西，開始用str，

1085
00:56:15,750 --> 00:56:18,600
通常是指有做一個字符串。

1086
00:56:20,990 --> 00:56:23,350
>> 好了，你已經得到了字符串的長度，

1087
00:56:23,350 --> 00:56:27,110
然後，我們做的字符？

1088
00:56:27,110 --> 00:56:29,020
你知道嗎，薩姆？

1089
00:56:29,020 --> 00:56:32,410
>>我不知道，我正試圖弄明白。

1090
00:56:32,410 --> 00:56:35,410
我真的不知道 - 我希望有一些方法 - 

1091
00:56:35,410 --> 00:56:38,990
我的意思是，我想，也許我們可以做一些事情的賠率，均勻，

1092
00:56:38,990 --> 00:56:40,860
但我不知道任何這樣的功能。

1093
00:56:40,860 --> 00:56:42,240
是啊。

1094
00:56:43,160 --> 00:56:45,200
“但是，這 - 它不一定會工作，

1095
00:56:45,200 --> 00:56:48,690
因為那樣的話，你會得到的空間 - 

1096
00:56:48,690 --> 00:56:51,130
你就必須有足夠的空間，以獲得關於如何 - 

1097
00:56:51,130 --> 00:56:54,310
好吧。

1098
00:56:54,310 --> 00:56:56,490
我不知道 - 我在這一點上失去了。

1099
00:56:56,490 --> 00:56:58,120
是啊 - 不，不，不，這些都是很好的點。

1100
00:56:58,120 --> 00:57:00,420
所以，我們需要做的是，像薩姆說，

1101
00:57:00,420 --> 00:57:02,970
我們需要跟踪的字母是奇怪的字母，

1102
00:57:02,970 --> 00:57:05,540
的，哪些是偶數字母。

1103
00:57:06,650 --> 00:57:09,090
但是，我們要確保我們不只是尋找

1104
00:57:09,090 --> 00:57:12,110
在奇數場和偶數

1105
00:57:12,110 --> 00:57:14,030
指數在字符串中，

1106
00:57:14,030 --> 00:57:17,660
而是尋找在字符串中的奇數和偶數的字母，

1107
00:57:17,660 --> 00:57:20,190
因此，我們需要還挺有這之間的區別

1108
00:57:20,190 --> 00:57:25,190
字母 - 像實際上是A，B，C，D等，

1109
00:57:25,190 --> 00:57:29,090
什麼事都沒有字母，但仍然在我們的字符串。

1110
00:57:29,090 --> 00:57:32,390
例如，在這裡，像這樣的感嘆點是不信，

1111
00:57:32,390 --> 00:57:36,060
但它仍然是我們的字符串的一部分，它仍然是一個字符。

1112
00:57:36,060 --> 00:57:38,820
同樣，所有的這些空間 - 

1113
00:57:38,820 --> 00:57:41,710
不利用的空間，對不對？

1114
00:57:41,710 --> 00:57:46,160
因此，我們要確保我們莫名其妙地跳過這些

1115
00:57:46,160 --> 00:57:49,410
，同時還跟踪總入球數單。

1116
00:57:50,900 --> 00:57:54,990
>> 所以在我們的編程工具箱

1117
00:57:54,990 --> 00:57:57,270
到目前為止，如果你願意，

1118
00:57:57,270 --> 00:58:01,310
我們有許多不同的工具，我們已經談到了。

1119
00:58:01,310 --> 00:58:04,640
因此在一個，例如，是變量，

1120
00:58:04,640 --> 00:58:07,120
就像我們以前談到這裡。

1121
00:58:07,120 --> 00:58:10,730
另一種工具，我們所談論的是功能。

1122
00:58:10,730 --> 00:58:15,800
因此，我們已經討論過的變量，我們的偽代碼在這裡

1123
00:58:15,800 --> 00:58:19,760
正如我們將用它來存儲我們的字符串。

1124
00:58:19,760 --> 00:58:24,630
我們已經討論了函數來獲取一個字符串的長度，如strlen的。

1125
00:58:28,510 --> 00:58:31,170
我們一直在談論別的事情，我們已經談論了

1126
00:58:31,170 --> 00:58:34,850
進行了大量前面部分的今天：循環。

1127
00:58:39,390 --> 00:58:42,030
>> 你們覺得在這個程序中使用循環？

1128
00:58:42,030 --> 00:58:44,110
賈里德，你有什麼感想？

1129
00:58:47,150 --> 00:58:50,030
在這個程序中，我們使用一個循環？

1130
00:58:50,030 --> 00:58:52,500
“也許不，不，因為你沒有去多一次。

1131
00:58:52,500 --> 00:58:55,260
好了，你沒有通過什麼去多一次？

1132
00:58:55,260 --> 00:58:57,190
>>的整個字符串。

1133
00:58:57,190 --> 00:59:00,660
好，那你不有一次去的字符串全。

1134
00:59:00,660 --> 00:59:03,330
遺憾的是，絕對沒有任何意義！

1135
00:59:03,330 --> 00:59:06,360
你不必去通過整個字符串不止一次。

1136
00:59:06,360 --> 00:59:08,660
好吧。

1137
00:59:09,790 --> 00:59:11,920
你怎麼想？

1138
00:59:11,920 --> 00:59:14,110
>>我認為這是更好地使用它們

1139
00:59:14,110 --> 00:59:16,640
所以我們可以這樣做利用，而

1140
00:59:16,640 --> 00:59:19,750
它的位置是[聽不清]數。

1141
00:59:19,750 --> 00:59:22,940
太好了，所以利用什麼？

1142
00:59:22,940 --> 00:59:25,200
好了，所以我們說，

1143
00:59:25,200 --> 00:59:28,130
因為我們想，我們應該使用一個循環

1144
00:59:28,130 --> 00:59:32,550
大寫字母，雖然它不是一個數字。

1145
00:59:35,130 --> 00:59:37,140
 - 對不起，沒有您要添加嗎？

1146
00:59:37,140 --> 00:59:39,340
>>我要說的話，你的方式治療的字符串

1147
00:59:39,340 --> 00:59:42,290
[聽不清]將[聽不清]的字符？

1148
00:59:42,290 --> 00:59:43,710
是啊。

1149
00:59:43,710 --> 00:59:45,850
>>，然後我們可以指定號碼 - 

1150
00:59:45,850 --> 00:59:47,780
或基於位置的字符串中的字母？

1151
00:59:47,780 --> 00:59:49,720
是啊。

1152
00:59:49,720 --> 00:59:53,640
>>，並確定它是否是奇數或偶數和大寫字母本身

1153
00:59:53,640 --> 00:59:57,750
而信的位置是聽不見的 - 對不起。

1154
00:59:57,750 --> 01:00:00,150
大。

1155
01:00:00,150 --> 01:00:03,430
>> 因此，只要回顧一下。

1156
01:00:03,430 --> 01:00:05,840
你的名字，你能提醒我 - 我很抱歉。

1157
01:00:05,840 --> 01:00:06,900
“夏洛特。

1158
01:00:06,900 --> 01:00:08,490
夏洛特，沒問題。

1159
01:00:08,490 --> 01:00:11,130
那麼，什麼夏洛特說，

1160
01:00:11,130 --> 01:00:14,950
這是完全正確的 - 天哪，我喜歡汽車縮進 - 

1161
01:00:14,950 --> 01:00:17,770
是，如果我們檢查一個字符串

1162
01:00:17,770 --> 01:00:19,160
如這一個在頂部 - 

1163
01:00:19,160 --> 01:00:21,590
“謝謝你的”添加“ - 

1164
01:00:21,590 --> 01:00:24,790
為一個字符序列

1165
01:00:24,790 --> 01:00:29,010
在位置0，

1166
01:00:29,010 --> 01:00:32,260
h是在位置1。

1167
01:00:32,260 --> 01:00:36,880
一個是在2，然後我們得到了3，4，5;

1168
01:00:36,880 --> 01:00:40,830
的空間是在6位。

1169
01:00:42,380 --> 01:00:45,300
鑑於 -  f的位置是什麼？

1170
01:00:45,300 --> 01:00:47,610
7！

1171
01:00:47,610 --> 01:00:49,300
O？ 8。

1172
01:00:49,300 --> 01:00:52,070
R？ 9。

1173
01:00:52,070 --> 01:00:54,340
然後，我們得到了10，然後我真的不能沒有它的把它寫

1174
01:00:54,340 --> 01:00:57,430
有點讓凌亂的在屏幕上。

1175
01:00:57,430 --> 01:01:02,340
但是，這其實是我們可以談論如何在內存中的字符串。

1176
01:01:02,340 --> 01:01:04,660
它是一個字符串

1177
01:01:04,660 --> 01:01:07,920
是一個字符序列，

1178
01:01:07,920 --> 01:01:12,430
當我們提到一個單個的字符在字符串中，

1179
01:01:12,430 --> 01:01:15,280
我們經常這樣做參照該字符的位置

1180
01:01:15,280 --> 01:01:17,620
在字符串中，

1181
01:01:17,620 --> 01:01:19,910
可能以同樣的方式，當我們談論九月

1182
01:01:19,910 --> 01:01:22,870
的第九個月的一年

1183
01:01:22,870 --> 01:01:27,730
或星期一是一周的第一天。

1184
01:01:29,280 --> 01:01:33,070
因此，這為我們提供了一種方法，

1185
01:01:33,070 --> 01:01:37,030
找出哪些是奇與偶

1186
01:01:37,030 --> 01:01:39,540
因為你可以在這裡看到，

1187
01:01:39,540 --> 01:01:43,640
如果我們符合了這件T，

1188
01:01:46,310 --> 01:01:49,360
你可以看到，所有符合資本化條件的

1189
01:01:49,360 --> 01:01:53,040
在偶數位置，

1190
01:01:53,040 --> 01:01:55,880
至少在第一個字，

1191
01:01:55,880 --> 01:01:59,080
然後事情變得揭去後，我們打的空間，

1192
01:01:59,080 --> 01:02:02,460
因為我們不指望這個空間為一個字母，

1193
01:02:02,460 --> 01:02:05,150
所以，如果我們開始

1194
01:02:05,150 --> 01:02:08,930
去0，1，2，3，4，5，

1195
01:02:08,930 --> 01:02:12,600
空間，6，7，8，空間，

1196
01:02:12,600 --> 01:02:16,440
9，然後10，11，12，並依此類推。

1197
01:02:19,300 --> 01:02:22,910
>> 酷，所以我們肯定會想使用某種循環

1198
01:02:22,910 --> 01:02:27,760
去中的每個字符。

1199
01:02:31,330 --> 01:02:34,580
因此，在這一點上，

1200
01:02:36,490 --> 01:02:38,360
我們再回過頭來我們這裡的老偽代碼。

1201
01:02:40,970 --> 01:02:42,650
作為這個識別哪些

1202
01:02:42,650 --> 01:02:45,350
是大寫的，哪些是小寫，

1203
01:02:45,350 --> 01:02:48,340
我們將要做到這一點，在某種循環。

1204
01:02:51,080 --> 01:02:53,390
“循環”，冒號。

1205
01:02:55,070 --> 01:03:01,220
什麼樣的類型，我們的循環，循環，

1206
01:03:01,220 --> 01:03:03,670
似乎是一個很好的使用在這種情況下？

1207
01:03:03,670 --> 01:03:05,610
>>我想在for循環。

1208
01:03:05,610 --> 01:03:07,500
你為什麼要思考的for循環？

1209
01:03:07,500 --> 01:03:10,000
>>因為它從0開始，然後

1210
01:03:10,000 --> 01:03:13,000
當我們到達字符串的長度，

1211
01:03:13,000 --> 01:03:16,170
，然後每次迭代中，您可以[聽不清]嗎？

1212
01:03:16,170 --> 01:03:18,260
是的，沒錯。

1213
01:03:18,260 --> 01:03:21,490
因此，出於不同的選擇的循環，

1214
01:03:21,490 --> 01:03:25,350
我們有for循環，while循環，do-whil​​e循環。

1215
01:03:25,350 --> 01:03:28,550
一個for循環是特別有用的

1216
01:03:28,550 --> 01:03:32,120
當你想知道

1217
01:03:32,120 --> 01:03:34,940
你在循環中的一種，

1218
01:03:34,940 --> 01:03:38,520
循環已經執行了多少次為止。

1219
01:03:38,520 --> 01:03:42,490
這正是我們想知道在這種情況下，

1220
01:03:42,490 --> 01:03:44,640
像凱利說，

1221
01:03:44,640 --> 01:03:47,400
根據夏洛特的先前的評論，我們想知道的位置

1222
01:03:47,400 --> 01:03:49,900
在字符串中的字符，

1223
01:03:49,900 --> 01:03:51,750
和for循環會給我們帶來了這一點，

1224
01:03:51,750 --> 01:03:54,680
因為，如果我們回頭看我們的字符串開始種，

1225
01:03:54,680 --> 01:03:57,140
如果我們開始我們的for循環為0，

1226
01:03:57,140 --> 01:04:00,350
我們去到的整個字符串的長度，

1227
01:04:00,350 --> 01:04:04,740
然後，我們可以將字母T

1228
01:04:04,740 --> 01:04:08,110
0的循環，

1229
01:04:09,950 --> 01:04:13,080
字母H與1在我們的for循環，依此類推，

1230
01:04:13,080 --> 01:04:16,600
將所有的方式通過字符串的結尾。

1231
01:04:18,810 --> 01:04:21,890
>> 因此，讓我們開始編碼這只是一點點

1232
01:04:21,890 --> 01:04:24,930
只是讓你們得到的感覺，這看起來像。

1233
01:04:24,930 --> 01:04:27,980
我要救，

1234
01:04:27,980 --> 01:04:31,230
所以在這裡，我們已經得到了我們的偽代碼，

1235
01:04:33,490 --> 01:04:38,120
我要刪除一切。

1236
01:04:38,120 --> 01:04:42,210
所以，我有一個空白的石板。

1237
01:04:42,210 --> 01:04:45,910
我要開始寫詮釋的主要（無效）

1238
01:04:45,910 --> 01:04:48,440
{

1239
01:04:48,440 --> 01:04:51,380
我會把返回0

1240
01:04:51,380 --> 01:04:53,320
然後}。

1241
01:04:53,320 --> 01:04:56,130
因此，通常當我開始計劃，這是我的開始。

1242
01:04:56,130 --> 01:04:59,370
我會保存它，以便你們有它。

1243
01:05:06,290 --> 01:05:08,440
因此，我們談論的第一件事情之一是

1244
01:05:08,440 --> 01:05:10,920
得到來自用戶的輸入

1245
01:05:10,920 --> 01:05:13,740
並把它存儲在一個字符串中。

1246
01:05:13,740 --> 01:05:16,420
我們怎樣才能從用戶的輸入？

1247
01:05:16,420 --> 01:05:19,640
>> GetString的。

1248
01:05:19,640 --> 01:05:21,870
GetString時，所有的權利。

1249
01:05:23,150 --> 01:05:26,820
所以，如果我輸入的GetString（）

1250
01:05:26,820 --> 01:05:32,150
和分號。

1251
01:05:32,150 --> 01:05:36,630
讓我們嘗試運行來看，第一呢？

1252
01:05:36,630 --> 01:05:38,430
為什麼不運行？

1253
01:05:38,430 --> 01:05:40,090
>>您必須聲明變量。

1254
01:05:40,090 --> 01:05:43,040
我要聲明一個變量。好吧。

1255
01:05:43,040 --> 01:05:45,700
>> 那麼，如何才能做到這一點？

1256
01:05:45,700 --> 01:05:48,400
你不介意寫的東西，分享了嗎？

1257
01:05:48,400 --> 01:05:51,270
然後，我們可以把它拽上來。

1258
01:05:51,270 --> 01:05:54,630
讓我們來看看，但正確的，沒問題。

1259
01:05:54,630 --> 01:05:59,100
大牛。複製，字符串輸入的GetString（）。

1260
01:05:59,100 --> 01:06:01,340
真棒。

1261
01:06:01,340 --> 01:06:02,890
這會不會跑？

1262
01:06:02,890 --> 01:06:05,210
讓我們試試吧。

1263
01:06:05,210 --> 01:06:08,890
命中來看，上載源代碼，建築，發生了錯誤。

1264
01:06:08,890 --> 01:06:11,040
好吧。

1265
01:06:11,040 --> 01:06:14,950
因此，whats怎麼回事呢？

1266
01:06:14,950 --> 01:06:18,700
使用未聲明的標識符“字符串”。

1267
01:06:18,700 --> 01:06:22,840
>>我們有包括庫嗎？

1268
01:06:22,840 --> 01:06:25,130
是啊，所以丹說，我們有包括庫。

1269
01:06:25,130 --> 01:06:28,270
這是你會說，斯特拉？真棒。

1270
01:06:29,450 --> 01:06:31,430
這是可怕的，所以斯特拉，你能

1271
01:06:31,430 --> 01:06:34,800
複製此代碼的丹尼爾的空間？

1272
01:06:34,800 --> 01:06:37,580
如果您點擊上丹尼爾·羅蘭文，將其複製，

1273
01:06:37,580 --> 01:06:41,360
然後你把include行，然後保存它嗎？

1274
01:06:46,580 --> 01:06:49,360
讓我知道，當你準備好了。

1275
01:06:57,160 --> 01:06:59,490
因此，這包括語法也是一種時髦;

1276
01:06:59,490 --> 01:07:02,210
有這樣的散列標籤，

1277
01:07:02,210 --> 01:07:05,760
的，然後有這些尖括號。

1278
01:07:12,490 --> 01:07:15,360
你還記得是如何工作的，或者我應該把它放在這個代碼在這裡嗎？

1279
01:07:15,360 --> 01:07:17,850
>>我很好。

1280
01:07:17,850 --> 01:07:19,810
好吧。

1281
01:07:19,810 --> 01:07:23,260
>>我打印了 - 我不知道哪個庫，雖然。

1282
01:07:23,260 --> 01:07:25,570
哦，好吧 - 是的，所以它的的CS50庫。

1283
01:07:25,570 --> 01:07:27,660
哦，我把stdio庫。

1284
01:07:27,660 --> 01:07:30,950
>> 哦，找到了 - 啊，不，that's  - 

1285
01:07:30,950 --> 01:07:34,380
所以，字符串實際上是一些特別CS50。

1286
01:07:36,590 --> 01:07:41,240
其實是不是一個真正的字符串類型

1287
01:07:41,240 --> 01:07:45,000
因為在這裡，字符串類型的位置 - 

1288
01:07:45,000 --> 01:07:49,140
我們要聲明一個變量稱為輸入字符串類型的 - 

1289
01:07:49,140 --> 01:07:53,320
我們把裡面的輸入

1290
01:07:53,320 --> 01:07:58,440
得到的值返回給我們：這GetString函數調用的輸出。

1291
01:07:58,440 --> 01:08:02,910
可以說這是一個函數調用，因為它得到了括號，就像printf並

1292
01:08:02,910 --> 01:08:05,920
就像strlen的。

1293
01:08:05,920 --> 01:08:09,860
但是，字符串實際上是不是一個真正的類型

1294
01:08:09,860 --> 01:08:11,760
在C語言中。

1295
01:08:11,760 --> 01:08:15,710
我們已經取得了一個類型，我們會採取更多的它究竟是什麼

1296
01:08:15,710 --> 01:08:19,000
C，因為有一種方法使用字符串;

1297
01:08:19,000 --> 01:08:22,479
我們剛剛做的東西，使它看起來更好一點。

1298
01:08:22,479 --> 01:08:25,240
>> 所以，在這裡，我們走了。

1299
01:08:25,240 --> 01:08:28,439
下面是Stella的代碼。

1300
01:08:28,439 --> 01:08:32,470
它得到了包括<cs50.h>。

1301
01:08:32,470 --> 01:08:36,390
其他人會稱此如哈希有時，或尖銳包括。

1302
01:08:36,390 --> 01:08:39,580
現在，我們可以啟動它，運行它，

1303
01:08:39,580 --> 01:08:43,649
我們還得到一個錯誤。

1304
01:08:43,649 --> 01:08:46,290
讓我們來看看發生了什麼事。

1305
01:08:48,069 --> 01:08:50,569
“未使用的變量'輸入'。”

1306
01:08:50,569 --> 01:08:53,350
好了，所以這很酷，這很酷。

1307
01:08:53,350 --> 01:08:55,859
我的意思是，這不是真的很酷，

1308
01:08:55,859 --> 01:08:57,930
因為我們得到一個錯誤，它沒有運行，

1309
01:08:57,930 --> 01:09:00,410
但是這是說的是，

1310
01:09:00,410 --> 01:09:03,130
我們還沒有使用我們的變量，這是有道理的。

1311
01:09:03,130 --> 01:09:06,090
我們還沒有嘗試用它做什麼。

1312
01:09:07,819 --> 01:09:10,490
這是一種方式，

1313
01:09:10,490 --> 01:09:14,170
鐺正試圖幫助我們確保我們不只是使用變量

1314
01:09:14,170 --> 01:09:18,819
然後在不經意間調用他們別的事情後來在我們的代碼中，

1315
01:09:18,819 --> 01:09:21,649
幫助我們避免錯誤的方法。

1316
01:09:23,130 --> 01:09:28,810
>> 所有的權利，因此，我們已經得到了來自用戶的輸入，

1317
01:09:28,810 --> 01:09:31,910
我們把它存儲在變量中。

1318
01:09:31,910 --> 01:09:34,569
下一步是那麼

1319
01:09:34,569 --> 01:09:37,609
在所有的字符在字符串中開始尋找

1320
01:09:37,609 --> 01:09:41,830
並確定哪些是大寫

1321
01:09:41,830 --> 01:09:44,600
哪些是小寫的。

1322
01:09:44,600 --> 01:09:49,439
而像凱利和夏洛特長大了，

1323
01:09:49,439 --> 01:09:52,340
我們使用一個for循環。

1324
01:09:52,340 --> 01:09:55,520
因此，任何人都不會記得一個for循環的語法

1325
01:09:55,520 --> 01:09:58,670
並希望藉此刺在只寫

1326
01:09:58,670 --> 01:10:03,170
在fo​​r循環的第一行，只是位嗎？

1327
01:10:05,740 --> 01:10:07,330
凱利，你想給它一個嘗試？

1328
01:10:07,330 --> 01:10:10,300
呀，所以你必須先進行初始化，

1329
01:10:10,300 --> 01:10:13,170
所以我把我= 0，

1330
01:10:13,170 --> 01:10:15,390
然後我做了我<strlen（）函數。

1331
01:10:15,390 --> 01:10:18,570
它是在你的空間 - 我可以拉起來嗎？

1332
01:10:18,570 --> 01:10:21,330
是的，我搞砸了一點點，但是是的。

1333
01:10:21,330 --> 01:10:24,180
>> 好吧，讓我們把它。

1334
01:10:24,180 --> 01:10:26,490
真棒。

1335
01:10:26,490 --> 01:10:29,510
“但是我不知道，如果你有這樣的 - 

1336
01:10:29,510 --> 01:10:32,180
是啊，好吧。

1337
01:10:33,020 --> 01:10:36,030
所以這裡是凱利的：讓我們再看一下。

1338
01:10:36,030 --> 01:10:40,290
所以她的包括CS50庫的在頂部。

1339
01:10:40,290 --> 01:10:44,790
包括她的標準IO庫的頂部，

1340
01:10:45,550 --> 01:10:48,990
和標準的IO函數如printf，

1341
01:10:48,990 --> 01:10:51,690
因此，如果你想使用printf，你需要的線。

1342
01:10:53,060 --> 01:10:56,140
然後，她又包含字符串庫，

1343
01:10:56,140 --> 01:10:58,200
我們需要的，

1344
01:10:58,200 --> 01:11:01,010
因為字符串庫的strlen函數，

1345
01:11:01,010 --> 01:11:04,320
我們會在短短位。

1346
01:11:04,320 --> 01:11:07,560
因此，如果我們在這裡看凱利做了什麼，

1347
01:11:07,560 --> 01:11:10,260
你能走我們通過你做了什麼？

1348
01:11:10,260 --> 01:11:13,600
>>呀，所以 - 我的意思是，我有錯誤，所以 - 

1349
01:11:13,600 --> 01:11:15,380
啊，不，it's  - 

1350
01:11:15,380 --> 01:11:18,580
“所以，我想叫我只是”字符串“的字符串。

1351
01:11:18,580 --> 01:11:22,230
我想打印出字符串

1352
01:11:22,230 --> 01:11:25,640
然後我 - 

1353
01:11:27,450 --> 01:11:30,930
我想喜歡像一個數組中的每個字符的字符串

1354
01:11:30,930 --> 01:11:33,170
不同的[聽不見的，對不對？

1355
01:11:33,170 --> 01:11:38,080
然後我想在位置0開始

1356
01:11:38,080 --> 01:11:40,630
然後每2位，

1357
01:11:40,630 --> 01:11:42,580
我要利用，

1358
01:11:42,580 --> 01:11:45,680
所以我剛才所描述的為23，因為我一直在尋找的ASCII表。

1359
01:11:45,680 --> 01:11:48,730
所以，這就是我在想 - 我知道這是不對的。

1360
01:11:48,730 --> 01:11:50,920
>> 得到它，所以這是一個很好的開始。

1361
01:11:50,920 --> 01:11:54,120
我想了很多的框架是在這裡舉行。

1362
01:11:54,120 --> 01:11:57,500
讓我們通過逐行種，看看會發生什麼。

1363
01:11:57,500 --> 01:12:01,040
所以我喜歡的方式做到這一點，剛開始編譯代碼

1364
01:12:01,040 --> 01:12:04,300
並讓編譯器告訴我，像我的代碼有什麼錯，

1365
01:12:04,300 --> 01:12:07,450
因為編譯器會告訴你，什麼是錯的，你的代碼是非常好的。

1366
01:12:09,790 --> 01:12:12,780
因此，如果我們發揮，建築，它沒有建立。

1367
01:12:12,780 --> 01:12:14,860
它說有一個錯誤，

1368
01:12:14,860 --> 01:12:17,320
因此，如果我們向下滾動，並期待在第一個錯誤，

1369
01:12:17,320 --> 01:12:20,960
它說 - 

1370
01:12:20,960 --> 01:12:22,040
滾動到頂部，

1371
01:12:22,040 --> 01:12:26,070
我們可以看到有5個在底部產生的錯誤。

1372
01:12:26,070 --> 01:12:30,180
哎呀，這是真正切斷。

1373
01:12:31,810 --> 01:12:35,790
我猜這只是不會得到任何好轉。

1374
01:12:36,970 --> 01:12:38,500
>> 在這裡，我們走了。

1375
01:12:39,790 --> 01:12:42,530
因此，總有5所產生的錯誤。

1376
01:12:42,530 --> 01:12:45,140
在這裡，我只能看到第2，

1377
01:12:45,140 --> 01:12:49,100
這樣我就可以移動一點點，然後向上滾動種。

1378
01:12:49,100 --> 01:12:53,220
這是運行的命令來編譯代碼，

1379
01:12:53,220 --> 01:12:59,030
然後file.c的第一個錯誤是在這裡：

1380
01:12:59,030 --> 01:13:03,300
“預計識別或”（“”，是在這條線

1381
01:13:03,300 --> 01:13:06,680
在這裡我們說的字符串= getString（）方法。

1382
01:13:07,660 --> 01:13:12,920
在這裡你可以看到，它是在第8行file.c，

1383
01:13:12,920 --> 01:13:17,230
然後我相信這是12字符 - 這是錯誤的。

1384
01:13:17,230 --> 01:13:20,390
那麼，這是怎麼回事第8行 - 凱利錯誤嗎？

1385
01:13:20,390 --> 01:13:22,810
>>您只需要調用它一樣，一個字母或什麼的，

1386
01:13:22,810 --> 01:13:24,400
如字符串s或東西嗎？

1387
01:13:24,400 --> 01:13:28,250
是啊，所以事實證明，這些特殊類型的名稱，

1388
01:13:28,250 --> 01:13:31,770
這樣的字符串，整型，字符型，短，

1389
01:13:31,770 --> 01:13:35,740
他們都是特殊的關鍵字，

1390
01:13:35,740 --> 01:13:38,940
，你不能使用他們的姓名您的變量，

1391
01:13:38,940 --> 01:13:41,430
因為編譯器看，並說，

1392
01:13:41,430 --> 01:13:43,680
“哦，我知道這是一個類型，”

1393
01:13:43,680 --> 01:13:46,530
所以，你不能真正稱為字符串有一個字符串變量，

1394
01:13:46,530 --> 01:13:50,800
我想在這裡做的，這將無法工作。

1395
01:13:52,610 --> 01:13:58,250
但相反，我們可以把它像S或ST或str。

1396
01:13:58,250 --> 01:14:01,540
我們也沒辦法把它詮釋。

1397
01:14:01,540 --> 01:14:03,740
我們不能有一個字符串調用int。

1398
01:14:03,740 --> 01:14:06,740
我們不能有一個稱為字符的字符串，沒有這些工作。

1399
01:14:06,740 --> 01:14:09,420
>> 因此，我們將只需要調用它的暫時。

1400
01:14:10,630 --> 01:14:13,170
真棒。

1401
01:14:13,170 --> 01:14:17,500
那麼下一步是什麼在這條線是怎麼回事？

1402
01:14:21,390 --> 01:14:24,350
字符串 - 這條線看起來很不錯嗎？

1403
01:14:24,350 --> 01:14:27,830
讓我們給它一個嘗試，讓我們來運行它。

1404
01:14:27,830 --> 01:14:30,360
好了，我們仍然出現錯誤。

1405
01:14:30,360 --> 01:14:32,080
這一次，我們4個錯誤。

1406
01:14:32,080 --> 01:14:34,350
因此，我們得到其中之一。

1407
01:14:34,350 --> 01:14:36,130
讓我們繼續。

1408
01:14:36,130 --> 01:14:38,890
“意外的類型名稱的字符串：預期的表情，”是嗎？

1409
01:14:38,890 --> 01:14:41,780
“是的，那是因為我試圖命名的字符串。

1410
01:14:41,780 --> 01:14:44,270
是啊，所以它看起來像我們現在也有去修復

1411
01:14:44,270 --> 01:14:46,560
所有這些引用字符串。

1412
01:14:46,560 --> 01:14:50,070
你可以看到這裡有一個參考字符串，在這裡，在這裡，

1413
01:14:50,070 --> 01:14:53,440
因此，我們可以將所有這些為s。

1414
01:14:56,040 --> 01:15:00,930
大。好了，再次運行它。

1415
01:15:00,930 --> 01:15:03,260
大廈 - 另一個錯誤的發生。

1416
01:15:03,260 --> 01:15:06,900
>> 好了，現在我們已經到了一個錯誤，

1417
01:15:06,900 --> 01:15:11,090
所以int i = s，然後在方括號。

1418
01:15:11,090 --> 01:15:14,880
所以你能告訴我們一點關於你在這裡做什麼，凱利？

1419
01:15:14,880 --> 01:15:17,120
“是的。

1420
01:15:17,120 --> 01:15:19,410
這是第10行。

1421
01:15:19,410 --> 01:15:22,760
>>我不知道，如果我們需要它，

1422
01:15:22,760 --> 01:15:25,560
但我認為我是想 - 

1423
01:15:25,560 --> 01:15:27,580
所以你可以跟著我將它保存。

1424
01:15:27,580 --> 01:15:30,470
>>我想我是

1425
01:15:30,470 --> 01:15:33,150
想告訴它開始在位置0

1426
01:15:33,150 --> 01:15:35,030
在我的for循環的開始，

1427
01:15:35,030 --> 01:15:38,370
所以我覺得也許該說是不必要的。

1428
01:15:39,690 --> 01:15:41,350
因此，只要回顧一下，

1429
01:15:41,350 --> 01:15:44,850
你說，這 - 你試圖啟動該位置0

1430
01:15:44,850 --> 01:15:47,030
得到這個 - 是的，

1431
01:15:47,030 --> 01:15:50,460
過，所以我覺得所說，當你步行通過的代碼，

1432
01:15:50,460 --> 01:15:54,070
你在談論你想如何處理字符串作為一個數組

1433
01:15:54,070 --> 01:15:57,440
這樣我們就可以訪問每個字符單獨。

1434
01:15:57,440 --> 01:16:00,660
我覺得丹提到過，陣列，試圖將字符串轉換成數組。

1435
01:16:01,400 --> 01:16:03,300
>> 事實證明，這樣的引擎蓋下，

1436
01:16:03,300 --> 01:16:06,060
實際存儲為一個字符串數組了，

1437
01:16:06,060 --> 01:16:08,060
您可以訪問它像一個數組;

1438
01:16:08,060 --> 01:16:12,390
有沒有轉換，你必須做的。

1439
01:16:12,390 --> 01:16:15,770
一個字符串，isn't  - 所以 - 

1440
01:16:15,770 --> 01:16:18,200
一個字符串是不是一個真正的陣列，

1441
01:16:18,200 --> 01:16:21,940
但您可以訪問它是這樣的，因為所有的字符都存儲

1442
01:16:21,940 --> 01:16:25,160
一個正確的彼此相鄰的，在內存中，

1443
01:16:25,160 --> 01:16:28,310
所以，如果你想要得到的第一個字符的字符串，

1444
01:16:28,310 --> 01:16:31,910
為獲得一個整數數組的第一個整數是相同的。

1445
01:16:31,910 --> 01:16:35,010
所以我們經常 - 我們就會

1446
01:16:35,010 --> 01:16:36,360
參閱2類似

1447
01:16:36,360 --> 01:16:38,590
哦，作為一個字符串，數組，

1448
01:16:38,590 --> 01:16:40,830
即使它真的 - 他們非常不同的事情，

1449
01:16:40,830 --> 01:16:43,410
但你可以把他們大同小異。

1450
01:16:44,700 --> 01:16:47,400
因此，原來，這條線實際上是 - 

1451
01:16:47,400 --> 01:16:51,270
我們不需要做任何轉換，

1452
01:16:51,270 --> 01:16:53,500
而事實上，

1453
01:16:53,500 --> 01:16:56,790
這實際上是不是一個有效的表達，

1454
01:16:56,790 --> 01:16:59,040
這是我們的編譯器是在告訴我們什麼。

1455
01:16:59,040 --> 01:17:01,290
它說：“嘿，它預計的表達，

1456
01:17:01,290 --> 01:17:04,610
我來到這裡是這不是一個表達的東西。“

1457
01:17:04,610 --> 01:17:07,310
聲明一個數組，

1458
01:17:07,310 --> 01:17:11,780
所有你需要做的是用分號這樣的事情，

1459
01:17:11,780 --> 01:17:15,080
然後你告訴陣列多久，你希望它是，

1460
01:17:15,080 --> 01:17:18,370
如5，所以這一行10

1461
01:17:18,370 --> 01:17:23,880
聲明一個數組，叫我5個整數。

1462
01:17:23,880 --> 01:17:26,540
>> 這是一個的一邊，這是沒有必要的代碼，

1463
01:17:26,540 --> 01:17:30,970
但是，這是 - 這是一種什麼樣的聲明看起來像。

1464
01:17:30,970 --> 01:17:35,310
>>你會不會使用char我的strlen（）]？

1465
01:17:35,310 --> 01:17:38,500
CHAR I的strlen（）]？

1466
01:17:38,500 --> 01:17:41,500
>>字符i，然後括號內的，strlen的（）。

1467
01:17:43,900 --> 01:17:47,710
是啊，所以我們可以 - 

1468
01:17:47,710 --> 01:17:49,460
我們能做到這一點，

1469
01:17:49,460 --> 01:17:52,160
這將宣布 - 這樣做什麼？

1470
01:17:52,160 --> 01:17:55,900
>>我想聲明一個數組

1471
01:17:55,900 --> 01:18:01,780
的一樣 - 的 - 

1472
01:18:01,780 --> 01:18:04,540
哦，你不需要我 - 哦，

1473
01:18:04,540 --> 01:18:06,420
是啊，你絕對不需要我。

1474
01:18:06,420 --> 01:18:10,250
你聲明一個字符數組

1475
01:18:10,250 --> 01:18:13,150
長度為S。

1476
01:18:14,680 --> 01:18:16,770
所以山姆說的是，

1477
01:18:16,770 --> 01:18:20,660
10號線 - 讓我把一些空間，所以我們可以在它與其餘孤立 - 

1478
01:18:20,660 --> 01:18:23,440
這10行聲明一個數組

1479
01:18:23,440 --> 01:18:28,520
的字符，字符strlen（）價值，

1480
01:18:28,520 --> 01:18:32,270
但我們其實需要我，

1481
01:18:32,270 --> 01:18:35,710
和的原因，我們需要的，我是因為我們需要為陣列的名稱;

1482
01:18:35,710 --> 01:18:38,900
否則，我們就沒有辦法在後面的代碼請參考陣列。

1483
01:18:38,900 --> 01:18:41,180
>> 所以在這裡是數組名

1484
01:18:41,180 --> 01:18:43,420
和內部的長度。

1485
01:18:43,420 --> 01:18:45,010
這將為我們提供一個數組，

1486
01:18:45,010 --> 01:18:47,430
但是，這是 - 再次，這是一個聲明。

1487
01:18:47,430 --> 01:18:50,380
這不是一項任務，它不是初始化。

1488
01:18:50,380 --> 01:18:52,330
如果我們宣布這樣的數組，

1489
01:18:52,330 --> 01:18:54,490
其實也沒什麼的數組中的內容。

1490
01:18:54,490 --> 01:18:57,490
這只是垃圾 - 無論是在那裡。

1491
01:18:57,490 --> 01:18:59,780
像我們所說的，

1492
01:18:59,780 --> 01:19:01,340
我們其實並不需要做這種轉換，

1493
01:19:01,340 --> 01:19:04,810
因為我們已經可以把字符串s為一個數組。

1494
01:19:06,750 --> 01:19:09,170
我知道我們正在運行的時間有點長，

1495
01:19:09,170 --> 01:19:12,330
但我想真的很快得到這個for循環

1496
01:19:12,330 --> 01:19:14,850
並告訴你如何訪問數組中的單個字符，

1497
01:19:14,850 --> 01:19:17,170
因為這是我們的任務的關鍵。

1498
01:19:17,170 --> 01:19:20,790
然後，我們將讓你從那裡走。

1499
01:19:20,790 --> 01:19:24,610
>> 所以在這裡，我們已經有了一個for循環

1500
01:19:24,610 --> 01:19:28,310
看起來差不多好了。

1501
01:19:28,310 --> 01:19:30,960
什麼不太幾乎沒有呢？

1502
01:19:30,960 --> 01:19:33,240
What's  - 什麼是不完全正確的循環嗎？

1503
01:19:33,240 --> 01:19:36,010
>>不花括號？

1504
01:19:36,010 --> 01:19:38,420
沒有花括號，對於一個。

1505
01:19:38,420 --> 01:19:42,580
想確保我們身體的循環使用花括號。

1506
01:19:42,580 --> 01:19:45,240
哎呀，而不是方括號！

1507
01:19:45,240 --> 01:19:48,660
接下來的事情，我們需要做的，這個循環是什麼？

1508
01:19:48,660 --> 01:19:52,640
如果我嘗試運行它，

1509
01:19:52,640 --> 01:19:56,740
這個錯誤，我得到什麼？

1510
01:19:56,740 --> 01:20:00,990
我得到的所有這些錯誤 - 我必須初始化i。

1511
01:20:00,990 --> 01:20:03,610
大。

1512
01:20:03,610 --> 01:20:05,770
因此，這將是一個循環 - 這是沒有做到這一點，

1513
01:20:05,770 --> 01:20:08,680
但它真的很近。

1514
01:20:08,680 --> 01:20:11,260
我們現在可以運行此代碼，

1515
01:20:11,260 --> 01:20:14,620
建立，仍出現錯誤。

1516
01:20:17,960 --> 01:20:19,800
為什麼它仍然抱怨，

1517
01:20:19,800 --> 01:20:22,030
說表達的是未使用的，

1518
01:20:22,030 --> 01:20:24,600
這是因為該行不會做任何事情。

1519
01:20:24,600 --> 01:20:27,620
我們並沒有存儲在任何地方，我們並沒有將結果保存。

1520
01:20:27,620 --> 01:20:30,210
我們應該在哪裡保存這個結果呢？

1521
01:20:30,210 --> 01:20:32,920
>> S或我呢？

1522
01:20:32,920 --> 01:20:35,990
沒錯，這個時髦的語法，

1523
01:20:35,990 --> 01:20:38,550
這個S的方括號

1524
01:20:38,550 --> 01:20:41,500
裝置進入的s的第i個字符。

1525
01:20:41,500 --> 01:20:45,650
這將是東西是真正重要的是分配。

1526
01:20:45,650 --> 01:20:48,070
不幸的是，我們將不得不停止在這裡，

1527
01:20:48,070 --> 01:20:50,550
所以，塞巴斯蒂安部分可以進來，

1528
01:20:50,550 --> 01:20:53,980
但我很高興留後外，並會採取任何問題。

1529
01:20:53,980 --> 01:20:56,680
所以，謝謝你們的到來。

1530
01:20:56,680 --> 01:20:59,730
現在應該上載，建立，運行。

1531
01:21:01,570 --> 01:21:04,320
我們可以輸入一個字符串，如“你好”

1532
01:21:06,570 --> 01:21:08,730
打印“中Qox”的。

1533
01:21:08,730 --> 01:21:11,030
[笑聲]

1534
01:21:11,030 --> 01:21:14,640
>> 因此，不太有，但移動，獲得對這些循環！

1535
01:21:14,640 --> 01:21:18,640
謝謝你能來，我會在外面。