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

2
00:00:07,070 --> 00:00:10,380
所以把你介绍给我有什么在屏幕上;

3
00:00:10,380 --> 00:00:12,710
它是一个在今年夏天，我们开发的工具;

4
00:00:12,710 --> 00:00:15,530
它被称为CS50空间，

5
00:00:15,530 --> 00:00:18,860
这是我们的合作编码应用

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

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

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

9
00:00:26,040 --> 00:00:29,760
让我拉起来，在另一个选项卡。

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

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

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

13
00:00:39,700 --> 00:00:43,030
你可以看到这是一个在您的浏览器的方式

14
00:00:43,030 --> 00:00:45,940
其实代码 - 编写C代码，

15
00:00:45,940 --> 00:00:47,460
然后运行它，

16
00:00:47,460 --> 00:00:50,960
所以编译，运行它，然后输出返回给你，

17
00:00:50,960 --> 00:00:53,350
所以这是一个冷静的方式进行实验

18
00:00:53,350 --> 00:00:56,060
大卫在课堂上的一些代码

19
00:00:56,060 --> 00:00:58,640
和我们给你的问题​​集

20
00:00:58,640 --> 00:01:01,900
没有真正火起来的家电。

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

22
00:01:04,489 --> 00:01:07,450
如果我切换到该选项卡，

23
00:01:07,450 --> 00:01:11,580
空间是CS50运行，就像你看到这里，

24
00:01:11,580 --> 00:01:15,380
但是，如果我们滚动，并期待在另一边的窗口，

25
00:01:15,380 --> 00:01:18,130
你看到的我是唯一的人在这个空间，

26
00:01:18,130 --> 00:01:21,030
但我要问你们加入这个跟我的空间

27
00:01:21,030 --> 00:01:24,590
，我们将所有的代码在同一个小窗口，

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

29
00:01:26,070 --> 00:01:28,900
谈论我们的代码之间的差异。

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

31
00:01:31,530 --> 00:01:35,770
所以要加入，如果您访问此链接在顶部

32
00:01:35,770 --> 00:01:38,980
我已经强调了，

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

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

35
00:01:56,610 --> 00:01:59,720
我去给你一点点的参观。

36
00:01:59,720 --> 00:02:01,720
我们会做一些愚蠢的小编码与它在第一，

37
00:02:01,720 --> 00:02:06,200
只是让大家有点的感觉是什么样子的，

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

39
00:02:09,000 --> 00:02:11,830
我在这里做什么 - 

40
00:02:11,830 --> 00:02:13,480
我要的代码，我已经写在这里，

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

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

43
00:02:17,090 --> 00:02:21,080
这只是锅炉板代码，我们将调用它。

44
00:02:21,080 --> 00:02:23,820
随着一点点地做评论。

45
00:02:23,820 --> 00:02:27,850
我要通过点击此“保存”按钮保存。

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

47
00:02:30,190 --> 00:02:34,400
强调它在这里简单 - 修订版本保存的绿框，

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

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

50
00:02:40,340 --> 00:02:43,370
你可以看到，我已经得到了本次修订在这里，

51
00:02:43,370 --> 00:02:45,490
如果你点击该版本，

52
00:02:45,490 --> 00:02:48,240
它会加载的代码到你的空间了。

53
00:02:50,510 --> 00:02:54,160
>> 所以每个人都加载了代码到他们的空间吗？

54
00:02:54,160 --> 00:02:57,810
好吧，如果你还没有，去进取，做到这一点，

55
00:02:57,810 --> 00:03:01,120
那么我希望你们在这个小的办节

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

57
00:03:05,940 --> 00:03:08,310
例如，我会写

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

59
00:03:15,140 --> 00:03:17,700
然后我会写

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

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

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

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

64
00:03:30,270 --> 00:03:33,910
无论你是在大学或商学院

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

66
00:03:36,130 --> 00:03:39,200
你正在学习什么，如果它的未知;

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

68
00:03:41,290 --> 00:03:45,170
我没有决定，直到我在我大二的时候已经很晚了。

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

70
00:03:49,210 --> 00:03:51,610
什么疯狂的，你要告诉我，或

71
00:03:51,610 --> 00:03:54,790
类或别的东西。

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

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

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

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

76
00:04:14,050 --> 00:04:16,399
然后如果你继续前进，并保存该修订

77
00:04:16,399 --> 00:04:21,600
使用修改保存“按钮，这小家伙在这里，

78
00:04:24,080 --> 00:04:27,340
，我们会有点儿经过，这样做一简单介绍。

79
00:04:27,340 --> 00:04:30,150
所以，你应该只需要点击“播放”按钮，

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

81
00:04:32,550 --> 00:04:35,340
所以这左上角的播放按钮将

82
00:04:35,340 --> 00:04:39,050
你的代码发送到我们​​的服务器，它被编译，然后运行。

83
00:04:40,600 --> 00:04:43,300
那么，什么是有点疯狂

84
00:04:43,300 --> 00:04:46,550
这段代码实际上是在计算机上运行;

85
00:04:46,550 --> 00:04:49,290
它实际上是在互联网上发送。

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

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

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

89
00:04:57,330 --> 00:05:00,530
在服务器上，这样它可以 - 我可以运行的程序。

90
00:05:02,090 --> 00:05:05,780
然后当我尝试运行它，它说，有一个错误。

91
00:05:05,780 --> 00:05:08,850
声明为病毒，这是不是在那里了。

92
00:05:08,850 --> 00:05:11,860
哦，让我们来看看，你可以再次点击保存？

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

94
00:05:13,770 --> 00:05:15,120
“对了，好了，所以这是我所拥有的。

95
00:05:15,120 --> 00:05:19,430
我不知道为什么它不会让我运行它。

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

97
00:05:27,930 --> 00:05:31,220
你能解释为什么 - 什么是错的 - 什么是不工作？

98
00:05:31,220 --> 00:05:34,760
“是啊，因为我没有看到，有一个最后一行那里的仍然是一个变量

99
00:05:34,760 --> 00:05:37,700
我没有宣布，我不打算为它在那里。

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

101
00:05:38,730 --> 00:05:40,390
>>现在，如果我保存它，我认为它应该工作。

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

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

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

105
00:05:46,690 --> 00:05:49,130
我只是重复的摄像头。

106
00:05:49,130 --> 00:05:51,760
发生了什么事，这个变量s

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

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

109
00:05:56,670 --> 00:05:59,560
，所以这个扔东西了，并没有让你运行它。

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

111
00:06:02,540 --> 00:06:05,690
有人尝试写不同的代码块，

112
00:06:05,690 --> 00:06:08,490
编译它，看看你的作品，看看有什么不

113
00:06:08,490 --> 00:06:10,730
然后有点谈论这些事情，因为这是跳闸点

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

115
00:06:12,850 --> 00:06:15,470
我还是 - 我做很多愚蠢的东西所有的时间，

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

117
00:06:17,820 --> 00:06:22,960
让我们拉起夏洛特的修订3，

118
00:06:23,980 --> 00:06:25,380
我们会运行它。

119
00:06:25,380 --> 00:06:28,950
>> 所以，当我运行了，现在我已经拿到了她在这里的代码，

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

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

122
00:06:33,680 --> 00:06:36,980
说，它成功地跑了，如果我向下滚动，

123
00:06:36,980 --> 00:06:39,440
夏洛特是一个大三学生亚当斯房子，

124
00:06:39,440 --> 00:06:42,720
心理学，经济二次真棒。

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

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

127
00:06:46,550 --> 00:06:49,670
好，继续，让我们去丹尼尔，

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

129
00:06:52,710 --> 00:06:54,180
编译，运行;

130
00:06:54,180 --> 00:06:56,680
你为什么不告诉我们一些关于自己，丹尼尔？

131
00:06:56,680 --> 00:06:59,380
给我打电话丹。

132
00:06:59,380 --> 00:07:01,920
我要你们对面的商学院，

133
00:07:01,920 --> 00:07:05,020
我是在海军陆战队员之前，在这里，

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

135
00:07:08,020 --> 00:07:11,060
不要难过，我30岁，我不知道任何这方面的东西。

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

137
00:07:13,800 --> 00:07:17,300
好了，我们还有丹尼尔。

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

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

140
00:07:22,260 --> 00:07:24,330
我是一个大二的学生现在在奥美。

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

142
00:07:25,840 --> 00:07:28,760
但我想借此CS50，因为我已经听到了巨大的类评论

143
00:07:28,760 --> 00:07:30,750
和我从来没有尝试过CS。

144
00:07:30,750 --> 00:07:34,680
向下滚动，并出示此 - 凉。

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

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

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

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

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

150
00:07:50,260 --> 00:07:53,100
和我采取CS50很感兴趣，因为我喜欢它的逻辑，

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

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

153
00:07:59,570 --> 00:08:02,340
“关于一个小时[听不清]的一个小城市[听不清]。

154
00:08:02,340 --> 00:08:04,850
哦，是的，我爸从雷德兰兹。

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

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

157
00:08:12,130 --> 00:08:15,130
>>好，你怎么样？

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

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

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

161
00:08:20,840 --> 00:08:22,820
但我有点倾向于经济学。

162
00:08:22,820 --> 00:08:25,680
像丹尼尔在我面前，我从来没有做过任何CS，但它听起来还挺酷的。

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

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

165
00:08:31,640 --> 00:08:34,630
我想问问，这样做打印出你所期望的吗？

166
00:08:34,630 --> 00:08:37,650
>>没有，我忘了打印新的生产线。

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

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

169
00:08:43,090 --> 00:08:46,330
这是一种痛苦，要记得把那些手动。

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

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

172
00:08:53,630 --> 00:08:56,050
哇，我们有2个的凯丽; 2丹尼尔斯，2凯丽。

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

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

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

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

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

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

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

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

181
00:09:24,090 --> 00:09:29,110
我没有经验，大部分的CS;

182
00:09:29,110 --> 00:09:32,700
我教自己建立的网站，我很年轻的时候，

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

184
00:09:35,750 --> 00:09:39,260
希望我会学多一点点

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

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

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

188
00:09:47,190 --> 00:09:48,880
我没有什么 - 你在这里说些什么？

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

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

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

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

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

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

195
00:10:05,560 --> 00:10:07,940
在2008年，我毕业于富兰克林与马歇尔学院

196
00:10:07,940 --> 00:10:10,840
在心理学和社会学专业

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

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

199
00:10:15,330 --> 00:10:18,080
因为我有兴趣在神经科学中获得博士学位

200
00:10:18,080 --> 00:10:21,220
我觉得这会帮助我了解正在使用的技术。

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

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

203
00:10:29,390 --> 00:10:31,640
那是正确的发音吗？

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

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

206
00:10:34,640 --> 00:10:36,870
我是一个大二的学生在柯克兰楼，

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

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

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

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

211
00:10:48,350 --> 00:10:52,550
但你知道，我认为这是尚酷样的工程类。

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

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

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

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

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

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

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

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

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

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

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

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

224
00:11:23,280 --> 00:11:25,500
因此，这意味着我什么都不知道！

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

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

227
00:11:31,220 --> 00:11:33,350
我觉得肯定会帮助。

228
00:11:33,350 --> 00:11:37,750
我是一个奇怪的事实，我是国家认证的消防队员。

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

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

231
00:11:42,440 --> 00:11:45,570
>>我参加了学院

232
00:11:45,570 --> 00:11:49,000
经历了地狱了很多周

233
00:11:49,000 --> 00:11:51,200
并得到我的认证。

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

235
00:11:54,090 --> 00:11:57,280
这是不小的壮举，是肯定的。

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

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

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

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

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

241
00:12:11,160 --> 00:12:13,840
我是一个符号系统的主要

242
00:12:13,840 --> 00:12:17,370
这是心，脑，行为集中在这里，

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

244
00:12:19,300 --> 00:12:22,350
计算机科学，语言学，心理学和哲学。

245
00:12:22,350 --> 00:12:26,600
样的 - 是的，有很多奇怪的东西，但它是伟大的，

246
00:12:26,600 --> 00:12:29,880
，然后我做我的主人在计算机科学，以及。

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

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

249
00:12:35,750 --> 00:12:39,860
我花了近4年在斯坦福大学的TA-计算机科学类

250
00:12:39,860 --> 00:12:43,370
大卫让我来吧，

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

252
00:12:45,550 --> 00:12:47,890
所以我做到这一点的时候，我不是在读研究生。

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

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

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

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

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

258
00:13:10,110 --> 00:13:13,240
我最喜欢的颜色是黄色的。

259
00:13:18,790 --> 00:13:21,100
没有必要通过判断或任何东西，但它是一个很好的颜色！

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

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

262
00:13:26,980 --> 00:13:30,070
我有没有什么线索，我尚未集中，

263
00:13:30,070 --> 00:13:32,500
所以CS50是一种随机，

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

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

266
00:13:36,080 --> 00:13:38,360
因为我们俩都从芝加哥。

267
00:13:38,360 --> 00:13:42,450
冷却，格雷斯 - 这应该是非常好的，对不对？

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

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

270
00:13:46,690 --> 00:13:51,210
[卡通/关闭摄像头聊天]

271
00:13:51,210 --> 00:13:54,420
好了，我现在还在学习，还在学习。

272
00:13:54,420 --> 00:13:57,800
>> 因此，我们有别的东西，这是一种有趣的。

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

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

275
00:14:05,890 --> 00:14:13,340
>>我本来是要放在每一行后面的分号。

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

277
00:14:16,370 --> 00:14:19,100
有时，这些的分号可以是一个真正的痛苦追查。

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

279
00:14:21,420 --> 00:14:22,820
我们使用的是今年的特别节目

280
00:14:22,820 --> 00:14:26,670
编译我们的C代码被称为铛，

281
00:14:26,670 --> 00:14:29,460
的原因，我们已经开始使用铛今年 - 

282
00:14:29,460 --> 00:14:32,030
因为我们没有使用该程序在过去的;

