1
00:00:00,000 --> 00:00:02,742
>> [音樂播放]

2
00:00:02,742 --> 00:00:05,030

3
00:00:05,030 --> 00:00:09,090
>> ANDI彭：這是CS50，以及
歡迎第兩個星期

4
00:00:09,090 --> 00:00:11,740
這實際上是當週
我們的兩個分類 - 實際上，

5
00:00:11,740 --> 00:00:14,550
第一個星期，我們已經有一節。

6
00:00:14,550 --> 00:00:18,897
舉手，你們有多少人所有
來到超節最後一周？

7
00:00:18,897 --> 00:00:19,480
OK，沒關係。

8
00:00:19,480 --> 00:00:20,020
這是確定的。

9
00:00:20,020 --> 00:00:23,110
你們有多少人觀看
上週超一節？

10
00:00:23,110 --> 00:00:23,610
確定。

11
00:00:23,610 --> 00:00:25,702
而你們做精
在問題設置一個？

12
00:00:25,702 --> 00:00:28,660
所以我打算把它，我們有
一群很聰明的孩子

13
00:00:28,660 --> 00:00:32,310
在這個類的東西將被罰款。

14
00:00:32,310 --> 00:00:33,180
確定。

15
00:00:33,180 --> 00:00:33,980
所以first--

16
00:00:33,980 --> 00:00:37,900

17
00:00:37,900 --> 00:00:41,090
>> 首先，我們只是簡單地
去了今天的議程。

18
00:00:41,090 --> 00:00:42,700
我們將討論過程中的物流。

19
00:00:42,700 --> 00:00:45,480
很多人可能
有關於問題

20
00:00:45,480 --> 00:00:46,920
在這個過程中運行的東西怎麼樣。

21
00:00:46,920 --> 00:00:47,897
我們將回答這些問題。

22
00:00:47,897 --> 00:00:49,730
我們將簡要地
過去的情況下，循環

23
00:00:49,730 --> 00:00:51,410
任何你們錯過了超級部分。

24
00:00:51,410 --> 00:00:53,240
我們將談論ASCII映射。

25
00:00:53,240 --> 00:00:56,180
我們將談論陣列，
功能，命令行參數。

26
00:00:56,180 --> 00:01:00,210
最後，什麼你們大概都
真的想在這裡學習，

27
00:01:00,210 --> 00:01:01,270
是你的pset2。

28
00:01:01,270 --> 00:01:04,209
我們將有一些很好的技巧
和提示如何做到這一點。

29
00:01:04,209 --> 00:01:07,910

30
00:01:07,910 --> 00:01:08,690
>> 確定。

31
00:01:08,690 --> 00:01:11,450
此外，第二，我們有
大量的糖果在這裡。

32
00:01:11,450 --> 00:01:13,583
任何人誰喜歡糖果，
剛來到這兒。

33
00:01:13,583 --> 00:01:14,430
抓住一些。

34
00:01:14,430 --> 00:01:15,100
我有一大堆。

35
00:01:15,100 --> 00:01:16,390
我們有一噸在辦公室。

36
00:01:16,390 --> 00:01:18,230
我真的不希望
整天吃糖果。

37
00:01:18,230 --> 00:01:20,300
你們應該吃所有的糖果，
因為我把它在這裡為你們。

38
00:01:20,300 --> 00:01:20,990
剛吃糖果。

39
00:01:20,990 --> 00:01:24,080
未來將有糖果的每一個部分。

40
00:01:24,080 --> 00:01:25,330
>> 因此，首先，我是誰？

41
00:01:25,330 --> 00:01:27,080
我的名字叫安迪鵬。

42
00:01:27,080 --> 00:01:30,270
我CS50頭TA在耶魯。

43
00:01:30,270 --> 00:01:32,540
而且除了
這一點，我也將be--

44
00:01:32,540 --> 00:01:35,600
如果有人將like--跑步
哥們，你的肩膀上哭了起來。

45
00:01:35,600 --> 00:01:39,140
如果您PSET的，由於前一天晚上，
你不知道這是怎麼回事，

46
00:01:39,140 --> 00:01:40,080
打我。

47
00:01:40,080 --> 00:01:42,770
我們會同情在一起，等等。

48
00:01:42,770 --> 00:01:46,100
只知道我在這裡作為一個
資源為你的前線

49
00:01:46,100 --> 00:01:51,830
在幫助你們找出如何
解決CS50及以後的問題。

50
00:01:51,830 --> 00:01:54,590
>> 我的郵箱是andi.peng@yale.edu。

51
00:01:54,590 --> 00:01:58,390
我還將派出一個人
我在裡面的電話號碼發送電子郵件

52
00:01:58,390 --> 00:02:01,860
所以不是每個人都對
網上能看到我的電話號碼。

53
00:02:01,860 --> 00:02:03,640
隨時打電話給我在任何時候。

54
00:02:03,640 --> 00:02:07,510
說真的，我的電話是
通常連接到我的手。

55
00:02:07,510 --> 00:02:10,240
我可能不響應
在幾分鐘內。

56
00:02:10,240 --> 00:02:11,984
我可能不是一兩個小時內做出回應。

57
00:02:11,984 --> 00:02:14,400
但我可以向你保證，如果
你給我發電子郵件，如果你打電話給我，

58
00:02:14,400 --> 00:02:17,404
給我發短信，我會在24小時內做出回應。

59
00:02:17,404 --> 00:02:19,820
通常情況下，我才回應
即，因為我明白

60
00:02:19,820 --> 00:02:23,900
每個人都得到了一些問題，
你希望你的答案

61
00:02:23,900 --> 00:02:26,110
要很快回答。

62
00:02:26,110 --> 00:02:28,945
>> 但是，如果你打電話
我前30分鐘

63
00:02:28,945 --> 00:02:31,570
這一塊是由於週四
night--是這樣，安迪，幫我，

64
00:02:31,570 --> 00:02:35,380
我還沒有started--我可以給
你的肩膀哭泣。

65
00:02:35,380 --> 00:02:41,520
但是，它可能是時間去思考
如何下一次到不行。

66
00:02:41,520 --> 00:02:44,040
確定。

67
00:02:44,040 --> 00:02:44,944
哎呀。

68
00:02:44,944 --> 00:02:45,850
我怎麼回去？

69
00:02:45,850 --> 00:02:48,140
在那裡，我們走了。

70
00:02:48,140 --> 00:02:52,310
>> 所以在這個過程中，我們有一個
噸為大家的支持。

71
00:02:52,310 --> 00:02:54,640
除了剛
這裡的部分，這你

72
00:02:54,640 --> 00:02:57,000
每週弄花90
妙鐘和我在一起，

73
00:02:57,000 --> 00:02:58,330
我們也有辦公時間。

74
00:02:58,330 --> 00:03:01,021
怎麼你們許多已經
去過辦公時間尋求幫助？

75
00:03:01,021 --> 00:03:01,520
太好了。

76
00:03:01,520 --> 00:03:05,700
這的確是很好看，因為我們
有超過45的TA和CA的工作人員

77
00:03:05,700 --> 00:03:11,780
訓練這個課程，在這裡
幫助你與你的pset傢伙。

78
00:03:11,780 --> 00:03:14,580
>> 週一他們在青色舉行
課堂在17個山家在這裡

79
00:03:14,580 --> 00:03:15,350
在耶魯大學。

80
00:03:15,350 --> 00:03:17,349
週二和週四，
他們在下議院舉行。

81
00:03:17,349 --> 00:03:20,010
8:00至11:00幾乎每一個工作日。

82
00:03:20,010 --> 00:03:21,620
進來，進來了。

83
00:03:21,620 --> 00:03:24,030
如果有任何問題，沒有problem--
剛進來吧，

84
00:03:24,030 --> 00:03:26,650
然後我們會幫你出這一點。

85
00:03:26,650 --> 00:03:31,640
>> 其次，除了在辦公時間
而部分，我們也有短褲。

86
00:03:31,640 --> 00:03:35,930
有沒有人見過一對夫婦的
在視頻短褲或演練

87
00:03:35,930 --> 00:03:36,750
在網站上？

88
00:03:36,750 --> 00:03:37,250
確定。

89
00:03:37,250 --> 00:03:39,510
所以他們非常，非常有幫助。

90
00:03:39,510 --> 00:03:42,470
我們可愛的哈佛生產
團隊那邊那所學校

91
00:03:42,470 --> 00:03:47,910
北上，他們拍攝並製作
這些令人難以置信的演練視頻。

92
00:03:47,910 --> 00:03:52,290
>> 他們會帶你通過一步一步
如何去解決問題。

93
00:03:52,290 --> 00:03:56,340
通常情況下，如果你感到困惑
一個簡單的概念，一個單一的概念，

94
00:03:56,340 --> 00:03:59,780
來看看，因為我們可能有
某處在我們的網站上有一個短。

95
00:03:59,780 --> 00:04:03,800
它通常是一個很好的資源
看，當你第一次的

96
00:04:03,800 --> 00:04:06,510
失去了對如何處理的問題。

97
00:04:06,510 --> 00:04:09,750
>> 第三，我們也有
study50和reference50。

98
00:04:09,750 --> 00:04:15,650
因此，在研究50
網站僅僅是一個鏈接。

99
00:04:15,650 --> 00:04:21,500
這是，我認為，study.cs50.net
或者類似的東西。

100
00:04:21,500 --> 00:04:22,860
它只是谷歌。

101
00:04:22,860 --> 00:04:24,229
我們有很多準備的幻燈片。

102
00:04:24,229 --> 00:04:26,770
我們有很多的短褲和
walkthroughs--東西全部編譯

103
00:04:26,770 --> 00:04:31,070
非常漂亮和整潔為你們所有
瀏覽，看到任何概念

104
00:04:31,070 --> 00:04:32,860
你感到困惑。

105
00:04:32,860 --> 00:04:35,920
它很可能被覆蓋
那邊study50。

106
00:04:35,920 --> 00:04:37,640
>> Reference50--相似。

107
00:04:37,640 --> 00:04:41,510
我們有很多的各種注意事項
隨時可供您使用。

108
00:04:41,510 --> 00:04:44,450
最後，我們有什麼
所謂的CS50討論，

109
00:04:44,450 --> 00:04:48,082
其中一個論壇，如果前一天晚上
你做你的問題，比如，

110
00:04:48,082 --> 00:04:49,880
您有任何問題。

111
00:04:49,880 --> 00:04:52,340
登錄到CS50討論。

112
00:04:52,340 --> 00:04:53,190
發表您的問題。

113
00:04:53,190 --> 00:04:55,820
然後一個hundreds--的
也許，thousands--同行

114
00:04:55,820 --> 00:04:57,960
網上採取這一類將登錄。

115
00:04:57,960 --> 00:05:01,182
也許有人可以得到
一個TA可以在你的答案。

116
00:05:01,182 --> 00:05:03,390
它本質上只是一個
在線論壇，我們都可以

117
00:05:03,390 --> 00:05:04,556
用它來討論我們的問題。

118
00:05:04,556 --> 00:05:06,483
這很酷。

119
00:05:06,483 --> 00:05:10,660

120
00:05:10,660 --> 00:05:11,550
>> 確定。

121
00:05:11,550 --> 00:05:13,220
所以，問題的設置。

122
00:05:13,220 --> 00:05:17,840
我們有關的權利的
厚厚的習題集兩種。

123
00:05:17,840 --> 00:05:20,570
我們很多人已經
通過問題掙扎設置之一。

124
00:05:20,570 --> 00:05:24,460
我們已經知道，也許等待
在昨晚做你的PSET

125
00:05:24,460 --> 00:05:28,170
是不是做CS50最聰明的事。

126
00:05:28,170 --> 00:05:32,380
>> 技巧和基本的提示
成功讀出完整的型號規格。

127
00:05:32,380 --> 00:05:36,270
你們有多少人已經
讀取規格為PSET 2？

128
00:05:36,270 --> 00:05:36,770
確定。

129
00:05:36,770 --> 00:05:39,840
這是一個堅實的量。

130
00:05:39,840 --> 00:05:43,210
我知道你們可能已經認識到
現在的規格是很長的。

131
00:05:43,210 --> 00:05:45,700
他們是真的，真的很長。

132
00:05:45,700 --> 00:05:49,630
>> 這真的很難讀每一行
那認真一字一句。

133
00:05:49,630 --> 00:05:52,780
你想只是走馬觀花的地方
它告訴你做什麼。

134
00:05:52,780 --> 00:05:54,459
我可以向你保證，不這樣做。

135
00:05:54,459 --> 00:05:56,750
如果你這樣做，你可能
要錯過的地方

136
00:05:56,750 --> 00:05:58,458
它會告訴你
如何啟動的問題

137
00:05:58,458 --> 00:06:01,140
或者它會告訴你什麼名字
您的問題，或者它會告訴你，

138
00:06:01,140 --> 00:06:03,720
這可能是最好的辦法
開始做你的問題。

139
00:06:03,720 --> 00:06:05,050
然後你會被丟失。

140
00:06:05,050 --> 00:06:08,219
>> 當您嘗試讀取你的
SPEC一半，

141
00:06:08,219 --> 00:06:10,510
很多重要
information--在你不

142
00:06:10,510 --> 00:06:12,260
要能夠真正地訪問。

143
00:06:12,260 --> 00:06:13,219
因此，閱讀完整的型號規格。

144
00:06:13,219 --> 00:06:15,468
嘗試閱讀全規格
你來段之前，

145
00:06:15,468 --> 00:06:17,360
因為那時，當我們
說說處理器集，

146
00:06:17,360 --> 00:06:21,070
我們都可以有一個想法
對正在發生的事情。

147
00:06:21,070 --> 00:06:25,169
>> 其次，這是一個概念
我會喜歡引用

148
00:06:25,169 --> 00:06:26,710
很多整個課程學期。

149
00:06:26,710 --> 00:06:30,070
但本質上，迎接我們半途而廢，對不對？

150
00:06:30,070 --> 00:06:33,970
我，作為你的TA和賈森當然
經理和Scaz作為你的教授

151
00:06:33,970 --> 00:06:37,120
大衛為你的教授和所有的
其他可愛的助教在這個過程中，

152
00:06:37,120 --> 00:06:39,830
在此course--助手
我們將盡我們所能

153
00:06:39,830 --> 00:06:42,965
以確保您的設置
多達在這個過程中取得成功。

154
00:06:42,965 --> 00:06:43,840
我們將舉行部分。

155
00:06:43,840 --> 00:06:44,870
我們將舉行辦公時間。

156
00:06:44,870 --> 00:06:47,087
我們會回答你的電話
電話，回答你的電子郵件，

157
00:06:47,087 --> 00:06:49,670
盡我們所能，使
確保你的問題的回答。

158
00:06:49,670 --> 00:06:51,460
>> 但是，幫助我們了。

159
00:06:51,460 --> 00:06:52,450
與我們見面一半。

160
00:06:52,450 --> 00:06:56,040
如果你來到辦公時間
不必去節，不

161
00:06:56,040 --> 00:07:02,060
在看到講座，無
知道是怎麼回事，像，幫助我。

162
00:07:02,060 --> 00:07:04,350
我要像，很好，我很抱歉。

163
00:07:04,350 --> 00:07:06,410
這可能是一次借
那肩膀哭泣，

164
00:07:06,410 --> 00:07:08,959
因為我不知道
我能做些什麼來幫助你

165
00:07:08,959 --> 00:07:12,000
如果你不嘗試，至少幫助
自己在一開始一點點。

166
00:07:12,000 --> 00:07:12,910
與我們見面一半。

167
00:07:12,910 --> 00:07:15,020
你知道嗎，請進來
準備回答，並得到

168
00:07:15,020 --> 00:07:16,353
準備從事材料。

169
00:07:16,353 --> 00:07:19,342
這使事情變得這麼多
方便大家參與。

170
00:07:19,342 --> 00:07:22,970
是啊，這幾乎是它。

171
00:07:22,970 --> 00:07:23,720
>> 評級。

172
00:07:23,720 --> 00:07:29,250
因此，在教學大綱，這是很
深入的關於我們如何檔次。

173
00:07:29,250 --> 00:07:32,440
但實際上，故障
在這個成績的50％

174
00:07:32,440 --> 00:07:34,530
將pset時，這
是可愛的，因為這是

175
00:07:34,530 --> 00:07:37,400
在那裡你花了廣闊
大部分的課程時間。

176
00:07:37,400 --> 00:07:39,854
測驗40％，你的
項目最終將有10％。

177
00:07:39,854 --> 00:07:42,520
將有兩個測驗貫穿
本學期的課程。

178
00:07:42,520 --> 00:07:47,050
我認為，時間和日期
同時上市的教學大綱。

179
00:07:47,050 --> 00:07:49,210
>> 的方式，我們將
被分級您的pset

180
00:07:49,210 --> 00:07:53,930
就是我們有本質4
我們分配給每個等級的值。

181
00:07:53,930 --> 00:07:57,250
我們有一個範圍值，
正確性，設計和風格。

182
00:07:57,250 --> 00:08:01,530
所以你看，這是一種我們
計算公式的pset。

183
00:08:01,530 --> 00:08:03,640
三，我們給予最
重量的正確性，

184
00:08:03,640 --> 00:08:06,140
因為很明顯你的教練
應該測試的情況下，

185
00:08:06,140 --> 00:08:08,480
我們希望它來測試。

186
00:08:08,480 --> 00:08:11,000
>> 你們都有
check50在您的處置。

187
00:08:11,000 --> 00:08:13,730
這是一個非常有用的功能
，你們都可以

188
00:08:13,730 --> 00:08:17,560
你的代碼上傳到我們的服務器，
在這裡，我們將幫你了解一下。

189
00:08:17,560 --> 00:08:20,800
你見過那些
frowny臉，笑臉。

190
00:08:20,800 --> 00:08:22,119
他們是真的，真的很有幫助。

191
00:08:22,119 --> 00:08:23,910
請不要在
學生是喜歡嘗試

192
00:08:23,910 --> 00:08:26,230
硬編碼在所有的答案。

193
00:08:26,230 --> 00:08:30,050
我肯定看到了PSET哪裡
有人看到check50的所有值

194
00:08:30,050 --> 00:08:33,429
他們只是硬編碼in--如果
這個數字，打印出這個數字。

195
00:08:33,429 --> 00:08:35,080
如果這個數字，打印出號。

196
00:08:35,080 --> 00:08:36,090
不要那樣做。

197
00:08:36,090 --> 00:08:39,360
>> 儘管在技術上
check50是正確的，

198
00:08:39,360 --> 00:08:41,809
你的解決方式
問題是不正確的。

199
00:08:41,809 --> 00:08:45,770
因此，只要使用check50謹慎。

200
00:08:45,770 --> 00:08:48,497
但也確保您
了解它是如何運作的，

201
00:08:48,497 --> 00:08:50,580
程序是否正常
除了check50，

202
00:08:50,580 --> 00:08:53,120
由於我們無法測試每
check50可能的情況下。

203
00:08:53,120 --> 00:08:55,440
我們將測試他們中的一些。

204
00:08:55,440 --> 00:09:00,390
>> 設計本質上是怎麼
精心設計的是你的代碼？

205
00:09:00,390 --> 00:09:04,150
如果你是複製粘貼多個
行的代碼很多很多次。

206
00:09:04,150 --> 00:09:06,960
也許你還沒有經歷
在代碼中最好的設計。

207
00:09:06,960 --> 00:09:09,470
也許是時候添加這個循環。

208
00:09:09,470 --> 00:09:12,090
從本質上講，在這裡它只是所有
關於嘗試做你的代碼，

209
00:09:12,090 --> 00:09:17,010
試圖盡可能高效編寫代碼
盡可能讓你的程序運行

210
00:09:17,010 --> 00:09:19,630
盡可能快。

211
00:09:19,630 --> 00:09:20,996
>> 最後，我們有風情。

212
00:09:20,996 --> 00:09:24,360
因此，風格是怎樣的
隨心所欲，主觀的詞。

213
00:09:24,360 --> 00:09:27,470
我知道，我們正式擁有
風格50指南CS50，

214
00:09:27,470 --> 00:09:30,050
它會告訴你，哦，你，
應該有一個空間在這裡。

215
00:09:30,050 --> 00:09:32,220
你應該用什麼樣的格式
你的代碼這種方式。

216
00:09:32,220 --> 00:09:34,070
你應該事物命名這種方式。

217
00:09:34,070 --> 00:09:38,180
>> 我真的不關心，本身，怎麼
您選擇的風格你的代碼，

218
00:09:38,180 --> 00:09:39,840
就像只要你保持一致。

219
00:09:39,840 --> 00:09:43,732
例如，如果你喜歡
四位後留下的空間

220
00:09:43,732 --> 00:09:45,690
四位循環之前，
只是做每一次。

221
00:09:45,690 --> 00:09:46,523
那種不這樣做。

222
00:09:46,523 --> 00:09:47,730
不這樣做，其他時間。

223
00:09:47,730 --> 00:09:51,046
如果你想保持捲髮
括號空間一定的方式，

224
00:09:51,046 --> 00:09:52,170
只是一直這樣做的。

225
00:09:52,170 --> 00:09:54,628
那種不要做它的地方
這裡地方不存在。

226
00:09:54,628 --> 00:09:57,010
當我們分級，
真的很難

227
00:09:57,010 --> 00:09:59,420
如果我不知道如何
你格式化你的代碼，

228
00:09:59,420 --> 00:10:02,064
事情是古怪和不合時宜。

229
00:10:02,064 --> 00:10:04,980
如果你只是保持一致，這是
對我來說更容易為大

230
00:10:04,980 --> 00:10:06,310
要能看懂你的代碼。

231
00:10:06,310 --> 00:10:09,393
這是你作為一個學生更容易
要能看穿你的代碼

232
00:10:09,393 --> 00:10:11,720
看看有什麼錯
它削減為什麼有問題。

233
00:10:11,720 --> 00:10:15,740
風格是最簡單的事情之一
你們能做得到充分的分數。

234
00:10:15,740 --> 00:10:18,770
從本質上講，如果你只關心，如果
你付出五分鐘關注

235
00:10:18,770 --> 00:10:22,760
你的代碼每個星期，你應該
要獲得完整的造型加分。

236
00:10:22,760 --> 00:10:26,020
>> 最後，我們有什麼所謂
範圍乘數。

237
00:10:26,020 --> 00:10:28,890
Scope--我知道這是一個很大
字，尤其是在這個類。

