1
00:00:00,000 --> 00:00:03,290
>> [音乐播放]

2
00:00:03,290 --> 00:00:04,989

3
00:00:04,989 --> 00:00:06,280
杰森赫塞豪恩：好，大家好。

4
00:00:06,280 --> 00:00:07,460
欢迎来到科。

5
00:00:07,460 --> 00:00:10,840
这是CS50，我们非常
首超一节。

6
00:00:10,840 --> 00:00:13,700
大家都知道，下周
规则部分将启动，

7
00:00:13,700 --> 00:00:15,580
但本周我们都在一起。

8
00:00:15,580 --> 00:00:17,730
>> 还有就是我自己。

9
00:00:17,730 --> 00:00:18,840
我的名字是贾森。

10
00:00:18,840 --> 00:00:20,630
我在计算机科学系讲师。

11
00:00:20,630 --> 00:00:23,910
我们有安迪，谁是CS50的头TA。

12
00:00:23,910 --> 00:00:27,630
而Scaz，布莱恩Scassellati教授，
他在计算机科学教授。

13
00:00:27,630 --> 00:00:30,970
>> 我们是在耶鲁大学的CS50头。

14
00:00:30,970 --> 00:00:34,992
您可以随时发送电子邮件
我们heads@cs50.yale.edu。

15
00:00:34,992 --> 00:00:35,950
我们将在讲座。

16
00:00:35,950 --> 00:00:37,547
我们会在办公时间。

17
00:00:37,547 --> 00:00:40,130
如果有过什么我们可以
为你做，你需要什么，

18
00:00:40,130 --> 00:00:42,610
随时接触到我们。

19
00:00:42,610 --> 00:00:44,140
>> 那么，我们今天要做？

20
00:00:44,140 --> 00:00:47,790
或者在此之前，有什么
来了这个星期？

21
00:00:47,790 --> 00:00:52,620
因此，办公时间为周一，周二，
周三和周四，8：00至11:00。

22
00:00:52,620 --> 00:00:54,770
还有的网站上日程。

23
00:00:54,770 --> 00:00:57,830
>> 节，就像我提到的，
在下周开始。

24
00:00:57,830 --> 00:01:01,390
而且你会发现这个星期什么
计时您的部分是，今天是什么日子，

25
00:01:01,390 --> 00:01:03,350
和你的TA是谁。

26
00:01:03,350 --> 00:01:08,610
>> 问题1在周四是由于在
中午，周五中午至深夜的一天。

27
00:01:08,610 --> 00:01:10,817
是的，你有九晚了几天。

28
00:01:10,817 --> 00:01:12,150
而且有九个问题集。

29
00:01:12,150 --> 00:01:14,320
而且只能使用一个
每道题集下旬的一天。

30
00:01:14,320 --> 00:01:17,930
是的，实际上，所有的问题
集将于周五中午。

31
00:01:17,930 --> 00:01:18,550
这是所有。

32
00:01:18,550 --> 00:01:20,400
所有的细节都在教学大纲。

33
00:01:20,400 --> 00:01:22,360
>> 每个星期五，我们的午餐。

34
00:01:22,360 --> 00:01:25,230
我们想使这个大
当然感觉有点小。

35
00:01:25,230 --> 00:01:26,580
所以，欢迎您RSVP。

36
00:01:26,580 --> 00:01:30,050
免费的午餐与其他
同学们和工作人员。

37
00:01:30,050 --> 00:01:34,120
cs50.yale.edu/rsvp。

38
00:01:34,120 --> 00:01:36,940
>> 所有这些事情，
我在屏幕上，

39
00:01:36,940 --> 00:01:43,330
多，你可以找到cs50.yale.edu或
cs50.harvard.edu，如果你去哈佛

40
00:01:43,330 --> 00:01:46,800
而在看这个网上。

41
00:01:46,800 --> 00:01:50,240
>> 同时在这些网站上，有
一吨为你的资源。

42
00:01:50,240 --> 00:01:54,610
每个讲座不仅具有视频
讲座，但也注意到。

43
00:01:54,610 --> 00:01:58,184
有人将观看
讲课和做笔记给你。

44
00:01:58,184 --> 00:02:00,100
所以，你可以只支付
在讲座的关注，

45
00:02:00,100 --> 00:02:03,970
或者您可以使用他们的笔记/我们
笔记来补充自己的笔记。

46
00:02:03,970 --> 00:02:04,987
>> 有网上的幻灯片。

47
00:02:04,987 --> 00:02:07,320
源代码 - 一切
大卫都要通过讲座，

48
00:02:07,320 --> 00:02:09,979
或Scaz都要通过讲座，这
源代码可在网上

49
00:02:09,979 --> 00:02:11,750
还有，像我，提到影片。

50
00:02:11,750 --> 00:02:14,257
>> 部分，同样地，都将被拍摄下来。

51
00:02:14,257 --> 00:02:15,840
所有这些幻灯片将可用。

52
00:02:15,840 --> 00:02:18,190
所有这些代码将
可为您服务。

53
00:02:18,190 --> 00:02:22,440
还有的网站，短裤
CS50的工作人员花费5到10

54
00:02:22,440 --> 00:02:24,130
分钟经历的主题为您服务。

55
00:02:24,130 --> 00:02:26,750
其中一些人已经过
在习题中遇到。

56
00:02:26,750 --> 00:02:30,430
>> 办公时间，正如我所说，星期一
至周四，8：00至11:00。

57
00:02:30,430 --> 00:02:32,600
CS50研究是一个奇妙的资源。

58
00:02:32,600 --> 00:02:37,100
有实际问题，
样本幻灯片，已知错误

59
00:02:37,100 --> 00:02:40,920
学生喜欢碰到，
基本上对每一个主题中，我们

60
00:02:40,920 --> 00:02:42,650
将覆盖在这个过程中。

61
00:02:42,650 --> 00:02:46,350
>> 最后，在这张幻灯片
至少，Reference50

62
00:02:46,350 --> 00:02:49,690
它给你的信息
在所有的C函数

63
00:02:49,690 --> 00:02:53,160
你所能可能希望
使用和许多，许多。

64
00:02:53,160 --> 00:02:55,690
>> 再次，点点点的
在屏幕的底部

65
00:02:55,690 --> 00:02:59,990
是表明甚至还有
在这两个网站上更多的资源：

66
00:02:59,990 --> 00:03:04,270
cs50.yale.edu，cs50.harvard.edu。

67
00:03:04,270 --> 00:03:05,840
>> 那么，我们今天做什么？

68
00:03:05,840 --> 00:03:08,970
首先，我想给
你的资源。

69
00:03:08,970 --> 00:03:10,010
已经做了一个。

70
00:03:10,010 --> 00:03:11,590
看看我们。

71
00:03:11,590 --> 00:03:16,430
>> 现在，我们要投奔
数据类型和运营商C.

72
00:03:16,430 --> 00:03:19,990
然后安迪会在这里和
在C中去了图书馆，printf（）的，

73
00:03:19,990 --> 00:03:24,570
一个函数，你已经
熟悉或将很快成为非常

74
00:03:24,570 --> 00:03:25,530
熟悉。

75
00:03:25,530 --> 00:03:27,810
而且你还可以去了
条件和循环。

76
00:03:27,810 --> 00:03:30,900
>> 然后最后，Scaz
会在CS50 ID。

77
00:03:30,900 --> 00:03:34,250
如果你还没有鸽子在
已经在习题集1，

78
00:03:34,250 --> 00:03:37,060
以及如何使用
终端和有用的命令

79
00:03:37,060 --> 00:03:42,280
然后给你一些演示和
实践编码在CS50 ID。

80
00:03:42,280 --> 00:03:45,130
>> 以前我跳这个
在这一侧的内容，

81
00:03:45,130 --> 00:03:46,770
没有任何人有任何问题这么远吗？

82
00:03:46,770 --> 00:03:53,190

83
00:03:53,190 --> 00:03:54,030
太好了。

84
00:03:54,030 --> 00:03:54,950
行。

85
00:03:54,950 --> 00:03:55,810
更换齿轮。

86
00:03:55,810 --> 00:03:58,760
>> [换档]

87
00:03:58,760 --> 00:04:03,070
>> 那是我移
齿轮在手动汽车。

88
00:04:03,070 --> 00:04:10,920
因此，在C数据类型，你不能只是有
一个变量x，并将它是在第10行，

89
00:04:10,920 --> 00:04:17,170
的整数，说不定数字1，
第20行，一个十进制数10.5，

90
00:04:17,170 --> 00:04:20,500
然后一对夫妇行
后来一个字符串，我爱CS50。

91
00:04:20,500 --> 00:04:25,052
>> 在C语言中，变量只能是
一件事，只有一件事。

92
00:04:25,052 --> 00:04:26,510
所以你必须给他们的类型。

93
00:04:26,510 --> 00:04:28,780
而在此板上，我们
有类型的列表。

94
00:04:28,780 --> 00:04:32,000
有字符，这
代表角色。

95
00:04:32,000 --> 00:04:36,850
所以这是一个字母A，B，C，
D.这也可以是一个空间，

96
00:04:36,850 --> 00:04:40,290
或者也可以是
新行字符。

97
00:04:40,290 --> 00:04:45,030
>> 有整数，这只是
数字，全numbers--或整数

98
00:04:45,030 --> 00:04:47,130
rather--但没有小数。

99
00:04:47,130 --> 00:04:49,790
>> 对于小数，我们有
浮点数。

100
00:04:49,790 --> 00:04:53,200
浮点数
与小数的数字。

101
00:04:53,200 --> 00:04:58,160
>> 再就是多头头寸，这是
本质上较长的整数。

102
00:04:58,160 --> 00:05:01,160
你会发现，长
是8，而一个int是4。

103
00:05:01,160 --> 00:05:02,640
我会得到，在第二。

104
00:05:02,640 --> 00:05:07,390
这是因为多头可以存储连
比int多个整数可以存储。

105
00:05:07,390 --> 00:05:10,100
双是一个长期的浮动。

106
00:05:10,100 --> 00:05:12,460
>> 最后，我们有
串，其是一种类型的

107
00:05:12,460 --> 00:05:14,430
你可能已经使用过。

108
00:05:14,430 --> 00:05:21,100
如果包括包括hashtag
＃includeCS50.h在源文件中，

109
00:05:21,100 --> 00:05:23,170
那么你可以使用一个字符串类型。

110
00:05:23,170 --> 00:05:25,560
它实际上没有内置到C.

111
00:05:25,560 --> 00:05:27,760
>> 有一对夫妇的其他类型也是如此。

112
00:05:27,760 --> 00:05:32,900
但这些都是与校长的人
您将使用和遇到的问题。

113
00:05:32,900 --> 00:05:36,210
c以，我又提到，
每一个变量 - 它

114
00:05:36,210 --> 00:05:38,620
只能是一种类型的且只有一个类型。

115
00:05:38,620 --> 00:05:42,890
这是因为C是一种静态
类型化的语言，而不是

116
00:05:42,890 --> 00:05:45,780
动态类型语言
如果你创建一个变量在哪里

117
00:05:45,780 --> 00:05:50,081
你可以改变什么是存储在
它在程序中去。

118
00:05:50,081 --> 00:05:52,580
在这里的右手
一边，我有不同的尺寸

119
00:05:52,580 --> 00:05:57,440
这些类型的字节的数据。

120
00:05:57,440 --> 00:05:59,710
这样一个字符是1个字节。

121
00:05:59,710 --> 00:06:01,250
这是8位。

122
00:06:01,250 --> 00:06:05,530
这意味着，因为8
位有八个0和1。

123
00:06:05,530 --> 00:06:08,280
我们看到这些演示在第一
周与二进制灯泡。

124
00:06:08,280 --> 00:06:15,680
>> 随着8位或1个字节，我们可以
表示数字从0到255。

125
00:06:15,680 --> 00:06:16,180
对。

126
00:06:16,180 --> 00:06:18,770
如果所有8位均为0这是0。

127
00:06:18,770 --> 00:06:23,640
如果第一位是1，这是数
1，等等，所有一直到255。

128
00:06:23,640 --> 00:06:28,290
这就是为什么对于字符可以
有本质上最多255，

129
00:06:28,290 --> 00:06:31,210
但是这足够覆盖所有
字符我们需要使用。

130
00:06:31,210 --> 00:06:38,060
>> 对于整数，你可以0，
那么你有2到32减1。

131
00:06:38,060 --> 00:06:40,340
这些都是多少选择
你有整数。

132
00:06:40,340 --> 00:06:44,780
>> 长期以来，你有0
到2〜64减1。

133
00:06:44,780 --> 00:06:48,860
所以，你有很多很多，
更多的选择，为多头。

134
00:06:48,860 --> 00:06:54,220
>> 字符串，这是一个问号
因为这是一个悬念以后。

135
00:06:54,220 --> 00:06:55,000
是啊。

136
00:06:55,000 --> 00:06:56,350
我可以告诉大家的
在他们的座位边，

137
00:06:56,350 --> 00:06:57,450
就像那是什么问号？

138
00:06:57,450 --> 00:06:58,390
这是一个悬念。

139
00:06:58,390 --> 00:07:02,340
我们将最终覆盖的大小
字符串和多谈谈字符串。

140
00:07:02,340 --> 00:07:04,692
因为字符串其实是
培训车轮之一

141
00:07:04,692 --> 00:07:06,400
我们在这个带上
当然，在开始

142
00:07:06,400 --> 00:07:09,700
再起飞后
对，因为在C字符串

143
00:07:09,700 --> 00:07:13,320
实际上指针
字符数组。

144
00:07:13,320 --> 00:07:15,810
但同样，这是一个
扣人心弦以后。

145
00:07:15,810 --> 00:07:18,890
在我继续前进的任何问题，
评论，这个幻灯片的担忧？

146
00:07:18,890 --> 00:07:25,800

147
00:07:25,800 --> 00:07:26,630
>> 行。

148
00:07:26,630 --> 00:07:30,330
我一定是一个梦幻般的讲解员。

149
00:07:30,330 --> 00:07:33,210
此外，当你在编程，
你要使用这些运算符。

150
00:07:33,210 --> 00:07:36,730
很简单的标志，可以做简单的
操作，与你可能

151
00:07:36,730 --> 00:07:38,340
已经很熟悉了。

152
00:07:38,340 --> 00:07:42,580
>> 例如，在右侧
右手边，我们看到的补充。

153
00:07:42,580 --> 00:07:44,640
要添加，你只是做一个加号。

154
00:07:44,640 --> 00:07:46,850
所以，你可能有
两个变量x和y。

155
00:07:46,850 --> 00:07:48,810
你可以在你的代码做X + Y。

156
00:07:48,810 --> 00:07:52,790
也许你想用于：说你
有7号和3，

157
00:07:52,790 --> 00:07:55,780
你想存储
在一个变量中称为总和。

158
00:07:55,780 --> 00:08:03,010
你可以做INT的类型，空间
总和，所述变量的名字，= 7 + 3;

159
00:08:03,010 --> 00:08:05,780
>> 那能店总和？

160
00:08:05,780 --> 00:08:07,190
有人吗？

161
00:08:07,190 --> 00:08:09,270
如果我在总和= 7 + 3。

162
00:08:09,270 --> 00:08:10,437
什么将存储在总和？

163
00:08:10,437 --> 00:08:11,520
你可以只喊出来。

164
00:08:11,520 --> 00:08:12,120
听众：10。

165
00:08:12,120 --> 00:08:12,995
>> 杰森赫塞豪恩：10！

166
00:08:12,995 --> 00:08:14,870
这是完全正确的。

167
00:08:14,870 --> 00:08:19,520
怎么样的总和= 7  -  3，
我只是用了几许的迹象。

168
00:08:19,520 --> 00:08:20,871
这是怎么回事存储？

169
00:08:20,871 --> 00:08:21,370
听众：4。

170
00:08:21,370 --> 00:08:22,203
杰森赫塞豪恩：4。

171
00:08:22,203 --> 00:08:25,770
总和可能是错误的名字
该变量，但4将被存储。

172
00:08:25,770 --> 00:08:31,890
>> 为了繁衍C，使用小
明星的性格，你不使用X。

173
00:08:31,890 --> 00:08:35,990
来划分，使用前向
斜线而不是分裂的象征。

174
00:08:35,990 --> 00:08:39,580
而对于模，使用百分比符号。

175
00:08:39,580 --> 00:08:47,900
>> 所以我们可以说我想看看INT Z =
7％3，什么将被存储在Z'

176
00:08:47,900 --> 00:08:51,250
所以，这是本质
问是什么模办？

177
00:08:51,250 --> 00:08:52,750
有谁知道什么模呢？

178
00:08:52,750 --> 00:08:53,940
是啊。

179
00:08:53,940 --> 00:08:54,870
Y 4。

180
00:08:54,870 --> 00:08:56,120
扬声器1：这是余数。

181
00:08:56,120 --> 00:08:58,369
杰森赫塞豪恩：它是
其余的，当你划分。

182
00:08:58,369 --> 00:09:02,790
所以7除以3余数2 1。

183
00:09:02,790 --> 00:09:04,690
所以1将存储。

184
00:09:04,690 --> 00:09:06,970
>> 你做减法，
但它是如何工作。

185
00:09:06,970 --> 00:09:09,140
这就是模运算符一样。

186
00:09:09,140 --> 00:09:12,360
它需要通过一些它除以
其他号码，并返回到你

187
00:09:12,360 --> 00:09:14,590
其余的。

188
00:09:14,590 --> 00:09:19,770
如此反复，7％，3为您提供了1，因为
7 3 2 1余分，

189
00:09:19,770 --> 00:09:21,650
和返回余。

190
00:09:21,650 --> 00:09:24,470
>> 那么，让我们回到了
一步到位的除号。

191
00:09:24,470 --> 00:09:29,194
如果我做了7 /除以3不
任何人都知道这是什么会回来？

192
00:09:29,194 --> 00:09:30,090
>> 扬声器2：2。

193
00:09:30,090 --> 00:09:32,240
>> 杰森赫塞豪恩：为什么2，而不是2.333？

194
00:09:32,240 --> 00:09:34,560
>> 扬声器2：我觉得它削减
关闭整数之后。

195
00:09:34,560 --> 00:09:36,310
杰森赫塞豪恩：所以
这是完全正确的。

196
00:09:36,310 --> 00:09:39,880
在C语言中，如果你做了分工
两个整数7除以3，

197
00:09:39,880 --> 00:09:43,430
它得到了答案，
在这种情况下，2.3333永远

198
00:09:43,430 --> 00:09:47,080
它认为，小数点和
小数点后挑起大梁事事休

199
00:09:47,080 --> 00:09:49,240
它只是返回2。

200
00:09:49,240 --> 00:09:51,120
>> 所以，如果我做了8除以3。

201
00:09:51,120 --> 00:09:54,010
实际上，我们知道
这回2.666，

202
00:09:54,010 --> 00:09:57,050
但在扒事事休
十进制，截断了这一切，

203
00:09:57,050 --> 00:09:58,640
而刚刚返回给你2。

204
00:09:58,640 --> 00:10:02,090
因此，6除以3，7分
3，8除以3，

205
00:10:02,090 --> 00:10:04,840
都将回报给你2。

206
00:10:04,840 --> 00:10:08,770
>> 任何人都不会知道，或者有一个猜测，
至于我怎么能真正得到

207
00:10:08,770 --> 00:10:10,790
完整的答案，如果我想要那个小数点？

208
00:10:10,790 --> 00:10:13,120

209
00:10:13,120 --> 00:10:13,620
是啊。

210
00:10:13,620 --> 00:10:14,152
前进。

211
00:10:14,152 --> 00:10:15,110
扬声器3：使用浮动？

212
00:10:15,110 --> 00:10:16,942
杰森赫塞豪恩：你是什么意思？

213
00:10:16,942 --> 00:10:19,786
扬声器3：因为你说的
浮动是数字[听不清]

214
00:10:19,786 --> 00:10:22,900

215
00:10:22,900 --> 00:10:23,900
杰森赫塞豪恩：对。

216
00:10:23,900 --> 00:10:26,100
所以，这是完全正确的。

217
00:10:26,100 --> 00:10:28,440
图7是一个整数。

218
00:10:28,440 --> 00:10:31,690
但是，如果我想反过来说
成浮点数，

219
00:10:31,690 --> 00:10:34,674
我将不得不存储
作为7.0，因为计算机

220
00:10:34,674 --> 00:10:37,090
真是stupid--我们看到，
用PB和J example--

221
00:10:37,090 --> 00:10:38,930
它只会做完全
你告诉它。

222
00:10:38,930 --> 00:10:40,846
>> 所以，如果你写的7，它
认为这是一个整数。

223
00:10:40,846 --> 00:10:43,640
如果你写7.0，即使我们
知道那些东西是相同的，

224
00:10:43,640 --> 00:10:45,550
它把那像
浮点数。

225
00:10:45,550 --> 00:10:50,441
所以，如果你没有7.0分
3，或除以3.0，

226
00:10:50,441 --> 00:10:52,440
它会说，好了，现在
我们正在处理的花车。

227
00:10:52,440 --> 00:10:57,514
我会回报给你2.333333永远。

228
00:10:57,514 --> 00:10:59,930
但不是真的永远，因为
因为我们也看到在讲座中，

229
00:10:59,930 --> 00:11:03,350
这些浮点数
并不完全精确。

230
00:11:03,350 --> 00:11:05,940
>> 所以，如果你想要的小数，
或小数的一部分，

231
00:11:05,940 --> 00:11:08,090
那么你必须use--其中之一
必须是一个浮点数

232
00:11:08,090 --> 00:11:11,048
和计算机必须了解
这是一个浮点你

233
00:11:11,048 --> 00:11:13,350
处理，而不是一个整数。

234
00:11:13,350 --> 00:11:16,760
在该表上的任何问题
右手侧，到目前为止？

235
00:11:16,760 --> 00:11:22,650
或者你的左边，你的
离开了，你的左手边。