283
00:14:32,030 --> 00:14:35,710
我们已经使用了另外一个叫GCC，实在是很受欢迎 - 

284
00:14:35,710 --> 00:14:38,420
铛实际上是为您提供了有意义的错误消息。

285
00:14:38,420 --> 00:14:41,420
这一个说，“预计”，“表达”之后，

286
00:14:41,420 --> 00:14:45,260
它甚至会告诉你之后，你需要一个分号的表达。

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

288
00:14:47,830 --> 00:14:48,930
>>是的，没错。

289
00:14:48,930 --> 00:14:52,040
真棒，让我知道，我们将它拉起来，我们将运行它。

290
00:14:52,040 --> 00:14:55,830
但是，是的，把这些分号，是一种痛苦。

291
00:14:55,830 --> 00:14:59,580
我固定的，所以我认为它应该工作。

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

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

294
00:15:05,250 --> 00:15:08,580
好了，所以现在如果我们运行它，

295
00:15:08,580 --> 00:15:11,020
就这样吧。

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

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

298
00:15:15,340 --> 00:15:18,230
因此，感谢你这样做。

299
00:15:18,230 --> 00:15:20,210
这极大地满足了你们。

300
00:15:20,210 --> 00:15:22,880
什么现在我们要做的就是在接下来的点点

301
00:15:22,880 --> 00:15:24,740
有点潜入的部分问题

302
00:15:24,740 --> 00:15:27,550
从本周的问题来自

303
00:15:27,550 --> 00:15:29,920
我们会做到这一点的大部分路段

304
00:15:29,920 --> 00:15:32,110
的其余部分的术语，

305
00:15:32,110 --> 00:15:35,580
然后，我们将保存最后15，20分钟左右

306
00:15:35,580 --> 00:15:38,490
谈论的问题本身

307
00:15:38,490 --> 00:15:41,420
，然后就您有任何其他问题，在一般的类。

308
00:15:43,380 --> 00:15:45,670
这就是说，我们真的很想做

309
00:15:45,670 --> 00:15:49,390
有大家参与

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

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

312
00:15:53,500 --> 00:15:56,500
和谈论这样的事情休息时，

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

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

315
00:16:00,870 --> 00:16:03,180
当我开始编码，

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

317
00:16:05,490 --> 00:16:08,690
因为如果它像凌晨2点之前是由于你的习题集，

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

319
00:16:11,330 --> 00:16:14,590
我并没有开始编程，直到我是一个大二学生。

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

321
00:16:17,360 --> 00:16:20,360
我听到的是有点凉

322
00:16:20,360 --> 00:16:23,590
我还听说它可能是一个真正的痛苦的对接

323
00:16:23,590 --> 00:16:27,610
如果你错过了一个分号，使你的程序不能正常工作，这是唯一的错误

324
00:16:27,610 --> 00:16:30,890
让你去睡觉，

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

326
00:16:32,650 --> 00:16:34,020
如果你有这样的问题，

327
00:16:34,020 --> 00:16:37,060
如果你有这样的问题，让我知道，

328
00:16:37,060 --> 00:16:40,050
因为我要让你们这是一个很好的经验。

329
00:16:40,050 --> 00:16:44,620
>> 因此，有你们所有下载的问题还设置？

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

331
00:16:47,160 --> 00:16:51,490
所以，我们去cs50.net，因为我没有在此帐户，

332
00:16:51,490 --> 00:16:54,110
拉起来的问题集，

333
00:16:54,110 --> 00:16:57,940
拉起来的问题集2，今天我们来看看标准版。

334
00:16:57,940 --> 00:17:01,190
我们会拉规范。

335
00:17:02,640 --> 00:17:04,420
向下滚动。

336
00:17:06,790 --> 00:17:11,109
因此，我们要的问题，在本节开始寻找。

337
00:17:14,069 --> 00:17:16,710
你们看着这些短裤吗？

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

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

340
00:17:21,329 --> 00:17:24,700
这是由汤米，头部教学研究员之一。

341
00:17:24,700 --> 00:17:27,230
还有一个关于范围，

342
00:17:27,230 --> 00:17:30,530
我相信，通过另一个教学名叫大卫的家伙，

343
00:17:30,530 --> 00:17:33,400
恺撒密码，然后由大卫也做了。

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

345
00:17:35,550 --> 00:17:37,770
你们看他们的短裤这么远吗？

346
00:17:37,770 --> 00:17:39,270
还好吗他们了？

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

348
00:17:41,490 --> 00:17:44,210
如果不是这样，你可以这么说。

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

350
00:17:49,870 --> 00:17:52,600
有你们看着这些问题，

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

352
00:17:55,430 --> 00:17:57,480
>> 我们谈谈这有点。

353
00:17:57,480 --> 00:18:00,600
因此，我们已经介绍了在过去的几个星期

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

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

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

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

358
00:18:09,570 --> 00:18:13,100
在讲座中，我们已经谈论了很多有关

359
00:18:13,100 --> 00:18:16,010
如何将这些循环

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

361
00:18:18,320 --> 00:18:21,210
和一个while循环，你可以做同样的事情

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

363
00:18:23,260 --> 00:18:26,300
你只需要种使用正确的组合变量等。

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

365
00:18:28,680 --> 00:18:31,200
所有的循环的真正区别是，

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

367
00:18:33,620 --> 00:18:36,930
使用它们比在另一时间在同一时间。

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

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

370
00:18:42,260 --> 00:18:45,680
大家都觉得像他们有一个很好的处理时

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

372
00:18:48,650 --> 00:18:50,990
有用的或有什么区别吗？

373
00:18:50,990 --> 00:18:53,410
>>我认为所不同的是一个do-whil​​e循环

374
00:18:53,410 --> 00:18:56,960
运行 - 我不知道是怎样的术语，

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

376
00:18:59,750 --> 00:19:02,020
他们自动 - 它至少运行

377
00:19:02,020 --> 00:19:05,390
前检查的情况下，或在while循环将只运行它​​时，

378
00:19:05,390 --> 00:19:08,290
连续运行 - 是否得到满足的条件。

379
00:19:08,290 --> 00:19:11,010
是的，这有意义吗？

380
00:19:11,010 --> 00:19:14,200
>> 让我们来看看一点点的代码。

381
00:19:14,200 --> 00:19:16,930
因此，只要重复的问题，

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

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

384
00:19:22,050 --> 00:19:25,850
一个while循环检查，看看是否条件

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

386
00:19:27,440 --> 00:19:31,320
前运行的主体的第一次循环，

387
00:19:31,320 --> 00:19:35,000
而do-whil​​e循环会自动执行循环体，

388
00:19:35,000 --> 00:19:38,450
就是我们所说的 - 这是奇怪的术语，

389
00:19:38,450 --> 00:19:41,460
但如果我说什么没有意义的，让我知道 - 

390
00:19:41,460 --> 00:19:45,360
循环体是，你把花括号之间的东西。

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

392
00:19:47,840 --> 00:19:50,220
该机构获得至少运行一次，

393
00:19:50,220 --> 00:19:54,460
检查的条件，然后被运行之前，每个连续的时间。

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

395
00:19:56,580 --> 00:20:00,820
你不介意编写一个简单的while循环

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

397
00:20:02,840 --> 00:20:05,600
>>你怎么有点像

398
00:20:05,600 --> 00:20:07,060
一个新的吗？

399
00:20:07,060 --> 00:20:09,220
我只是删除了，无论你在那里。

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

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

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

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

404
00:20:21,050 --> 00:20:23,140
让我们来看看。

405
00:20:23,140 --> 00:20:25,850
亚历山大，我意识到我们从来没有向你介绍。

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

407
00:20:27,510 --> 00:20:30,760
你 - 你可以编写一个do-whil​​e循环的我们吗？

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

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

410
00:20:34,370 --> 00:20:38,240
种让你有一个把手上的差异是什么。

411
00:20:38,240 --> 00:20:41,280
>> 因此，这里的山姆做什么。

412
00:20:41,280 --> 00:20:44,460
他有一个名为i的整数

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

414
00:20:47,480 --> 00:20:51,570
然后，他说，虽然（INT I = 17）

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

416
00:20:54,230 --> 00:20:57,300
所以我们运行这个代码时会发生什么？

417
00:20:57,300 --> 00:21:00,340
有一个错误;错误说什么？

418
00:21:00,340 --> 00:21:02,890
让我们把它和谈论它。

419
00:21:02,890 --> 00:21:05,040
发生错误，它说。

420
00:21:05,040 --> 00:21:07,400
让我们向下滚动。

421
00:21:07,400 --> 00:21:09,460
因此，它给了我们这个错误，它说，

422
00:21:09,460 --> 00:21:12,690
“嘿，我预计的表达。”

423
00:21:12,690 --> 00:21:16,180
这有点难以理解。

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

425
00:21:23,140 --> 00:21:27,140
会有另一个小错误，我们将赶在第二。

426
00:21:27,140 --> 00:21:31,800
但是，这是另一个那些奇怪的术语的东西，

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

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

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

430
00:21:41,220 --> 00:21:43,410
声明一个整数叫我

431
00:21:43,410 --> 00:21:45,540
将其设置为等于17

432
00:21:45,540 --> 00:21:48,780
或者说，叫我把17这个int。

433
00:21:50,560 --> 00:21:53,350
这没有任何意义

434
00:21:53,350 --> 00:21:55,790
在这个while循环的上下文中。

435
00:21:55,790 --> 00:21:58,190
这有一定道理，因为我们可以看到，

436
00:21:58,190 --> 00:22:01,250
for循环的背景下，由于环声明开始

437
00:22:01,250 --> 00:22:05,800
为int i等于什么

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

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

440
00:22:09,500 --> 00:22:12,630
修复的东西，所有的权利。

441
00:22:12,630 --> 00:22:15,270
在这里，它会真棒。

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

443
00:22:17,920 --> 00:22:19,030
一对夫妇的事情发生了变化。

444
00:22:19,030 --> 00:22:21,300
你能告诉我们什么事情发生了变化？

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

446
00:22:24,950 --> 00:22:28,770
一个等号，我把2个等号，这意味着一个等号。

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

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

449
00:22:33,320 --> 00:22:35,770
这是在这里，

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

451
00:22:39,340 --> 00:22:41,970
宣布 - 让我们拿出的类型。

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

453
00:22:44,710 --> 00:22:47,380
那些被称为类型。

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

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

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

457
00:22:54,190 --> 00:22:57,300
他说的是问题的有关

458
00:22:57,300 --> 00:22:59,580
当你有1个等号，

459
00:22:59,580 --> 00:23:01,780
这是一个赋值运算符。

460
00:23:01,780 --> 00:23:04,930
这不是测试，是否事情都是平等的。

461
00:23:04,930 --> 00:23:07,920
这实际上是设置的东西的东西。

462
00:23:07,920 --> 00:23:11,110
我们将在17号到变量i。

463
00:23:11,110 --> 00:23:13,850
因此，做这种比较，

464
00:23:13,850 --> 00:23:16,430
你必须使用双等号，

465
00:23:16,430 --> 00:23:19,640
这是一种一个奇怪的事情

466
00:23:19,640 --> 00:23:22,760
但它是一个相当常见的错误。

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

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

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

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

471
00:23:36,740 --> 00:23:39,810
从左侧偏移

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

473
00:23:42,400 --> 00:23:44,730
我们这样做的原因

474
00:23:44,730 --> 00:23:47,000
仅仅是为了提高可读性。

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

476
00:23:51,620 --> 00:23:53,120
他并没有在所有的缩进，

477
00:23:53,120 --> 00:23:55,390
并且不影响的功能的代码。

478
00:23:55,390 --> 00:23:57,860
它将运行完全一样的。

479
00:23:57,860 --> 00:24:00,950
>> 因此，举例来说，如果我们拿出顶端

480
00:24:00,950 --> 00:24:02,680
，然后按播放按钮，它会建立，

481
00:24:02,680 --> 00:24:04,470
它会运行它，

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

483
00:24:06,700 --> 00:24:08,360
为什么仍然说吗？

484
00:24:08,360 --> 00:24:10,560
>>，因为它会不断地重复您好。

485
00:24:10,560 --> 00:24:12,900
没错，为什么它不停地重复您好吗？

486
00:24:12,900 --> 00:24:15,850
“由于整数永远不会改变，所以它总是17。

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

488
00:24:18,030 --> 00:24:20,970
让我们来看看， - 再次提醒我你的名字吗？

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

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

491
00:24:27,340 --> 00:24:30,510
是因为这种情况下总是如此。

492
00:24:30,510 --> 00:24:33,270
我们永远不会改变i的值。

493
00:24:33,270 --> 00:24:36,170
我们永远不会改变该变量中存储的内容。

494
00:24:36,170 --> 00:24:39,180
因此，在这一点上，我们得到了这个错误，

495
00:24:39,180 --> 00:24:42,170
你的程序产生过多的输出，

496
00:24:42,170 --> 00:24:45,100
如果我们向下滚动，看看这是怎么回事种，

497
00:24:45,100 --> 00:24:49,160
你可以看到，它是嗨，嗨，嗨，嗨，嗨，嗨，嗨，一路过关斩将。

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

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

500
00:24:53,750 --> 00:24:57,020
有压痕这里

501
00:24:57,020 --> 00:25:00,110
在身体的while循环没有造成任何影响。

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

503
00:25:03,050 --> 00:25:06,790
通常，对于良好的作风 - 

504
00:25:06,790 --> 00:25:10,210
这是什么，我们期待在您的问题集 - 

505
00:25:10,210 --> 00:25:13,930
我们希望您能缩进4个空格，你可以做

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

507
00:25:16,440 --> 00:25:18,860
或通过手动把自己的4个空格。

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

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

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

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

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

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

514
00:25:37,430 --> 00:25:39,200
>> 好了，所以在这里我们去。