238
00:10:28,890 --> 00:10:31,030
但是範圍，所有的手段
是你正在嘗試

239
00:10:31,030 --> 00:10:33,670
pset時盡你的能力。

240
00:10:33,670 --> 00:10:37,180
如果你把三出
你的四個問題

241
00:10:37,180 --> 00:10:39,460
甚至不嘗試
最後一個，你可能

242
00:10:39,460 --> 00:10:41,630
要輸的範圍幾點。

243
00:10:41,630 --> 00:10:44,560
>> 即使你剛開始的問題，
盡你所能地穿行了。

244
00:10:44,560 --> 00:10:47,691
即使不工作，把它在，
因為顯示和演示

245
00:10:47,691 --> 00:10:50,190
我們說你想，那
你嘗試的問題集

246
00:10:50,190 --> 00:10:51,430
盡你的能力。

247
00:10:51,430 --> 00:10:53,800
然後我們可以給你
全點的範圍。

248
00:10:53,800 --> 00:10:58,715
>> 適用範圍也是我們非常重要的
說說最低PSET得分下降。

249
00:10:58,715 --> 00:11:02,010
因此，在的過程
學期，你們有九pset中。

250
00:11:02,010 --> 00:11:05,340
我們實際上將下降
得分最低的掉那些九，

251
00:11:05,340 --> 00:11:07,670
但前提是你有充分的範圍點。

252
00:11:07,670 --> 00:11:11,120
>> 因此，如果你在一個不完整的PSET轉，
不幸的是，我們不能刪除的，

253
00:11:11,120 --> 00:11:13,540
因為你的範圍
點沒有完成。

254
00:11:13,540 --> 00:11:16,570
所以，即使你有可怕的一周
在這裡你死，你生病了

255
00:11:16,570 --> 00:11:20,040
或者你的狗死掉，你的貓死了，
而你超負荷作業，

256
00:11:20,040 --> 00:11:21,074
只是試圖處理器集。

257
00:11:21,074 --> 00:11:22,490
它做盡你的能力。

258
00:11:22,490 --> 00:11:23,840
如果它不工作，也沒關係。

259
00:11:23,840 --> 00:11:24,506
只要把它研究。

260
00:11:24,506 --> 00:11:26,590
至少我們可以給
你點的努力。

261
00:11:26,590 --> 00:11:28,510
>> 一種努力，在這個類。

262
00:11:28,510 --> 00:11:30,170
至少有最低分數下降的努力。

263
00:11:30,170 --> 00:11:32,354
所以呀。

264
00:11:32,354 --> 00:11:33,270
這幾乎是它。

265
00:11:33,270 --> 00:11:36,521
有沒有人有問題，所以
遠的我們在課堂上怎麼樣檔次？

266
00:11:36,521 --> 00:11:37,187
或任何這些？

267
00:11:37,187 --> 00:11:41,220
任何這些所以far--
段，辦公時間？

268
00:11:41,220 --> 00:11:41,720
酷。

269
00:11:41,720 --> 00:11:46,720

270
00:11:46,720 --> 00:11:47,800
確定。

271
00:11:47,800 --> 00:11:51,260
>> 因此，這是一個主題，沒有
人真的喜歡談論。

272
00:11:51,260 --> 00:11:53,084
我真的不喜歡談論它。

273
00:11:53,084 --> 00:11:55,250
你們真的不希望
聽到我談論它。

274
00:11:55,250 --> 00:11:57,690
但不幸的是，我們都
要談論它。

275
00:11:57,690 --> 00:12:00,110
大衛花了20分鐘
演講談論它。

276
00:12:00,110 --> 00:12:02,580
那就是主體
學術誠信。

277
00:12:02,580 --> 00:12:08,110
>> 所以，我們都在這裡可能已經寫
一篇文章的某個時候在我們耶魯上學。

278
00:12:08,110 --> 00:12:11,800
我們可能已經得到了談話，我們已經
被告知不要抄襲我們的作文，

279
00:12:11,800 --> 00:12:13,940
因為這項工作是不是我們的。

280
00:12:13,940 --> 00:12:18,109
在計算機科學中，我們有
同一種概念。

281
00:12:18,109 --> 00:12:20,150
您提交的所有工作，
你寫的所有代碼

282
00:12:20,150 --> 00:12:21,900
應該是你寫的代碼。

283
00:12:21,900 --> 00:12:24,280
不應該說你已經碼
從別的地方複製。

284
00:12:24,280 --> 00:12:26,777
不應該代碼
你一派，一屁股在

285
00:12:26,777 --> 00:12:28,360
你真的不知道，如果它的工作原理。

286
00:12:28,360 --> 00:12:32,440
有種你有感
它在做什麼，但不是真的。

287
00:12:32,440 --> 00:12:36,562
如有疑問，本質上，
它僅僅是合理的。

288
00:12:36,562 --> 00:12:38,520
在我們的教學大綱，我們有
事情的完整列表

289
00:12:38,520 --> 00:12:40,560
我們認為是合理的
對不合理的。

290
00:12:40,560 --> 00:12:43,820
>> 例如，合理
是你和你的朋友

291
00:12:43,820 --> 00:12:47,360
在討論什麼是最好的方式去
大約在邏輯上解決問題。

292
00:12:47,360 --> 00:12:48,910
這是相當合理的。

293
00:12:48,910 --> 00:12:53,244
什麼是不合理的，如果你
人聚在一起，鍵入相同的代碼，

294
00:12:53,244 --> 00:12:54,410
，並獲得了相同的代碼。

295
00:12:54,410 --> 00:12:56,302
這不是合理的。

296
00:12:56,302 --> 00:12:57,510
同樣的事情，那種短文。

297
00:12:57,510 --> 00:12:59,290
如果你想討論
與您的朋友，哎，

298
00:12:59,290 --> 00:13:00,220
這就是我想寫。

299
00:13:00,220 --> 00:13:02,500
這些是我想要的步驟
需要寫下來，太棒了。

300
00:13:02,500 --> 00:13:03,208
那太好了。

301
00:13:03,208 --> 00:13:04,790
請互相協作。

302
00:13:04,790 --> 00:13:06,540
如果你們開始
寫同樣的事情，

303
00:13:06,540 --> 00:13:10,020
把在同一篇文章，那是不太確定。

304
00:13:10,020 --> 00:13:13,200
因此，有疑問的時候，就不要去做。

305
00:13:13,200 --> 00:13:16,940
>> 在這裡，我們在CS50，我們有腳本
該運行自動化測試

306
00:13:16,940 --> 00:13:21,740
不僅是你的代碼的正確性，
而且你的代碼的唯一性。

307
00:13:21,740 --> 00:13:25,920
所以，請不要把我們的位置
具有參考您的案件EXCOMM。

308
00:13:25,920 --> 00:13:31,110
請只是為了大家，我們只
使這是一個奇妙的經歷。

309
00:13:31,110 --> 00:13:33,600
每個人都學會更好，
大家都快樂，

310
00:13:33,600 --> 00:13:37,926
我們都設置為
在這個過程中取得成功。

311
00:13:37,926 --> 00:13:39,800
東西是很
獨特的關於這個類

312
00:13:39,800 --> 00:13:42,660
我認為每個人都應該真
要注意的是，我們有

313
00:13:42,660 --> 00:13:44,930
什麼叫做後悔
在我們的教學大綱條款。

314
00:13:44,930 --> 00:13:50,010
所以基本上，在72小時內，如果
你相信你已經做了一些

315
00:13:50,010 --> 00:13:53,240
你真的不知道是
相應的，請來找我們。

316
00:13:53,240 --> 00:13:57,220
我們向你們保證，72小時內
我們將處理的情況下自己

317
00:13:57,220 --> 00:13:59,820
不參照更高
當局在管理。

318
00:13:59,820 --> 00:14:03,100
>> 所以，如果你來找我，說：
岸堤，哎，我真的很抱歉，

319
00:14:03,100 --> 00:14:07,620
但我認為有一對夫婦線在我的
代碼昨晚那種我GOOGLE了，

320
00:14:07,620 --> 00:14:10,120
下車棧
溢出，複製和粘貼，

321
00:14:10,120 --> 00:14:13,680
而我真的，真的很抱歉
這件事，讓我知道。

322
00:14:13,680 --> 00:14:16,900
請不要讓它潰爛
而只是希望我抓住它。

323
00:14:16,900 --> 00:14:17,784
我們將抓住它。

324
00:14:17,784 --> 00:14:18,450
只是到我這裡來。

325
00:14:18,450 --> 00:14:20,520
讓我知道，在72小時內。

326
00:14:20,520 --> 00:14:22,240
我們會找出一個解決方案。

327
00:14:22,240 --> 00:14:26,679
我們承諾，我們將不參考
大學當局本質。

328
00:14:26,679 --> 00:14:29,220
所以這是在你最感興趣
只是說實話大家一起

329
00:14:29,220 --> 00:14:31,720
涉及的過程。

330
00:14:31,720 --> 00:14:34,630
>> 確定。

331
00:14:34,630 --> 00:14:35,240
確定。

332
00:14:35,240 --> 00:14:37,800
所以，現在，快速前
我繼續前進，沒有任何人

333
00:14:37,800 --> 00:14:42,670
有關於物流問題
如何課程，我們要去跑，

334
00:14:42,670 --> 00:14:45,982
如何節會
運行，所有的是什麼？

335
00:14:45,982 --> 00:14:46,711
確定。

336
00:14:46,711 --> 00:14:47,210
是啊。

337
00:14:47,210 --> 00:14:48,126
>> 聽眾：[聽不清]？

338
00:14:48,126 --> 00:14:50,414

339
00:14:50,414 --> 00:14:51,080
ANDI彭：是的。

340
00:14:51,080 --> 00:14:54,850
那麼quizzes--你們有多少人是
在週一/週三部分？

341
00:14:54,850 --> 00:14:56,700
有多少人都在
週二/週四？

342
00:14:56,700 --> 00:14:58,550
好了，就在這裡了堅實的分裂。

343
00:14:58,550 --> 00:15:00,900
讓我們運行方式
它在耶魯是我們

344
00:15:00,900 --> 00:15:04,040
將有兩個獨立的
quizzes--一個用於每個section--那

345
00:15:04,040 --> 00:15:06,160
上課時將採取。

346
00:15:06,160 --> 00:15:09,310
我認為這是十月十月底，
這樣的事情，一個星期

347
00:15:09,310 --> 00:15:10,794
的測驗。

348
00:15:10,794 --> 00:15:11,960
是啊，所以才來上課。

349
00:15:11,960 --> 00:15:13,920
在週一或週三，
你會參加測驗。

350
00:15:13,920 --> 00:15:16,336
在那個星期二或星期四
你會採取不同的測驗。

351
00:15:16,336 --> 00:15:18,570
但是，同樣的材料將被覆蓋。

352
00:15:18,570 --> 00:15:19,160
是啊。

353
00:15:19,160 --> 00:15:20,660
好問題。

354
00:15:20,660 --> 00:15:21,160
是啊。

355
00:15:21,160 --> 00:15:23,260
>> 聽眾：我們在哪裡
去檢查我們的成績？

356
00:15:23,260 --> 00:15:23,926
>> ANDI彭：是的。

357
00:15:23,926 --> 00:15:28,420
因此，我將派出一個
電子郵件無論每個星期

358
00:15:28,420 --> 00:15:31,460
當測驗是graded--或者，
對不起，當pset中分級。

359
00:15:31,460 --> 00:15:34,120
Pset中通常轉向
在中午或週五。

360
00:15:34,120 --> 00:15:37,540
所以，我承諾，我會
試圖讓他們回到你身邊

361
00:15:37,540 --> 00:15:40,000
由上週五的中午。

362
00:15:40,000 --> 00:15:44,950
>> 每當我一年級pset的，我會送
出上檔次書的通知

363
00:15:44,950 --> 00:15:47,070
告訴你你的分數
可在線觀看。

364
00:15:47,070 --> 00:15:52,022
所以，正確的這一周，之後我
完成分級上週的pset時，

365
00:15:52,022 --> 00:15:54,230
你們會得到一封電子郵件
通知告訴你，

366
00:15:54,230 --> 00:15:55,870
嘿，這是你
去查看你的成績。

367
00:15:55,870 --> 00:15:57,680
你可以看到每一個
你的成績擊穿。

368
00:15:57,680 --> 00:15:58,555
你可以看到評論。

369
00:15:58,555 --> 00:16:00,360
噢，快的事也。

370
00:16:00,360 --> 00:16:03,060
在偉大的註釋部分
本書是我可能會

371
00:16:03,060 --> 00:16:05,300
花我的大部分時間分級。

372
00:16:05,300 --> 00:16:07,094
所以一件事是
真正重要的當

373
00:16:07,094 --> 00:16:09,010
你們正在查看
你的成績在你的pset

374
00:16:09,010 --> 00:16:11,400
不僅找
在物理得分

375
00:16:11,400 --> 00:16:14,630
而且服用時間
真正讀懂我的意見。

376
00:16:14,630 --> 00:16:17,820
>> 通常情況下，給你的反饋
關於你如何解決問題。

377
00:16:17,820 --> 00:16:20,480
如果你需要做的
東西好一點，

378
00:16:20,480 --> 00:16:24,080
建設性的批評通常是
在這些意見節最好的說明。

379
00:16:24,080 --> 00:16:26,950
所以，請，請，我要去
花時間寫評論。

380
00:16:26,950 --> 00:16:30,440
請，我真的很感激它
如果你們會讀這些意見。

381
00:16:30,440 --> 00:16:31,170
確定。

382
00:16:31,170 --> 00:16:34,150
酷。

383
00:16:34,150 --> 00:16:34,680
>> 好的。

384
00:16:34,680 --> 00:16:40,680
因此，我們將開始討論
和公正的審查快速

385
00:16:40,680 --> 00:16:45,040
一些從該材料的
零只所以我們一周

386
00:16:45,040 --> 00:16:48,760
正確的頁面上
開始這個星期的問題。

387
00:16:48,760 --> 00:16:52,600
因此，while循環是
三種類型的循環的

388
00:16:52,600 --> 00:16:54,510
前面我們在這個課堂上討論。

389
00:16:54,510 --> 00:16:57,060
>> while循環本質
被寫在語法

390
00:16:57,060 --> 00:17:00,666
其中，而在一定條件下，
這樣做反复，對不對？

391
00:17:00,666 --> 00:17:02,040
想想它在這個圖形在這裡。

392
00:17:02,040 --> 00:17:04,780
你會開始在
某一點在你的代碼。

393
00:17:04,780 --> 00:17:09,030
你要進入循環條件
if--我不知道 -  x小於1。

394
00:17:09,030 --> 00:17:11,677
>> 如果是真的，你要
執行循環體。

395
00:17:11,677 --> 00:17:14,010
而你要繼續做
一遍，再次再次

396
00:17:14,010 --> 00:17:17,900
過去，over--這就是為什麼它是一個
loop--直到你的條件變為

397
00:17:17,900 --> 00:17:19,079
假的。

398
00:17:19,079 --> 00:17:22,140
因此以這種方式，一個循環的同時
是比較簡單的方法之一

399
00:17:22,140 --> 00:17:25,619
寫任何形式的條件
需要重複一遍又一遍又一遍。

400
00:17:25,619 --> 00:17:28,109
只是要小心，每當
你寫的任何種類的循環

401
00:17:28,109 --> 00:17:32,140
你有一個退出條件為
還有一個更新不管它

402
00:17:32,140 --> 00:17:36,714
為使您的循環不只是
遍地跑無限。

403
00:17:36,714 --> 00:17:38,630
在任何情況下，你會
想要確保

404
00:17:38,630 --> 00:17:42,670
您正在改變的某些方面
代碼或在循環結束

405
00:17:42,670 --> 00:17:46,680
只是為了確保你有辦法
邁向的條件

406
00:17:46,680 --> 00:17:48,400
要見面結束。

407
00:17:48,400 --> 00:17:50,239
這是否有意義給大家？

408
00:17:50,239 --> 00:17:52,530
我們只是不希望
陷入這種螺旋式的地方

409
00:17:52,530 --> 00:17:55,710
我們走了一圈又一圈，並
有沒有辦法來打破循環。

410
00:17:55,710 --> 00:17:58,844
而且每次循環本質
具有這樣做的一種方式。

411
00:17:58,844 --> 00:17:59,344
確定。

412
00:17:59,344 --> 00:18:03,030

413
00:18:03,030 --> 00:18:06,060
>> 其次，你們中許多人
在馬里奧的pset

414
00:18:06,060 --> 00:18:08,910
可能不得不使用
這種類型的循環。

415
00:18:08,910 --> 00:18:11,802
它被稱為do while循環。

416
00:18:11,802 --> 00:18:14,510
首先，誰能告訴我
什麼做的區別

417
00:18:14,510 --> 00:18:16,586
while循環和while循環？

418
00:18:16,586 --> 00:18:17,086
是啊。

419
00:18:17,086 --> 00:18:21,030
>> 聽眾：while循環的做
運行在第一個[聽不清]。

420
00:18:21,030 --> 00:18:22,120
>> ANDI彭：是的，沒錯。

421
00:18:22,120 --> 00:18:27,130
因此，一個do while循環總是做什麼
是做在裡面，括號內

422
00:18:27,130 --> 00:18:30,520
那裡確實是條件
檢查the--對不起之前，

423
00:18:30,520 --> 00:18:32,940
這是否代碼之前
檢查的條件。

424
00:18:32,940 --> 00:18:37,200
這是特別相關我們
在這裡這個類，因為大多數時候

425
00:18:37,200 --> 00:18:41,450
我們將要提示
用戶對某種類型的輸入。

426
00:18:41,450 --> 00:18:43,520
然後，視
輸入他們給我們，

427
00:18:43,520 --> 00:18:46,150
那麼我們可以計算，呵呵，
我們需要再次提示呢？

428
00:18:46,150 --> 00:18:49,930
>> 因此，在馬里奧，如果用戶給你
一負高度，例如，

429
00:18:49,930 --> 00:18:52,990
你要第一個提示
做任何在裡面。

430
00:18:52,990 --> 00:18:54,820
然後，你要檢查的同時。

431
00:18:54,820 --> 00:18:57,570
要知道，為負1，
是一個正數？

432
00:18:57,570 --> 00:19:00,680
如果不是的話，我會去
背部和重複做，重複

433
00:19:00,680 --> 00:19:03,950
重複，重複，直到他們
最後給你一個數字，你喜歡，

434
00:19:03,950 --> 00:19:07,002
我們都可以運用在我們的代碼。

435
00:19:07,002 --> 00:19:09,210
這對於非常重要的
基本上任何用戶輸入。

436
00:19:09,210 --> 00:19:11,760
我可以在任何保證你
一次在PSET哪裡

437
00:19:11,760 --> 00:19:15,070
我們要求您輸入
任何類型的代碼，我們

438
00:19:15,070 --> 00:19:17,540
可能要給你
測試案例中，我們

439
00:19:17,540 --> 00:19:21,200
想給你的東西不好那
要嘗試打破你的代碼。

440
00:19:21,200 --> 00:19:25,044
>> 如果我們試圖要求你輸入一個
整數，我們可能只給你一個字符串

441
00:19:25,044 --> 00:19:26,460
看看你會如何處理。

442
00:19:26,460 --> 00:19:30,610
如果我們要求您使用的時代，
我們可以給你一個負數

443
00:19:30,610 --> 00:19:32,340
就看你會如何處理。

444
00:19:32,340 --> 00:19:37,260
只要確保你們正在測試
案件中，你沒有得到最好的

445
00:19:37,260 --> 00:19:38,590
輸入，讓我們只說。

446
00:19:38,590 --> 00:19:40,510
而一個do while循環
通常情況下是最好的

447
00:19:40,510 --> 00:19:45,260
的方式來設計你的代碼，以便
它符合該範圍。

448
00:19:45,260 --> 00:19:45,760
確定。

449
00:19:45,760 --> 00:19:48,930

450
00:19:48,930 --> 00:19:49,470
>> 確定。

451
00:19:49,470 --> 00:19:53,270
因此，這可能是最
複雜的環出三個

452
00:19:53,270 --> 00:19:54,990
我們已經看到了這麼遠。

453
00:19:54,990 --> 00:19:56,689
它看起來很嚇人在第一。

454
00:19:56,689 --> 00:19:59,730
但我向你保證，一旦你們
了解如何使用一個for循環的竅門，

455
00:19:59,730 --> 00:20:03,320
這是最有用的事情之一，
在您的阿森納最有用的工具

456
00:20:03,320 --> 00:20:05,300
為推動這一類。

457
00:20:05,300 --> 00:20:09,920
>> 因此，例如，在刮，
我們有一個非常簡單的塊

458
00:20:09,920 --> 00:20:13,180
只是說重複這個特定
短語一定的次數。

459
00:20:13,180 --> 00:20:16,260
順便說一下，SAJ--
這是Scaz安迪傑森。

460
00:20:16,260 --> 00:20:18,740
我們常常簽署我們的郵件SAJ。

461
00:20:18,740 --> 00:20:20,360
如果說SAJ，不要混淆。

462
00:20:20,360 --> 00:20:22,630
這只是我們。

463
00:20:22,630 --> 00:20:28,600
>> 因此，在刮，我們能夠有
一個塊表示，重複我愛SAJ！

464
00:20:28,600 --> 00:20:29,430
的10倍。

465
00:20:29,430 --> 00:20:30,130
很簡單。

466
00:20:30,130 --> 00:20:32,302
背後的邏輯是一個
非常，非常簡單吧？

467
00:20:32,302 --> 00:20:35,260
我想先通過第一
時間和看到的是，第二次

468
00:20:35,260 --> 00:20:38,510
並看到，第三次，依此類推
並依此類推，直到你打10。

469
00:20:38,510 --> 00:20:41,960
>> 而這樣，我們將表示在
代碼只是通過for循環的簡單。

470
00:20:41,960 --> 00:20:45,440
因此，對，你要申報
這裡對您的變量，在這種情況下，

471
00:20:45,440 --> 00:20:46,349
用int。

472
00:20:46,349 --> 00:20:47,390
我們將其命名為我。

473
00:20:47,390 --> 00:20:49,500
我們將其初始化為0。

474
00:20:49,500 --> 00:20:52,490
和制動版本是
將是i小於10。

475
00:20:52,490 --> 00:20:54,622
並且更新將是我++。

476
00:20:54,622 --> 00:20:57,750
>> 而內環路，這是怎麼回事
直到最後它來執行

