1
00:00:00,000 --> 00:00:05,410

2
00:00:05,410 --> 00:00:07,640
>> DOUG LLOYD：好吧，所以
让我们来谈谈循环。

3
00:00:07,640 --> 00:00:10,015
因此，循环是一种很酷
因为它们可以让你的程序

4
00:00:10,015 --> 00:00:12,050
要执行的代码行
一遍又一遍又一遍。

5
00:00:12,050 --> 00:00:15,600
反复，而不需要复制
和粘贴或以其他方式重复。

6
00:00:15,600 --> 00:00:17,630
有三个主要
种类的循环，你会看到的。

7
00:00:17,630 --> 00:00:21,010
你可能有机会使用
每一个你通过CS50进步。

8
00:00:21,010 --> 00:00:22,940
其中一些循环是相当
熟悉你从头开始，

9
00:00:22,940 --> 00:00:25,814
如此反复，当我们用条件语句一样，
我们把他们并排

10
00:00:25,814 --> 00:00:28,930
如果有一个比喻，我们可以借鉴。

11
00:00:28,930 --> 00:00:33,600
>> 首先是永远的从无到有，
与之相比，而（真）。

12
00:00:33,600 --> 00:00:35,390
这就是我们所说的无限循环。

13
00:00:35,390 --> 00:00:38,560
代码卷曲之间的界线
牙套，就像拼图

14
00:00:38,560 --> 00:00:41,190
那放不下的C
永远阻断，

15
00:00:41,190 --> 00:00:45,290
将从顶部反复执行
到下，一遍又一遍又一遍，

16
00:00:45,290 --> 00:00:46,085
永远。

17
00:00:46,085 --> 00:00:48,710
毕竟，如果你还记得我们的
布尔表达式的讨论，

18
00:00:48,710 --> 00:00:51,060
真正的总是正确的。

19
00:00:51,060 --> 00:00:53,250
因此，如果我们正在做
东西只要真

20
00:00:53,250 --> 00:00:58,227
是true--似乎有点silly--真
永远是真实的，所以它会始终运行。

21
00:00:58,227 --> 00:01:00,060
它会永远运行和
永永远远，直到我们

22
00:01:00,060 --> 00:01:02,900
找到一种方法来摆脱它
break语句，这再次，

23
00:01:02,900 --> 00:01:06,350
我们看到前一阵我们
谈论开关。

24
00:01:06,350 --> 00:01:08,725
>> 或只是杀死我们
节目，顺便说一句，

25
00:01:08,725 --> 00:01:11,110
如果你发现自己在一个
有一个无限循环的情况

26
00:01:11,110 --> 00:01:13,484
你不知道如何停止
你的程序运行。

27
00:01:13,484 --> 00:01:16,527
只要按下控制和C
这会杀了你的计划，你。

28
00:01:16,527 --> 00:01:18,360
但是，这又是
所谓无限循环。

29
00:01:18,360 --> 00:01:19,818
它是一个将永远运行一个循环。

30
00:01:19,818 --> 00:01:22,570

31
00:01:22,570 --> 00:01:25,610
现在，while循环不
总是无限的，因为还

32
00:01:25,610 --> 00:01:27,880
我们可以代替布尔
的东西表达

33
00:01:27,880 --> 00:01:29,867
比多一点有用的只是真实的。

34
00:01:29,867 --> 00:01:30,950
因此，这里是另一个例子。

35
00:01:30,950 --> 00:01:34,600
虽然有些布尔
表达式，然后大括号。

36
00:01:34,600 --> 00:01:38,310
这几乎是类似的
重复，直到从头开始。

37
00:01:38,310 --> 00:01:40,700
虽然在第二，我会
解释这种差异。

38
00:01:40,700 --> 00:01:44,310
>> 因此，在C，如果布尔表达式
while循环内

39
00:01:44,310 --> 00:01:47,980
计算结果为真，行
大括号之间的代码

40
00:01:47,980 --> 00:01:51,900
会一遍又一遍地重复执行
又一遍，直到布尔表达式