515
00:25:39,200 --> 00:25:41,010
这是代码，亚历山大写道。

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

517
00:25:43,410 --> 00:25:46,380
因此，这里的亚历克斯写的代码。

518
00:25:46,380 --> 00:25:50,500
所以，我们已经得到了我们的声明，主要就在这里，

519
00:25:50,500 --> 00:25:54,410
然后，我们得到了这个整数变量名为i

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

521
00:25:57,320 --> 00:26:01,060
我们已经有了一个do语句

522
00:26:01,060 --> 00:26:04,600
然后身体再次与这些大括号，

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

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

525
00:26:09,210 --> 00:26:12,730
在身，我们正在试图打印“，这是身体”，

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

527
00:26:14,300 --> 00:26:17,710
因此，增加的内容，我这样做

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

529
00:26:19,470 --> 00:26:22,440
那么，我们的程序结束。

530
00:26:22,440 --> 00:26:24,680
>> 所以当我们运行这个程序时，会发生什么呢？

531
00:26:24,680 --> 00:26:27,580
>>我预期的标识符。

532
00:26:27,580 --> 00:26:32,070
好了，因此，建立，运行，就会发生错误。

533
00:26:32,070 --> 00:26:34,820
发生了什么？

534
00:26:34,820 --> 00:26:37,060
我们向下滚动，

535
00:26:37,060 --> 00:26:40,260
我们得到这个有些神秘的东西，

536
00:26:40,260 --> 00:26:43,930
预计分号后的顶级声明。

537
00:26:43,930 --> 00:26:46,620
这是有点怪异。

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

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

540
00:26:54,640 --> 00:26:57,640
>> [听不清]声明以外的括号？

541
00:26:57,640 --> 00:27:03,480
那么，不适用，那么当您使用括号吗？

542
00:27:03,480 --> 00:27:07,390
因此，他宣称这其中括号外的家伙？

543
00:27:09,670 --> 00:27:12,240
噢，这些家伙 - 在大括号？

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

545
00:27:13,850 --> 00:27:15,310
是的，没错。

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

547
00:27:17,120 --> 00:27:21,550
你可以声明一个变量实际上不是在这里是这样的。

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

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

550
00:27:30,110 --> 00:27:34,330
你可以把它在大括号在这里

551
00:27:34,330 --> 00:27:37,400
或另一种选择

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

553
00:27:42,480 --> 00:27:46,610
所以，这些 - 这取决于你居然把声明

554
00:27:46,610 --> 00:27:48,550
该整数变量，

555
00:27:48,550 --> 00:27:53,540
你可以得到2个不同类型的变量;

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

557
00:27:55,100 --> 00:27:58,240
这就是我们所说的一个全局变量。

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

559
00:28:00,070 --> 00:28:03,420
这是不是在函数 - 

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

561
00:28:07,050 --> 00:28:10,000
喜欢这里，然后它被称为局部变量，

562
00:28:10,000 --> 00:28:13,830
因为它是本地的主要范围。

563
00:28:13,830 --> 00:28:16,720
我们将讨论多一点点的区别是什么

564
00:28:16,720 --> 00:28:20,970
之间的2种类型，以及为什么要使用不同类型的变量，

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

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

567
00:28:25,070 --> 00:28:28,320
因为我们没有任何需要全局变量。

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

569
00:28:31,390 --> 00:28:34,680
让我们尝试再次运行这个，看看会发生什么。

570
00:28:37,420 --> 00:28:40,270
运行“，另一个错误。

571
00:28:40,270 --> 00:28:43,320
放大一点，我们都能得到什么呢？

572
00:28:45,110 --> 00:28:50,000
后做/而我们得到这一预期的括号。

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

574
00:28:55,260 --> 00:28:58,880
“一会儿，然后括号，然后 - 

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

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

577
00:29:04,980 --> 00:29:06,930
没错，是的。

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

579
00:29:08,830 --> 00:29:11,230
我们没有必要再在这里把这个类型。

580
00:29:11,230 --> 00:29:14,440
相反，我们可以杀死类型

581
00:29:14,440 --> 00:29:17,220
做到这一点。

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

583
00:29:21,640 --> 00:29:24,950
我会放大，尝试更多的时间。

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

585
00:29:29,580 --> 00:29:33,260
如果我们向下滚动，“这是身体的”打印出来的3倍。

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

587
00:29:35,820 --> 00:29:38,670
干得好，干得好，伙计们。

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

589
00:29:41,080 --> 00:29:43,250
怎么这么远吗？

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

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

592
00:29:49,200 --> 00:29:52,590
>> 因此，作为一种回到原来的问题，

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

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

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

596
00:30:00,030 --> 00:30:02,530
因此，随着计算机读取程序

597
00:30:02,530 --> 00:30:06,050
种在这个顺序执行C程序，

598
00:30:06,050 --> 00:30:09,450
他们从字面上开始与第一线的主要

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

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

601
00:30:16,150 --> 00:30:18,440
这一切的东西在这里的右上角

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

603
00:30:20,020 --> 00:30:23,350
之前我们曾经测试情况，以

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

605
00:30:26,240 --> 00:30:29,750
小于数字3。

606
00:30:29,750 --> 00:30:33,300
只有一次，我们到12号线，

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

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

609
00:30:39,150 --> 00:30:41,140
然后重复这个过程中，

610
00:30:41,140 --> 00:30:44,620
然后我们测试的条件，再一遍又一遍。

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

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

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

614
00:30:56,500 --> 00:31:00,760
我们要看看这个，稍有改变，因此，它不再是一个无限循环 - 

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

616
00:31:03,570 --> 00:31:06,300
我们可以看到，这个程序执行，

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

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

619
00:31:12,030 --> 00:31:15,820
然后它击中的while循环的第一条件，

620
00:31:15,820 --> 00:31:19,210
因此，在这种情况下，这个身体，这个printf（“HI”）和i + +

621
00:31:19,210 --> 00:31:21,630
甚至不会执行

622
00:31:21,630 --> 00:31:24,310
除非实际上i是小于或等于2。

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

624
00:31:26,750 --> 00:31:28,840
如果我们在这里

625
00:31:28,840 --> 00:31:32,160
等于4  - 或者我会做，因为我说3  - 

626
00:31:32,160 --> 00:31:34,890
然后运行它，

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

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

629
00:31:40,530 --> 00:31:43,030
因为它对于第一种情况，测试失败。

630
00:31:44,780 --> 00:31:47,530
因此，在课堂上，我们谈到了为什么这些do-whil​​e循环

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

632
00:31:49,800 --> 00:31:53,140
为什么我们会使用它，而不是一个while循环。

633
00:31:53,140 --> 00:31:56,450
>> 在那里 - 你们有任何的建议

634
00:31:56,450 --> 00:31:59,090
为什么do-whil​​e循环可能更为有用吗？

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

636
00:32:02,560 --> 00:32:05,020
因为这样可以让他们

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

638
00:32:07,780 --> 00:32:09,300
我们可以移动到程序的其余部分，

639
00:32:09,300 --> 00:32:11,250
但如果它是不正确的，那么你继续提示用户

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

641
00:32:13,250 --> 00:32:14,260
是的，没错 - 这正是，

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

643
00:32:16,840 --> 00:32:18,930
提示用户输入，因为当

644
00:32:18,930 --> 00:32:23,000
因为你需要得到用户的输入，才能真正检查。

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

646
00:32:27,330 --> 00:32:29,650
您在何处提示用户输入了很多，

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

648
00:32:31,200 --> 00:32:33,740
而不是只是一个简单的while循环。

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

650
00:32:36,780 --> 00:32:38,750
你可以做同样的事情，一个while循环

651
00:32:38,750 --> 00:32:40,580
当你做一个do-whil​​e循环。

652
00:32:40,580 --> 00:32:43,380
你只需要种有这个重复的过程

653
00:32:43,380 --> 00:32:47,010
你在哪里得到的输入，然后开始你的while循环。

654
00:32:47,010 --> 00:32:49,800
而一个do-whil​​e循环，你只需要编写一次

655
00:32:49,800 --> 00:32:52,430
这是一个很大清洁。

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

657
00:32:55,970 --> 00:32:57,330
有什么问题吗？

658
00:32:59,350 --> 00:33:01,380
有意义吗？

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

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

661
00:33:08,960 --> 00:33:11,960
好了，我们将讨论这有点多了以后

662
00:33:11,960 --> 00:33:13,290
但事实证明，

663
00:33:13,290 --> 00:33:15,720
我们把这个返回0，

664
00:33:15,720 --> 00:33:19,090
结束时的主所有的时间 - 

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

666
00:33:21,980 --> 00:33:24,930
暂时。

667
00:33:24,930 --> 00:33:28,860
现在我们开始谈论与功能

668
00:33:28,860 --> 00:33:31,600
种在上周结束，本周再次

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

670
00:33:33,550 --> 00:33:37,680
需要输入括号内的这些东西;

671
00:33:37,680 --> 00:33:41,690
这是2个输入，参数或参数，

672
00:33:41,690 --> 00:33:44,540
他们也被称为我们的主要功能，

673
00:33:44,540 --> 00:33:48,510
然后一个函数产生一个输出

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

675
00:33:51,290 --> 00:33:56,260
和返回值的情况下，主要是这样的诠释，

676
00:33:56,260 --> 00:33:58,320
这个整数，

677
00:33:58,320 --> 00:34:01,160
告诉函数的方式，“嘿，这是你的输出

678
00:34:01,160 --> 00:34:05,840
将是“是”回归“这个词，

679
00:34:05,840 --> 00:34:07,960
该关键字，而

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

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

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

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

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

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

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

687
00:34:27,440 --> 00:34:31,080
这是用来告诉运行这个程序

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

689
00:34:35,739 --> 00:34:39,989
所以，当我们在这学期更复杂的东西，

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

691
00:34:42,670 --> 00:34:46,650
“哎呀，你知道的，出了这个程序错误”

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

693
00:34:49,409 --> 00:34:52,310
亚军我的程序出现了错误，

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

695
00:34:54,530 --> 00:34:57,230
我们称呼它，这是不为0。

696
00:35:00,180 --> 00:35:02,240
>> 所以我们将讨论多一点点

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

698
00:35:05,480 --> 00:35:09,030
诸如此类的有道理吗？

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

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

701
00:35:13,530 --> 00:35:17,270
我认为有很多的数学背景的人，

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

703
00:35:20,100 --> 00:35:22,540
特别是如果你有一点点抽象的数学背景

704
00:35:22,540 --> 00:35:24,240
和你谈论功能

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

706
00:35:28,590 --> 00:35:30,610
但我们会尽力并覆盖

707
00:35:30,610 --> 00:35:33,280
很好的和缓慢的，因为他们拿出去。

708
00:35:34,730 --> 00:35:37,870
同样，这整个的int argc个，

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

710
00:35:41,090 --> 00:35:44,960
现在，你也可以把它看作锅炉板。

711
00:35:46,650 --> 00:35:49,050
我们已经开始覆盖那些在演讲一点点

712
00:35:49,050 --> 00:35:53,060
当我们谈论到程序中的命令行参数获得通过，

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

714
00:35:55,700 --> 00:35:58,760
这是完全正常，只是写作废，并保持它的简单。

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

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

717
00:36:04,630 --> 00:36:07,440
这仅仅是一个程序，我们会刚刚运行。

718
00:36:07,440 --> 00:36:09,320
我们不会给它任何额外信息。

719
00:36:09,320 --> 00:36:12,420
我们每次启动运行。“

720
00:36:14,730 --> 00:36:16,600
所以现在，你可以做到这一点;

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

722
00:36:19,710 --> 00:36:22,650
您的程序结束时，他们会运行得很好，

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

724
00:36:26,150 --> 00:36:28,320
在几个星期中，我们将开始种

725
00:36:28,320 --> 00:36:31,340
拉回来盖一点点，更多的了解

726
00:36:31,340 --> 00:36:34,380
所有这些不同的小运动部件。

727
00:36:34,380 --> 00:36:38,160
>> 好了，现在让我们来谈谈我们在这里的第二个问题。

728
00:36:38,160 --> 00:36:43,190
那么什么是“未声明的标识符”，则通常表明

729
00:36:43,190 --> 00:36:46,040
如果输出铛？

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

731
00:36:51,170 --> 00:36:54,370
有人可以给一个回顾一下这是什么意思呢？

732
00:36:54,370 --> 00:36:57,680
让我们来看看，凯利 - 的凯丽之一。

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

734
00:37:05,300 --> 00:37:07,080
是啊，这是什么 - 

735
00:37:07,080 --> 00:37:10,140
>>我认为，当你一样，不声明变量，并尝试使用它。

736
00:37:10,140 --> 00:37:13,310
是的，没错，没错。

737
00:37:13,310 --> 00:37:15,250
所以，如果你看到这样的输出

738
00:37:15,250 --> 00:37:17,690
当您尝试编译程序，

739
00:37:17,690 --> 00:37:19,470
就像凯利说，

740
00:37:19,470 --> 00:37:24,210
这意味着你使用一个变量，你没有申报，

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

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

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

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

745
00:37:40,070 --> 00:37:42,440
和尝试，并填写％s的

746
00:37:42,440 --> 00:37:45,640
，我没有任何地方声明一个变量s

747
00:37:45,640 --> 00:37:48,330
我尝试运行它，

748
00:37:48,330 --> 00:37:51,330
你会看到我所得到的，在这个底部就在这里：

749
00:37:51,330 --> 00:37:54,010
“使用未声明的标识符”S“”;

750
00:37:54,010 --> 00:37:57,710
这只是意味着你不声明你的变量。

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

752
00:38:00,750 --> 00:38:05,240
你有X，你尝试和存储7

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

754
00:38:08,720 --> 00:38:10,200
我得到了同样的错误：

755
00:38:10,200 --> 00:38:13,480
“使用未声明的标识符'X'”。

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

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

758
00:38:21,720 --> 00:38:24,590
我将让你们看这短短的，一种明白为什么，