477
00:20:57,750 --> 00:21:01,490
擊中condition--的端部，其中
情況下，這將打破循環。

478
00:21:01,490 --> 00:21:04,600
應該有東西，你
所有類型的球員已經見過

479
00:21:04,600 --> 00:21:07,270
而不得不做你的問題集之一。

480
00:21:07,270 --> 00:21:12,310
有沒有人有任何問題
關於for循環的權利嗎？

481
00:21:12,310 --> 00:21:12,930
確定。

482
00:21:12,930 --> 00:21:13,430
太好了。

483
00:21:13,430 --> 00:21:17,520

484
00:21:17,520 --> 00:21:18,620
>> 確定。

485
00:21:18,620 --> 00:21:22,270
因此，對於那些你們誰
讀處理器集規格本週

486
00:21:22,270 --> 00:21:27,690
知道我們將不得不僱用
一些所謂的ASCII和ASCII表。

487
00:21:27,690 --> 00:21:32,380
大衛在演講走過去簡單
計算機如何essentially--一切

488
00:21:32,380 --> 00:21:35,410
被編碼在計算機中
二元，在零和一。

489
00:21:35,410 --> 00:21:39,740
而這台計算機能的方式
以存儲除了不同的值

490
00:21:39,740 --> 00:21:44,360
以零和的是通過映射
這些數字代表其他數字

491
00:21:44,360 --> 00:21:47,220
或基本上其他字符。

492
00:21:47,220 --> 00:21:49,810
>> 所以在這種情況下，一個
ASCII table--它所做的一切

493
00:21:49,810 --> 00:21:53,600
是圖個字符，或字符，為數字。

494
00:21:53,600 --> 00:21:57,385
因此，在源代碼文件
您computer--它認為，

495
00:21:57,385 --> 00:22:00,010
哎，一堆零和一，
零和一，零和一。

496
00:22:00,010 --> 00:22:02,350
這就是存儲在
您的計算機的實際內存。

497
00:22:02,350 --> 00:22:04,750
>> 但是，當我們人類要
與電腦進行通訊，

498
00:22:04,750 --> 00:22:08,249
我們want--說，例如，
如果我想的大寫字母A，

499
00:22:08,249 --> 00:22:10,540
我將需要一些方法
告訴電腦，哦，

500
00:22:10,540 --> 00:22:16,300
當我輸入大寫字母A，我的意思是
這表示二進制。

501
00:22:16,300 --> 00:22:22,260
>> 所以我們這樣做的方式是拋出了一個
隨心所欲的東西稱為ASCII表，

502
00:22:22,260 --> 00:22:25,020
我們，作為人，作為
程序員，前一段時間，

503
00:22:25,020 --> 00:22:28,660
我們隨意決定我們
將要分配這些號碼

504
00:22:28,660 --> 00:22:30,960
值這些字符。

505
00:22:30,960 --> 00:22:32,720
>> 所以你們可以google一下網上。

506
00:22:32,720 --> 00:22:37,120
我覺得有一個在你一個鏈接
pset--只是一個ASCII映射表，ASCII

507
00:22:37,120 --> 00:22:37,720
表。

508
00:22:37,720 --> 00:22:40,722
它只是轉換二進制
號碼轉換成字符。

509
00:22:40,722 --> 00:22:42,930
而且這將是非常
針對您的問題集有用

510
00:22:42,930 --> 00:22:45,470
每當你想
算什麼，或者你

511
00:22:45,470 --> 00:22:47,880
要顯示一定的
字符或整數

512
00:22:47,880 --> 00:22:50,327
或操縱某些字符。

513
00:22:50,327 --> 00:22:52,160
這將是非常
重要的是你的所有

514
00:22:52,160 --> 00:22:55,140
知道如何定位的ASCII表。

515
00:22:55,140 --> 00:23:01,260
>> 因此，例如，在大寫字母A
由數字65表示。

516
00:23:01,260 --> 00:23:04,207
而小寫
用97來表示。

517
00:23:04,207 --> 00:23:07,040
因此，重要的是要知道，
兩個值之間的差異

518
00:23:07,040 --> 00:23:08,320
是32。

519
00:23:08,320 --> 00:23:13,210
通常情況下，如果你需要從轉換
一個到另一個，不同的是32。

520
00:23:13,210 --> 00:23:15,710
如果你是那種不用擔心
迷糊這個在第一。

521
00:23:15,710 --> 00:23:20,230
我們一起去了我們如何
在實際的代碼中使用此。

522
00:23:20,230 --> 00:23:24,700

523
00:23:24,700 --> 00:23:26,380
>> 確定。

524
00:23:26,380 --> 00:23:30,770
因此，對於那些你與筆記本電腦了，
隨意拉一個ASCII表，

525
00:23:30,770 --> 00:23:36,030
因為這些大概會
需要你們引用

526
00:23:36,030 --> 00:23:38,100
什麼字符。

527
00:23:38,100 --> 00:23:38,640
確定。

528
00:23:38,640 --> 00:23:42,840
>> 因此，了解某些
字符映射到特定的號碼，

529
00:23:42,840 --> 00:23:47,240
如果我只是跑第一
那行代碼 - 在printf的一個，

530
00:23:47,240 --> 00:23:50,900
小寫，減
大寫字母A.有誰

531
00:23:50,900 --> 00:23:55,880
有這將是一個猜測
打印出來的畫面，現在呢？

532
00:23:55,880 --> 00:23:58,190
>> 所以首先，有哪些呢
小寫代表什麼？

533
00:23:58,190 --> 00:24:00,990
什麼號碼是
編碼在ASCII表。

534
00:24:00,990 --> 00:24:01,490
對不起？

535
00:24:01,490 --> 00:24:02,630
>> 聽眾：97？

536
00:24:02,630 --> 00:24:03,630
>> ANDI彭：97，偉大的。

537
00:24:03,630 --> 00:24:05,077
什麼是大寫字母A？

538
00:24:05,077 --> 00:24:06,330
>> 聽眾：65。

539
00:24:06,330 --> 00:24:08,255
>> ANDI彭：那麼，什麼是97減65？

540
00:24:08,255 --> 00:24:09,227
>> 聽眾：32。

541
00:24:09,227 --> 00:24:09,810
ANDI彭：OK。

542
00:24:09,810 --> 00:24:13,530
那麼，你們認為是要
發生時，我輸入了代碼行

543
00:24:13,530 --> 00:24:14,670
進入我的電腦？

544
00:24:14,670 --> 00:24:17,981

545
00:24:17,981 --> 00:24:19,896
>> 聽眾：[聽不清]。

546
00:24:19,896 --> 00:24:21,020
ANDI彭：對不起，說出來。

547
00:24:21,020 --> 00:24:22,520
無後顧之憂。

548
00:24:22,520 --> 00:24:25,750
這是一個非常安全的
環境，減去相機。

549
00:24:25,750 --> 00:24:27,550
我們都將用於：無後顧之憂。

550
00:24:27,550 --> 00:24:30,940
只是我們都去假裝
它只是我們心寒在這個房間裡。

551
00:24:30,940 --> 00:24:31,480
無後顧之憂。

552
00:24:31,480 --> 00:24:33,410
毫無疑問是太愚蠢了。

553
00:24:33,410 --> 00:24:35,300
沒有答案是愚蠢的答案。

554
00:24:35,300 --> 00:24:38,260
我可能會犯錯誤
在我的教學過程。

555
00:24:38,260 --> 00:24:40,740
說真的，伙計們，只是脫口而出出來。

556
00:24:40,740 --> 00:24:43,092
要充滿自信，你知道嗎？

557
00:24:43,092 --> 00:24:43,800
所以，那是什麼？

558
00:24:43,800 --> 00:24:47,990
誰說，去年的答案嗎？

559
00:24:47,990 --> 00:24:48,540
確定。

560
00:24:48,540 --> 00:24:50,380
喊了很好的和明確的。

561
00:24:50,380 --> 00:24:51,220
>> 聽眾：32？

562
00:24:51,220 --> 00:24:51,850
>> ANDI彭：32。

563
00:24:51,850 --> 00:24:54,141
OK，讓我們運行此代碼，
看看這是什麼情況。

564
00:24:54,141 --> 00:25:00,260

565
00:25:00,260 --> 00:25:00,760
確定。

566
00:25:00,760 --> 00:25:03,300

567
00:25:03,300 --> 00:25:06,360
所以當你們可以種
看，典型的符號我已經

568
00:25:06,360 --> 00:25:12,250
設在這裡的，我們將如何使用
在我們的電腦任何類型的程序。

569
00:25:12,250 --> 00:25:14,770
我們有我們的主要功能
在我們的主要功能。

570
00:25:14,770 --> 00:25:17,265
我只是去複製和
粘貼此行代碼。

571
00:25:17,265 --> 00:25:21,082

572
00:25:21,082 --> 00:25:23,540
你什麼時候你們也要小心
正在複製和粘貼代碼。

573
00:25:23,540 --> 00:25:28,750
有時候，某些運營商
不貼了正常。

574
00:25:28,750 --> 00:25:31,397
在這種情況下，減
符號實際上是一個破折號。

575
00:25:31,397 --> 00:25:32,980
這樣一來，電腦並沒有把它撿起來。

576
00:25:32,980 --> 00:25:35,870
因此，我不得不回去
身體重新輸入。

577
00:25:35,870 --> 00:25:37,846
只是要小心
你們正在做的。

578
00:25:37,846 --> 00:25:41,178

579
00:25:41,178 --> 00:25:42,660
>> 確定。

580
00:25:42,660 --> 00:25:43,980
我們要在這裡運行此。

581
00:25:43,980 --> 00:25:45,670
所以，我們要cd到我們的第2節。

582
00:25:45,670 --> 00:25:50,470

583
00:25:50,470 --> 00:25:52,030
我叫這個節目asciimath。

584
00:25:52,030 --> 00:25:55,690
所以請記住，當我們運行任何
程序中，我們要先編譯

585
00:25:55,690 --> 00:25:57,150
通過我們的化妝運行它。

586
00:25:57,150 --> 00:26:00,030
然後我們要實際運行
該方案通過做點斜線。

587
00:26:00,030 --> 00:26:01,280
所以，我們要./asciimath。

588
00:26:01,280 --> 00:26:05,780

589
00:26:05,780 --> 00:26:06,590
>> 對了，我們走吧。

590
00:26:06,590 --> 00:26:07,410
我們看到32。

591
00:26:07,410 --> 00:26:07,930
幹得好。

592
00:26:07,930 --> 00:26:10,340
你應該得到一塊糖。

593
00:26:10,340 --> 00:26:11,160
糖果給你。

594
00:26:11,160 --> 00:26:11,900
抱歉。

595
00:26:11,900 --> 00:26:13,100
好的。

596
00:26:13,100 --> 00:26:13,670
確定。

597
00:26:13,670 --> 00:26:18,070
所以，我們可以回到我們的例子在這裡。

598
00:26:18,070 --> 00:26:23,530

599
00:26:23,530 --> 00:26:24,345
啊哈，沒有。

600
00:26:24,345 --> 00:26:29,147

601
00:26:29,147 --> 00:26:31,090
AAH。

602
00:26:31,090 --> 00:26:32,490
確定。

603
00:26:32,490 --> 00:26:34,610
我只是要保持這樣的。

604
00:26:34,610 --> 00:26:48,520

605
00:26:48,520 --> 00:26:51,240
確定。

606
00:26:51,240 --> 00:26:51,740
確定。

607
00:26:51,740 --> 00:26:55,340
所以當你們可以看到，我們能做到
很多非常有趣的事情，

608
00:26:55,340 --> 00:26:58,880
很多非常酷的事情，很多的
涉及到非常複雜的事情

609
00:26:58,880 --> 00:27:02,720
ASCII字符和數字。

610
00:27:02,720 --> 00:27:05,890
一旦你到五號線，
這是一個很多跟隨。

611
00:27:05,890 --> 00:27:07,640
我們不會去
通過部分。

612
00:27:07,640 --> 00:27:10,720
隨意，如果可以的話，
原因，它在紙上

613
00:27:10,720 --> 00:27:14,750
第一次什麼應該發生時，
你輸入這樣的字符串值。

614
00:27:14,750 --> 00:27:19,720
例如，在最後一行，我們有
z--表示某種number--

615
00:27:19,720 --> 00:27:24,740
A--這也代表了
某些number--加1模數26

616
00:27:24,740 --> 00:27:26,750
再加上小寫。

617
00:27:26,750 --> 00:27:29,220
>> 如果你們繼續閱讀
通過這些，你

618
00:27:29,220 --> 00:27:34,009
可以看到一個模式來在
我們是如何操作的代碼。

619
00:27:34,009 --> 00:27:36,050
我強烈，強烈建議
畢竟你節

620
00:27:36,050 --> 00:27:38,160
球員前進和投入
這些都在你的電腦

621
00:27:38,160 --> 00:27:40,060
看看是什麼樣的
數字現身

622
00:27:40,060 --> 00:27:43,090
並通過這些原因是推理
發生的事情，因為你的pset

623
00:27:43,090 --> 00:27:45,060
這將是非常重要的
讓你了解

624
00:27:45,060 --> 00:27:47,132
為什麼某些事情正在發生。

625
00:27:47,132 --> 00:27:48,590
所有這些幻​​燈片將在網上。

626
00:27:48,590 --> 00:27:51,510
所以不愁努力
身體上複製下來的筆記。

627
00:27:51,510 --> 00:27:52,510
一切都在網上。

628
00:27:52,510 --> 00:27:54,050
本節本身會上網。

629
00:27:54,050 --> 00:27:57,500
我的所有的源代碼，
我正在將是網上。

630
00:27:57,500 --> 00:27:58,180
是啊。

631
00:27:58,180 --> 00:27:59,430
你還有問題嗎？

632
00:27:59,430 --> 00:28:00,587
聽眾：什麼是模數？

633
00:28:00,587 --> 00:28:01,170
ANDI彭：OK。

634
00:28:01,170 --> 00:28:05,620
所以模是一個操作員，那將
是你的球員的pset中非常重要的

635
00:28:05,620 --> 00:28:06,690
在這裡。

636
00:28:06,690 --> 00:28:12,280
這樣的方式，操作人員
C語言和編程工作

637
00:28:12,280 --> 00:28:16,360
是，你有什麼所謂的
師符號和模量的象徵，

638
00:28:16,360 --> 00:28:18,350
這就像百分號。

639
00:28:18,350 --> 00:28:24,840
>> 因此，在C，當你做一個整數
除以整數帶斜線，

640
00:28:24,840 --> 00:28:27,720
C具有一種傾向，要削減
關閉所有的小數點，

641
00:28:27,720 --> 00:28:30,290
因為一個整數希望
轉換成整數。

642
00:28:30,290 --> 00:28:33,550
它不會想成為一個雙
一堆小數所有之後的。

643
00:28:33,550 --> 00:28:39,322
>> 所以，如果我做的3除以2，這是怎麼回事
切斷0.5和只給你1。

644
00:28:39,322 --> 00:28:41,530
所以這是一件值得
非常小心，當你的

645
00:28:41,530 --> 00:28:45,294
做任何形式的數學編程，
是這些數字你

646
00:28:45,294 --> 00:28:47,210
未必是數字
你所想，

647
00:28:47,210 --> 00:28:50,190
這就是為什麼在舍入你的
最後PSET是非常重要的。

648
00:28:50,190 --> 00:28:51,980
>> 模給你的剩餘部分。

649
00:28:51,980 --> 00:28:56,200
因此，舉例來說，如果我做了3
模2--所以3百分號2--

650
00:28:56,200 --> 00:28:58,020
它會給你的那剩下的人。

651
00:28:58,020 --> 00:29:00,460
所以3除以2為1.5。

652
00:29:00,460 --> 00:29:01,410
這是1剩下的1。

653
00:29:01,410 --> 00:29:04,600
它會給你1，這
是那剩下的人。

654
00:29:04,600 --> 00:29:07,361
>> 所以，當你們正在
通過ASCII表，

655
00:29:07,361 --> 00:29:09,735
模將最終被
東西是非常重要的，

656
00:29:09,735 --> 00:29:11,240
我們將討論以後。

657
00:29:11,240 --> 00:29:17,750

658
00:29:17,750 --> 00:29:19,040
>> 確定。

659
00:29:19,040 --> 00:29:27,300
所以東西是漂亮，
漂亮的新獨闢蹊徑

660
00:29:27,300 --> 00:29:31,920
我們已經在本週討論的
什麼數組的概念。

661
00:29:31,920 --> 00:29:34,370
所以陣列是第一
數據結構的類型

662
00:29:34,370 --> 00:29:36,320
我們要去
遇到此類。

663
00:29:36,320 --> 00:29:40,010
所有的數據結構是
某種隨意性，

664
00:29:40,010 --> 00:29:43,370
從字面上的東西狀結構
我們作為程序員創建的，

665
00:29:43,370 --> 00:29:47,890
我們已經把我們的代碼，
可以包含其他的代碼段。

666
00:29:47,890 --> 00:29:51,090
>> 所以在這個意義上說，一個array--
認為它是一個文件櫃，

667
00:29:51,090 --> 00:29:53,470
在那裡，如果你打開不同的
文件櫃貨架，

668
00:29:53,470 --> 00:29:55,630
您可以訪問不同的事情。

669
00:29:55,630 --> 00:29:58,630
在內存中，數組只是做
同樣的事情在您的計算機上。

670
00:29:58,630 --> 00:30:01,730
你可以有不同的blocks--我們
稱他們indices--數組。

671
00:30:01,730 --> 00:30:04,210
這就像一個塊，
的存儲器的架子

672
00:30:04,210 --> 00:30:07,580
我們已經在創建了
計算機，你可以輸入

673
00:30:07,580 --> 00:30:10,270
在不同的空間中某些事情。

674
00:30:10,270 --> 00:30:18,000
>> 因此，一個數組，你
總是要specify--

675
00:30:18,000 --> 00:30:22,360
您必須指定在聲明
陣列中的下面的格式。

676
00:30:22,360 --> 00:30:24,290
你會第一
指定數據類型

677
00:30:24,290 --> 00:30:25,831
要創建陣列。

678
00:30:25,831 --> 00:30:28,870
如果我想要一個整數數組，
我打算把INT就在這裡。

679
00:30:28,870 --> 00:30:32,079
如果我想要一個字符串數組，
我打算把字符串出現，

680
00:30:32,079 --> 00:30:34,995
陣列的名稱，然後
你將有方括號。

681
00:30:34,995 --> 00:30:39,580
而在方括號，你
將有你的數組的大小。

682
00:30:39,580 --> 00:30:42,900
>> 東西是真正重要的
記住，當創建陣列是

683
00:30:42,900 --> 00:30:46,530
如此，一旦你創建一個
陣列，該尺寸不能改變。

684
00:30:46,530 --> 00:30:50,180
所以，如果你知道現在
你有大小為10的數組，

685
00:30:50,180 --> 00:30:54,550
你知道，我將有10個小區
內或10這個數組中的索引，

686
00:30:54,550 --> 00:30:56,830
它永遠不會
擴大或減少

687
00:30:56,830 --> 00:30:59,850
不管是什麼，這有
空間目前只有10個街區

688
00:30:59,850 --> 00:31:04,490
分配你的內存，可以存儲
最多10個任何事情，你已經把。

689
00:31:04,490 --> 00:31:08,790
>> 因此以這種方式，陣列數據類型，
的數據結構是數組

690
00:31:08,790 --> 00:31:13,392
從其他一些人，我們將非常不同
在此過程中稍後覆蓋。

691
00:31:13,392 --> 00:31:15,170
是啊。

692
00:31:15,170 --> 00:31:20,080
例如，如果你想
創建大小為3的數組

693
00:31:20,080 --> 00:31:23,670
的integer--包含變量
哦，不好意思，temperature--

694
00:31:23,670 --> 00:31:25,640
和溫度，
當然，是整數。

695
00:31:25,640 --> 00:31:28,710
>> 因此，我們將產生int，它是
是我們要存儲的數據類型。

696
00:31:28,710 --> 00:31:32,680
我們將調用這個溫度
為求命名的命名

697
00:31:32,680 --> 00:31:34,200
東西，大家都明白。

698
00:31:34,200 --> 00:31:35,900
而我們將有方括號。

699
00:31:35,900 --> 00:31:37,200
我們希望三個數字。

700
00:31:37,200 --> 00:31:39,000
因此，我們打算把
三是內部的。

701
00:31:39,000 --> 00:31:41,041
>> 東西是真的
重要的是要記住

702
00:31:41,041 --> 00:31:43,530
是陣列零索引。

703
00:31:43,530 --> 00:31:46,410
所有這一切意味著你
開始為0的索引，

704
00:31:46,410 --> 00:31:49,800
你通過跑起來
減1的陣列的大小。

705
00:31:49,800 --> 00:31:52,730
因此，對於這裡的例子，我們
有大小3的數組。

706
00:31:52,730 --> 00:31:54,680
這將能
持有三個值。

707
00:31:54,680 --> 00:31:57,450
但數字themselves--的
號，陣列，該索引，

708
00:31:57,450 --> 00:32:00,271
數組，從0到2。

709
00:32:00,271 --> 00:32:03,520
所以，球員，真的，真的很小心
你要通過你的問題集

710
00:32:03,520 --> 00:32:06,500
和創建任何類型的數組，
因為很多它的時代

711
00:32:06,500 --> 00:32:08,490
真的，真的很容易忘記這一點。

712
00:32:08,490 --> 00:32:11,840
我居然沒有索引
3，我現在只是

713
00:32:11,840 --> 00:32:13,130
具有2的索引。

714
00:32:13,130 --> 00:32:16,046
如果你嘗試
訪問第三索引，

715
00:32:16,046 --> 00:32:18,170
這將是怎樣的
所謂空終止。

716
00:32:18,170 --> 00:32:19,990
它不會實際
存在陣列中。

717
00:32:19,990 --> 00:32:21,781
並且計算機
不會喜歡的。

718
00:32:21,781 --> 00:32:24,570
所以要小心，只要
您正在訪問的事情只是

719
00:32:24,570 --> 00:32:28,070
確保你記住
該數組是零索引。

720
00:32:28,070 --> 00:32:28,880
>> 確定。

721
00:32:28,880 --> 00:32:34,030
所以第一實施例僅僅是
創建陣列的一種方式。

722
00:32:34,030 --> 00:32:36,790
第二個例子，我有
下面就是一個獨立的方式