236
00:11:22,650 --> 00:11:23,264
是啊。

237
00:11:23,264 --> 00:11:23,972
扬声器4：对。

238
00:11:23,972 --> 00:11:26,216
对于就像一个普通的
整数，你会

239
00:11:26,216 --> 00:11:30,230
写 - 将你写浮动？

240
00:11:30,230 --> 00:11:31,920
>> 杰森赫塞豪恩：是这样。

241
00:11:31,920 --> 00:11:34,400
好吧，如果你想创建
一个变量，它是一个浮动，

242
00:11:34,400 --> 00:11:37,020
你需要说浮法
z等于什么。

243
00:11:37,020 --> 00:11:37,640
>> 扬声器4：确定。

244
00:11:37,640 --> 00:11:41,950
>> 杰森赫塞豪恩：但是，如果我想
做7除以3，并获得了小数，

245
00:11:41,950 --> 00:11:48,540
我会做浮动Z = 7.0 / 3.0;和
这会给我的浮点

246
00:11:48,540 --> 00:11:49,273
号。

247
00:11:49,273 --> 00:11:50,000
>> 扬声器4：确定。

248
00:11:50,000 --> 00:11:56,370
>> 杰森赫塞豪恩：如果我这样做
像INT Z = 7/3，

249
00:11:56,370 --> 00:12:00,856
这会给我一个整数，
因为这些都是整数。

250
00:12:00,856 --> 00:12:01,730
那有意义吗？

251
00:12:01,730 --> 00:12:02,320
>> 扬声器4：是的。

252
00:12:02,320 --> 00:12:02,950
>> 杰森赫塞豪恩：OK。

253
00:12:02,950 --> 00:12:03,450
太好了。

254
00:12:03,450 --> 00:12:06,030
有关该表的任何其他问题？

255
00:12:06,030 --> 00:12:07,220
真的吗？

256
00:12:07,220 --> 00:12:08,380
我太激动了。

257
00:12:08,380 --> 00:12:09,120
行。

258
00:12:09,120 --> 00:12:13,910
>> 所以，你会使用一些其他的东西，
经常在条件或循环，

259
00:12:13,910 --> 00:12:17,580
是这些类型的operators--
这些类型的布尔表达式。

260
00:12:17,580 --> 00:12:23,140
当我们了解到，==就是你
用它来检查，​​如果两件事情都是平等的。

261
00:12:23,140 --> 00:12:28,170
>> 所以在这里我检查如果x == Y，让我们
再次假设x是7和y为3。

262
00:12:28,170 --> 00:12:33,220
所以，如果我写了7 == 3，什么
将返回给我吗？

263
00:12:33,220 --> 00:12:34,220
这是真的还是假的？

264
00:12:34,220 --> 00:12:35,275
>> 听众：假。

265
00:12:35,275 --> 00:12:36,150
杰森赫塞豪恩：OK。

266
00:12:36,150 --> 00:12:37,370
我觉得每个人都可以得到这一个。

267
00:12:37,370 --> 00:12:39,054
所以每个人，那能回来吗？

268
00:12:39,054 --> 00:12:39,720
听众：假。

269
00:12:39,720 --> 00:12:40,130
杰森赫塞豪恩：假。

270
00:12:40,130 --> 00:12:40,850
太好了。

271
00:12:40,850 --> 00:12:41,930
7不等于3。

272
00:12:41,930 --> 00:12:44,530
因此，7 == 3将返回false。

273
00:12:44,530 --> 00:12:50,746
你有没有等号，所以如果我
被查7！= 3，那能回来吗？

274
00:12:50,746 --> 00:12:51,370
听众：真。

275
00:12:51,370 --> 00:12:52,650
杰森赫塞豪恩：真。

276
00:12:52,650 --> 00:12:53,200
优秀的。

277
00:12:53,200 --> 00:12:55,990
有人很言之凿凿
背部和理解。

278
00:12:55,990 --> 00:12:59,070
然后，你必须小于运算符，
小于或等于操作员，

279
00:12:59,070 --> 00:13:01,990
大于运算，更大
于或等于操作员。

280
00:13:01,990 --> 00:13:03,490
>> 因此，人们更全面的检查。

281
00:13:03,490 --> 00:13:05,660
如果我有7大
大于或等于3。

282
00:13:05,660 --> 00:13:06,966
那能回来吗？

283
00:13:06,966 --> 00:13:07,692
>> 听众：真。

284
00:13:07,692 --> 00:13:08,650
杰森赫塞豪恩：真。

285
00:13:08,650 --> 00:13:10,050
是。

286
00:13:10,050 --> 00:13:13,290
这回房，背面
房间的，梦幻般的。

287
00:13:13,290 --> 00:13:16,240
您可以将这些
表达式如果你喜欢，还有，

288
00:13:16,240 --> 00:13:21,880
带有逻辑AND这是
&&或逻辑OR这是||

289
00:13:21,880 --> 00:13:22,800
||。

290
00:13:22,800 --> 00:13:25,785
所以现在你可以测试两个
事情together--是不是可笑吗？

291
00:13:25,785 --> 00:13:28,250
这是为什么笑？

292
00:13:28,250 --> 00:13:35,200
>> 所以，如果我想，我能说的是7
大于3与2小于4？

293
00:13:35,200 --> 00:13:37,090
好吧，如果7大
比3，这是事实。

294
00:13:37,090 --> 00:13:38,400
2小于4，这是事实。

295
00:13:38,400 --> 00:13:41,140
所以，这整个事情将返回true。

296
00:13:41,140 --> 00:13:45,130
>> 如果我测试了7比3和 - 
我只是挑选随机数这里 - 

297
00:13:45,130 --> 00:13:47,340
4小于2，好，这是假的。

298
00:13:47,340 --> 00:13:49,610
所以真假作出虚假。

299
00:13:49,610 --> 00:13:54,520
你可以去和你结合的
很多条件在一起，你想。

300
00:13:54,520 --> 00:14:00,000
>> 没有任何人有任何问题，
评论，关注这么远吗？

301
00:14:00,000 --> 00:14:03,862
而且我看你拍照的一些
在屏幕上，这是我感激我。

302
00:14:03,862 --> 00:14:05,070
但愿，这不是Snapchat。

303
00:14:05,070 --> 00:14:06,417
我们希望，这对你的笔记。

304
00:14:06,417 --> 00:14:08,500
但所有这些都将
要在网上提供。

305
00:14:08,500 --> 00:14:11,210
所以，你不必
利用这一图像。

306
00:14:11,210 --> 00:14:15,150
就像我提到的，应有尽有
会为你在网上提供。

307
00:14:15,150 --> 00:14:15,650
行。

308
00:14:15,650 --> 00:14:17,980
我即将得到
台下，所以是否有人

309
00:14:17,980 --> 00:14:20,350
不想多说什么
在此之前，会发生什么？

310
00:14:20,350 --> 00:14:21,080
有问题吗？

311
00:14:21,080 --> 00:14:21,680
>> [插入VOICES]

312
00:14:21,680 --> 00:14:22,250
>> 杰森赫塞豪恩：哦，停下来。

313
00:14:22,250 --> 00:14:23,290
你们是太好。

314
00:14:23,290 --> 00:14:23,790
行。

315
00:14:23,790 --> 00:14:26,520
我要挂牌。

316
00:14:26,520 --> 00:14:27,240
我们走吧。

317
00:14:27,240 --> 00:14:29,570
>> ANDI彭：我们要做的
现在是一个尴尬的MIC变化。

318
00:14:29,570 --> 00:14:32,280
>> 杰森赫塞豪恩：我
要采取这一关。

319
00:14:32,280 --> 00:14:33,946
ANDI彭：欣赏支持，伙计们。

320
00:14:33,946 --> 00:14:42,250

321
00:14:42,250 --> 00:14:43,180
你能听到我吗？

322
00:14:43,180 --> 00:14:43,930
好了吗？

323
00:14:43,930 --> 00:14:44,760
完善。

324
00:14:44,760 --> 00:14:45,630
美丽。

325
00:14:45,630 --> 00:14:47,490
让我掖了研究。

326
00:14:47,490 --> 00:14:49,100
行。

327
00:14:49,100 --> 00:14:54,140
所以，我要做到像一个巨大的
信息倾倒在你们现在。

328
00:14:54,140 --> 00:14:57,370
而且没有任何后顾之忧，如果你
不继的每一个小线是什么

329
00:14:57,370 --> 00:14:58,812
我要告诉你。

330
00:14:58,812 --> 00:15:00,770
正如杰森说，一切
完全联机。

331
00:15:00,770 --> 00:15:03,780
只要我们将尝试引进
大家的概念覆盖

332
00:15:03,780 --> 00:15:05,270
在一些幻灯片。

333
00:15:05,270 --> 00:15:06,582
所以只要跟着。

334
00:15:06,582 --> 00:15:09,540
不，如果你不明白的忧虑
一切;然而，如果在任何点

335
00:15:09,540 --> 00:15:12,820
你觉得失落，提高你的
另一方面，我们就会停止，无后顾之忧。

336
00:15:12,820 --> 00:15:15,060
酷。

337
00:15:15,060 --> 00:15:19,270
>> 所以，我认为有些事情，大卫有
已经种提到讲座

338
00:15:19,270 --> 00:15:23,240
那种和贾森已经暗示
今天是一个图书馆。

339
00:15:23,240 --> 00:15:27,510
因此在编程时，我们有
这些东西叫做库。

340
00:15:27,510 --> 00:15:29,690
其中，从本质上讲，所有的
他们只是一组

341
00:15:29,690 --> 00:15:32,610
的功能，即
本质上只是代码的

342
00:15:32,610 --> 00:15:35,070
已经被写入由
别人说我们都可以

343
00:15:35,070 --> 00:15:36,410
我们的程序中使用。

344
00:15:36,410 --> 00:15:38,790
>> 那么，如何正常
图书馆的工作，对不对？

345
00:15:38,790 --> 00:15:40,030
你进入图书馆的门。

346
00:15:40,030 --> 00:15:41,890
你把所有这些
书籍可以拉出来

347
00:15:41,890 --> 00:15:44,590
您可以访问信息
在那些书。

348
00:15:44,590 --> 00:15:45,840
同样的事情在编程。

349
00:15:45,840 --> 00:15:48,820
>> 你有一个已经库
写了由其他人。

350
00:15:48,820 --> 00:15:51,530
而这样就可以了，
作为程序员或学生，

351
00:15:51,530 --> 00:15:55,780
可以访问该库
通过包括hashtag的#include。

352
00:15:55,780 --> 00:15:59,720
>> 例如，在C我们
有三个C--最

353
00:15:59,720 --> 00:16:03,420
常用的三C标准
libraries--输入/输出库，

354
00:16:03,420 --> 00:16:05,540
串库，
和数学库。

355
00:16:05,540 --> 00:16:07,610
>> 所以，在你的第一个
夫妇习题集，

356
00:16:07,610 --> 00:16:10,940
那些将三个
那你主要使用。

357
00:16:10,940 --> 00:16:14,610
因此，大卫已经
讲座中解释说，

358
00:16:14,610 --> 00:16:17,460
标准I / O库，或
标准输入/输出库

359
00:16:17,460 --> 00:16:18,620
正是这么做的。

360
00:16:18,620 --> 00:16:23,530
它可以让你在你的代码，输入
从用户和输出任何

361
00:16:23,530 --> 00:16:25,960
到屏幕上，基本上
它打印到屏幕上。

362
00:16:25,960 --> 00:16:29,990
>> 所以，任何时候你使用任何功能，
例如函数printf（），其

363
00:16:29,990 --> 00:16:33,319
我们要投奔的下一张幻灯片，
一定要包括标准I / O

364
00:16:33,319 --> 00:16:36,360
库要不然你不会
能够使用的printf（）函数。

365
00:16:36,360 --> 00:16:39,110
因为你作为程序员
从来没有真正写到功能，

366
00:16:39,110 --> 00:16:41,840
你只是冒用
在你自己的代码别人的代码。

367
00:16:41,840 --> 00:16:43,620
>> 这是否有意义的人呢？

368
00:16:43,620 --> 00:16:44,520
酷。

369
00:16:44,520 --> 00:16:48,530
>> 然后，我们基本上是沾到
该文件string.h库和文件math.h

370
00:16:48,530 --> 00:16:52,970
图书馆，.H只是表示库，
其他图书馆，你最终会

371
00:16:52,970 --> 00:16:55,310
是你的代码中使用。

372
00:16:55,310 --> 00:16:57,620
>> 然而，为了
这个库，我们也

373
00:16:57,620 --> 00:17:01,170
这个分类 - 我们也有have--
什么是所谓的CS50库，

374
00:17:01,170 --> 00:17:05,270
cs50.h，我们在那里，为
你细读创造

375
00:17:05,270 --> 00:17:07,369
许多重要和有用的功能。

376
00:17:07,369 --> 00:17:09,550
所以，你作为一个程序员
可以捎带关闭

377
00:17:09,550 --> 00:17:14,470
我们已经写了这样
这一功能的提供给你

378
00:17:14,470 --> 00:17:15,599
供您使用。

379
00:17:15,599 --> 00:17:18,359
>> 我将涵盖几个
功能常用

380
00:17:18,359 --> 00:17:20,839
但要知道，这些都是
所有googleable在线。

381
00:17:20,839 --> 00:17:24,904
随意，拉起CS50库和
然后你把所有的功能出现。

382
00:17:24,904 --> 00:17:25,828
是啊。

383
00:17:25,828 --> 00:17:28,140
>> 扬声器5：所以，如果你不
使用该软件

384
00:17:28,140 --> 00:17:29,916
提供给我们，
类，这是否

385
00:17:29,916 --> 00:17:32,698
意味着我们不得不下载并找到
这个头文件自己，并告诉

386
00:17:32,698 --> 00:17:33,840
它是计算机？

387
00:17:33,840 --> 00:17:34,320
>> ANDI彭：大的问题。

388
00:17:34,320 --> 00:17:34,820
没错。

389
00:17:34,820 --> 00:17:38,194
因此，这就像如果你不
在图书馆实际存在的，

390
00:17:38,194 --> 00:17:40,360
有没有办法为你
其实去访问它。

391
00:17:40,360 --> 00:17:42,589
因此，同样的事情
在C，你的编程

392
00:17:42,589 --> 00:17:45,880
要确保你使用的是我们的
家电，因为图书馆已经

393
00:17:45,880 --> 00:17:47,270
被纳入进去。

394
00:17:47,270 --> 00:17:50,020
然后当你的hashtag
＃包括，图书馆的存在。

395
00:17:50,020 --> 00:17:50,520
是啊。

396
00:17:50,520 --> 00:17:51,920
好问题。

397
00:17:51,920 --> 00:17:53,461
每个人都好？

398
00:17:53,461 --> 00:17:53,960
酷。

399
00:17:53,960 --> 00:17:56,371

400
00:17:56,371 --> 00:17:56,870
好吧。

401
00:17:56,870 --> 00:17:59,330
因此，我们会打，
本质上，是什么

402
00:17:59,330 --> 00:18:01,620
所述第一函数
我们作为程序员

403
00:18:01,620 --> 00:18:03,900
将被我们的代码中使用。

404
00:18:03,900 --> 00:18:05,690
这就是所谓的printf（）函数。

405
00:18:05,690 --> 00:18:08,450
因此，printf（）函数，因为我
已经在最后一张幻灯片说，

406
00:18:08,450 --> 00:18:11,830
包括在标准I / O，
标准输入/输出库。

407
00:18:11,830 --> 00:18:16,470
>> 所以一定要确保无论你using--
哦，让我抢激光pointer--

408
00:18:16,470 --> 00:18:18,660
每当你使用
在printf（）函数，

409
00:18:18,660 --> 00:18:21,790
你必须包括标准I / O
库否则，当你编译，

410
00:18:21,790 --> 00:18:23,760
你会得到一个错误
因为电脑会像，

411
00:18:23,760 --> 00:18:26,140
哦，我不知道在哪里的printf（）是，
你不告诉我在哪里的printf（）

412
00:18:26,140 --> 00:18:26,830
是。

413
00:18:26,830 --> 00:18:30,150
井的printf（）被包括在
标准I / O，所以当你用printf（）

414
00:18:30,150 --> 00:18:32,960
确保有
上面一行代码。

415
00:18:32,960 --> 00:18:36,040
>> 因此，例如，printf（）的
这里是一个函数。

416
00:18:36,040 --> 00:18:40,260
它所做的就是打印出来的东西
内的括号给用户。

417
00:18:40,260 --> 00:18:44,840
会有人想借此刺
在这行代码的权利

418
00:18:44,840 --> 00:18:46,420
这里是要打印出来？

419
00:18:46,420 --> 00:18:48,730
因此，应答是在屏幕上。

420
00:18:48,730 --> 00:18:50,480
有人吗？

421
00:18:50,480 --> 00:18:51,380
>> VERDI：底部。

422
00:18:51,380 --> 00:18:53,510
>> ANDI彭：威尔第，你为什么不走
直截了当地说出了整个语句？

423
00:18:53,510 --> 00:18:55,718
>> VERDI：你好，我的名字是
安迪，我20岁。

424
00:18:55,718 --> 00:18:57,270
ANDI彭：啊，可爱。

425
00:18:57,270 --> 00:19:00,240
因此，在这条线，我们要
打印出来，你好，我的名字叫安迪，

426
00:19:00,240 --> 00:19:04,280
我今年20岁了，这
其实一个真实的陈述。

427
00:19:04,280 --> 00:19:05,090
>> 语法。

428
00:19:05,090 --> 00:19:08,830
于是几个语法问题的
你们要确保你知道的。

429
00:19:08,830 --> 00:19:09,360
行情。

430
00:19:09,360 --> 00:19:13,170
双引号告诉
计算机里面的一切

431
00:19:13,170 --> 00:19:14,850
将要被打印出来。

432
00:19:14,850 --> 00:19:16,620
>> 里面可以一切
只是究竟如何

433
00:19:16,620 --> 00:19:19,920
您键入它，除了
一般在年底，

434
00:19:19,920 --> 00:19:23,610
我们将要包括
一个hash--哦sorry--破折号ñ。

435
00:19:23,610 --> 00:19:24,640
因此，一个破折号ñ。

436
00:19:24,640 --> 00:19:28,884
>> 有没有人想以此来猜测
什么，做我们的代码？

437
00:19:28,884 --> 00:19:29,465
是啊。

438
00:19:29,465 --> 00:19:30,840
扬声器6：把它放在一个新行。

439
00:19:30,840 --> 00:19:31,650
ANDI鹏：没错。

440
00:19:31,650 --> 00:19:34,660
因此，所有这样做是
让无论发生什么事

441
00:19:34,660 --> 00:19:37,520
在此之后，该语句之后，
要打印到一个新行。

442
00:19:37,520 --> 00:19:40,030
所以，当你写你的
代码，您不要随意有事情

443
00:19:40,030 --> 00:19:41,738
上涨到年底
你不想要的。

444
00:19:41,738 --> 00:19:43,700
这一切变得
整齐地打印一行

445
00:19:43,700 --> 00:19:46,870
然后我们开始在下一行。

446
00:19:46,870 --> 00:19:50,970
>> 有谁还记得那是什么
当我们编码分号呢？

447
00:19:50,970 --> 00:19:54,580

448
00:19:54,580 --> 00:19:55,330
是啊。

449
00:19:55,330 --> 00:19:55,740
>> 扬声器7：声明。

450
00:19:55,740 --> 00:19:56,010
>> ANDI彭：对不起？

451
00:19:56,010 --> 00:19:57,100
>> 扬声器7：是否结束的声明？

452
00:19:57,100 --> 00:19:57,766
>> ANDI彭：是的。

453
00:19:57,766 --> 00:20:02,670
因此，在C或任何编程
语言中，分号

454
00:20:02,670 --> 00:20:04,640
表示一编程线的末端。

455
00:20:04,640 --> 00:20:09,240
因此，例如，在英语中，我们使用期限
说，哦，这是结束一个句子。

456
00:20:09,240 --> 00:20:12,857
在编程中，同样的事情，我们有一个
分号来表示一个行的末尾。

457
00:20:12,857 --> 00:20:14,690
通常情况下，当你
开始编程，

458
00:20:14,690 --> 00:20:17,150
你会发现你
忘了加分号

459
00:20:17,150 --> 00:20:19,400
然后再尝试运行
代码和它不工作。

460
00:20:19,400 --> 00:20:21,520
而你喜欢啊，我不知道
知道为什么，这应该是工作。

461
00:20:21,520 --> 00:20:24,394
>> 有可能到头来你可能忘了
分号或支架或东西

462
00:20:24,394 --> 00:20:25,020
某个地方。

463
00:20:25,020 --> 00:20:27,740
所以，这是重要的是要记住。

464
00:20:27,740 --> 00:20:29,627
酷。

465
00:20:29,627 --> 00:20:31,960
好吧，举手，如何
很多人在这里有过

466
00:20:31,960 --> 00:20:37,210
采取AP计算机科学或
在Java的编程之前，永远？

467
00:20:37,210 --> 00:20:37,710
行。

468
00:20:37,710 --> 00:20:38,210
可爱。

469
00:20:38,210 --> 00:20:41,340
这不会是适用
然后，但在Java，则

470
00:20:41,340 --> 00:20:44,960
有一些所谓的System.out.println
中不存在C.

471
00:20:44,960 --> 00:20:49,927
>> 因此，在C，只要你
要在添加变量

472
00:20:49,927 --> 00:20:51,760
到任何你想要的
打印出来，有

473
00:20:51,760 --> 00:20:54,620
一个特定的语法，我们要使用。

474
00:20:54,620 --> 00:20:56,520
这就是所谓的
placeholding--本质

475
00:20:56,520 --> 00:21:01,180
我们的地方添加占位符
整数或可变的

476
00:21:01,180 --> 00:21:02,580
我们要打印。

477
00:21:02,580 --> 00:21:07,430
>> 所以当你们可以看到，我们已经包括
这里一个新的库头文件。