759
00:38:24,590 --> 00:38:27,590
后，希望做这个星期的问题集

760
00:38:27,590 --> 00:38:29,270
在那里你写的恺撒密码，你就会明白一点点

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

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

763
00:38:40,560 --> 00:38:43,140
另一件事是，我们这些其他的问题在这里

764
00:38:43,140 --> 00:38:45,470
有关职能

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

766
00:38:47,330 --> 00:38:52,820
我们种，简要谈到，当我们谈到的返回值;

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

768
00:38:54,560 --> 00:38:57,790
你可以回顾一下谁是今天讲课的吗？

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

770
00:39:01,210 --> 00:39:04,320
让我们来看看，让我们 - 有人可以告诉我们的功能是什么？

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

772
00:39:07,800 --> 00:39:11,260
>> >>基本上是借鉴的东西，写的库

773
00:39:11,260 --> 00:39:14,460
更复杂的那边，然后你只写一个简短的形式，

774
00:39:14,460 --> 00:39:17,360
那么喜欢​​你是指该库，使用

775
00:39:17,360 --> 00:39:19,650
所有的长码和[听不清]。

776
00:39:19,650 --> 00:39:22,680
是的，没错，然后你想添加的东西吗？

777
00:39:22,680 --> 00:39:27,050
>>是的，我把它作为类似数学公式的概念

778
00:39:27,050 --> 00:39:30,130
你只写一个公式，然后你可以插入变量

779
00:39:30,130 --> 00:39:32,660
这就是一个功能是听不见的。

780
00:39:32,660 --> 00:39:35,390
>> 是啊，所以我们有一对夫妇的答案在这里

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

782
00:39:38,080 --> 00:39:43,040
有指使你的代码库中的某处被写入

783
00:39:43,040 --> 00:39:45,390
是更复杂的

784
00:39:45,390 --> 00:39:47,130
然后你可以借鉴的代码

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

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

787
00:39:54,060 --> 00:39:57,590
再有就是数学中的公式比较

788
00:39:57,590 --> 00:40:00,400
或物理，所有这样的东西;

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

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

791
00:40:05,690 --> 00:40:08,100
该公式的变量

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

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

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

795
00:40:17,690 --> 00:40:21,310
二次方程求根公式是什么在数学课上，

796
00:40:21,310 --> 00:40:24,610
你只是有一个小的计算器程序，这样做是为了你。

797
00:40:24,610 --> 00:40:28,930
有没有人在高中数学课中使用的计算器程序？

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

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

800
00:40:34,670 --> 00:40:37,740
这些都是我要输入的变量。

801
00:40:37,740 --> 00:40:40,250
现在给我答案。“

802
00:40:40,250 --> 00:40:42,170
这是一种功能是什么。

803
00:40:42,170 --> 00:40:44,850
这是一个方式，让我们

804
00:40:44,850 --> 00:40:47,720
种写像一个小的小的子计划

805
00:40:47,720 --> 00:40:51,700
在我们的程序

806
00:40:51,700 --> 00:40:55,090
并用它一遍又一遍

807
00:40:55,090 --> 00:40:58,380
所以，我们不必复制和粘贴代码，

808
00:40:58,380 --> 00:41:04,220
我们可以给它不同的输入和得到不同的输出，

809
00:41:04,220 --> 00:41:07,090
这是超级方便

810
00:41:07,090 --> 00:41:11,420
当你试图在不同的时间写不同的程序。

811
00:41:11,420 --> 00:41:14,580
>> 因此，举例来说，一个功能，我们已经使用了一遍又一遍，一遍又一遍

812
00:41:14,580 --> 00:41:17,310
整个过程是printf。

813
00:41:17,310 --> 00:41:19,680
printf是本身就是一个函数

814
00:41:19,680 --> 00:41:23,360
事实证明，它实际上是一个相当漫长而复杂的，

815
00:41:23,360 --> 00:41:26,420
讨厌的，写的功能。

816
00:41:26,420 --> 00:41:29,590
因此，简单的，因为在我们看来，

817
00:41:29,590 --> 00:41:31,810
要打印的东西输出到屏幕上，

818
00:41:31,810 --> 00:41:34,820
因为我们都只是做节今天开始，

819
00:41:34,820 --> 00:41:36,870
事实证明，它实际上是，你知道，

820
00:41:36,870 --> 00:41:39,900
一个很好的情侣几百行代码。

821
00:41:42,030 --> 00:41:45,620
这不是我真的愿意写，可以肯定，

822
00:41:45,620 --> 00:41:47,480
但我们每天都使用它，这是一种很酷的，

823
00:41:47,480 --> 00:41:49,020
所以我们把它分享给对方，

824
00:41:49,020 --> 00:41:51,790
不同的程序，

825
00:41:51,790 --> 00:41:54,520
所以我们就到功能更潜水;

826
00:41:54,520 --> 00:41:56,090
暂时，我们不 - 

827
00:41:56,090 --> 00:41:59,150
我们要编写的唯一功能是主要的。

828
00:41:59,150 --> 00:42:01,570
主本身也是一个函数，

829
00:42:01,570 --> 00:42:04,270
你可以看到它有它的输出，

830
00:42:04,270 --> 00:42:06,610
它的输入就像我们谈到，

831
00:42:06,610 --> 00:42:08,930
那么它的名字，这是主要的。

832
00:42:08,930 --> 00:42:11,800
主要是怎么样的 - 那里是一个特殊的功能。

833
00:42:11,800 --> 00:42:14,800
在你的C程序中，必须有一个主要功能，

834
00:42:14,800 --> 00:42:17,900
所以现在，我们已经遗漏的写作

835
00:42:17,900 --> 00:42:21,400
的原型，或声明的，主要的。

836
00:42:21,400 --> 00:42:23,050
我们已经给了你，

837
00:42:23,050 --> 00:42:25,650
我们刚刚有你填写的空白种。

838
00:42:25,650 --> 00:42:29,120
>> >>因此，对于第二个问题集，我们并不需要

839
00:42:29,120 --> 00:42:31,350
把它写在第二个功能吗？

840
00:42:31,350 --> 00:42:34,200
我不这么认为。

841
00:42:34,200 --> 00:42:37,600
我相信，这一切都在这里。

842
00:42:37,600 --> 00:42:41,710
是啊，所以恺撒密码，

843
00:42:41,710 --> 00:42:45,000
你没有，它看起来并不像，

844
00:42:48,740 --> 00:42:53,150
维琼内尔，你不要么，

845
00:42:53,150 --> 00:42:56,400
 - 事实证明，你没有真正写

846
00:42:56,400 --> 00:42:58,250
的功能，对不对？

847
00:42:58,250 --> 00:43:01,950
你打电话总是把所有的代码在main，

848
00:43:01,950 --> 00:43:04,500
许多程序员做到这一点。

849
00:43:04,500 --> 00:43:07,130
随着我们继续前进，

850
00:43:07,130 --> 00:43:09,480
我们开始引入功能的一种方式

851
00:43:09,480 --> 00:43:11,530
清理你的代码，

852
00:43:11,530 --> 00:43:13,380
，使其更加优雅，

853
00:43:13,380 --> 00:43:16,890
如果你有当我们谈到循环任务 - 有点像，

854
00:43:16,890 --> 00:43:20,400
有时有一些事情你想做的事一而再，再而三，

855
00:43:20,400 --> 00:43:23,510
你有一种天真的方式 - 

856
00:43:23,510 --> 00:43:26,360
也就是我们常称的“稻草人”的解决方案，

857
00:43:26,360 --> 00:43:29,390
只需复制并粘贴一遍又一遍 - 

858
00:43:29,390 --> 00:43:31,000
你可以做同样的事情的功能，您只需复制并粘贴

859
00:43:31,000 --> 00:43:33,360
一遍又一遍相同的代码，

860
00:43:33,360 --> 00:43:35,750
但涨大了你的代码 - 

861
00:43:35,750 --> 00:43:38,550
最终使你的代码很长的 - 

862
00:43:38,550 --> 00:43:41,550
它也变得有点混乱，

863
00:43:41,550 --> 00:43:43,470
那么就意味着，你是不是能够喜欢 - 

864
00:43:43,470 --> 00:43:45,250
如果你想再次使用该代码在另一个程序中，

865
00:43:45,250 --> 00:43:48,610
你还坚持再次复制和粘贴，

866
00:43:48,610 --> 00:43:51,170
这样的事情之一，我们来谈谈

867
00:43:51,170 --> 00:43:54,960
种你的程序的设计和风格，

868
00:43:54,960 --> 00:43:57,010
因此，当它是有道理的种

869
00:43:57,010 --> 00:43:59,800
包的东西，并把它作为一个单独的函数，

870
00:43:59,800 --> 00:44:02,080
我们鼓励你这样做，

871
00:44:02,080 --> 00:44:04,700
那是，再次

872
00:44:04,700 --> 00:44:07,790
有没有硬性规定。

873
00:44:07,790 --> 00:44:11,540
我们很少说，你必须写一个函数调用此，

874
00:44:12,870 --> 00:44:16,320
但更重要的是，一个人的东西，你只是随着时间的发展

875
00:44:16,320 --> 00:44:19,470
为你写的节目越来越多。

876
00:44:21,940 --> 00:44:24,790
>> 还有什么问题吗？

877
00:44:26,340 --> 00:44:30,610
好吧，让我们现在

878
00:44:30,610 --> 00:44:34,750
返回这个家伙在这里，

879
00:44:34,750 --> 00:44:37,800
所以，我仍然在这部分问题。

880
00:44:37,800 --> 00:44:39,900
我们已经讨论了所有这些不同的，

881
00:44:39,900 --> 00:44:42,050
什么是一个函数，为什么写功能，

882
00:44:42,050 --> 00:44:44,700
当你可以复制和粘贴？

883
00:44:44,700 --> 00:44:47,700
希望我们确信你写功能是一件好事。

884
00:44:47,700 --> 00:44:50,870
所以，现在让我们继续这MySpace的计划，

885
00:44:50,870 --> 00:44:53,080
我们会花一点点的时间这样做。

886
00:44:54,600 --> 00:44:56,480
>> 所以，让我们来看看，

887
00:44:56,480 --> 00:45:00,230
我有一个人读这个吗？

888
00:45:02,640 --> 00:45:04,660
让我们Mikhaila  - 你阅读这篇文章，我们呢？

889
00:45:07,660 --> 00:45:08,890
>>你的意思是回来时，MySpace的 - 

890
00:45:08,890 --> 00:45:10,920
回来时，MySpace是酷。

891
00:45:10,920 --> 00:45:12,070
“返回时，MySpace是凉爽，

892
00:45:12,070 --> 00:45:14,900
这是所有的愤怒，象这样。

893
00:45:14,900 --> 00:45:17,320
也许它仍然是吗？我真的不知道。

894
00:45:17,320 --> 00:45:19,990
在任何情况下，使用CS50电器，

895
00:45:19,990 --> 00:45:22,600
CS50运行，或CS50空间的的，

896
00:45:22,600 --> 00:45:25,370
写一个程序，提示用户的消息

897
00:45:25,370 --> 00:45:29,350
它的第一个字母大写，然后输出信息，

898
00:45:29,350 --> 00:45:31,800
在交替的情况下，与所有其他字母，

899
00:45:31,800 --> 00:45:34,010
如下面的示例输出，

900
00:45:34,010 --> 00:45:37,060
其中粗体文字表示一些用户的输入。

901
00:45:37,060 --> 00:45:39,800
为简单起见，你可以假设用户

902
00:45:39,800 --> 00:45:42,810
只能输入小写字母和空格。

903
00:45:42,810 --> 00:45:45,900
考虑这个问题的一个练习的机会;

904
00:45:45,900 --> 00:45:48,640
你不会被要求提交这一计划。“

905
00:45:48,640 --> 00:45:51,640
>> 真棒，谢谢你。

906
00:45:51,640 --> 00:45:54,750
因此，作为Mikhaila说，

907
00:45:54,750 --> 00:45:58,850
我们要编写一个程序，MySpaces你的代码。

908
00:45:58,850 --> 00:46:02,230
因此，没有任何你们使用MySpace上吗？

909
00:46:02,230 --> 00:46:04,100
你有任何MySpace帐户？

910
00:46:04,100 --> 00:46:05,920
哦，是啊，是啊！

911
00:46:05,920 --> 00:46:08,300
这是很酷。

912
00:46:08,300 --> 00:46:09,950
[笑声]

913
00:46:09,950 --> 00:46:12,060
我知道。

914
00:46:12,060 --> 00:46:14,500
约会自己。

915
00:46:15,490 --> 00:46:18,300
所以我们正在试图做的是写一个程序，

916
00:46:18,300 --> 00:46:21,110
经过

917
00:46:21,110 --> 00:46:24,490
的首字母大写

918
00:46:24,490 --> 00:46:27,140
然后此后的每一个字母 - 

919
00:46:27,140 --> 00:46:29,350
其后或其他字母，对不起。

920
00:46:29,350 --> 00:46:32,910
>> 所以 - 你可以看到在这个例子中，

921
00:46:32,910 --> 00:46:35,260
这是怎么了，我们运行程序，

922
00:46:35,260 --> 00:46:38,780
所以这只是说，“我们正在运行一个名为a.out的程序。

923
00:46:41,490 --> 00:46:44,630
我们要赋予它的输入，

924
00:46:44,630 --> 00:46:47,090
将被提示。

925
00:46:47,090 --> 00:46:51,150
我们不是让你去提供在命令行上输入“。

926
00:46:51,150 --> 00:46:54,100
如果你一直遵循所有的演讲

927
00:46:54,100 --> 00:46:56,710
和听到的命令行参数，

928
00:46:57,810 --> 00:47:00,080
这是种者 - 那时髦的语法

929
00:47:00,080 --> 00:47:04,530
在主要的用int argc个，所有的东西，