723
00:32:36,790 --> 00:32:40,210
創造了什麼是相同的數據
我們剛剛輸入的結構。

724
00:32:40,210 --> 00:32:44,347
因此，而不是實際運行
通過並把在0溫度

725
00:32:44,347 --> 00:32:47,180
等於什麼，溫度1
等於什麼，溫度2等於

726
00:32:47,180 --> 00:32:50,950
不管，我其實只是
在一行中直接創建這一切

727
00:32:50,950 --> 00:32:53,010
成溫方括號等於。

728
00:32:53,010 --> 00:32:56,536
>> 並注意在這種情況下，你不需要
到指定的數組有多大，

729
00:32:56,536 --> 00:32:59,160
因為電腦的打算
經過，看到有

730
00:32:59,160 --> 00:33:01,570
在這些大括號三個要素。

731
00:33:01,570 --> 00:33:04,000
而且它會知道，OK，
我需要的大小為3的數組。

732
00:33:04,000 --> 00:33:07,440
你不會需要
輸入它下面的方式。

733
00:33:07,440 --> 00:33:10,170
>> 而且，是的，這種方式。

734
00:33:10,170 --> 00:33:12,610
有沒有人有問題
關於我們如何數組

735
00:33:12,610 --> 00:33:17,391
或如何陣列結構的工作原理？

736
00:33:17,391 --> 00:33:17,890
是啊。

737
00:33:17,890 --> 00:33:18,806
>> 聽眾：[聽不清]？

738
00:33:18,806 --> 00:33:21,649

739
00:33:21,649 --> 00:33:22,690
ANDI彭：是的，沒錯。

740
00:33:22,690 --> 00:33:26,150
所以，如果你要聲明和初始化
陣列以下的方法，

741
00:33:26,150 --> 00:33:28,477
這是第二次的方式，
你可以離開的。

742
00:33:28,477 --> 00:33:30,310
而且電腦
自動知道它

743
00:33:30,310 --> 00:33:33,950
需要指望有多少元素
在這些大括號，分離

744
00:33:33,950 --> 00:33:34,930
用逗號。

745
00:33:34,930 --> 00:33:37,517
>> 所以在這裡，他們看到65，87，30。

746
00:33:37,517 --> 00:33:39,600
因此，計算機就知道，哦，
有三個整數。

747
00:33:39,600 --> 00:33:45,960
我知道要創建一個數組名
溫度在其三大要素。

748
00:33:45,960 --> 00:33:46,590
好問題。

749
00:33:46,590 --> 00:33:47,090
是啊。

750
00:33:47,090 --> 00:33:51,590
>> 聽眾：是不是有可能創建
與不同類型的數據陣列

751
00:33:51,590 --> 00:33:53,021
可能被輸入到什麼？

752
00:33:53,021 --> 00:33:56,746
例如，對於整數[聽不清]？

753
00:33:56,746 --> 00:33:59,120
ANDI彭：為施行
這個類的，不，現在。

754
00:33:59,120 --> 00:34:03,070
當你創建一個數據
結構是怎樣的一個數組，

755
00:34:03,070 --> 00:34:04,990
你告訴
計算機，嘿嘿，我需要你

756
00:34:04,990 --> 00:34:08,159
分配這麼多
記憶在我的硬盤驅動器，

757
00:34:08,159 --> 00:34:10,690
每個小區是一個
一定數目的位。

758
00:34:10,690 --> 00:34:13,429
>> 還記得我們在上週得知
零的不同的數據

759
00:34:13,429 --> 00:34:15,300
類型有不同的大小？

760
00:34:15,300 --> 00:34:17,630
因此，例如，一個字符串
是一個不同的量

761
00:34:17,630 --> 00:34:20,719
空間不是一個字符，這
是不同量的空間

762
00:34:20,719 --> 00:34:21,830
從一個整數。

763
00:34:21,830 --> 00:34:25,534
所以，如果你沒有指定你
混搭是什麼類型的變量

764
00:34:25,534 --> 00:34:27,659
你有電腦的
將是很迷茫。

765
00:34:27,659 --> 00:34:29,950
而且它不會知道
多少內存給你。

766
00:34:29,950 --> 00:34:32,480
所以為便於右
現在，計算機只能

767
00:34:32,480 --> 00:34:36,120
識別一種類型的數組。

768
00:34:36,120 --> 00:34:37,940
好問題。

769
00:34:37,940 --> 00:34:38,440
確定。

770
00:34:38,440 --> 00:34:45,179

771
00:34:45,179 --> 00:34:47,120
>> 所以很自然的
我們的第二個問題

772
00:34:47,120 --> 00:34:50,760
是，好了，現在我們已經創建了一個
陣列，我們已經把所有的這些東西

773
00:34:50,760 --> 00:34:54,190
陣列中的情況是怎樣的
要能夠訪問它？

774
00:34:54,190 --> 00:34:59,710
因此，典型結構是我們始終
訪問數組是我們可愛的for循環。

775
00:34:59,710 --> 00:35:03,830
我答應你們，我們會
看到很多這樣的傢伙在這裡。

776
00:35:03,830 --> 00:35:06,470
>> 從本質上講，任何時候你想
輸入值到一個數組

777
00:35:06,470 --> 00:35:09,940
或者你想訪問他們來說，
這樣做的最好的方法是一個for循環，

778
00:35:09,940 --> 00:35:13,730
因為在一個for循環，你
知道你有多少次

779
00:35:13,730 --> 00:35:17,290
會希望通過陣列來運行，
因為你有一個停止的版本，對不對？

780
00:35:17,290 --> 00:35:19,680
而每一次運行
通過，你可以訪問

781
00:35:19,680 --> 00:35:21,310
不同的元件的陣列構成。

782
00:35:21,310 --> 00:35:26,920
>> 而且，這是一個原因，通常
我們在0值開始我們的for循環，

783
00:35:26,920 --> 00:35:30,080
因為當你訪問陣列，
您可以訪問零指標。

784
00:35:30,080 --> 00:35:32,070
因此它平行非常漂亮。

785
00:35:32,070 --> 00:35:35,295
你們可能想
寫INT I等於1。

786
00:35:35,295 --> 00:35:37,330
i小於或等於3。

787
00:35:37,330 --> 00:35:39,890
>> 但它不會是相當正常工作
還有在這裡，因為你只

788
00:35:39,890 --> 00:35:42,010
具有0，1和2的元件。

789
00:35:42,010 --> 00:35:45,815
所以如果你開始
您我在元件1，2，和3中，

790
00:35:45,815 --> 00:35:48,440
你會最終運行
你的數組的邊界，

791
00:35:48,440 --> 00:35:50,440
壞的事情將要發生。

792
00:35:50,440 --> 00:35:54,480
>> 所以，我希望你們看到SEGUE
為什麼在前面的類

793
00:35:54,480 --> 00:35:58,560
我們教你們如何運行和
格式化的循環，我們的方式。

794
00:35:58,560 --> 00:36:01,900
這是因為，現在我們已經
過渡到陣列，

795
00:36:01,900 --> 00:36:06,760
你可以看到為什麼0貸出
本身非常漂亮來訪問。

796
00:36:06,760 --> 00:36:09,880
>> 所以我們這樣做的方式是that--我
剛剛打印出來這裡是為了

797
00:36:09,880 --> 00:36:10,830
打印出來。

798
00:36:10,830 --> 00:36:13,750
但是，我有我的佔位符，逗號。

799
00:36:13,750 --> 00:36:15,645
與實際訪問
部分正在發生。

800
00:36:15,645 --> 00:36:17,520
所述陣列的名稱
被稱為溫度。

801
00:36:17,520 --> 00:36:21,570
所以它的溫度和
該陣列的第i個元素。

802
00:36:21,570 --> 00:36:24,400
>> 所以for循環貫穿，
它會從0開始。

803
00:36:24,400 --> 00:36:27,640
這將打印出
此數組的第0個指標。

804
00:36:27,640 --> 00:36:29,599
然後它會打印
出的第一個元素。

805
00:36:29,599 --> 00:36:31,431
然後它會打印
出第二個。

806
00:36:31,431 --> 00:36:32,880
然後，我們要打破。

807
00:36:32,880 --> 00:36:36,718
是每個人都清楚
怎麼說是怎麼回事？

808
00:36:36,718 --> 00:36:37,217
太好了。

809
00:36:37,217 --> 00:36:43,230

810
00:36:43,230 --> 00:36:44,100
>> 好的。

811
00:36:44,100 --> 00:36:47,270
所以在這裡我們有辦法
他說，如果我們不想要

812
00:36:47,270 --> 00:36:50,020
硬編碼in--我為程序員。

813
00:36:50,020 --> 00:36:53,320
我不想實際的物理
擺在每一個單獨的元素

814
00:36:53,320 --> 00:36:54,020
此陣。

815
00:36:54,020 --> 00:36:56,500
如果我想，而不是
有用戶輸入的值，

816
00:36:56,500 --> 00:36:58,100
什麼是做到這一點的最好方法是什麼？

817
00:36:58,100 --> 00:37:00,920
>> 那麼，在這裡我已經創建
這個可愛的功能，

818
00:37:00,920 --> 00:37:03,560
我在其中可以聲明數組。

819
00:37:03,560 --> 00:37:06,210
因此，廉政scores--我們
只是說我們要

820
00:37:06,210 --> 00:37:10,660
即持有的所有18年級的數組
對這裡的學生在本節。

821
00:37:10,660 --> 00:37:12,670
我認為我們已經有了一個位
超過18個孩子的今天。

822
00:37:12,670 --> 00:37:16,460
但如的緣故，
讓我們只是假設，我們有18。

823
00:37:16,460 --> 00:37:21,580
我想創建一個數組名得分與
int類型，因為得分，當然，

824
00:37:21,580 --> 00:37:22,987
是數字。

825
00:37:22,987 --> 00:37:24,820
而我將不得不
在方括號18，

826
00:37:24,820 --> 00:37:29,900
有多少學生，因為這是我
希望能夠存儲的分數。

827
00:37:29,900 --> 00:37:32,206
>> 而這樣，我想填充
該陣列是我最好

828
00:37:32,206 --> 00:37:35,572
通過運行for循環中，
當然，0是我的第0指數。

829
00:37:35,572 --> 00:37:38,030
然後用18是我的
停版，因為有

830
00:37:38,030 --> 00:37:39,690
數組中的18個元素。

831
00:37:39,690 --> 00:37:44,620
然後，我會做的printf，輸入
得分student--亞達內容十分重要。

832
00:37:44,620 --> 00:37:51,171
>> 誰能告訴我為什麼在這裡，我
打印I加1，而不是我？

833
00:37:51,171 --> 00:37:52,920
這是怎樣的一個把戲
問題，不是真的。

834
00:37:52,920 --> 00:37:56,020
它並沒有實際的物理
影響代碼的運行。

835
00:37:56,020 --> 00:37:56,520
是啊。

836
00:37:56,520 --> 00:37:57,909
>> 聽眾：[聽不清] 0？

837
00:37:57,909 --> 00:37:58,950
ANDI彭：是的，沒錯。

838
00:37:58,950 --> 00:38:02,620
這是一個有點尷尬地說，哎，
你是第0個學生在這個類。

839
00:38:02,620 --> 00:38:03,780
這是一個有點怪。

840
00:38:03,780 --> 00:38:08,340
所以我們作為人類，真的不喜歡
想想計算機如何想的。

841
00:38:08,340 --> 00:38:10,930
因此，即使在
計算機，它的存儲值

842
00:38:10,930 --> 00:38:13,310
在第0索引，當
我們是人類，我們真的不

843
00:38:13,310 --> 00:38:15,520
喜歡把自己看作為零。

844
00:38:15,520 --> 00:38:18,119
所以，當我剛打印，
我要打印，並添加

845
00:38:18,119 --> 00:38:19,410
1只是為了清楚起見。

846
00:38:19,410 --> 00:38:22,447
所以，當我打印，我將是
能夠通過18打印學生1。

847
00:38:22,447 --> 00:38:24,530
它實際上並不影響
代碼的運行

848
00:38:24,530 --> 00:38:27,110
以任何方式，我的方式進行打印。

849
00:38:27,110 --> 00:38:30,380
>> 但要小心，當你
實際訪問的陣列。

850
00:38:30,380 --> 00:38:32,780
當你看到我得分，
注意這裡我其實

851
00:38:32,780 --> 00:38:38,200
訪問第0指數
不是1加0--或1加1，

852
00:38:38,200 --> 00:38:45,530
在這種情況下，指數所以
這實際上是明確的。

853
00:38:45,530 --> 00:38:48,870
是每個人都種確定對
這是如何通過運行

854
00:38:48,870 --> 00:38:51,470
並與各項指標我
把一個值到陣列

855
00:38:51,470 --> 00:38:55,340
並創建具有18個數字的數組
該用戶將要輸入？

856
00:38:55,340 --> 00:38:58,780

857
00:38:58,780 --> 00:38:59,821
確定。

858
00:38:59,821 --> 00:39:00,321
酷。

859
00:39:00,321 --> 00:39:05,380

860
00:39:05,380 --> 00:39:07,400
>> 確定。

861
00:39:07,400 --> 00:39:12,220
現在，我們進入的東西，是很
有關這片設置為好。

862
00:39:12,220 --> 00:39:15,020
我知道在講座中，David--
對不起，你有問題嗎？

863
00:39:15,020 --> 00:39:16,840
>> 聽眾：您可以放大嗎？

864
00:39:16,840 --> 00:39:18,080
>> ANDI彭：是啊，所以我嘗試。

865
00:39:18,080 --> 00:39:18,788
但我不知道。

866
00:39:18,788 --> 00:39:21,437
出於某種原因，這
版本的PowerPoint

867
00:39:21,437 --> 00:39:23,270
是真的不工作
很好地與所述顯示。

868
00:39:23,270 --> 00:39:25,260
因此，我們只是要
要保持這樣。

869
00:39:25,260 --> 00:39:27,280
這些都將在網上上傳。

870
00:39:27,280 --> 00:39:28,218
對不起，伙計們。

871
00:39:28,218 --> 00:39:30,090
是啊。

872
00:39:30,090 --> 00:39:30,980
確定。

873
00:39:30,980 --> 00:39:35,530
>> 因此，我們也可以有字符串。

874
00:39:35,530 --> 00:39:39,320
所以，如果你們確實notice--我
知道羅布走到這在演講

875
00:39:39,320 --> 00:39:43,652
他did--字符串實際上是
字符的只是陣列，

876
00:39:43,652 --> 00:39:44,860
如果你仔細想想，對吧？

877
00:39:44,860 --> 00:39:47,500
字符串是一個名稱或
句子或單詞，對不對？

878
00:39:47,500 --> 00:39:52,975
>> 如果我要創建一個名為字符串
Andi--只是我的名字，A-N-D-我。

879
00:39:52,975 --> 00:39:55,460
你認為那是只有一個變量。

880
00:39:55,460 --> 00:39:58,630
但實際上，它的分解
成字符的只是一個數組。

881
00:39:58,630 --> 00:40:01,910
因此它有足夠的字符
一個存儲在數組中的值。

882
00:40:01,910 --> 00:40:05,420
它有n個存儲於一個字符
第二索引等等，等等。

883
00:40:05,420 --> 00:40:08,660
>> 因此，在這樣的方式，我們
居然有這樣的

884
00:40:08,660 --> 00:40:10,970
結構的設置
把我們的字符串。

885
00:40:10,970 --> 00:40:14,660
所以在這裡，如果我輸入
詞“吃” - 這樣的字符串字是

886
00:40:14,660 --> 00:40:15,540
得到的字符串。

887
00:40:15,540 --> 00:40:19,260
如果我要輸入單詞“吃”了
在物理的方式，我的電腦

888
00:40:19,260 --> 00:40:21,870
是存儲該字符串在我的記憶中。

889
00:40:21,870 --> 00:40:27,140
>> 如果我想通過運行
和打印的out--所以到我

890
00:40:27,140 --> 00:40:30,890
等於零，請記住，在講座中，我們
涵蓋的東西，就是所謂的strlen，

891
00:40:30,890 --> 00:40:32,990
或字符串的長度。

892
00:40:32,990 --> 00:40:36,520
因為我不實際
知道數組有多大

893
00:40:36,520 --> 00:40:38,210
無論用戶的inputting--的

894
00:40:38,210 --> 00:40:40,370
>> 比如，我輸入
字“吃，”我知道

895
00:40:40,370 --> 00:40:41,870
這三個字符長，對不對？

896
00:40:41,870 --> 00:40:44,700
所以，我可以把在三有
一切都會好起來的。

897
00:40:44,700 --> 00:40:49,290
但是，如果用戶輸入的東西
這是一個不同值的數量，

898
00:40:49,290 --> 00:40:52,760
你將不能夠真正
知道，當你的程序代碼。

899
00:40:52,760 --> 00:40:56,040
>> 讓我們處理測試用例的方法
這樣的是，我們有一些

900
00:40:56,040 --> 00:41:00,070
所謂strlen的，這僅僅是一個函數
告訴你一個字符串有多長。

901
00:41:00,070 --> 00:41:02,080
所以strlen的字。

902
00:41:02,080 --> 00:41:03,470
我的話是吃的。

903
00:41:03,470 --> 00:41:05,990
n等於字strlen的。

904
00:41:05,990 --> 00:41:08,930
有誰能告訴我這是什麼
值實際上是正確的呢？

905
00:41:08,930 --> 00:41:12,550
這是什麼ñ代表權
現在，在這個例子中，如果我有吃的嗎？

906
00:41:12,550 --> 00:41:13,530
>> 聽眾：3。

907
00:41:13,530 --> 00:41:14,520
>> ANDI彭：3，正好。

908
00:41:14,520 --> 00:41:18,820
因此，我們必須對於int i等於
零，n等於3，本質上。

909
00:41:18,820 --> 00:41:22,355
並且i要運行
直到它的不足3I ++。

910
00:41:22,355 --> 00:41:24,980
而這將基本上去
通過做同樣的事情。

911
00:41:24,980 --> 00:41:26,979
這將打印出
每個值，並給您

912
00:41:26,979 --> 00:41:29,700
E-A-T。它只是表示一個
寫它的不同的方式。

913
00:41:29,700 --> 00:41:31,170
這將是非常有益的。

914
00:41:31,170 --> 00:41:31,670
是啊。

915
00:41:31,670 --> 00:41:35,174
聽眾：什麼是推桿的好處
在n等於裡面那個strlen的字

916
00:41:35,174 --> 00:41:36,894
循環[聽不清]？

917
00:41:36,894 --> 00:41:37,560
ANDI彭：是的。

918
00:41:37,560 --> 00:41:44,880
所以，如果我是用於：說，例如，
如果我這樣做，然後

919
00:41:44,880 --> 00:41:51,935
do-- oop--的是，在我的代碼，它會
實際上是在做喜歡同樣的事情。

920
00:41:51,935 --> 00:41:55,060
然而，這樣，大衛解釋
它講座期間，如果有的話你們

921
00:41:55,060 --> 00:41:57,854
請記住，是，由於
人類，作為程序員，

922
00:41:57,854 --> 00:42:00,270
我們真正嘗試編寫我們
代碼，使我們的電腦有

923
00:42:00,270 --> 00:42:04,070
工作盡可能小，所以
我們的代碼是非常有效的。

924
00:42:04,070 --> 00:42:06,850
>> 所以，如果我有，有，有什麼
會發生在我的for循環

925
00:42:06,850 --> 00:42:10,790
是，我想首先聲明一個
變量命名的我將是​​0。

926
00:42:10,790 --> 00:42:13,350
我要檢查一下，哦，
什麼是字的strlen的？

927
00:42:13,350 --> 00:42:15,000
哦，strlen的是3。

928
00:42:15,000 --> 00:42:16,191
那麼，我不到三？

929
00:42:16,191 --> 00:42:16,690
是的，它是。

930
00:42:16,690 --> 00:42:17,870
我要去運行。

931
00:42:17,870 --> 00:42:21,130
>> 然後將第二次回周圍
循環，我要增加我。

932
00:42:21,130 --> 00:42:22,550
我將是1。

933
00:42:22,550 --> 00:42:25,600
而我是要檢查，哦，
但什麼是字的strlen的？

934
00:42:25,600 --> 00:42:26,839
哦，這三種。

935
00:42:26,839 --> 00:42:29,880
而確實，似乎有種浪費，
每次通過循環運行時，

936
00:42:29,880 --> 00:42:33,340
要檢查的功能，
即使字的strlen

937
00:42:33,340 --> 00:42:35,490
實際上從未改變？

938
00:42:35,490 --> 00:42:38,590
>> 因此，它是額外功率的計算機。

939
00:42:38,590 --> 00:42:42,180
當你開始談論的東西
這是數十億

940
00:42:42,180 --> 00:42:44,431
與數十億的地方
長，想像一下你的電腦

941
00:42:44,431 --> 00:42:47,430
不必實際經歷和
檢查所有的，每一個時間。

942
00:42:47,430 --> 00:42:53,170
這就是為什麼，使​​剛
為求效率，

943
00:42:53,170 --> 00:42:57,620
我們往往只做到這一點，
因為這樣一來，我們只

944
00:42:57,620 --> 00:42:59,850
調用函數
一旦在開始的時候，

945
00:42:59,850 --> 00:43:01,766
並且，每一次它
經過這回事

946
00:43:01,766 --> 00:43:03,789
存儲值3
在那裡，你不

947
00:43:03,789 --> 00:43:05,330
必須不斷地檢查每一個時間。

948
00:43:05,330 --> 00:43:05,743
是啊。

949
00:43:05,743 --> 00:43:06,409
>> 聽眾：對不起。

950
00:43:06,409 --> 00:43:09,070
只是[聽不清]。

951
00:43:09,070 --> 00:43:13,985
你可以做詮釋n等於strlen的放
上面的for循環的外

952
00:43:13,985 --> 00:43:15,364
呢？

953
00:43:15,364 --> 00:43:16,030
ANDI彭：是的。

954
00:43:16,030 --> 00:43:17,100
你可以做到這一點，絕對。

955
00:43:17,100 --> 00:43:19,970
我們有它在這裡的原因是
因為for循環工作方式

956
00:43:19,970 --> 00:43:23,500
的是，它被稱為
在這個意義上局部變量

957
00:43:23,500 --> 00:43:26,150
這一切你
創建的內部進行循環

958
00:43:26,150 --> 00:43:27,890
只存在內部循環。