41
00:01:51,900 --> 00:01:55,174
计算结果为false。

42
00:01:55,174 --> 00:01:57,340
因此，例如，你可能
有某种形式的计数器。

43
00:01:57,340 --> 00:02:01,440
所以说，你在开始
这个循环说INT x等于为零。

44
00:02:01,440 --> 00:02:06,370
当x小于100，做一对夫妇
里面那个大括号的事情，

45
00:02:06,370 --> 00:02:10,570
然后在循环结束时，你说
X加再加，你递增x。

46
00:02:10,570 --> 00:02:13,360
最终x将得到
100，你会

47
00:02:13,360 --> 00:02:15,760
停止，因为条件
x小于100

48
00:02:15,760 --> 00:02:19,416
将不再是真实的作为
一旦x等于100。

49
00:02:19,416 --> 00:02:21,820
100是不小于100。

50
00:02:21,820 --> 00:02:25,870
>> 现在有点混乱，行为
划痕块的反转。

51
00:02:25,870 --> 00:02:29,110
所以要非常小心，如果这是
您的第一个进军使用循环。

52
00:02:29,110 --> 00:02:33,630
基本上，重复
直到块划痕

53
00:02:33,630 --> 00:02:35,970
将重复的东西
一遍又一遍又一遍，

54
00:02:35,970 --> 00:02:40,460
直到表达，布尔
在六边形表达式为true。

55
00:02:40,460 --> 00:02:43,860
因此，它会继续做
它，直到它是真实的。

56
00:02:43,860 --> 00:02:48,881
同时，while循环
继续做它，直到它是假的。

57
00:02:48,881 --> 00:02:51,630
所以他们是非常相似的，但
有那么一点区别只是

58
00:02:51,630 --> 00:02:55,140
要特别为您做出谨慎
你从过渡首次尝试

59
00:02:55,140 --> 00:02:58,149
刮成C。

60
00:02:58,149 --> 00:03:00,190
接下来的循环方式是
其实很相似。

61
00:03:00,190 --> 00:03:02,860
这就是所谓的do while循环。

62
00:03:02,860 --> 00:03:07,060
这个循环将执行所有的行
曾经的大括号之间的代码，

63
00:03:07,060 --> 00:03:09,530
然后它会检查
布尔表达式。

64
00:03:09,530 --> 00:03:11,700
如果布尔表达式
计算结果为true，

65
00:03:11,700 --> 00:03:14,340
它会回去重复
这一过程一遍又一遍

66
00:03:14,340 --> 00:03:17,690
又一遍，直到布尔
表达式的值为false。

67
00:03:17,690 --> 00:03:23,370
所以这个循环，不像while循环，是
保证运行的至少一个时间。

68
00:03:23,370 --> 00:03:26,080
这可能是非常有用的。

69
00:03:26,080 --> 00:03:28,011
>> 最后，我们有一个for循环。

70
00:03:28,011 --> 00:03:30,010
For循环是一种
语法上没有吸引力

71
00:03:30,010 --> 00:03:32,330
这里面的很多事情
在这里，所以我承担

72
00:03:32,330 --> 00:03:34,640
当我们尝试和突破这些作品分开。

73
00:03:34,640 --> 00:03:36,810
通常，用例
for循环是你

74
00:03:36,810 --> 00:03:40,136
要重复东西
的时间的特定次数。

75
00:03:40,136 --> 00:03:42,010
在这里本实施例中，
我有重复块

76
00:03:42,010 --> 00:03:44,010
从无到有，这是
类似于for循环

77
00:03:44,010 --> 00:03:47,340
在C，重复的东西10倍。

78
00:03:47,340 --> 00:03:49,250
而for循环的
左边有，这

79
00:03:49,250 --> 00:03:51,410
是一个四循环
会做同样的事情。

80
00:03:51,410 --> 00:03:52,570
这将去10次。

81
00:03:52,570 --> 00:03:56,720
从零算起，我们
递增循环的每个通行证。