930
00:47:04,530 --> 00:47:07,630
所以在这里我们没有使用;我们并没有任何的处理。

931
00:47:09,400 --> 00:47:12,650
我们只是得到这类型的用户，

932
00:47:12,650 --> 00:47:15,700
那么这第二个行与时髦的资本

933
00:47:15,700 --> 00:47:18,550
是什么，我们希望我们的程序输出。

934
00:47:19,790 --> 00:47:22,860
>> 因此，而不是使用设备或运行中，我们将使用空间，

935
00:47:22,860 --> 00:47:25,360
因为我们有空间，

936
00:47:25,360 --> 00:47:28,640
因此，如果你们会

937
00:47:28,640 --> 00:47:32,380
让你的代码看起来像这样，

938
00:47:32,380 --> 00:47:35,930
所以我要救这个修订

939
00:47:35,930 --> 00:47:38,390
只是让你在这里得到了锅炉板

940
00:47:38,390 --> 00:47:42,840
像这样的，诠释的主要（无效），什么也没有。

941
00:47:44,480 --> 00:47:48,460
其实，我们要做的是，我们只是删除一切。

942
00:47:48,460 --> 00:47:50,330
我们希望有一个空白的石板，

943
00:47:50,330 --> 00:47:52,470
因为我们不会开始编写代码;

944
00:47:52,470 --> 00:47:55,380
相反，我们要去尝试写一些伪代码

945
00:47:55,380 --> 00:47:58,580
这真的只是意味着我们将写的东西，这不是代码

946
00:47:58,580 --> 00:48:01,010
这样的描述，我们想要做的是什么，

947
00:48:01,010 --> 00:48:05,180
有点像大卫那样在第一天的演讲，

948
00:48:05,180 --> 00:48:08,310
我想是第二天的演讲时，他做了整个袜子演示。

949
00:48:08,310 --> 00:48:10,990
你们还记得 - 看到袜子呢？

950
00:48:10,990 --> 00:48:13,300
约瑟夫是在那里种输入中英文吗？

951
00:48:13,300 --> 00:48:16,300
所以，我们要做同样的事情。

952
00:48:16,300 --> 00:48:18,380
>> 所以，当我开始写伪代码，

953
00:48:18,380 --> 00:48:22,640
我喜欢的输入将是开始。

954
00:48:22,640 --> 00:48:24,950
我给自己一个样品的情况下，

955
00:48:24,950 --> 00:48:28,780
所以像添加“谢谢！”

956
00:48:35,030 --> 00:48:38,010
然后我也写的是什么，我想要的输出，

957
00:48:38,010 --> 00:48:42,210
在这种情况下是这样的事情。

958
00:48:53,790 --> 00:48:56,050
给了我一个这样的好事，比如，开始认为，

959
00:48:56,050 --> 00:48:59,730
“好吧，我想采取1号线

960
00:48:59,730 --> 00:49:03,560
我想将其改造成2行，“

961
00:49:03,560 --> 00:49:06,570
而这种帮助引导我的思想。

962
00:49:06,570 --> 00:49:09,990
这是一个良好的开端。

963
00:49:09,990 --> 00:49:12,190
另一种思考方式，也为我们还挺移动

964
00:49:12,190 --> 00:49:15,020
和你这样做，是在自己的程序

965
00:49:15,020 --> 00:49:18,530
认为像边缘的情况下，这是什么样的呢？

966
00:49:18,530 --> 00:49:20,740
是什么样的怪异的情景吗？

967
00:49:20,740 --> 00:49:23,660
奇怪的投入，我们可能会得到什么？

968
00:49:23,660 --> 00:49:26,550
这些产出应该是什么样子？

969
00:49:26,550 --> 00:49:29,670
例如，一个奇怪的输入

970
00:49:29,670 --> 00:49:33,200
会是这一个，

971
00:49:33,200 --> 00:49:35,630
创建绝对没问题，

972
00:49:35,630 --> 00:49:37,840
像我们在这种情况下，输出吗？

973
00:49:37,840 --> 00:49:40,530
我们想要的东西去思考，太。

974
00:49:40,530 --> 00:49:44,450
>> 因此，正如一个问题，

975
00:49:44,450 --> 00:49:46,870
我们可能要输出什么？

976
00:49:46,870 --> 00:49:50,740
如果我们没有得到任何输入，如果我们的程序输出？

977
00:49:53,740 --> 00:49:54,860
“什么也没有。

978
00:49:54,860 --> 00:49:57,340
什么都没有？听起来很不错。

979
00:49:57,340 --> 00:49:59,280
因此，我们要确保我们不写任何东西

980
00:49:59,280 --> 00:50:01,500
如果我们没有得到任何东西英寸

981
00:50:01,500 --> 00:50:04,320
酷。好吧。

982
00:50:04,320 --> 00:50:07,370
所以

983
00:50:07,370 --> 00:50:09,380
我要叫上几个人，我们去通过

984
00:50:09,380 --> 00:50:12,790
只是有点像一般的算法是什么

985
00:50:12,790 --> 00:50:15,250
样开始，我们会一起度过这次难关。

986
00:50:16,240 --> 00:50:19,710
>> 所以，让我们来看看。大小姐。

987
00:50:19,710 --> 00:50:21,220
您如何看待我们就开始吗？

988
00:50:21,220 --> 00:50:24,830
这将是一个好地方，从这里开始

989
00:50:24,830 --> 00:50:27,900
如果我们要进行改造，比如，1号线

990
00:50:27,900 --> 00:50:29,440
到第2行吗？

991
00:50:29,440 --> 00:50:32,650
你能种只是向我解释，英语，你在想什么？

992
00:50:32,650 --> 00:50:34,770
不要担心代码。

993
00:50:34,770 --> 00:50:38,250
>>我会做的第一件事情将是

994
00:50:38,250 --> 00:50:41,170
种直接用户，告诉他们你想要什么。

995
00:50:41,170 --> 00:50:44,730
好了，所以，比如说，

996
00:50:44,730 --> 00:50:47,450
“嘿，用户，我想

997
00:50:47,450 --> 00:50:50,560
一个字符串“ - 真棒。

998
00:50:50,560 --> 00:50:52,990
因此，让我们把这个写下来。

999
00:50:52,990 --> 00:50:56,140
提示用户输入一个字符串。

1000
00:50:56,140 --> 00:50:59,270
这听起来像一个良好的开端。

1001
00:51:03,920 --> 00:51:06,460
好的。

1002
00:51:06,460 --> 00:51:09,750
让我们问凯利任。

1003
00:51:09,750 --> 00:51:11,580
什么我们愿意做的事吗？

1004
00:51:11,580 --> 00:51:14,220
我们的未来是什么样的 - ？

1005
00:51:14,220 --> 00:51:18,080
>>收集他们的意见，并将其存储为一个变量。

1006
00:51:18,080 --> 00:51:20,470
大。

1007
00:51:20,470 --> 00:51:24,280
因此，收集的字符串，

1008
00:51:25,450 --> 00:51:27,880
它存储在变量中。

1009
00:51:34,840 --> 00:51:36,460
那么，有没有什么特别的，我们要在这里做吗？

1010
00:51:36,460 --> 00:51:39,700
我们要检查他们的意见

1011
00:51:39,700 --> 00:51:42,260
前 - ？

1012
00:51:42,260 --> 00:51:43,790
>>呀。

1013
00:51:43,790 --> 00:51:46,330
我们可能要检查什么？

1014
00:51:46,330 --> 00:51:48,980
>>嗯，你说我们没有检查它是否是一个数字，对吗？

1015
00:51:48,980 --> 00:51:52,400
因为它会假设它是小写吗？

1016
00:51:52,400 --> 00:51:55,650
是啊。

1017
00:51:56,380 --> 00:51:58,920
>> 因此，原来， - 是啊。

1018
00:51:58,920 --> 00:52:01,850
因此，保证返回一个字符串的getString。

1019
00:52:01,850 --> 00:52:05,050
它不会返回一个数字或类似的东西。

1020
00:52:05,050 --> 00:52:09,140
有可能是数字字符在该字符串。

1021
00:52:09,140 --> 00:52:13,460
而这些，我们可以忽略，因为我们没有资本化。

1022
00:52:13,460 --> 00:52:16,620
但一个空字符串是完全正常的，

1023
00:52:16,620 --> 00:52:19,900
这样的情况下，于4日和5号线在这里，

1024
00:52:19,900 --> 00:52:22,020
正确的，那里没有输入，

1025
00:52:22,020 --> 00:52:25,190
我们已经把什么作为输出。

1026
00:52:25,190 --> 00:52:28,730
我们不必担心肯定有什么东西在字符串中

1027
00:52:28,730 --> 00:52:31,840
该字符串是至少4个字符长;

1028
00:52:31,840 --> 00:52:34,190
什么是好的。

1029
00:52:34,190 --> 00:52:38,270
因此，这是对比，例如，像便士你写的程序，

1030
00:52:38,270 --> 00:52:42,340
其中，以确保你得到非负数;

1031
00:52:42,340 --> 00:52:46,430
你必须确保你得到正确的天数在一个月内。

1032
00:52:46,430 --> 00:52:49,630
如何你们这样做吗？

1033
00:52:49,630 --> 00:52:51,470
你将如何做这个测试吗？

1034
00:52:51,470 --> 00:52:54,090
那是什么要求你使用吗？

1035
00:52:54,090 --> 00:52:55,650
>> do-whil​​e循环。

1036
00:52:55,650 --> 00:53:00,840
do-whil​​e循环，其他类型的循环，太多，是的。

1037
00:53:02,190 --> 00:53:04,520
因此，原来，我们没有在这种情况下，使用一个循环，

1038
00:53:04,520 --> 00:53:07,360
当我们提示的字符串，这是一种不错的。

1039
00:53:08,280 --> 00:53:10,620
>> 好吧，继续前进。

1040
00:53:12,410 --> 00:53:14,270
所以，斯特拉。

1041
00:53:14,270 --> 00:53:17,530
你能告诉我们什么，我们下一步应该做的一点点吗？

1042
00:53:17,530 --> 00:53:20,270
现在，我们已经得到的字符串，我们已经有了它存储在一个变量;

1043
00:53:20,270 --> 00:53:23,360
的字符串，我们需要做的是什么？

1044
00:53:26,790 --> 00:53:33,530
>>我们需要 - 

1045
00:53:33,530 --> 00:53:36,550
识别的2  - 

1046
00:53:36,550 --> 00:53:39,290
是啊，就用英语说，这是真棒。

1047
00:53:39,290 --> 00:53:42,670
>>确定[听不清]首都 - 或大写字母。

1048
00:53:44,420 --> 00:53:48,130
是啊，所以你识别哪些是大写和小写。

1049
00:53:50,020 --> 00:53:54,180
我们可以没有他们，直到我们已经确定了哪些大写或小写。

1050
00:54:03,790 --> 00:54:06,350
因此，我们将在这里。

1051
00:54:06,350 --> 00:54:10,210
>> 所以，只要一想到这个过程中，

1052
00:54:10,210 --> 00:54:13,200
我们怎么做这个鉴定呢？

1053
00:54:13,200 --> 00:54:15,050
你知道吗，丹？

1054
00:54:15,050 --> 00:54:18,120
种什么，我们 - 我们不得不使用我们的工具箱里什么工具？

1055
00:54:18,120 --> 00:54:22,500
>>我把它在某种方式中像一个数组或每行

1056
00:54:22,500 --> 00:54:24,240
是它自己的小盒子，

1057
00:54:24,240 --> 00:54:27,240
然后大写有或没有。

1058
00:54:27,240 --> 00:54:30,440
好了，所以我们可以利用的一个工具，是一个数组。

1059
00:54:30,440 --> 00:54:33,760
我们有什么看在字符串中的，

1060
00:54:33,760 --> 00:54:36,680
不过，要弄清楚 - 我们有看的字符。

1061
00:54:36,680 --> 00:54:40,890
“所以，你得看在字符串的长度？

1062
00:54:40,890 --> 00:54:43,880
是啊，所以得到的字符串的长度。

1063
00:54:50,450 --> 00:54:54,150
只是出于好奇，我们用它来得到一个字符串的长度？

1064
00:54:54,150 --> 00:54:58,080
>> strlen的？

1065
00:54:58,080 --> 00:55:02,870
是啊，strlen的，我们称之为“strlen的”

1066
00:55:04,180 --> 00:55:08,620
所有这些字符串函数，所以strlen的是一个函数，

1067
00:55:08,620 --> 00:55:10,670
这是超级方便的，因为我们可以用它来只是说，

1068
00:55:10,670 --> 00:55:13,430
嘿，strlen的：这是一个字符串，你能告诉我它有多长。

1069
00:55:13,430 --> 00:55:17,350
在今天的演讲中，大卫谈了很多关于如何strlen的实施，

1070
00:55:17,350 --> 00:55:20,370
幕后到底发生了什么。

1071
00:55:20,370 --> 00:55:25,450
但是这是一个非常超级方便的。

1072
00:55:25,450 --> 00:55:29,170
有也字符串中的库的其他那些，

1073
00:55:29,170 --> 00:55:34,690
如STRCMP的拼写是“STRCMP”，

1074
00:55:34,690 --> 00:55:38,010
这是用来相互比较字符串。

1075
00:55:41,220 --> 00:55:45,020
您将使用函数strstr一样，

1076
00:55:45,020 --> 00:55:48,770
这是很好的发现子串等。

1077
00:55:48,770 --> 00:55:53,380
在大多数情况下，他们开始用str，然后去别的东西。

1078
00:55:53,380 --> 00:55:57,080
的原因，他们没有实际拼写，如字符串，等等

1079
00:55:57,080 --> 00:56:00,260
因为早在初期的C一样，

1080
00:56:00,260 --> 00:56:04,100
当人们第一次写操作，这一切，

1081
00:56:04,100 --> 00:56:07,580
他们，你可以使用的字符数限制