959
00:43:27,890 --> 00:43:31,530
>> 所以變量i僅
存在於這些括號內。

960
00:43:31,530 --> 00:43:35,260
n個而這裡的變量也
只存在於那些括號。

961
00:43:35,260 --> 00:43:39,350
所以，如果你使用的strlen的
詞多次向下跌破，

962
00:43:39,350 --> 00:43:42,230
絕對做到這一點的最好辦法
將宣布它的頂部

963
00:43:42,230 --> 00:43:43,563
所以你不必做一次。

964
00:43:43,563 --> 00:43:45,420
是啊。

965
00:43:45,420 --> 00:43:47,670
聽眾：你為什麼有
百分比後，新生產線

966
00:43:47,670 --> 00:43:51,300
看，如果你想要把所有
字母旁邊分開？

967
00:43:51,300 --> 00:43:54,140
>> ANDI彭：哦，我想
全部打印出來，每行。

968
00:43:54,140 --> 00:43:54,890
不要緊

969
00:43:54,890 --> 00:43:55,890
是的，這是一個格式。

970
00:43:55,890 --> 00:43:57,181
這是一個很好的問題，但。

971
00:43:57,181 --> 00:43:59,360
是啊，如果我想打印
這一切只有一行，

972
00:43:59,360 --> 00:44:02,731
我也不會在衝刺。

973
00:44:02,731 --> 00:44:03,230
確定。

974
00:44:03,230 --> 00:44:06,880
每個人都好？

975
00:44:06,880 --> 00:44:07,500
確定。

976
00:44:07,500 --> 00:44:08,000
酷。

977
00:44:08,000 --> 00:44:12,080

978
00:44:12,080 --> 00:44:14,750
>> 所以，我想我已經談得夠多。

979
00:44:14,750 --> 00:44:20,040
你們輪到通過運行
代碼，並告訴我什麼是錯在這裡。

980
00:44:20,040 --> 00:44:21,560
哪裡的錯誤？

981
00:44:21,560 --> 00:44:26,920
因此，大家可以看到，我已宣布
字符串類型命名為類新的數組。

982
00:44:26,920 --> 00:44:30,220
而且我已經輸入的山姆，
傑斯和金進去。

983
00:44:30,220 --> 00:44:33,400
而我試圖打印出
該陣列中的所有元素。

984
00:44:33,400 --> 00:44:36,796
誰能告訴我為什麼這個
是要給我的問題？

985
00:44:36,796 --> 00:44:39,320
我給你們10
秒去想這個。

986
00:44:39,320 --> 00:44:55,490

987
00:44:55,490 --> 00:44:56,619
>> 確定。

988
00:44:56,619 --> 00:44:57,118
是嗎？

989
00:44:57,118 --> 00:45:01,972
>> 聽眾：是左側中心
等於3或[聽不清]？

990
00:45:01,972 --> 00:45:02,680
ANDI彭：對。

991
00:45:02,680 --> 00:45:06,784
那麼有多少次是這其實
通過這個循環運行？

992
00:45:06,784 --> 00:45:07,620
>> 聽眾：四。

993
00:45:07,620 --> 00:45:08,070
>> ANDI鵬：沒錯。

994
00:45:08,070 --> 00:45:09,445
這將通過四次。

995
00:45:09,445 --> 00:45:12,250
這將貫穿
於0，1，2，和3中，

996
00:45:12,250 --> 00:45:15,200
因為他們的元素是我
小於或等於3。

997
00:45:15,200 --> 00:45:16,960
它不會停止時，它的2。

998
00:45:16,960 --> 00:45:18,800
這將繼續
走，直到它擊中3。

999
00:45:18,800 --> 00:45:21,720
正如我們所知，有只有三
在我們實際的數組元素。

1000
00:45:21,720 --> 00:45:27,260
>> 如果我們試圖訪問的第四個
元件或3的索引，

1001
00:45:27,260 --> 00:45:30,357
你會打的地方
內存中不存在。

1002
00:45:30,357 --> 00:45:31,690
這就是所謂的空終止。

1003
00:45:31,690 --> 00:45:32,856
沒有什麼是去那裡。

1004
00:45:32,856 --> 00:45:35,324
您的計算機不會
很高興和你在一起。

1005
00:45:35,324 --> 00:45:36,170
是啊。

1006
00:45:36,170 --> 00:45:38,430
有沒有人有問題
為什麼這是怎麼回事？

1007
00:45:38,430 --> 00:45:39,679
這是一個公共區域，以避免。

1008
00:45:39,679 --> 00:45:40,712
是啊。

1009
00:45:40,712 --> 00:45:45,777
>> 聽眾：難道不是第一次
滑動也有2一串？

1010
00:45:45,777 --> 00:45:46,360
ANDI彭：沒有。

1011
00:45:46,360 --> 00:45:49,610
所以基本上，當
你正在做一個數組，

1012
00:45:49,610 --> 00:45:51,540
該支架右
那裡，number--所有

1013
00:45:51,540 --> 00:45:53,480
它告訴你是怎麼
許多元素我有。

1014
00:45:53,480 --> 00:45:55,840
它實際上沒有告訴
我什麼指標。

1015
00:45:55,840 --> 00:45:58,760
因此，在這種情況下，我知道我要
與三地書寫，

1016
00:45:58,760 --> 00:46:02,690
有三個物理地方
持有任何我想要持有。

1017
00:46:02,690 --> 00:46:04,510
所以這就是為什麼數字三是存在的。

1018
00:46:04,510 --> 00:46:06,560
但是，如果我想
實際訪問它，

1019
00:46:06,560 --> 00:46:11,220
如果我想說的話，printf的
類托架號碼，然後

1020
00:46:11,220 --> 00:46:14,560
你要真正把
有物理索引。

1021
00:46:14,560 --> 00:46:16,330
是啊，好問題。

1022
00:46:16,330 --> 00:46:20,065
>> 聽眾：所以是物理
指數應該是[聽不清]？

1023
00:46:20,065 --> 00:46:20,940
ANDI彭：我很抱歉。

1024
00:46:20,940 --> 00:46:21,500
你能說了一下？

1025
00:46:21,500 --> 00:46:24,208
>> 聽眾：所以是物理指標
[聽不清]每個盒子？

1026
00:46:24,208 --> 00:46:25,260
[聽不清]？

1027
00:46:25,260 --> 00:46:26,040
>> ANDI彭：是的。

1028
00:46:26,040 --> 00:46:28,970
所以，我要回到這裡。

1029
00:46:28,970 --> 00:46:31,120
想到這裡的。

1030
00:46:31,120 --> 00:46:32,820
我們有大小3的陣列。

1031
00:46:32,820 --> 00:46:35,540
有三個地方，比如，
物理佔位符在這裡。

1032
00:46:35,540 --> 00:46:37,620
但它們命名為0，1和2。

1033
00:46:37,620 --> 00:46:40,700
所以，如果我想訪問他們，
我訪問它們的方式

1034
00:46:40,700 --> 00:46:43,480
是的printf什麼的，我想在這裡。

1035
00:46:43,480 --> 00:46:45,485
你將不得不打印
從它的名字，

1036
00:46:45,485 --> 00:46:47,610
因為這樣的計算機
知道，哦，我需要看看

1037
00:46:47,610 --> 00:46:51,391
這個數組的第0個指標。

1038
00:46:51,391 --> 00:46:51,890
是啊。

1039
00:46:51,890 --> 00:46:53,306
但它的大小不發生變化。

1040
00:46:53,306 --> 00:46:55,492
的大小是3，而不管
你如何標記他們。

1041
00:46:55,492 --> 00:46:58,321

1042
00:46:58,321 --> 00:46:58,820
確定。

1043
00:46:58,820 --> 00:47:01,387
每個人都好？

1044
00:47:01,387 --> 00:47:02,970
聽眾：所以每次我[聽不清]？

1045
00:47:02,970 --> 00:47:06,357

1046
00:47:06,357 --> 00:47:06,940
ANDI彭：OK。

1047
00:47:06,940 --> 00:47:13,270
因此，在這種情況下，我們真的不
進入它現在在課程。

1048
00:47:13,270 --> 00:47:16,760
但是要知道，像我一個string--
前面說過，一個字符串，本質上是

1049
00:47:16,760 --> 00:47:18,440
字符數組。

1050
00:47:18,440 --> 00:47:21,430
所以，如果我創建一個數組
字符串類型的，我

1051
00:47:21,430 --> 00:47:24,430
有數組的數組
字符，對不對？

1052
00:47:24,430 --> 00:47:27,720
>> 因此，在這種情況下，因為我
有一個字符串數組，

1053
00:47:27,720 --> 00:47:31,340
如果你輸入一個很長的話，
仍然只佔用一個空格，

1054
00:47:31,340 --> 00:47:33,230
因為這是一個字符串。

1055
00:47:33,230 --> 00:47:37,492
但是，如果你想
該陣列的字符，

1056
00:47:37,492 --> 00:47:40,450
那麼這是佔用了很多
字符比任何換言之

1057
00:47:40,450 --> 00:47:41,372
是。

1058
00:47:41,372 --> 00:47:42,830
沒有真正的，現在重要的。

1059
00:47:42,830 --> 00:47:44,921
但是，這只是一般
它是如何工作的。

1060
00:47:44,921 --> 00:47:49,750

1061
00:47:49,750 --> 00:47:50,560
>> 確定。

1062
00:47:50,560 --> 00:47:55,840
因此，這是我就讓你做
很多在這學期的課程。

1063
00:47:55,840 --> 00:47:57,500
我需要休息，我的聲音。

1064
00:47:57,500 --> 00:47:59,530
你們需要激勵自己。

1065
00:47:59,530 --> 00:48:02,300
很多人可能
要睡現在。

1066
00:48:02,300 --> 00:48:05,960
我輸入隨機問題
在這裡，我們為一類，或者你

1067
00:48:05,960 --> 00:48:09,480
與伴侶在你身邊會
花幾分鐘時間討論

1068
00:48:09,480 --> 00:48:14,980
關於我們如何去解決
或創建一個程序，如這一點。

1069
00:48:14,980 --> 00:48:17,100
>> 所以，現在，我們要
創建program--

1070
00:48:17,100 --> 00:48:19,560
我們要叫它
upper.c--可以轉換

1071
00:48:19,560 --> 00:48:24,787
小寫的字到上流
string--大寫，對不起。

1072
00:48:24,787 --> 00:48:26,370
詞串，對不起，是同義的。

1073
00:48:26,370 --> 00:48:28,370
我要改變他們
意味著同樣的事情。

1074
00:48:28,370 --> 00:48:32,270

1075
00:48:32,270 --> 00:48:33,499
>> 是啊。

1076
00:48:33,499 --> 00:48:34,540
就拿一兩分鐘。

1077
00:48:34,540 --> 00:48:37,130
它並不必須是
用任何語言。

1078
00:48:37,130 --> 00:48:39,890
就在偽代碼或
邏輯上我們怎麼會連

1079
00:48:39,890 --> 00:48:42,083
去這樣做這樣一個問題。

1080
00:48:42,083 --> 00:48:42,583
是啊。

1081
00:48:42,583 --> 00:48:49,881

1082
00:48:49,881 --> 00:48:52,780
>> [副會話]

1083
00:48:52,780 --> 00:49:18,680

1084
00:49:18,680 --> 00:49:22,130
>> 我還注意到，你們can--
我看到那種已經計劃。

1085
00:49:22,130 --> 00:49:24,600
我想我的缺乏
演示模式是一個問題。

1086
00:49:24,600 --> 00:49:27,410
但它的確定。

1087
00:49:27,410 --> 00:49:30,410
>> [副會話]

1088
00:49:30,410 --> 00:50:03,589

1089
00:50:03,589 --> 00:50:04,380
是的，請，伙計們。

1090
00:50:04,380 --> 00:50:05,400
來拿糖果。

1091
00:50:05,400 --> 00:50:06,372
來拿糖果。

1092
00:50:06,372 --> 00:50:07,698
>> 聽眾：是的！

1093
00:50:07,698 --> 00:50:09,958
>> [副會話]

1094
00:50:09,958 --> 00:50:16,101

1095
00:50:16,101 --> 00:50:18,100
ANDI彭：另外，是啊，
我就開始扔糖果

1096
00:50:18,100 --> 00:50:20,280
在人誰不回答問題。

1097
00:50:20,280 --> 00:50:22,260
所以，你都應該回答的問題。

1098
00:50:22,260 --> 00:50:24,895
或者，我想，人誰
不回答問題。

1099
00:50:24,895 --> 00:50:26,070
是的，周圍的其他方法。

1100
00:50:26,070 --> 00:50:28,570
>> [副會話]

1101
00:50:28,570 --> 00:51:13,399

1102
00:51:13,399 --> 00:51:14,274
聽眾：[聽不清]

1103
00:51:14,274 --> 00:51:17,300

1104
00:51:17,300 --> 00:51:18,340
>> ANDI彭：是的。

1105
00:51:18,340 --> 00:51:19,340
是啊。

1106
00:51:19,340 --> 00:51:22,840
>> [副會話]

1107
00:51:22,840 --> 00:51:40,700

1108
00:51:40,700 --> 00:51:41,590
>> 好吧，伙計們。

1109
00:51:41,590 --> 00:51:44,731
就拿一樣，10多秒。

1110
00:51:44,731 --> 00:51:48,210
>> [副會話]

1111
00:51:48,210 --> 00:52:10,600

1112
00:52:10,600 --> 00:52:11,750
>> OK，伙計們。

1113
00:52:11,750 --> 00:52:14,920
因此，我們開始嘗試之前，
實際的物理寫代碼，

1114
00:52:14,920 --> 00:52:20,650
一個好習慣培養的是，
我們希望第一種原因

1115
00:52:20,650 --> 00:52:22,737
從邏輯上我們將如何做到這一點。

1116
00:52:22,737 --> 00:52:24,570
你要確保，
在你身體

1117
00:52:24,570 --> 00:52:27,210
開始嘗試編寫
在馬里奧，你做

1118
00:52:27,210 --> 00:52:28,870
確保你有你的偽代碼。

1119
00:52:28,870 --> 00:52:31,235
這是帶你通過
你需要創建這樣

1120
00:52:31,235 --> 00:52:33,360
即，物理當你
後來編寫程序，

1121
00:52:33,360 --> 00:52:36,640
你能夠更好地捕捉錯誤
在你的代碼之類的東西。

1122
00:52:36,640 --> 00:52:40,460
>> 所以，我們要剛開始
by--在英語中，偽代碼，

1123
00:52:40,460 --> 00:52:43,320
沒有人想給
我一個通用的解釋

1124
00:52:43,320 --> 00:52:46,250
我們如何會去這樣做呢？

1125
00:52:46,250 --> 00:52:48,102
是啊。

1126
00:52:48,102 --> 00:52:49,664
>> 聽眾：[聽不清]。

1127
00:52:49,664 --> 00:52:50,830
ANDI彭：當然，沒有後顧之憂。

1128
00:52:50,830 --> 00:52:57,233
聽眾：你可以問它還是問
有人拿到字符串1--是啊，串，

1129
00:52:57,233 --> 00:52:58,160
和then--

1130
00:52:58,160 --> 00:52:59,826
>> ANDI彭：是的，所以這是一個良好的開端。

1131
00:52:59,826 --> 00:53:01,972
我將開始打字，對不起，因為你說話。

1132
00:53:01,972 --> 00:53:02,471
So--

1133
00:53:02,471 --> 00:53:05,698
>> 聽眾：--the小寫
數字是更高的，對不對？

1134
00:53:05,698 --> 00:53:08,519
還是小寫字母
有高的數字？

1135
00:53:08,519 --> 00:53:09,310
ANDI鵬：沒錯。

1136
00:53:09,310 --> 00:53:16,156
聽眾：那麼接下來我們減去
32從什麼[聽不清]。

1137
00:53:16,156 --> 00:53:28,600

1138
00:53:28,600 --> 00:53:29,870
>> ANDI彭：太好了。

1139
00:53:29,870 --> 00:53:35,020
所以，我們種得一般意義
如何工作這個問題。

1140
00:53:35,020 --> 00:53:40,060
知道那種我們學到
物理方式串

1141
00:53:40,060 --> 00:53:43,320
被存儲在存儲器，
你是什​​麼已經

1142
00:53:43,320 --> 00:53:45,920
知道你要大概
要在你的代碼編寫

1143
00:53:45,920 --> 00:53:48,288
以移動通過字符串？

1144
00:53:48,288 --> 00:53:49,259
>> 顧客：循環。

1145
00:53:49,259 --> 00:53:50,550
ANDI彭：一種循環，沒錯。

1146
00:53:50,550 --> 00:53:56,540

1147
00:53:56,540 --> 00:53:57,220
太好了。

1148
00:53:57,220 --> 00:54:00,539
所以，我們種有一個通用的
偽代碼寫下來

1149
00:54:00,539 --> 00:54:02,330
那種是給
你注意到你如何

1150
00:54:02,330 --> 00:54:03,900
會動一下解決問題。

1151
00:54:03,900 --> 00:54:06,150
現在，你有這個，你
可以參考它以後

1152
00:54:06,150 --> 00:54:08,233
當你試圖對
實際上編寫代碼。

1153
00:54:08,233 --> 00:54:10,240
所以，我們實際上可以去這裡。

1154
00:54:10,240 --> 00:54:25,130
而且我有一個調用的函數upper.c--
那裡is--只是一個空白模板

1155
00:54:25,130 --> 00:54:28,510
現在，你們要
幫我找出如何寫

1156
00:54:28,510 --> 00:54:30,430
這行代碼 - 不是代碼行。

1157
00:54:30,430 --> 00:54:32,890
這將是多行代碼。

1158
00:54:32,890 --> 00:54:35,710
>> 當啟動任何形式
空白PSET的，什麼是

1159
00:54:35,710 --> 00:54:37,418
我需要的第一件事
記得嗎？

1160
00:54:37,418 --> 00:54:39,290
>> 聽眾：[聽不清]。

1161
00:54:39,290 --> 00:54:41,000
>> ANDI彭：大是的。

1162
00:54:41,000 --> 00:54:41,500
包括。

1163
00:54:41,500 --> 00:54:44,850

1164
00:54:44,850 --> 00:54:47,130
stdio.h中。

1165
00:54:47,130 --> 00:54:49,640
通常情況下，這是一個
最易犯的錯誤

1166
00:54:49,640 --> 00:54:51,598
將當他們
寫作，是，他們將

1167
00:54:51,598 --> 00:54:54,180
忘了包括
他們需要的重要的圖書館。

1168
00:54:54,180 --> 00:54:57,689
所以，如果是上班時間，你就會說：
我不知道為什麼我的代碼不能正常工作。

1169
00:54:57,689 --> 00:54:59,230
你能告訴我，為什麼它不工作？

1170
00:54:59,230 --> 00:55:00,730
我們會說你＃包括？

1171
00:55:00,730 --> 00:55:02,520
你應該＃包含它。

1172
00:55:02,520 --> 00:55:03,270
確定。

1173
00:55:03,270 --> 00:55:07,230
>> 因此，我們已經得到了標準I / O位置。

1174
00:55:07,230 --> 00:55:10,740
這是唯一的圖書館
我們要在這裡需要什麼？

1175
00:55:10,740 --> 00:55:12,681
還有什麼是我們該怎麼辦？

1176
00:55:12,681 --> 00:55:13,180
抱歉。

1177
00:55:13,180 --> 00:55:14,562
剛才有人尖叫出來？

1178
00:55:14,562 --> 00:55:15,666
>> 聽眾：[聽不清]。

1179
00:55:15,666 --> 00:55:16,666
ANDI彭：你去那裡。

1180
00:55:16,666 --> 00:55:20,320

1181
00:55:20,320 --> 00:55:21,440
確定。

1182
00:55:21,440 --> 00:55:26,070
以及如何著手開始任何形式
的功能，任何類型的主要功能的

1183
00:55:26,070 --> 00:55:28,760
在我們的計劃？

1184
00:55:28,760 --> 00:55:30,020
詮釋為主。

1185
00:55:30,020 --> 00:55:34,531

1186
00:55:34,531 --> 00:55:35,030
確定。

1187
00:55:35,030 --> 00:55:35,970
我怎麼把裡面嗎？

1188
00:55:35,970 --> 00:55:37,640
什麼是你想要做的第一件事情？

1189
00:55:37,640 --> 00:55:39,910
如果我們想獲得一個
來自用戶的字符串，

1190
00:55:39,910 --> 00:55:43,870
什麼是我們將會有
做這一行頭？

1191
00:55:43,870 --> 00:55:46,120
對不起，你們只是覺得
自由發言和響亮。

1192
00:55:46,120 --> 00:55:47,123
剛喊出來什麼的。

1193
00:55:47,123 --> 00:55:48,772
>> 聽眾：詢問用戶？

1194
00:55:48,772 --> 00:55:49,980
ANDI彭：我們怎麼做呢？

1195
00:55:49,980 --> 00:55:51,873
Ask--我是要輸入“詢問用戶”？

1196
00:55:51,873 --> 00:55:52,600
>> 聽眾：printf的。

1197
00:55:52,600 --> 00:55:54,341
>> ANDI彭：OK。

1198
00:55:54,341 --> 00:55:54,840
PRINTF。

1199
00:55:54,840 --> 00:55:57,372
我想要什麼的printf？

1200
00:55:57,372 --> 00:55:58,776
>> 聽眾：在什麼類型。

1201
00:55:58,776 --> 00:56:02,760

1202
00:56:02,760 --> 00:56:03,840
>> ANDI彭：這樣呢？

1203
00:56:03,840 --> 00:56:05,430
伙計們，假裝我是一台電腦。

1204
00:56:05,430 --> 00:56:08,475
物理告訴我的每一步
我需要在這裡輸入？

1205
00:56:08,475 --> 00:56:09,600
難道我做錯了什麼？

1206
00:56:09,600 --> 00:56:10,743
我應該已經輸入的東西嗎？

1207
00:56:10,743 --> 00:56:11,690
>> 聽眾：你需要引號。

1208
00:56:11,690 --> 00:56:12,380
>> ANDI彭：我需要報價？

1209
00:56:12,380 --> 00:56:12,880
確定。

1210
00:56:12,880 --> 00:56:15,520

1211
00:56:15,520 --> 00:56:16,297
確定。

1212
00:56:16,297 --> 00:56:17,698
>> 聽眾：然後，新的生產線。