478
00:21:07,430 --> 00:21:09,130
在CS50库。

479
00:21:09,130 --> 00:21:13,160
而载有CS50库中
是我们将使用一个通用功能

480
00:21:13,160 --> 00:21:15,610
在我们的课程叫调用getInt（）。

481
00:21:15,610 --> 00:21:21,830
>> 有谁要采取刺伤
什么调用getInt（）有可能会做。

482
00:21:21,830 --> 00:21:22,830
>> 听众：[听不清]

483
00:21:22,830 --> 00:21:23,550
>> ANDI彭：对不起。

484
00:21:23,550 --> 00:21:24,370
听不见你。

485
00:21:24,370 --> 00:21:25,511
麦迪，任何人。

486
00:21:25,511 --> 00:21:27,260
曼蒂：哦，它会提示
你一个整数。

487
00:21:27,260 --> 00:21:28,051
ANDI鹏：没错。

488
00:21:28,051 --> 00:21:30,670
所以这个功能，另一个
功能是已经

489
00:21:30,670 --> 00:21:33,690
写了由别人
我们可以在请他发言。

490
00:21:33,690 --> 00:21:38,000
所有这就是提示你，用户，
任何你想要的代码输入

491
00:21:38,000 --> 00:21:41,850
正在运行，并且它存储whatever--
在这种情况下，我们调用getInt（） - 荷兰国际集团，

492
00:21:41,850 --> 00:21:44,060
所以这意味着我们
获得的整数。

493
00:21:44,060 --> 00:21:46,150
>> 而且我们要存储
在另一个整数

494
00:21:46,150 --> 00:21:48,900
我们已经刚才所谓的年纪。

495
00:21:48,900 --> 00:21:51,500
有意义给大家？

496
00:21:51,500 --> 00:21:52,190
酷。

497
00:21:52,190 --> 00:21:56,400
>> 所以，现在我们已经存储在该整数，
我们已经从用户提示，

498
00:21:56,400 --> 00:22:00,010
在这个变量中，我们
int类型被称为时代的创造​​，

499
00:22:00,010 --> 00:22:03,720
我们可以继续的地方
在我们的printf（）函数。

500
00:22:03,720 --> 00:22:08,970
因此，语法通常是printf（）的是
这无论在实际的物理

501
00:22:08,970 --> 00:22:14,410
行，你希望包括整数，
你这样做，符号在那里，

502
00:22:14,410 --> 00:22:17,800
百分比符号，与
您要的变量类型。

503
00:22:17,800 --> 00:22:20,090
>> 因此，在这种情况下，年龄是一个整数。

504
00:22:20,090 --> 00:22:25,030
所以，你要包括
％我，因为它是一个整数。

505
00:22:25,030 --> 00:22:26,860
然后经过你
声明中，你会

506
00:22:26,860 --> 00:22:30,370
做逗号和
变量的名称。

507
00:22:30,370 --> 00:22:33,420
>> 所以在这里，我们要打印
出，你好，我的名字叫安迪，

508
00:22:33,420 --> 00:22:35,730
而我的空白岁。

509
00:22:35,730 --> 00:22:38,890
Hashta--或sorry--，
年龄无论我输入。

510
00:22:38,890 --> 00:22:42,790
所以，如果我输入
20我调用getInt（）在这里，

511
00:22:42,790 --> 00:22:44,500
它会打印出完全一样的东西。

512
00:22:44,500 --> 00:22:47,990
但是，如果我想输入的东西
否则，可能像40或45，

513
00:22:47,990 --> 00:22:50,800
然后你会看到反映
因此在代码中。

514
00:22:50,800 --> 00:22:52,886
>> 所以这是一个例子
的东西在其中

515
00:22:52,886 --> 00:22:55,260
它打印出来，并期待
你仿佛这是同样的事情，

516
00:22:55,260 --> 00:22:57,593
但罩下方
计算机实际上有

517
00:22:57,593 --> 00:22:59,560
非常不同的事情发生。

518
00:22:59,560 --> 00:23:00,060
酷。

519
00:23:00,060 --> 00:23:02,760

520
00:23:02,760 --> 00:23:03,260
好吧。

521
00:23:03,260 --> 00:23:06,940
那么，如果我们想要多个变量？

522
00:23:06,940 --> 00:23:08,290
非常的方便。

523
00:23:08,290 --> 00:23:09,150
一样。

524
00:23:09,150 --> 00:23:11,930
我们也有一个新功能
这里所谓的GetString（）

525
00:23:11,930 --> 00:23:15,380
也包括在CS50库中，
所有它的作用是提示用户

526
00:23:15,380 --> 00:23:18,120
为一个字符串，它是
刚一组字符，

527
00:23:18,120 --> 00:23:19,810
因此喜欢的句子或类似的名称。

528
00:23:19,810 --> 00:23:25,470
>> 所以在这种情况下，我们将有两个
占位符％s的字符串和％I

529
00:23:25,470 --> 00:23:26,750
为整数。

530
00:23:26,750 --> 00:23:29,190
而我们将遵循
由两个变量

531
00:23:29,190 --> 00:23:32,670
我们希望包括，在订单
它们出现在句子中。

532
00:23:32,670 --> 00:23:35,471
因此，例如，我的名字是
空白，我想一个名字在那里，

533
00:23:35,471 --> 00:23:36,970
所以我打算先有名字。

534
00:23:36,970 --> 00:23:39,637
再后来，我想
年龄，希望有年龄第二。

535
00:23:39,637 --> 00:23:42,720
所以，如果我想输入，你好，
我的名字叫安迪，我20岁。

536
00:23:42,720 --> 00:23:46,370
如果我输入岸堤和20，
同样的事情将打印;

537
00:23:46,370 --> 00:23:51,134
然而，现在我们已经有了两个存储
名称变量以及INT。

538
00:23:51,134 --> 00:23:51,634
是啊。

539
00:23:51,634 --> 00:23:54,124
>> 扬声器8：它会
能够运行，如果你切换

540
00:23:54,124 --> 00:23:55,620
姓名和年龄在那结束了吗？

541
00:23:55,620 --> 00:23:55,840
>> ANDI彭：是的。

542
00:23:55,840 --> 00:23:57,006
这是非常好的问题。

543
00:23:57,006 --> 00:23:59,520
所以长话短说，没有。

544
00:23:59,520 --> 00:24:03,070
由于名称和age--什么
变量的类型是什么名字？

545
00:24:03,070 --> 00:24:03,950
>> 扬声器8：字符串。

546
00:24:03,950 --> 00:24:05,440
>> ANDI彭：什么
变量的类型是年龄？

547
00:24:05,440 --> 00:24:06,231
>> 扬声器8：整数。

548
00:24:06,231 --> 00:24:10,290
ANDI彭：所以在这里，我们有一个占位符
字符串和整数，对不对？

549
00:24:10,290 --> 00:24:13,350
所以，如果你要切换这些，
计算机不会知道。

550
00:24:13,350 --> 00:24:16,250
这将检查一个字符串，
如果你试图给它一个int，

551
00:24:16,250 --> 00:24:18,083
它会像
等待我很困惑，你

552
00:24:18,083 --> 00:24:21,100
告诉我，我应该是
配发的内存类型为int。

553
00:24:21,100 --> 00:24:23,760
而当就在这里，
它要求整

554
00:24:23,760 --> 00:24:25,640
你给它一个名称
和一个字符串代替，

555
00:24:25,640 --> 00:24:28,931
它也将是非常混乱的，它
将不完全运行，你需要的方式。

556
00:24:28,931 --> 00:24:35,280
所以在这里，命名和语法
用于运行代码非常重要的。

557
00:24:35,280 --> 00:24:37,991
每个人都好？

558
00:24:37,991 --> 00:24:38,490
是啊。

559
00:24:38,490 --> 00:24:39,476
麦迪。

560
00:24:39,476 --> 00:24:44,620
>> 曼蒂：在这里，我知道我们已经看了
在类的例子，他们会问在哪里

561
00:24:44,620 --> 00:24:46,950
什么是你的年龄，你叫什么名字。

562
00:24:46,950 --> 00:24:50,250
在这里，那又是它doesn't--
如果我们运行这段代码，

563
00:24:50,250 --> 00:24:51,750
它不会要求是什么？

564
00:24:51,750 --> 00:24:54,740
但是，你只是输入两个数字
然后它会运行这样呢？

565
00:24:54,740 --> 00:24:55,781
>> ANDI彭：是的，没错。

566
00:24:55,781 --> 00:24:58,250
所以，如果你想为它
显示器，请输入您的年龄，

567
00:24:58,250 --> 00:25:01,100
你可以再补充一个printf（）函数
上面写着，请输入您的年龄，

568
00:25:01,100 --> 00:25:01,600
它上面。

569
00:25:01,600 --> 00:25:02,711
这是一个很好的问题。

570
00:25:02,711 --> 00:25:03,210
是啊。

571
00:25:03,210 --> 00:25:07,964
>> 扬声器9：那么，就已经是
包括在调用getInt（）[听不清]。

572
00:25:07,964 --> 00:25:09,380
ANDI彭：不，它实际上不是。

573
00:25:09,380 --> 00:25:11,809
因此，所有这样做仅仅是
提示空屏幕

574
00:25:11,809 --> 00:25:13,100
到用户输入的东西。

575
00:25:13,100 --> 00:25:17,420
如果你想它，如果你想让它打印
出来的东西，告诉用户喜欢，

576
00:25:17,420 --> 00:25:21,110
请给我你的年龄，那么你
必须printf（）的那个自己。

577
00:25:21,110 --> 00:25:23,789
因为每个人都使用这个
功能不同的东西，

578
00:25:23,789 --> 00:25:26,080
你可能会被存储时代，
你可以存储地址，

579
00:25:26,080 --> 00:25:28,060
你可能会被储存的电话号码。

580
00:25:28,060 --> 00:25:31,190
所以这真的取决于
你的球员的个人用途

581
00:25:31,190 --> 00:25:34,390
你希望它是什么的话。

582
00:25:34,390 --> 00:25:34,890
是啊。

583
00:25:34,890 --> 00:25:38,236
>> 扬声器10：所以，我只想澄清，在那里
做你输入的名称和年龄

584
00:25:38,236 --> 00:25:43,020
因此，它显示了在地方的％s？

585
00:25:43,020 --> 00:25:44,320
>> ANDI彭：作为用户？

586
00:25:44,320 --> 00:25:47,165
>> 扬声器10：是的，像我该怎么办
使得它 - 我在哪里把安迪，

587
00:25:47,165 --> 00:25:48,350
和我在哪里把20？

588
00:25:48,350 --> 00:25:48,640
>> ANDI彭：是的。

589
00:25:48,640 --> 00:25:50,250
所以，如果你要
实际运行这段代码，

590
00:25:50,250 --> 00:25:52,875
我没有实际运行
代码，这仅仅是现在在这里。

591
00:25:52,875 --> 00:25:56,910
如果我要运行的代码，我会
编译代码，使文件，

592
00:25:56,910 --> 00:26:00,760
运行代码，然后将有
只是两个空格，我将其输入。

593
00:26:00,760 --> 00:26:01,260
是啊。

594
00:26:01,260 --> 00:26:03,843
当你玩你们会看到
周围与自己的代码。

595
00:26:03,843 --> 00:26:05,760

596
00:26:05,760 --> 00:26:09,645
>> 所有我们要向右移动
入的下一个章节什么

597
00:26:09,645 --> 00:26:11,610
我们将涵盖当今。

598
00:26:11,610 --> 00:26:13,980
我们打​​算去了什么
条件语句是。

599
00:26:13,980 --> 00:26:16,500
所以，如果你们还记得
从讲座回忆，

600
00:26:16,500 --> 00:26:19,210
条件语句，
所有却已是一家集

601
00:26:19,210 --> 00:26:24,010
的说明在计算机中
其中，如果某个条件为真，

602
00:26:24,010 --> 00:26:27,470
你执行的代码
内的这一条件。

603
00:26:27,470 --> 00:26:30,101
>> 因此，在Scratch--本质
从今天的大主题

604
00:26:30,101 --> 00:26:32,850
是，你们已经全部
看到一切背后的逻辑

605
00:26:32,850 --> 00:26:34,020
我们正在覆盖。

606
00:26:34,020 --> 00:26:36,190
而我们正在做的是
翻译的东西

607
00:26:36,190 --> 00:26:39,090
这是非常直观的
从无到有，硬编码它

608
00:26:39,090 --> 00:26:41,950
到语法，我们将使用
对于这是C类

609
00:26:41,950 --> 00:26:47,550
所以从逻辑上讲，这一切都堵得
是一段代码就在那里。

610
00:26:47,550 --> 00:26:49,995
是啊。

611
00:26:49,995 --> 00:26:50,900
行。

612
00:26:50,900 --> 00:26:55,290
>> 我们也进入一个if ... else
声明这仅仅是一个额外的层

613
00:26:55,290 --> 00:26:59,120
复杂的if语句
其中，计算机需要看看这个

614
00:26:59,120 --> 00:27:04,260
并认为，如果这种情况是真实的，做的
任何的这两个括号内，

615
00:27:04,260 --> 00:27:08,470
else--样的等等之类的默认值，如果
它不符合condition--做到这一点。

616
00:27:08,470 --> 00:27:10,120
这就像在一个岔路口。

617
00:27:10,120 --> 00:27:14,400
如果它的外面下雨了，我把
在一个防雨外套，还有什么别的

618
00:27:14,400 --> 00:27:16,330
别的我不把一个雨衣。

619
00:27:16,330 --> 00:27:18,400
>> 这是否逻辑意义的人呢？

620
00:27:18,400 --> 00:27:21,031
酷。

621
00:27:21,031 --> 00:27:21,530
好吧。

622
00:27:21,530 --> 00:27:24,970
因此，像硬例子
这一点，我们将在C见

623
00:27:24,970 --> 00:27:28,890
是，如果我想创建一个
变量调用功课小时。

624
00:27:28,890 --> 00:27:32,050
如果作业时间少
超过五个，我说生命是伟大的。

625
00:27:32,050 --> 00:27:33,070
太好了。

626
00:27:33,070 --> 00:27:36,450
不过，说的斗争是real--
这是我们这一切星期一

627
00:27:36,450 --> 00:27:39,337
下午起来学山都
可能做正确的now--

628
00:27:39,337 --> 00:27:40,170
听众：[笑气]

629
00:27:40,170 --> 00:27:42,510
ANDI彭：他们的方法，我们
会，向你表示感谢。

630
00:27:42,510 --> 00:27:46,180
我们要硬编码的方式
这在C是if--让我们假设

631
00:27:46,180 --> 00:27:49,920
我们已经有类型的变量
int，名为功课小时就在这里。

632
00:27:49,920 --> 00:27:53,870
如果作业小时小于
5 printf（）的，生命是伟大的。

633
00:27:53,870 --> 00:27:57,330
记住保持/ N，因为
你想后，新的生产线。

634
00:27:57,330 --> 00:27:59,660
否则打印的斗争是真实的。

635
00:27:59,660 --> 00:28:03,720
>> 大家是否明白如何
我从这个块转换

636
00:28:03,720 --> 00:28:07,610
到这个代码块？

637
00:28:07,610 --> 00:28:08,110
酷。

638
00:28:08,110 --> 00:28:11,030

639
00:28:11,030 --> 00:28:11,840
好吧。

640
00:28:11,840 --> 00:28:15,930
>> 所以，现在我们要看看
多重如果语句完全。

641
00:28:15,930 --> 00:28:18,140
因此，让我们假设
该计划的目的

642
00:28:18,140 --> 00:28:20,870
为我们提示了一个档次的用户。

643
00:28:20,870 --> 00:28:24,450
我们提示符下使用调用getInt（）的
级，并且它们的输入值，

644
00:28:24,450 --> 00:28:27,700
你想显示
他们得到了什么样的档次。

645
00:28:27,700 --> 00:28:30,730
>> 所以，如果我来设计一个程序，我
在我们所有的目光意味着通常情况下，

646
00:28:30,730 --> 00:28:35,490
90-100是A，80-90是
乙，等等等等。

647
00:28:35,490 --> 00:28:39,040
什么是不对的
一段代码，它不是

648
00:28:39,040 --> 00:28:41,393
做我想做的事情。

649
00:28:41,393 --> 00:28:41,892
是啊。

650
00:28:41,892 --> 00:28:45,100
>> 扬声器11：他们有下限，
但他们没有上限。

651
00:28:45,100 --> 00:28:46,280
>> ANDI鹏：没错。

652
00:28:46,280 --> 00:28:47,950
大家有没有听到她说什么？

653
00:28:47,950 --> 00:28:50,200
还有的将是上
限制，但没有下限。

654
00:28:50,200 --> 00:28:52,540
对不起，反过来，
下限，没有上限。

655
00:28:52,540 --> 00:28:55,090
所以，你想
采取刺伤说

656
00:28:55,090 --> 00:28:58,945
什么将被印刷在该
屏幕如果我要运行该代码。

657
00:28:58,945 --> 00:28:59,820
扬声器11：一个错误？

658
00:28:59,820 --> 00:29:01,140
ANDI彭：一个错误？

659
00:29:01,140 --> 00:29:02,740
伟大的猜测，并不完全正确。

660
00:29:02,740 --> 00:29:05,465
没有任何人有另一种刺？

661
00:29:05,465 --> 00:29:06,640
是啊，阿龙。

662
00:29:06,640 --> 00:29:10,099
>> AARON：如果你把
东西大于90，

663
00:29:10,099 --> 00:29:11,640
它会显示所有你得到的成绩。

664
00:29:11,640 --> 00:29:13,640
它会告诉你得了A，
你有一个B，你得到了一个C.

665
00:29:13,640 --> 00:29:13,870
>> ANDI彭：是的。

666
00:29:13,870 --> 00:29:14,840
这是完全正确的。

667
00:29:14,840 --> 00:29:17,820
所以，这会是美好的。

668
00:29:17,820 --> 00:29:21,781
然而，它们是相互
独家的，我想。

669
00:29:21,781 --> 00:29:23,280
如果我要运行这段代码。

670
00:29:23,280 --> 00:29:26,200
然后让我们只说，我
输入的95级。

671
00:29:26,200 --> 00:29:30,360
所以95现在存储在
整型所谓的档次。

672
00:29:30,360 --> 00:29:33,610
>> 所以C是一门语言
运行了从上到下，

673
00:29:33,610 --> 00:29:36,000
所以它要永远
运行到底部。

674
00:29:36,000 --> 00:29:39,420
所以它要来这里，看是否
级是大于或等于90，

675
00:29:39,420 --> 00:29:42,850
printf（）函数，你得到了一个A.太好了，我
有一个95，这是大于90。

676
00:29:42,850 --> 00:29:44,866
这将打印，
我得到一个答：这是怎么回事

677
00:29:44,866 --> 00:29:48,850
看看这个，如果，这是怎么回事
说，还有95也大于80，

678
00:29:48,850 --> 00:29:52,970
这将打印也得到了GOT
A，B感叹号，等等等等

679
00:29:52,970 --> 00:29:53,690
等等。

680
00:29:53,690 --> 00:29:55,890
>> 因此，当我们都可以看到，
这是一种常见的错误

681
00:29:55,890 --> 00:30:00,760
当我们认为可能会出现
编写代码看出来的。

682
00:30:00,760 --> 00:30:05,430
任何人，在任何问题
为什么这是怎么回事？

683
00:30:05,430 --> 00:30:05,930
太好了。

684
00:30:05,930 --> 00:30:08,920

685
00:30:08,920 --> 00:30:09,440
行。

686
00:30:09,440 --> 00:30:12,110
>> 那么，我们如何解决这个问题，显然是
下一个逻辑问题。

687
00:30:12,110 --> 00:30:16,290
好了，我们有这些美丽
事情如果叫别人，如果别人

688
00:30:16,290 --> 00:30:18,010
如果else语句。

689
00:30:18,010 --> 00:30:22,230
所以你可以看到，如果你想
改变这种状况的问题，

690
00:30:22,230 --> 00:30:25,260
你想使每个
条件相互排斥的，

691
00:30:25,260 --> 00:30:26,860
您将添加一个else ... if语句。

692
00:30:26,860 --> 00:30:30,068
>> 而这些course--的认为他们是
梯子，还是喜欢上了ladder--梯级

693
00:30:30,068 --> 00:30:34,050
这些可以添加多达你
希望尽可能多的条件，只要你想。

694
00:30:34,050 --> 00:30:36,790
所以在这里，如果我输入级为95。

695
00:30:36,790 --> 00:30:39,479
如果等级大于95，
printf（）的，我得到了一个A.大。

696
00:30:39,479 --> 00:30:42,020
这将看到一个else ...如果
而且它会知道，哦，不，

697
00:30:42,020 --> 00:30:43,750
我已经执行的第一人。

698
00:30:43,750 --> 00:30:47,020
我知道 - 或者第一if--我知道，
我没有看任何这些

699
00:30:47,020 --> 00:30:48,920
因为其中的一个
已是事实。

700
00:30:48,920 --> 00:30:50,410
因此，它会从上往下运行。

701
00:30:50,410 --> 00:30:53,650
一旦第一个是真实的，那么
它会跳过所有的休息

702
00:30:53,650 --> 00:30:54,675
的东西...... IFS。

703
00:30:54,675 --> 00:30:55,550
那有意义吗？

704
00:30:55,550 --> 00:30:57,841
因此，在这种方式你
不同层次的检查的

705
00:30:57,841 --> 00:31:01,090
并尽快其中之一为假，则
其余的都还可以，他们甚至不会检查。

706
00:31:01,090 --> 00:31:03,577

707
00:31:03,577 --> 00:31:04,076
酷。

708
00:31:04,076 --> 00:31:07,680

709
00:31:07,680 --> 00:31:08,180
好吧。

710
00:31:08,180 --> 00:31:11,180
>> 因此，这是一个不同的例子
排序条件语句