82
00:03:56,720 --> 00:03:59,220
我们继续这样做，
直到i小于10。

83
00:03:59,220 --> 00:04:00,134
>> 所以会发生什么？

84
00:04:00,134 --> 00:04:01,550
有一大堆的代码中有。

85
00:04:01,550 --> 00:04:03,424
让我们打破它
发生了什么步骤

86
00:04:03,424 --> 00:04:05,684
一步，因为我们通过一个挖掘循环。

87
00:04:05,684 --> 00:04:08,350
发生的第一件事是
计数器变量为中心。

88
00:04:08,350 --> 00:04:11,970
一切到第一左侧
分号括号内

89
00:04:11,970 --> 00:04:12,970
被执行。

90
00:04:12,970 --> 00:04:15,180
在这种情况下，我们
他说INT I等于0。

91
00:04:15,180 --> 00:04:18,709
声明一个叫我新的变量，
该变量是一个整数类型

92
00:04:18,709 --> 00:04:22,570
和我们说里面的值
该变量将是零。

93
00:04:22,570 --> 00:04:25,480
>> 我们做的第二件事是
我们然后立即评估

94
00:04:25,480 --> 00:04:26,750
布尔表达式。

95
00:04:26,750 --> 00:04:30,100
布尔表达式是在
中间的两个分号。

96
00:04:30,100 --> 00:04:31,360
余小于10。

97
00:04:31,360 --> 00:04:32,410
这是真的在这里，对不对？

98
00:04:32,410 --> 00:04:36,030
我们只是说，我等于
零，所以0小于10，

99
00:04:36,030 --> 00:04:38,040
并使得条件
是真实的，现在我们将

100
00:04:38,040 --> 00:04:40,640
继续执行该循环体。

101
00:04:40,640 --> 00:04:41,480
如果是假的。

102
00:04:41,480 --> 00:04:46,380
如果，例如，我说，而不是
我等于0那里，我说我等于15，

103
00:04:46,380 --> 00:04:47,820
INT I等于15。

104
00:04:47,820 --> 00:04:51,450
阱15不小于10，所以我们
会不会进入循环体

105
00:04:51,450 --> 00:04:55,450
因为布尔表达式
将有评价是假的。

106
00:04:55,450 --> 00:04:59,060
>> 之后我们通过自上而下，
我们遇到右大括号，

107
00:04:59,060 --> 00:05:00,830
第三个事情发生。

108
00:05:00,830 --> 00:05:03,840
计数器变量
递增，或者说，该线

109
00:05:03,840 --> 00:05:07,790
的语句代码之后
的内侧第二分号

110
00:05:07,790 --> 00:05:10,500
for循环的括号被执行。

111
00:05:10,500 --> 00:05:13,250
因此，我们开始通过
他说INT I等于0。

112
00:05:13,250 --> 00:05:15,770
然后我们检查是否不
布尔表达式为true。

113
00:05:15,770 --> 00:05:17,469
0小于10所以这是真的。

114
00:05:17,469 --> 00:05:19,510
因此，我们将继续
入体循环。

115
00:05:19,510 --> 00:05:22,676
事情会发生在循环里面，
当我们遇到右大

116
00:05:22,676 --> 00:05:25,660
梅开二度，接下来的事情我们
做的是我们说我加分，加分。

117
00:05:25,660 --> 00:05:28,860
我是零，现在我是其中之一。

118
00:05:28,860 --> 00:05:33,100
然后，我们再检查的价值
布尔表达式在中间。

119
00:05:33,100 --> 00:05:34,900
一小于10。

120
00:05:34,900 --> 00:05:38,325
因此，我们将通过这种
一次又一次的处理。

121
00:05:38,325 --> 00:05:40,590
我们会得到闭幕
大括号了。

122
00:05:40,590 --> 00:05:44,090
我们会增加我的
1至2，从2至3。

123
00:05:44,090 --> 00:05:48,290
等等等等等等，直到
最后，我的价值变成10。

124
00:05:48,290 --> 00:05:49,950
比10小10？