1213
00:56:17,698 --> 00:56:21,434

1214
00:56:21,434 --> 00:56:22,465
分號。

1215
00:56:22,465 --> 00:56:23,340
ANDI彭：分號？

1216
00:56:23,340 --> 00:56:24,060
確定。

1217
00:56:24,060 --> 00:56:24,560
好。

1218
00:56:24,560 --> 00:56:27,060
>> 聽眾：也許指定
你想在小寫？

1219
00:56:27,060 --> 00:56:30,120

1220
00:56:30,120 --> 00:56:31,415
>> ANDI彭：太好了。

1221
00:56:31,415 --> 00:56:33,540
你們笑我
忘了把一個分號。

1222
00:56:33,540 --> 00:56:36,350
我在某處向你保證
在這個類的過程中，

1223
00:56:36,350 --> 00:56:38,260
你會忘了把
分號，和它

1224
00:56:38,260 --> 00:56:41,116
將帶你三個小時圖
為什麼你的代碼不能正常工作。

1225
00:56:41,116 --> 00:56:42,240
這是發生在我們所有人。

1226
00:56:42,240 --> 00:56:43,950
它可能會發生在你身上。

1227
00:56:43,950 --> 00:56:46,352
獲取使用分號的好習慣。

1228
00:56:46,352 --> 00:56:46,852
確定。

1229
00:56:46,852 --> 00:56:49,010
>> 聽眾：你想
做的反斜線？

1230
00:56:49,010 --> 00:56:50,398
>> ANDI彭：當然。

1231
00:56:50,398 --> 00:56:51,856
你想要做的反斜線？

1232
00:56:51,856 --> 00:56:53,020
>> 聽眾：是的。

1233
00:56:53,020 --> 00:56:54,330
>> ANDI彭：太好了。

1234
00:56:54,330 --> 00:56:54,830
確定。

1235
00:56:54,830 --> 00:56:57,872
我該怎麼辦？

1236
00:56:57,872 --> 00:56:58,964
>> 聽眾：獲取字符串。

1237
00:56:58,964 --> 00:56:59,880
ANDI彭：獲取字符串。

1238
00:56:59,880 --> 00:57:03,080

1239
00:57:03,080 --> 00:57:03,830
所以，我該怎麼輸入？

1240
00:57:03,830 --> 00:57:04,233
有人？

1241
00:57:04,233 --> 00:57:05,040
>> 聽眾：的String。

1242
00:57:05,040 --> 00:57:05,873
>> ANDI彭：的String。

1243
00:57:05,873 --> 00:57:07,251
聽眾：GetString的。

1244
00:57:07,251 --> 00:57:09,000
ANDI鵬：一個人，
你能告訴我在哪裡

1245
00:57:09,000 --> 00:57:12,000
此功能的GetString是哪裡來的？

1246
00:57:12,000 --> 00:57:13,660
>> 聽眾：STRING.H。

1247
00:57:13,660 --> 00:57:15,256
>> ANDI彭：STRING.H？

1248
00:57:15,256 --> 00:57:16,715
你認為這是從string.h中？

1249
00:57:16,715 --> 00:57:17,830
>> 聽眾：[聽不清]。

1250
00:57:17,830 --> 00:57:18,830
>> ANDI彭：你去那裡。

1251
00:57:18,830 --> 00:57:21,280
這是一個從CS50.h.

1252
00:57:21,280 --> 00:57:24,530
如果你總是困惑於其中
庫文件或頭文件，

1253
00:57:24,530 --> 00:57:28,450
谷歌從字面上STRING.H，
我會告訴你

1254
00:57:28,450 --> 00:57:30,450
什麼是所有的功能
這是string.h中。

1255
00:57:30,450 --> 00:57:31,340
確定。

1256
00:57:31,340 --> 00:57:35,210
>> 所以，現在，我已經創建了一個字符串
而我已經提示用戶輸入它，

1257
00:57:35,210 --> 00:57:38,770
我存儲在一個變量
命名為S，我該怎麼現在需要做的？

1258
00:57:38,770 --> 00:57:40,652
>> 聽眾：檢查，如果是小寫。

1259
00:57:40,652 --> 00:57:41,360
ANDI彭：對不起？

1260
00:57:41,360 --> 00:57:42,545
聽眾：檢查，如果是小寫。

1261
00:57:42,545 --> 00:57:44,045
ANDI鵬：好吧，讓我們做到這一點。

1262
00:57:44,045 --> 00:57:45,857
我該怎麼辦呢？

1263
00:57:45,857 --> 00:57:47,940
實際上，為的宗旨
眼下之類的，

1264
00:57:47,940 --> 00:57:50,330
我們只是要
假設一切

1265
00:57:50,330 --> 00:57:52,620
我們投入已經是小寫。

1266
00:57:52,620 --> 00:57:55,430
如果你想檢查一下，你會
只需添加一個條件語句

1267
00:57:55,430 --> 00:57:59,640
該檢查，該貫穿
每一個數組元素

1268
00:57:59,640 --> 00:58:02,540
並檢查它是否
一定值之間。

1269
00:58:02,540 --> 00:58:05,627
我忘了是什麼數
小寫的值都是。

1270
00:58:05,627 --> 00:58:07,210
你可以看看它的ASCII表。

1271
00:58:07,210 --> 00:58:08,800
但是，是的，這是一個非常好的點。

1272
00:58:08,800 --> 00:58:11,758
但是現在，我們只是要
假設所有的字符串，我們輸入

1273
00:58:11,758 --> 00:58:13,130
是小寫。

1274
00:58:13,130 --> 00:58:13,870
確定。

1275
00:58:13,870 --> 00:58:18,069
>> 所以，我怎麼會去
這個問題下一個？

1276
00:58:18,069 --> 00:58:18,860
顧客：循環。

1277
00:58:18,860 --> 00:58:19,340
ANDI彭：For循環？

1278
00:58:19,340 --> 00:58:19,839
確定。

1279
00:58:19,839 --> 00:58:20,847
告訴我什麼類型。

1280
00:58:20,847 --> 00:58:25,230
>> 顧客：INT I等於0。

1281
00:58:25,230 --> 00:58:27,230
>> ANDI彭：OK。

1282
00:58:27,230 --> 00:58:36,350
>> 聽眾：呵呵，其實，那你
做一個逗號，做N等於strlen的。

1283
00:58:36,350 --> 00:58:38,940
>> ANDI彭：那麼重要的事
我認為她在這裡發現

1284
00:58:38,940 --> 00:58:42,936
是，我們沒得說INT
n向第一次，我們這樣做。

1285
00:58:42,936 --> 00:58:45,060
要知道，在一個為
當你聲明循環，

1286
00:58:45,060 --> 00:58:47,934
你其實並不需要的INT
第二次你做一個變量。

1287
00:58:47,934 --> 00:58:51,202
你可以說ñstrlen的。

1288
00:58:51,202 --> 00:58:52,620
>> 第：受眾。

1289
00:58:52,620 --> 00:58:53,510
>> ANDI彭：秒。

1290
00:58:53,510 --> 00:58:54,706
確定。

1291
00:58:54,706 --> 00:58:58,370
>> 聽眾：然後一個分號。

1292
00:58:58,370 --> 00:59:00,130
>> ANDI彭：當然。

1293
00:59:00,130 --> 00:59:04,050
>> 聽眾：然後[聽不清] n的。

1294
00:59:04,050 --> 00:59:07,480

1295
00:59:07,480 --> 00:59:09,460
然後我++。

1296
00:59:09,460 --> 00:59:11,780
>> ANDI彭：太好了。

1297
00:59:11,780 --> 00:59:12,280
好的。

1298
00:59:12,280 --> 00:59:14,690
我們想要什麼內
本作目前循環？

1299
00:59:14,690 --> 00:59:17,820
請記住，如果我們要貫穿
一個串並通過陣列上運行，

1300
00:59:17,820 --> 00:59:19,287
我們要檢查的東西在裡面。

1301
00:59:19,287 --> 00:59:20,370
什麼是我們將需要？

1302
00:59:20,370 --> 00:59:23,070

1303
00:59:23,070 --> 00:59:26,900
這是一種棘手的部分現在。

1304
00:59:26,900 --> 00:59:27,960
任何人都有一個猜測？

1305
00:59:27,960 --> 00:59:34,160

1306
00:59:34,160 --> 00:59:34,690
>> 確定。

1307
00:59:34,690 --> 00:59:37,830
因此，首先，我們怎麼連上網？

1308
00:59:37,830 --> 00:59:41,610
我們怎麼連第一次檢查或
訪問數組中的元素？

1309
00:59:41,610 --> 00:59:42,920
我們該怎麼做呢？

1310
00:59:42,920 --> 00:59:47,120
什麼是我們用來做記號？

1311
00:59:47,120 --> 00:59:50,920
這是什麼陣的名字叫什麼？

1312
00:59:50,920 --> 00:59:52,400
這就是所謂的S，對吧？

1313
00:59:52,400 --> 00:59:54,850
>> 請記住，任何字符串始終是一個數組。

1314
00:59:54,850 --> 00:59:58,210
所以小號支架我，對吧？

1315
00:59:58,210 --> 01:00:01,360
因為，它是當前值
或索引值，我們正在檢查。

1316
01:00:01,360 --> 01:00:05,156
而且我們要設置相同
用於：我們希望有一個小寫的價值，對不對？

1317
01:00:05,156 --> 01:00:07,530
我們希望把這一lower--
對不起，我們希望有一個大寫字母。

1318
01:00:07,530 --> 01:00:10,014
我們想將小寫
值轉換為大寫。

1319
01:00:10,014 --> 01:00:11,805
所以like--我很抱歉，
你叫什麼名字？

1320
01:00:11,805 --> 01:00:12,580
>> 聽眾：海蒂。

1321
01:00:12,580 --> 01:00:12,940
>> ANDI彭：對不起？

1322
01:00:12,940 --> 01:00:13,280
>> 聽眾：海蒂。

1323
01:00:13,280 --> 01:00:13,988
>> ANDI彭：海蒂。

1324
01:00:13,988 --> 01:00:15,850
就像海蒂說，
最初，我們可能

1325
01:00:15,850 --> 01:00:20,330
將需要the--我們
可能將不得不減去

1326
01:00:20,330 --> 01:00:22,630
32無論從任何charc也就是說，對吧？

1327
01:00:22,630 --> 01:00:24,680
因為在ASCII
表，所不同的

1328
01:00:24,680 --> 01:00:27,790
小寫字母之間
和大寫字母為32。

1329
01:00:27,790 --> 01:00:31,290
所以，當我們這樣做，我們可能
將要減去32，對不對？

1330
01:00:31,290 --> 01:00:33,910
>> 所以，我們要做的I。

1331
01:00:33,910 --> 01:00:37,590

1332
01:00:37,590 --> 01:00:41,200
大家是否明白我為什麼這樣做？

1333
01:00:41,200 --> 01:00:45,760
因為現在，在我們的數組，
我們正在檢查第0個指標，對不對？

1334
01:00:45,760 --> 01:00:49,190
和在的第0索引
字符串，這是第一個字符。

1335
01:00:49,190 --> 01:00:51,820
而這個角色，我們要去
假設它是小寫。

1336
01:00:51,820 --> 01:00:55,980
如果我們要使它大寫，我們
必須減去32從它的價值，

1337
01:00:55,980 --> 01:00:58,620
因為在我們的ASCII
表，這就是我們如何把它

1338
01:00:58,620 --> 01:01:01,600
到下一個相應的
值，這使得它大寫。

1339
01:01:01,600 --> 01:01:03,714
大家是否明白了嗎？

1340
01:01:03,714 --> 01:01:04,213
是啊。

1341
01:01:04,213 --> 01:01:06,530
>> 聽眾：你能不能
做一個小寫minus--

1342
01:01:06,530 --> 01:01:08,080
>> ANDI彭：是啊，所以這是
居然真的不錯。

1343
01:01:08,080 --> 01:01:10,455
我會回來的
問題，我們這樣做之後。

1344
01:01:10,455 --> 01:01:11,060
是啊。

1345
01:01:11,060 --> 01:01:13,940
然後，如果我想
看看這是怎麼回事，

1346
01:01:13,940 --> 01:01:16,180
我可能會
要打印，對吧？

1347
01:01:16,180 --> 01:01:19,930
有人告訴我是什麼
我想在這裡打印。

1348
01:01:19,930 --> 01:01:29,160
>> 聽眾：printf的百分比
Ç反斜杠[聽不清]。

1349
01:01:29,160 --> 01:01:33,570
這是[聽不清]的I值。

1350
01:01:33,570 --> 01:01:34,614
>> ANDI彭：■我，對不起？

1351
01:01:34,614 --> 01:01:35,530
聽眾：[聽不清]。

1352
01:01:35,530 --> 01:01:38,550

1353
01:01:38,550 --> 01:01:39,550
ANDI彭：我不知道。

1354
01:01:39,550 --> 01:01:40,600
你怎麼看？

1355
01:01:40,600 --> 01:01:44,016
>> 聽眾：嗯，我wouldn't--
我想我不會bring--

1356
01:01:44,016 --> 01:01:46,944
我把它拿出來
在裡面，因為[聽不清]。

1357
01:01:46,944 --> 01:01:49,726

1358
01:01:49,726 --> 01:01:51,392
ANDI彭：哦，你會做嗎？

1359
01:01:51,392 --> 01:01:53,867
聽眾：是的。

1360
01:01:53,867 --> 01:01:56,700
ANDI彭：讓我們離開的方式
是的，為什麼我稍後會解釋。

1361
01:01:56,700 --> 01:01:58,533
請記住，即使你
有一個佔位符，

1362
01:01:58,533 --> 01:02:00,701
你想要把括號它。

1363
01:02:00,701 --> 01:02:01,200
好的。

1364
01:02:01,200 --> 01:02:04,810
因此，這應該在這裡是一個堅實的功能。

1365
01:02:04,810 --> 01:02:06,370
讓我們來運行它，看看它是否編譯。

1366
01:02:06,370 --> 01:02:08,750
製作上。

1367
01:02:08,750 --> 01:02:09,250
嗯，哦。

1368
01:02:09,250 --> 01:02:12,030

1369
01:02:12,030 --> 01:02:13,340
這看起來並不太好。

1370
01:02:13,340 --> 01:02:14,507
這究竟是為什麼？

1371
01:02:14,507 --> 01:02:17,340
對於任何錯誤，你想要去的
背部，並開始與第一位的，

1372
01:02:17,340 --> 01:02:20,630
因為通常是一個錯誤的原因
大量的後其他錯誤。

1373
01:02:20,630 --> 01:02:26,700
在這裡，我們看到upper.c：18：25，它告訴
我這個計劃命名為upper.c，

1374
01:02:26,700 --> 01:02:33,800
在第18行，錯誤隱式聲明
函數庫strlen的類型

1375
01:02:33,800 --> 01:02:36,330
unassigned--胡說，我不知道
在那之後發生了什麼事情。

1376
01:02:36,330 --> 01:02:39,990
>> 所有它告訴我現在是
這東西是怎麼回事strlen的。

1377
01:02:39,990 --> 01:02:43,520
和計算機的困惑，因為
這就像，我不知道是什麼strlen的是？

1378
01:02:43,520 --> 01:02:45,520
什麼是可能
告訴你，你錯過？

1379
01:02:45,520 --> 01:02:46,490
>> 聽眾：你錯過了[聽不清]。

1380
01:02:46,490 --> 01:02:47,630
>> ANDI彭：你說得對。

1381
01:02:47,630 --> 01:02:49,510
沒錯。

1382
01:02:49,510 --> 01:02:52,140
因此，這是它的
重要的是要確保

1383
01:02:52,140 --> 01:02:56,970
您在使用每個功能的
碼為具有正確的標題

1384
01:02:56,970 --> 01:02:59,660
文件的庫，要不然
你會得到很多的錯誤

1385
01:02:59,660 --> 01:03:01,150
和你的代碼是不會
要知道這是怎麼回事。

1386
01:03:01,150 --> 01:03:03,050
因此，我們要在這裡包括string.h中。

1387
01:03:03,050 --> 01:03:06,270
>> 現在，當我們嘗試編譯上。

1388
01:03:06,270 --> 01:03:08,410
編譯正常。

1389
01:03:08,410 --> 01:03:09,960
讓我們來運行這個程序。

1390
01:03:09,960 --> 01:03:12,000
因此，輸入一些小寫。

1391
01:03:12,000 --> 01:03:14,920
你們有什麼要鍵入？

1392
01:03:14,920 --> 01:03:16,546
喊出來的東西。

1393
01:03:16,546 --> 01:03:17,920
好吧，查理只是走了進來。

1394
01:03:17,920 --> 01:03:18,990
我們鍵入查理的名字。

1395
01:03:18,990 --> 01:03:21,670

1396
01:03:21,670 --> 01:03:22,840
>> 查理小寫。

1397
01:03:22,840 --> 01:03:27,742
並希望，有希望，這是
要喊出來，並吐出

1398
01:03:27,742 --> 01:03:28,575
查理大寫。

1399
01:03:28,575 --> 01:03:30,830
耶！

1400
01:03:30,830 --> 01:03:33,430
大家都知道如何
我去著手解決呢？

1401
01:03:33,430 --> 01:03:36,190
的方式，我可以
操作使用整數

1402
01:03:36,190 --> 01:03:39,410
解決的東西，
我想在字符串，

1403
01:03:39,410 --> 01:03:44,390
因為字符和整數能
以同樣的方式，因為進行引用

1404
01:03:44,390 --> 01:03:45,540
ASCII碼的映射。

1405
01:03:45,540 --> 01:03:52,890
>> 所以回到你的問題，如果我
希望把32個位置，而不是

1406
01:03:52,890 --> 01:03:58,959
大寫字母A減去小寫一個活脫脫
即，將工作同樣為好，

1407
01:03:58,959 --> 01:04:01,750
因為這只是簡單的
這兩個值之間的差異。

1408
01:04:01,750 --> 01:04:09,570
如果我想使這個again--查理。

1409
01:04:09,570 --> 01:04:10,320
哦，不。

1410
01:04:10,320 --> 01:04:11,820
我想我們走錯了路，是嗎？

1411
01:04:11,820 --> 01:04:13,260
>> 聽眾：[聽不清]小寫。

1412
01:04:13,260 --> 01:04:14,260
>> ANDI彭：你去那裡。

1413
01:04:14,260 --> 01:04:22,380

1414
01:04:22,380 --> 01:04:22,880
是的。

1415
01:04:22,880 --> 01:04:24,920
進出吐查理。

1416
01:04:24,920 --> 01:04:28,020
所以，要小心
你減去值

1417
01:04:28,020 --> 01:04:30,400
要記住哪一個是
比其它更大。

1418
01:04:30,400 --> 01:04:35,220
例如，在這裡我忘了
這小寫實際上是

1419
01:04:35,220 --> 01:04:38,540
大於大寫字母A.所以，當我
試圖減去它們的其他方式

1420
01:04:38,540 --> 01:04:40,600
的時候，我得到了負32。

1421
01:04:40,600 --> 01:04:42,800
而我的電腦很喜歡，
我不知道那是什麼。

1422
01:04:42,800 --> 01:04:45,810
這可能只是一些隨意
值不是很好。

1423
01:04:45,810 --> 01:04:48,760
所以請確保你
減去在正確的長度

1424
01:04:48,760 --> 01:04:52,831
找到你想要的字符。

1425
01:04:52,831 --> 01:04:53,330
確定。

1426
01:04:53,330 --> 01:04:58,550
有沒有人困惑於我們如何
走遍寫這個功能呢？

1427
01:04:58,550 --> 01:04:59,180
確定。

1428
01:04:59,180 --> 01:05:04,830
所以實際上，功能已經
存在於庫調用文件ctype.h。

1429
01:05:04,830 --> 01:05:06,417
圖書館的所謂文件ctype.h。

1430
01:05:06,417 --> 01:05:08,500
這個功能其實是
你已經寫。

1431
01:05:08,500 --> 01:05:10,820
這就是所謂的要高。

1432
01:05:10,820 --> 01:05:13,027
>> 所以，為便於
這PSET，你會

1433
01:05:13,027 --> 01:05:15,860
找到你真的要使用
包含了很多功能

1434
01:05:15,860 --> 01:05:17,390
內CTYPE的庫。

1435
01:05:17,390 --> 01:05:21,040
要上，為了降低，是上，是
lower--這些都是功能

1436
01:05:21,040 --> 01:05:24,914
你將能夠非常使用，
很快在自己的代碼，

1437
01:05:24,914 --> 01:05:26,080
不正是這樣做。

1438
01:05:26,080 --> 01:05:28,941
我們寫了如何轉換
一個字符串為大寫。

1439
01:05:28,941 --> 01:05:31,440
但其實這是代碼
是別人寫

1440
01:05:31,440 --> 01:05:33,800
並且您可以訪問
經由不同的功能。

1441
01:05:33,800 --> 01:05:34,300
是嗎？

1442
01:05:34,300 --> 01:05:39,570
>> 聽眾：所以你剛才複製的在那裡
而做到這一點的每一個字母？

1443
01:05:39,570 --> 01:05:42,070
>> ANDI彭：是的，因為我不知道
關心的一個的值。

1444
01:05:42,070 --> 01:05:44,540
我只是關心的差異
他們之間是32，對吧？

1445
01:05:44,540 --> 01:05:48,210
小寫之間的差
b和大寫B也32。

1446
01:05:48,210 --> 01:05:50,860
和c之間的差
和大寫C是永遠32。

1447
01:05:50,860 --> 01:05:53,235
>> 我只需要關心
兩者之間的差異，

1448
01:05:53,235 --> 01:05:56,666
因為所有的字母
遵循相同的模式，對不對？

1449
01:05:56,666 --> 01:05:58,540
如果我有差異
它們中的一個之間，

1450
01:05:58,540 --> 01:06:01,050
我知道有什麼區別
所有的人之間。

1451
01:06:01,050 --> 01:06:01,740
好問題。

1452
01:06:01,740 --> 01:06:04,090
是啊。

1453
01:06:04,090 --> 01:06:06,660
每個人都好？

1454
01:06:06,660 --> 01:06:09,080
確定。

1455
01:06:09,080 --> 01:06:09,580
空中接力。

1456
01:06:09,580 --> 01:06:14,380

1457
01:06:14,380 --> 01:06:15,270
>> 確定。