711
00:31:11,180 --> 00:31:15,250
我们看到较少，但
我们将看到和使用它们。

712
00:31:15,250 --> 00:31:18,120
而且他们往往更
有效的某些情况。

713
00:31:18,120 --> 00:31:20,020
因此，我们有什么所谓
switch语句。

714
00:31:20,020 --> 00:31:25,140
所以在我们讨论什么是一个else
语句中，if ... else语句。

715
00:31:25,140 --> 00:31:27,790
在这里，我们有什么
所谓的switch语句。

716
00:31:27,790 --> 00:31:31,100
>> 因此，当我们使用开​​关
语句是关键？

717
00:31:31,100 --> 00:31:34,090
因此，在一个switch语句，你
通常情况下，通常情况下，其实你

718
00:31:34,090 --> 00:31:38,010
只能输入整数您
你正在检查的变量。

719
00:31:38,010 --> 00:31:42,390
所以，如果我想查查看
如果某一number--例如

720
00:31:42,390 --> 00:31:43,720
一个档次，如果我有一个90。

721
00:31:43,720 --> 00:31:48,190
我想它，看看如果这是一个A，
B或C.我能有这里的情况。

722
00:31:48,190 --> 00:31:50,840
然而，这起案件
是另一个恒定。

723
00:31:50,840 --> 00:31:53,170
>> 所以在这个意义上说，
可以切换语句只

724
00:31:53,170 --> 00:31:55,290
检查两个数相等。

725
00:31:55,290 --> 00:31:57,242
它不检查为别的。

726
00:31:57,242 --> 00:31:59,950
所以，这件事情是非常
小心，当你使用这个的。

727
00:31:59,950 --> 00:32:04,810
所以在这里，如果我想查查看
如果我的90级等于90或80

728
00:32:04,810 --> 00:32:08,500
或70或60，然后打印
相应的等级，

729
00:32:08,500 --> 00:32:11,420
我能写的
在switch语句。

730
00:32:11,420 --> 00:32:15,120
>> 因此，它会来到这里，检查
这个整数等于这个常数？

731
00:32:15,120 --> 00:32:17,030
如果不是，它会跳过。

732
00:32:17,030 --> 00:32:19,880
是不是等于常数
2，等等，等等，

733
00:32:19,880 --> 00:32:22,390
直到你打的默认情况下，
如果他们都不是相等的。

734
00:32:22,390 --> 00:32:24,590
只要其中之一
被设定为相等的，

735
00:32:24,590 --> 00:32:27,040
它会做到这一点
一行代码和休息。

736
00:32:27,040 --> 00:32:30,990
这意味着它会打的
运行，破裂，只是完全跳过

737
00:32:30,990 --> 00:32:32,240
到代码的底部。

738
00:32:32,240 --> 00:32:37,550
因此，在这个意义上说的那种功能
就像if的else if else if语句可。

739
00:32:37,550 --> 00:32:40,830
>> 所以这里有一个具体的
例如，对于你们。

740
00:32:40,830 --> 00:32:46,140
因此，让我们假设，我想
创建一个名为成立的变量。

741
00:32:46,140 --> 00:32:50,230
我想提示用户输入
这一年，他们的学校正式成立。

742
00:32:50,230 --> 00:32:53,300
所以，我可以在这里创建一个switch语句。

743
00:32:53,300 --> 00:32:56,650
而让我们只说，我输入1636。

744
00:32:56,650 --> 00:33:01,120
>> 这里这段​​代码是要见开关
成立时间等于1636。

745
00:33:01,120 --> 00:33:03,940
这将看情况
1636年，哦，这些都是平等的，

746
00:33:03,940 --> 00:33:06,230
的printf（）你不应该
在那所学校北上？

747
00:33:06,230 --> 00:33:08,770
因为我们假设他们不这样做
到这里，如果他们去哈佛，

748
00:33:08,770 --> 00:33:10,380
突破并跳到结束。

749
00:33:10,380 --> 00:33:14,090
>> 如果我输入1701，这
我想大家都会投入，

750
00:33:14,090 --> 00:33:17,500
它会跳过此情况下，来
到案例二是1701年，

751
00:33:17,500 --> 00:33:19,660
和打印欢迎来到耶鲁大学！

752
00:33:19,660 --> 00:33:21,360
打破，跳到结束。

753
00:33:21,360 --> 00:33:25,130
否则你可能正在服用此课程
在网上，其中case--真棒欢迎

754
00:33:25,130 --> 00:33:29,020
以Yale--它会进入
默认打印，您好上网！

755
00:33:29,020 --> 00:33:29,870
而打破。

756
00:33:29,870 --> 00:33:30,466
是啊。

757
00:33:30,466 --> 00:33:32,090
>> SPEAKER 12：您可以使用其他
默认情况下，而不是在那里？

758
00:33:32,090 --> 00:33:34,550
>> ANDI彭：没有，因为
这样，这个整体功能

759
00:33:34,550 --> 00:33:39,170
开关建成，语法，
需要使用的情况下，默认的情况下。

760
00:33:39,170 --> 00:33:42,400
这就像如果别人当此
之一，它的情况下，默认的情况下。是啊。

761
00:33:42,400 --> 00:33:45,650
SPEAKER 13：你也许已经说了这一点，
但你有两个以上的案件？

762
00:33:45,650 --> 00:33:48,066
ANDI彭：是的，你可以
有，只要你想尽可能多的情况下。

763
00:33:48,066 --> 00:33:50,050
把它看成只是想
无限增加的。

764
00:33:50,050 --> 00:33:52,396
>> 扬声器14：如果你
交换1701 1636年，

765
00:33:52,396 --> 00:33:54,187
它并没有真正做
有差别吗？

766
00:33:54,187 --> 00:33:55,770
它只是要检查它。

767
00:33:55,770 --> 00:33:56,900
>> ANDI彭：这是一个
非常好的问题。

768
00:33:56,900 --> 00:33:58,880
我们会触及
这以后，只是

769
00:33:58,880 --> 00:34:01,160
知道这是开关
声明infinitely--它的

770
00:34:01,160 --> 00:34:03,536
超过它，如果更高效
否则，如果因为它的运作

771
00:34:03,536 --> 00:34:06,660
使用不同类型的功能
可以让你，基本上，只是

772
00:34:06,660 --> 00:34:08,790
直接跳转至
如果您需要所在。

773
00:34:08,790 --> 00:34:10,547
是啊。

774
00:34:10,547 --> 00:34:11,255
扬声器14：酷。

775
00:34:11,255 --> 00:34:11,754
谢谢。

776
00:34:11,754 --> 00:34:12,526
ANDI彭：是

777
00:34:12,526 --> 00:34:16,687
>> 扬声器14：你不能
做情况下，像大于。

778
00:34:16,687 --> 00:34:17,270
ANDI彭：没有。

779
00:34:17,270 --> 00:34:19,860
所以，这是什么限制了对
switch语句是，你有

780
00:34:19,860 --> 00:34:21,564
有常数只，只有整数。

781
00:34:21,564 --> 00:34:22,064
是啊。

782
00:34:22,064 --> 00:34:25,179

783
00:34:25,179 --> 00:34:25,820
行。

784
00:34:25,820 --> 00:34:28,659
>> 因此，这是什么，你
球员都会遇到的次数减少，

785
00:34:28,659 --> 00:34:32,280
但我只是想
在情况介绍吧。

786
00:34:32,280 --> 00:34:36,210
我们这里有什么
被称为三元运算符。

787
00:34:36,210 --> 00:34:39,370
凡从本质上讲，它就像一个
if语句编译成一条线。

788
00:34:39,370 --> 00:34:42,630
在这里，我会去到下一行中，
下一个页面，因为它更容易看到的。

789
00:34:42,630 --> 00:34:44,860
>> 所以，我们都看到了这一点吗？

790
00:34:44,860 --> 00:34:46,110
这是很容易理解。

791
00:34:46,110 --> 00:34:51,290
如果我想创建一个名为变量
名为字符串s，如果一定数目的

792
00:34:51,290 --> 00:34:54,770
我给它小于100，我
要分配较低的字符串，

793
00:34:54,770 --> 00:34:57,240
否则我要分配高。

794
00:34:57,240 --> 00:35:01,370
>> 这在这里是做同样的事情
这八行代码在做什么。

795
00:35:01,370 --> 00:35:03,600
所以在这里我想创建
一个变量字符串。

796
00:35:03,600 --> 00:35:08,520
这是我的条件
检查，如果一个数小于100，

797
00:35:08,520 --> 00:35:12,750
那么您分配的低价值，
其他指定的高值。

798
00:35:12,750 --> 00:35:15,802
>> 这些幻灯片将在网上，无后顾之忧
如果你们没有得到这个下来。

799
00:35:15,802 --> 00:35:18,510
这仅仅是一个简单的方法，更
编写代码的有效方式。

800
00:35:18,510 --> 00:35:21,290

801
00:35:21,290 --> 00:35:21,810
行。

802
00:35:21,810 --> 00:35:25,190
>> 所以，现在我们要
输入的内容，对于大多数人来说

803
00:35:25,190 --> 00:35:28,660
就像一个非常，非常混乱
件事想在第一。

804
00:35:28,660 --> 00:35:30,226
环路部分。

805
00:35:30,226 --> 00:35:32,600
所以我们今天要谈
大约有三种类型的循环。

806
00:35:32,600 --> 00:35:34,890
我们将开始一段时间
循环，再来谈一个do while循环，

807
00:35:34,890 --> 00:35:36,740
然后说说for循环。

808
00:35:36,740 --> 00:35:40,010
>> 所以基本上，对于更
视觉学习者在那里，

809
00:35:40,010 --> 00:35:44,410
我们本质上是一个图形化
描写一个什么样的while循环一样。

810
00:35:44,410 --> 00:35:48,290
因此，在编程时，你将开始
并进入循环在某一点。

811
00:35:48,290 --> 00:35:49,470
你检查的条件。

812
00:35:49,470 --> 00:35:52,165
如果条件为真，
你内心执行的代码。

813
00:35:52,165 --> 00:35:53,790
而你再回头来您检查。

814
00:35:53,790 --> 00:35:57,190
如果它仍然是真的，你继续运行
一圈又一圈，这个代码在一个循环。

815
00:35:57,190 --> 00:36:00,970
>> 然而，第二即
条件为假，

816
00:36:00,970 --> 00:36:02,739
你要打破和结束循环。

817
00:36:02,739 --> 00:36:05,030
这在本质上是
语法你要使用。

818
00:36:05,030 --> 00:36:08,250
而一定条件是
真正做到这一点，如果这不是真的，

819
00:36:08,250 --> 00:36:12,920
你要跳到结束
和前进与您的程序。

820
00:36:12,920 --> 00:36:13,690
行。

821
00:36:13,690 --> 00:36:17,250
>> 有没有人有一个例子
什么可能会潜在地发生

822
00:36:17,250 --> 00:36:19,160
如果我尝试运行这段代码？

823
00:36:19,160 --> 00:36:22,470
顺便说一句，SAJ--这是Scaz，安迪，
Jason--我们将签署我们的邮件，

824
00:36:22,470 --> 00:36:24,830
爱，SAJ。

825
00:36:24,830 --> 00:36:25,573
这就是我们。

826
00:36:25,573 --> 00:36:26,500
行。

827
00:36:26,500 --> 00:36:29,829
>> 任何人有一个例子，还是有
什么这将打印的想法？

828
00:36:29,829 --> 00:36:30,870
样的一个很难回答的问题。

829
00:36:30,870 --> 00:36:34,550

830
00:36:34,550 --> 00:36:39,380
所以在这里，记住状况
我们正在检查的同时，真实的。

831
00:36:39,380 --> 00:36:42,840
因此，虽然这是真的，这是
付印，我爱SAJ！

832
00:36:42,840 --> 00:36:48,460
有没有在我们最好的任意点
更改为任何其他方式？

833
00:36:48,460 --> 00:36:49,050
没有，对不对？

834
00:36:49,050 --> 00:36:51,470
>> 所以在这里，我们有
遇到什么可能

835
00:36:51,470 --> 00:36:54,310
将要窃听了很多
你的程序，无限循环。

836
00:36:54,310 --> 00:36:56,268
你会发现，如果你
运行这段代码，

837
00:36:56,268 --> 00:36:58,160
它只是要保持
印刷，我爱SAJ！

838
00:36:58,160 --> 00:37:00,701
虽然我们赞赏的支持，
我们不希望你的电脑

839
00:37:00,701 --> 00:37:02,910
崩溃是因为你
保持印刷我爱SAJ！

840
00:37:02,910 --> 00:37:05,320
>> 所以，请，请，
避免无限循环

841
00:37:05,320 --> 00:37:07,320
因为它永远不会
以评估为假

842
00:37:07,320 --> 00:37:08,780
和你永远也不会
离开循环。

843
00:37:08,780 --> 00:37:10,530
而你要
被吸入天长地久。

844
00:37:10,530 --> 00:37:13,000
酷。

845
00:37:13,000 --> 00:37:13,694
行。

846
00:37:13,694 --> 00:37:15,610
第二类型的循环
我们将谈论今天

847
00:37:15,610 --> 00:37:17,580
是while循环，做while循环的做的。

848
00:37:17,580 --> 00:37:20,580
它之所以被称为do while循环
因为你有做，一段时间。

849
00:37:20,580 --> 00:37:24,390
因此，这是非常类似，而
循环，但有一点点不同。

850
00:37:24,390 --> 00:37:27,620
在这里，你打算怎么办
无论公司的这里面

851
00:37:27,620 --> 00:37:29,747
而在一定条件下是真的。

852
00:37:29,747 --> 00:37:32,580
所以，如果我是C和我的电脑
顺着这一段代码，

853
00:37:32,580 --> 00:37:33,880
我看看顶部。

854
00:37:33,880 --> 00:37:36,890
我去到C，我说的做这件事情。

855
00:37:36,890 --> 00:37:40,550
然后我检查，而这
是真的，我要重复它。

856
00:37:40,550 --> 00:37:42,750
不过，虽然这是假的，
然后我往前走

857
00:37:42,750 --> 00:37:44,700
我从来没有回到那个循环一次。

858
00:37:44,700 --> 00:37:48,360
>> 任何人都可以花刺
有什么区别

859
00:37:48,360 --> 00:37:52,130
这个循环和一个我们之间
只是看着是实际。

860
00:37:52,130 --> 00:37:52,717
是啊。

861
00:37:52,717 --> 00:37:55,050
SPEAKER 15：条件
来代替前后？

862
00:37:55,050 --> 00:37:55,841
ANDI鹏：没错。

863
00:37:55,841 --> 00:37:57,984
所以她说的条件
来后，而不是之前。

864
00:37:57,984 --> 00:38:00,400
最终，所不同的
这和while循环之间

865
00:38:00,400 --> 00:38:03,597
是，你只是打算怎么办
任何的这里面不管

866
00:38:03,597 --> 00:38:06,430
无论您的病情
真的，然后检查条件。

867
00:38:06,430 --> 00:38:08,304
所以在这种情况下，你
always--以这种方式，

868
00:38:08,304 --> 00:38:11,240
你总是要确保
无论是内至少运行

869
00:38:11,240 --> 00:38:14,230
检查，看看前一次
如果你想让它再次运行。

870
00:38:14,230 --> 00:38:18,040
>> 这里有一个例子
当我们会使用它。

871
00:38:18,040 --> 00:38:22,570
因此，举例来说，如果我想有
int类型的变量命名的时代，

872
00:38:22,570 --> 00:38:25,640
我想提示
他们的年龄的用户，

873
00:38:25,640 --> 00:38:27,910
我会做的printf（）
你几岁？

874
00:38:27,910 --> 00:38:30,330
年龄=调用getInt（），它
是提示用户。

875
00:38:30,330 --> 00:38:32,140
>> 而有些人会真的很烦人。

876
00:38:32,140 --> 00:38:34,931
而且你不想在错误的
有人程序输入一样，

877
00:38:34,931 --> 00:38:36,680
哦，我是负4岁或什么的。

878
00:38:36,680 --> 00:38:39,900
在这种情况下，如果它们
做到这一点，这个计算结果

879
00:38:39,900 --> 00:38:43,150
为true，这意味着我要去
必须保持回去和这样做。

880
00:38:43,150 --> 00:38:45,310
因此，这是要保持
再次提示用户

881
00:38:45,310 --> 00:38:47,960
给你像一个真正的
年龄号和它的

882
00:38:47,960 --> 00:38:51,930
要保持回去和重做
它，直到他们给你一个真实年龄

883
00:38:51,930 --> 00:38:56,900
大于一，或不为零。

884
00:38:56,900 --> 00:38:58,020
>> 因此暗示，暗示。

885
00:38:58,020 --> 00:39:02,263
这将是非常，非常有用
为你的PSET问题之一。

886
00:39:02,263 --> 00:39:04,155
是啊。

887
00:39:04,155 --> 00:39:05,580
>> 扬声器16：哎呀，对不起。

888
00:39:05,580 --> 00:39:06,288
>> ANDI彭：是的。

889
00:39:06,288 --> 00:39:09,424
>> 扬声器16：有没有，不
是一个混蛋，但 - 

890
00:39:09,424 --> 00:39:10,340
ANDI彭：不用担心。

891
00:39:10,340 --> 00:39:11,990
扬声器16：--are有
这里不同的规则，

892
00:39:11,990 --> 00:39:13,810
还是你只是忘记
把报价？

893
00:39:13,810 --> 00:39:14,250
>> ANDI彭：哦，是的。

894
00:39:14,250 --> 00:39:15,530
对不起，这是完全是我不好。

895
00:39:15,530 --> 00:39:17,100
这是肯定
应该是一个报价。

896
00:39:17,100 --> 00:39:17,690
接得好。

897
00:39:17,690 --> 00:39:18,800
那将无法运行。

898
00:39:18,800 --> 00:39:22,070

899
00:39:22,070 --> 00:39:22,830
行。

900
00:39:22,830 --> 00:39:26,160
>> 因此，循环的最后一个类型，我们将讨论
约，最终同类产品中最

901
00:39:26,160 --> 00:39:28,854
复杂的for循环。

902
00:39:28,854 --> 00:39:30,770
如果你不知道不要担心
知道这意味着什么。

903
00:39:30,770 --> 00:39:32,061
这是相当混乱在第一。

904
00:39:32,061 --> 00:39:33,640
我们一起去了一个例子。

905
00:39:33,640 --> 00:39:37,040
>> 所有这一切发生在一个for循环
是，你有三个语句

906
00:39:37,040 --> 00:39:38,380
你要去包含。

907
00:39:38,380 --> 00:39:42,130
因此，对于某一件事情，你
要初始化变量。

908
00:39:42,130 --> 00:39:45,280
你要的条件添加到
此循环将继续运行。

909
00:39:45,280 --> 00:39:47,790
然后，在的结尾
循环，你要更新它。

910
00:39:47,790 --> 00:39:50,248
您可以更新变量
要跟踪。

911
00:39:50,248 --> 00:39:52,530
因此，我们通常使用
for循环的时候，我们

912
00:39:52,530 --> 00:39:55,390
要运行一个循环
一定量的时间

913
00:39:55,390 --> 00:39:58,900
我们已经知道，哦，我想
这个循环就像10次执行，

914
00:39:58,900 --> 00:40:03,060
那么你do--我过去
下页的一个例子。

915
00:40:03,060 --> 00:40:07,830
>> 所以在这里，例如，在刮，如果
想要的东西，重复10次，

916
00:40:07,830 --> 00:40:10,790
你不得不说的是，
重复10次我爱SAJ！

917
00:40:10,790 --> 00:40:15,260
这是一种更可接受
展会对我们的支持

918
00:40:15,260 --> 00:40:17,120
而不是无限循环。

919
00:40:17,120 --> 00:40:19,920
在这里，你会如何
过渡到C和写

920
00:40:19,920 --> 00:40:26,040
这是int--我要创建或
声明一个int类型的变量命名的我。

921
00:40:26,040 --> 00:40:30,089
我要初始化
为0，所以我= 0;

922
00:40:30,089 --> 00:40:31,630
这将是我的病情。

923
00:40:31,630 --> 00:40:33,860
所以i小于10。

924
00:40:33,860 --> 00:40:36,096
然后在end--
你是最后一个发言

925
00:40:36,096 --> 00:40:38,710
将不得不是的更新
恰好变量i什么

926
00:40:38,710 --> 00:40:40,206
在您的for循环的结束。

927
00:40:40,206 --> 00:40:42,830
因此，它是一种令人困惑的，因为
这条线的不同部分

928
00:40:42,830 --> 00:40:44,871
都发生在不同的
类型的循环。

929
00:40:44,871 --> 00:40:46,746
但我去了一个
那伪代码示例

930
00:40:46,746 --> 00:40:50,360
也许解释
只是好一点。

931
00:40:50,360 --> 00:40:51,500
>> 所以在这里。

932
00:40:51,500 --> 00:40:52,929
这就是我们刚才看到的循环。

933
00:40:52,929 --> 00:40:55,470
基本上伪代码，是什么
在这个程序中，

934
00:40:55,470 --> 00:40:57,940
首先是我创建
我，初始化为0。

935
00:40:57,940 --> 00:41:00,440
我检查，看看我是
小于10，在这种情况

936
00:41:00,440 --> 00:41:02,840
第一次是
因为0小于10。

937
00:41:02,840 --> 00:41:04,727
因此，环路将运行。

938
00:41:04,727 --> 00:41:06,310
然后我会打印这一行。

939
00:41:06,310 --> 00:41:11,240
然后在该行的末尾，右
在这里，我打算做增量我，我++，

940
00:41:11,240 --> 00:41:13,370
所有的手段是
由一个递增它。

941
00:41:13,370 --> 00:41:15,460
>> 所以，我现在是1。

942
00:41:15,460 --> 00:41:17,960
因为它曾经是0，如果我
增加它的，它现在是1。

943
00:41:17,960 --> 00:41:19,610
然后，我要回去
到循环的开始