125
00:05:49,950 --> 00:05:51,200
第

126
00:05:51,200 --> 00:05:53,800
从0开始计数，我们已经走了
经过10次迭代循环。

127
00:05:53,800 --> 00:05:57,204
我们已经重复10次，只是
就像我们在划痕块。

128
00:05:57,204 --> 00:05:59,370
所以这基本上是
过程中产生的四环路。

129
00:05:59,370 --> 00:06:01,630
>> 现在收走了
实际的代码，并把它

130
00:06:01,630 --> 00:06:05,120
在短短的一些基本的一般性发言。

131
00:06:05,120 --> 00:06:06,550
这里会发生什么。

132
00:06:06,550 --> 00:06:09,290
所有的发言
先开始执行。

133
00:06:09,290 --> 00:06:11,260
你可能有不止一个。

134
00:06:11,260 --> 00:06:13,440
然后，布尔表达式进行检查。

135
00:06:13,440 --> 00:06:17,850
如果表达式的值为true，
执行主体的循环一次。

136
00:06:17,850 --> 00:06:21,060
如果表达式的计算
为假，我们就大功告成了。

137
00:06:21,060 --> 00:06:23,040
我们不执行
体循环可言。

138
00:06:23,040 --> 00:06:25,530
我们已经执行后，
体循环一次，

139
00:06:25,530 --> 00:06:29,487
然后，我们做的是什么
增量部分出现。

140
00:06:29,487 --> 00:06:31,820
这通常将是
像我加分，加

141
00:06:31,820 --> 00:06:34,510
或者类似的东西，那
修改计数器变量。

142
00:06:34,510 --> 00:06:37,390
然后，当我们增加，我们
再次检查表达

143
00:06:37,390 --> 00:06:41,120
并且一遍又一遍地重复这些步骤
又一遍，直到表达式

144
00:06:41,120 --> 00:06:42,890
不再是真实的。

145
00:06:42,890 --> 00:06:44,469
>> 那么，什么是用例为一个循环？

146
00:06:44,469 --> 00:06:46,760
使用您使用whil​​e循环时，
你想有一个循环重复

147
00:06:46,760 --> 00:06:51,200
一个未知的次数，但
它可能可能无法运行所有。

148
00:06:51,200 --> 00:06:53,940
一个真正常见的例子
正在使用，而循环

149
00:06:53,940 --> 00:06:56,480
是运行一个游戏的控制流程。

150
00:06:56,480 --> 00:06:59,040
你可能不知道多久
用户将被播放，

151
00:06:59,040 --> 00:07:01,440
但你要保持
做同样的事情。

152
00:07:01,440 --> 00:07:04,970
更新的位置
各种精灵在黑板上。

153
00:07:04,970 --> 00:07:07,490
你要保持事物
在任何时候移动，

154
00:07:07,490 --> 00:07:09,110
但你不知道什么时候
用户要停止播放

155
00:07:09,110 --> 00:07:10,450
或者当他们要去
用完的生命。

156
00:07:10,450 --> 00:07:12,741
因此，while循环是真的
良好的类似的东西。

157
00:07:12,741 --> 00:07:14,130
这是一个很好的用例。

158
00:07:14,130 --> 00:07:16,230
>> 对于一个do while循环，
这是非常相似的。

159
00:07:16,230 --> 00:07:19,746
你想要一个循环重复未知
次数，但至少一次。

160
00:07:19,746 --> 00:07:22,370
您可以使用它来游戏
太多，但一个真正的常见用例

161
00:07:22,370 --> 00:07:24,420
是提示用户输入。

162
00:07:24,420 --> 00:07:28,609
通常情况下，你可能会说些什么
喜欢，给我一个正整数，

163
00:07:28,609 --> 00:07:30,650
你可能把那个
里面的do while循环。

164
00:07:30,650 --> 00:07:33,900
因此，它总是会问他们在
至少一次为一个正整数。

165
00:07:33,900 --> 00:07:36,850
如果他们给你一个正整数，
你可能会打破循环。