1458
01:06:15,270 --> 01:06:20,310
因此，另一種概念，是
會是你非常有用

1459
01:06:20,310 --> 01:06:22,570
繼續發展
你的代碼是這樣的想法

1460
01:06:22,570 --> 01:06:25,430
對創建函數或抽象。

1461
01:06:25,430 --> 01:06:28,479
所以，現在，我們都採取了代數。

1462
01:06:28,479 --> 01:06:31,770
在代數中，你被教導，有
這個奇妙的東西叫做功能

1463
01:06:31,770 --> 01:06:35,300
機，在那裡，如果你
輸入某種類型數量，

1464
01:06:35,300 --> 01:06:38,720
它貫穿這個美妙的功能
進出彈出不同的輸出，對不對？

1465
01:06:38,720 --> 01:06:42,220
在代碼中，同樣的事情發生
在任何類型的功能。

1466
01:06:42,220 --> 01:06:48,230
>> 所以我可以物理
寫在我的我的代碼的身體

1467
01:06:48,230 --> 01:06:52,357
實際上做了主要發言
任何代碼的身體在做什麼。

1468
01:06:52,357 --> 01:06:54,940
但是，這以外，我還可以
寫了許多不同的功能

1469
01:06:54,940 --> 01:06:56,320
是做許多不同的事情。

1470
01:06:56,320 --> 01:06:58,570
例如，我們已把
開始使用其中的一些。

1471
01:06:58,570 --> 01:07:00,610
Printf--這是一個
功能別人

1472
01:07:00,610 --> 01:07:02,870
已經寫了
我們可以在代碼中調用。

1473
01:07:02,870 --> 01:07:05,410
到upper--在這種情況下，
upper--是另一個函數

1474
01:07:05,410 --> 01:07:07,330
我們已經寫了我們
可以在我們的代碼中調用。

1475
01:07:07,330 --> 01:07:09,520
所以我想，為什麼
我們甚至有功能呢？

1476
01:07:09,520 --> 01:07:12,100
為什麼我們不只是放下它
所有在相同的代碼行？

1477
01:07:12,100 --> 01:07:13,730
這很容易讓每一個人。

1478
01:07:13,730 --> 01:07:19,200
>> 好了，背後的理由
是，第一個組織的全部。

1479
01:07:19,200 --> 01:07:21,880
這真是煩人會
通過別人的代碼

1480
01:07:21,880 --> 01:07:25,110
和一個功能如printf。

1481
01:07:25,110 --> 01:07:28,570
如果你們真正知道什麼是
函數printf entailed寫，

1482
01:07:28,570 --> 01:07:30,530
它的一樣，1000行代碼。

1483
01:07:30,530 --> 01:07:32,357
>> 如果每次我需要時間
對printf的東西，

1484
01:07:32,357 --> 01:07:35,440
我不得不寫1000行代碼，
這將是非常惱人的閱讀，

1485
01:07:35,440 --> 01:07:36,290
對不對？

1486
01:07:36,290 --> 01:07:38,860
這就是為什麼我們剛剛
創建這個抽象函數

1487
01:07:38,860 --> 01:07:41,670
我們已經有人
別人寫了別的地方。

1488
01:07:41,670 --> 01:07:44,920
而每一次，我們需要使用它的
我們的代碼，我們只是說printf的。

1489
01:07:44,920 --> 01:07:48,070
並且，能夠使用該功能
別人已經寫在我們的代碼。

1490
01:07:48,070 --> 01:07:51,020
這使得它更容易
組織上讀取的代碼。

1491
01:07:51,020 --> 01:07:53,460
>> 其次，它的簡化。

1492
01:07:53,460 --> 01:07:56,750
它簡化了我們有以下步驟：
拿地解決我們的問題。

1493
01:07:56,750 --> 01:07:59,300
PRINTF，如printf函數，
喜歡上的功能

1494
01:07:59,300 --> 01:08:03,560
是所有的東西，使我們能夠
簡化了我們的代碼下來，以便更容易。

1495
01:08:03,560 --> 01:08:05,830
而最後一件事是可重用性。

1496
01:08:05,830 --> 01:08:08,710
>> 因此，事實上，我們有
一個函數調用的printf

1497
01:08:08,710 --> 01:08:11,990
我們可以調用許多不同的
倍，並允許它可重複使用。

1498
01:08:11,990 --> 01:08:14,980
如果我寫的printf，
我只有一次它寫。

1499
01:08:14,980 --> 01:08:16,439
它存在僅在該一個位置。

1500
01:08:16,439 --> 01:08:19,890
如果我想再做一次，我會
要複製並粘貼了這一切

1501
01:08:19,890 --> 01:08:21,760
進入代碼我的第二個行。

1502
01:08:21,760 --> 01:08:24,880
這就是為什麼如果我們創建了一個功能
存在我們的主要之外，

1503
01:08:24,880 --> 01:08:26,880
我們只能呼籲
它並重複使用它時，

1504
01:08:26,880 --> 01:08:29,604
我們需要這樣它是一個更容易
我們作為程序來寫。

1505
01:08:29,604 --> 01:08:32,220

1506
01:08:32,220 --> 01:08:35,549
>> 所以這樣，我們實際上寫
一個功能很相似，對不對？

1507
01:08:35,549 --> 01:08:37,590
這是一種第一
比如在我們將

1508
01:08:37,590 --> 01:08:42,830
看到一個風格的函數取
不同於我們INT主要無效。

1509
01:08:42,830 --> 01:08:46,779
在這種情況下，如果我想
寫一個名為Q函數，對不對？

1510
01:08:46,779 --> 01:08:49,370
>> 而這裡的int值
在所有的告訴我，

1511
01:08:49,370 --> 01:08:51,649
我該怎麼想這個
函數返回我嗎？

1512
01:08:51,649 --> 01:08:54,484
如果我想立方體的整數，
我將要輸入。

1513
01:08:54,484 --> 01:08:55,525
這些是參數。

1514
01:08:55,525 --> 01:08:58,490
我要輸入一個int類型的值。

1515
01:08:58,490 --> 01:09:01,300
而我要回報
整型另一種類型的值。

1516
01:09:01,300 --> 01:09:03,050
而在這裡，你
可以看到，所有的我做

1517
01:09:03,050 --> 01:09:07,300
在多維數據不管我輸入
作為輸出，並返回它。

1518
01:09:07,300 --> 01:09:10,790
>> 因此，所有這個函數是
需要某種形式的整數。

1519
01:09:10,790 --> 01:09:14,979
它相乘本身兩次
這樣它立方體中的效果。

1520
01:09:14,979 --> 01:09:17,729
然後返回
無論是輸出。

1521
01:09:17,729 --> 01:09:20,540
因此，在這種情況下，它的兩行
我們必須編寫額外的代碼。

1522
01:09:20,540 --> 01:09:22,880
但是，如果我們想叫
在此多次，

1523
01:09:22,880 --> 01:09:26,210
這是一個更容易輸入，一個
線對這裡的立方體比

1524
01:09:26,210 --> 01:09:28,830
要經過多次。

1525
01:09:28,830 --> 01:09:34,180
>> 這樣的方式，基本上任何
格式化為任何類型的功能

1526
01:09:34,180 --> 01:09:36,420
會存在就是喜歡這裡。

1527
01:09:36,420 --> 01:09:38,659
因此，我們有函數名。

1528
01:09:38,659 --> 01:09:39,950
在這種情況下，它被稱為立方體。

1529
01:09:39,950 --> 01:09:42,033
我們將其命名為立方體，因為
很容易記住。

1530
01:09:42,033 --> 01:09:44,220
你可以將其命名為正方形，
它其實是可以立方。

1531
01:09:44,220 --> 01:09:45,500
無所謂。

1532
01:09:45,500 --> 01:09:48,020
只要你是一個名字
分配你的函數。

1533
01:09:48,020 --> 01:09:51,660
>> 在這裡這項權利，INT，是
類型你需要的參數。

1534
01:09:51,660 --> 01:09:54,149
那麼，這功能
需要以操作？

1535
01:09:54,149 --> 01:09:55,990
那麼，它需要一個輸入。

1536
01:09:55,990 --> 01:09:56,704
我把它命名為輸入。

1537
01:09:56,704 --> 01:09:58,120
任何你想要的，你可以將其命名為。

1538
01:09:58,120 --> 01:10:00,500
但我需要的東西int類型。

1539
01:10:00,500 --> 01:10:03,730
這將實際執行
無論是在這裡裡面，

1540
01:10:03,730 --> 01:10:04,990
功能的主體。

1541
01:10:04,990 --> 01:10:07,847
然後返回類型
就在這裡，這int--

1542
01:10:07,847 --> 01:10:09,680
所有它告訴我的是
這個功能是

1543
01:10:09,680 --> 01:10:11,250
要回到我的int。

1544
01:10:11,250 --> 01:10:14,460
因此，要採取一個int，和
它會還給你一個int。

1545
01:10:14,460 --> 01:10:17,750
每個人都明白是怎麼
這種格式的作品？

1546
01:10:17,750 --> 01:10:18,250
酷。

1547
01:10:18,250 --> 01:10:24,690

1548
01:10:24,690 --> 01:10:25,740
>> 確定。

1549
01:10:25,740 --> 01:10:31,770
所以不要擔心，如果這似乎
現在有點抽象的權利。

1550
01:10:31,770 --> 01:10:33,450
這是我們要談談。

1551
01:10:33,450 --> 01:10:36,310
我們將深入更深
後來在使用過程中。

1552
01:10:36,310 --> 01:10:41,170
的方式，任何類型的更高級別的
這些東西的工作抽象

1553
01:10:41,170 --> 01:10:43,530
的是，在存儲器中，在
您的電腦，一切

1554
01:10:43,530 --> 01:10:47,660
存儲在該類型
棧的，我會說。

1555
01:10:47,660 --> 01:10:49,070
>> 所以在那裡在頂部。

1556
01:10:49,070 --> 01:10:50,861
我不知道，如果你
你們可以看到，很好。

1557
01:10:50,861 --> 01:10:52,590
我會嘗試進行放大。

1558
01:10:52,590 --> 01:10:55,111
此處在頂部，我們
有物理文

1559
01:10:55,111 --> 01:10:57,860
什麼樣的電腦是interpreting--
所有的零和那些

1560
01:10:57,860 --> 01:10:59,540
我們的電腦中存在。

1561
01:10:59,540 --> 01:11:03,390
然後，我們已經初始化
數據和未初始化的數據，

1562
01:11:03,390 --> 01:11:05,340
我們所說的全局變量。

1563
01:11:05,340 --> 01:11:08,200
所以存在變數
所有程序

1564
01:11:08,200 --> 01:11:11,815
並在您的整個，
從本質上講，代碼。

1565
01:11:11,815 --> 01:11:13,940
不，如果你們有隱憂
那種對這個不清楚。

1566
01:11:13,940 --> 01:11:16,060
它並不真正的問題現在。

1567
01:11:16,060 --> 01:11:18,680
>> 然後我們有什麼
所謂在棧堆。

1568
01:11:18,680 --> 01:11:21,140
想想一摞字面上
就像一摞東西，

1569
01:11:21,140 --> 01:11:23,098
一疊不同
事情被推向頂部

1570
01:11:23,098 --> 01:11:27,870
彼此存儲的各種的
你的代碼中的變量和語法。

1571
01:11:27,870 --> 01:11:31,460
然後在此間舉行的最底層，
我們的環境變量

1572
01:11:31,460 --> 01:11:35,480
你是在執行什麼
只是你的小行代碼。

1573
01:11:35,480 --> 01:11:40,510
>> 而我們只是要放大
在實際棧的一部分。

1574
01:11:40,510 --> 01:11:43,880
所以在這裡，如果我們放大
在棧只是這個領域，

1575
01:11:43,880 --> 01:11:45,140
這是什麼樣子。

1576
01:11:45,140 --> 01:11:48,590
這實際上是非常重要的
當你們談論的功能，

1577
01:11:48,590 --> 01:11:52,330
因為公告稱，
計算機中的內存

1578
01:11:52,330 --> 01:11:55,600
正存儲變量
和功能

1579
01:11:55,600 --> 01:11:58,790
及兩者的參數的
功能與您的主要變數

1580
01:11:58,790 --> 01:12:00,190
在不同的地方。

1581
01:12:00,190 --> 01:12:03,390
>> 所以，現在，主要是
實際功能

1582
01:12:03,390 --> 01:12:04,780
您正在執行的代碼。

1583
01:12:04,780 --> 01:12:08,050
你在這兒儲存它的參數
這裡存放局部變量。

1584
01:12:08,050 --> 01:12:12,270
局部變量只是意味著任何變量
存在僅在該功能。

1585
01:12:12,270 --> 01:12:15,610
而在它的上面，你有這樣的
單獨的函數調用的立方體。

1586
01:12:15,610 --> 01:12:18,240
你有這就是參數
以及那些當地人。

1587
01:12:18,240 --> 01:12:21,540
>> 其原因可以
在這裡看到的是什麼

1588
01:12:21,540 --> 01:12:25,030
發生在多維數據集需要在
從你的主函數值

1589
01:12:25,030 --> 01:12:27,640
是，實際上它複製了過來。

1590
01:12:27,640 --> 01:12:31,470
所以，如果我想立方
2，並返回8，即2

1591
01:12:31,470 --> 01:12:33,730
實際輸入
作為一個參數，它是

1592
01:12:33,730 --> 01:12:37,690
複製，讓你有它存在的
在內存中的兩個不同的地方。

1593
01:12:37,690 --> 01:12:40,520
而且你必須要非常小心
在回憶這其中的一個

1594
01:12:40,520 --> 01:12:42,520
你實際操作。

1595
01:12:42,520 --> 01:12:47,170
和發生了什麼事的例子
這將是非常，非常糟糕

1596
01:12:47,170 --> 01:12:48,050
存在這裡。

1597
01:12:48,050 --> 01:12:50,760

1598
01:12:50,760 --> 01:12:58,650
>> 所以在這裡，我有，從理論上講，
一個程序就在這裡，一個主要功能

1599
01:12:58,650 --> 01:13:02,180
那我聲明了一個int x等於1。

1600
01:13:02,180 --> 01:13:04,505
我聲明了另外一個INT y等於2。

1601
01:13:04,505 --> 01:13:06,380
然後我運行它
通過這個功能

1602
01:13:06,380 --> 01:13:09,647
稱為交換，在那裡我認為
它交換的兩個值。

1603
01:13:09,647 --> 01:13:11,480
然後我要去
把它們打印出來，對不對？

1604
01:13:11,480 --> 01:13:13,220
這就是我想這個程序做。

1605
01:13:13,220 --> 01:13:15,180
>> 因此，讓我們下來看一看。

1606
01:13:15,180 --> 01:13:18,200
所以，如果我真的寫不同
功能，你可以看到，

1607
01:13:18,200 --> 01:13:19,750
我們在這裡有我們的主要功能。

1608
01:13:19,750 --> 01:13:22,860
然後，我們有我們的
第二個功能在這裡。

1609
01:13:22,860 --> 01:13:24,520
空掉。

1610
01:13:24,520 --> 01:13:27,090
虛空只是意味著它的
不會返回任何東西。

1611
01:13:27,090 --> 01:13:28,930
該函數名
稱為交換，它的

1612
01:13:28,930 --> 01:13:33,730
要進兩個變量，INT A和
詮釋B，從你的[聽不清]功能。

1613
01:13:33,730 --> 01:13:39,010
>> 所以基本上在這裡，我們
通過x和y成此功能。

1614
01:13:39,010 --> 01:13:40,760
如果我們要
創建this--所以我們要

1615
01:13:40,760 --> 01:13:42,420
創建一個臨時的價值，對不對？

1616
01:13:42,420 --> 01:13:43,930
我們將其賦值給一個。

1617
01:13:43,930 --> 01:13:45,388
然後將要現在等於灣

1618
01:13:45,388 --> 01:13:47,660
而B是要回來
那裡的溫度值，

1619
01:13:47,660 --> 01:13:51,070
其是，因為當
要交換的東西，

1620
01:13:51,070 --> 01:13:52,320
你不能只是喜歡交換他們。

1621
01:13:52,320 --> 01:13:54,360
>> 你必須保持一個出來
在這裡，以便它記住

1622
01:13:54,360 --> 01:13:56,485
那是什麼，因為一旦
你換一個，你忘了

1623
01:13:56,485 --> 01:13:58,200
這是什麼原值是吧？

1624
01:13:58,200 --> 01:14:00,990
因此從理論上講，這個方案
應該工作，對不對？

1625
01:14:00,990 --> 01:14:03,630
如果我想交換
二，他們應該掉。

1626
01:14:03,630 --> 01:14:05,490
因此，讓我們運行它，看看它是否工作。

1627
01:14:05,490 --> 01:14:11,130

1628
01:14:11,130 --> 01:14:16,940
>> 所以當你們可以看到，X
曾經是1和y曾經2。

1629
01:14:16,940 --> 01:14:21,475
如果我把它打印出來，
x是仍然1和y為2。

1630
01:14:21,475 --> 01:14:25,970
嗯，這個方案似乎並不被
工作，我希望它的工作方式。

1631
01:14:25,970 --> 01:14:29,950
有沒有人想採取射擊在
猜測為什麼這是怎麼回事？

1632
01:14:29,950 --> 01:14:34,430
它做的方式
不同的事情

1633
01:14:34,430 --> 01:14:38,172
存儲在存儲器不同的地方。

1634
01:14:38,172 --> 01:14:39,377
>> 確定。

1635
01:14:39,377 --> 01:14:41,960
所以你們不必擔心
太多關於這個現在。

1636
01:14:41,960 --> 01:14:46,610
但是要知道，立方體的地方
變量是a和b，

1637
01:14:46,610 --> 01:14:49,230
因為在這裡我們的功能，
我們已經聲明a和b

1638
01:14:49,230 --> 01:14:53,570
如存在的變量
在立方體，該功能。

1639
01:14:53,570 --> 01:14:59,490
但正如你所看到的，參數
它採取的是被存放在這裡。

1640
01:14:59,490 --> 01:15:01,370
但是，我們並沒有真正
返回任何東西。

1641
01:15:01,370 --> 01:15:03,120
我們並沒有實際上改變x和y。

1642
01:15:03,120 --> 01:15:04,440
我們只是改變a和b。

1643
01:15:04,440 --> 01:15:08,340
>> 我們抄襲了x和y成
所謂a和b。

1644
01:15:08,340 --> 01:15:11,092
但是，我們從來沒有真正
操縱x和y自己。

1645
01:15:11,092 --> 01:15:12,800
是你們看到的
怎麼說是怎麼回事？

1646
01:15:12,800 --> 01:15:16,140
是，我們已經簡單地複製它
結束了，但我們還沒有真正保持

1647
01:15:16,140 --> 01:15:18,030
軌道，其中他們是在存儲器。

1648
01:15:18,030 --> 01:15:20,127
>> 所以，現在的電腦
期待哦，我已經

1649
01:15:20,127 --> 01:15:21,960
通過運行這個東西
這個可愛的功能。

1650
01:15:21,960 --> 01:15:23,690
但x和y是仍然x和y。

1651
01:15:23,690 --> 01:15:26,240
什麼也沒有發生
它們，因為這樣的事實

1652
01:15:26,240 --> 01:15:28,340
這些參數
和局部變量

1653
01:15:28,340 --> 01:15:30,150
被存儲在一個不同的
放置在存儲器中。

1654
01:15:30,150 --> 01:15:32,030
而這是一個較高級別的
概念，我們將

1655
01:15:32,030 --> 01:15:34,300
在啟動過程中看到以後。

1656
01:15:34,300 --> 01:15:36,950
但是，僅僅知道這是
可能發生的一個問題

1657
01:15:36,950 --> 01:15:41,400
而且我們會想出辦法如何
在使用過程中處理這個以後。

1658
01:15:41,400 --> 01:15:41,900
確定。

1659
01:15:41,900 --> 01:15:47,750

1660
01:15:47,750 --> 01:15:48,250
好的。

1661
01:15:48,250 --> 01:15:51,780
所以，最後的概念，我們是
真的要覆蓋

1662
01:15:51,780 --> 01:15:53,880
那將是有益的
本週處理器集

1663
01:15:53,880 --> 01:15:56,060
被所謂的
命令行參數。

1664
01:15:56,060 --> 01:16:00,820
所以搶在他的演講經歷
那種簡單地對如何將這些工作。

1665
01:16:00,820 --> 01:16:02,770
從本質上講知道
你寫的時候

1666
01:16:02,770 --> 01:16:06,280
就像一個主要功能，當我們
前過去寫功能，

1667
01:16:06,280 --> 01:16:07,804
我們有INT主要無效。

1668
01:16:07,804 --> 01:16:10,470
其原因，我們有空隙存在
是因為我們的方案沒有

1669
01:16:10,470 --> 01:16:12,520
需要輸入值運行，對吧？

1670
01:16:12,520 --> 01:16:16,020
當我跑馬里奧，我也沒必要
實際上只需鍵入一些

1671
01:16:16,020 --> 01:16:16,970
當我跑馬里奧。

1672
01:16:16,970 --> 01:16:20,170
我可以提示用戶以後。

1673
01:16:20,170 --> 01:16:22,450
但是，這不會總是這種情況。

1674
01:16:22,450 --> 01:16:24,980
>> 例如，在本
本週的習題集，

1675
01:16:24,980 --> 01:16:28,365
你要問的是，在
除了運行您的程序，

1676
01:16:28,365 --> 01:16:30,990
你會想要輸入
直某些事情，你

1677
01:16:30,990 --> 01:16:32,050
運行程序。

1678
01:16:32,050 --> 01:16:34,720
所以我們這樣做的方式被稱為
一個命令行參數，這

1679
01:16:34,720 --> 01:16:37,280
就像是一個說法
你可以直接輸入

1680
01:16:37,280 --> 01:16:39,260
因為你想運行您的程序。

1681
01:16:39,260 --> 01:16:44,680
>> 因此，符號對於這一點，
這是相當複雜的前瞻性，

1682
01:16:44,680 --> 01:16:47,320
但它真的不是那麼
難。因此，INT main--

1683
01:16:47,320 --> 01:16:48,910
這只是你的主要功能。

1684
01:16:48,910 --> 01:16:52,110
進入ARGC逗號字符串argv的括號內。

1685
01:16:52,110 --> 01:16:56,040
因此，所有這是說的是，這
INT argc--所有這一切告訴你