1082
00:56:07,580 --> 00:56:09,950
函数名和变量名，

1083
00:56:09,950 --> 00:56:12,620
所以，一切都像超浓缩。

1084
00:56:12,620 --> 00:56:15,750
但是，任何时候，你看到的东西，开始用str，

1085
00:56:15,750 --> 00:56:18,600
通常是指有做一个字符串。

1086
00:56:20,990 --> 00:56:23,350
>> 好了，你已经得到了字符串的长度，

1087
00:56:23,350 --> 00:56:27,110
然后，我们做的字符？

1088
00:56:27,110 --> 00:56:29,020
你知道吗，萨姆？

1089
00:56:29,020 --> 00:56:32,410
>>我不知道，我正试图弄明白。

1090
00:56:32,410 --> 00:56:35,410
我真的不知道 - 我希望有一些方法 - 

1091
00:56:35,410 --> 00:56:38,990
我的意思是，我想，也许我们可以做一些事情的赔率，均匀，

1092
00:56:38,990 --> 00:56:40,860
但我不知道任何这样的功能。

1093
00:56:40,860 --> 00:56:42,240
是啊。

1094
00:56:43,160 --> 00:56:45,200
“但是，这 - 它不一定会工作，

1095
00:56:45,200 --> 00:56:48,690
因为那样的话，你会得到的空间 - 

1096
00:56:48,690 --> 00:56:51,130
你就必须有足够的空间，以获得关于如何 - 

1097
00:56:51,130 --> 00:56:54,310
好吧。

1098
00:56:54,310 --> 00:56:56,490
我不知道 - 我在这一点上失去了。

1099
00:56:56,490 --> 00:56:58,120
是啊 - 不，不，不，这些都是很好的点。

1100
00:56:58,120 --> 00:57:00,420
所以，我们需要做的是，像萨姆说，

1101
00:57:00,420 --> 00:57:02,970
我们需要跟踪的字母是奇怪的字母，

1102
00:57:02,970 --> 00:57:05,540
的，哪些是偶数字母。

1103
00:57:06,650 --> 00:57:09,090
但是，我们要确保我们不只是寻找

1104
00:57:09,090 --> 00:57:12,110
在奇数场和偶数

1105
00:57:12,110 --> 00:57:14,030
指数在字符串中，

1106
00:57:14,030 --> 00:57:17,660
而是寻找在字符串中的奇数和偶数的字母，

1107
00:57:17,660 --> 00:57:20,190
因此，我们需要还挺有这之间的区别

1108
00:57:20,190 --> 00:57:25,190
字母 - 像实际上是A，B，C，D等，

1109
00:57:25,190 --> 00:57:29,090
什么事都没有字母，但仍然在我们的字符串。

1110
00:57:29,090 --> 00:57:32,390
例如，在这里，像这样的感叹点是不信，

1111
00:57:32,390 --> 00:57:36,060
但它仍然是我们的字符串的一部分，它仍然是一个字符。

1112
00:57:36,060 --> 00:57:38,820
同样，所有的这些空间 - 

1113
00:57:38,820 --> 00:57:41,710
不利用的空间，对不对？

1114
00:57:41,710 --> 00:57:46,160
因此，我们要确保我们莫名其妙地跳过这些

1115
00:57:46,160 --> 00:57:49,410
，同时还跟踪总入球数单。

1116
00:57:50,900 --> 00:57:54,990
>> 所以在我们的编程工具箱

1117
00:57:54,990 --> 00:57:57,270
到目前为止，如果你愿意，

1118
00:57:57,270 --> 00:58:01,310
我们有许多不同的工具，我们已经谈到了。

1119
00:58:01,310 --> 00:58:04,640
因此在一个，例如，是变量，

1120
00:58:04,640 --> 00:58:07,120
就像我们以前谈到这里。

1121
00:58:07,120 --> 00:58:10,730
另一种工具，我们所谈论的是功能。

1122
00:58:10,730 --> 00:58:15,800
因此，我们已经讨论过的变量，我们的伪代码在这里

1123
00:58:15,800 --> 00:58:19,760
正如我们将用它来存储我们的字符串。

1124
00:58:19,760 --> 00:58:24,630
我们已经讨论了函数来获取一个字符串的长度，如strlen的。

1125
00:58:28,510 --> 00:58:31,170
我们一直在谈论别的事情，我们已经谈论了

1126
00:58:31,170 --> 00:58:34,850
进行了大量前面部分的今天：循环。

1127
00:58:39,390 --> 00:58:42,030
>> 你们觉得在这个程序中使用循环？

1128
00:58:42,030 --> 00:58:44,110
贾里德，你有什么感想？

1129
00:58:47,150 --> 00:58:50,030
在这个程序中，我们使用一个循环？

1130
00:58:50,030 --> 00:58:52,500
“也许不，不，因为你没有去多一次。

1131
00:58:52,500 --> 00:58:55,260
好了，你没有通过什么去多一次？

1132
00:58:55,260 --> 00:58:57,190
>>的整个字符串。

1133
00:58:57,190 --> 00:59:00,660
好，那你不有一次去的字符串全。

1134
00:59:00,660 --> 00:59:03,330
遗憾的是，绝对没有任何意义！

1135
00:59:03,330 --> 00:59:06,360
你不必去通过整个字符串不止一次。

1136
00:59:06,360 --> 00:59:08,660
好吧。

1137
00:59:09,790 --> 00:59:11,920
你怎么想？

1138
00:59:11,920 --> 00:59:14,110
>>我认为这是更好地使用它们

1139
00:59:14,110 --> 00:59:16,640
所以我们可以这样做利用，而

1140
00:59:16,640 --> 00:59:19,750
它的位置是[听不清]数。

1141
00:59:19,750 --> 00:59:22,940
太好了，所以利用什么？

1142
00:59:22,940 --> 00:59:25,200
好了，所以我们说，

1143
00:59:25,200 --> 00:59:28,130
因为我们想，我们应该使用一个循环

1144
00:59:28,130 --> 00:59:32,550
大写字母，虽然它不是一个数字。

1145
00:59:35,130 --> 00:59:37,140
 - 对不起，没有您要添加吗？

1146
00:59:37,140 --> 00:59:39,340
>>我要说的话，你的方式治疗的字符串

1147
00:59:39,340 --> 00:59:42,290
[听不清]将[听不清]的字符？

1148
00:59:42,290 --> 00:59:43,710
是啊。

1149
00:59:43,710 --> 00:59:45,850
>>，然后我们可以指定号码 - 

1150
00:59:45,850 --> 00:59:47,780
或基于位置的字符串中的字母？

1151
00:59:47,780 --> 00:59:49,720
是啊。

1152
00:59:49,720 --> 00:59:53,640
>>，并确定它是否是奇数或偶数和大写字母本身

1153
00:59:53,640 --> 00:59:57,750
而信的位置是听不见的 - 对不起。

1154
00:59:57,750 --> 01:00:00,150
大。

1155
01:00:00,150 --> 01:00:03,430
>> 因此，只要回顾一下。

1156
01:00:03,430 --> 01:00:05,840
你的名字，你能提醒我 - 我很抱歉。

1157
01:00:05,840 --> 01:00:06,900
“夏洛特。

1158
01:00:06,900 --> 01:00:08,490
夏洛特，没问题。

1159
01:00:08,490 --> 01:00:11,130
那么，什么夏洛特说，

1160
01:00:11,130 --> 01:00:14,950
这是完全正确的 - 天哪，我喜欢汽车缩进 - 

1161
01:00:14,950 --> 01:00:17,770
是，如果我们检查一个字符串

1162
01:00:17,770 --> 01:00:19,160
如这一个在顶部 - 

1163
01:00:19,160 --> 01:00:21,590
“谢谢你的”添加“ - 

1164
01:00:21,590 --> 01:00:24,790
为一个字符序列

1165
01:00:24,790 --> 01:00:29,010
在位置0，

1166
01:00:29,010 --> 01:00:32,260
h是在位置1。

1167
01:00:32,260 --> 01:00:36,880
一个是在2，然后我们得到了3，4，5;

1168
01:00:36,880 --> 01:00:40,830
的空间是在6位。

1169
01:00:42,380 --> 01:00:45,300
鉴于 -  f的位置是什么？

1170
01:00:45,300 --> 01:00:47,610
7！

1171
01:00:47,610 --> 01:00:49,300
O？ 8。

1172
01:00:49,300 --> 01:00:52,070
R？ 9。

1173
01:00:52,070 --> 01:00:54,340
然后，我们得到了10，然后我真的不能没有它的把它写

1174
01:00:54,340 --> 01:00:57,430
有点让凌乱的在屏幕上。

1175
01:00:57,430 --> 01:01:02,340
但是，这其实是我们可以谈论如何在内存中的字符串。

1176
01:01:02,340 --> 01:01:04,660
它是一个字符串

1177
01:01:04,660 --> 01:01:07,920
是一个字符序列，

1178
01:01:07,920 --> 01:01:12,430
当我们提到一个单个的字符在字符串中，

1179
01:01:12,430 --> 01:01:15,280
我们经常这样做参照该字符的位置

1180
01:01:15,280 --> 01:01:17,620
在字符串中，

1181
01:01:17,620 --> 01:01:19,910
可能以同样的方式，当我们谈论九月

1182
01:01:19,910 --> 01:01:22,870
的第九个月的一年

1183
01:01:22,870 --> 01:01:27,730
或星期一是一周的第一天。

1184
01:01:29,280 --> 01:01:33,070
因此，这为我们提供了一种方法，

1185
01:01:33,070 --> 01:01:37,030
找出哪些是奇与偶

1186
01:01:37,030 --> 01:01:39,540
因为你可以在这里看到，

1187
01:01:39,540 --> 01:01:43,640
如果我们符合了这件T，

1188
01:01:46,310 --> 01:01:49,360
你可以看到，所有符合资本化条件的

1189
01:01:49,360 --> 01:01:53,040
在偶数位置，

1190
01:01:53,040 --> 01:01:55,880
至少在第一个字，

1191
01:01:55,880 --> 01:01:59,080
然后事情变得揭去后，我们打的空间，

1192
01:01:59,080 --> 01:02:02,460
因为我们不指望这个空间为一个字母，

1193
01:02:02,460 --> 01:02:05,150
所以，如果我们开始

1194
01:02:05,150 --> 01:02:08,930
去0，1，2，3，4，5，

1195
01:02:08,930 --> 01:02:12,600
空间，6，7，8，空间，

1196
01:02:12,600 --> 01:02:16,440
9，然后10，11，12，并依此类推。

1197
01:02:19,300 --> 01:02:22,910
>> 酷，所以我们肯定会想使用某种循环

1198
01:02:22,910 --> 01:02:27,760
去中的每个字符。

1199
01:02:31,330 --> 01:02:34,580
因此，在这一点上，

1200
01:02:36,490 --> 01:02:38,360
我们再回过头来我们这里的老伪代码。

1201
01:02:40,970 --> 01:02:42,650
作为这个识别哪些

1202
01:02:42,650 --> 01:02:45,350
是大写的，哪些是小写，

1203
01:02:45,350 --> 01:02:48,340
我们将要做到这一点，在某种循环。

1204
01:02:51,080 --> 01:02:53,390
“循环”，冒号。

1205
01:02:55,070 --> 01:03:01,220
什么样的类型，我们的循环，循环，

1206
01:03:01,220 --> 01:03:03,670
似乎是一个很好的使用在这种情况下？

1207
01:03:03,670 --> 01:03:05,610
>>我想在for循环。

1208
01:03:05,610 --> 01:03:07,500
你为什么要思考的for循环？

1209
01:03:07,500 --> 01:03:10,000
>>因为它从0开始，然后

1210
01:03:10,000 --> 01:03:13,000
当我们到达字符串的长度，

1211
01:03:13,000 --> 01:03:16,170
，然后每次迭代中，您可以[听不清]吗？

1212
01:03:16,170 --> 01:03:18,260
是的，没错。

1213
01:03:18,260 --> 01:03:21,490
因此，出于不同的选择的循环，

1214
01:03:21,490 --> 01:03:25,350
我们有for循环，while循环，do-whil​​e循环。

1215
01:03:25,350 --> 01:03:28,550
一个for循环是特别有用的

1216
01:03:28,550 --> 01:03:32,120
当你想知道

1217
01:03:32,120 --> 01:03:34,940
你在循环中的一种，

1218
01:03:34,940 --> 01:03:38,520
循环已经执行了多少次为止。

1219
01:03:38,520 --> 01:03:42,490
这正是我们想知道在这种情况下，

1220
01:03:42,490 --> 01:03:44,640
像凯利说，

1221
01:03:44,640 --> 01:03:47,400
根据夏洛特的先前的评论，我们想知道的位置

1222
01:03:47,400 --> 01:03:49,900
在字符串中的字符，

1223
01:03:49,900 --> 01:03:51,750
和for循环会给我们带来了这一点，

1224
01:03:51,750 --> 01:03:54,680
因为，如果我们回头看我们的字符串开始种，

1225
01:03:54,680 --> 01:03:57,140
如果我们开始我们的for循环为0，

1226
01:03:57,140 --> 01:04:00,350
我们上去通过整个字符串的长度，

1227
01:04:00,350 --> 01:04:04,740
然后，我们可以将字母T

1228
01:04:04,740 --> 01:04:08,110
0的循环，

1229
01:04:09,950 --> 01:04:13,080
字母H的1在我们的for循环，依此类推，

1230
01:04:13,080 --> 01:04:16,600
将所有的方式通过字符串的结尾。

1231
01:04:18,810 --> 01:04:21,890
>> 因此，让我们开始编码这只是一点点

1232
01:04:21,890 --> 01:04:24,930
只是让你们得到的感觉，这看起来像。

1233
01:04:24,930 --> 01:04:27,980
我要救，

1234
01:04:27,980 --> 01:04:31,230
所以在这里，我们已经得到了我们的伪代码，