944
00:41:19,610 --> 00:41:20,730
我检查车况。

945
00:41:20,730 --> 00:41:22,080
是条件还是真的吗？

946
00:41:22,080 --> 00:41:24,030
是的，1仍低于10。

947
00:41:24,030 --> 00:41:27,370
因此，这将再次打印此，
去，然后加我，并检查

948
00:41:27,370 --> 00:41:29,180
条件
不断，不断，

949
00:41:29,180 --> 00:41:33,290
直到你最终得到
到这种地步，我是10。

950
00:41:33,290 --> 00:41:36,300
>> 你要打印10次
然后我会等于10。

951
00:41:36,300 --> 00:41:37,800
你要检查的条件。

952
00:41:37,800 --> 00:41:38,760
比10小10？

953
00:41:38,760 --> 00:41:40,370
不，那是假的。

954
00:41:40,370 --> 00:41:43,020
因此，该环是不会
运行，这将打破，

955
00:41:43,020 --> 00:41:45,040
而你要
继续与您的代码。

956
00:41:45,040 --> 00:41:47,550
>> 所以当你们看到的，这
是一个真正伟大的例子

957
00:41:47,550 --> 00:41:53,110
一个循环，你可以设定在
运行一段指定的时间量。

958
00:41:53,110 --> 00:41:54,457
每个人都清楚了吗？

959
00:41:54,457 --> 00:41:54,956
是啊。

960
00:41:54,956 --> 00:41:59,060
>> 扬声器17：约增量如何
指数，它是不同的编码？

961
00:41:59,060 --> 00:42:02,060
>> ANDI彭：你can--我们会去
在这个下一张幻灯片。

962
00:42:02,060 --> 00:42:03,350
好问题。

963
00:42:03,350 --> 00:42:05,910
是anyone--之前，我谨
on--任何人都糊涂了，

964
00:42:05,910 --> 00:42:07,640
因为这是一个非常艰难的概念。

965
00:42:07,640 --> 00:42:09,510
不用担心，如果you're--确定。

966
00:42:09,510 --> 00:42:10,010
酷。

967
00:42:10,010 --> 00:42:12,836

968
00:42:12,836 --> 00:42:13,490
>> 好吧。

969
00:42:13,490 --> 00:42:14,610
只是一般的幻灯片。

970
00:42:14,610 --> 00:42:18,020
这个while循环做
循环完全一样的事情了。

971
00:42:18,020 --> 00:42:19,631
这只是写的不同。

972
00:42:19,631 --> 00:42:22,130
你们可以仔细阅读幻灯片
在稍后您方便。

973
00:42:22,130 --> 00:42:24,880
但是，仅仅知道有多重
写同样的事情的方法

974
00:42:24,880 --> 00:42:28,300
以发生在不同的循环。

975
00:42:28,300 --> 00:42:28,800
行。

976
00:42:28,800 --> 00:42:32,380
>> 所以，现在我们的问题得到了什么
如果我们有一个循环内的循环。

977
00:42:32,380 --> 00:42:35,810
我们正在转化为现实
盗梦式的东西在这里。

978
00:42:35,810 --> 00:42:40,640
当你想要做的事情多
其他的事情里面倍

979
00:42:40,640 --> 00:42:44,129
该做的事情多次，你
想要什么叫做嵌套循环。

980
00:42:44,129 --> 00:42:47,420
对于那些你们谁第一个看到这一点，
得到非常困惑，所有我们在这里做

981
00:42:47,420 --> 00:42:50,580
是有循环，其中一个
我们有行的变量。

982
00:42:50,580 --> 00:42:54,500
但是它里面，我们也有另一种
用于可变称为柱的循环。

983
00:42:54,500 --> 00:42:58,560
我强烈建议大家
谁是困惑，首先保持

984
00:42:58,560 --> 00:43:00,310
track--画了这一点，画了这一点。

985
00:43:00,310 --> 00:43:03,000
不要试图正当理由
通过它，画出来。

986
00:43:03,000 --> 00:43:06,630
>> 在你的头，在这片
纸，或什么的，写一行，

987
00:43:06,630 --> 00:43:08,614
跟踪哪些行是公平的。

988
00:43:08,614 --> 00:43:10,780
写专栏，跟踪
什么列等于。

989
00:43:10,780 --> 00:43:13,490
并跟踪的是什么
打印出与每一个迭代。

990
00:43:13,490 --> 00:43:16,320
这个循环的每次迭代，每
那个大循环迭代，

991
00:43:16,320 --> 00:43:17,820
只是一味地按照逻辑。

992
00:43:17,820 --> 00:43:20,190
我向你保证，
你一定会喜欢你所看到的，

993
00:43:20,190 --> 00:43:24,307
因为它也很
适用于您的问题集。

994
00:43:24,307 --> 00:43:24,806
酷。

995
00:43:24,806 --> 00:43:27,501

996
00:43:27,501 --> 00:43:28,000
好吧。

997
00:43:28,000 --> 00:43:30,723
所以，最重要的事情
那你们可能都

998
00:43:30,723 --> 00:43:32,400
想着现在，
是你的习题集1秒，

999
00:43:32,400 --> 00:43:33,650
这是由于周四/周五。

1000
00:43:33,650 --> 00:43:36,890

1001
00:43:36,890 --> 00:43:39,710
>> 在您的water.c程序，
暗示你将会有

1002
00:43:39,710 --> 00:43:41,590
以提示的用户输入。

1003
00:43:41,590 --> 00:43:43,640
在您mario.c程序
你将有

1004
00:43:43,640 --> 00:43:46,431
使用嵌套的for循环，这是
一个for循环的for循环里面，

1005
00:43:46,431 --> 00:43:50,247
打印金字塔块，基本上
像什么马里奥跳通过。

1006
00:43:50,247 --> 00:43:53,330
然后在你的greedy--或者
找零，如果有的话你们

1007
00:43:53,330 --> 00:43:55,740
曾经听说过that--
你将必须非常

1008
00:43:55,740 --> 00:43:58,160
细心的第一个浮点值。

1009
00:43:58,160 --> 00:44:01,860
记住浮动小数和
整数是不一样的东西。

1010
00:44:01,860 --> 00:44:03,620
跟踪哪个是哪个。

1011
00:44:03,620 --> 00:44:05,953
而你要使用
条件语句，也是如此。

1012
00:44:05,953 --> 00:44:09,070

1013
00:44:09,070 --> 00:44:10,940
>> 好了，最后一件事。

1014
00:44:10,940 --> 00:44:12,770
我有留下一两分钟。

1015
00:44:12,770 --> 00:44:13,460
样式。

1016
00:44:13,460 --> 00:44:19,320
因此，这是一些不
实际上实现的效率，

1017
00:44:19,320 --> 00:44:21,010
或代码的实际运行。

1018
00:44:21,010 --> 00:44:24,380
然而，它影响我们的
您的平地机，为你的读者。

1019
00:44:24,380 --> 00:44:27,290
它会影响你自己，如果你
试图找到一个问题。

1020
00:44:27,290 --> 00:44:30,700
它会影响您的代码的可读性。

1021
00:44:30,700 --> 00:44:34,070
>> 所以风格，当你试图像
如果你的风格的一篇文章为英语，

1022
00:44:34,070 --> 00:44:36,070
没有段落，
你拥有了一切样

1023
00:44:36,070 --> 00:44:39,190
的混在一起在同一行，它
使得任何人真的很难

1024
00:44:39,190 --> 00:44:42,620
读你的文章，即使
你的观点在逻辑上是健全的。

1025
00:44:42,620 --> 00:44:44,390
同样的事情在编程。

1026
00:44:44,390 --> 00:44:47,910
你可以有可怕的晦涩
码Scaz将覆盖，

1027
00:44:47,910 --> 00:44:49,660
和它仍然可以运行和功能。

1028
00:44:49,660 --> 00:44:53,110
但对我们来说，因为你的可爱助教，谁都会
可以阅读和评估您的pset时，

1029
00:44:53,110 --> 00:44:54,460
这不是很好。

1030
00:44:54,460 --> 00:44:56,859
>> 所以，请为求
我们和你自己的，

1031
00:44:56,859 --> 00:44:58,900
当你试图修复
在你的代码中的问题，

1032
00:44:58,900 --> 00:45:00,774
和你想
看你自己的代码，使

1033
00:45:00,774 --> 00:45:03,910
一定要遵循一些约定
我们打​​算走了过来。

1034
00:45:03,910 --> 00:45:04,510
>> 所以第一。

1035
00:45:04,510 --> 00:45:07,070
给你的变量有意义的名称。

1036
00:45:07,070 --> 00:45:11,450
如果你想存储的整数
所谓的年龄，请其命名为年龄。

1037
00:45:11,450 --> 00:45:12,875
不要将其命名高度。

1038
00:45:12,875 --> 00:45:14,750
当你想
存储时代的高度，

1039
00:45:14,750 --> 00:45:16,722
它使一切
很迷惑我们。

1040
00:45:16,722 --> 00:45:17,930
我们不喜欢被人混淆。

1041
00:45:17,930 --> 00:45:19,180
你不喜欢被人混淆。

1042
00:45:19,180 --> 00:45:20,350
没有人喜欢被混淆。

1043
00:45:20,350 --> 00:45:23,100
如果你想创造的东西，
它命名为一些有意义的事情。

1044
00:45:23,100 --> 00:45:26,440
>> 然而，在用于循环，单
字符变量通常是罚款。

1045
00:45:26,440 --> 00:45:31,350
而在for循环，如果你只想要我，
与J，K，随意仅仅做到这一点。

1046
00:45:31,350 --> 00:45:32,670
>> 一致的初始化。

1047
00:45:32,670 --> 00:45:33,770
那么，是什么意思呢？

1048
00:45:33,770 --> 00:45:37,600
这意味着在技术上，理论上，
你可以发起并创建

1049
00:45:37,600 --> 00:45:40,140
在同一行上的多个变量。

1050
00:45:40,140 --> 00:45:42,820
因此，例如，我可以创建
称为scaz_age的整数，

1051
00:45:42,820 --> 00:45:47,110
和整数称为andi_age = 20，
和整数称为jason_age

1052
00:45:47,110 --> 00:45:48,090
在同一行上。

1053
00:45:48,090 --> 00:45:52,060
而且我也可以指定只有一个
他们，而不是其他人值。

1054
00:45:52,060 --> 00:45:54,142
我们请你，请不要那样做。

1055
00:45:54,142 --> 00:45:57,350
因为在这里你已经基本上建立
三个变量，但是它们中只有一个

1056
00:45:57,350 --> 00:45:58,295
实际上有一个值。

1057
00:45:58,295 --> 00:46:00,170
然后，当我们
试图读取你的代码，

1058
00:46:00,170 --> 00:46:01,850
或者如果你试图修复
在你的代码中的问题，

1059
00:46:01,850 --> 00:46:03,340
这是非常令人困惑遵循。

1060
00:46:03,340 --> 00:46:09,300
因此，只要你的可读性，对于
我们的可读性，不这样做。

1061
00:46:09,300 --> 00:46:10,355
>> 一致的大括号。

1062
00:46:10,355 --> 00:46:12,980
有些人喜欢把自己的
大括号在不同的地方。

1063
00:46:12,980 --> 00:46:14,100
这其实并不重要。

1064
00:46:14,100 --> 00:46:17,900
只要确保你在一致的
自己的代码，你喜欢把他们。

1065
00:46:17,900 --> 00:46:18,950
>> 一致的间距。

1066
00:46:18,950 --> 00:46:22,040
如果你把一个空间后，
for循环，始终做到这一点。

1067
00:46:22,040 --> 00:46:24,930
那种就像不要在做
有些地方，不要在别人去做。

1068
00:46:24,930 --> 00:46:26,580
只要是一致的。

1069
00:46:26,580 --> 00:46:29,500
>> 其次，如果有人想
细读CS50风格指南，

1070
00:46:29,500 --> 00:46:33,230
我们正式有一番风情指南，
告诉你这些公约，

1071
00:46:33,230 --> 00:46:34,890
加上更多。

1072
00:46:34,890 --> 00:46:35,530
这是在网上。

1073
00:46:35,530 --> 00:46:38,670
这就像cs50.net/style
或类似的东西。

1074
00:46:38,670 --> 00:46:40,180
你可以google一下。

1075
00:46:40,180 --> 00:46:41,399
>> 一致性是关键。

1076
00:46:41,399 --> 00:46:43,190
所以不用担心什么
其他人都在做，

1077
00:46:43,190 --> 00:46:46,180
只要确保你
在你自己的代码相一致。

1078
00:46:46,180 --> 00:46:50,570
任何人有关于什么问题吗？

1079
00:46:50,570 --> 00:46:51,070
是啊。

1080
00:46:51,070 --> 00:46:53,370
>> 扬声器18：所以正确的事
做初始化就是

1081
00:46:53,370 --> 00:46:56,130
让他们都在一个单独的
行，是你在说什么？

1082
00:46:56,130 --> 00:46:58,850
>> ANDI彭：所以我很少有这种情况发生。

1083
00:46:58,850 --> 00:47:02,230
但是，如果你想，如果你想
要像节约空间，在你的代码，

1084
00:47:02,230 --> 00:47:04,000
或什么的，你可以做到这一点。

1085
00:47:04,000 --> 00:47:07,800
我们要求你只是不初始化
有一件事，而不是其他人。

1086
00:47:07,800 --> 00:47:12,600
所以，如果你想要做INT scaz_age，INT
andi_age，INT jason_age，这很好。

1087
00:47:12,600 --> 00:47:15,600
只是不初始化一个
而不是其他的一切。

1088
00:47:15,600 --> 00:47:18,380

1089
00:47:18,380 --> 00:47:19,904
>> 有问题吗？

1090
00:47:19,904 --> 00:47:20,850
好吧。

1091
00:47:20,850 --> 00:47:24,610
我要通过关闭
麦克风，激光指示器，

1092
00:47:24,610 --> 00:47:28,862
和着指挥棒Scaz在这一点上。

1093
00:47:28,862 --> 00:47:29,808
这是尴尬的。

1094
00:47:29,808 --> 00:47:32,650

1095
00:47:32,650 --> 00:47:33,200
这里是。

1096
00:47:33,200 --> 00:47:34,408
>> BRIAN SCASSELLATI：谢谢。

1097
00:47:34,408 --> 00:47:42,500

1098
00:47:42,500 --> 00:47:43,380
是如何形成的声音？

1099
00:47:43,380 --> 00:47:46,420

1100
00:47:46,420 --> 00:47:47,900
声音是好的？ 。

1101
00:47:47,900 --> 00:47:49,220
优秀的。

1102
00:47:49,220 --> 00:47:50,350
行。

1103
00:47:50,350 --> 00:47:52,110
所以，大家好。

1104
00:47:52,110 --> 00:47:56,540
>> 我要去尝试工作，通过
一个实际的例子和你在一起。

1105
00:47:56,540 --> 00:48:00,850
我们要使用CS50的
开发环境，什么所谓

1106
00:48:00,850 --> 00:48:03,120
集成开发环境。

1107
00:48:03,120 --> 00:48:05,145
你已经看到了这个
证明在讲座。

1108
00:48:05,145 --> 00:48:07,520
而在习题集1，你
将有机会

1109
00:48:07,520 --> 00:48:10,890
使用它，和玩
它，并习惯于它，

1110
00:48:10,890 --> 00:48:13,640
因为我们要使用它
通过本学期的休息。

1111
00:48:13,640 --> 00:48:20,350
>> 所以在这个IDE，你有什么期待
就像一个非常传统的文件浏览器

1112
00:48:20,350 --> 00:48:21,890
过在一个面上。

1113
00:48:21,890 --> 00:48:24,360
你已经有了一个部分了
顶你要去哪里

1114
00:48:24,360 --> 00:48:28,850
看看你的源代码，你
CFILE，你写的代码。

1115
00:48:28,850 --> 00:48:31,880
上下底，你会
有一个终端窗口

1116
00:48:31,880 --> 00:48:36,330
你会使用到
这两个编译程序

1117
00:48:36,330 --> 00:48:39,090
并运行或执行程序。

1118
00:48:39,090 --> 00:48:40,100
行。

1119
00:48:40,100 --> 00:48:46,560
>> 因此，只要给我们一点点
的基础上，在终端窗口中，

1120
00:48:46,560 --> 00:48:48,930
你会是
使用一组命令

1121
00:48:48,930 --> 00:48:53,040
这是整个标准命令
大多数Unix或Linux系统。

1122
00:48:53,040 --> 00:48:55,890
所以，如果你曾经使用过
任何形式的Unix，Ubuntu的的，

1123
00:48:55,890 --> 00:48:59,140
或任何其他调味剂，
这些将要看起来很熟悉。

1124
00:48:59,140 --> 00:49:00,890
>> 如果你还没有，请不要担心。

1125
00:49:00,890 --> 00:49:02,830
没有什么复杂的他们。

1126
00:49:02,830 --> 00:49:05,330
他们只是用不同的
语法，不同的命名

1127
00:49:05,330 --> 00:49:07,630
约定比你以前见过。

1128
00:49:07,630 --> 00:49:12,190
>> 因此，要列出文件
一个特定的目录中，

1129
00:49:12,190 --> 00:49:15,310
他们将使用
命令称为LS或列表。

1130
00:49:15,310 --> 00:49:18,010
如果你想看到的一切
与所有的细节，

1131
00:49:18,010 --> 00:49:21,535
你会使用命令
行参数使用ls -l命令。

1132
00:49:21,535 --> 00:49:23,910
这会告诉你一切
更详细地，包括

1133
00:49:23,910 --> 00:49:26,270
该权限的文件。

1134
00:49:26,270 --> 00:49:31,190
>> 要更改目录，
你会使用cd命令。

1135
00:49:31,190 --> 00:49:35,180
而你就可以更改目录
既要到你的主目录。

1136
00:49:35,180 --> 00:49:38,500
这只是CD全部由
本身，光盘有两个

1137
00:49:38,500 --> 00:49:42,930
点会返回上一层
级别到以前的目录。

1138
00:49:42,930 --> 00:49:46,400
而且你还可以cd到一个
子目录通过键入CD

1139
00:49:46,400 --> 00:49:48,500
和该子目录的名称。

1140
00:49:48,500 --> 00:49:50,540
>> 您还可以创建新的目录。

1141
00:49:50,540 --> 00:49:52,790
而且我们要走路
通过这次在短短的一分钟。

1142
00:49:52,790 --> 00:49:54,498
但是，仅仅把
一切都在屏幕上。

1143
00:49:54,498 --> 00:49:56,310
所以，你可以看到他们。

1144
00:49:56,310 --> 00:50:00,420
>> 您也将有能力
直接操作文件

1145
00:50:00,420 --> 00:50:02,100
在命令行。

1146
00:50:02,100 --> 00:50:06,059
您将能够复制他们，
移动它们，或者将它们删除，

1147
00:50:06,059 --> 00:50:07,600
也就是说，有效地将其删除。

1148
00:50:07,600 --> 00:50:10,310

1149
00:50:10,310 --> 00:50:15,350
>> 该CS50 IDE给你完整的
命令行参数的力量。

1150
00:50:15,350 --> 00:50:20,280
这意味着你也可以
这样做非常危险的事情。

1151
00:50:20,280 --> 00:50:21,560
行。

1152
00:50:21,560 --> 00:50:25,010
例如，你可以
除去，或者说是删除，

1153
00:50:25,010 --> 00:50:28,750
不求回报的文件
进行确认。

1154
00:50:28,750 --> 00:50:31,820
你甚至可以删除
recursively--那