1686
01:16:56,040 --> 01:17:00,560
的是，這些是數
參數的計算機應該期望。

1687
01:17:00,560 --> 01:17:03,130
>> 所以一件事是真的
重要的是要保持跟踪

1688
01:17:03,130 --> 01:17:07,080
是你的程序的物理名稱
計為這些參數之一。

1689
01:17:07,080 --> 01:17:11,080
所以，如果我想有我的計劃
運行加上一個額外的命令行

1690
01:17:11,080 --> 01:17:13,310
的說法，我其實
將有兩種。

1691
01:17:13,310 --> 01:17:15,080
ARGC實際發生是兩個。

1692
01:17:15,080 --> 01:17:18,010
然後串的argv
bracket--一切是幹什麼的，

1693
01:17:18,010 --> 01:17:20,410
它給了我一個
字符串數組是

1694
01:17:20,410 --> 01:17:24,870
將只顯示和存儲什麼
所有這些命令行參數。

1695
01:17:24,870 --> 01:17:34,090
>> 因此，舉例來說，如果我想有這樣的
程序，./copy INFILE OUTFILE，對不對？

1696
01:17:34,090 --> 01:17:37,330
這只是一個典型的Linux命令。

1697
01:17:37,330 --> 01:17:38,830
究竟是ARGC？

1698
01:17:38,830 --> 01:17:41,320
多少個命令行參數
有沒有真正在這？

1699
01:17:41,320 --> 01:17:45,130
所有這一切確實是做的一個副本
一個文件的名稱的infile的

1700
01:17:45,130 --> 01:17:47,070
它拷貝到
另一個文件，對不對？

1701
01:17:47,070 --> 01:17:48,700
這是這一切都在做什麼。

1702
01:17:48,700 --> 01:17:53,080
正如你所看到的，我做的在一行
而不實際需要的程序。

1703
01:17:53,080 --> 01:17:55,380
>> 什麼是我們在這種情況下ARGC？

1704
01:17:55,380 --> 01:17:58,968
多少個參數我們有嗎？

1705
01:17:58,968 --> 01:17:59,634
聽眾：三？

1706
01:17:59,634 --> 01:18:01,200
ANDI彭：我們有三個，正好。

1707
01:18:01,200 --> 01:18:05,030
所以這是非常直觀的
只是覺得它只是

1708
01:18:05,030 --> 01:18:06,290
在INFILE和OUTFILE。

1709
01:18:06,290 --> 01:18:10,190
但是要知道，的物理名稱
計劃你運行計為一個。

1710
01:18:10,190 --> 01:18:13,220
所以在這種情況下，的argc實際上是三種。

1711
01:18:13,220 --> 01:18:15,860
怎麼樣，是什麼argv的0？

1712
01:18:15,860 --> 01:18:18,180
請記住，所有的
命令行參數

1713
01:18:18,180 --> 01:18:20,500
存儲在一個字符串數組。

1714
01:18:20,500 --> 01:18:24,140
所以，如果我嘗試訪問它，有什麼
將argv的支架0給我？

1715
01:18:24,140 --> 01:18:25,364
>> 聽眾：[聽不清]。

1716
01:18:25,364 --> 01:18:26,155
ANDI鵬：沒錯。

1717
01:18:26,155 --> 01:18:28,550
它會給我點
斜線副本，因為這是

1718
01:18:28,550 --> 01:18:31,070
第0元件，所述
我的數組的第一個元素。

1719
01:18:31,070 --> 01:18:33,236
那麼argv的1？

1720
01:18:33,236 --> 01:18:33,945
>> 聽眾：INFILE。

1721
01:18:33,945 --> 01:18:35,070
ANDI彭：INFILE，沒錯。

1722
01:18:35,070 --> 01:18:36,272
怎麼樣的argv 2？

1723
01:18:36,272 --> 01:18:37,022
聽眾：OUTFILE。

1724
01:18:37,022 --> 01:18:38,190
ANDI彭：OUTFILE。

1725
01:18:38,190 --> 01:18:39,290
現在，這是一個有點棘手。

1726
01:18:39,290 --> 01:18:42,630
你們有什麼想的argv
3將是給我

1727
01:18:42,630 --> 01:18:45,522
如果我試圖打印出來？

1728
01:18:45,522 --> 01:18:48,260
>> 聽眾：[聽不清]？

1729
01:18:48,260 --> 01:18:50,164
>> ANDI彭：你有一隻手嗎？

1730
01:18:50,164 --> 01:18:50,663
是啊。

1731
01:18:50,663 --> 01:18:51,550
>> 聽眾：一個選擇。

1732
01:18:51,550 --> 01:18:52,341
>> ANDI鵬：沒錯。

1733
01:18:52,341 --> 01:18:55,440
所以請記住講座中，我們
有在比賽的東西到底

1734
01:18:55,440 --> 01:18:56,640
所謂空終結者？

1735
01:18:56,640 --> 01:18:58,890
我們將進入這也
進一步在上課。

1736
01:18:58,890 --> 01:19:02,472
但是要知道，在符號，
順便你的電腦

1737
01:19:02,472 --> 01:19:04,430
知道它的結束
陣列的是，它

1738
01:19:04,430 --> 01:19:07,310
把一種叫做空
終止或破折號為零。

1739
01:19:07,310 --> 01:19:12,047
>> 所以，如果您嘗試訪問ARGV 3，
你會打這個破折號0。

1740
01:19:12,047 --> 01:19:13,630
這更是一個很難回答的問題。

1741
01:19:13,630 --> 01:19:17,020
那麼argv的4？

1742
01:19:17,020 --> 01:19:20,920
因此，這是過去的空終結，
過去我們的數組的邊界。

1743
01:19:20,920 --> 01:19:24,380
你認為是要
發生在我們試圖做到這一點？

1744
01:19:24,380 --> 01:19:25,842
>> 聽眾：[聽不清]？

1745
01:19:25,842 --> 01:19:26,550
ANDI彭：對不起？

1746
01:19:26,550 --> 01:19:28,025
都說有點響？

1747
01:19:28,025 --> 01:19:29,086
>> 聽眾：[聽不清]。

1748
01:19:29,086 --> 01:19:29,710
ANDI彭：是的。

1749
01:19:29,710 --> 01:19:32,420
也就是說的名稱
區域中，您將最有可能得到的。

1750
01:19:32,420 --> 01:19:36,610
但是要知道，argv的4--
它允許您訪問

1751
01:19:36,610 --> 01:19:38,610
在您的計算機的地方
記憶，你真的

1752
01:19:38,610 --> 01:19:41,650
不應該是感動，因為
現在你知道什麼是argv的是。

1753
01:19:41,650 --> 01:19:46,220
你知道它的大小為3的數組
有網點拷貝，INFILE和OUTFILE。

1754
01:19:46,220 --> 01:19:50,200
>> 如果你嘗試至今點到為止
你是過去的空結束，

1755
01:19:50,200 --> 01:19:53,050
你的計算機有可能
argv中4存放的東西。

1756
01:19:53,050 --> 01:19:55,790
而你真的不應該
允許訪問到argv的4，

1757
01:19:55,790 --> 01:19:58,130
因為你有一個文件
櫥櫃，你只能是

1758
01:19:58,130 --> 01:19:59,790
允許訪問這三個貨架。

1759
01:19:59,790 --> 01:20:02,870
但是，如果你試圖達到的方式超越
在那裡你被允許的架子，

1760
01:20:02,870 --> 01:20:04,930
你要開始搞亂
在計算機的內存中其他的東西。

1761
01:20:04,930 --> 01:20:06,690
這將是非常糟糕。

1762
01:20:06,690 --> 01:20:07,440
所以只要知道這一點。

1763
01:20:07,440 --> 01:20:10,370
要非常小心，你
不只是隨機啟動

1764
01:20:10,370 --> 01:20:14,772
在數組訪問元素
是不是你想要的創建。

1765
01:20:14,772 --> 01:20:17,114
是的。

1766
01:20:17,114 --> 01:20:18,430
>> 確定。

1767
01:20:18,430 --> 01:20:26,360
所以，我們要做的另一
這裡終端的例子。

1768
01:20:26,360 --> 01:20:27,300
確定。

1769
01:20:27,300 --> 01:20:29,900
所以羅布迅速講座
前些天去

1770
01:20:29,900 --> 01:20:35,040
通過這個例子，在那裡，他
有INT主要INT ARGC字符串的argv

1771
01:20:35,040 --> 01:20:39,090
括號，這是告訴我，我
將有命令行參數。

1772
01:20:39,090 --> 01:20:41,860
>> 他，如果ARGC等於
等於2--記得，

1773
01:20:41,860 --> 01:20:45,070
等於等於裝置的比較。

1774
01:20:45,070 --> 01:20:47,980
如果它等於2，那麼我
要打印你好，

1775
01:20:47,980 --> 01:20:51,190
無論第一
數組的元素是。

1776
01:20:51,190 --> 01:20:54,100
否則打印的hello world。

1777
01:20:54,100 --> 01:20:56,300
這是什麼打算
發生本質？

1778
01:20:56,300 --> 01:21:00,570
可有人只是解釋
英語這是什麼程序在做什麼？

1779
01:21:00,570 --> 01:21:01,272
是啊。

1780
01:21:01,272 --> 01:21:08,160
>> 聽眾：如果有人鍵入命令
並表示，他們的名字和姓氏，

1781
01:21:08,160 --> 01:21:12,096
它不只是打印
第一個說，你好，

1782
01:21:12,096 --> 01:21:14,090
無論你的第一個名字是。

1783
01:21:14,090 --> 01:21:15,410
>> ANDI彭：好吧，讓我們來運行它。

1784
01:21:15,410 --> 01:21:22,470
因此，舉例來說，如果我做
這個文件讓你好你好用於：

1785
01:21:22,470 --> 01:21:24,500
用於：你有什麼要我輸入？

1786
01:21:24,500 --> 01:21:25,900
>> 聽眾：姓氏和名字。

1787
01:21:25,900 --> 01:21:27,280
>> ANDI彭：姓氏和名字？

1788
01:21:27,280 --> 01:21:28,180
空間？

1789
01:21:28,180 --> 01:21:29,690
>> 聽眾：是的。

1790
01:21:29,690 --> 01:21:33,490
>> ANDI彭：誰能告訴
我現在，什麼是ARGC？

1791
01:21:33,490 --> 01:21:35,630
只是在那裡？

1792
01:21:35,630 --> 01:21:36,290
哎呀，對不起。

1793
01:21:36,290 --> 01:21:37,920
讓我回去。

1794
01:21:37,920 --> 01:21:40,740
多少個命令行參數
are--你們真的不能看。

1795
01:21:40,740 --> 01:21:43,760
但我會嘗試進行放大。

1796
01:21:43,760 --> 01:21:44,290
我想。

1797
01:21:44,290 --> 01:21:45,414
是啊，有三個，對嗎？

1798
01:21:45,414 --> 01:21:48,750
這點斜線你好，
這是安迪，這是鵬。

1799
01:21:48,750 --> 01:21:51,870
>> 那麼，你們認為這
程序將被打印出來？

1800
01:21:51,870 --> 01:21:55,550

1801
01:21:55,550 --> 01:21:56,060
呵呵。

1802
01:21:56,060 --> 01:21:57,120
哦，對不起。

1803
01:21:57,120 --> 01:21:57,810
錯誤的名稱。

1804
01:21:57,810 --> 01:22:03,630

1805
01:22:03,630 --> 01:22:06,130
它打印出來，你好世界。

1806
01:22:06,130 --> 01:22:09,603
有誰不想解釋
為什麼會是怎麼回事？

1807
01:22:09,603 --> 01:22:10,103
是嗎？

1808
01:22:10,103 --> 01:22:11,019
>> 聽眾：[聽不清]。

1809
01:22:11,019 --> 01:22:14,439

1810
01:22:14,439 --> 01:22:15,230
ANDI鵬：沒錯。

1811
01:22:15,230 --> 01:22:19,940
所以在這裡，是有條件的
是，如果的argc等於等於2。

1812
01:22:19,940 --> 01:22:23,650
因此只有在的情況下有
兩個命令行參數。

1813
01:22:23,650 --> 01:22:25,850
然後我會打印，
你好，不管它是什麼。

1814
01:22:25,850 --> 01:22:28,210
但其他人，我要
僅打印，你好世界。

1815
01:22:28,210 --> 01:22:30,040
因此，沒有人想要
給我一個例子

1816
01:22:30,040 --> 01:22:35,050
如何我將能夠實際
得到它打印的argv 1的價值？

1817
01:22:35,050 --> 01:22:38,600
>> 什麼我都必須輸入嗎？

1818
01:22:38,600 --> 01:22:39,840
只有一件事，對不對？

1819
01:22:39,840 --> 01:22:42,900
因為點招呼已經
數作為第一個參數。

1820
01:22:42,900 --> 01:22:43,930
我只有一個。

1821
01:22:43,930 --> 01:22:46,470
因此，點你好，如果我只是做安迪。

1822
01:22:46,470 --> 01:22:47,270
你好，安迪。

1823
01:22:47,270 --> 01:22:49,186
大家是否明白
為什麼會是怎麼回事？

1824
01:22:49,186 --> 01:22:49,602
是啊。

1825
01:22:49,602 --> 01:22:52,500
>> 聽眾：所以之間的空間
命令line--是[聽不清]？

1826
01:22:52,500 --> 01:22:56,247

1827
01:22:56,247 --> 01:22:56,830
ANDI彭：沒有。

1828
01:22:56,830 --> 01:23:03,810
因此，在一個命令行的空間
的說法，X，告訴你的電腦

1829
01:23:03,810 --> 01:23:06,820
這是一個新的字符串的開始。

1830
01:23:06,820 --> 01:23:11,130
因此字符串的argv這裡 - 它的商店
所有的命令行參數

1831
01:23:11,130 --> 01:23:13,110
在字符串。

1832
01:23:13,110 --> 01:23:17,420
因此在命令行中的空間
argument--所有這些都告訴你，

1833
01:23:17,420 --> 01:23:21,030
這是在一個字符串的末尾
它的時間移動到另一個。

1834
01:23:21,030 --> 01:23:21,990
>> 是啊。

1835
01:23:21,990 --> 01:23:23,530
這是非常重要的
您PSET，因為你

1836
01:23:23,530 --> 01:23:24,613
將要測試這些。

1837
01:23:24,613 --> 01:23:29,300
因此，沒有人有
在這個問題嗎？

1838
01:23:29,300 --> 01:23:30,016
OK，涼。

1839
01:23:30,016 --> 01:23:30,515
是嗎？

1840
01:23:30,515 --> 01:23:35,008
>> 聽眾：所以你會原因
把整型參數計算的，而不是

1841
01:23:35,008 --> 01:23:40,059
的[聽不清]會當你想
鍵入其他信息

1842
01:23:40,059 --> 01:23:41,030
[聽不清]？

1843
01:23:41,030 --> 01:23:42,090
>> ANDI彭：是的，沒錯。

1844
01:23:42,090 --> 01:23:45,370
有些程序會要求你
輸入命令行參數

1845
01:23:45,370 --> 01:23:47,732
它傳遞中並使用該。

1846
01:23:47,732 --> 01:23:49,035
是啊。

1847
01:23:49,035 --> 01:23:50,410
聽眾：那麼，如果[聽不清]？

1848
01:23:50,410 --> 01:23:55,440

1849
01:23:55,440 --> 01:23:58,870
>> ANDI彭：嗯，我有什麼
然後改變我的計劃？

1850
01:23:58,870 --> 01:23:59,870
>> 聽眾：剛才3。

1851
01:23:59,870 --> 01:24:12,460

1852
01:24:12,460 --> 01:24:15,020
>> ANDI彭：這是為什麼呢
發生的事情，你覺得呢？

1853
01:24:15,020 --> 01:24:18,940
>> 聽眾：因為[聽不清]。

1854
01:24:18,940 --> 01:24:22,370
>> 聽眾：你得
將其更改為2 [聽不清]。

1855
01:24:22,370 --> 01:24:23,484
>> 聽眾：1和2。

1856
01:24:23,484 --> 01:24:24,650
ANDI彭：1和2，完全吻合。

1857
01:24:24,650 --> 01:24:29,150
因此，在這種情況下，你可能
想要有兩個printf的statements--

1858
01:24:29,150 --> 01:24:32,601
一個印刷的argv 1
在一個印刷的argv 2。

1859
01:24:32,601 --> 01:24:33,100
在這裡。

1860
01:24:33,100 --> 01:24:34,516
其實我可以做真正的快。

1861
01:24:34,516 --> 01:24:46,720

1862
01:24:46,720 --> 01:24:47,320
你去那裡。

1863
01:24:47,320 --> 01:24:48,287
呵呵。

1864
01:24:48,287 --> 01:24:49,370
不太你想要的。

1865
01:24:49,370 --> 01:24:52,590
但是，如果你們更動
格式化，它就會出來。

1866
01:24:52,590 --> 01:24:54,981
是啊。

1867
01:24:54,981 --> 01:24:55,480
酷。

1868
01:24:55,480 --> 01:24:57,670
我知道我們有點短準時。

1869
01:24:57,670 --> 01:25:02,469
但我只是要迅速花
幾分鐘經歷helpful--

1870
01:25:02,469 --> 01:25:03,760
聽眾：你有兩分鐘。

1871
01:25:03,760 --> 01:25:05,010
ANDI彭：我有兩分鐘？

1872
01:25:05,010 --> 01:25:06,340
謝謝。

1873
01:25:06,340 --> 01:25:09,180
一些快速PSET技巧。

1874
01:25:09,180 --> 01:25:13,100
因此，對於這個pset的，我強烈建議，
就像我說的，每個人都讀了規範。

1875
01:25:13,100 --> 01:25:16,804
你會被寫入三種programs-- 1
所謂initials.c，一個叫caesar.c，

1876
01:25:16,804 --> 01:25:17,720
一個叫vigenere.c。

1877
01:25:17,720 --> 01:25:20,465

1878
01:25:20,465 --> 01:25:22,340
一些重要的提示，
你們真的想

1879
01:25:22,340 --> 01:25:25,040
保持mind--所以
有這個功能

1880
01:25:25,040 --> 01:25:27,770
所謂atoi--我想說，一個三河。

1881
01:25:27,770 --> 01:25:29,520
目前還不清楚是否這就是
其實你怎麼說。

1882
01:25:29,520 --> 01:25:32,510
但是，所有它做，它的輸入。

1883
01:25:32,510 --> 01:25:34,320
它轉換成一個字符串為int。

1884
01:25:34,320 --> 01:25:37,490
因此，一個代表ASCII到我的整數。

1885
01:25:37,490 --> 01:25:40,310
它只是將ASCII
值整數值。

1886
01:25:40,310 --> 01:25:44,510
所以請記住ARGV，數組，其存儲
所有的命令行arguments--

1887
01:25:44,510 --> 01:25:46,300
這其中所有的存儲為字符串。

1888
01:25:46,300 --> 01:25:50,010
所以，如果你想成為能夠
具有其中的一個成為一個整數，

1889
01:25:50,010 --> 01:25:52,750
你將有
在這裡使用這個值。

1890
01:25:52,750 --> 01:25:56,690
>> 模，就像我們蓋
今天早些時候類，

1891
01:25:56,690 --> 01:25:59,550
讓你擁有
其餘的不管你有。

1892
01:25:59,550 --> 01:26:03,620
因此，如果我們真的，真的
大量的凱撒，

1893
01:26:03,620 --> 01:26:06,117
如果我們有結束
中的Vigenere的字符串？

1894
01:26:06,117 --> 01:26:08,450
你如何將能夠
吃出環繞？

1895
01:26:08,450 --> 01:26:11,330
如果我打Z和我想
它返回一個，

1896
01:26:11,330 --> 01:26:13,650
我應該如何獲得
那環繞？

1897
01:26:13,650 --> 01:26:15,960
可能需要使用
模在那裡的地方。

1898
01:26:15,960 --> 01:26:19,190
>> 其次，四處瀏覽
您的圖書館。文件ctype.h。

1899
01:26:19,190 --> 01:26:20,680
這是一個新的圖書館，我們有。

1900
01:26:20,680 --> 01:26:25,270
你會發現很多非常，非常
有用functions-- isupper，islower判斷，

1901
01:26:25,270 --> 01:26:27,681
TOUPPER，tolower的，因而isalpha，等等。

1902
01:26:27,681 --> 01:26:30,680
所有的功能，這將是非常有用的
當你試圖弄清楚，

1903
01:26:30,680 --> 01:26:33,780
這種性格小寫字母？

1904
01:26:33,780 --> 01:26:35,730
如何轉換這種
字符串大寫？

1905
01:26:35,730 --> 01:26:38,146
所有這些都將是非常，
非常有幫助您PSET。

1906
01:26:38,146 --> 01:26:42,720

1907
01:26:42,720 --> 01:26:45,500
確定。

1908
01:26:45,500 --> 01:26:49,644
>> 今晚是8:00上班時間到
明天在TEAL教室11:00

1909
01:26:49,644 --> 01:26:51,310
以及週三和週四晚上。

1910
01:26:51,310 --> 01:26:53,280
辦公時間是公共資源。

1911
01:26:53,280 --> 01:26:56,180
強烈建議你們
所有馬上開始，

1912
01:26:56,180 --> 01:27:00,490
因為你不希望是，
孩子誰週四晚有問題

1913
01:27:00,490 --> 01:27:03,870
提交您的PSET並
就像，我不知道該怎麼辦。

1914
01:27:03,870 --> 01:27:05,870
我開始，我完了，我提交。

1915
01:27:05,870 --> 01:27:09,737
試著給自己一些空間，
因為在代碼中的問題總是會發生。

1916
01:27:09,737 --> 01:27:11,570
你要確保
你給自己

1917
01:27:11,570 --> 01:27:14,810
了大量的時間，以便能夠
完成pset中。

1918
01:27:14,810 --> 01:27:15,310
酷。

1919
01:27:15,310 --> 01:27:16,720
我會在這裡流連。

1920
01:27:16,720 --> 01:27:18,226
>> 聽眾：這是網上了嗎？

1921
01:27:18,226 --> 01:27:20,850
ANDI彭：我不知道這是否是
在線已經，但它會。

1922
01:27:20,850 --> 01:27:23,500
我會在這裡流連，如果任何人
有任何問題了。

1923
01:27:23,500 --> 01:27:25,390
謝謝你的光臨。

1924
01:27:25,390 --> 01:27:27,105