166
00:07:36,850 --> 00:07:37,599
你可能会做。

167
00:07:37,599 --> 00:07:39,900
布尔表达式
在做，而可能是假的。

168
00:07:39,900 --> 00:07:41,137
>> 你会不会再问问他们。

169
00:07:41,137 --> 00:07:44,470
如果他们给你一个负数，其中
他们键入一些文字或东西是

170
00:07:44,470 --> 00:07:46,630
不是真的有用
你，你可能会使用

171
00:07:46,630 --> 00:07:49,770
do while循环回去做
一遍又一遍。

172
00:07:49,770 --> 00:07:52,410
你肯定要问
他们给你一个数字一次，

173
00:07:52,410 --> 00:07:56,350
但你不知道多少倍
在那之后他们可能是害虫。

174
00:07:56,350 --> 00:08:00,540
所以，一个做，而这是一个伟大的使用
情况下，用于提示用户输入。

175
00:08:00,540 --> 00:08:03,060
而一个for循环使用
通常情况是，当

176
00:08:03,060 --> 00:08:06,230
要重复循环
离散的次数，

177
00:08:06,230 --> 00:08:08,230
虽然你可能不
知道的次数

178
00:08:08,230 --> 00:08:10,040
此刻程序编译。

179
00:08:10,040 --> 00:08:15,510
>> 因此，例如，也许你有一个程序
在那里你提示输入数字的用户。

180
00:08:15,510 --> 00:08:17,660
他们进入100。

181
00:08:17,660 --> 00:08:20,510
然后，你的循环将
在这种情况下，运行100次。

182
00:08:20,510 --> 00:08:22,480
或者，也许他们进入
1000在你的程序

183
00:08:22,480 --> 00:08:24,570
然后运行循环1000次。

184
00:08:24,570 --> 00:08:26,987
它的特定次数。

185
00:08:26,987 --> 00:08:28,820
他们不一定
知道这是什么号码

186
00:08:28,820 --> 00:08:31,010
是编译时刻程序。

187
00:08:31,010 --> 00:08:35,010
它不象while循环
它可能是无限的。

188
00:08:35,010 --> 00:08:37,127
这是相当一些
你只是不知道。

189
00:08:37,127 --> 00:08:39,210
现在，即使我
列出所有这些用例，

190
00:08:39,210 --> 00:08:41,501
你应该知道，在相当
每很多情况下，

191
00:08:41,501 --> 00:08:44,110
你可以交换所有
这三个循环。

192
00:08:44,110 --> 00:08:46,890
您可以使用一个for循环，你
否则将使用whil​​e循环。

193
00:08:46,890 --> 00:08:49,860
您可以使用一个for循环的地方
你会使用一个do while循环等。

194
00:08:49,860 --> 00:08:53,680
它可以是一个有点棘手，有时，
所以一般这是一个很好的做法

195
00:08:53,680 --> 00:08:55,140
坚持一个典型的用例。

196
00:08:55,140 --> 00:08:57,599
使用do while循环，如果你
想要的东西一次，至少。

197
00:08:57,599 --> 00:09:00,514
如果你想要做的使用for循环
东西的特定次数。

198
00:09:00,514 --> 00:09:03,730
毕竟，这就是为什么有
三种不同类型的循环。

199
00:09:03,730 --> 00:09:06,172
>> 因此，他们可以使用
在正确的范围内。

200
00:09:06,172 --> 00:09:07,880
但是你可以互换
他们，如果你想要的。

201
00:09:07,880 --> 00:09:10,790
如果你觉得舒服，而循环
而你总是想使用whil​​e循环。

202
00:09:10,790 --> 00:09:12,623
这是一些
你可以这样做，但它

203
00:09:12,623 --> 00:09:15,590
可能有点语法
棘手的，其中一个for循环

204
00:09:15,590 --> 00:09:17,850
将是一个简单得多。

205
00:09:17,850 --> 00:09:21,100
>> 我的名字是道格·劳埃德，这是CS50。

206
00:09:21,100 --> 00:09:22,688