1155
00:50:31,820 --> 00:50:38,940
破折号 -  [R flag--整个
子目录及其所有内容。

1156
00:50:38,940 --> 00:50:39,660
行。

1157
00:50:39,660 --> 00:50:42,940
他们列在红色的，因为你
每次应考虑“危险”

1158
00:50:42,940 --> 00:50:45,000
你看到的那些东西。

1159
00:50:45,000 --> 00:50:45,920
行。

1160
00:50:45,920 --> 00:50:46,420
好吧。

1161
00:50:46,420 --> 00:50:50,090

1162
00:50:50,090 --> 00:50:53,430
>> 现在，终于，这个事情是
将是真正有价值的给你，

1163
00:50:53,430 --> 00:50:57,270
是有几个不错的招数
要知道，你正在浏览

1164
00:50:57,270 --> 00:50:59,190
通过这个终端窗口。

1165
00:50:59,190 --> 00:51:03,590
首先，你可以清除屏幕上
任何时候只需键入明确。

1166
00:51:03,590 --> 00:51:06,310
而且你会看到
我这样经常。

1167
00:51:06,310 --> 00:51:09,990
你也可以显示
一个文件的文本

1168
00:51:09,990 --> 00:51:13,992
通过键入以上，然后文件名。

1169
00:51:13,992 --> 00:51:17,200
然后，您就可以滚动回来，
提出与刚刚与空格键

1170
00:51:17,200 --> 00:51:19,010
和箭头键。

1171
00:51:19,010 --> 00:51:25,450
>> 如果你有，因为我们今天的演讲做了，
该连续运行的程序

1172
00:51:25,450 --> 00:51:29,190
在无限循环，你
可以停止该程序

1173
00:51:29,190 --> 00:51:35,160
通过键入控制执行，
即按住Ctrl-C组合。

1174
00:51:35,160 --> 00:51:38,360
而且你可能必须做
这种多次。

1175
00:51:38,360 --> 00:51:40,620
计算机得到远远领先于你。

1176
00:51:40,620 --> 00:51:43,380
你有时需要
给它一个尝试几次

1177
00:51:43,380 --> 00:51:46,280
之前它实际上会通过。

1178
00:51:46,280 --> 00:51:48,760
>> 您还可以
通过命令排序

1179
00:51:48,760 --> 00:51:54,230
您刚刚输入使用向上键，
箭头键，然后向下箭头键。

1180
00:51:54,230 --> 00:51:57,560
什么是最有用的是，而不是
打字了长文件名，

1181
00:51:57,560 --> 00:52:02,209
您就可以使用Tab键
自动完成几条指令。

1182
00:52:02,209 --> 00:52:04,750
现在，我们将演示
所有这些，在短短一秒钟。

1183
00:52:04,750 --> 00:52:06,780
所以，如果你不记得
他们，不要担心。

1184
00:52:06,780 --> 00:52:10,780
这些事情，你会
拿起和使用，因为我们走。

1185
00:52:10,780 --> 00:52:11,470
行。

1186
00:52:11,470 --> 00:52:18,830
>> 因此，在C--不像在Scratch--
C是编译型语言。

1187
00:52:18,830 --> 00:52:23,210
这意味着，我们将采取一个源
file--这是你写的文字，

1188
00:52:23,210 --> 00:52:26,500
你写的命令
的printf（）语句，环，

1189
00:52:26,500 --> 00:52:32,580
一切else--，我们要
采取该文件，并把它关闭

1190
00:52:32,580 --> 00:52:34,670
到一个程序调用编译器。

1191
00:52:34,670 --> 00:52:39,850
>> 那么编译器将
你写的文字

1192
00:52:39,850 --> 00:52:43,270
并把它翻译成
二进制指令

1193
00:52:43,270 --> 00:52:46,010
您的电脑
实际上是使用。

1194
00:52:46,010 --> 00:52:49,700
这就是所谓的对象
或可执行文件。

1195
00:52:49,700 --> 00:52:55,320
如果你看一下这个文件，你会
看到你写的代码。

1196
00:52:55,320 --> 00:52:59,480
如果你看一下这个文件，你会
看个字符的随机序列

1197
00:52:59,480 --> 00:53:01,680
使没有任何意义。

1198
00:53:01,680 --> 00:53:03,250
这是因为这是二进制。

1199
00:53:03,250 --> 00:53:05,560
这并不意味着你必须阅读。

1200
00:53:05,560 --> 00:53:08,690
>> 但是，任何时候你想
运行的东西，你要什么

1201
00:53:08,690 --> 00:53:13,670
在运行是这个目标文件。

1202
00:53:13,670 --> 00:53:19,110
因此，当我们与这些合作
文件，我们会用C编写的文件

1203
00:53:19,110 --> 00:53:23,400
然后，我们将编译它，使用
命令类似于make将调用

1204
00:53:23,400 --> 00:53:27,070
编译器铛的C语言。

1205
00:53:27,070 --> 00:53:31,530
并且，将产生一个对象
文件，就像一个出来，或在此情况下，

1206
00:53:31,530 --> 00:53:36,580
这个名字，我的文件，我已经把研究。

1207
00:53:36,580 --> 00:53:37,780
好吧。

1208
00:53:37,780 --> 00:53:39,790
>> 因此，让我们真正尝试这一点。

1209
00:53:39,790 --> 00:53:42,850
所以，我想出了一个例子
是我想尝试。

1210
00:53:42,850 --> 00:53:47,380
和的事情之一
让我着迷的动画。

1211
00:53:47,380 --> 00:53:51,010
所以我们要尽量做到
动画的一点点

1212
00:53:51,010 --> 00:53:53,760
仅使用ASCII字符。

1213
00:53:53,760 --> 00:53:56,470
人物我们现在可以打印出轻松。

1214
00:53:56,470 --> 00:54:00,890
>> 因此，这里是我的最好的尝试
创造适合你

1215
00:54:00,890 --> 00:54:07,005
兔子的动画
通过高草运行。

1216
00:54:07,005 --> 00:54:07,505
他在那。

1217
00:54:07,505 --> 00:54:10,150

1218
00:54:10,150 --> 00:54:10,670
行。

1219
00:54:10,670 --> 00:54:14,050
所以，他没有跑呢，但他
在高高的草丛站在那里。

1220
00:54:14,050 --> 00:54:17,810
>> 现在，如果我是一个漫画家，
在老同学

1221
00:54:17,810 --> 00:54:20,860
版本的动画，我
会做的是我将产生

1222
00:54:20,860 --> 00:54:23,640
这个兔子在草地上的图片。

1223
00:54:23,640 --> 00:54:25,390
然后，我会产生
另一个picture--

1224
00:54:25,390 --> 00:54:30,600
另外他们所谓cell--了
有兔子只是稍微移动。

1225
00:54:30,600 --> 00:54:34,870
然后第三个是有
兔子感动得远一点。

1226
00:54:34,870 --> 00:54:40,610
>> 我会产生一个完整的
序列这些细胞。

1227
00:54:40,610 --> 00:54:44,220
一些地方的兔子已经结束
到左侧。

1228
00:54:44,220 --> 00:54:47,050
然后缓缓移动，人们
由一个向中间。

1229
00:54:47,050 --> 00:54:51,120
然后从中间
到正确的。

1230
00:54:51,120 --> 00:54:55,760
如果我当时真的
幸运的话，我可以把它在一起

1231
00:54:55,760 --> 00:54:57,970
我可以动画。

1232
00:54:57,970 --> 00:55:00,370
还有就是我的兔子
通草运行。

1233
00:55:00,370 --> 00:55:02,310
>> 这是我的伟大的PowerPoint
欺骗的一天。

1234
00:55:02,310 --> 00:55:02,809
行。

1235
00:55:02,809 --> 00:55:04,760
因此，这是因为它得到很好的。

1236
00:55:04,760 --> 00:55:05,260
行。

1237
00:55:05,260 --> 00:55:08,455
所以，在这里，人们有更多的时间，这里是我们的
兔子在草地上运行。

1238
00:55:08,455 --> 00:55:09,217
>> SPEAKER 19：再次。

1239
00:55:09,217 --> 00:55:11,050
BRIAN SCASSELLATI：一
更多的时间，所有的权利。

1240
00:55:11,050 --> 00:55:11,940
这是你的兔子。

1241
00:55:11,940 --> 00:55:12,940
行。

1242
00:55:12,940 --> 00:55:15,470
>> 所以，我们今天有什么
做的是我们要去

1243
00:55:15,470 --> 00:55:21,110
尝试的过程自动化
的生产这些细胞。

1244
00:55:21,110 --> 00:55:24,135
我们不会完全得到以点
能够把它们放在一起。

1245
00:55:24,135 --> 00:55:28,900
但是，我们要尽量自动化
产生该序列的过程。

1246
00:55:28,900 --> 00:55:32,900
>> 这是很多东西，
今日动画等。

1247
00:55:32,900 --> 00:55:36,690
也就是说，你没有做的事情不一定
通过绘制一切手工制作。

1248
00:55:36,690 --> 00:55:40,610
我们用电脑自动化
零件的过程。

1249
00:55:40,610 --> 00:55:41,110
行。

1250
00:55:41,110 --> 00:55:47,720
>> 因此，让我切换
现在我们CS50 IDE。

1251
00:55:47,720 --> 00:55:54,260
和我已经us--，让创建
我放大这里一点bit--我已经

1252
00:55:54,260 --> 00:55:58,420
为我们创造了一个出发点。

1253
00:55:58,420 --> 00:56:03,830
>> 我们要求你坐每次
来写一段代码，

1254
00:56:03,830 --> 00:56:09,250
我们真正要你做
是我们要求解决的一个问题。

1255
00:56:09,250 --> 00:56:11,810
而这样，你应该
想想这样做

1256
00:56:11,810 --> 00:56:17,900
是通过启动与一些
该解决方案的简单零件。

1257
00:56:17,900 --> 00:56:21,730
然后从该部分打造出来的。

1258
00:56:21,730 --> 00:56:23,400
这就是我们今天要做的。

1259
00:56:23,400 --> 00:56:27,570
>> 因此，而不是试图全部一次
写整个一串代码这是

1260
00:56:27,570 --> 00:56:30,770
要生产这些
10动画细胞，

1261
00:56:30,770 --> 00:56:35,506
我们要开始，而不是
与该作品一件。

1262
00:56:35,506 --> 00:56:37,380
然后，我们将构建一个
周围的那一点点

1263
00:56:37,380 --> 00:56:39,740
多一点，多一点。

1264
00:56:39,740 --> 00:56:42,550
>> 现在谈谈好事
解决问题这样

1265
00:56:42,550 --> 00:56:46,716
是，它可以让你开始
总是与你知道的东西

1266
00:56:46,716 --> 00:56:51,130
作品和介绍一款渐变。

1267
00:56:51,130 --> 00:56:54,090
这是一个伟大的方式
学习如何编写，

1268
00:56:54,090 --> 00:56:58,590
因为每次你犯了一个
变化，你看到什么影响了。

1269
00:56:58,590 --> 00:56:59,540
行。

1270
00:56:59,540 --> 00:57:01,450
>> 因此，这里是我们的出发点。

1271
00:57:01,450 --> 00:57:01,950
行。

1272
00:57:01,950 --> 00:57:08,030
所以在我的文件的开头，
我已经哈希包含（#include）stdio.h中。

1273
00:57:08,030 --> 00:57:12,560
这让我可以得到
printf（）函数工作。

1274
00:57:12,560 --> 00:57:15,240
>> 我然后我有我的主要功能。

1275
00:57:15,240 --> 00:57:18,760
这看起来还是有点
神秘的或不明显的一些你。

1276
00:57:18,760 --> 00:57:20,010
没关系。

1277
00:57:20,010 --> 00:57:23,190
所有这说的是，
主要功能需要

1278
00:57:23,190 --> 00:57:27,830
没有arguments--无效的手段
没有在C.它

1279
00:57:27,830 --> 00:57:29,940
按照惯例，返回一个整数。

1280
00:57:29,940 --> 00:57:33,290
主总是返回一个整数，
通常一个代码说事

1281
00:57:33,290 --> 00:57:35,071
顺利或不顺利。

1282
00:57:35,071 --> 00:57:35,570
行。

1283
00:57:35,570 --> 00:57:39,110
但主要必须具有该
现在构成了我们。

1284
00:57:39,110 --> 00:57:42,080
>> 我再放入三行代码。

1285
00:57:42,080 --> 00:57:46,760
而且随着每行
代码，我已经把评论。

1286
00:57:46,760 --> 00:57:51,340
现在，人们的事情，
我们将坚持这样做，

1287
00:57:51,340 --> 00:57:55,320
它是如此重要
编程实践，

1288
00:57:55,320 --> 00:57:57,800
是要始终注释你的代码。

1289
00:57:57,800 --> 00:58:02,550
总是在记
英文注释的东西

1290
00:58:02,550 --> 00:58:06,740
你认为
代码是应该做的。

1291
00:58:06,740 --> 00:58:11,360
这样，以后当你回来的
它，你可以看看它，你可以说，

1292
00:58:11,360 --> 00:58:13,800
哦，我记得我是什么
尝试做这个。

1293
00:58:13,800 --> 00:58:17,590
或者当TA坐下来与你
尽量帮你在办公时间，

1294
00:58:17,590 --> 00:58:20,890
他们可以看看这个去，我
看看你想要做什么，

1295
00:58:20,890 --> 00:58:25,630
而是，这是
到底发生了什么。

1296
00:58:25,630 --> 00:58:26,130
行。

1297
00:58:26,130 --> 00:58:30,300
>> 所以，我有三个部分，以我的代码，
我将首先打印

1298
00:58:30,300 --> 00:58:33,110
一些点在开始。

1299
00:58:33,110 --> 00:58:37,480
然后我会打印出我的
非常看中的兔子。

1300
00:58:37,480 --> 00:58:40,600
然后点在最后的一些位。

1301
00:58:40,600 --> 00:58:45,220
>> 而这三种打印报表应
很熟悉，你在这一点上。

1302
00:58:45,220 --> 00:58:47,350
所有这一切我做的
他们每个人是我

1303
00:58:47,350 --> 00:58:49,780
打印出的字符序列。

1304
00:58:49,780 --> 00:58:51,370
有没有涉及到的变量。

1305
00:58:51,370 --> 00:58:54,320
一切都只是持平。

1306
00:58:54,320 --> 00:58:55,270
行。

1307
00:58:55,270 --> 00:59:07,340
>> 所以，如果我现在下去给我terminal--
让我们来看看，如果我能得到这个回out--

1308
00:59:07,340 --> 00:59:09,370
而我要再次键入明确。

1309
00:59:09,370 --> 00:59:12,507
>> 扬声器20：我们用
双斜线评论？

1310
00:59:12,507 --> 00:59:14,340
BRIAN SCASSELLATI：可以
使用double--肯定。

1311
00:59:14,340 --> 00:59:16,920
有多种方式来
离开C.一个评论

1312
00:59:16,920 --> 00:59:19,440
的方式是使用双斜线。

1313
00:59:19,440 --> 00:59:24,910
另一种方法是使用一个斜杠和一个星
然后关闭与一个明星，一个斜线。

1314
00:59:24,910 --> 00:59:26,110
好吧。

1315
00:59:26,110 --> 00:59:28,950
>> 首先，我要
从这里开始浏览周围。

1316
00:59:28,950 --> 00:59:35,350
所以，如果我去我的主目录，
我已经改变了目录存在，

1317
00:59:35,350 --> 00:59:40,230
我要去看看，看看有什么
在该目录中，LS，列出。

1318
00:59:40,230 --> 00:59:43,230
我要看到我
有两个子目录。

1319
00:59:43,230 --> 00:59:47,910
让我们使这个有点大
在这里，以便我们都可以看到它。

1320
00:59:47,910 --> 00:59:50,610
>> 我可以看到我
有两个子目录。

1321
00:59:50,610 --> 00:59:53,510
我会改变目录
进入工作区。

1322
00:59:53,510 --> 00:59:58,380
而我要的类型只会出
它的一部分，然后只需按一下Tab键。

1323
00:59:58,380 --> 01:00:01,520
而且它会完成剩下的我。

1324
01:00:01,520 --> 01:00:03,370
花式。

1325
01:00:03,370 --> 01:00:04,960
>> 我会看看，看看工作区。

1326
01:00:04,960 --> 01:00:08,431
而现在，我的工作
在超部分

1327
01:00:08,431 --> 01:00:09,680
我们是在教现在。

1328
01:00:09,680 --> 01:00:10,971
所以，我会去到该目录中。

1329
01:00:10,971 --> 01:00:14,770

1330
01:00:14,770 --> 01:00:15,970
最后，再看看吧。

1331
01:00:15,970 --> 01:00:18,480
而且我有这个文件bunny.c。

1332
01:00:18,480 --> 01:00:20,980
>> 好所以让我清楚的一次。

1333
01:00:20,980 --> 01:00:24,370
而且我要再次声明，我now--
仍然留在该目录

1334
01:00:24,370 --> 01:00:27,540
并且它告诉我，我在
该超部分目录。

1335
01:00:27,540 --> 01:00:30,690
我要继续前进，
让我的程序的兔子。

1336
01:00:30,690 --> 01:00:33,730

1337
01:00:33,730 --> 01:00:38,810
而该命令，使兔子，
虽然听起来有点古怪，

1338
01:00:38,810 --> 01:00:42,960
还调用铛编译器。

1339
01:00:42,960 --> 01:00:46,470
>> 而且它产生的
我的输出，

1340
01:00:46,470 --> 01:00:52,130
可执行funny--的
可执行文件被称为兔子。

1341
01:00:52,130 --> 01:00:52,700
行。

1342
01:00:52,700 --> 01:00:56,700
我可以再和这听起来
更糟的是，执行兔子。

1343
01:00:56,700 --> 01:00:59,360

1344
01:00:59,360 --> 01:01:00,680
行。

1345
01:01:00,680 --> 01:01:03,150
让我们看看会发生什么。

1346
01:01:03,150 --> 01:01:04,527
行。

1347
01:01:04,527 --> 01:01:06,360
这是一点点
我所期待的。

1348
01:01:06,360 --> 01:01:11,290
我有我的兔子图片在那里，
样的，但我希望它所有的本身。

1349
01:01:11,290 --> 01:01:13,186
我错过了什么？

1350
01:01:13,186 --> 01:01:14,478
>> 扬声器21：斜线L或斜线ñ。

1351
01:01:14,478 --> 01:01:15,602
BRIAN SCASSELLATI：斩ñ。

1352
01:01:15,602 --> 01:01:16,580
行。

1353
01:01:16,580 --> 01:01:18,800
因此，让我们回到这里。

1354
01:01:18,800 --> 01:01:20,330
我会离开的。

1355
01:01:20,330 --> 01:01:23,320
我会重新回到这一个。

1356
01:01:23,320 --> 01:01:27,720
让我们来看看现在
从我的主要功能在这里。

1357
01:01:27,720 --> 01:01:29,280
>> 所以，我应该怎么办？

1358
01:01:29,280 --> 01:01:30,465
我想结束就行了。

1359
01:01:30,465 --> 01:01:34,020

1360
01:01:34,020 --> 01:01:35,800
所以，我加入了注释。

1361
01:01:35,800 --> 01:01:38,430
我会在一个printf（）。

1362
01:01:38,430 --> 01:01:41,350
而且我有什么投入？

1363
01:01:41,350 --> 01:01:41,890
/ N。

1364
01:01:41,890 --> 01:01:43,480
行。

1365
01:01:43,480 --> 01:01:46,040
我有什么用结束了吗？

1366
01:01:46,040 --> 01:01:47,100
分号。

1367
01:01:47,100 --> 01:01:48,730
好吧。

1368
01:01:48,730 --> 01:01:52,880
>> 现在的人真的
重要的事情是要确保

1369
01:01:52,880 --> 01:01:56,720
每当你做出改变
在你的代码，你保存它。

1370
01:01:56,720 --> 01:02:01,380
如果您还没有保存你的代码，你
要注意到一个小星星在那里。

1371
01:02:01,380 --> 01:02:03,420
这星说你
已经没救了这些代码。

1372
01:02:03,420 --> 01:02:07,790
>> 如果我现在编译它，它不是
要反映的任何更改，

1373
01:02:07,790 --> 01:02:11,680
因为编译器查看文件
这是磁盘，而不是只是文件上

1374
01:02:11,680 --> 01:02:13,790
在编辑器中打开。

1375
01:02:13,790 --> 01:02:14,290
好吧。

1376
01:02:14,290 --> 01:02:20,830
>> 因此，让我们将它保存，然后我们会去
对上到这里，回来了。

1377
01:02:20,830 --> 01:02:24,670
下来到我的终端。

1378
01:02:24,670 --> 01:02:27,193
而让我们再次清除空间。

1379
01:02:27,193 --> 01:02:30,690

1380
01:02:30,690 --> 01:02:35,760
>> 我们可以继续前进，多了一个
时间让我们的兔子计划。

1381
01:02:35,760 --> 01:02:40,180
并执行兔子。

1382
01:02:40,180 --> 01:02:42,500
这也不起作用。

1383
01:02:42,500 --> 01:02:43,950
错误的斜线。

1384
01:02:43,950 --> 01:02:52,280
所以，如果你看一下我有，我把
/ N在那里，但我有错的斜线。

1385
01:02:52,280 --> 01:02:56,190
>> 一切你的电脑
做的是非常明确的。

1386
01:02:56,190 --> 01:02:57,230
好不好？

1387
01:02:57,230 --> 01:03:01,250
标点符号的一个小错误，
突然间，你没有得到你想要的。

1388
01:03:01,250 --> 01:03:01,750
好吧。

1389
01:03:01,750 --> 01:03:03,740
因此，让我们放大出来了。

1390
01:03:03,740 --> 01:03:04,410
我们会回去。

1391
01:03:04,410 --> 01:03:07,930
那么做出非常快修。

1392
01:03:07,930 --> 01:03:09,270
我们会把正确的斜线研究。

1393
01:03:09,270 --> 01:03:10,570
我们会保存。

1394
01:03:10,570 --> 01:03:13,410
我们会放大。

1395
01:03:13,410 --> 01:03:16,730
>> 出于某种原因，这不是
快乐，但让我们继续

1396
01:03:16,730 --> 01:03:19,850
我们将回到终端在这里。

1397
01:03:19,850 --> 01:03:22,940
它清除掉。

1398
01:03:22,940 --> 01:03:24,880
我们将进行放大。

1399
01:03:24,880 --> 01:03:28,410
而一个更多的时间，我们会让兔子。

1400
01:03:28,410 --> 01:03:32,360
而现在果然，它的工作原理。

1401
01:03:32,360 --> 01:03:33,240
万岁。

1402
01:03:33,240 --> 01:03:34,300
行。

1403
01:03:34,300 --> 01:03:39,580
>> 因此，让我们努力使今天
多了几分一般。

1404
01:03:39,580 --> 01:03:46,750
让我们来看看，而不仅仅是
打印一个特定的框架，

1405
01:03:46,750 --> 01:03:49,610
让我们来看看，如果我们可以让这个
这样我们就可以得到所有10

1406
01:03:49,610 --> 01:03:52,960
这些动画帧
我们希望有。

1407
01:03:52,960 --> 01:03:56,550
如此反复，让我们
此一步骤的时间。

1408
01:03:56,550 --> 01:03:59,900
>> 让我们先来概括它，不是
让我做的所有的帧，

1409
01:03:59,900 --> 01:04:03,990
但让我做任何一
框架，我可能想。

1410
01:04:03,990 --> 01:04:05,920
所以，有什么区别
在帧之间？

1411
01:04:05,920 --> 01:04:07,377
是兔子一样吗？

1412
01:04:07,377 --> 01:04:07,960
听众：是的。

1413
01:04:07,960 --> 01:04:08,390
BRIAN SCASSELLATI：是的。

1414
01:04:08,390 --> 01:04:09,370
有什么不同？

1415
01:04:09,370 --> 01:04:10,246
>> 听众：位置。

1416
01:04:10,246 --> 01:04:11,870
BRIAN SCASSELLATI：它的位置，对不对？

1417
01:04:11,870 --> 01:04:15,590
以及如何控制它的位置？

1418
01:04:15,590 --> 01:04:17,340
多少点我
将在开始

1419
01:04:17,340 --> 01:04:19,048
而且我有多少点
将在末端。

1420
01:04:19,048 --> 01:04:21,970
所以，我有五处
开始和五个在末端。

1421
01:04:21,970 --> 01:04:28,320
>> 让我们来替换五连一个for循环。

1422
01:04:28,320 --> 01:04:29,380
行。

1423
01:04:29,380 --> 01:04:32,330
而且我要创建一个用于
环现在会说，

1424
01:04:32,330 --> 01:04:37,800
我要打印一些数
的圆点在开始。

1425
01:04:37,800 --> 01:04:39,600
我将使用一个变量。

1426
01:04:39,600 --> 01:04:44,150
比方说，怎么样我作为
计数器在我的循环。

1427
01:04:44,150 --> 01:04:47,200
而我要声明它往上顶。

1428
01:04:47,200 --> 01:04:49,360
>> 然后在for循环
我需要做三件事情。

1429
01:04:49,360 --> 01:04:52,340
我需要做的第一件事情
是我需要初始化我。

1430
01:04:52,340 --> 01:04:56,570
我应该怎么初始化
它开始呢？

1431
01:04:56,570 --> 01:04:57,160
0。

1432
01:04:57,160 --> 01:04:58,310
行。

1433
01:04:58,310 --> 01:05:00,950
>> 然后，我需要说的，有什么
终止条件？

1434
01:05:00,950 --> 01:05:03,020
什么时候应该停下来？

1435
01:05:03,020 --> 01:05:05,983
那么多少个点你
要打印在这一个？

1436
01:05:05,983 --> 01:05:06,921
>> 听众：五。

1437
01:05:06,921 --> 01:05:08,170
BRIAN SCASSELLATI：五了吗？

1438
01:05:08,170 --> 01:05:10,650
怎么样让我们做什么
不同的，我们做了五位。

1439
01:05:10,650 --> 01:05:12,584
让我们表明，它的不同。

1440
01:05:12,584 --> 01:05:13,250
扬声器22：两个。

1441
01:05:13,250 --> 01:05:13,580
BRIAN SCASSELLATI：两个。

1442
01:05:13,580 --> 01:05:14,080
行。

1443
01:05:14,080 --> 01:05:17,760
所以，如果我想两个点，
我应该放在这里？

1444
01:05:17,760 --> 01:05:19,140
>> 听众：三。

1445
01:05:19,140 --> 01:05:20,530
>> BRIAN SCASSELLATI：三。

1446
01:05:20,530 --> 01:05:21,400
行。

1447
01:05:21,400 --> 01:05:24,220
多少次是
要办理什么手续？

1448
01:05:24,220 --> 01:05:28,469
这是怎么回事要经过
三次，0，1，和图2，是吗？

1449
01:05:28,469 --> 01:05:30,010
好吧，让我们回到到两个。

1450
01:05:30,010 --> 01:05:31,570
现在，我们会得到两个点。

1451
01:05:31,570 --> 01:05:35,800
什么做我想做的每一
一次我去通过循环？

1452
01:05:35,800 --> 01:05:38,657
什么必须改变
每次我办理什么手续？

1453
01:05:38,657 --> 01:05:39,850
>> 扬声器23：添加一个点。

1454
01:05:39,850 --> 01:05:41,020
>> BRIAN SCASSELLATI：我一定要坚持下去。

1455
01:05:41,020 --> 01:05:41,978
我要加一个点。

1456
01:05:41,978 --> 01:05:45,310
我要打印一个点，
通过每次循环。

1457
01:05:45,310 --> 01:05:49,990
但我怎么保存，如何跟踪
很多次，我经历过的循环？

1458
01:05:49,990 --> 01:05:53,260
我用我，那
变量，该计数器。

1459
01:05:53,260 --> 01:05:57,110
>> 所以每次经过，我要去
一个递增计数器。

1460
01:05:57,110 --> 01:06:00,670
现在，这是相同的
我的话说：I = I + 1。

1461
01:06:00,670 --> 01:06:01,210
没关系。

1462
01:06:01,210 --> 01:06:04,653
我能做到这一点that--我喜欢
速记，所以我会说我++。

1463
01:06:04,653 --> 01:06:07,190

1464
01:06:07,190 --> 01:06:08,370
行。

1465
01:06:08,370 --> 01:06:10,680
>> 让我们做同样的事情
这儿的底部。

1466
01:06:10,680 --> 01:06:11,846
那种只有我做了一个。

1467
01:06:11,846 --> 01:06:13,990
我将让你们
完全做到这一点。

1468
01:06:13,990 --> 01:06:14,260
好吧。

1469
01:06:14,260 --> 01:06:15,426
>> 所以，我应该写在这里？

1470
01:06:15,426 --> 01:06:17,170
这是我的for循环。

1471
01:06:17,170 --> 01:06:23,162
我会做一个printf（），我要去
为让这个我只打印一个点

1472
01:06:23,162 --> 01:06:25,740
在该底部。

1473
01:06:25,740 --> 01:06:27,740
>> 我应该怎么写
这里面现在循环？

1474
01:06:27,740 --> 01:06:30,897

1475
01:06:30,897 --> 01:06:33,948
好了，首先是什么
变量我应该使用？

1476
01:06:33,948 --> 01:06:35,430
>> 扬声器24：J-。

1477
01:06:35,430 --> 01:06:36,880
>> BRIAN SCASSELLATI：我可以用学家

1478
01:06:36,880 --> 01:06:38,040
我可以使用相同的吗？

1479
01:06:38,040 --> 01:06:39,961
我还可以再用吗？

1480
01:06:39,961 --> 01:06:40,460
是啊。

1481
01:06:40,460 --> 01:06:45,531
这是确定的，因为是
我使用了这里，

1482
01:06:45,531 --> 01:06:47,780
我不要再当需要他们
我得到了这一点。

1483
01:06:47,780 --> 01:06:52,240

1484
01:06:52,240 --> 01:06:53,790
>> 所以，我应该初始化我来？

1485
01:06:53,790 --> 01:06:56,675

1486
01:06:56,675 --> 01:06:57,300
扬声器25：10。

1487
01:06:57,300 --> 01:06:58,567
BRIAN SCASSELLATI：0。

1488
01:06:58,567 --> 01:06:59,400
我应该怎么检查？

1489
01:06:59,400 --> 01:07:02,960
多少点我现在需要在最后
如果我有两个点的开始？

1490
01:07:02,960 --> 01:07:05,820

1491
01:07:05,820 --> 01:07:09,165
我需要8月末，还等什么
我应该检查一下，我少than--

1492
01:07:09,165 --> 01:07:12,645
>> 听众：七，八，九。

1493
01:07:12,645 --> 01:07:14,020
BRIAN SCASSELLATI：听说七人。

1494
01:07:14,020 --> 01:07:14,810
我听到了八强。

1495
01:07:14,810 --> 01:07:15,970
我听见九岁。

1496
01:07:15,970 --> 01:07:16,470
行。

1497
01:07:16,470 --> 01:07:19,540
所以我们都在正确的
ball--杰森说：10。

1498
01:07:19,540 --> 01:07:21,550
行。

1499
01:07:21,550 --> 01:07:25,920
>> 如果我需要两个点的
第一位的，又有多少呢

1500
01:07:25,920 --> 01:07:30,170
我 - 我需要8个点的
最后埃德蒙顿我放了两个加上面，

1501
01:07:30,170 --> 01:07:31,743
我应该放下下面？

1502
01:07:31,743 --> 01:07:32,570
>> 听众：八。

1503
01:07:32,570 --> 01:07:33,611
>> BRIAN SCASSELLATI：八。

1504
01:07:33,611 --> 01:07:35,695
因为这是要
算上0到7。

1505
01:07:35,695 --> 01:07:38,490
这就是通过环路八次。

1506
01:07:38,490 --> 01:07:38,990
行。

1507
01:07:38,990 --> 01:07:41,774
什么我必须做底？

1508
01:07:41,774 --> 01:07:42,670
>> 观众：我++。

1509
01:07:42,670 --> 01:07:44,400
>> BRIAN SCASSELLATI：我++。

1510
01:07:44,400 --> 01:07:45,440
好吧。

1511
01:07:45,440 --> 01:07:48,260
所以，这看起来相当不错那里。

1512
01:07:48,260 --> 01:07:50,620
让我们来试试吧，让我们看看会发生什么。

1513
01:07:50,620 --> 01:07:51,450
行。

1514
01:07:51,450 --> 01:07:53,770
所以我们要保存它。

1515
01:07:53,770 --> 01:07:54,940
尼斯和保存。

1516
01:07:54,940 --> 01:07:56,910
>> 我们将放大出来。

1517
01:07:56,910 --> 01:07:58,220
我们将尝试在这里的终端。

1518
01:07:58,220 --> 01:08:01,440

1519
01:08:01,440 --> 01:08:02,970
我们将进行放大。

1520
01:08:02,970 --> 01:08:05,416
哎呀。

1521
01:08:05,416 --> 01:08:09,990
我们会，更多的时间，
让我们的兔子计划。

1522
01:08:09,990 --> 01:08:14,460
并继续前进，执行兔子。

1523
01:08:14,460 --> 01:08:15,980
它就在那里。

1524
01:08:15,980 --> 01:08:17,710
>> 因此，有我们的兔子。

1525
01:08:17,710 --> 01:08:25,130
其中，它有两个点的开头
和8个点出在末端。

1526
01:08:25,130 --> 01:08:27,540
大家还我？

1527
01:08:27,540 --> 01:08:28,770
行。

1528
01:08:28,770 --> 01:08:29,580
>> 因此，我们建立起来。

1529
01:08:29,580 --> 01:08:33,000
我们造成了一辆小兔子，
一个特定帧。

1530
01:08:33,000 --> 01:08:36,229
现在，我们已经能够
概括说来构建

1531
01:08:36,229 --> 01:08:38,390
更，不同种帧。

1532
01:08:38,390 --> 01:08:42,399
>> 现在，让我们继续前进，并有
它产生的不只是一个框架，

1533
01:08:42,399 --> 01:08:46,290
但让我们产生10
帧，在那里我们慢慢地

1534
01:08:46,290 --> 01:08:50,569
让兔子把所有
横跨字段的方式。

1535
01:08:50,569 --> 01:08:51,430
好吧。

1536
01:08:51,430 --> 01:08:53,660
>> 让我们回去。

1537
01:08:53,660 --> 01:08:54,839
我们会尽力了。

1538
01:08:54,839 --> 01:09:00,680

1539
01:09:00,680 --> 01:09:02,830
那么什么才是我真正需要改变这里的？

1540
01:09:02,830 --> 01:09:06,139

1541
01:09:06,139 --> 01:09:07,180
我需要做什么改变？

1542
01:09:07,180 --> 01:09:10,638
>> 扬声器26：首先，您需要
改变点的最大数量

1543
01:09:10,638 --> 01:09:11,626
在开始。

1544
01:09:11,626 --> 01:09:16,850
因为如果我们正在做的10点，
这将需要多达规模。

1545
01:09:16,850 --> 01:09:17,850
BRIAN SCASSELLATI：是的。

1546
01:09:17,850 --> 01:09:23,760
所以，现在我有几分是硬
要始终做到两个点开头

1547
01:09:23,760 --> 01:09:27,890
始终做到8个点底。

1548
01:09:27,890 --> 01:09:30,660
>> 我想建一个循环，对不对？

1549
01:09:30,660 --> 01:09:33,290
因为我不希望
建立只是一个兔子图片，

1550
01:09:33,290 --> 01:09:37,140
我想建立10兔子的照片。

1551
01:09:37,140 --> 01:09:41,500
所以，我需要建立另一个循环，
当我经过这个循环，

1552
01:09:41,500 --> 01:09:44,660
我想换多少
点我打印开头

1553
01:09:44,660 --> 01:09:50,529
多少点我打印末，
基于通过环路循环

1554
01:09:50,529 --> 01:09:52,270
算我一个。

1555
01:09:52,270 --> 01:09:52,770
好吧。

1556
01:09:52,770 --> 01:09:54,430
>> 因此，让我们得到另一个柜台。

1557
01:09:54,430 --> 01:09:58,142
别人的面前说Ĵ，
所以我们会再拍学家

1558
01:09:58,142 --> 01:10:00,100
而现在，我们要
for循环另建。

1559
01:10:00,100 --> 01:10:02,650

1560
01:10:02,650 --> 01:10:06,200
>> 什么是循环中去？

1561
01:10:06,200 --> 01:10:09,060
这东西已去
内循环，对不对？

1562
01:10:09,060 --> 01:10:11,190
难道兔子有
走在循环中？

1563
01:10:11,190 --> 01:10:13,390
我需要在一个小兔子
其中每个10帧？

1564
01:10:13,390 --> 01:10:14,099
>> 听众：嗯。

1565
01:10:14,099 --> 01:10:15,098
BRIAN SCASSELLATI：是的。

1566
01:10:15,098 --> 01:10:17,250
我想在每一个兔子
在10帧的，对不对？

1567
01:10:17,250 --> 01:10:20,531
怎么样的圆点
最后，我需要吗？

1568
01:10:20,531 --> 01:10:21,030
行。

1569
01:10:21,030 --> 01:10:22,550
>> 所以，我要缩进所有的人。

1570
01:10:22,550 --> 01:10:25,110
我要强调的是
这一点，我会打标签。

1571
01:10:25,110 --> 01:10:28,590
这就是将他们推向全国各地
一点点，这样很容易让我

1572
01:10:28,590 --> 01:10:32,010
看看有什么环路中。

1573
01:10:32,010 --> 01:10:33,710
然后，我将结束它。

1574
01:10:33,710 --> 01:10:35,850
比如说。

1575
01:10:35,850 --> 01:10:36,430
好不好？

1576
01:10:36,430 --> 01:10:39,230
>> 现在，在该循环
我building--哎呦，

1577
01:10:39,230 --> 01:10:43,810
做出这样你就可以see--
我有我的计数器j。

1578
01:10:43,810 --> 01:10:45,630
我会在0开始的。

1579
01:10:45,630 --> 01:10:47,829
多少次，我想
要经过这个循环？

1580
01:10:47,829 --> 01:10:48,620
听众：10次。

1581
01:10:48,620 --> 01:10:49,786
布莱恩SCASSELLATI：10次。

1582
01:10:49,786 --> 01:10:51,402
那么什么号码，我应该把在这里？

1583
01:10:51,402 --> 01:10:52,880
>> 听众：9，10。

1584
01:10:52,880 --> 01:10:55,600
>> 布莱恩SCASSELLATI：9，10，
有人在得说11了吧？

1585
01:10:55,600 --> 01:10:58,190

1586
01:10:58,190 --> 01:11:01,585
我想两个点前
并把小于2我。

1587
01:11:01,585 --> 01:11:03,810
我想8个点，
我把小于8我。

1588
01:11:03,810 --> 01:11:06,950
现在我想通过10
次，所以我把Ĵ少than--

1589
01:11:06,950 --> 01:11:07,590
>> 听众：10。

1590
01:11:07,590 --> 01:11:08,610
>> BRIAN SCASSELLATI：10。

1591
01:11:08,610 --> 01:11:10,150
在那里，我们走了。

1592
01:11:10,150 --> 01:11:13,360
而我做底到j是什么？

1593
01:11:13,360 --> 01:11:15,310
++，增加它。

1594
01:11:15,310 --> 01:11:16,230
行。

1595
01:11:16,230 --> 01:11:21,500
现在，这里的棘手的部分，什么是
会发生什么，现在如果我这样做？

1596
01:11:21,500 --> 01:11:24,537
我要去打印10帧？

1597
01:11:24,537 --> 01:11:26,370
SPEAKER 27：我认为，
他们都会是相同的。

1598
01:11:26,370 --> 01:11:28,453
BRIAN SCASSELLATI：他们会
都是一样的，对不对？

1599
01:11:28,453 --> 01:11:31,750
因为所有的人都仍在继续
把两个点开头。

1600
01:11:31,750 --> 01:11:34,162
但我不希望它们都
有两个点的开始。

1601
01:11:34,162 --> 01:11:35,870
多少点我
想在开始？

1602
01:11:35,870 --> 01:11:39,097

1603
01:11:39,097 --> 01:11:40,020
>> 听众：更改。

1604
01:11:40,020 --> 01:11:42,840
>> BRIAN SCASSELLATI：我
想要改变，对不对？

1605
01:11:42,840 --> 01:11:46,588
所以，我有什么在这里，正在改变
每次循环经历？

1606
01:11:46,588 --> 01:11:48,242
>> 听众：的点数，J。

1607
01:11:48,242 --> 01:11:49,950
BRIAN SCASSELLATI：J-，
点的数量。

1608
01:11:49,950 --> 01:11:54,782
所以，我可以改变这是学家

1609
01:11:54,782 --> 01:11:59,190
第一次通过
环，那是什么打算呢？

1610
01:11:59,190 --> 01:12:01,700
我该怎么设置J可在第一？

1611
01:12:01,700 --> 01:12:02,420
>> 听众：0。

1612
01:12:02,420 --> 01:12:05,700
>> BRIAN SCASSELLATI：那么有多少
次我该怎么做呢？

1613
01:12:05,700 --> 01:12:06,750
0。

1614
01:12:06,750 --> 01:12:11,750
通过循环，J的第二时间
将是1，因为我加一。

1615
01:12:11,750 --> 01:12:14,180
多少点我要去打印？

1616
01:12:14,180 --> 01:12:15,100
1。

1617
01:12:15,100 --> 01:12:19,904
通过循环的第三次，
多少点我要去打印？

1618
01:12:19,904 --> 01:12:20,587
>> 听众：三。

1619
01:12:20,587 --> 01:12:22,170
BRIAN SCASSELLATI：J-将是3。

1620
01:12:22,170 --> 01:12:24,890
多少点我要去打印？

1621
01:12:24,890 --> 01:12:26,817
哦，对不起，J将是2。

1622
01:12:26,817 --> 01:12:28,233
多少点我要去打印？

1623
01:12:28,233 --> 01:12:28,980
>> 听众：2。

1624
01:12:28,980 --> 01:12:29,855
>> BRIAN SCASSELLATI：2。

1625
01:12:29,855 --> 01:12:32,460
好了，所以我要保持
递增的，因为我们走。

1626
01:12:32,460 --> 01:12:33,460
如何向下跌破？

1627
01:12:33,460 --> 01:12:34,310
善有善报这儿？

1628
01:12:34,310 --> 01:12:38,080
我不想8总
在结束了吗？

1629
01:12:38,080 --> 01:12:39,269
>> 扬声器28：10。

1630
01:12:39,269 --> 01:12:40,685
BRIAN SCASSELLATI：我想10点？

1631
01:12:40,685 --> 01:12:43,440

1632
01:12:43,440 --> 01:12:44,620
我希望它改变了。

1633
01:12:44,620 --> 01:12:47,469
所以，我怎么想它改变？

1634
01:12:47,469 --> 01:12:49,167
>> 听众：[听不清]。

1635
01:12:49,167 --> 01:12:51,750
BRIAN SCASSELLATI：嗯，如果我
有五个点在开始，

1636
01:12:51,750 --> 01:12:53,293
多少个点的我在最后得到什么呢？

1637
01:12:53,293 --> 01:12:54,020
>> 听众：五。

1638
01:12:54,020 --> 01:12:55,630
>> 布赖恩SCASSELLATI：如果我有
6点之初，

1639
01:12:55,630 --> 01:12:56,875
多少才能获得在结束了吗？

1640
01:12:56,875 --> 01:12:57,500
听众：四。

1641
01:12:57,500 --> 01:12:58,950
布赖恩SCASSELLATI：如果我有
7点在一开始，

1642
01:12:58,950 --> 01:13:00,204
多少才能获得在结束了吗？

1643
01:13:00,204 --> 01:13:00,870
听众：三。

1644
01:13:00,870 --> 01:13:03,161
布赖恩SCASSELLATI：如果我
有Ĵ点之初，

1645
01:13:03,161 --> 01:13:04,790
多少才能获得在结束了吗？

1646
01:13:04,790 --> 01:13:07,520
10-j的。

1647
01:13:07,520 --> 01:13:08,650
行。

1648
01:13:08,650 --> 01:13:10,390
所以让我们尝试了这一点。

1649
01:13:10,390 --> 01:13:13,180
>> 所以，我要拯救我们的兔子计划。

1650
01:13:13,180 --> 01:13:16,270
我们再次将缩小。

1651
01:13:16,270 --> 01:13:19,090
我们将去到我们的终端。

1652
01:13:19,090 --> 01:13:20,180
我们将清除它。

1653
01:13:20,180 --> 01:13:23,410
并进行放大。

1654
01:13:23,410 --> 01:13:26,410
我们将让我们的兔子节目，再次。

1655
01:13:26,410 --> 01:13:27,690
我们将执行它。

1656
01:13:27,690 --> 01:13:30,462

1657
01:13:30,462 --> 01:13:32,090
嗯，哦。

1658
01:13:32,090 --> 01:13:34,580
>> 等一下，让我们缩小。

1659
01:13:34,580 --> 01:13:36,860
难道我得到10帧？

1660
01:13:36,860 --> 01:13:38,970
那么，有多少兔子
我看到那里？

1661
01:13:38,970 --> 01:13:43,330
1，2，3，4，5，6，7，8，9，10。

1662
01:13:43,330 --> 01:13:44,820
我得到了10帧。

1663
01:13:44,820 --> 01:13:46,375
他们都是一样的吗？

1664
01:13:46,375 --> 01:13:47,000
听众：是的。

1665
01:13:47,000 --> 01:13:48,740
第

1666
01:13:48,740 --> 01:13:50,000
>> BRIAN SCASSELLATI：没有。

1667
01:13:50,000 --> 01:13:55,050
这第一位的，
兔子是远在左边。

1668
01:13:55,050 --> 01:13:57,541
而在这里，兔子是远在

1669
01:13:57,541 --> 01:13:58,290
SPEAKER 29：对。

1670
01:13:58,290 --> 01:14:00,502
BRIAN SCASSELLATI：那么，
我怎么忘了怎么办？

1671
01:14:00,502 --> 01:14:01,750
扬声器30：启动一个新行。

1672
01:14:01,750 --> 01:14:04,041
BRIAN SCASSELLATI：我忘了
开始一个新的生产线，再次。

1673
01:14:04,041 --> 01:14:05,270
同样的错误，我之前所做的。

1674
01:14:05,270 --> 01:14:07,120
好吧，让我们去解决这个问题。

1675
01:14:07,120 --> 01:14:11,690
现在，我还有代码
在那里做一个新的生产线。

1676
01:14:11,690 --> 01:14:13,899
为什么不工作？

1677
01:14:13,899 --> 01:14:15,440
扬声器31：这不是在循环中。

1678
01:14:15,440 --> 01:14:17,710
BRIAN SCASSELLATI：哦，
它不是在循环中。

1679
01:14:17,710 --> 01:14:18,520
这是正确的。

1680
01:14:18,520 --> 01:14:20,150
它在这里坐在外面。

1681
01:14:20,150 --> 01:14:23,470

1682
01:14:23,470 --> 01:14:29,050
而for循环就是一切
就是这样的文字里。

1683
01:14:29,050 --> 01:14:35,500
>> 所以，我要动
这里面的for循环。

1684
01:14:35,500 --> 01:14:39,410
我将标签在它前面
表明它在正确的地方。

1685
01:14:39,410 --> 01:14:42,020
而现在，我们将重新保存。

1686
01:14:42,020 --> 01:14:44,350
我们会缩小。

1687
01:14:44,350 --> 01:14:45,770
我们将切换到我们的终端。

1688
01:14:45,770 --> 01:14:48,330

1689
01:14:48,330 --> 01:14:50,360
放大。

1690
01:14:50,360 --> 01:14:54,050
我们将重塑我们的兔子计划。

1691
01:14:54,050 --> 01:14:59,070
而现在，现在我们已经得到了我们的10帧。

1692
01:14:59,070 --> 01:15:00,190
>> [掌声]

1693
01:15:00,190 --> 01:15:02,120
>> BRIAN SCASSELLATI：OK。

1694
01:15:02,120 --> 01:15:04,080
所以。

1695
01:15:04,080 --> 01:15:08,370
我们的嵌套这里的for循环。

1696
01:15:08,370 --> 01:15:13,140
我们能够生成在
我有多少点希望内环

1697
01:15:13,140 --> 01:15:15,320
打印在开始的时候，在末端。

1698
01:15:15,320 --> 01:15:21,570
和外环控制
多少帧我是建设。

1699
01:15:21,570 --> 01:15:26,340
我们从一个小小的
问题的核心，

1700
01:15:26,340 --> 01:15:30,320
我们从该点建造出来。

1701
01:15:30,320 --> 01:15:30,820
好吧。

1702
01:15:30,820 --> 01:15:33,500
>> 让我们做一个步骤。

1703
01:15:33,500 --> 01:15:35,040
你准备好了吗？

1704
01:15:35,040 --> 01:15:38,800
有一件事在这儿，
样的，我们实际上已经得到了

1705
01:15:38,800 --> 01:15:42,180
更多的复杂性比我们所需要的。

1706
01:15:42,180 --> 01:15:44,700
让我们一起来看看。

1707
01:15:44,700 --> 01:15:52,050
因此，在我们的兔子节目，
如果我缩小这里，

1708
01:15:52,050 --> 01:15:54,980
我实际上做一些相同的
事情一遍又一遍。

1709
01:15:54,980 --> 01:15:59,032
我该怎么做那类的
同样的事情重复了两次？

1710
01:15:59,032 --> 01:16:00,310
>> 扬声器32：打印点。

1711
01:16:00,310 --> 01:16:03,526
>> BRIAN SCASSELLATI：是
我打印这些点的两倍。

1712
01:16:03,526 --> 01:16:05,710
说真的，我应该有
此评论到这里。

1713
01:16:05,710 --> 01:16:09,037
我打印了一些点在
开始，一直在这里。

1714
01:16:09,037 --> 01:16:10,620
然后，我打印了一些点底。

1715
01:16:10,620 --> 01:16:14,694
我做那种完全一样的东西。

1716
01:16:14,694 --> 01:16:17,110
我们要开始
致力于在未来几周内

1717
01:16:17,110 --> 01:16:23,440
是能够利用这些区块
我们使用了一遍又一遍代码，

1718
01:16:23,440 --> 01:16:25,800
并通过一个过程
所谓抽象，

1719
01:16:25,800 --> 01:16:31,100
我们要拉他们出来，
一旦写出来，这样我们就可以

1720
01:16:31,100 --> 01:16:35,130
一遍又一遍重复使用它们。

1721
01:16:35,130 --> 01:16:37,210
因此，让我们试试吧。

1722
01:16:37,210 --> 01:16:38,220
准备好了吗？

1723
01:16:38,220 --> 01:16:42,200
>> 我们将利用这个代码块。

1724
01:16:42,200 --> 01:16:45,280
而且我打算把它救出来。

1725
01:16:45,280 --> 01:16:50,530
而且我要define--
向下在底部，

1726
01:16:50,530 --> 01:16:53,130
我打算写一个新的功能。

1727
01:16:53,130 --> 01:16:54,750
它不会返回任何东西。

1728
01:16:54,750 --> 01:16:58,550
而且我要叫它printDots。

1729
01:16:58,550 --> 01:17:01,530
>> 这将需要一个
参数，一个整数，

1730
01:17:01,530 --> 01:17:04,920
说howManyDots我应打印。

1731
01:17:04,920 --> 01:17:09,310

1732
01:17:09,310 --> 01:17:17,720
而不是打印Ĵ点和现在，我
打印告诉howManyDots我应打印。

1733
01:17:17,720 --> 01:17:21,581
>> 而且还有一个小问题在这里。

1734
01:17:21,581 --> 01:17:22,580
任何人都知道它是什么？

1735
01:17:22,580 --> 01:17:27,270

1736
01:17:27,270 --> 01:17:31,505
我有什么说的上市
在这里没有定义？

1737
01:17:31,505 --> 01:17:34,165

1738
01:17:34,165 --> 01:17:35,090
>> 听众：[听不清]

1739
01:17:35,090 --> 01:17:37,465
>> BRIAN SCASSELLATI：那么怎么样
多点是指直到

1740
01:17:37,465 --> 01:17:40,584
在这里，但我使用的变量i。

1741
01:17:40,584 --> 01:17:43,750
所以，我要采取的变量i
我要去下来定义它在这里

1742
01:17:43,750 --> 01:17:44,610
代替。

1743
01:17:44,610 --> 01:17:49,683
>> 所以，现在它要stay--哎呀，
得到了大写锁定somehow--我

1744
01:17:49,683 --> 01:17:52,060
要保持我倒在这里。

1745
01:17:52,060 --> 01:17:57,050
>> 所以，现在这里是我的小功能
或子程序，它说，

1746
01:17:57,050 --> 01:18:00,640
多少点我要去打印？

1747
01:18:00,640 --> 01:18:05,300
而且它会通过这个循环，
一遍又一遍打印出来。

1748
01:18:05,300 --> 01:18:10,940
>> 那么我可以修改我的程序在这里。

1749
01:18:10,940 --> 01:18:12,540
而且我怎么调用该函数？

1750
01:18:12,540 --> 01:18:13,960
printDots。

1751
01:18:13,960 --> 01:18:17,060
所以，我会打电话给printDots。

1752
01:18:17,060 --> 01:18:21,530
多少点我要打印
第一次小兔过吗？

1753
01:18:21,530 --> 01:18:22,030
听众：J-。

1754
01:18:22,030 --> 01:18:23,230
BRIAN SCASSELLATI：J-。

1755
01:18:23,230 --> 01:18:27,110
多少点我要打印
在最后，兔子后？

1756
01:18:27,110 --> 01:18:30,610

1757
01:18:30,610 --> 01:18:31,110
10-j的。

1758
01:18:31,110 --> 01:18:35,020

1759
01:18:35,020 --> 01:18:38,010
>> 还有一件事我很想念。

1760
01:18:38,010 --> 01:18:43,740
正如你在演讲今天看到的，
我们要声明printDots

1761
01:18:43,740 --> 01:18:52,430
高达上面给的原型。

1762
01:18:52,430 --> 01:18:56,740

1763
01:18:56,740 --> 01:18:58,220
行。

1764
01:18:58,220 --> 01:19:03,530
>> 因此，我所做的是我一直在努力，
隔离的代码重用一部分

1765
01:19:03,530 --> 01:19:06,430
我已经做了一遍又一遍。

1766
01:19:06,430 --> 01:19:11,120
我一直试图将其拉出，使
所有这一切都包含在一个地方。

1767
01:19:11,120 --> 01:19:16,810
这样一来，如果我有一个错误的地方，
我只需要解决它在一个地方。

1768
01:19:16,810 --> 01:19:17,310
好吧。

1769
01:19:17,310 --> 01:19:18,470
>> 因此，让我们将它保存。

1770
01:19:18,470 --> 01:19:20,950
而且，我们要确保它的工作原理。

1771
01:19:20,950 --> 01:19:22,050
因此，让我们走出去。

1772
01:19:22,050 --> 01:19:25,200
我们将再次去我们的终端。

1773
01:19:25,200 --> 01:19:27,960
我们将进行放大。

1774
01:19:27,960 --> 01:19:31,010
我们会作出这样的兔子进程。

1775
01:19:31,010 --> 01:19:32,380
>> 呵呵。

1776
01:19:32,380 --> 01:19:34,800
它给了我一个警告。

1777
01:19:34,800 --> 01:19:37,070
它是什么告诉我？

1778
01:19:37,070 --> 01:19:39,870
那么在任何这些
时候，你总是希望

1779
01:19:39,870 --> 01:19:44,170
滚动到第一个error--
现在就这一个，我只得到了一个。

1780
01:19:44,170 --> 01:19:52,700
>> 它告诉我bunny.c，上线
8，第9栏，有一个问题。

1781
01:19:52,700 --> 01:19:58,650
它说，你已经声明这
变量i，你还没有使用过。

1782
01:19:58,650 --> 01:20:02,230
>> 现在通常，这是
还不是最坏的错误。

1783
01:20:02,230 --> 01:20:04,300
这是一个容易解决。

1784
01:20:04,300 --> 01:20:07,550
而事实上，我们可以回去研究。

1785
01:20:07,550 --> 01:20:09,910
我们可以回到兔子。

1786
01:20:09,910 --> 01:20:13,010
在这种情况下，所有的我们
所要做的就是摆脱我，

1787
01:20:13,010 --> 01:20:16,630
因为我们没有使用
我在主了。

1788
01:20:16,630 --> 01:20:19,860
我们只是用它
在我们的子程序。

1789
01:20:19,860 --> 01:20:22,777
>> 因此，让我们保存。

1790
01:20:22,777 --> 01:20:23,360
我们会回去。

1791
01:20:23,360 --> 01:20:26,760

1792
01:20:26,760 --> 01:20:28,630
并进行放大。

1793
01:20:28,630 --> 01:20:30,700
我们将更多的时间做兔子。

1794
01:20:30,700 --> 01:20:33,810

1795
01:20:33,810 --> 01:20:36,530
还有一次是我们的10帧。

1796
01:20:36,530 --> 01:20:39,450

1797
01:20:39,450 --> 01:20:41,360
行。

1798
01:20:41,360 --> 01:20:43,190
>> 提供给您的任何时候
一个procedure--呀。

1799
01:20:43,190 --> 01:20:44,690
SPEAKER 33：我有A--我很困惑。

1800
01:20:44,690 --> 01:20:45,892
你能回去的代码？

1801
01:20:45,892 --> 01:20:46,850
BRIAN SCASSELLATI：是的。

1802
01:20:46,850 --> 01:20:50,730

1803
01:20:50,730 --> 01:20:54,367
>> SPEAKER 33：所以，当你写的
你的原型，争论你

1804
01:20:54,367 --> 01:20:56,550
有它命名叫的howmany？

1805
01:20:56,550 --> 01:20:57,540
但是，below--

1806
01:20:57,540 --> 01:20:57,640
>> BRIAN SCASSELLATI：哦，是的。

1807
01:20:57,640 --> 01:20:59,140
>> SPEAKER 33：--called他们的东西
不同的，我不明白。

1808
01:20:59,140 --> 01:21:00,240
>> BRIAN SCASSELLATI：为什么
他们是不同的。

1809
01:21:00,240 --> 01:21:01,780
所以这是一个很好的问题。

1810
01:21:01,780 --> 01:21:08,250
所以现在的问题是，上升
在这里，我写的howmany，

1811
01:21:08,250 --> 01:21:12,380
而楼下，我写了howManyDots。

1812
01:21:12,380 --> 01:21:15,590
>> 其原因是，在你的原型，
它实际上不重视

1813
01:21:15,590 --> 01:21:17,090
给你把的姓名。

1814
01:21:17,090 --> 01:21:20,530
它所真正关心
是，它是一个整数。

1815
01:21:20,530 --> 01:21:23,080
它希望知道的形式
对你把什么。

1816
01:21:23,080 --> 01:21:31,560
>> 现在stylistically-- oops--我应该
不，是我喜欢做这些比赛。

1817
01:21:31,560 --> 01:21:33,150
行。

1818
01:21:33,150 --> 01:21:36,430
因为这会保持它
我更容易记住。

1819
01:21:36,430 --> 01:21:38,390
但是，这是我的错呀。

1820
01:21:38,390 --> 01:21:47,620
>> SPEAKER 34：所以对于
原型去上班，就

1821
01:21:47,620 --> 01:21:50,510
写作这一行，
写原型，

1822
01:21:50,510 --> 01:21:53,932
允许函数来
右下方它去年底

1823
01:21:53,932 --> 01:21:55,140
和检索是什么意思？

1824
01:21:55,140 --> 01:21:58,480
>> BRIAN SCASSELLATI：这是什么意思
是当编译经过，

1825
01:21:58,480 --> 01:22:01,930
它从顶部
你的代码底部。

1826
01:22:01,930 --> 01:22:05,430
什么这个原型是，
是它基本上是一个承诺。

1827
01:22:05,430 --> 01:22:09,570
>> 它说，那里将是
一个函数定义的地方。

1828
01:22:09,570 --> 01:22:11,880
这将是所谓的printDots。

1829
01:22:11,880 --> 01:22:15,110
而这将需要一个参数
那将是一个整数

1830
01:22:15,110 --> 01:22:18,590
并且它会返回
什么都没有，空类型。

1831
01:22:18,590 --> 01:22:19,310
行。

1832
01:22:19,310 --> 01:22:22,950
我向你保证这将是
某处定义的道路。

1833
01:22:22,950 --> 01:22:25,590
但是，任何时候你看
那，你下去

1834
01:22:25,590 --> 01:22:28,710
通过其余我
主要的功能，我想

1835
01:22:28,710 --> 01:22:33,800
你可以把它看成一个函数
这需要一个整数输入。

1836
01:22:33,800 --> 01:22:37,970
>> 因此，当编译器出现故障
通过这一点，它认为这一承诺。

1837
01:22:37,970 --> 01:22:40,220
当它下来，
一直走，一直走，

1838
01:22:40,220 --> 01:22:43,060
它找到的第一次
printDots被提及。

1839
01:22:43,060 --> 01:22:46,910
它说，呵呵，你给
我这个学家生的一个整数。

1840
01:22:46,910 --> 01:22:49,570
>> 嗯，你答应我，会
是一个整数，这是正确的。

1841
01:22:49,570 --> 01:22:51,370
没关系。

1842
01:22:51,370 --> 01:22:53,880
然后终于，下来
在最底层，

1843
01:22:53,880 --> 01:22:58,340
之前，我到年底我
文件，我兑现我的诺言

1844
01:22:58,340 --> 01:22:59,896
我定义它。

1845
01:22:59,896 --> 01:23:01,868
好不好？

1846
01:23:01,868 --> 01:23:06,320
>> 扬声器35：所以，saves--的
程序将保存空白

1847
01:23:06,320 --> 01:23:09,570
它可以追溯到并填充在结束了吗？

1848
01:23:09,570 --> 01:23:12,140
>> BRIAN SCASSELLATI：这不是
关于内存分配。

1849
01:23:12,140 --> 01:23:16,800
它实际上只是什么
类型是你希望看到的。

1850
01:23:16,800 --> 01:23:19,340
如果这件事情有一个
参数或五个参数？

1851
01:23:19,340 --> 01:23:23,590
应该有它的整数是
给它，或字符串？

1852
01:23:23,590 --> 01:23:25,780
这一切都在寻找
做的是检查，

1853
01:23:25,780 --> 01:23:29,303
你给我
正确的说法。

1854
01:23:29,303 --> 01:23:31,560
好不好？

1855
01:23:31,560 --> 01:23:32,300
好吧。

1856
01:23:32,300 --> 01:23:38,570
>> 让我离开你
另外一个位来看待。

1857
01:23:38,570 --> 01:23:44,850
ASCII艺术不是伟大的榜样
动画，因为它是今天。

1858
01:23:44,850 --> 01:23:50,850
但是，当然，也有人拿东西
他们推到自己的极限。

1859
01:23:50,850 --> 01:23:56,790
>> 这是，正如大卫展示
在讲座中，一段代码

1860
01:23:56,790 --> 01:24:02,150
你应该在任何情况下
尝试复制自己。

1861
01:24:02,150 --> 01:24:05,260
因为它是可怕的文体。

1862
01:24:05,260 --> 01:24:11,180
事实上，它的设计是为
困难的，因为可以读取。

1863
01:24:11,180 --> 01:24:11,680
行。

1864
01:24:11,680 --> 01:24:16,210
>> 所以，再一次做，让我们放大在了这里。

1865
01:24:16,210 --> 01:24:20,120
我现在要去走，更改目录。

1866
01:24:20,120 --> 01:24:24,050
我要转到上一级
的水平，回到我的工作区。

1867
01:24:24,050 --> 01:24:29,760
然后，我会改变目录到这个
我已经创建了其他目录。

1868
01:24:29,760 --> 01:24:36,190
>> 这是国际
混淆C程序设计大赛。

1869
01:24:36,190 --> 01:24:40,650
混淆手段硬
如可以理解。

1870
01:24:40,650 --> 01:24:44,150
所以，请不要如果你吓到
在这去，我无法读取。

1871
01:24:44,150 --> 01:24:46,350
这是它的点。

1872
01:24:46,350 --> 01:24:47,700
好不好？

1873
01:24:47,700 --> 01:24:52,770
>> 但是，我们有这个
精彩的节目，我是

1874
01:24:52,770 --> 01:24:57,180
将只需键入更多的关注一下。

1875
01:24:57,180 --> 01:25:01,890
让我们来看看，如果我能缩小
只是有点，所以你可以看到它

1876
01:25:01,890 --> 01:25:03,940
>> 这就是该程序。

1877
01:25:03,940 --> 01:25:08,080
它的命名endo.c.

1878
01:25:08,080 --> 01:25:14,850
它看起来像这样桶
一种字母F-L-U-I-D在里面的。

1879
01:25:14,850 --> 01:25:16,440
>> 这其实是一个程序。

1880
01:25:16,440 --> 01:25:20,260
这是写在最不起眼的
这样，作者可能可能

1881
01:25:20,260 --> 01:25:21,760
写下来。

1882
01:25:21,760 --> 01:25:29,210
但它是一个奇妙的小片的
产生流体动力学模型。

1883
01:25:29,210 --> 01:25:34,870
>> 因此，我们打算给
这种模式的输入端，

1884
01:25:34,870 --> 01:25:42,520
看起来的这样，
staired集集装箱

1885
01:25:42,520 --> 01:25:45,820
一些液体，一些
液，在顶部。

1886
01:25:45,820 --> 01:25:48,790
我们将有它模拟
发生了什么吧。

1887
01:25:48,790 --> 01:25:52,415
>> 所以，我会调用该函数，内。

1888
01:25:52,415 --> 01:25:59,000
而我给它的
，我已经有输入文件。

1889
01:25:59,000 --> 01:26:02,830
还有就是我们的ASCII艺术的缩影。

1890
01:26:02,830 --> 01:26:08,960
一个完整的流体动力学模拟
在代码只有几行运行。

1891
01:26:08,960 --> 01:26:13,750
>> 现在，什么是居然真的
令人惊奇这个小程序

1892
01:26:13,750 --> 01:26:17,280
是，我现在要停止它，
所以我打算用什么命令？

1893
01:26:17,280 --> 01:26:18,660
>> 听众：控制-C。

1894
01:26:18,660 --> 01:26:20,390
>> BRIAN SCASSELLATI：控制-C。行。

1895
01:26:20,390 --> 01:26:22,960
因此，我将使用Ctrl-C组合。
C，它会停止它。

1896
01:26:22,960 --> 01:26:25,330
我会再次清除。

1897
01:26:25,330 --> 01:26:31,210
而现在我要调用
程序，执行程序，

1898
01:26:31,210 --> 01:26:33,740
使用本身作为输入。

1899
01:26:33,740 --> 01:26:36,760

1900
01:26:36,760 --> 01:26:42,700
>> 我们将看到流体动力
模拟它融化。

1901
01:26:42,700 --> 01:26:43,830
行。

1902
01:26:43,830 --> 01:26:48,180
请不要让该程序
是因为混淆了你的东西。

1903
01:26:48,180 --> 01:26:52,220
这只是这样我们就可以结束
一些冷静和有趣。

1904
01:26:52,220 --> 01:26:53,930
行。

1905
01:26:53,930 --> 01:26:56,330
>> 祝您好运与你的习题集。

1906
01:26:56,330 --> 01:26:59,030
我们很乐意回答
课后问题。

1907
01:26:59,030 --> 01:27:01,180
谢谢了，伙计们。

1908
01:27:01,180 --> 01:27:02,793