1235
01:04:33,490 --> 01:04:38,120
我要删除一切。

1236
01:04:38,120 --> 01:04:42,210
所以，我有一个空白的石板。

1237
01:04:42,210 --> 01:04:45,910
我要开始写（无效）

1238
01:04:45,910 --> 01:04:48,440
{

1239
01:04:48,440 --> 01:04:51,380
我会把返回0

1240
01:04:51,380 --> 01:04:53,320
然后}。

1241
01:04:53,320 --> 01:04:56,130
因此，通常当我开始计划，这是我的开始。

1242
01:04:56,130 --> 01:04:59,370
我会保存它，以便你们有它。

1243
01:05:06,290 --> 01:05:08,440
因此，我们谈论的第一件事情之一是

1244
01:05:08,440 --> 01:05:10,920
得到来自用户的输入

1245
01:05:10,920 --> 01:05:13,740
并把它存储在一个字符串中。

1246
01:05:13,740 --> 01:05:16,420
我们怎样才能从用户的输入？

1247
01:05:16,420 --> 01:05:19,640
>> GetString的。

1248
01:05:19,640 --> 01:05:21,870
GetString时，所有的权利。

1249
01:05:23,150 --> 01:05:26,820
所以，如果我输入的GetString（）

1250
01:05:26,820 --> 01:05:32,150
和分号。

1251
01:05:32,150 --> 01:05:36,630
让我们尝试运行来看，第一呢？

1252
01:05:36,630 --> 01:05:38,430
为什么不运行？

1253
01:05:38,430 --> 01:05:40,090
>>您必须声明变量。

1254
01:05:40,090 --> 01:05:43,040
我要声明一个变量。好吧。

1255
01:05:43,040 --> 01:05:45,700
>> 那么，如何才能做到这一点？

1256
01:05:45,700 --> 01:05:48,400
你不介意写的东西，分享了吗？

1257
01:05:48,400 --> 01:05:51,270
然后，我们可以把它拽上来。

1258
01:05:51,270 --> 01:05:54,630
让我们来看看，但正确的，没问题。

1259
01:05:54,630 --> 01:05:59,100
大牛。复制，字符串输入的GetString（）。

1260
01:05:59,100 --> 01:06:01,340
真棒。

1261
01:06:01,340 --> 01:06:02,890
这会不会跑？

1262
01:06:02,890 --> 01:06:05,210
让我们试试吧。

1263
01:06:05,210 --> 01:06:08,890
命中来看，上载源代码，建筑，发生了错误。

1264
01:06:08,890 --> 01:06:11,040
好吧。

1265
01:06:11,040 --> 01:06:14,950
因此，whats怎么回事呢？

1266
01:06:14,950 --> 01:06:18,700
使用未声明的标识符“字符串”。

1267
01:06:18,700 --> 01:06:22,840
>>我们有包括库吗？

1268
01:06:22,840 --> 01:06:25,130
是啊，所以丹说，我们有包括库。

1269
01:06:25,130 --> 01:06:28,270
这是你会说，斯特拉？真棒。

1270
01:06:29,450 --> 01:06:31,430
这是可怕的，所以斯特拉，你能

1271
01:06:31,430 --> 01:06:34,800
复制此代码的丹尼尔的空间？

1272
01:06:34,800 --> 01:06:37,580
如果您点击上丹尼尔·罗兰文，将其复制，

1273
01:06:37,580 --> 01:06:41,360
然后你把include行，然后保存它吗？

1274
01:06:46,580 --> 01:06:49,360
让我知道，当你准备好了。

1275
01:06:57,160 --> 01:06:59,490
因此，这包括语法也是一种时髦;

1276
01:06:59,490 --> 01:07:02,210
有这样的散列标签，

1277
01:07:02,210 --> 01:07:05,760
的，然后有这些尖括号。

1278
01:07:12,490 --> 01:07:15,360
你还记得是如何工作的，或者我应该把它放在这个代码在这里吗？

1279
01:07:15,360 --> 01:07:17,850
>>我很好。

1280
01:07:17,850 --> 01:07:19,810
好吧。

1281
01:07:19,810 --> 01:07:23,260
>>我打印了 - 我不知道哪个库，虽然。

1282
01:07:23,260 --> 01:07:25,570
哦，好吧 - 是的，所以它的的CS50库。

1283
01:07:25,570 --> 01:07:27,660
哦，我把stdio库。

1284
01:07:27,660 --> 01:07:30,950
>> 哦，找到了 - 啊，不，that's  - 

1285
01:07:30,950 --> 01:07:34,380
所以，字符串实际上是一些特别CS50。

1286
01:07:36,590 --> 01:07:41,240
其实是不是一个真正的字符串类型

1287
01:07:41,240 --> 01:07:45,000
因为在这里，字符串类型的位置 - 

1288
01:07:45,000 --> 01:07:49,140
我们要声明一个变量称为输入字符串类型的 - 

1289
01:07:49,140 --> 01:07:53,320
我们把里面的输入

1290
01:07:53,320 --> 01:07:58,440
得到的值返回给我们：这GetString函数调用的输出。

1291
01:07:58,440 --> 01:08:02,910
可以说这是一个函数调用，因为它得到了括号，就像printf并

1292
01:08:02,910 --> 01:08:05,920
就像strlen的。

1293
01:08:05,920 --> 01:08:09,860
但是，字符串实际上是不是一个真正的类型

1294
01:08:09,860 --> 01:08:11,760
在C语言中。

1295
01:08:11,760 --> 01:08:15,710
我们已经取得了一个类型，我们会采取更多的它究竟是什么

1296
01:08:15,710 --> 01:08:19,000
C，因为有一种方法使用字符串;

1297
01:08:19,000 --> 01:08:22,479
我们刚刚做的东西，使它看起来更好一点。

1298
01:08:22,479 --> 01:08:25,240
>> 所以，在这里，我们走了。

1299
01:08:25,240 --> 01:08:28,439
下面是Stella的代码。

1300
01:08:28,439 --> 01:08:32,470
它得到了包括<cs50.h>。

1301
01:08:32,470 --> 01:08:36,390
其他人会称此如哈希有时，或尖锐包括。

1302
01:08:36,390 --> 01:08:39,580
现在，我们可以启动它，运行它，

1303
01:08:39,580 --> 01:08:43,649
我们还得到一个错误。

1304
01:08:43,649 --> 01:08:46,290
让我们来看看发生了什么事。

1305
01:08:48,069 --> 01:08:50,569
“未使用的变量'输入'。”

1306
01:08:50,569 --> 01:08:53,350
好了，所以这很酷，这很酷。

1307
01:08:53,350 --> 01:08:55,859
我的意思是，这不是真的很酷，

1308
01:08:55,859 --> 01:08:57,930
因为我们得到一个错误，它没有运行，

1309
01:08:57,930 --> 01:09:00,410
但是这是说的是，

1310
01:09:00,410 --> 01:09:03,130
我们还没有使用我们的变量，这是有道理的。

1311
01:09:03,130 --> 01:09:06,090
我们还没有尝试用它做什么。

1312
01:09:07,819 --> 01:09:10,490
这是一种方式，

1313
01:09:10,490 --> 01:09:14,170
铛正试图帮助我们确保我们不只是使用变量

1314
01:09:14,170 --> 01:09:18,819
然后在不经意间调用他们别的事情后来在我们的代码中，

1315
01:09:18,819 --> 01:09:21,649
帮助我们避免错误的方法。

1316
01:09:23,130 --> 01:09:28,810
>> 所有的权利，因此，我们已经得到了来自用户的输入，

1317
01:09:28,810 --> 01:09:31,910
我们把它存储在变量中。

1318
01:09:31,910 --> 01:09:34,569
下一步是那么

1319
01:09:34,569 --> 01:09:37,609
在所有的字符在字符串中开始寻找

1320
01:09:37,609 --> 01:09:41,830
并确定哪些是大写

1321
01:09:41,830 --> 01:09:44,600
哪些是小写的。

1322
01:09:44,600 --> 01:09:49,439
而像凯利和夏洛特长大了，

1323
01:09:49,439 --> 01:09:52,340
我们使用一个for循环。

1324
01:09:52,340 --> 01:09:55,520
因此，任何人都不会记得一个for循环的语法

1325
01:09:55,520 --> 01:09:58,670
并希望借此刺在只写

1326
01:09:58,670 --> 01:10:03,170
在fo​​r循环的第一行，只是位吗？

1327
01:10:05,740 --> 01:10:07,330
凯利，你想给它一个尝试？

1328
01:10:07,330 --> 01:10:10,300
呀，所以你必须先进行初始化，

1329
01:10:10,300 --> 01:10:13,170
所以我把我= 0，

1330
01:10:13,170 --> 01:10:15,390
然后我做了我<strlen（）函数。

1331
01:10:15,390 --> 01:10:18,570
它是在你的空间 - 我可以拉起来吗？

1332
01:10:18,570 --> 01:10:21,330
是的，我搞砸了一点点，但是是的。

1333
01:10:21,330 --> 01:10:24,180
>> 好吧，让我们把它拽上来。

1334
01:10:24,180 --> 01:10:26,490
真棒。

1335
01:10:26,490 --> 01:10:29,510
“但是我不知道，如果你有这样的 - 

1336
01:10:29,510 --> 01:10:32,180
是啊，好吧。

1337
01:10:33,020 --> 01:10:36,030
所以这里是凯利的：让我们再看一下。

1338
01:10:36,030 --> 01:10:40,290
所以她的包括CS50库的在顶部。

1339
01:10:40,290 --> 01:10:44,790
包括她的标准IO库的顶部，

1340
01:10:45,550 --> 01:10:48,990
和标准的IO函数如printf，

1341
01:10:48,990 --> 01:10:51,690
因此，如果你想使用printf，你需要的线。

1342
01:10:53,060 --> 01:10:56,140
然后，她又包含字符串库，

1343
01:10:56,140 --> 01:10:58,200
我们需要的，

1344
01:10:58,200 --> 01:11:01,010
因为字符串库的strlen函数，

1345
01:11:01,010 --> 01:11:04,320
我们会在短短位。

1346
01:11:04,320 --> 01:11:07,560
因此，如果我们在这里看凯利做了什么，

1347
01:11:07,560 --> 01:11:10,260
你能走我们通过你做了什么？

1348
01:11:10,260 --> 01:11:13,600
>>呀，所以 - 我的意思是，我有错误，所以 - 

1349
01:11:13,600 --> 01:11:15,380
啊，不，it's  - 

1350
01:11:15,380 --> 01:11:18,580
“所以，我想叫我只是”字符串“的字符串。

1351
01:11:18,580 --> 01:11:22,230
我想打印出字符串

1352
01:11:22,230 --> 01:11:25,640
然后我 - 

1353
01:11:27,450 --> 01:11:30,930
我想喜欢像一个数组中的每个字符的字符串

1354
01:11:30,930 --> 01:11:33,170
不同的[听不见的，对不对？

1355
01:11:33,170 --> 01:11:38,080
然后我想在位置0开始

1356
01:11:38,080 --> 01:11:40,630
然后每2位，

1357
01:11:40,630 --> 01:11:42,580
我要利用，

1358
01:11:42,580 --> 01:11:45,680
所以我刚才所描述的为23，因为我一直在寻找的ASCII表。

1359
01:11:45,680 --> 01:11:48,730
所以，这就是我在想 - 我知道这是不对的。

1360
01:11:48,730 --> 01:11:50,920
>> 得到它，所以这是一个很好的开始。

1361
01:11:50,920 --> 01:11:54,120
我想了很多的框架是在这里举行。

1362
01:11:54,120 --> 01:11:57,500
让我们通过逐行种，看看会发生什么。

1363
01:11:57,500 --> 01:12:01,040
所以我喜欢的方式做到这一点，刚开始编译代码

1364
01:12:01,040 --> 01:12:04,300
并让编译器告诉我，像我的代码有什么错，

1365
01:12:04,300 --> 01:12:07,450
因为编译器会告诉你，什么是错的，你的代码是非常好的。

1366
01:12:09,790 --> 01:12:12,780
因此，如果我们发挥，建筑，它没有建立。

1367
01:12:12,780 --> 01:12:14,860
它说有一个错误，

1368
01:12:14,860 --> 01:12:17,320
因此，如果我们向下滚动，并期待在第一个错误，

1369
01:12:17,320 --> 01:12:20,960
它说 - 

1370
01:12:20,960 --> 01:12:22,040
滚动到顶部，

1371
01:12:22,040 --> 01:12:26,070
我们可以看到有5个在底部产生的错误。

1372
01:12:26,070 --> 01:12:30,180
哎呀，这是真正切断。

1373
01:12:31,810 --> 01:12:35,790
我猜这只是不会得到任何好转。

1374
01:12:36,970 --> 01:12:38,500
>> 在这里，我们走了。

1375
01:12:39,790 --> 01:12:42,530
因此，总有5所产生的错误。

1376
01:12:42,530 --> 01:12:45,140
在这里，我只能看到第2，

1377
01:12:45,140 --> 01:12:49,100
这样我就可以移动一点点，然后向上滚动种。

1378
01:12:49,100 --> 01:12:53,220
这是命令运行编译的代码，

1379
01:12:53,220 --> 01:12:59,030
然后file.c的第一个错误是在这里：

1380
01:12:59,030 --> 01:13:03,300
“预计识别或”（“”，是在这条线

1381
01:13:03,300 --> 01:13:06,680
在这里我们说的字符串= getString（）方法。

1382
01:13:07,660 --> 01:13:12,920
在这里你可以看到，它是在第8行file.c，

1383
01:13:12,920 --> 01:13:17,230
然后我相信这是12字符 - 这是错误的。

1384
01:13:17,230 --> 01:13:20,390
那么，这是怎么回事第8行 - 凯利错误吗？

1385
01:13:20,390 --> 01:13:22,810
>>您只需要调用它一样，一个字母或什么的，

1386
01:13:22,810 --> 01:13:24,400
如字符串s或东西吗？

1387
01:13:24,400 --> 01:13:28,250
是啊，所以事实证明，这些特殊类型的名称，

1388
01:13:28,250 --> 01:13:31,770
这样的字符串，整型，字符型，短，

1389
01:13:31,770 --> 01:13:35,740
他们都是特殊的关键字，

1390
01:13:35,740 --> 01:13:38,940
，你不能使用他们的姓名您的变量，

1391
01:13:38,940 --> 01:13:41,430
因为编译器看，并说，

1392
01:13:41,430 --> 01:13:43,680
“哦，我知道这是一个类型，”

1393
01:13:43,680 --> 01:13:46,530
所以，你不能真正称为字符串有一个字符串变量，

1394
01:13:46,530 --> 01:13:50,800
我想在这里做的，这将无法工作。

1395
01:13:52,610 --> 01:13:58,250
但相反，我们可以把它像S或ST或str。

1396
01:13:58,250 --> 01:14:01,540
我们也没办法把它诠释。

1397
01:14:01,540 --> 01:14:03,740
我们不能有一个字符串调用int。

1398
01:14:03,740 --> 01:14:06,740
我们不能有一个称为字符的字符串，没有这些工作。

1399
01:14:06,740 --> 01:14:09,420
>> 因此，我们将只需要调用它的暂时。

1400
01:14:10,630 --> 01:14:13,170
真棒。

1401
01:14:13,170 --> 01:14:17,500
那么下一步是什么在这条线是怎么回事？

1402
01:14:21,390 --> 01:14:24,350
字符串 - 这条线看起来很不错吗？

1403
01:14:24,350 --> 01:14:27,830
让我们给它一个尝试，让我们来运行它。

1404
01:14:27,830 --> 01:14:30,360
好了，我们仍然出现错误。

1405
01:14:30,360 --> 01:14:32,080
这一次，我们4个错误。

1406
01:14:32,080 --> 01:14:34,350
因此，我们得到其中之一。

1407
01:14:34,350 --> 01:14:36,130
让我们继续。

1408
01:14:36,130 --> 01:14:38,890
“意外的类型名称的字符串：预期的表情，”是吗？

1409
01:14:38,890 --> 01:14:41,780
“是的，那是因为我试图命名的字符串。

1410
01:14:41,780 --> 01:14:44,270
是啊，所以它看起来像我们现在也有去修复

1411
01:14:44,270 --> 01:14:46,560
所有这些引用字符串。

1412
01:14:46,560 --> 01:14:50,070
你可以看到这里有一个参考字符串，在这里，在这里，

1413
01:14:50,070 --> 01:14:53,440
因此，我们可以将所有这些为s。

1414
01:14:56,040 --> 01:15:00,930
大。好了，再次运行它。

1415
01:15:00,930 --> 01:15:03,260
大厦 - 另一个错误的发生。

1416
01:15:03,260 --> 01:15:06,900
>> 好了，现在我们已经到了一个错误，

1417
01:15:06,900 --> 01:15:11,090
所以int i = s，然后在方括号。

1418
01:15:11,090 --> 01:15:14,880
所以你能告诉我们一点关于你在这里做什么，凯利？

1419
01:15:14,880 --> 01:15:17,120
“是的。

1420
01:15:17,120 --> 01:15:19,410
这是第10行。

1421
01:15:19,410 --> 01:15:22,760
>>我不知道，如果我们需要它，

1422
01:15:22,760 --> 01:15:25,560
但我认为我是想 - 

1423
01:15:25,560 --> 01:15:27,580
所以你可以跟着我将它保存。

1424
01:15:27,580 --> 01:15:30,470
>>我想我是

1425
01:15:30,470 --> 01:15:33,150
想告诉它开始在位置0

1426
01:15:33,150 --> 01:15:35,030
在我的for循环的开始，

1427
01:15:35,030 --> 01:15:38,370
所以我觉得也许该说是不必要的。

1428
01:15:39,690 --> 01:15:41,350
因此，只要回顾一下，

1429
01:15:41,350 --> 01:15:44,850
你说，这 - 你试图启动该位置0

1430
01:15:44,850 --> 01:15:47,030
得到这个 - 是的，

1431
01:15:47,030 --> 01:15:50,460
过，所以我觉得所说，当你步行通过的代码，

1432
01:15:50,460 --> 01:15:54,070
你在谈论你想如何处理字符串作为一个数组

1433
01:15:54,070 --> 01:15:57,440
这样我们就可以访问每个字符单独。

1434
01:15:57,440 --> 01:16:00,660
我觉得丹提到过，阵列，试图将字符串转换成数组。

1435
01:16:01,400 --> 01:16:03,300
>> 事实证明，这样的引擎盖下，

1436
01:16:03,300 --> 01:16:06,060
实际存储为一个字符串数组了，

1437
01:16:06,060 --> 01:16:08,060
您可以访问它像一个数组;

1438
01:16:08,060 --> 01:16:12,390
有没有转换，你必须做的。

1439
01:16:12,390 --> 01:16:15,770
一个字符串，isn't  - 所以 - 

1440
01:16:15,770 --> 01:16:18,200
一个字符串是不是一个真正的阵列，

1441
01:16:18,200 --> 01:16:21,940
但您可以访问它是这样的，因为所有的字符都存储

1442
01:16:21,940 --> 01:16:25,160
一个正确的彼此相邻的，在内存中，

1443
01:16:25,160 --> 01:16:28,310
所以，如果你想要得到的第一个字符的字符串，

1444
01:16:28,310 --> 01:16:31,910
为获得一个整数数组的第一个整数是相同的。

1445
01:16:31,910 --> 01:16:35,010
所以我们经常 - 我们就会

1446
01:16:35,010 --> 01:16:36,360
参阅2类似

1447
01:16:36,360 --> 01:16:38,590
哦，作为一个字符串，数组，

1448
01:16:38,590 --> 01:16:40,830
即使它真的 - 他们非常不同的事情，

1449
01:16:40,830 --> 01:16:43,410
但你可以把他们大同小异。

1450
01:16:44,700 --> 01:16:47,400
因此，原来，这条线实际上是 - 

1451
01:16:47,400 --> 01:16:51,270
我们不需要做任何转换，

1452
01:16:51,270 --> 01:16:53,500
而事实上，

1453
01:16:53,500 --> 01:16:56,790
这实际上是不是一个有效的表达，

1454
01:16:56,790 --> 01:16:59,040
这是我们的编译器是在告诉我们什么。

1455
01:16:59,040 --> 01:17:01,290
它说：“嘿，它预计的表达，

1456
01:17:01,290 --> 01:17:04,610
我来到这里是这不是一个表达的东西。“

1457
01:17:04,610 --> 01:17:07,310
声明一个数组，

1458
01:17:07,310 --> 01:17:11,780
所有你需要做的是用分号这样的事情，

1459
01:17:11,780 --> 01:17:15,080
然后你告诉阵列多久，你希望它是，

1460
01:17:15,080 --> 01:17:18,370
如5，所以这一行10

1461
01:17:18,370 --> 01:17:23,880
声明一个数组，叫我5个整数。

1462
01:17:23,880 --> 01:17:26,540
>> 这是一个的一边，这是没有必要的代码，

1463
01:17:26,540 --> 01:17:30,970
但是，这是 - 这是一种什么样的声明看起来像。

1464
01:17:30,970 --> 01:17:35,310
>>你会不会使用char我的strlen（）]？

1465
01:17:35,310 --> 01:17:38,500
CHAR I的strlen（）]？

1466
01:17:38,500 --> 01:17:41,500
>>字符i，然后括号内的，strlen的（）。

1467
01:17:43,900 --> 01:17:47,710
是啊，所以我们可以 - 

1468
01:17:47,710 --> 01:17:49,460
我们能做到这一点，

1469
01:17:49,460 --> 01:17:52,160
这将宣布 - 这样做什么？

1470
01:17:52,160 --> 01:17:55,900
>>我想声明一个数组

1471
01:17:55,900 --> 01:18:01,780
的一样 - 的 - 

1472
01:18:01,780 --> 01:18:04,540
哦，你不需要我 - 哦，

1473
01:18:04,540 --> 01:18:06,420
是啊，你绝对不需要我。

1474
01:18:06,420 --> 01:18:10,250
你声明一个字符数组

1475
01:18:10,250 --> 01:18:13,150
长度为S。

1476
01:18:14,680 --> 01:18:16,770
所以山姆说的是，

1477
01:18:16,770 --> 01:18:20,660
10号线 - 让我把一些空间，所以我们可以在它与其余孤立 - 

1478
01:18:20,660 --> 01:18:23,440
这10行声明一个数组

1479
01:18:23,440 --> 01:18:28,520
的字符，字符strlen（）价值，

1480
01:18:28,520 --> 01:18:32,270
但我们其实需要我，

1481
01:18:32,270 --> 01:18:35,710
和的原因，我们需要的，我是因为我们需要为阵列的名称;

1482
01:18:35,710 --> 01:18:38,900
否则，我们就没有办法在后面的代码请参考阵列。

1483
01:18:38,900 --> 01:18:41,180
>> 所以在这里是数组名

1484
01:18:41,180 --> 01:18:43,420
和内部的长度。

1485
01:18:43,420 --> 01:18:45,010
这将为我们提供一个数组，

1486
01:18:45,010 --> 01:18:47,430
但是，这是 - 再次，这是一个声明。

1487
01:18:47,430 --> 01:18:50,380
这不是一项任务，它不是初始化。

1488
01:18:50,380 --> 01:18:52,330
如果我们宣布这样的数组，

1489
01:18:52,330 --> 01:18:54,490
其实也没什么的数组中的内容。

1490
01:18:54,490 --> 01:18:57,490
这只是垃圾 - 无论是在那里。

1491
01:18:57,490 --> 01:18:59,780
像我们所说的，

1492
01:18:59,780 --> 01:19:01,340
我们其实并不需要做这种转换，

1493
01:19:01,340 --> 01:19:04,810
因为我们已经可以把字符串s为一个数组。

1494
01:19:06,750 --> 01:19:09,170
我知道我们正在运行的时间有点长，

1495
01:19:09,170 --> 01:19:12,330
但我想真的很快得到这个for循环

1496
01:19:12,330 --> 01:19:14,850
并告诉你如何访问数组中的单个字符，

1497
01:19:14,850 --> 01:19:17,170
因为这是我们的任务的关键。

1498
01:19:17,170 --> 01:19:20,790
然后，我们将让你从那里走。

1499
01:19:20,790 --> 01:19:24,610
>> 所以在这里，我们已经有了一个for循环

1500
01:19:24,610 --> 01:19:28,310
看起来差不多好了。

1501
01:19:28,310 --> 01:19:30,960
什么不太几乎没有呢？

1502
01:19:30,960 --> 01:19:33,240
What's  - 什么是不完全正确的循环吗？

1503
01:19:33,240 --> 01:19:36,010
>>不花括号？

1504
01:19:36,010 --> 01:19:38,420
没有花括号，对于一个。

1505
01:19:38,420 --> 01:19:42,580
想确保我们身体的循环使用花括号。

1506
01:19:42,580 --> 01:19:45,240
哎呀，而不是方括号！

1507
01:19:45,240 --> 01:19:48,660
接下来的事情，我们需要做的，这个循环是什么？

1508
01:19:48,660 --> 01:19:52,640
如果我尝试运行它，

1509
01:19:52,640 --> 01:19:56,740
这个错误，我得到什么？

1510
01:19:56,740 --> 01:20:00,990
我得到的所有这些错误 - 我必须初始化i。

1511
01:20:00,990 --> 01:20:03,610
大。

1512
01:20:03,610 --> 01:20:05,770
因此，这将是一个循环 - 这是没有做到这一点，

1513
01:20:05,770 --> 01:20:08,680
但它真的很近。

1514
01:20:08,680 --> 01:20:11,260
我们现在可以运行此代码，

1515
01:20:11,260 --> 01:20:14,620
建立，仍出现错误。

1516
01:20:17,960 --> 01:20:19,800
为什么它仍然抱怨，

1517
01:20:19,800 --> 01:20:22,030
说表达的是未使用的，

1518
01:20:22,030 --> 01:20:24,600
这是因为该行不会做任何事情。

1519
01:20:24,600 --> 01:20:27,620
我们并没有存储在任何地方，我们并没有将结果保存。

1520
01:20:27,620 --> 01:20:30,210
我们应该在哪里保存这个结果呢？

1521
01:20:30,210 --> 01:20:32,920
>> S或我呢？

1522
01:20:32,920 --> 01:20:35,990
没错，这个时髦的语法，

1523
01:20:35,990 --> 01:20:38,550
这个S的方括号

1524
01:20:38,550 --> 01:20:41,500
装置进入的s的第i个字符。

1525
01:20:41,500 --> 01:20:45,650
这将是东西是真正重要的是分配。

1526
01:20:45,650 --> 01:20:48,070
不幸的是，我们将不得不停止在这里，

1527
01:20:48,070 --> 01:20:50,550
所以，塞巴斯蒂安部分可以进来，

1528
01:20:50,550 --> 01:20:53,980
但我很高兴留后外，并会采取任何问题。

1529
01:20:53,980 --> 01:20:56,680
所以，谢谢你们的到来。

1530
01:20:56,680 --> 01:20:59,730
现在应该上载，建立，运行。

1531
01:21:01,570 --> 01:21:04,320
我们可以输入一个字符串，如“你好”

1532
01:21:06,570 --> 01:21:08,730
打印“中Qox”的。

1533
01:21:08,730 --> 01:21:11,030
[笑声]

1534
01:21:11,030 --> 01:21:14,640
>> 因此，不太有，但移动，获得对这些循环！

1535
01:21:14,640 --> 01:21:18,640
谢谢你能来，我会在外面。