1
00:00:00,000 --> 00:00:07,170

2
00:00:07,170 --> 00:00:09,100
>> LUCAS FREITAS：好吧，我猜
现在我们的现场。

3
00:00:09,100 --> 00:00:11,220
欢迎来到CS50 Supersection。

4
00:00:11,220 --> 00:00:12,880
我们是不太舒服。

5
00:00:12,880 --> 00:00:13,870
我的名字是卢卡斯塔斯。

6
00:00:13,870 --> 00:00:16,230
我算是CS50头转录因子。

7
00:00:16,230 --> 00:00:17,523
这是劳伦。

8
00:00:17,523 --> 00:00:19,002
>> LAUREN卡瓦略：嗨，我是劳伦。

9
00:00:19,002 --> 00:00:21,330
我也头TF的CS50。

10
00:00:21,330 --> 00:00:24,730
>> LUCAS FREITAS：今天我们只是
让公众知道你的概述

11
00:00:24,730 --> 00:00:28,440
家伙已经学会了在一个星期内，有希望
给你们一个好

12
00:00:28,440 --> 00:00:32,580
意义是什么你应该知道
对于问题集之一。

13
00:00:32,580 --> 00:00:34,120
>> 只是一对夫妇的公告。

14
00:00:34,120 --> 00:00:36,490
首先，办公时间。

15
00:00:36,490 --> 00:00:41,580
办公时间是从周一发生
周四在不同的房子

16
00:00:41,580 --> 00:00:43,450
嫩伯格的每一天。

17
00:00:43,450 --> 00:00:46,680
他们是为你一个非常好的资源
人来问问题，

18
00:00:46,680 --> 00:00:49,470
聊到TFS，甚至交换
想法与其他同学。

19
00:00:49,470 --> 00:00:55,420
所以一定要使用该资源
对你有利。

20
00:00:55,420 --> 00:00:59,790
>> 第二件事是
CS50电器。

21
00:00:59,790 --> 00:01:01,390
在过去的[听不清]

22
00:01:01,390 --> 00:01:04,180
你们没有真正
有一个设备。

23
00:01:04,180 --> 00:01:06,910
你只是在做的一切
你的个人电脑。

24
00:01:06,910 --> 00:01:10,330
但对于这个问题，你实际上有
有一个虚拟机，因此

25
00:01:10,330 --> 00:01:14,680
一定要下载CS50
电器和设置它。

26
00:01:14,680 --> 00:01:18,670
>> 而第三件事是一定要
启动设置问题尽快公正

27
00:01:18,670 --> 00:01:22,740
因为它更容易找到
帮助时，你在

28
00:01:22,740 --> 00:01:23,730
开始的一周。

29
00:01:23,730 --> 00:01:27,540
因为人们往往要等到
最后一秒启动问题集，

30
00:01:27,540 --> 00:01:29,730
然后你去办公时间，
而且也有很多人。

31
00:01:29,730 --> 00:01:33,020
在那里，如果你去周一，你会
一看就知道你可以倾诉的转录因子

32
00:01:33,020 --> 00:01:35,870
几乎整个晚上，
他们打算超过

33
00:01:35,870 --> 00:01:37,790
竭诚为您服务。

34
00:01:37,790 --> 00:01:40,720
>> LAUREN卡瓦略：我可以只是停止
您只需一秒？

35
00:01:40,720 --> 00:01:43,330
人人都能够下载
在CS50电器？

36
00:01:43,330 --> 00:01:44,255
人们已经尝试过？

37
00:01:44,255 --> 00:01:47,120
>> LUCAS FREITAS：要下载，由
这样，就可以在得到指令

38
00:01:47,120 --> 00:01:48,045
cs50.net/appliance。

39
00:01:48,045 --> 00:01:48,817
>> LAUREN卡瓦略：对。

40
00:01:48,817 --> 00:01:53,120
而它确实需要一些时间，我们的
系统管理员以获得您的许可

41
00:01:53,120 --> 00:01:55,450
键，所以报名参加
免费试用第一。

42
00:01:55,450 --> 00:01:59,080
这样，你将拥有它30天，
然后等待您的许可证密钥

43
00:01:59,080 --> 00:02:02,650
这应该给它
你一年。

44
00:02:02,650 --> 00:02:04,100
>> LUCAS FREITAS：首先，
让我们来谈谈一点点

45
00:02:04,100 --> 00:02:06,180
关于CS50电器。

46
00:02:06,180 --> 00:02:10,770
该CS50设备实际上是一个虚拟的
机器，你要

47
00:02:10,770 --> 00:02:15,040
在你自己的电脑是运行
基本上运行另一台电脑

48
00:02:15,040 --> 00:02:16,010
在你自己的电脑。

49
00:02:16,010 --> 00:02:16,800
这是很酷。

50
00:02:16,800 --> 00:02:19,420
而实际上它的使用无处不在。

51
00:02:19,420 --> 00:02:23,150
人谁到高科技的都知道
这是所使用的所有的时间。

52
00:02:23,150 --> 00:02:23,250
你呢？

53
00:02:23,250 --> 00:02:26,200
可以有多个电脑
在一个设备中。

54
00:02:26,200 --> 00:02:27,760
>> 让我们来实际看看
在电器。

55
00:02:27,760 --> 00:02:32,680

56
00:02:32,680 --> 00:02:36,640
当你以后去的电器
注册后，你将不得不

57
00:02:36,640 --> 00:02:42,035
把你的名字和登录哈佛
所以我们可以让你所有注册。

58
00:02:42,035 --> 00:02:46,570
你会看到基本上是一个
壁纸，然后家庭和垃圾桶，

59
00:02:46,570 --> 00:02:48,980
然后这些小图标。

60
00:02:48,980 --> 00:02:51,930
这三个图标实际上是最
您可以在重要的事情

61
00:02:51,930 --> 00:02:53,000
您的设备。

62
00:02:53,000 --> 00:03:00,270
>> 第一个是gedit的，这是一个文本
编辑器，就像记事本或类似

63
00:03:00,270 --> 00:03:01,440
任何类型的文本编辑器。

64
00:03:01,440 --> 00:03:09,750
这是我们用它来写东西只是
代码，然后做的东西吧。

65
00:03:09,750 --> 00:03:11,770
>> 第二件事，我们
这里是Chrome浏览器。

66
00:03:11,770 --> 00:03:13,910
所以，如果你需要使用互联网
在家电，这是

67
00:03:13,910 --> 00:03:15,030
你可以使用的东西。

68
00:03:15,030 --> 00:03:22,000
>> 而第三件事是终端，
这其实是很甜蜜的。

69
00:03:22,000 --> 00:03:26,420
这类人通常都害怕
终端，因为它是这个非常

70
00:03:26,420 --> 00:03:32,320
在老式的应用程序，您
只是基本型与一切

71
00:03:32,320 --> 00:03:32,940
您的键盘。

72
00:03:32,940 --> 00:03:34,730
有没有很多的互动
用你的鼠标。

73
00:03:34,730 --> 00:03:39,780
但实际上终端
确实很不错的东西。

74
00:03:39,780 --> 00:03:43,990
>> 首先，让我们刚刚经历
一些命令，你

75
00:03:43,990 --> 00:03:48,765
可以在终端中使用。

76
00:03:48,765 --> 00:03:51,995
>> LAUREN卡瓦略：而且随时停止
我们，如果您有任何问题。

77
00:03:51,995 --> 00:03:52,830
>> LUCAS FREITAS：是啊。

78
00:03:52,830 --> 00:04:01,950
因此，我们有第一个命令
对于终端是LS。

79
00:04:01,950 --> 00:04:06,450
LS的基本含义列表的一切，都是
文件及全体董事，

80
00:04:06,450 --> 00:04:09,540
那我在，我在这个地方。

81
00:04:09,540 --> 00:04:15,200
所以，如果我在这里做的LS，我要去看看
我有一些目录。

82
00:04:15,200 --> 00:04:18,670
我的桌面上，下载，
日志和虚拟主机。

83
00:04:18,670 --> 00:04:21,260
这些都是蓝色，因为他们
是所有的目录。

84
00:04:21,260 --> 00:04:24,160
>> 那么你有一些其他文件。

85
00:04:24,160 --> 00:04:27,840
你有像打招呼，hello.c中，这
只是文件，而他们在

86
00:04:27,840 --> 00:04:28,910
不同的颜色。

87
00:04:28,910 --> 00:04:33,960
所以这是一个非常重要的命令只是
你可以看到哪些文件

88
00:04:33,960 --> 00:04:37,690
并且您有目录
在该目录中

89
00:04:37,690 --> 00:04:39,410
你在终端正处于。

90
00:04:39,410 --> 00:04:44,580
当你看到jharvard @家电和
接着小符号那里，

91
00:04:44,580 --> 00:04:49,185
波浪，那只是意味着这就是
你是在目前的目录。

92
00:04:49,185 --> 00:04:52,970
>> LAUREN卡瓦略：所以输入ls几乎是
如单击该文件夹

93
00:04:52,970 --> 00:04:57,380
列出在那里，在它表演
你们凡内容

94
00:04:57,380 --> 00:04:58,886
在该文件夹。

95
00:04:58,886 --> 00:05:04,232
>> 观众：是否有文字
在hello.c中呢？

96
00:05:04,232 --> 00:05:10,070
>> LAUREN卡瓦略：哦，你不能
看到，因为它是蓝色的。

97
00:05:10,070 --> 00:05:12,490
>> LUCAS FREITAS：它说
日志和虚拟主机。

98
00:05:12,490 --> 00:05:14,450
>> LAUREN卡瓦略：这些都是
只是其他文件夹。

99
00:05:14,450 --> 00:05:16,890
我很抱歉，这真的很难看到的。

100
00:05:16,890 --> 00:05:19,090
也许如果我们关掉灯？

101
00:05:19,090 --> 00:05:23,002
科尔顿，你想尝试和
找到灯的开关？

102
00:05:23,002 --> 00:05:24,960
我们对此深感抱歉。

103
00:05:24,960 --> 00:05:25,675
我没有去想它。

104
00:05:25,675 --> 00:05:27,340
>> LUCAS FREITAS：但它基本上是 - 

105
00:05:27,340 --> 00:05:30,310
是啊，如果你能 - 

106
00:05:30,310 --> 00:05:32,278
>> LAUREN卡瓦略：放大屏幕。

107
00:05:32,278 --> 00:05:34,738
>> LUCAS FREITAS：我不知道
具有该功能。

108
00:05:34,738 --> 00:05:35,988
>> LAUREN卡瓦略：[听不清]。

109
00:05:35,988 --> 00:05:39,528

110
00:05:39,528 --> 00:05:40,001
确定。

111
00:05:40,001 --> 00:05:44,270
嗯，有只是很多自然
光在这个房间也是如此。

112
00:05:44,270 --> 00:05:48,726
>> LUCAS FREITAS：让我们姑且认为
还有另外两个没有目录。

113
00:05:48,726 --> 00:05:49,780
>> LAUREN卡瓦略：刚才我们一起承担。

114
00:05:49,780 --> 00:05:54,200
这是唯一的一部分，你会
要着眼于终端。

115
00:05:54,200 --> 00:06:00,160
>> LUCAS FREITAS：下一个命令
基本上，也许你想组织

116
00:06:00,160 --> 00:06:01,080
你的文件 - 

117
00:06:01,080 --> 00:06:05,015
例如，所有的在一个C文件
目录，但是你没有一个

118
00:06:05,015 --> 00:06:07,180
只是对于C目录中的文件呢。

119
00:06:07,180 --> 00:06:11,590
你基本上可以创建一个目录
使用终端以及，这是

120
00:06:11,590 --> 00:06:15,670
同样的事情，右击
并说新文件夹。

121
00:06:15,670 --> 00:06:20,640
该命令创建目录，其中
是MKDIR，所以基本上“制造”和

122
00:06:20,640 --> 00:06:21,260
“目录”。

123
00:06:21,260 --> 00:06:22,680
>> 然后你可以把
该目录的名称。

124
00:06:22,680 --> 00:06:32,490
比方说，我想叫，
我不知道，让我们说做PSET1

125
00:06:32,490 --> 00:06:33,900
这一点，我刚刚创建的目录。

126
00:06:33,900 --> 00:06:35,910
让我们只检查它的存在。

127
00:06:35,910 --> 00:06:40,870
所以，如果我做的LS，现在我看日志，
然后PSET1，然后虚拟主机。

128
00:06:40,870 --> 00:06:44,360
所以，我有没有新的目录。

129
00:06:44,360 --> 00:06:46,670
>> 然后经过你有一个新的目录，
也许你想浏览

130
00:06:46,670 --> 00:06:51,760
进去，所以下一个命令这张CD，
这只是基本上意味着去

131
00:06:51,760 --> 00:06:53,400
特定的目录。

132
00:06:53,400 --> 00:06:58,377
所以，如果我想去PSET1，
我可以做CD PSET1。

133
00:06:58,377 --> 00:07:01,550
>> LAUREN卡瓦略：CD代表变更
目录[听不清]能

134
00:07:01,550 --> 00:07:02,230
记住这一点。

135
00:07:02,230 --> 00:07:05,460
>> LUCAS FREITAS：现在你看到，
而不是仅仅有jharvard

136
00:07:05,460 --> 00:07:09,150
家电，我已经jharvard家电，
然后PSET1，因为它示出

137
00:07:09,150 --> 00:07:14,150
我在哪里，我在这台电脑。

138
00:07:14,150 --> 00:07:17,510
>> 现在，如果我想回去
目录是这样的人之前，我

139
00:07:17,510 --> 00:07:22,950
可以做一个CD点点，这只是意味着去
到我之前所在的目录，

140
00:07:22,950 --> 00:07:26,290
像这样的父
目录中，基本上是这样。

141
00:07:26,290 --> 00:07:30,460
现在我看到我
回jharvard。

142
00:07:30,460 --> 00:07:36,050
>> 接下来的事情，我可以做到这一点
为rm，这是删除一个文件。

143
00:07:36,050 --> 00:07:39,590
例如，让我们先做LS
看看我这里有。

144
00:07:39,590 --> 00:07:41,790
我有打招呼，hello.c中。

145
00:07:41,790 --> 00:07:43,780
比方说，我想删除它们。

146
00:07:43,780 --> 00:07:48,280
我能做的RM打招呼。

147
00:07:48,280 --> 00:07:52,770
它会说“删除普通文件
你好？“我说：”是的。“现在，如果我

148
00:07:52,770 --> 00:07:56,410
做LS，我看到它的
不存在了。

149
00:07:56,410 --> 00:07:59,700
>> 如果我尝试使用rm等的目录，
不过，它不会

150
00:07:59,700 --> 00:08:00,800
让你做任何事情。

151
00:08:00,800 --> 00:08:02,960
它会说，哎，你
不能删除一个目录。

152
00:08:02,960 --> 00:08:08,100
因此，我们有这个其他都称为RMDIR，
这只是基本含义

153
00:08:08,100 --> 00:08:09,800
删除目录。

154
00:08:09,800 --> 00:08:12,842
我可以，例如，删除PSET1。

155
00:08:12,842 --> 00:08:15,770
如果我做LS，我不
拥有它了。

156
00:08:15,770 --> 00:08:18,430
>> 这方面有任何问题吗？

157
00:08:18,430 --> 00:08:20,200
没有？

158
00:08:20,200 --> 00:08:20,595
是吗？

159
00:08:20,595 --> 00:08:23,954
>> 观众：你离开是很重要
一个空格之后 - 当你

160
00:08:23,954 --> 00:08:26,540
开始输入的东西？

161
00:08:26,540 --> 00:08:26,830
>> LUCAS FREITAS：是啊。

162
00:08:26,830 --> 00:08:32,080
如果我做喜欢的CD和目录，
我要加一个空格。

163
00:08:32,080 --> 00:08:33,350
什么空间你在说什么？

164
00:08:33,350 --> 00:08:34,979
>> LAUREN卡瓦略：之间的空间
CD和[听不清]。

165
00:08:34,979 --> 00:08:37,710
>> LUCAS FREITAS：是啊，你要
放空间，因为CD是

166
00:08:37,710 --> 00:08:42,770
命令，然后在接下来的字符串
你的类型是基本的目录。

167
00:08:42,770 --> 00:08:45,020
所以它就像一个参数。

168
00:08:45,020 --> 00:08:45,360
是吗？

169
00:08:45,360 --> 00:08:47,952
>> 观众：当你列出，所有这些
在不同的目录，对不对？

170
00:08:47,952 --> 00:08:50,125
>> LUCAS FREITAS：是的，他们
在目录中。

171
00:08:50,125 --> 00:08:53,524
>> 观众：什么是差异
目录中？

172
00:08:53,524 --> 00:08:55,390
>> LUCAS FREITAS：他们只是
不同的文件夹。

173
00:08:55,390 --> 00:08:57,366
目录是一个文件夹
在您的计算机。

174
00:08:57,366 --> 00:08:58,120
>> 观众：打开文件夹。

175
00:08:58,120 --> 00:09:00,140
>> LUCAS FREITAS：是的，这是
刚打开的文件夹。

176
00:09:00,140 --> 00:09:03,400
>> LAUREN卡瓦略：在这里，那些
那是蓝色的是实际的

177
00:09:03,400 --> 00:09:07,107
您可以进入和目录
然后看到一堆东西，是

178
00:09:07,107 --> 00:09:10,248
内，这是不幸
因为你不能真正阅读

179
00:09:10,248 --> 00:09:11,290
那些蓝色。

180
00:09:11,290 --> 00:09:16,166
和那些在白色的只是文件
是当前目录内。

181
00:09:16,166 --> 00:09:17,870
>> LUCAS FREITAS：所以目录
是文件夹。

182
00:09:17,870 --> 00:09:18,810
其他的都是文件。

183
00:09:18,810 --> 00:09:22,810
>> 观众：什么是命令
重设或清除呢？

184
00:09:22,810 --> 00:09:23,650
LUCAS FREITAS：要清除？

185
00:09:23,650 --> 00:09:24,362
LAUREN卡瓦略：要清除？

186
00:09:24,362 --> 00:09:27,985
LUCAS FREITAS：我觉得
这是“清”。是啊。

187
00:09:27,985 --> 00:09:32,370
所以，你只需要输入不清楚
你的屏幕是太乱了。

188
00:09:32,370 --> 00:09:33,700
还有没有其他问题？

189
00:09:33,700 --> 00:09:36,720
你会学到一堆其他的
在命令只是自然的

190
00:09:36,720 --> 00:09:38,405
学期，因为他们是非常有用的。

191
00:09:38,405 --> 00:09:42,380

192
00:09:42,380 --> 00:09:46,155
>> 所以，现在让我们来谈谈编译。

193
00:09:46,155 --> 00:09:51,510

194
00:09:51,510 --> 00:09:54,730
我们谈到伪代码和
源代码和目标代码。

195
00:09:54,730 --> 00:09:59,020
并且有很多代码，也许
你们是困惑的。

196
00:09:59,020 --> 00:10:02,190
让我们说一下什么
当你写一个程序发生，

197
00:10:02,190 --> 00:10:06,620
而你编译它，并成为
一个可执行文件。

198
00:10:06,620 --> 00:10:10,190
这些都是的话，你的家伙
可能听说过，也许你不

199
00:10:10,190 --> 00:10:12,130
真的知道是怎么回事。

200
00:10:12,130 --> 00:10:15,540
>> 比方说，例如，我想
编写一个程序，说：“你好。”该

201
00:10:15,540 --> 00:10:19,670
，在你的头脑的第一件事就是
有种你再想想你是怎样

202
00:10:19,670 --> 00:10:23,000
要做到这一点在你的心中，并
你可能在想用英语或

203
00:10:23,000 --> 00:10:25,550
其他一些语言，如自然
语言，大概。

204
00:10:25,550 --> 00:10:28,770
然后你想，好吧，如果我想，
例如，编写一个程序，

205
00:10:28,770 --> 00:10:32,630
说：“你好，”我会启动一个程序，
我将打印打招呼，然后我会

206
00:10:32,630 --> 00:10:35,270
退出程序。

207
00:10:35,270 --> 00:10:36,350
这是伪代码。

208
00:10:36,350 --> 00:10:41,740
这只是基本上你想
想出的事件序列

209
00:10:41,740 --> 00:10:46,510
你要做的是
能写一个程序。

210
00:10:46,510 --> 00:10:49,610
>> 那么你的源代码，并
源代码不必

211
00:10:49,610 --> 00:10:53,240
特别是C。我们谈论
C语言有关的源代码，因为这是

212
00:10:53,240 --> 00:10:56,760
我们正在学习的语言，但当然
代码可以是几乎任何

213
00:10:56,760 --> 00:10:59,160
你有编程语言。

214
00:10:59,160 --> 00:11:01,230
在学期过去了，你会
学习其他语言。

215
00:11:01,230 --> 00:11:03,230
这也是源代码。

216
00:11:03,230 --> 00:11:07,380
>> 例如，在这里，这是我的源
代码，然后我包括一个

217
00:11:07,380 --> 00:11:10,170
库，然后我开始
主要的，然后我打印。

218
00:11:10,170 --> 00:11:14,510
和劳拉是要谈一点
所有的这一点。

219
00:11:14,510 --> 00:11:16,190
因此，这是源代码。

220
00:11:16,190 --> 00:11:19,590
>> 什么是目标代码？

221
00:11:19,590 --> 00:11:22,500
对象是一堆零
和的，基本上是这样。

222
00:11:22,500 --> 00:11:27,680
什么情况是你一开始有
伪代码，这是全英文的。

223
00:11:27,680 --> 00:11:29,020
我的意思是，你了解它。

224
00:11:29,020 --> 00:11:31,260
可能是你的朋友了解
它，大多数人会

225
00:11:31,260 --> 00:11:32,560
理解的想法。

226
00:11:32,560 --> 00:11:36,770
但电脑是非常愚蠢的，他们
不懂英语，所以你

227
00:11:36,770 --> 00:11:41,320
已翻译的到的东西，
通常译成

228
00:11:41,320 --> 00:11:42,460
编程语言。

229
00:11:42,460 --> 00:11:46,840
>> 和你能想到一个编程
语言那种作为一门语言

230
00:11:46,840 --> 00:11:50,970
那你告诉你的电脑怎么
说话和理解。

231
00:11:50,970 --> 00:11:54,160
你基本上写的东西在
一种语言，你们俩和你

232
00:11:54,160 --> 00:11:55,190
计算机理解。

233
00:11:55,190 --> 00:11:56,470
这是源代码。

234
00:11:56,470 --> 00:12:00,580
那么回事形式的伪代码源
代码，它是由你决定。

235
00:12:00,580 --> 00:12:03,130
它基本上是你做你的方案。

236
00:12:03,130 --> 00:12:06,740
>> 但问题是，
电脑甚至不

237
00:12:06,740 --> 00:12:08,360
了解编程语言。

238
00:12:08,360 --> 00:12:10,320
它不明白
源代码中。

239
00:12:10,320 --> 00:12:12,520
它实际上只是理解
零和一。

240
00:12:12,520 --> 00:12:16,570
因此，我们有这个非常神奇的东西叫做
一个编译器，这基本上是

241
00:12:16,570 --> 00:12:19,755
要得到所谓的源，你
写在你俩的语言

242
00:12:19,755 --> 00:12:25,320
和你的电脑说话，现在你
要改造，在

243
00:12:25,320 --> 00:12:26,270
零和一。

244
00:12:26,270 --> 00:12:30,860
所以基本上什么样的编译器是
它得到的源代码，在这种情况下，C，

245
00:12:30,860 --> 00:12:34,100
它是将它改造成零
和那些在计算机

246
00:12:34,100 --> 00:12:37,440
理解并可以使一个
可执行文件出来。

247
00:12:37,440 --> 00:12:40,900
>> 这是否有道理？

248
00:12:40,900 --> 00:12:45,300
你可以认为编译器作为
一些翻译的是

249
00:12:45,300 --> 00:12:50,280
帮助您讲解到电脑
究竟什么是应该做的。

250
00:12:50,280 --> 00:12:52,310
>> 但我怎么编译。

251
00:12:52,310 --> 00:12:59,680
让我们回到设备，并
让我们说，我做了计划。

252
00:12:59,680 --> 00:13:04,220
首先我要创建一个目录
在这里，我要叫它

253
00:13:04,220 --> 00:13:11,130
“实践”。现在，我要浏览
到该目录，所以CD的做法。

254
00:13:11,130 --> 00:13:13,210
现在，我在里面练习。

255
00:13:13,210 --> 00:13:16,860
>> 现在，我要开始gedit的，
让我怎么做呢？

256
00:13:16,860 --> 00:13:21,920
我可以点击这里，或者我可以只
逐字输入“gedit的，”它是怎么回事

257
00:13:21,920 --> 00:13:24,290
打开我。

258
00:13:24,290 --> 00:13:28,100
>> 现在，我要输入我的程序，所以
正是我写在幻灯片。

259
00:13:28,100 --> 00:13:30,360
我宣布一个图书馆。

260
00:13:30,360 --> 00:13:35,440
我做整型为主，无效。

261
00:13:35,440 --> 00:13:39,180
现在我做的printf，你好。

262
00:13:39,180 --> 00:13:46,530

263
00:13:46,530 --> 00:13:50,170
现在，我要救这一点。

264
00:13:50,170 --> 00:13:53,665
让我把它付诸实践，并
我要调用这个hello.c中。

265
00:13:53,665 --> 00:13:57,710

266
00:13:57,710 --> 00:13:59,590
所以，现在它的保存。

267
00:13:59,590 --> 00:14:03,250
>> 如果我想编译它，其实我
可以在两个不同的地方做。

268
00:14:03,250 --> 00:14:07,090
我可以做一个终端窗口，
所以这个大的，或者您也可以

269
00:14:07,090 --> 00:14:09,860
用gedit，实际上有一个
终端窗口就在这里。

270
00:14:09,860 --> 00:14:17,890
所以，你可以很方便地就去做
你的代码，那么你可以只输入

271
00:14:17,890 --> 00:14:20,670
无论在这里，并尝试编译它。

272
00:14:20,670 --> 00:14:23,450
>> 让我怎么编译的代码？

273
00:14:23,450 --> 00:14:27,495
我们有最简单的方法是使用
作，这是一个函数，它

274
00:14:27,495 --> 00:14:29,590
基本上要
编译你的代码。

275
00:14:29,590 --> 00:14:34,170
你只需要说做招呼，所以
“使”和该程序的名称。

276
00:14:34,170 --> 00:14:35,420
>> 哎呀。

277
00:14:35,420 --> 00:14:38,250

278
00:14:38,250 --> 00:14:39,280
这是尴尬的。

279
00:14:39,280 --> 00:14:41,738
>> LAUREN卡瓦略：你能[听不清]？

280
00:14:41,738 --> 00:14:45,182

281
00:14:45,182 --> 00:14:45,990
>> LUCAS FREITAS：对不起。

282
00:14:45,990 --> 00:14:49,960
我没有把它保存在
正确的目录。

283
00:14:49,960 --> 00:14:52,130
来练习，现在
将其保存为hello.c中。

284
00:14:52,130 --> 00:14:54,750
对不起。

285
00:14:54,750 --> 00:14:56,250
现在它的保存。

286
00:14:56,250 --> 00:14:58,300
>> 我只是做ls和被
确保它在这里。

287
00:14:58,300 --> 00:14:59,460
好了，现在就在这里。

288
00:14:59,460 --> 00:15:05,930
所以，现在如果我这样做让你好，它吐出一个
很多东西，但当时它只是给

289
00:15:05,930 --> 00:15:08,870
我的另一条线的终端，它
也就是说，它是成功的。

290
00:15:08,870 --> 00:15:13,160
现在如果我再这样做了LS，我竟如此
看到此文件为绿色，这是

291
00:15:13,160 --> 00:15:15,470
可执行文件。

292
00:15:15,470 --> 00:15:21,700
>> 然后如果我要运行它，所有的
我所要做的就是点斜线打招呼。

293
00:15:21,700 --> 00:15:25,830
它会跟你打招呼就在这里，所以
这正是我要问它。

294
00:15:25,830 --> 00:15:29,620
>> 有编制的一种方式，
这是使用铛。

295
00:15:29,620 --> 00:15:35,740
铛只是一个编译器，我们有，
和它的更详细一点点

296
00:15:35,740 --> 00:15:36,390
编译它。

297
00:15:36,390 --> 00:15:40,180
但它的作品一样好。

298
00:15:40,180 --> 00:15:46,810
所以，如果我做铛，然后邻，然后
我想给的名字

299
00:15:46,810 --> 00:15:50,400
可执行文件，所以让我们说
“你好。”然后我想要的文件

300
00:15:50,400 --> 00:15:53,460
编译，hello.c中。

301
00:15:53,460 --> 00:15:55,900
它也将进行编译。

302
00:15:55,900 --> 00:15:59,020
和你在这里的文件，
我可以执行它。

303
00:15:59,020 --> 00:16:00,610
所以他们两个人的工作。

304
00:16:00,610 --> 00:16:03,270
>> 这是否有道理？

305
00:16:03,270 --> 00:16:06,020
有问题吗？

306
00:16:06,020 --> 00:16:09,020
>> 观众：你能否放大
在一点点？

307
00:16:09,020 --> 00:16:09,913
>> LUCAS FREITAS：对不起？

308
00:16:09,913 --> 00:16:11,135
>> 观众：放大？

309
00:16:11,135 --> 00:16:13,310
>> LAUREN卡瓦略：我想你
只需命令加。

310
00:16:13,310 --> 00:16:14,295
>> LUCAS FREITAS：命令是什么？

311
00:16:14,295 --> 00:16:16,060
>> LAUREN卡瓦略：命令加。

312
00:16:16,060 --> 00:16:17,000
>> LUCAS FREITAS：号

313
00:16:17,000 --> 00:16:19,350
>> LAUREN卡瓦略：哦，那不是
去上班，因为 - 

314
00:16:19,350 --> 00:16:25,548
这是因为我们设置的分辨率
对于这件事情。

315
00:16:25,548 --> 00:16:27,450
>> LUCAS FREITAS：我不知道
认为我们可以放大。

316
00:16:27,450 --> 00:16:30,852

317
00:16:30,852 --> 00:16:34,130
是啊，我们不能放大。

318
00:16:34,130 --> 00:16:36,200
你有别的问题？

319
00:16:36,200 --> 00:16:36,680
抱歉。

320
00:16:36,680 --> 00:16:39,170
>> 观众：你能重复铛？

321
00:16:39,170 --> 00:16:40,630
>> LUCAS FREITAS：该铛？

322
00:16:40,630 --> 00:16:44,190
铛的是同样的事情化妆，但
不同的是，第一次我要去

323
00:16:44,190 --> 00:16:48,460
写铛，这是命令，
那么我该怎么办-0，所有的，这是

324
00:16:48,460 --> 00:16:51,680
只是我们要什么
后来作为一个标志学习。

325
00:16:51,680 --> 00:16:54,440
所以，只是觉得你总是
必须把邻。

326
00:16:54,440 --> 00:16:58,690
>> 然后首先，你要放
该可执行文件的文件名，

327
00:16:58,690 --> 00:17:00,680
基本上，你是该文件
要创建。

328
00:17:00,680 --> 00:17:06,430
所以我可以说，举例来说，的Hello2和
然后，我要编译的文件，

329
00:17:06,430 --> 00:17:07,800
这是c文件。

330
00:17:07,800 --> 00:17:09,240
所以这是hello.c中。

331
00:17:09,240 --> 00:17:10,871
这是否有道理？

332
00:17:10,871 --> 00:17:12,635
>> 观众：你好是什么？

333
00:17:12,635 --> 00:17:13,076
那是什么？

334
00:17:13,076 --> 00:17:15,960
>> LUCAS FREITAS：HELLO.C。

335
00:17:15,960 --> 00:17:19,849
如果我编译它，而如果
我LS，我也有一个

336
00:17:19,849 --> 00:17:22,010
的Hello2，我只是编译。

337
00:17:22,010 --> 00:17:26,339
如果我尝试运行它，它会
做同样的事情为hello，

338
00:17:26,339 --> 00:17:27,089
只是打印打招呼。

339
00:17:27,089 --> 00:17:31,660
>> 观众：怎么来化妆
你可以穿上后的hello.c？

340
00:17:31,660 --> 00:17:33,880
>> LUCAS FREITAS：在化妆，你
不必把。角

341
00:17:33,880 --> 00:17:36,140
在化妆，你刚才说的
该程序的名称。

342
00:17:36,140 --> 00:17:37,750
你不必说了。角

343
00:17:37,750 --> 00:17:39,020
但对于铛，你应该。

344
00:17:39,020 --> 00:17:44,040
>> 观众：随着铛做的，你也
必须添加[听不清]

345
00:17:44,040 --> 00:17:44,480
>> LAUREN卡瓦略：是啊。

346
00:17:44,480 --> 00:17:46,180
所以，你也有图书馆。

347
00:17:46,180 --> 00:17:51,170
>> LUCAS FREITAS：是啊，这东西
我们打​​算以后使用。

348
00:17:51,170 --> 00:17:54,850
这就是所谓的连接，并且我认为我们
后来去谈论它。

349
00:17:54,850 --> 00:17:55,930
另一个问题？

350
00:17:55,930 --> 00:17:59,927
>> 观众：你放
点斜线铛？

351
00:17:59,927 --> 00:18:01,060
>> LUCAS FREITAS：号

352
00:18:01,060 --> 00:18:06,040
点斜线只是开
可执行文件。

353
00:18:06,040 --> 00:18:09,440
所以，铛，你只写“铛”，并
那么，如果你想打开

354
00:18:09,440 --> 00:18:12,640
可执行文件，你只是
编译，那么你就点

355
00:18:12,640 --> 00:18:13,780
削减而得名。

356
00:18:13,780 --> 00:18:15,100
这是否有道理？

357
00:18:15,100 --> 00:18:18,635

358
00:18:18,635 --> 00:18:22,435
>> 观众：如果你只是改变
[听不清]为Hello World，你

359
00:18:22,435 --> 00:18:23,870
必须重新编译它？

360
00:18:23,870 --> 00:18:24,750
>> LUCAS FREITAS：是啊。

361
00:18:24,750 --> 00:18:36,650
如果我想要说，例如，“你好
在那里，“我可以只保存了，我

362
00:18:36,650 --> 00:18:38,020
只是重新编译它。

363
00:18:38,020 --> 00:18:41,910
因此，让我做一个make打招呼。

364
00:18:41,910 --> 00:18:48,490
如果我做你好，这将
说“你好”。有道理？

365
00:18:48,490 --> 00:18:50,280
还有没有其他问题？

366
00:18:50,280 --> 00:18:54,384
>> 观众：你一定要包括
标准I / O的协调工作？

367
00:18:54,384 --> 00:18:55,480
>> LUCAS FREITAS：是啊。

368
00:18:55,480 --> 00:18:58,050
标准I / O的基本
具有一个库

369
00:18:58,050 --> 00:19:00,050
实现printf的。

370
00:19:00,050 --> 00:19:03,450

371
00:19:03,450 --> 00:19:06,910
所以，在那件事权利
顶部包括标准输入输出。

372
00:19:06,910 --> 00:19:11,920
这是包括一个库，
基本上有一堆不同

373
00:19:11,920 --> 00:19:13,260
工具，你可以使用。

374
00:19:13,260 --> 00:19:13,480
呢？

375
00:19:13,480 --> 00:19:17,820
其中printf的是那是一个函数
基本上版画

376
00:19:17,820 --> 00:19:21,290
消息到屏幕上。

377
00:19:21,290 --> 00:19:23,200
>> 还有没有其他问题？

378
00:19:23,200 --> 00:19:24,700
没有？

379
00:19:24,700 --> 00:19:25,060
确定。

380
00:19:25,060 --> 00:19:31,620
所以，现在让我们来谈谈 - 

381
00:19:31,620 --> 00:19:33,948
>> LAUREN卡瓦略：我们只是
去的风格指南。

382
00:19:33,948 --> 00:19:35,896
你想只找到它在这里？

383
00:19:35,896 --> 00:19:37,880
>> LUCAS FREITAS：所以我们要
谈风格。

384
00:19:37,880 --> 00:19:47,006

385
00:19:47,006 --> 00:19:50,430
>> LAUREN卡瓦略：哦，大卫
没有完成。

386
00:19:50,430 --> 00:19:51,230
确定。

387
00:19:51,230 --> 00:19:53,870
我们为什么不回来
风格在最后？

388
00:19:53,870 --> 00:19:56,220
它实际上已更新
因为我们说话。

389
00:19:56,220 --> 00:19:56,810
>> LUCAS FREITAS：是啊。

390
00:19:56,810 --> 00:19:58,300
让我们的方式为大卫完成了。

391
00:19:58,300 --> 00:20:07,150

392
00:20:07,150 --> 00:20:08,600
>> LAUREN卡瓦略：能
我们改用什么呢？

393
00:20:08,600 --> 00:20:14,920

394
00:20:14,920 --> 00:20:17,200
>> 所以我希望每个人都对
享受划痕。

395
00:20:17,200 --> 00:20:21,950
不幸的是，它的时间
远离本 - 

396
00:20:21,950 --> 00:20:25,280
不幸的是它的时间离开
从这些漂亮的编程块

397
00:20:25,280 --> 00:20:28,530
到C。但幸运的是，所有的
编程构造，你已经

398
00:20:28,530 --> 00:20:32,370
在划痕一直与有
直接翻译到C，和我们

399
00:20:32,370 --> 00:20:35,130
要开始学习
他们中的一些现在。

400
00:20:35,130 --> 00:20:39,200
让我们谈条件先说说
在布尔表达式。

401
00:20:39,200 --> 00:20:41,944
>> 这是在运行储备
电池电量。

402
00:20:41,944 --> 00:20:43,912
>> LUCAS FREITAS：如何是
那不工作？

403
00:20:43,912 --> 00:20:47,850

404
00:20:47,850 --> 00:20:48,010
确定。

405
00:20:48,010 --> 00:20:50,256
你去那里，我会得到 - 

406
00:20:50,256 --> 00:20:53,700

407
00:20:53,700 --> 00:20:57,390
>> LAUREN卡瓦略：所以条件
重要的，因为它们使我们能够

408
00:20:57,390 --> 00:21:00,588
逻辑引入到我们的节目。

409
00:21:00,588 --> 00:21:04,620
这里有一个条件的例子
在一个C程序。

410
00:21:04,620 --> 00:21:06,130
让我们注意如何 - 

411
00:21:06,130 --> 00:21:11,324
所以这种情况下块就在这里，这
printf语句将不会执行

412
00:21:11,324 --> 00:21:14,860
除非内的条件
括号中，n大于0，则

413
00:21:14,860 --> 00:21:16,800
计算结果为true。

414
00:21:16,800 --> 00:21:20,780
>> 现在，所有的F内的条件
语句是布尔表达式，

415
00:21:20,780 --> 00:21:22,970
这意味着有
只有两个选项。

416
00:21:22,970 --> 00:21:26,856
他们既可以评估为true，
或者他们可以评估为false。

417
00:21:26,856 --> 00:21:33,174
所以在这里，所以这是有道理的，对不对？ Ñ
大于0时，意味着它是一个正

418
00:21:33,174 --> 00:21:41,160
数，这意味着它将打印
出“你选择了一个正数。”

419
00:21:41,160 --> 00:21:44,630
>> 有很多的布尔表达式
能够形成的条件与

420
00:21:44,630 --> 00:21:47,190
初始化语句。

421
00:21:47,190 --> 00:21:48,520
我们具有比少。

422
00:21:48,520 --> 00:21:50,950
这是小于或等于。

423
00:21:50,950 --> 00:21:52,200
这仅仅是一个有趣的[听不清]。

424
00:21:52,200 --> 00:21:54,800

425
00:21:54,800 --> 00:22:01,630
如果你想，如果它是printf的发生
大于或等于0，则

426
00:22:01,630 --> 00:22:03,345
你会选择这个。

427
00:22:03,345 --> 00:22:07,750
因此，平等公正的权利附加
后大于号。

428
00:22:07,750 --> 00:22:12,030
>> 相等相等，这是从不同
只是一个等号，平等平等

429
00:22:12,030 --> 00:22:16,430
实际上意味着，凡是在
本左手边是一样

430
00:22:16,430 --> 00:22:20,610
什么在这个右手侧
其中一个等号是什么？

431
00:22:20,610 --> 00:22:23,333
什么是只是一个等号？

432
00:22:23,333 --> 00:22:24,275
分配。

433
00:22:24,275 --> 00:22:25,985
>> LUCAS FREITAS：谁说的？

434
00:22:25,985 --> 00:22:27,170
是糖果？

435
00:22:27,170 --> 00:22:27,370
哦，不。

436
00:22:27,370 --> 00:22:27,885
抱歉。

437
00:22:27,885 --> 00:22:28,210
抱歉。

438
00:22:28,210 --> 00:22:30,400
你都得到糖果。

439
00:22:30,400 --> 00:22:31,510
哦，好吧！

440
00:22:31,510 --> 00:22:33,046
三个人得到的糖果！

441
00:22:33,046 --> 00:22:37,393
>> LAUREN卡瓦略：所以这一块就在这里
是前爆炸运营商

442
00:22:37,393 --> 00:22:40,240
等号，所以这
不等于。

443
00:22:40,240 --> 00:22:46,560
因此，如果这是在我的情况下，
病情的身体会

444
00:22:46,560 --> 00:22:49,615
执行只有当一切在
左边是不一样的

445
00:22:49,615 --> 00:22:52,540
什么是右侧。

446
00:22:52,540 --> 00:22:57,680
>> 我也可以有刚
感叹号。

447
00:22:57,680 --> 00:23:01,250
实际上，我们将在一个功能看
滑动如何做到这一点可以使用。

448
00:23:01,250 --> 00:23:03,830
>> LUCAS FREITAS：有问题吗？

449
00:23:03,830 --> 00:23:06,450
没有？

450
00:23:06,450 --> 00:23:10,460
>> LAUREN卡瓦略：我们可以结合这些
布尔表达式构建更

451
00:23:10,460 --> 00:23:12,500
复杂的条件语句。

452
00:23:12,500 --> 00:23:19,680
所以在这里，如果凡是在左边
双杆的右手边，或

453
00:23:19,680 --> 00:23:23,160
无论是在右手侧
双杆计算结果为true，

454
00:23:23,160 --> 00:23:25,700
然后我们再打印出来无效。

455
00:23:25,700 --> 00:23:29,503
然后到这里，如果不管的
对2的左手侧

456
00:23:29,503 --> 00:23:33,480
＆符号和任何的右侧
两个＆符号的右手边

457
00:23:33,480 --> 00:23:37,470
计算结果为true，则
我们将打印出有效的。

458
00:23:37,470 --> 00:23:42,195
双条被称为逻辑
OR运算符的双连字号

459
00:23:42,195 --> 00:23:44,190
所谓逻辑AND运算。

460
00:23:44,190 --> 00:23:44,648
是吗？

461
00:23:44,648 --> 00:23:47,850
>> 观众：是那些刚
小写l的？

462
00:23:47,850 --> 00:23:48,620
>> LAUREN卡瓦略：号

463
00:23:48,620 --> 00:23:50,890
它们实际上是 - 

464
00:23:50,890 --> 00:23:55,134
你知道的反弹，像
上面的回车键？

465
00:23:55,134 --> 00:23:56,585
你看到了吗？

466
00:23:56,585 --> 00:23:57,940
>> LUCAS FREITAS：它实际上是一个酒吧。

467
00:23:57,940 --> 00:24:02,100
>> LAUREN卡瓦略：它实际上是
只是两间酒吧。

468
00:24:02,100 --> 00:24:05,724
>> 观众：你可以使用
字符串相等相等？

469
00:24:05,724 --> 00:24:07,000
>> LUCAS FREITAS：号

470
00:24:07,000 --> 00:24:09,130
我们打​​算以后学习
一些事。

471
00:24:09,130 --> 00:24:10,735
>> LAUREN卡瓦略：有一个函数
您可以使用。

472
00:24:10,735 --> 00:24:12,644
但你不必
担心，只是还没有。

473
00:24:12,644 --> 00:24:15,530

474
00:24:15,530 --> 00:24:18,270
>> 如果我给这个程序
数字5？

475
00:24:18,270 --> 00:24:20,850
什么会打印出来吗？

476
00:24:20,850 --> 00:24:22,100
>> 观众：[听不清]

477
00:24:22,100 --> 00:24:27,780

478
00:24:27,780 --> 00:24:28,275
有效。

479
00:24:28,275 --> 00:24:29,770
>> LAUREN卡瓦略：有效？

480
00:24:29,770 --> 00:24:30,135
是啊。

481
00:24:30,135 --> 00:24:34,092
我不知道谁得到了这一点。

482
00:24:34,092 --> 00:24:35,036
>> [笑]

483
00:24:35,036 --> 00:24:37,990
>> LAUREN卡瓦略：这是一种
吓人[听不清]。

484
00:24:37,990 --> 00:24:40,900
>> 观众：所以，双和，
这只是意味着和？

485
00:24:40,900 --> 00:24:41,740
>> LAUREN卡瓦略：是啊。

486
00:24:41,740 --> 00:24:46,160
因此，5号是两个较大
比大于100 0及以下。

487
00:24:46,160 --> 00:24:48,970
>> 观众：它为什么会呢？

488
00:24:48,970 --> 00:24:51,350
>> LAUREN卡瓦略：一个是符号
其实不同的东西，它是

489
00:24:51,350 --> 00:24:53,390
按位运算符，你会
后来了解。

490
00:24:53,390 --> 00:24:58,250
但它的东西，实际工作
与一个给定数目的位。

491
00:24:58,250 --> 00:25:00,872
>> LUCAS FREITAS：试想他们不
不用担心它现在。

492
00:25:00,872 --> 00:25:04,590
>> LAUREN卡瓦略：我觉得它可能
下周就要到了。

493
00:25:04,590 --> 00:25:06,420
>> LUCAS FREITAS：还有没有其他问题？

494
00:25:06,420 --> 00:25:07,990
没有？

495
00:25:07,990 --> 00:25:12,480
>> LAUREN卡瓦略：因此，我们已经看到了一个
它阻止可单独存在，但它可以

496
00:25:12,480 --> 00:25:15,370
也可以搭配和else块。

497
00:25:15,370 --> 00:25:18,880
因此，在这种情况下，如果n大于
0，我们要打印出“你

498
00:25:18,880 --> 00:25:23,855
拾取的正数。“一样，意味着
如果是0，或者如果它的不足

499
00:25:23,855 --> 00:25:27,170
大于0，我们要打印出来，
“你挑一个负数。”

500
00:25:27,170 --> 00:25:30,390
>> 这里有趣的是，这些
是互相排斥的。

501
00:25:30,390 --> 00:25:33,940
还有的永远不会是一个案例
其中这与本

502
00:25:33,940 --> 00:25:35,544
既可以打印出来。

503
00:25:35,544 --> 00:25:38,190

504
00:25:38,190 --> 00:25:41,030
>> 我敢肯定，你曾与if / else语句
方块在刮，所以这应该是

505
00:25:41,030 --> 00:25:42,392
相当熟悉。

506
00:25:42,392 --> 00:25:42,874
是吗？

507
00:25:42,874 --> 00:25:48,522
>> 观众：我们是否需要之间的空间
整数n等于调用getInt然后在空间

508
00:25:48,522 --> 00:25:49,460
if语句？

509
00:25:49,460 --> 00:25:51,565
就像我们使用一个线[听不清]

510
00:25:51,565 --> 00:25:52,790
>> LAUREN卡瓦略：哦，这里的空间？

511
00:25:52,790 --> 00:25:56,742
>> 观众：这样，但
你双倍的空间。

512
00:25:56,742 --> 00:25:58,718
没有，上去了。

513
00:25:58,718 --> 00:25:59,706
上去了。

514
00:25:59,706 --> 00:26:00,610
>> LUCAS FREITAS：只是行了？

515
00:26:00,610 --> 00:26:01,140
>> 观众：是啊。

516
00:26:01,140 --> 00:26:02,870
>> LUCAS FREITAS：就在空行？

517
00:26:02,870 --> 00:26:03,270
>> 观众：是啊。

518
00:26:03,270 --> 00:26:04,070
>> LAUREN卡瓦略：空行？

519
00:26:04,070 --> 00:26:04,470
号

520
00:26:04,470 --> 00:26:06,320
这只是一个风格的东西。

521
00:26:06,320 --> 00:26:09,360
>> LUCAS FREITAS：这就像有时
你只是跳过一些行，以便

522
00:26:09,360 --> 00:26:12,330
该代码看起来并不像
文本块巨大。

523
00:26:12,330 --> 00:26:15,800
>> LAUREN卡瓦略：我觉得发生了什么
是，我们必须在这里留言，但我

524
00:26:15,800 --> 00:26:18,220
拿出来，这样你们将有
思考的代码，而

525
00:26:18,220 --> 00:26:19,920
不只是看我的评论。

526
00:26:19,920 --> 00:26:24,170
一般来说，间距不会真的
影响程序的运行方式。

527
00:26:24,170 --> 00:26:26,070
它更多的是一种风格的东西。

528
00:26:26,070 --> 00:26:29,460
而当我们有风格指南更新
并准备去年底

529
00:26:29,460 --> 00:26:33,260
supersection，我们将讨论
关于更多。

530
00:26:33,260 --> 00:26:34,660
>> 有什么东西错
这一方案，对不对？

531
00:26:34,660 --> 00:26:38,980
因为0是不是真的
一个负数。

532
00:26:38,980 --> 00:26:40,270
因此，让我们看看我们是否能够解决这个问题。

533
00:26:40,270 --> 00:26:45,710

534
00:26:45,710 --> 00:26:48,370
>> 你大概可以想像
与此说，对不对？

535
00:26:48,370 --> 00:26:52,850
如果n大于0，我们打印，“你
挑一个正数。“THEN ELSE

536
00:26:52,850 --> 00:26:57,340
如果n小于0，“你挑了个
负数。“一样，”你挑

537
00:26:57,340 --> 00:27:01,040
0。“

538
00:27:01,040 --> 00:27:06,030
>> 现在，有趣的是，
这可能会永远持续下去。

539
00:27:06,030 --> 00:27:10,020
你可以有一个if块中，否则，如果
块，另一否则，如果块，否则，如果，

540
00:27:10,020 --> 00:27:14,790
否则，如果，否则，如果，否则，基本上
只要你想要的。

541
00:27:14,790 --> 00:27:17,110
而当这样的构造，
这些都将是

542
00:27:17,110 --> 00:27:19,206
互相排斥的。

543
00:27:19,206 --> 00:27:19,650
是吗？

544
00:27:19,650 --> 00:27:24,130
>> 观众：那么，为什么你就不能使用
另外，如果代替[听不清]？

545
00:27:24,130 --> 00:27:26,990
>> LAUREN卡瓦略：在这种情况下，是的，我
如果可以使用另一个，这将是

546
00:27:26,990 --> 00:27:29,190
精绝，因为
条件本身是

547
00:27:29,190 --> 00:27:30,600
互相排斥的。

548
00:27:30,600 --> 00:27:33,560
但如果条件不是唯一
相互的，这将

549
00:27:33,560 --> 00:27:37,596
迫使他们从来没有两个评价，
如果是有道理的。

550
00:27:37,596 --> 00:27:44,195
>> 观众：在这种情况下，我们能否巢
第二，如果在第一，如果？

551
00:27:44,195 --> 00:27:46,160
>> LAUREN卡瓦略：如果 - 
你是什​​么意思？

552
00:27:46,160 --> 00:27:49,660
>> 观众：如果这两个条件
并不相互排斥？

553
00:27:49,660 --> 00:27:54,700
>> LAUREN卡瓦略：如果条件
并不相互排斥？

554
00:27:54,700 --> 00:27:58,000
但是你只想要其中的一种来运行？

555
00:27:58,000 --> 00:28:00,260
>> 观众：你只想要
如果不是别的。

556
00:28:00,260 --> 00:28:01,020
>> LAUREN卡瓦略：是啊。

557
00:28:01,020 --> 00:28:03,630
有总是会很多
的方式，你可以做到这一点。

558
00:28:03,630 --> 00:28:06,600
你绝对可以嵌套它们。

559
00:28:06,600 --> 00:28:10,390
而且你会在将来的幻灯片看到，
你可以有多个如果，只有一个

560
00:28:10,390 --> 00:28:11,680
纷至沓来。

561
00:28:11,680 --> 00:28:14,840
但是，这是逻辑上的一种方法
组织你的程序的流程。

562
00:28:14,840 --> 00:28:18,000
>> LUCAS FREITAS：而且还有一
的事情，就是你问把

563
00:28:18,000 --> 00:28:20,110
如果再另外如果。

564
00:28:20,110 --> 00:28:25,240
这将很好地工作，但它的坏
设计，因为基本上，如果你

565
00:28:25,240 --> 00:28:29,320
第一，如果检查，而且你注意到
的数目大于0，则

566
00:28:29,320 --> 00:28:30,660
可以只是完成该程序。

567
00:28:30,660 --> 00:28:33,080
你不必检查
它是小于0的，对不对？

568
00:28:33,080 --> 00:28:37,510
>> 但是，如果你做，如果，如​​果，它要检查
这两个，而如果我做，如果其他人在，

569
00:28:37,510 --> 00:28:39,260
它会检查是否
它是大于0。

570
00:28:39,260 --> 00:28:43,500
如果是，它不会连看
在其他行的代码。

571
00:28:43,500 --> 00:28:48,560
所以你基本上是检查它像
两次不必要的，所以这就是为什么我们

572
00:28:48,560 --> 00:28:50,750
如果做别的，如果。

573
00:28:50,750 --> 00:28:52,350
还有没有其他问题？

574
00:28:52,350 --> 00:28:56,547
>> 观众：这样的功能
在其他的，如果是相同的

575
00:28:56,547 --> 00:28:57,790
如果这只是如果？

576
00:28:57,790 --> 00:28:58,470
>> LAUREN卡瓦略：号

577
00:28:58,470 --> 00:29:02,720
你究竟要看到我的未来
滑动的示例，其中它可以

578
00:29:02,720 --> 00:29:03,270
是不同的。

579
00:29:03,270 --> 00:29:05,690
在这种情况下，它几乎是相同的。

580
00:29:05,690 --> 00:29:10,190

581
00:29:10,190 --> 00:29:15,410
>> 所以在这里，我们有多个的一个例子
if语句和

582
00:29:15,410 --> 00:29:20,020
功能是不一样的
就好像我刚刚说，如果

583
00:29:20,020 --> 00:29:23,120
否则，如果其他人，如果其他人。

584
00:29:23,120 --> 00:29:26,970
让我们只是想想将打印
，如果我输入数字95

585
00:29:26,970 --> 00:29:27,715
到这个程序。

586
00:29:27,715 --> 00:29:29,764
>> 观众：[听不清]

587
00:29:29,764 --> 00:29:31,102
>> LAUREN卡瓦略：然后呢？

588
00:29:31,102 --> 00:29:32,340
>> 观众：[听不清]

589
00:29:32,340 --> 00:29:33,680
>> LAUREN卡瓦略：是啊。

590
00:29:33,680 --> 00:29:37,430
所以在这种情况下，这些条件是
不是相互排斥的。

591
00:29:37,430 --> 00:29:41,040
并且因为没有什么能阻止
从评估这种情况下，如果这

592
00:29:41,040 --> 00:29:44,730
1已经有了，他们只是
一切都将打印出来。

593
00:29:44,730 --> 00:29:46,222
所以，我怎么能解决这个问题？

594
00:29:46,222 --> 00:29:47,608
>> 观众：还有IFS？

595
00:29:47,608 --> 00:29:48,910
>> LAUREN卡瓦略：您可以使用其他IFS。

596
00:29:48,910 --> 00:29:50,590
我可以改变顺序
这些，对不对？

597
00:29:50,590 --> 00:29:53,800
如果我第一次做这个吗？

598
00:29:53,800 --> 00:29:55,120
嗯，事实上，没有。

599
00:29:55,120 --> 00:29:57,100
这不会对95工作。

600
00:29:57,100 --> 00:29:58,490
>> LUCAS FREITAS：没有，只是在else IFS。

601
00:29:58,490 --> 00:30:01,720
>> LAUREN卡瓦略：在别的IFS
将固定的。

602
00:30:01,720 --> 00:30:07,050
这是否清理混乱
IFS之间和else IFS？

603
00:30:07,050 --> 00:30:11,480
>> 观众：我只是想问问你，如果
你没有使用否则，如果，它会停下来？

604
00:30:11,480 --> 00:30:11,840
>> LAUREN卡瓦略：对。

605
00:30:11,840 --> 00:30:13,330
所以只有这第一个。

606
00:30:13,330 --> 00:30:16,535
如果我输入的号码95，仅此
将打印出来的，它从不

607
00:30:16,535 --> 00:30:17,934
会进展到别人。

608
00:30:17,934 --> 00:30:22,570
>> LUCAS FREITAS：刚才那种想到的
它作为如果发生这种情况，做到这一点。

609
00:30:22,570 --> 00:30:26,990
在else是一样，如果没有，检查
对于这一点，然后做到这一点。

610
00:30:26,990 --> 00:30:28,690
因此，像他们都相互
排斥。

611
00:30:28,690 --> 00:30:30,270
你不能为两个以上的。

612
00:30:30,270 --> 00:30:32,800

613
00:30:32,800 --> 00:30:37,630
>> 观众：你可以使用逻辑
而对于这种情况？

614
00:30:37,630 --> 00:30:39,370
>> LAUREN卡瓦略：是啊。

615
00:30:39,370 --> 00:30:41,400
这是另一种方式，我们可以
已经修正了这个问题。

616
00:30:41,400 --> 00:30:43,470
我们可以定义
范围，对不对？

617
00:30:43,470 --> 00:30:49,410
所以我可以说，如果n大于
大于90且小于 - 

618
00:30:49,410 --> 00:30:52,135
嗯，我想这其中并没有真正
无所谓，但在这里我可以说，如果

619
00:30:52,135 --> 00:30:53,960
n大于80小于90。

620
00:30:53,960 --> 00:30:55,570
大于70，小于80更大。

621
00:30:55,570 --> 00:30:59,077
那会还努力。

622
00:30:59,077 --> 00:30:59,891
>> [笑]

623
00:30:59,891 --> 00:31:00,980
>> LUCAS FREITAS：她是害怕。

624
00:31:00,980 --> 00:31:02,070
>> LAUREN卡瓦略：不要怕。

625
00:31:02,070 --> 00:31:04,570
>> LUCAS FREITAS：这不是
这将是错误的。

626
00:31:04,570 --> 00:31:08,630
只是，它是不必要的
冗长。

627
00:31:08,630 --> 00:31:13,480
就像在计算机科学，人们应
要尽可能简单，只要

628
00:31:13,480 --> 00:31:14,730
你具备的功能。

629
00:31:14,730 --> 00:31:16,725

630
00:31:16,725 --> 00:31:17,835
你想要的糖果？

631
00:31:17,835 --> 00:31:19,084
>> 观众：不需要它。

632
00:31:19,084 --> 00:31:20,340
>> LAUREN卡瓦略：你吓到
每个人，卢卡斯。

633
00:31:20,340 --> 00:31:21,590
>> LUCAS FREITAS：对不起。

634
00:31:21,590 --> 00:31:24,650

635
00:31:24,650 --> 00:31:29,510
>> LAUREN卡瓦略：大卫还提到
在这些类switch语句。

636
00:31:29,510 --> 00:31:33,180
基本上，这是怎么回事是开关
需要声明一个变量。

637
00:31:33,180 --> 00:31:35,760
在这种情况下，我们正在采取一个整数。

638
00:31:35,760 --> 00:31:39,220
>> 如果整数是1，我们要
打印出来，“你挑一个小

639
00:31:39,220 --> 00:31:42,000
数。“如果整数为1，”你
挑了中等数量。“如果

640
00:31:42,000 --> 00:31:45,730
整数为3，“你挑了个高
号，“而且我也有一个默认的情况下，

641
00:31:45,730 --> 00:31:50,020
到这里，但它没有显示
起来，这是太糟糕了。

642
00:31:50,020 --> 00:31:53,120

643
00:31:53,120 --> 00:31:55,360
>> 基本上，这仅仅是
另一种语法。

644
00:31:55,360 --> 00:31:58,640
我们也可以精确实现这一
同样的事情，if和else if

645
00:31:58,640 --> 00:31:59,390
语句。

646
00:31:59,390 --> 00:32:05,530
但是，当有很多不同
条件和许多不同的

647
00:32:05,530 --> 00:32:10,350
变化你想要做什么
每个输入，这是一种选择。

648
00:32:10,350 --> 00:32:13,262
所以它只是一个很好的语法就知道了。

649
00:32:13,262 --> 00:32:15,099
是吗？

650
00:32:15,099 --> 00:32:21,380
>> 观众：为什么不是一个反斜杠
N的第一个？

651
00:32:21,380 --> 00:32:23,340
>> LAUREN卡瓦略：对于在那里？

652
00:32:23,340 --> 00:32:27,600
有没有反斜线Ñ在那里
因为调用getInt  - 

653
00:32:27,600 --> 00:32:30,140
如果你试试这个，它会
给你这样的提示。

654
00:32:30,140 --> 00:32:32,290
给我1和3之间的整数。

655
00:32:32,290 --> 00:32:35,550
如果我把背隙N，它会
带我到下一行，但我只是

656
00:32:35,550 --> 00:32:38,690
希望他们键入整数
后右结肠。

657
00:32:38,690 --> 00:32:40,120
你可能已经把反弹ñ。

658
00:32:40,120 --> 00:32:42,374
这不是什么大不了的事。

659
00:32:42,374 --> 00:32:43,288
是吗？

660
00:32:43,288 --> 00:32:50,525
>> 观众：对于此代码，这是
情况1，是因为

661
00:32:50,525 --> 00:32:51,760
这是第一种情况？

662
00:32:51,760 --> 00:32:52,260
因为 - 

663
00:32:52,260 --> 00:32:53,400
>> LAUREN卡瓦略：不，不，不。

664
00:32:53,400 --> 00:32:56,480
因此，这是给我一个整数
1到3之间。

665
00:32:56,480 --> 00:32:59,070
如果n为1，我打印了。

666
00:32:59,070 --> 00:33:02,740
如果我问信，我可以有
说给我的一封信

667
00:33:02,740 --> 00:33:04,935
和C那么这将是案件A.

668
00:33:04,935 --> 00:33:05,910
>> 观众：[听不清]。

669
00:33:05,910 --> 00:33:08,090
的情况下也只是[听不清]

670
00:33:08,090 --> 00:33:11,260
>> LAUREN卡瓦略：是的，没错。

671
00:33:11,260 --> 00:33:11,550
是吗？

672
00:33:11,550 --> 00:33:14,861
>> 观众：如果你有什么想有
更多的关系式的？

673
00:33:14,861 --> 00:33:17,645
所以不是说Ñ
等于1，[听不清]

674
00:33:17,645 --> 00:33:21,050
n是大于1的第一种情况？

675
00:33:21,050 --> 00:33:26,630
>> LAUREN卡瓦略：其实，如果我不
定义其中的一些情况下，这将

676
00:33:26,630 --> 00:33:28,500
被带下去。

677
00:33:28,500 --> 00:33:30,680
因此，实际上，也许这不是
你问什么。

678
00:33:30,680 --> 00:33:36,240
>> LUCAS FREITAS：我认为她询问
的情况下为：N比0，更大的情况下，

679
00:33:36,240 --> 00:33:37,150
小于0。

680
00:33:37,150 --> 00:33:39,210
>> LAUREN卡瓦略：也许开关
声明是不是真的是你想要的东西

681
00:33:39,210 --> 00:33:39,880
在这种情况下使用。

682
00:33:39,880 --> 00:33:42,420
>> LUCAS FREITAS：switch语句是
只是值，所以你检查

683
00:33:42,420 --> 00:33:45,370
该值是像这样或那样的。

684
00:33:45,370 --> 00:33:47,025
所以你不能真正
把条件。

685
00:33:47,025 --> 00:33:50,988

686
00:33:50,988 --> 00:33:55,920
>> 观众：如果什么人
类型的[听不清]？

687
00:33:55,920 --> 00:33:58,240
>> LAUREN卡瓦略：那将是
我的默认情况下，不幸的是

688
00:33:58,240 --> 00:33:58,910
你看不到。

689
00:33:58,910 --> 00:34:02,240
>> LUCAS FREITAS：[听不清]
让他们看到。

690
00:34:02,240 --> 00:34:03,690
>> LAUREN卡瓦略：其实，
你知道吗？

691
00:34:03,690 --> 00:34:07,795
就让我们去研究50，我会
只是放大在学习上的幻灯片

692
00:34:07,795 --> 00:34:10,610
50，因为这仅仅是烦人。

693
00:34:10,610 --> 00:34:14,938
所以让我真正去条件。

694
00:34:14,938 --> 00:34:17,860
这只是要
取一小会儿。

695
00:34:17,860 --> 00:34:26,940

696
00:34:26,940 --> 00:34:27,840
>> 好的。

697
00:34:27,840 --> 00:34:29,590
所以，我很抱歉。

698
00:34:29,590 --> 00:34:33,625
至少现在，我们就可以看到
一切都没有它切断。

699
00:34:33,625 --> 00:34:36,230

700
00:34:36,230 --> 00:34:36,969
好的。

701
00:34:36,969 --> 00:34:43,800
>> 所以，如果他们把在10，我们将默认
这里我默认情况下，我

702
00:34:43,800 --> 00:34:46,510
将只打印无效的，因为我
要求他们输入一个整数

703
00:34:46,510 --> 00:34:49,460
1到3之间。

704
00:34:49,460 --> 00:34:50,650
还有没有其他问题？

705
00:34:50,650 --> 00:34:51,081
是吗？

706
00:34:51,081 --> 00:34:57,590
>> 观众：我们先来说说案例一，案例
3，说，你希望它是所有

707
00:34:57,590 --> 00:35:00,950
同样的事情，所以你选择了一个数
这不是一个中等数量。

708
00:35:00,950 --> 00:35:03,840
在这种情况下，会是多余的？

709
00:35:03,840 --> 00:35:08,371
你只需要改变两个文本
其中，或者会有一些

710
00:35:08,371 --> 00:35:08,617
冗余？

711
00:35:08,617 --> 00:35:11,920
有什么办法来组合
[听不清]？

712
00:35:11,920 --> 00:35:15,810
>> LAUREN卡瓦略：有办法
结合他们，但我相信你可以

713
00:35:15,810 --> 00:35:18,730
只有结合相邻。

714
00:35:18,730 --> 00:35:22,250
所以，如果我没有什么定义
对于案例二，这将

715
00:35:22,250 --> 00:35:24,130
适用于这两种情况。

716
00:35:24,130 --> 00:35:28,110
哦，如果我没有把任何东西的情况下
之一，这将同时适用于

717
00:35:28,110 --> 00:35:30,620
案例一和二。

718
00:35:30,620 --> 00:35:33,616
如果是有道理的。

719
00:35:33,616 --> 00:35:35,872
>> 观众：你能再说一遍吗？

720
00:35:35,872 --> 00:35:36,670
>> LUCAS FREITAS：确定。

721
00:35:36,670 --> 00:35:39,950
如果你做了，基本上一样，你有
同样的事情，但你不把

722
00:35:39,950 --> 00:35:46,820
任何事情在这里，你会无论是对
案例一案例二，做到这一点。

723
00:35:46,820 --> 00:35:47,930
对不对？

724
00:35:47,930 --> 00:35:54,010
如果你得到这个突破意味着
这个情况下，见好就收。

725
00:35:54,010 --> 00:35:55,030
所以，这就是刹车的意思。

726
00:35:55,030 --> 00:35:59,755
所以，如果我只是做了这个，你看，这是
情况之一，你只需做到这一点。

727
00:35:59,755 --> 00:36:02,110
如果是情况二，它也将
刚刚来这里做。

728
00:36:02,110 --> 00:36:03,544
>> 观众：但是你能做到吗？

729
00:36:03,544 --> 00:36:05,140
如果有东西
案例二[听不清]

730
00:36:05,140 --> 00:36:07,095
>> LAUREN卡瓦略：我不相信
你可以做到这一点。

731
00:36:07,095 --> 00:36:09,380
我不认为你可以跳过左右。

732
00:36:09,380 --> 00:36:11,070
你可以做到这一点，罗布？

733
00:36:11,070 --> 00:36:13,300
我不认为如此。

734
00:36:13,300 --> 00:36:16,548
>> 观众：所以只有一个号码
可以去一案之后，对不对？

735
00:36:16,548 --> 00:36:21,410
不能有案例一，逗号，二？

736
00:36:21,410 --> 00:36:21,970
>> LUCAS FREITAS：不，你不能。

737
00:36:21,970 --> 00:36:25,085
你绝对不能。

738
00:36:25,085 --> 00:36:28,770
>> LAUREN卡瓦略：我的意思是，问题是
这是一种选择，而这可能不是

739
00:36:28,770 --> 00:36:31,940
适合你的使用情况，这样，那么你
在if条件会使用。

740
00:36:31,940 --> 00:36:33,906
>> 观众：那你为什么还要这么做？

741
00:36:33,906 --> 00:36:34,314
开关？

742
00:36:34,314 --> 00:36:38,540
>> LAUREN卡瓦略：我会用这
如果你很确定 - 

743
00:36:38,540 --> 00:36:39,730
实际上，卢卡斯，被你堵。

744
00:36:39,730 --> 00:36:40,982
>> LUCAS FREITAS：哦，对不起。

745
00:36:40,982 --> 00:36:44,200
>> LAUREN卡瓦略：如果你有非常
您要为定义的行为

746
00:36:44,200 --> 00:36:48,105
每一个输入端，这可能是一个
小比写出来更简洁

747
00:36:48,105 --> 00:36:49,530
一个if语句为每一个。

748
00:36:49,530 --> 00:36:51,210
>> 观众：什么的
再次突破是什么意思？

749
00:36:51,210 --> 00:36:53,180
>> LAUREN卡瓦略：间隔意味着停止。

750
00:36:53,180 --> 00:36:56,860
请记住，如果我没有这个破
在这里，我们刚刚倒下

751
00:36:56,860 --> 00:36:58,110
进入下一个案例。

752
00:36:58,110 --> 00:37:00,820
>> LUCAS FREITAS：歇手段来获得
出了switch语句。

753
00:37:00,820 --> 00:37:03,400
因为如果它是1，我想
打印该离开。

754
00:37:03,400 --> 00:37:04,640
我并不想检查什么。

755
00:37:04,640 --> 00:37:05,790
>> 观众：你不想
打印任何东西。

756
00:37:05,790 --> 00:37:06,730
>> LUCAS FREITAS：是啊。

757
00:37:06,730 --> 00:37:08,260
因为它是相互排斥的。

758
00:37:08,260 --> 00:37:11,378
>> 观众：而这是否只是进行
到下一个的情况下，如果第一种情况下

759
00:37:11,378 --> 00:37:11,850
是不是真的？

760
00:37:11,850 --> 00:37:14,120
抑或是测试所有的情况下，
在同一时间？

761
00:37:14,120 --> 00:37:16,300
>> LUCAS FREITAS：不，
检查顺序。

762
00:37:16,300 --> 00:37:18,070
按顺序，是的。

763
00:37:18,070 --> 00:37:21,840
还有一个问题，那我们得
继续前进，所以我们可以面面俱到。

764
00:37:21,840 --> 00:37:22,300
是吗？

765
00:37:22,300 --> 00:37:25,280
>> 观众：所以对于的情况下，可以有
做了一些事情，除了只是一个？

766
00:37:25,280 --> 00:37:27,680
你可以给它一个范围？

767
00:37:27,680 --> 00:37:28,580
>> LUCAS FREITAS：号

768
00:37:28,580 --> 00:37:29,900
>> LAUREN卡瓦略：我不认为
你可以给它一个范围。

769
00:37:29,900 --> 00:37:31,430
>> LUCAS FREITAS：你不能你
不能给它一个范围。

770
00:37:31,430 --> 00:37:33,190
>> 观众：此案是具体的
[听不清]。

771
00:37:33,190 --> 00:37:34,840
>> LUCAS FREITAS：开关
是有点价值的。

772
00:37:34,840 --> 00:37:38,400
你在做不同的事情
上的值，为特定值。

773
00:37:38,400 --> 00:37:41,050
你不能做的范围，你不能
做任何事情。

774
00:37:41,050 --> 00:37:43,055
它只是一个工具来查看。

775
00:37:43,055 --> 00:37:46,570
>> LAUREN卡瓦略：大多数人不使用
十分CS50 switch语句，

776
00:37:46,570 --> 00:37:48,760
但它的存在。

777
00:37:48,760 --> 00:37:49,920
>> 好的。

778
00:37:49,920 --> 00:37:53,870
因此，我们要谈接下来的事情
大约是三元运算符。

779
00:37:53,870 --> 00:37:56,650
这只是另一种类型
有条件的。

780
00:37:56,650 --> 00:38:01,460
基本上，这是怎么回事是我
寻求的整数，如果n为

781
00:38:01,460 --> 00:38:05,550
大于100，我要打印出来
“高”。如果不是的话，我要去

782
00:38:05,550 --> 00:38:07,010
打印出“低”。

783
00:38:07,010 --> 00:38:11,230
>> 所以它在做什么是条件
在这里，在括号和你

784
00:38:11,230 --> 00:38:13,550
一种能想到的问题
因为我问是否

785
00:38:13,550 --> 00:38:15,030
这是真的还是假的。

786
00:38:15,030 --> 00:38:18,485
如果这是真的，我要做到这一点首先
的事情，如果这不是真的，我

787
00:38:18,485 --> 00:38:20,020
要做到这第二件事。

788
00:38:20,020 --> 00:38:23,520

789
00:38:23,520 --> 00:38:27,960
>> 有关的任何问题
三元运算符？

790
00:38:27,960 --> 00:38:30,880
>> LUCAS FREITAS：只是想注意，从
大卫是，只要你有一个

791
00:38:30,880 --> 00:38:33,346
条件 - 

792
00:38:33,346 --> 00:38:35,690
>> LAUREN卡瓦略：我想大卫
通过实时流观看。

793
00:38:35,690 --> 00:38:37,210
>> LUCAS FREITAS：他在干什么
生活流现在。

794
00:38:37,210 --> 00:38:41,730
所以，只要你有一个条件，你
应该把花括号，

795
00:38:41,730 --> 00:38:45,320
就像我们在一个开关
这里声明。

796
00:38:45,320 --> 00:38:46,750
我们在这里有大括号。

797
00:38:46,750 --> 00:38:49,560
不管是什么条件，你
应该也放了。

798
00:38:49,560 --> 00:38:50,820
>> LAUREN卡瓦略：你会看到
这在风格指南。

799
00:38:50,820 --> 00:38:52,900
我们实际上并不具备
风格指南现在。

800
00:38:52,900 --> 00:38:53,930
我觉得大卫还在工作。

801
00:38:53,930 --> 00:38:55,100
>> LUCAS FREITAS：他说，
它只是现在的工作。

802
00:38:55,100 --> 00:38:56,120
>> LAUREN卡瓦略：哦，原来是现在的工作？

803
00:38:56,120 --> 00:38:57,520
确定。

804
00:38:57,520 --> 00:39:02,060
因此很明显，今年的风格
引导，即使你只是有一条线，

805
00:39:02,060 --> 00:39:06,040
你必须把那些
大括号英寸

806
00:39:06,040 --> 00:39:09,480
你不一定需要为
该程序的功能。

807
00:39:09,480 --> 00:39:12,210
也许我们应该休息一下
之后的条件和直行

808
00:39:12,210 --> 00:39:14,620
在风格指南来清除
一些这些东西？

809
00:39:14,620 --> 00:39:15,010
>> LUCAS FREITAS：是啊。

810
00:39:15,010 --> 00:39:15,775
你有问题吗？

811
00:39:15,775 --> 00:39:17,580
>> 观众：不，我只是等待
直到风格指南。

812
00:39:17,580 --> 00:39:19,578
>> 观众：你能回去
以三元运算符？

813
00:39:19,578 --> 00:39:23,360
>> LAUREN卡瓦略：三元，是的。

814
00:39:23,360 --> 00:39:29,010
>> LUCAS FREITAS：三元运算符是
基本上是一个的if else语句，但

815
00:39:29,010 --> 00:39:33,590
而不必有两条线
检查了，如果再的

816
00:39:33,590 --> 00:39:36,600
否则，你只是有一条线。

817
00:39:36,600 --> 00:39:40,930
所以基本上，如果我想给一个字符串
高或低的，并且我的一个值

818
00:39:40,930 --> 00:39:46,270
想要做一个高，如果n大于
100还是低，如果是少，我能做些什么

819
00:39:46,270 --> 00:39:47,730
这是[听不清]

820
00:39:47,730 --> 00:39:53,060
该字符串将是，然后我
问该程序是n大于100？

821
00:39:53,060 --> 00:39:55,750
>> 所以这就是为什么我有这样的表达
在括号中，然后

822
00:39:55,750 --> 00:39:56,580
问号。

823
00:39:56,580 --> 00:39:59,110
我问的是它大于100？

824
00:39:59,110 --> 00:40:02,310
如果是这样，这将是很高的。

825
00:40:02,310 --> 00:40:03,850
如果它不是，它要低。

826
00:40:03,850 --> 00:40:07,310
>> 所以基本上你认为是你问
一个问题，所以你把括号

827
00:40:07,310 --> 00:40:08,620
的条件。

828
00:40:08,620 --> 00:40:11,160
然后你把问号
因为你问吧。

829
00:40:11,160 --> 00:40:15,240
如果这是真的，这将是
在第一个值[听不清]在这里。

830
00:40:15,240 --> 00:40:18,176
如果不是的话，我打算把
值，冒号之后。

831
00:40:18,176 --> 00:40:21,580
这是否有意义？

832
00:40:21,580 --> 00:40:24,730
>> 这也是东西，就像是一个
工具在C，但你不必

833
00:40:24,730 --> 00:40:25,700
具体地使用它。

834
00:40:25,700 --> 00:40:29,890
但是CS的人通常喜欢
因为它只是节省了线。

835
00:40:29,890 --> 00:40:31,050
>> LAUREN卡瓦略：这是非常优雅。

836
00:40:31,050 --> 00:40:32,951
它做了很多，在短短一个语句。

837
00:40:32,951 --> 00:40:36,077
>> 观众：所以百分号是
只是无论对结果

838
00:40:36,077 --> 00:40:36,799
前行？

839
00:40:36,799 --> 00:40:38,260
>> LAUREN卡瓦略：哦，对不起。

840
00:40:38,260 --> 00:40:42,670
这百分号实际上是
一个占位符，这个S。

841
00:40:42,670 --> 00:40:46,160
在printf语句，你有这个
串在这里，这是怎么回事，以

842
00:40:46,160 --> 00:40:48,440
打印出来，但你不能随便
把这个在里面。

843
00:40:48,440 --> 00:40:50,290
否则，将打印
出的S字面上。

844
00:40:50,290 --> 00:40:54,070
所以我们把一个百分点这里，以保持
保持这个地方什么

845
00:40:54,070 --> 00:40:57,590
谈到在逗号后。

846
00:40:57,590 --> 00:40:59,470
>> 因此，对于一个字符串，你有百分之秒。

847
00:40:59,470 --> 00:41:00,950
对于一个整数，百分比我。

848
00:41:00,950 --> 00:41:03,330
对于浮动，百分比f。

849
00:41:03,330 --> 00:41:06,960
你会看到那些为我们
看到更多的例子。

850
00:41:06,960 --> 00:41:09,230
但也许你应该说说
风格指南一小会儿，现在

851
00:41:09,230 --> 00:41:10,480
它的了。

852
00:41:10,480 --> 00:41:21,040

853
00:41:21,040 --> 00:41:24,010
>> LUCAS FREITAS：如果你去
cs50.net/style，你会看到

854
00:41:24,010 --> 00:41:25,760
风格指南。

855
00:41:25,760 --> 00:41:32,420
对于习题集，你的分数为
习题集是由范围，

856
00:41:32,420 --> 00:41:35,510
而如果你做了所有的基本含义
问题设置的部分，或者如果您

857
00:41:35,510 --> 00:41:37,170
尝试一些东西。

858
00:41:37,170 --> 00:41:41,120
第二件事是正确，这
手段是你的程序在做什么

859
00:41:41,120 --> 00:41:44,520
是应该做的，还是它
有错误，或者是它没有做什么

860
00:41:44,520 --> 00:41:45,620
它应该做的。

861
00:41:45,620 --> 00:41:51,420
>> 第三件事是设计，这意味着
你实现这口井，或者是

862
00:41:51,420 --> 00:41:54,520
您使用不必要的报表？

863
00:41:54,520 --> 00:41:59,400
因此，举例来说，如果你想重复
一个数字的10倍，你在写一个

864
00:41:59,400 --> 00:42:03,040
for循环还是你只是在做10次
相同的语句，只是在做

865
00:42:03,040 --> 00:42:04,060
复制和粘贴。

866
00:42:04,060 --> 00:42:05,760
这样的设计对于那些。

867
00:42:05,760 --> 00:42:07,420
>> 最后，你有风格。

868
00:42:07,420 --> 00:42:12,000
风格就像判断
如果你的代码看起来

869
00:42:12,000 --> 00:42:14,050
可读种漂亮，。

870
00:42:14,050 --> 00:42:16,520
这只是基本含义
是你的代码可读性？

871
00:42:16,520 --> 00:42:20,560
将别人谁一直在寻找有
你的代码能够了解什么

872
00:42:20,560 --> 00:42:21,250
它在做什么？

873
00:42:21,250 --> 00:42:25,360
它有意见之类的？

874
00:42:25,360 --> 00:42:30,430
>> 让我们来谈谈的风格，
你应该使用。

875
00:42:30,430 --> 00:42:32,200
第一件事是注释。

876
00:42:32,200 --> 00:42:35,280
注释是非常重要的，你的
代码，因为有时候你做

877
00:42:35,280 --> 00:42:38,750
你的程序，你知道到底是什么
你想这样做，你刚开始

878
00:42:38,750 --> 00:42:43,120
编码，只要输入了一堆C的，但
如果有人在看着你是

879
00:42:43,120 --> 00:42:47,500
代码，他们不会要能够
了解它，因为他们不知道

880
00:42:47,500 --> 00:42:51,420
是在你的脑袋的东西，比如
该pesudocode，所以也许他们会

881
00:42:51,420 --> 00:42:53,970
有一个很难理解
什么代码正在做什么。

882
00:42:53,970 --> 00:42:57,900
>> 因此，注释是真正有用的解释
以人谁是在看

883
00:42:57,900 --> 00:43:00,880
你的代码它在做什么，和
实际上，即使对你来说，

884
00:43:00,880 --> 00:43:01,880
他们是非常有用的。

885
00:43:01,880 --> 00:43:05,740
当你去努力和辛勤pset时，
你会看到，代码变得

886
00:43:05,740 --> 00:43:10,590
更长的时间，然后注释是真的
所以你记住每一个重要的东西

887
00:43:10,590 --> 00:43:13,320
你的程序的一部分一样。

888
00:43:13,320 --> 00:43:16,920
>> 把一个评论，你可以做一个
斜线斜线，然后写一个评论。

889
00:43:16,920 --> 00:43:21,250
和整个行是注释的一部分，
不管你写下来，

890
00:43:21,250 --> 00:43:24,550
它不会是
用你的代码。

891
00:43:24,550 --> 00:43:27,993
这基本上就像编译器
将要忽略。

892
00:43:27,993 --> 00:43:29,290
这是否有道理？

893
00:43:29,290 --> 00:43:31,710
>> 观众：你又做了什么
写评论？

894
00:43:31,710 --> 00:43:33,260
>> LUCAS FREITAS：这个？

895
00:43:33,260 --> 00:43:36,020
斜线斜线？

896
00:43:36,020 --> 00:43:39,810
当您键入斜线斜线，无论
是在该行的是不会

897
00:43:39,810 --> 00:43:42,260
被认为是C。是吗？

898
00:43:42,260 --> 00:43:45,910
>> 观众：所以注释之后，你
刚刚进入并开始一个新行？

899
00:43:45,910 --> 00:43:47,120
>> LUCAS FREITAS：是的，没错。

900
00:43:47,120 --> 00:43:50,010
>> LAUREN卡瓦略：斜杠斜杠
是单行注释。

901
00:43:50,010 --> 00:43:52,910
>> LUCAS FREITAS：例如，
在这里，我们有 - 

902
00:43:52,910 --> 00:43:54,160
让我放大 - 

903
00:43:54,160 --> 00:43:56,530

904
00:43:56,530 --> 00:44:01,180
例如，我在这里声明一个浮点数，
但也许，如果你只是把这个

905
00:44:01,180 --> 00:44:04,980
在你的代码，就像你不知道
这是什么在做什么，其实像

906
00:44:04,980 --> 00:44:06,950
有人谁的看着这个代码
将是一样，什么样的

907
00:44:06,950 --> 00:44:09,190
到底是怎么回事？

908
00:44:09,190 --> 00:44:12,890
>> 如果你把一个评论说“转换
华氏摄氏度，这让很多

909
00:44:12,890 --> 00:44:13,450
更有意义。

910
00:44:13,450 --> 00:44:15,480
你，想，好，你是
做一个转换。

911
00:44:15,480 --> 00:44:16,730
这是否有道理？

912
00:44:16,730 --> 00:44:19,860

913
00:44:19,860 --> 00:44:24,960
所以它只是一些帮助人们
准备好你的代码，也使

914
00:44:24,960 --> 00:44:28,290
你能够组织
你的代码更好。

915
00:44:28,290 --> 00:44:33,080
>> 第二件事是，你可以做
多行注释，所以有一个

916
00:44:33,080 --> 00:44:34,850
对于一帮行的意见。

917
00:44:34,850 --> 00:44:38,880
相反，不必把斜线斜线
第一行注释，斜线斜线，

918
00:44:38,880 --> 00:44:43,590
在第二行，依此类推，则
可以使用斜线明星。

919
00:44:43,590 --> 00:44:46,330
你做的方式是，对
注释的第一行，你

920
00:44:46,330 --> 00:44:49,650
要做一个斜线明星明星，
所以就是这样。

921
00:44:49,650 --> 00:44:56,900
就像我们这里有初
一个程序，你通常把你们谁

922
00:44:56,900 --> 00:44:59,530
是，这是什么节目呢，
和类似的东西。

923
00:44:59,530 --> 00:45:01,900
这有点像一个头
对于该程序。

924
00:45:01,900 --> 00:45:04,540
>> 再次，它不是一个
编译器会关心，但

925
00:45:04,540 --> 00:45:07,570
这是重要的，你知道这是什么
程序执行或其他人

926
00:45:07,570 --> 00:45:09,960
知道你的程序在做什么。

927
00:45:09,960 --> 00:45:17,480
这样你就凶多吉少明星明星，然后
你要做明星最后一行

928
00:45:17,480 --> 00:45:22,250
削减到能够关闭
这一评论。

929
00:45:22,250 --> 00:45:26,140
因此，基本上所有其它线路，
你可以只写什么，而这

930
00:45:26,140 --> 00:45:27,390
一切会被忽略。

931
00:45:27,390 --> 00:45:32,920

932
00:45:32,920 --> 00:45:37,780
>> 而且，正如风格，你看到
每一行都有一个明星，和所有

933
00:45:37,780 --> 00:45:39,380
星星是一致的。

934
00:45:39,380 --> 00:45:41,605
这些都是重要的东西，所以
你的代码看起来很漂亮。

935
00:45:41,605 --> 00:45:42,855
听起来不错？

936
00:45:42,855 --> 00:45:45,320

937
00:45:45,320 --> 00:45:47,290
>> 现在，条件。

938
00:45:47,290 --> 00:45:52,240
什么大卫说，我们应该
居然把这些幻灯片，是

939
00:45:52,240 --> 00:45:55,810
当你有任何形式的if语句
或任何种类的情况下，

940
00:45:55,810 --> 00:46:00,700
你应该使用大括号表明，
这是发生了什么事情要发生

941
00:46:00,700 --> 00:46:02,730
当你具备的条件。

942
00:46:02,730 --> 00:46:07,560
从技术上讲，当你有一个条件
然后下一行仅仅是一个

943
00:46:07,560 --> 00:46:12,110
行，你没有在技术上有
把花括号。

944
00:46:12,110 --> 00:46:16,930
>> 基本上，编译器会明白
反正是隐式的。

945
00:46:16,930 --> 00:46:21,100
但对于CS50，我们要求你们把
花括号只是让你

946
00:46:21,100 --> 00:46:24,560
代码更有条理
和更具可读性。

947
00:46:24,560 --> 00:46:28,200
因为该代码变得更长，如果你
没有大括号和如此的。

948
00:46:28,200 --> 00:46:29,150
它变得非常凌乱。

949
00:46:29,150 --> 00:46:31,410
>> LAUREN卡瓦略：这正是
什么大卫刚指出，

950
00:46:31,410 --> 00:46:33,000
在我以前的幻灯片。

951
00:46:33,000 --> 00:46:36,690
它绝对有效不带花
括号，但对于文体的原因

952
00:46:36,690 --> 00:46:38,840
我们要问这个
你不要把那些英寸

953
00:46:38,840 --> 00:46:42,400
>> 而当你开始运行style50，
这是一种检查50对

954
00:46:42,400 --> 00:46:44,860
风格，它会提醒你做到这一点。

955
00:46:44,860 --> 00:46:49,710
>> LUCAS FREITAS：还有一件事是
记得把花括号沿

956
00:46:49,710 --> 00:46:50,610
在每一行。

957
00:46:50,610 --> 00:46:52,490
所以你做什么，例如，l的。

958
00:46:52,490 --> 00:46:56,910
转到下一行，开大
撑，然后你去下一行。

959
00:46:56,910 --> 00:46:59,560
缩进，这是四个空格。

960
00:46:59,560 --> 00:47:03,570
那么你就写什么，然后又
线，并关闭大括号。

961
00:47:03,570 --> 00:47:06,870
所以，要确保这两个大
括号是在不同的线路。

962
00:47:06,870 --> 00:47:11,548
>> 观众：所以，如果这段代码有一个像
10其他IFS，这应该

963
00:47:11,548 --> 00:47:13,040
有10套括号？

964
00:47:13,040 --> 00:47:14,610
>> LUCAS FREITAS：是的，为他们每个人。

965
00:47:14,610 --> 00:47:14,930
是啊。

966
00:47:14,930 --> 00:47:17,980
因此，如果，否则，如果，等等。

967
00:47:17,980 --> 00:47:21,990
>> 观众：你不能
按Tab键缩进？

968
00:47:21,990 --> 00:47:25,350
>> LUCAS FREITAS：我们要求您
你们用四个空格。

969
00:47:25,350 --> 00:47:30,060
一些文本编辑器翻译标签
作为四个空格自动。

970
00:47:30,060 --> 00:47:34,850
gedit中没有，所以你必须
做空格空格空格空格。

971
00:47:34,850 --> 00:47:37,920
这也未尝一些
程序员只能做标签，有的

972
00:47:37,920 --> 00:47:40,560
程序员只能做四个空格，
和其他一些人甚至做

973
00:47:40,560 --> 00:47:41,900
2或3位。

974
00:47:41,900 --> 00:47:44,040
这只是我们在这里问
你们做四个空格。

975
00:47:44,040 --> 00:47:47,556
>> 观众：有几乎肯定
必须是一个方式的gedit来

976
00:47:47,556 --> 00:47:48,645
自动[听不清]。

977
00:47:48,645 --> 00:47:50,480
像没有[听不清]这样做的。

978
00:47:50,480 --> 00:47:51,150
>> LUCAS FREITAS：是啊。

979
00:47:51,150 --> 00:47:53,165
我觉得你可以去设置。

980
00:47:53,165 --> 00:47:55,270
>> 观众：它已经这样做了这一切。

981
00:47:55,270 --> 00:47:56,410
>> LUCAS FREITAS：它已经这样做？

982
00:47:56,410 --> 00:47:56,890
确定。

983
00:47:56,890 --> 00:48:00,854
因此，只要确保你
有4个空格。

984
00:48:00,854 --> 00:48:05,880
>> 观众：我们有没有把卷发
括号中的for循环呢？

985
00:48:05,880 --> 00:48:07,470
>> LUCAS FREITAS：是的。

986
00:48:07,470 --> 00:48:11,610
>> LAUREN卡瓦略：每当你的
封装的代码块，就

987
00:48:11,610 --> 00:48:13,570
请使用大括号。

988
00:48:13,570 --> 00:48:18,040
而你认为我们只是之前
是拘泥于这个没有很好的

989
00:48:18,040 --> 00:48:23,450
因此，如果你们干什么去了就搞定
高科技在实习的大公司，

990
00:48:23,450 --> 00:48:26,020
他们会给你一个风格指南，并
他们会告诉你，这是你的

991
00:48:26,020 --> 00:48:27,220
代码需要的样子。

992
00:48:27,220 --> 00:48:31,120
而且即使你学会了这样的代码
这一点，也许在你的实习

993
00:48:31,120 --> 00:48:32,680
你必须做一些事情
完全不同的。

994
00:48:32,680 --> 00:48:35,115
他们期望你符合
他们的风格。

995
00:48:35,115 --> 00:48:39,800
>> LUCAS FREITAS：还有一件事是
那你会注意我怎么有这样的x，

996
00:48:39,800 --> 00:48:42,290
空间少，空间，0？

997
00:48:42,290 --> 00:48:44,640
只要你有一个操作 - 

998
00:48:44,640 --> 00:48:50,490
它可以像加，减，时间，少，
更大，无论运营商 - 

999
00:48:50,490 --> 00:48:57,560
你必须把左边的空间
和操作者的权利。

1000
00:48:57,560 --> 00:49:00,570
>> LAUREN卡瓦略：这些都是
称为二进制操作数。

1001
00:49:00,570 --> 00:49:03,720
只要确保你总是空间
你的二进制操作数。

1002
00:49:03,720 --> 00:49:05,465
>> LUCAS FREITAS：这是
不是二元运算。

1003
00:49:05,465 --> 00:49:07,010
>> LAUREN卡瓦略：这是
因为它需要两个。

1004
00:49:07,010 --> 00:49:08,260
>> LUCAS FREITAS：哦，是的。

1005
00:49:08,260 --> 00:49:13,340

1006
00:49:13,340 --> 00:49:14,590
>> OK，开关。

1007
00:49:14,590 --> 00:49:18,180

1008
00:49:18,180 --> 00:49:23,390
首先，你必须要看到，就像
在if或else语句，你有

1009
00:49:23,390 --> 00:49:28,280
把花括号在它自己的行
并根据这里的大括号。

1010
00:49:28,280 --> 00:49:32,240
请注意，有一个空格
切换后，如果只是和其他人喜欢

1011
00:49:32,240 --> 00:49:35,360
我们之间有一个空格
这和括号。

1012
00:49:35,360 --> 00:49:36,610
所以，你必须把那个。

1013
00:49:36,610 --> 00:49:40,380

1014
00:49:40,380 --> 00:49:48,270
>> 而且也没有空间，之后每
括号中或年底前

1015
00:49:48,270 --> 00:49:49,080
括号中。

1016
00:49:49,080 --> 00:49:52,612
所以你看，这一切都在一起，
也喜欢这里了。

1017
00:49:52,612 --> 00:49:53,940
>> 是吗？

1018
00:49:53,940 --> 00:49:58,040
>> LAUREN卡瓦略：我觉得
我们需要继续前进。

1019
00:49:58,040 --> 00:50:02,340
>> LUCAS FREITAS：所以这是其中的一部分，
风格指南，你必须为CS50。

1020
00:50:02,340 --> 00:50:06,520
一定要到cs50.net/style
并看看这个。

1021
00:50:06,520 --> 00:50:09,250
这些都是非常重要的
为你的风格得分。

1022
00:50:09,250 --> 00:50:12,740

1023
00:50:12,740 --> 00:50:15,670
>> 让我回去的语句。

1024
00:50:15,670 --> 00:50:17,070
>> LAUREN卡瓦略：我宁愿
只需使用style50。

1025
00:50:17,070 --> 00:50:18,920
我们只是要去
直循环。

1026
00:50:18,920 --> 00:50:27,580

1027
00:50:27,580 --> 00:50:28,300
好的。

1028
00:50:28,300 --> 00:50:33,720
>> 因此，让我们回到内容，现在
我们已经讨论了在风格指南。

1029
00:50:33,720 --> 00:50:37,220
循环，你见过他们的划痕，并
我们要谈论他们在

1030
00:50:37,220 --> 00:50:39,210
C.

1031
00:50:39,210 --> 00:50:44,400
>> 在fo​​r循环中，有
三个部分的

1032
00:50:44,400 --> 00:50:45,440
声明这个for循环。

1033
00:50:45,440 --> 00:50:49,040
你有你的初始化中
您设置的变量。

1034
00:50:49,040 --> 00:50:52,160
你有你的条件，这是
检查，看东西是否是

1035
00:50:52,160 --> 00:50:54,670
真或假，以及是否
循环应该继续。

1036
00:50:54,670 --> 00:50:59,390
和你有你的更新，这
正在更新您的变数。

1037
00:50:59,390 --> 00:51:05,310
>> 就让我们来简单看看一些
这个C代码的for循环在行动。

1038
00:51:05,310 --> 00:51:08,860
这是怎么回事是在这里的
初始化时，我们设置时i为0。

1039
00:51:08,860 --> 00:51:11,820
在此条件下，我们正在检查
i是否小于10。

1040
00:51:11,820 --> 00:51:14,982
并在更新我们
i增加。

1041
00:51:14,982 --> 00:51:20,490
这样会导致什么
这个循环？

1042
00:51:20,490 --> 00:51:24,344
>> LUCAS FREITAS：其实，首先，
做你们知道我+ +是？

1043
00:51:24,344 --> 00:51:25,850
>> 观众：由1提高。

1044
00:51:25,850 --> 00:51:26,870
>> LUCAS FREITAS：增加1，是的。

1045
00:51:26,870 --> 00:51:30,020
因此，这是同样的事情，
做我等于我加1。

1046
00:51:30,020 --> 00:51:35,890
并请注意，我们没有一个空间
在i和+之间。

1047
00:51:35,890 --> 00:51:37,600
>> 所以，不要你们知道这是什么会做什么？

1048
00:51:37,600 --> 00:51:39,060
有人能告诉我吗？

1049
00:51:39,060 --> 00:51:41,463
也许得到一些糖果
正因为如此？

1050
00:51:41,463 --> 00:51:42,912
>> 观众：[听不清]

1051
00:51:42,912 --> 00:51:44,850
>> LUCAS FREITAS：确定。

1052
00:51:44,850 --> 00:51:45,400
[听不清]

1053
00:51:45,400 --> 00:51:47,450
显示大家以后[听不清]。

1054
00:51:47,450 --> 00:51:49,565
是啊，它会显示“此
是CS50“的10倍。

1055
00:51:49,565 --> 00:51:52,150
>> LAUREN卡瓦略：我想这是
在幻灯片的标题。

1056
00:51:52,150 --> 00:51:53,830
>> LUCAS FREITAS：哦，是的。

1057
00:51:53,830 --> 00:51:54,670
>> [笑]

1058
00:51:54,670 --> 00:51:56,790
>> LUCAS FREITAS：没有什么帮助。

1059
00:51:56,790 --> 00:51:58,370
>> LAUREN卡瓦略：那么那些
对于循环。

1060
00:51:58,370 --> 00:52:03,200
我们将看到一些更多的例子
以后的循环。

1061
00:52:03,200 --> 00:52:06,510
但是，让我们实际来看看的
第二种类型的循环，你会遇到

1062
00:52:06,510 --> 00:52:08,920
在C中，它就是所谓的while循环。

1063
00:52:08,920 --> 00:52:11,120
>> 在while循环中，你已经
刚刚得到一个条件。

1064
00:52:11,120 --> 00:52:14,790
条件是在检查
开始，如果该条件

1065
00:52:14,790 --> 00:52:18,450
计算结果为true，那么代码中
而该块体

1066
00:52:18,450 --> 00:52:20,380
将执行。

1067
00:52:20,380 --> 00:52:23,000
并且代码将继续
执行，只要该

1068
00:52:23,000 --> 00:52:24,450
条件保持为真。

1069
00:52:24,450 --> 00:52:28,350

1070
00:52:28,350 --> 00:52:33,320
>> 下面是C中的while循环的一个例子
我们将设置数为10〜

1071
00:52:33,320 --> 00:52:34,580
开始的时候。

1072
00:52:34,580 --> 00:52:41,800
只要计数值大于0时，
我们要保持打印出此

1073
00:52:41,800 --> 00:52:43,360
变量在这里。

1074
00:52:43,360 --> 00:52:47,080
我们将递减计数和
然后再检查的条件。

1075
00:52:47,080 --> 00:52:51,370
打印，减量，检查
的条件了。

1076
00:52:51,370 --> 00:52:54,530
>> 在这里，我们有一个涉及一个例子
早期你的问题。

1077
00:52:54,530 --> 00:52:57,340
我们有百分之S当我们
打印出一个字符串，而现在

1078
00:52:57,340 --> 00:53:03,420
我们要打印出一个int，我们有一个
％的我作为我们的占位符代替。

1079
00:53:03,420 --> 00:53:09,250
这些信件都应该是相当
直观，s为字符串，i为整数。

1080
00:53:09,250 --> 00:53:15,400
>> 所以，如果这段代码执行时，你应该
从10倒数到0时，打印出

1081
00:53:15,400 --> 00:53:15,925
每个整数。

1082
00:53:15,925 --> 00:53:19,460
>> LUCAS FREITAS：你能想到的
％，因为它感觉就像一个空白

1083
00:53:19,460 --> 00:53:23,960
空间，然后你把这个
这里的变量在该空白。

1084
00:53:23,960 --> 00:53:27,640
因此，举例来说，在这里我将刚
一片空白，然后我把

1085
00:53:27,640 --> 00:53:30,262
算右那里，
计数的值。

1086
00:53:30,262 --> 00:53:32,710
这是否有道理？

1087
00:53:32,710 --> 00:53:35,860
>> 难道我只是做如printf
然后报价，算什么？

1088
00:53:35,860 --> 00:53:36,840
将这项工作？

1089
00:53:36,840 --> 00:53:37,980
>> 观众：号

1090
00:53:37,980 --> 00:53:41,190
>> LUCAS FREITAS：没有，因为它会
实际打印的字“数”

1091
00:53:41,190 --> 00:53:42,850
而不是打印的值。

1092
00:53:42,850 --> 00:53:46,080
这是你如何让它打印出值
朝向变量，而不是

1093
00:53:46,080 --> 00:53:47,670
可变的只是名称。

1094
00:53:47,670 --> 00:53:48,530
有问题吗？

1095
00:53:48,530 --> 00:53:53,060
>> 观众：你为什么使用
作为反对一会儿？

1096
00:53:53,060 --> 00:53:56,130
>> LAUREN卡瓦略：我会用的
循环，如果我知道到底有多少

1097
00:53:56,130 --> 00:53:59,520
迭代我想我的循环运行。

1098
00:53:59,520 --> 00:54:02,810
在这种情况下，也没有关系，因为
我的意思是，我只是想

1099
00:54:02,810 --> 00:54:05,310
想到一个非常简单的
例如这个幻灯片。

1100
00:54:05,310 --> 00:54:09,990
但让我们说，你想要的东西
坚持下去，而 - 

1101
00:54:09,990 --> 00:54:14,480
>> LUCAS FREITAS：例如，你
要求输入，直到人

1102
00:54:14,480 --> 00:54:15,370
为您提供了正确的输入。

1103
00:54:15,370 --> 00:54:19,720
所以像而输入不
好了，一个劲儿地问它。

1104
00:54:19,720 --> 00:54:22,920
还是喜欢，而你父母不给
你的钱，不断地问它。

1105
00:54:22,920 --> 00:54:23,430
>> [笑]

1106
00:54:23,430 --> 00:54:25,390
>> LAUREN卡瓦略：你不知道如何
很多时候，你就必须做到这一点。

1107
00:54:25,390 --> 00:54:27,292
>> LUCAS FREITAS：因为你不
知道多少倍的

1108
00:54:27,292 --> 00:54:28,010
要继续下去。

1109
00:54:28,010 --> 00:54:30,397
>> LAUREN卡瓦略：但是，在一个for循环，
你需要知道多少倍。

1110
00:54:30,397 --> 00:54:33,640

1111
00:54:33,640 --> 00:54:33,860
是吗？

1112
00:54:33,860 --> 00:54:38,520
>> 观众：我想弄清楚，百分比
说这是一些关于到

1113
00:54:38,520 --> 00:54:42,415
发生时，我的为整数，
和反斜线北 - 

1114
00:54:42,415 --> 00:54:43,910
>> LAUREN卡瓦略：什么意思？

1115
00:54:43,910 --> 00:54:45,820
谁知道反斜杠n意思？

1116
00:54:45,820 --> 00:54:47,770
新的生产线，是的。

1117
00:54:47,770 --> 00:54:48,130
没错。

1118
00:54:48,130 --> 00:54:50,500
>> LUCAS FREITAS：你能想到的
n作为新行。

1119
00:54:50,500 --> 00:54:52,258
>> LAUREN卡瓦略：尼斯。

1120
00:54:52,258 --> 00:54:55,775
>> 观众：那是什么数
短跑冲刺[听不清]？

1121
00:54:55,775 --> 00:55:00,240
>> LUCAS FREITAS：减计数减为
同样的事情，再加上加分，但

1122
00:55:00,240 --> 00:55:02,160
而不是增加，
它减少了1。

1123
00:55:02,160 --> 00:55:04,720

1124
00:55:04,720 --> 00:55:07,185
>> LAUREN卡瓦略：任何更多
while循环的问题？

1125
00:55:07,185 --> 00:55:09,460
没有？

1126
00:55:09,460 --> 00:55:13,910
哦，我们应该
跳过了这一点。

1127
00:55:13,910 --> 00:55:14,950
>> 这是一个do while循环。

1128
00:55:14,950 --> 00:55:18,950
非常相似，除了在一个while循环
这种情况下，我们检查的条件后，

1129
00:55:18,950 --> 00:55:23,430
中的主体的代码
循环执行一次。

1130
00:55:23,430 --> 00:55:27,170
因此，我们执行的代码
先不管。

1131
00:55:27,170 --> 00:55:31,956
然后我们检查的情况下，执行
再次，如果条件为真。

1132
00:55:31,956 --> 00:55:35,450

1133
00:55:35,450 --> 00:55:38,950
>> 你会发现自己使用这个时
你要求用户输入。

1134
00:55:38,950 --> 00:55:42,080
因为你总是不得不
再问一次，然后根据什么

1135
00:55:42,080 --> 00:55:46,570
用户输入的是，您可能需要
重新提示，如果再次问

1136
00:55:46,570 --> 00:55:50,670
输入是不是你
希望它是。

1137
00:55:50,670 --> 00:55:53,610
>> 观众：所以它就像一个形式
供人填写。

1138
00:55:53,610 --> 00:55:56,010
>> LAUREN卡瓦略：是的，没错。

1139
00:55:56,010 --> 00:55:59,720
你会发现，我想，在你的第一个
PSET，你将不得不

1140
00:55:59,720 --> 00:56:04,010
使用做好循环收集
来自用户的输入。

1141
00:56:04,010 --> 00:56:08,728
>> 观众：视情况而定，
您的while循环将倾向于运行更

1142
00:56:08,728 --> 00:56:12,805
往往比while循环，像
由一个或某事？

1143
00:56:12,805 --> 00:56:14,080
>> LAUREN卡瓦略：如果是准确的 - 

1144
00:56:14,080 --> 00:56:17,400
>> LUCAS FREITAS：他们应该始终运行
时代的确切数额，你

1145
00:56:17,400 --> 00:56:19,130
希望它运行。

1146
00:56:19,130 --> 00:56:23,860
就像我们用做的，而因为我们真的
想要得到的输入至少一次。

1147
00:56:23,860 --> 00:56:27,220
在while循环，有时候你不想
执行它在所有，如果它不是

1148
00:56:27,220 --> 00:56:28,540
执行的情况。

1149
00:56:28,540 --> 00:56:31,300
因此它取决于设计。

1150
00:56:31,300 --> 00:56:35,900
我的意思是，你可以使用做，而或
而只要你的代码做了

1151
00:56:35,900 --> 00:56:36,905
它应该做的。

1152
00:56:36,905 --> 00:56:38,470
>> LAUREN卡瓦略：但我
认为答案给你

1153
00:56:38,470 --> 00:56:40,540
问题很可能是肯定的。

1154
00:56:40,540 --> 00:56:42,190
假设条件是假的。

1155
00:56:42,190 --> 00:56:45,498
在一种情况下，它会运行一次，并
另一种情况下，它会运行零次。

1156
00:56:45,498 --> 00:56:47,370
所以，是的。

1157
00:56:47,370 --> 00:56:49,260
>> 还有什么问题吗？

1158
00:56:49,260 --> 00:56:50,320
是吗？

1159
00:56:50,320 --> 00:56:56,443
>> 观众：可循环条件是
for循环中的变量其他条款

1160
00:56:56,443 --> 00:56:57,385
比[听不清]。

1161
00:56:57,385 --> 00:57:01,700
>> LAUREN卡瓦略：是啊，
它可以是任何东西。

1162
00:57:01,700 --> 00:57:06,420
可能是开始pset时，你
不会遇到这种情况，但

1163
00:57:06,420 --> 00:57:09,878
肯定它可以是任何东西。

1164
00:57:09,878 --> 00:57:12,680
>> LUCAS FREITAS：我觉得
我们在这里完成。

1165
00:57:12,680 --> 00:57:13,290
>> LAUREN卡瓦略：我们？

1166
00:57:13,290 --> 00:57:13,480
没有？

1167
00:57:13,480 --> 00:57:13,870
>> LUCAS FREITAS：循环？

1168
00:57:13,870 --> 00:57:14,600
是啊。

1169
00:57:14,600 --> 00:57:16,280
>> LAUREN卡瓦略：我们不应该。

1170
00:57:16,280 --> 00:57:17,760
哦，我们已经完成了循环。

1171
00:57:17,760 --> 00:57:19,250
确定。

1172
00:57:19,250 --> 00:57:23,180
>> 事实上，因为我们一直在谈论这样
多，让我们居然全部浏览

1173
00:57:23,180 --> 00:57:28,950
交给study.cs50.net/conditions。

1174
00:57:28,950 --> 00:57:34,460
而你要向下导航
对问题部件。

1175
00:57:34,460 --> 00:57:39,090
嗯，事实上，当人们越来越
这种设置中，CS50是研究

1176
00:57:39,090 --> 00:57:42,620
将是一个工具，你将转录因子
使用的部分，并且准备

1177
00:57:42,620 --> 00:57:45,230
你们可以使用，如果您错过的部分。

1178
00:57:45,230 --> 00:57:48,980
这将包含一堆幻灯片，
一些提示和技巧对每个

1179
00:57:48,980 --> 00:57:54,030
的话题，和一些实际问题
的解决方案。

1180
00:57:54,030 --> 00:57:57,200
>> 为什么不是每个人都只是来看看
这个问题就在这里。

1181
00:57:57,200 --> 00:58:01,630

1182
00:58:01,630 --> 00:58:04,790
>> 对不起，我应该提醒
今天的人们带来的笔记本电脑。

1183
00:58:04,790 --> 00:58:07,050
但是，如果你没有
一台笔记本电脑，那也无妨。

1184
00:58:07,050 --> 00:58:10,140
你可以只记下来的
一张纸或查看

1185
00:58:10,140 --> 00:58:12,890
你的邻居的肩膀。

1186
00:58:12,890 --> 00:58:16,380
>> 让我们试着写一个程序，
提示用户采取了猜测，

1187
00:58:16,380 --> 00:58:19,250
每个家庭子女平均数
单元在美国。

1188
00:58:19,250 --> 00:58:22,265
这个数字是2，顺便说一下，当你
从这些例子看。

1189
00:58:22,265 --> 00:58:24,770

1190
00:58:24,770 --> 00:58:29,030
>> 我们想打印出的平均数
在美国每个家庭的孩子，那么我们

1191
00:58:29,030 --> 00:58:31,080
想什么？

1192
00:58:31,080 --> 00:58:35,480
我们要收集的输入
从用户。

1193
00:58:35,480 --> 00:58:41,290
然后这取决于用户的
输入是，你要打印出

1194
00:58:41,290 --> 00:58:44,850
无论这是正确的
或者这是不正确的。

1195
00:58:44,850 --> 00:58:48,040
>> 而第一件事，你会
看，如果你点击那个小箭头

1196
00:58:48,040 --> 00:58:52,190
问题插件的底部是一个
当场记下一些伪代码。

1197
00:58:52,190 --> 00:58:53,340
这样你就不会编程呢。

1198
00:58:53,340 --> 00:58:56,740
你只是让你的
思想秩序。

1199
00:58:56,740 --> 00:58:59,620
>> 有谁想帮助卢卡斯
想出正确的

1200
00:58:59,620 --> 00:59:01,270
伪代码这个问题？

1201
00:59:01,270 --> 00:59:04,900
>> LUCAS FREITAS：什么是第一件事情
我们也许应该在这里做？

1202
00:59:04,900 --> 00:59:07,010
你们有什么想法？

1203
00:59:07,010 --> 00:59:08,260
>> 观众：[听不清]

1204
00:59:08,260 --> 00:59:12,060

1205
00:59:12,060 --> 00:59:13,290
>> LUCAS FREITAS：是的，确定。

1206
00:59:13,290 --> 00:59:16,610
因此，打印。

1207
00:59:16,610 --> 00:59:19,480
只是说在打印这个平均值
人数？

1208
00:59:19,480 --> 00:59:20,470
确定。

1209
00:59:20,470 --> 00:59:23,450
打印的问题，让我们说。

1210
00:59:23,450 --> 00:59:25,951
之后我打印这个问题，
我该怎么办？

1211
00:59:25,951 --> 00:59:27,875
>> 观众：获取输入。

1212
00:59:27,875 --> 00:59:30,690
>> LUCAS FREITAS：获取输入。

1213
00:59:30,690 --> 00:59:32,864
还有别的吗？

1214
00:59:32,864 --> 00:59:34,114
>> 观众：条件。

1215
00:59:34,114 --> 00:59:36,770

1216
00:59:36,770 --> 00:59:38,980
>> LUCAS FREITAS：条件。

1217
00:59:38,980 --> 00:59:41,325
>> LAUREN卡瓦略：那是什么
情况会是什么？

1218
00:59:41,325 --> 00:59:43,550
>> 观众：中[听不清]的数量。

1219
00:59:43,550 --> 00:59:44,440
>> LAUREN卡瓦略：对。

1220
00:59:44,440 --> 00:59:46,945
>> LUCAS FREITAS：那么我该怎么
检查的条件？

1221
00:59:46,945 --> 00:59:48,750
>> 观众：如果它等于2。

1222
00:59:48,750 --> 00:59:50,640
>> Lauren的CARVALHO：如果它等于2。

1223
00:59:50,640 --> 00:59:51,890
没错。

1224
00:59:51,890 --> 00:59:58,340

1225
00:59:58,340 --> 01:00:00,140
>> LUCAS FREITAS：这有什么
否则，我应该怎么办？

1226
01:00:00,140 --> 01:00:01,390
>> 观众：计数。

1227
01:00:01,390 --> 01:00:05,184

1228
01:00:05,184 --> 01:00:08,110
>> LUCAS FREITAS：所以，如果它是
等于2，让我们说 - 

1229
01:00:08,110 --> 01:00:14,250

1230
01:00:14,250 --> 01:00:17,960
让我写，如果输入等于
2，然后我什么都

1231
01:00:17,960 --> 01:00:23,665
需要做的就是正确的。

1232
01:00:23,665 --> 01:00:26,230

1233
01:00:26,230 --> 01:00:31,826
然后别人，我要去
打印不正确。

1234
01:00:31,826 --> 01:00:34,600

1235
01:00:34,600 --> 01:00:37,720
还有别的吗？

1236
01:00:37,720 --> 01:00:38,670
没有？

1237
01:00:38,670 --> 01:00:40,500
>> LAUREN卡瓦略：所以你
可以点击 - 

1238
01:00:40,500 --> 01:00:42,290
每个人都拥有这样下来？

1239
01:00:42,290 --> 01:00:44,680
>> LUCAS FREITAS：这是否有意义？

1240
01:00:44,680 --> 01:00:46,226
所以，现在让我们尝试编写这一点。

1241
01:00:46,226 --> 01:00:50,140
>> LAUREN卡瓦略：如果您按一下小
箭头，它实际上可以节省您的

1242
01:00:50,140 --> 01:00:51,900
伪代码，这实在是令人振奋的。

1243
01:00:51,900 --> 01:00:56,480
你可以让那些为注释如果
你要只是为了提醒自己

1244
01:00:56,480 --> 01:00:57,075
该怎么做。

1245
01:00:57,075 --> 01:01:01,555
>> LUCAS FREITAS：因此，例如，第一
我要打印的问题，所以

1246
01:01:01,555 --> 01:01:05,930
我应该如何去做到这一点，其实？

1247
01:01:05,930 --> 01:01:07,050
printf的。

1248
01:01:07,050 --> 01:01:12,130
所以printf的，问题是平均
每个儿童的数量

1249
01:01:12,130 --> 01:01:14,110
家人在美国。

1250
01:01:14,110 --> 01:01:19,070

1251
01:01:19,070 --> 01:01:21,790
>> 然后我会得到
来自用户的输入。

1252
01:01:21,790 --> 01:01:29,050

1253
01:01:29,050 --> 01:01:31,324
我那么如何才能做到这一点？

1254
01:01:31,324 --> 01:01:32,200
>> 观众：找诠释。

1255
01:01:32,200 --> 01:01:33,076
>> LAUREN卡瓦略：调用getInt。

1256
01:01:33,076 --> 01:01:33,890
>> LUCAS FREITAS：确定。

1257
01:01:33,890 --> 01:01:35,220
所以先声明，对不对？

1258
01:01:35,220 --> 01:01:39,300
整型，姑且称之为n等于调用getInt。

1259
01:01:39,300 --> 01:01:42,610

1260
01:01:42,610 --> 01:01:44,670
>> 而现在的情况。

1261
01:01:44,670 --> 01:01:49,250
所以，让我说，我要去
来看看这里的答案。

1262
01:01:49,250 --> 01:01:57,290
因此，首先，如果输入，这为n，等于
到 - 我应该如何去写呢？

1263
01:01:57,290 --> 01:01:58,480
>> 观众：平等相等。

1264
01:01:58,480 --> 01:02:00,000
>> LUCAS FREITAS：完美。

1265
01:02:00,000 --> 01:02:00,670
因此n。

1266
01:02:00,670 --> 01:02:04,600
并请注意，我做一个空间，
等于，等于，空间，真实的。

1267
01:02:04,600 --> 01:02:06,930
现在我该怎么办？

1268
01:02:06,930 --> 01:02:08,820
东西的风格很重要。

1269
01:02:08,820 --> 01:02:10,070
大括号。

1270
01:02:10,070 --> 01:02:16,570

1271
01:02:16,570 --> 01:02:17,795
>> 然后我去打印。

1272
01:02:17,795 --> 01:02:19,790
如何打印？

1273
01:02:19,790 --> 01:02:22,500
printf的。

1274
01:02:22,500 --> 01:02:24,568
>> 观众：难道资本化？

1275
01:02:24,568 --> 01:02:27,166

1276
01:02:27,166 --> 01:02:28,380
>> LUCAS FREITAS：号

1277
01:02:28,380 --> 01:02:31,000
它应该全部小写。

1278
01:02:31,000 --> 01:02:32,250
所以这是正确的。

1279
01:02:32,250 --> 01:02:40,990

1280
01:02:40,990 --> 01:02:44,870
>> 请问这足以令​​的printf
语句，还是我缺少什么？

1281
01:02:44,870 --> 01:02:46,265
>> 观众：新线。

1282
01:02:46,265 --> 01:02:50,220
>> LUCAS FREITAS：新线，是的。

1283
01:02:50,220 --> 01:02:51,250
现在别的。

1284
01:02:51,250 --> 01:02:57,290
>> 观众：是否有空间
中的printf后，还是没有呢？

1285
01:02:57,290 --> 01:03:00,820
>> LAUREN卡瓦略：我们应该
检查风格指南。

1286
01:03:00,820 --> 01:03:02,260
>> 观众：它不应该。

1287
01:03:02,260 --> 01:03:03,510
>> LUCAS FREITAS：应该不是，确定。

1288
01:03:03,510 --> 01:03:05,820

1289
01:03:05,820 --> 01:03:13,605
所以别的，printf的，“这是不正确的。”

1290
01:03:13,605 --> 01:03:17,105
>> LAUREN卡瓦略：哎呀，你的报价。

1291
01:03:17,105 --> 01:03:17,950
>> LUCAS FREITAS：确定。

1292
01:03:17,950 --> 01:03:18,600
还有别的吗？

1293
01:03:18,600 --> 01:03:20,770
它是否好看？

1294
01:03:20,770 --> 01:03:21,890
>> LAUREN卡瓦略：大家试试吧？

1295
01:03:21,890 --> 01:03:23,190
>> LUCAS FREITAS：是啊，让我们来运行它。

1296
01:03:23,190 --> 01:03:25,880

1297
01:03:25,880 --> 01:03:29,070
所以它的编译，并将其
看来，它的工作原理。

1298
01:03:29,070 --> 01:03:31,465
让我们尝试两个孩子。

1299
01:03:31,465 --> 01:03:34,110
这是正确的。

1300
01:03:34,110 --> 01:03:37,300
现在让我们再次运行，但现在反而
把两个孩子，让我们的

1301
01:03:37,300 --> 01:03:40,990
说，我要去把像5。

1302
01:03:40,990 --> 01:03:41,515
这是不正确的。

1303
01:03:41,515 --> 01:03:42,670
如此看来，它的工作原理。

1304
01:03:42,670 --> 01:03:44,160
>> LAUREN卡瓦略：你为什么不向他们展示
如果你把东西会发生什么

1305
01:03:44,160 --> 01:03:45,055
奇怪，像一些字母。

1306
01:03:45,055 --> 01:03:45,790
>> LUCAS FREITAS：哦，是的。

1307
01:03:45,790 --> 01:03:47,430
让我们也检查。

1308
01:03:47,430 --> 01:03:51,170
如果什么用户试图一塌糊涂
与你的程序，他们只是

1309
01:03:51,170 --> 01:03:57,430
写的，我不知道两。

1310
01:03:57,430 --> 01:03:58,320
它会说重试。

1311
01:03:58,320 --> 01:04:00,780
>> LAUREN卡瓦略：所以调用getInt
是要求他们重试。

1312
01:04:00,780 --> 01:04:02,115
我们没有照顾
那我们自己。

1313
01:04:02,115 --> 01:04:02,750
>> LUCAS FREITAS：是啊。

1314
01:04:02,750 --> 01:04:06,853
所以，除非我居然把一个数字，它是
要不断地问我重试。

1315
01:04:06,853 --> 01:04:08,330
>> 观众：你是怎么运行呢？

1316
01:04:08,330 --> 01:04:10,570
>> LUCAS FREITAS：只要按一下
这个星号按钮。

1317
01:04:10,570 --> 01:04:11,940
>> LAUREN卡瓦略：你应该上去。

1318
01:04:11,940 --> 01:04:13,320
你去那里。

1319
01:04:13,320 --> 01:04:15,550
>> LUCAS FREITAS：星形
按钮就在那里。

1320
01:04:15,550 --> 01:04:16,040
是吗？

1321
01:04:16,040 --> 01:04:19,960
>> 观众：是否提示[听不清]
与十进制数吗？

1322
01:04:19,960 --> 01:04:21,235
>> LAUREN卡瓦略：我相信会的。

1323
01:04:21,235 --> 01:04:22,660
>> LUCAS FREITAS：如果它做什么？

1324
01:04:22,660 --> 01:04:24,990
>> LAUREN卡瓦略：如果他们输入
在一个十进制数，我觉得

1325
01:04:24,990 --> 01:04:25,880
它会提示。

1326
01:04:25,880 --> 01:04:26,586
>> LUCAS FREITAS：让我们来看看。

1327
01:04:26,586 --> 01:04:28,360
>> LAUREN卡瓦略：因为
它不是一个int。

1328
01:04:28,360 --> 01:04:32,056

1329
01:04:32,056 --> 01:04:33,442
>> LUCAS FREITAS：是啊。

1330
01:04:33,442 --> 01:04:37,370
>> LAUREN卡瓦略：所以它不是一个int，
得到诠释将要求您重试。

1331
01:04:37,370 --> 01:04:40,795
>> 观众：那么，在该代码将
提示的小数位

1332
01:04:40,795 --> 01:04:46,005
用户，他们必须输入
一个整数，具体一点吗？

1333
01:04:46,005 --> 01:04:48,480
>> LAUREN卡瓦略：调用getInt实际上是
这样做，对我们来说。

1334
01:04:48,480 --> 01:04:50,600
>> 观众：不是，我的意思是，如果我们想
进入[听不清]

1335
01:04:50,600 --> 01:04:55,070
>> LUCAS FREITAS：你可以说像平均
在美国的子女数。

1336
01:04:55,070 --> 01:04:56,120
我不知道。

1337
01:04:56,120 --> 01:05:01,761
我们可以说，例如，“请
输入的整数。“

1338
01:05:01,761 --> 01:05:04,270
>> LAUREN卡瓦略：一个整数，等于
到的平均数目。

1339
01:05:04,270 --> 01:05:06,190
我的意思是，它只是如何
你话呢，对吧？

1340
01:05:06,190 --> 01:05:06,520
>> LUCAS FREITAS：是啊。

1341
01:05:06,520 --> 01:05:08,420
这实际上是不可能的编码的一部分。

1342
01:05:08,420 --> 01:05:11,000
它是更多的像什么
你会想

1343
01:05:11,000 --> 01:05:13,987
写在你的程序。

1344
01:05:13,987 --> 01:05:17,723
>> 观众：怎么会，我们已经运行它，如果它
实际上是在gedit中[听不清]。

1345
01:05:17,723 --> 01:05:19,130
而不是压着打？

1346
01:05:19,130 --> 01:05:21,180
>> LUCAS FREITAS：我们会
首先编译它。

1347
01:05:21,180 --> 01:05:25,080
我们可以通过做凑合吧
和该文件的名称。

1348
01:05:25,080 --> 01:05:29,896
然后运行它，我们会做点斜线
和该程序的名称。

1349
01:05:29,896 --> 01:05:36,588
>> 观众：我想我的意思是，如果
我们希望该方案以应对

1350
01:05:36,588 --> 01:05:42,010
他们不正确，无效的条目，
你不应该把 - 

1351
01:05:42,010 --> 01:05:45,710
>> LUCAS FREITAS：我们将无法
做到这一点，因为这个代码表示

1352
01:05:45,710 --> 01:05:50,350
重试来自获取诠释其是
一个已经实现的功能

1353
01:05:50,350 --> 01:05:55,790
我们通过CS50库，并且由于
它已经实现在那里，我们

1354
01:05:55,790 --> 01:05:58,340
不能随便[听不清]。

1355
01:05:58,340 --> 01:06:00,780
>> LAUREN卡瓦略：如果你不使用
调用getInt，那么你就可以做到这一点。

1356
01:06:00,780 --> 01:06:01,490
>> LUCAS FREITAS：是啊。

1357
01:06:01,490 --> 01:06:03,750
但是，如果你使用的是调用getInt，你不能。

1358
01:06:03,750 --> 01:06:05,427
还有没有其他问题？

1359
01:06:05,427 --> 01:06:12,938
>> 观众：请问您去与像
GetFloat然后能够把

1360
01:06:12,938 --> 01:06:14,381
它在一个小数？

1361
01:06:14,381 --> 01:06:15,343
>> LUCAS FREITAS：是啊。

1362
01:06:15,343 --> 01:06:15,824
>> 观众：确定。

1363
01:06:15,824 --> 01:06:19,210
然后你只需输入能
飘起了一个等号 - 

1364
01:06:19,210 --> 01:06:19,950
>> LAUREN卡瓦略：是啊。

1365
01:06:19,950 --> 01:06:22,740
除了一个完全相同的
浮而不是一个int。

1366
01:06:22,740 --> 01:06:27,372
>> LUCAS FREITAS：只要把它放在这里
然后GetFloat那里。

1367
01:06:27,372 --> 01:06:29,795
>> 观众：当你将
看到或已经看到 - 

1368
01:06:29,795 --> 01:06:31,327
>> LAUREN卡瓦略：我们有
没有得到那里。

1369
01:06:31,327 --> 01:06:36,490
>> 观众： - 做与不平等
花车不[听不清]

1370
01:06:36,490 --> 01:06:40,290
>> 观众：是什么分号是什么意思？

1371
01:06:40,290 --> 01:06:43,220
>> LAUREN卡瓦略：分号刚
也就是说，这种说法是完整的，

1372
01:06:43,220 --> 01:06:45,030
我们打​​算去
到下一张幻灯片。

1373
01:06:45,030 --> 01:06:47,040
>> 观众：所以这是必要的
每一次？

1374
01:06:47,040 --> 01:06:48,330
>> LAUREN卡瓦略：是啊。

1375
01:06:48,330 --> 01:06:53,130
好了，好了，没有这些条件，
因为他们是

1376
01:06:53,130 --> 01:06:54,090
封装的东西。

1377
01:06:54,090 --> 01:07:00,290
所以基本上，如果事情是造成
你再创建一个大括号

1378
01:07:00,290 --> 01:07:03,000
块，不要把一个分号
在末端。

1379
01:07:03,000 --> 01:07:04,200
>> LUCAS FREITAS：但是，一切都
否则，是的。

1380
01:07:04,200 --> 01:07:06,670
当你完成一项声明，
把分号。

1381
01:07:06,670 --> 01:07:10,380
如果你忘了分号，则
编译器会得到你生气，

1382
01:07:10,380 --> 01:07:12,640
而你将不得不
以尝试修复它。

1383
01:07:12,640 --> 01:07:16,520
>> LAUREN卡瓦略：如果我把一个分号
在这里，将停止这一点，我

1384
01:07:16,520 --> 01:07:18,780
永远不会得到执行什么
内，通过的方式。

1385
01:07:18,780 --> 01:07:21,113
所以它的那些常见的错误之一。

1386
01:07:21,113 --> 01:07:22,390
>> 观众：始终执行。

1387
01:07:22,390 --> 01:07:22,950
>> LAUREN卡瓦略：是啊。

1388
01:07:22,950 --> 01:07:25,860
在这种情况下，我们总是
执行里面有什么。

1389
01:07:25,860 --> 01:07:29,050
>> 观众：你的风格[听不清]
附加的你，想过。

1390
01:07:29,050 --> 01:07:29,802
>> LAUREN卡瓦略：哦，这是真的。

1391
01:07:29,802 --> 01:07:34,298
>> 观众：[听不清]单
行的事[听不清]

1392
01:07:34,298 --> 01:07:35,286
>> 观众：是的？

1393
01:07:35,286 --> 01:07:37,756
>> 观众：你可以有多个
在一个线路输入？

1394
01:07:37,756 --> 01:07:41,214
所以像你可以问用户
打印两件事？

1395
01:07:41,214 --> 01:07:42,530
>> LAUREN卡瓦略：不使用 - 

1396
01:07:42,530 --> 01:07:44,520
>> LUCAS FREITAS：号

1397
01:07:44,520 --> 01:07:47,040
比方说，我也想
得到这个整数米。

1398
01:07:47,040 --> 01:07:49,558
我必须这样做，在不同的线路。

1399
01:07:49,558 --> 01:07:54,992
>> 观众：如果你要运行
即，如何[听不清]？

1400
01:07:54,992 --> 01:07:59,438
这将打印的提示
有[听不清]

1401
01:07:59,438 --> 01:08:00,940
然后你会进入一个， - 

1402
01:08:00,940 --> 01:08:01,840
>> LAUREN卡瓦略：嗯，运行它。

1403
01:08:01,840 --> 01:08:04,365
我的意思是，没有什么从阻止我们
只需运行它，看到什么

1404
01:08:04,365 --> 01:08:06,610
会发生什么。

1405
01:08:06,610 --> 01:08:08,080
>> LUCAS FREITAS：我认为这是
要在抱怨我们

1406
01:08:08,080 --> 01:08:08,977
因为我们没有使用 - 

1407
01:08:08,977 --> 01:08:09,751
>> LAUREN卡瓦略：哎呀。

1408
01:08:09,751 --> 01:08:12,580
>> LUCAS FREITAS：它在抱怨我们的权利
现在，因为我们没有使用这个

1409
01:08:12,580 --> 01:08:21,640
可变的，但如果我这样做，例如，
n是等于等于，和m等于

1410
01:08:21,640 --> 01:08:26,849
等于，那么会出现什么
发生这种情况？

1411
01:08:26,849 --> 01:08:28,830
什么这个节目吗？

1412
01:08:28,830 --> 01:08:30,330
>> 观众：我只是想知道
它怎么会 - 

1413
01:08:30,330 --> 01:08:31,550
>> LAUREN卡瓦略：她只是想
要知道它的外观

1414
01:08:31,550 --> 01:08:34,189
像，我想，对不对？

1415
01:08:34,189 --> 01:08:36,819
于是花了其中之一，然后
它采取了第二个。

1416
01:08:36,819 --> 01:08:41,279

1417
01:08:41,279 --> 01:08:43,069
>> 我认为我们应该继续前进，
因为我们多了一个

1418
01:08:43,069 --> 01:08:44,689
幻灯片放映去之前 - 

1419
01:08:44,689 --> 01:08:46,269
你要拉起来的数学？

1420
01:08:46,269 --> 01:08:47,558
>> LUCAS FREITAS：是啊，数学。

1421
01:08:47,558 --> 01:09:00,033

1422
01:09:00,033 --> 01:09:02,206
>> LAUREN卡瓦略：给
我只是一秒钟。

1423
01:09:02,206 --> 01:09:07,390

1424
01:09:07,390 --> 01:09:14,260
>> 有几个不同的数值
在C C.数值数据变量

1425
01:09:14,260 --> 01:09:18,130
可以分为不同的类型，
而这些是那些你会

1426
01:09:18,130 --> 01:09:19,570
看到最频繁。

1427
01:09:19,570 --> 01:09:20,910
>> 和int是整数。

1428
01:09:20,910 --> 01:09:23,189
你不能有任何小数。

1429
01:09:23,189 --> 01:09:27,754
在电器，它需要
32位来存储一个int。

1430
01:09:27,754 --> 01:09:30,450
>> 一个浮点可以有小数。

1431
01:09:30,450 --> 01:09:34,330
它也需要32位来存储
一个漂浮在电器。

1432
01:09:34,330 --> 01:09:42,270
>> 双是一个数字带小数
点需要64位来存储它，

1433
01:09:42,270 --> 01:09:44,470
这意味着你可以有
更高的精确度，因为

1434
01:09:44,470 --> 01:09:46,426
你可以有更多的 - 

1435
01:09:46,426 --> 01:09:47,785
你怎么称呼它？

1436
01:09:47,785 --> 01:09:48,640
>> LUCAS FREITAS：是啊，这更多。

1437
01:09:48,640 --> 01:09:52,140
>> LAUREN卡瓦略：更多地方
小数点后。

1438
01:09:52,140 --> 01:09:57,140
和久长是一个整数
这需要64位

1439
01:09:57,140 --> 01:09:58,395
其疼痛的电器。

1440
01:09:58,395 --> 01:10:00,278
>> LUCAS FREITAS：所以它可以
比整数大即可。

1441
01:10:00,278 --> 01:10:03,320

1442
01:10:03,320 --> 01:10:08,380
>> LAUREN卡瓦略：关于数据的东西
C语言的类型是，他们告诉你什么

1443
01:10:08,380 --> 01:10:11,050
样的数据可以存储
在您的变量。

1444
01:10:11,050 --> 01:10:15,860
他们会告诉你如何使用这个
变量在你的程序。

1445
01:10:15,860 --> 01:10:19,650
这是非常重要的，只是跟踪
什么样的数据类型，你正在使用的，如果

1446
01:10:19,650 --> 01:10:23,070
你需要转换从一个数据类型
另一个，确保你知道

1447
01:10:23,070 --> 01:10:25,250
究竟发生了什么时
铸造发生。

1448
01:10:25,250 --> 01:10:28,520
你会看到一个例子后
在上一这些幻灯片

1449
01:10:28,520 --> 01:10:31,490
错误可能发生。

1450
01:10:31,490 --> 01:10:35,300
>> 让我们来看看C语言的一些数学和
觉得真的很用心，我猜，

1451
01:10:35,300 --> 01:10:38,470
这是怎么回事就当这
数学正在发生。

1452
01:10:38,470 --> 01:10:43,552
在第一行，有什么
发生的事情时，我x声明？

1453
01:10:43,552 --> 01:10:48,921
>> 观众：你让
X要的东西？

1454
01:10:48,921 --> 01:10:49,700
>> LAUREN卡瓦略：是啊。

1455
01:10:49,700 --> 01:10:54,040
好吧，我真的问工作
系统为32位的内存，对不对？

1456
01:10:54,040 --> 01:10:57,890
我在其中可以存储一个int，并
我要调用诠释x。

1457
01:10:57,890 --> 01:11:01,370
>> LUCAS FREITAS：基本上会在内存中
并发现有32个地方

1458
01:11:01,370 --> 01:11:05,290
位和说法，哎，我想这个空间，
它的将是名为x。

1459
01:11:05,290 --> 01:11:08,590
所以，你只是相当多的发现
在你的记忆的盒子

1460
01:11:08,590 --> 01:11:10,440
存储值对于x。

1461
01:11:10,440 --> 01:11:13,980
>> LAUREN卡瓦略：然后我初始化
x，它意味着，我只是存储

1462
01:11:13,980 --> 01:11:20,270
2在那个地方，那个块的价值
内存，我们问经营

1463
01:11:20,270 --> 01:11:21,860
制度。

1464
01:11:21,860 --> 01:11:25,090
而这儿正是我们正在做的是
我们实际上并声明

1465
01:11:25,090 --> 01:11:29,060
在一行中初始化Ÿ代替
在两行像我们一样在这里，

1466
01:11:29,060 --> 01:11:33,960
这也是一个完美的罚款，我们是
加1到x，和我们的存储

1467
01:11:33,960 --> 01:11:34,950
在y值。

1468
01:11:34,950 --> 01:11:39,360
>> LUCAS FREITAS：所以基本上这是什么
行呢，它现在发现一个盒子Y，

1469
01:11:39,360 --> 01:11:41,990
然后将其值，在东西
你打算把箱子里面，是

1470
01:11:41,990 --> 01:11:43,800
将是x的值加1。

1471
01:11:43,800 --> 01:11:45,850
所以它有这个方块年。

1472
01:11:45,850 --> 01:11:49,980
它得到x的值，看起来
在这里，看看它的2。

1473
01:11:49,980 --> 01:11:53,035
把它放在那里，加1，所以
它把一个3那里。

1474
01:11:53,035 --> 01:11:54,290
这是否有道理？

1475
01:11:54,290 --> 01:11:55,780
所以y是2在这种情况下。

1476
01:11:55,780 --> 01:11:58,993

1477
01:11:58,993 --> 01:12:00,770
>> LAUREN卡瓦略：好吧，冷静。

1478
01:12:00,770 --> 01:12:06,010
我们看到了一些另外，让我们觉得现在
关于分工。这里我

1479
01:12:06,010 --> 01:12:11,490
声明和初始化一个浮点
所谓的答案，1除以10，

1480
01:12:11,490 --> 01:12:14,860
然后我打印出来的答案
到小数点后两位。

1481
01:12:14,860 --> 01:12:18,800
并注意在这里，在我的printf语句，
当我想打印的东西两

1482
01:12:18,800 --> 01:12:25,600
小数位，％.2 f是
我想用。

1483
01:12:25,600 --> 01:12:28,880

1484
01:12:28,880 --> 01:12:31,760
因此，问题2只是说
我需要经过两地

1485
01:12:31,760 --> 01:12:34,980
十进制打印出来。

1486
01:12:34,980 --> 01:12:38,740
>> 现在，什么事情要发生
如果我运行这个代码？

1487
01:12:38,740 --> 01:12:40,500
有没有人有一个想法？

1488
01:12:40,500 --> 01:12:42,721
你会打印出来？

1489
01:12:42,721 --> 01:12:45,010
>> LUCAS FREITAS：什么是
我们期望得到的。

1490
01:12:45,010 --> 01:12:46,810
>> LAUREN卡瓦略：做什么
我们想，首先？

1491
01:12:46,810 --> 01:12:48,871
>> LUCAS FREITAS：[听不清]

1492
01:12:48,871 --> 01:12:51,120
>> LAUREN卡瓦略：0.1，是的。

1493
01:12:51,120 --> 01:12:52,325
但是，会打印出？

1494
01:12:52,325 --> 01:12:53,275
>> 观众：[听不清]

1495
01:12:53,275 --> 01:12:56,760
>> LAUREN卡瓦略：哦，不，其实。

1496
01:12:56,760 --> 01:13:01,400
这就是我说的是你为什么
需要保持非常谨慎的轨道

1497
01:13:01,400 --> 01:13:02,550
您的数据类型。

1498
01:13:02,550 --> 01:13:05,000
那么，什么样的数据类型是什么？

1499
01:13:05,000 --> 01:13:06,250
是一个int，对不对？

1500
01:13:06,250 --> 01:13:07,600
有没有小数位。

1501
01:13:07,600 --> 01:13:08,770
10也是一个int。

1502
01:13:08,770 --> 01:13:09,930
有没有小数位。

1503
01:13:09,930 --> 01:13:15,770
>> 如果我把一个int一个int，我得到一个
INT这是不是0.1的，因为整型

1504
01:13:15,770 --> 01:13:18,630
不能有小数位，但只是0。

1505
01:13:18,630 --> 01:13:21,005
由于int只是截断
关闭小数。

1506
01:13:21,005 --> 01:13:24,280
>> LUCAS FREITAS：所以每当你做
与整数运算，你要

1507
01:13:24,280 --> 01:13:25,990
得到一个int作为答案。

1508
01:13:25,990 --> 01:13:28,930
因此，基本上，什么样的电脑
是干什么的，它的划分由1

1509
01:13:28,930 --> 01:13:31,520
10，连带0.1。

1510
01:13:31,520 --> 01:13:34,870
但随后的样子，等待，这是
应该是一个整数，所以你只要

1511
01:13:34,870 --> 01:13:37,045
忽略了0.1，所以它现在只是0。

1512
01:13:37,045 --> 01:13:41,782
>> LAUREN卡瓦略：所以，当我打印这个
出来，我得到0.00，而不是0.10。

1513
01:13:41,782 --> 01:13:44,075
>> LUCAS FREITAS：这是否有道理？

1514
01:13:44,075 --> 01:13:45,530
>> LAUREN卡瓦略：这是一种
不幸的，对不对？

1515
01:13:45,530 --> 01:13:47,290
>> LUCAS FREITAS：我们那么如何才能解决这个问题？

1516
01:13:47,290 --> 01:13:48,620
>> LAUREN卡瓦略：让我们
尝试解决这个问题。

1517
01:13:48,620 --> 01:13:51,570

1518
01:13:51,570 --> 01:13:54,810
这里是哪里，我的例子
实际上铸造1

1519
01:13:54,810 --> 01:13:56,650
和10至浮动。

1520
01:13:56,650 --> 01:13:58,800
所以，现在，1已不再是一个int。

1521
01:13:58,800 --> 01:14:00,020
1是一个浮点数。

1522
01:14:00,020 --> 01:14:02,590
顺便说一句，这仅仅是个语法
当你想投的一个用于

1523
01:14:02,590 --> 01:14:03,410
数据类型到另一个。

1524
01:14:03,410 --> 01:14:07,140
你可以把数据类型
括号和有刚刚之前

1525
01:14:07,140 --> 01:14:10,860
您正在铸造的值。

1526
01:14:10,860 --> 01:14:15,800
>> 所以在这里，我把一个浮点数由
花车得到一个浮动的答案。

1527
01:14:15,800 --> 01:14:19,535
是的，这将在
事实上打印0.10。

1528
01:14:19,535 --> 01:14:20,470
这是否有道理？

1529
01:14:20,470 --> 01:14:24,110
>> LUCAS FREITAS：所以类型转换只是
从一种类型转换到另一边。

1530
01:14:24,110 --> 01:14:29,460
因此，浮动1实际上是1.000。

1531
01:14:29,460 --> 01:14:33,400
不完全是这样，但是它的东西
带小数位

1532
01:14:33,400 --> 01:14:34,715
这实际上是1。

1533
01:14:34,715 --> 01:14:35,960
这是否有道理？

1534
01:14:35,960 --> 01:14:36,260
是吗？

1535
01:14:36,260 --> 01:14:40,990
>> 观众：如果你没有浮答案
等于1.0除以10？

1536
01:14:40,990 --> 01:14:43,940
>> LAUREN卡瓦略：你究竟要
一看就知道下一张幻灯片。

1537
01:14:43,940 --> 01:14:47,150
这实际上是我们非常下一张幻灯片。

1538
01:14:47,150 --> 01:14:50,740
这实际上是一个更好的比
类型转换，我想。

1539
01:14:50,740 --> 01:14:53,470
因此，这两个是刚彩车通过
的事实性质，它们

1540
01:14:53,470 --> 01:14:54,926
有小数位。

1541
01:14:54,926 --> 01:14:55,300
是吗？

1542
01:14:55,300 --> 01:14:57,670
>> 观众：如果你的所作所为[听不清]

1543
01:14:57,670 --> 01:14:59,480
除以10？

1544
01:14:59,480 --> 01:15:02,270
>> LAUREN卡瓦略：其实一个浮动
一个int划分实际上给你一个

1545
01:15:02,270 --> 01:15:03,670
浮动，这样就会很好地工作。

1546
01:15:03,670 --> 01:15:08,070

1547
01:15:08,070 --> 01:15:09,120
>> 等待，每个人都明白这一点？

1548
01:15:09,120 --> 01:15:12,720
因为这将是一个非常
大不了在PS​​ET1，其实。

1549
01:15:12,720 --> 01:15:13,130
是吗？

1550
01:15:13,130 --> 01:15:14,762
>> 观众：你能不能快
走在红色的部分？

1551
01:15:14,762 --> 01:15:16,380
>> LAUREN卡瓦略：红色部分，是啊。

1552
01:15:16,380 --> 01:15:17,250
卢卡斯，你想？

1553
01:15:17,250 --> 01:15:18,020
>> LUCAS FREITAS：确定。

1554
01:15:18,020 --> 01:15:20,570
因此请记住百分比
是一个占位符。

1555
01:15:20,570 --> 01:15:22,150
这就像一个空格。

1556
01:15:22,150 --> 01:15:26,240
因此，让我们试着去了解一切
这是怎么回事。

1557
01:15:26,240 --> 01:15:28,170
百分比意味着它是一个占位符。

1558
01:15:28,170 --> 01:15:33,640
然后，你必须在F，这意味着
这个占位符是一个浮动。

1559
01:15:33,640 --> 01:15:38,870
我们在这里的最后一件事是
2，这意味着我想有两个

1560
01:15:38,870 --> 01:15:42,410
小数的浮点数。

1561
01:15:42,410 --> 01:15:48,510
>> 如果我刚％F，他们就会把
一堆小数。

1562
01:15:48,510 --> 01:15:54,170
这样我就可以把0.2或0.1或0.5，或
什么，以及它打算把那

1563
01:15:54,170 --> 01:15:55,950
小数位数。

1564
01:15:55,950 --> 01:15:59,950
唯一的一点是，如果你把喜欢
.100或.1,000，它实际上并不是

1565
01:15:59,950 --> 01:16:04,200
打算把所有这些小数
因为它不具有足够的内存

1566
01:16:04,200 --> 01:16:06,432
有这种精度。

1567
01:16:06,432 --> 01:16:07,955
>> 还有没有其他问题？

1568
01:16:07,955 --> 01:16:08,450
是吗？

1569
01:16:08,450 --> 01:16:12,970
>> 观众：所以刚才浮动允许
你要超越的整数？

1570
01:16:12,970 --> 01:16:13,720
>> LUCAS FREITAS：是的。

1571
01:16:13,720 --> 01:16:17,345
>> LAUREN卡瓦略：好了，只是浮
可以让你有小数位。

1572
01:16:17,345 --> 01:16:20,460
>> LUCAS FREITAS：它只是意味着你
现在可以有小数。

1573
01:16:20,460 --> 01:16:25,728
>> 观众：为什么我们
用不完的整数？

1574
01:16:25,728 --> 01:16:27,870
>> LUCAS FREITAS：为什么会
你使用整数？

1575
01:16:27,870 --> 01:16:31,810
也许，如果你是从0数到10，
你想实际使用一个整数。

1576
01:16:31,810 --> 01:16:33,370
你并不需要使用浮点数。

1577
01:16:33,370 --> 01:16:35,430
在某些情况下，你不
有实际 - 

1578
01:16:35,430 --> 01:16:37,040
>> LAUREN卡瓦略：也许你
不想小数。

1579
01:16:37,040 --> 01:16:38,600
>> LUCAS FREITAS：也许你不
想用一个浮点数。

1580
01:16:38,600 --> 01:16:42,660
>> LAUREN卡瓦略：另一件事是，
记住，无论是把一个float和int

1581
01:16:42,660 --> 01:16:46,170
需要32位来存储它们，也许
你不想浪费比特的

1582
01:16:46,170 --> 01:16:48,062
小数位。

1583
01:16:48,062 --> 01:16:49,750
>> LUCAS FREITAS：是啊。

1584
01:16:49,750 --> 01:16:51,910
这么喜欢，只是觉得这个问题。

1585
01:16:51,910 --> 01:16:55,200
你有32位为
一个int和float类型。

1586
01:16:55,200 --> 01:16:59,400
对于一个int，所有这些32位
去的整数部分。

1587
01:16:59,400 --> 01:17:03,460
如果您使用的是浮动32位，你
有正在使用这块内存部分

1588
01:17:03,460 --> 01:17:06,820
对数，为整数，
和正在使用的其它部分

1589
01:17:06,820 --> 01:17:08,300
小数位。

1590
01:17:08,300 --> 01:17:12,370
因此，这意味着，你不能去
非常大的数字用浮漂，因为

1591
01:17:12,370 --> 01:17:16,020
浮动的已经使用了很多
内存为小数位。

1592
01:17:16,020 --> 01:17:17,014
是吗？

1593
01:17:17,014 --> 01:17:21,487
>> 观众：那第一个答案，
它到底是什么做的？

1594
01:17:21,487 --> 01:17:25,214
它是设置浮动平等的价值
该占位符，你可以

1595
01:17:25,214 --> 01:17:26,954
记得在它的下一行？

1596
01:17:26,954 --> 01:17:28,942
它说，浮动的答案。

1597
01:17:28,942 --> 01:17:29,770
>> LUCAS FREITAS：是啊。

1598
01:17:29,770 --> 01:17:37,200
因此，浮动的答案意味着你得到
现在有点桶的内存

1599
01:17:37,200 --> 01:17:40,050
持有浮动，这是怎么回事
被称为应答。

1600
01:17:40,050 --> 01:17:42,040
所以，这就是浮动的答案呢。

1601
01:17:42,040 --> 01:17:44,720
>> 然后你说的内
这一点，你要放

1602
01:17:44,720 --> 01:17:46,470
这样做的结果。

1603
01:17:46,470 --> 01:17:52,610
所以你要做1.0除以
10.0，你会得到0.1，然后你把

1604
01:17:52,610 --> 01:17:53,490
这里面的答案。

1605
01:17:53,490 --> 01:17:57,540
>> LAUREN卡瓦略：那么在一行中，我们
声明和初始化这个浮动

1606
01:17:57,540 --> 01:18:00,070
所谓的答案。

1607
01:18:00,070 --> 01:18:04,470
>> LUCAS FREITAS：有趣的是，虽然
这只是一条线，它在做

1608
01:18:04,470 --> 01:18:05,570
多个操作。

1609
01:18:05,570 --> 01:18:08,800
这是Ç出租的只是一种方式
你用更少的代码。

1610
01:18:08,800 --> 01:18:12,310
这是同样的事情三元
运营商，你怎么可以这样做的

1611
01:18:12,310 --> 01:18:13,810
在一行[听不清]。

1612
01:18:13,810 --> 01:18:18,860
它实际上在做同样的事情，
做浮动答案，分号和

1613
01:18:18,860 --> 01:18:23,060
那么答案等于代替这一点，但
让你做两线的，

1614
01:18:23,060 --> 01:18:24,160
它就像一个快捷方式。

1615
01:18:24,160 --> 01:18:24,520
是吗？

1616
01:18:24,520 --> 01:18:27,929
>> 观众：所以，如果你跑了这一点，
这将是0.10？

1617
01:18:27,929 --> 01:18:30,120
>> LUCAS FREITAS：是的。

1618
01:18:30,120 --> 01:18:30,530
是吗？

1619
01:18:30,530 --> 01:18:34,540
>> 观众：是回答居然代码，
或者是它只是叫什么名字？

1620
01:18:34,540 --> 01:18:36,010
>> LAUREN卡瓦略：这
实际上是代码。

1621
01:18:36,010 --> 01:18:37,750
这就是我们要去
来命名我们的变量。

1622
01:18:37,750 --> 01:18:39,770
>> 观众：所以这只是
名称[听不清]。

1623
01:18:39,770 --> 01:18:40,270
>> LAUREN卡瓦略：是啊。

1624
01:18:40,270 --> 01:18:44,670
我可以说浮x等于1.0。

1625
01:18:44,670 --> 01:18:47,160
>> LUCAS FREITAS：问题是，
变量的名称是

1626
01:18:47,160 --> 01:18:48,400
您使用的东西。

1627
01:18:48,400 --> 01:18:49,690
这是对你很重要。

1628
01:18:49,690 --> 01:18:52,660
对于实际的程序，唯一
该事项是价值，你

1629
01:18:52,660 --> 01:18:55,570
有桶的内部。

1630
01:18:55,570 --> 01:18:59,270
为什么你有变量和的原因
变量名是这样你就会知道

1631
01:18:59,270 --> 01:19:01,910
你处​​理的，像什么
你是什​​么样的数据

1632
01:19:01,910 --> 01:19:03,040
访问的时间。

1633
01:19:03,040 --> 01:19:07,580
但代码本身，如果你调用
它回答或提问或任何东西，

1634
01:19:07,580 --> 01:19:09,530
漂亮多了，也没关系。

1635
01:19:09,530 --> 01:19:10,060
不要紧

1636
01:19:10,060 --> 01:19:12,910
只要你在每一个一致
它的发生，所​​以你叫它

1637
01:19:12,910 --> 01:19:13,620
别的东西。

1638
01:19:13,620 --> 01:19:14,880
是吗？

1639
01:19:14,880 --> 01:19:17,208
>> 观众：执行变量
超越函数？

1640
01:19:17,208 --> 01:19:20,902
就像如果你要创建一个支架
[听不清]，可能你只是

1641
01:19:20,902 --> 01:19:21,806
[听不清]再回答？

1642
01:19:21,806 --> 01:19:22,550
>> LAUREN卡瓦略：号

1643
01:19:22,550 --> 01:19:23,300
>> 观众：[听不清]

1644
01:19:23,300 --> 01:19:24,200
>> LAUREN卡瓦略：号

1645
01:19:24,200 --> 01:19:26,930
这将是在范围之外
这个特殊的变量。

1646
01:19:26,930 --> 01:19:29,940
而实际上，这是一种
有趣，因为当我们有

1647
01:19:29,940 --> 01:19:33,010
之类的东西循环或如果这些
条件下，如果你声明一个变量

1648
01:19:33,010 --> 01:19:36,330
在另一组大括号，
它真的只存在

1649
01:19:36,330 --> 01:19:39,800
在这些大括号。

1650
01:19:39,800 --> 01:19:43,088
>> 观众：最后一个音符左右
在[听不清]花车。

1651
01:19:43,088 --> 01:19:46,076
为什么你想使用整数？

1652
01:19:46,076 --> 01:19:49,562
这更是一个侧面说明比
任何事情，但你的电脑

1653
01:19:49,562 --> 01:19:53,048
显著更好地处理整数
比它在处理浮点数。

1654
01:19:53,048 --> 01:19:55,040
这就像一个数量级
幅度更快。

1655
01:19:55,040 --> 01:20:00,360
因此，如果我们仅仅只处理了花车，
事情会是慢了很多。

1656
01:20:00,360 --> 01:20:03,080
>> LAUREN卡瓦略：其实，似乎有
要与花车的一个问题。

1657
01:20:03,080 --> 01:20:06,400
>> LUCAS FREITAS：类的原因
这一点，你能想到，就是如何以二进制

1658
01:20:06,400 --> 01:20:08,480
你可以表示整数
通过将0和1的。

1659
01:20:08,480 --> 01:20:09,980
>> LAUREN卡瓦略：这是
接下来的事情。

1660
01:20:09,980 --> 01:20:10,480
>> LUCAS FREITAS：确定。

1661
01:20:10,480 --> 01:20:10,740
真棒。

1662
01:20:10,740 --> 01:20:11,480
>> LAUREN卡瓦略：只是
持有这种想法。

1663
01:20:11,480 --> 01:20:13,800
>> LUCAS FREITAS：好的，我会
以后告诉你。

1664
01:20:13,800 --> 01:20:16,920
>> LAUREN卡瓦略：在我们到达什么
卢卡斯只是说，运营商

1665
01:20:16,920 --> 01:20:17,420
优先。

1666
01:20:17,420 --> 01:20:18,220
这是常识。

1667
01:20:18,220 --> 01:20:20,830
你们这样做就够了。

1668
01:20:20,830 --> 01:20:24,705
所以，只要有什么东西是在括号中，
它会先发生。

1669
01:20:24,705 --> 01:20:27,970
这是乘法的优先级
在此外，

1670
01:20:27,970 --> 01:20:30,330
减法，这样的事情。

1671
01:20:30,330 --> 01:20:34,700
因此，实际上，只是没有人要
告诉我什么头号实际

1672
01:20:34,700 --> 01:20:36,674
计算结果为？

1673
01:20:36,674 --> 01:20:37,638
>> 对象：27。

1674
01:20:37,638 --> 01:20:39,090
>> LAUREN卡瓦略：27？

1675
01:20:39,090 --> 01:20:39,550
是啊。

1676
01:20:39,550 --> 01:20:41,975
>> LUCAS FREITAS：我举
糖果的人。

1677
01:20:41,975 --> 01:20:42,850
>> LAUREN卡瓦略：好吧。

1678
01:20:42,850 --> 01:20:44,100
怎么样二号吗？

1679
01:20:44,100 --> 01:20:46,880

1680
01:20:46,880 --> 01:20:48,340
怎么样二号吗？

1681
01:20:48,340 --> 01:20:49,280
>> 对象：22。

1682
01:20:49,280 --> 01:20:50,680
>> LAUREN卡瓦略：22，是的。

1683
01:20:50,680 --> 01:20:51,570
我不知道谁得到了这一点。

1684
01:20:51,570 --> 01:20:52,694
之三？

1685
01:20:52,694 --> 01:20:54,050
>> 对象：10。

1686
01:20:54,050 --> 01:20:55,300
>> LAUREN卡瓦略：10，是的。

1687
01:20:55,300 --> 01:20:58,150

1688
01:20:58,150 --> 01:20:58,490
凉爽。

1689
01:20:58,490 --> 01:21:01,280
所以模。

1690
01:21:01,280 --> 01:21:03,700
卢卡斯，你想解释模？

1691
01:21:03,700 --> 01:21:07,150
>> LUCAS FREITAS：模数是这样的运营商
这实际上是一个非常有用的

1692
01:21:07,150 --> 01:21:09,470
一堆问题。

1693
01:21:09,470 --> 01:21:15,270
如果我做55模数10，它做什么
这让我们说，我想

1694
01:21:15,270 --> 01:21:16,970
除以10 55。

1695
01:21:16,970 --> 01:21:18,240
我能得到什么？

1696
01:21:18,240 --> 01:21:21,380
这感觉就像如果我实际上只是
这样的划分，什么是

1697
01:21:21,380 --> 01:21:22,450
第一次，我得到了整数？

1698
01:21:22,450 --> 01:21:23,190
>> 对象：5。

1699
01:21:23,190 --> 01:21:24,080
>> LUCAS FREITAS：5。

1700
01:21:24,080 --> 01:21:26,230
然后余数为5，对不对？

1701
01:21:26,230 --> 01:21:29,250
所以它就像5次10加5。

1702
01:21:29,250 --> 01:21:35,570
基本上，它，它会尝试什么模
这个数除以这一个，

1703
01:21:35,570 --> 01:21:37,440
它看到什么是余数
分工。

1704
01:21:37,440 --> 01:21:40,080
>> LAUREN卡瓦略：因此，它只是
返回余数。

1705
01:21:40,080 --> 01:21:41,920
所以，排名第一的是什么？

1706
01:21:41,920 --> 01:21:42,560
5。

1707
01:21:42,560 --> 01:21:43,336
第二？

1708
01:21:43,336 --> 01:21:44,150
>> 对象：3。

1709
01:21:44,150 --> 01:21:44,934
>> Lauren的CARVALHO：3。

1710
01:21:44,934 --> 01:21:46,240
之三？

1711
01:21:46,240 --> 01:21:47,190
0。

1712
01:21:47,190 --> 01:21:48,410
和4是1。

1713
01:21:48,410 --> 01:21:48,665
没错。

1714
01:21:48,665 --> 01:21:49,915
>> LUCAS FREITAS：简单，对不对？

1715
01:21:49,915 --> 01:21:54,270

1716
01:21:54,270 --> 01:21:56,560
>> LAUREN卡瓦略：我们为什么不跳过这
仅仅因为我们没有真正的

1717
01:21:56,560 --> 01:21:59,780
一次，人们似乎明白了。

1718
01:21:59,780 --> 01:22:03,330
因此，这里就是卢卡斯
刚才讲的。

1719
01:22:03,330 --> 01:22:08,030
>> LUCAS FREITAS：另一个原因，我
将使用整数而不是浮点数是

1720
01:22:08,030 --> 01:22:10,840
该花车非常不精确。

1721
01:22:10,840 --> 01:22:12,720
他们为什么不精确？

1722
01:22:12,720 --> 01:22:17,140
大卫说，代表一个整数，
例如，我们使用0和

1723
01:22:17,140 --> 01:22:17,810
1的，对不对？

1724
01:22:17,810 --> 01:22:22,370
然后你基本上做
乘法，做所有这些

1725
01:22:22,370 --> 01:22:30,000
操作要知道什么十进制数
你有代替二进制。

1726
01:22:30,000 --> 01:22:33,040
>> 现在会发生什么，如果我尝试
把小数点？

1727
01:22:33,040 --> 01:22:37,680
事实上，举例来说，如果我有
像3.33333多少？

1728
01:22:37,680 --> 01:22:40,250
这感觉就像10超过3。

1729
01:22:40,250 --> 01:22:44,950
我怎么来存储所有的
3就是我以后有哪些？

1730
01:22:44,950 --> 01:22:47,120
这真的很难，对吧？

1731
01:22:47,120 --> 01:22:49,580
你不能只是告诉电脑，
哎，我有一个3，和

1732
01:22:49,580 --> 01:22:50,520
那么你这样做，直到永远。

1733
01:22:50,520 --> 01:22:52,810
其实，电脑是不
足够聪明这一点。

1734
01:22:52,810 --> 01:22:58,300
>> 所以基本上所有的计算机所做的就是
它试图把尽可能多的数字作为

1735
01:22:58,300 --> 01:23:00,950
它可以达到，你有记忆。

1736
01:23:00,950 --> 01:23:05,890
因此，让我们说，它要
说3.3333，就是这样。

1737
01:23:05,890 --> 01:23:10,690
所以它不是能够真正表达
正是浮动是什么。

1738
01:23:10,690 --> 01:23:13,240
>> LAUREN卡瓦略：我们有一个有限的数量
比特，表示不

1739
01:23:13,240 --> 01:23:17,910
每一个十进制数将是
能够被精确地表示。

1740
01:23:17,910 --> 01:23:24,910
所以在这个例子中，如果我们
打印出0.1，我们现在是印刷

1741
01:23:24,910 --> 01:23:26,475
出20个名额。

1742
01:23:26,475 --> 01:23:30,250
>> LUCAS FREITAS：就像我告诉
你们这些家伙，你可以​​把任何数字。

1743
01:23:30,250 --> 01:23:36,520
但如果你只是做了两个地方，
你会得到0.10，但如果你把20

1744
01:23:36,520 --> 01:23:43,630
的地方，它会告诉你一堆
的的，因为这是你可以把什么

1745
01:23:43,630 --> 01:23:45,720
在记忆里，对不对？

1746
01:23:45,720 --> 01:23:48,800
>> 但在这里，直到0，
然后只是把它放在一个

1747
01:23:48,800 --> 01:23:50,030
一串随机数。

1748
01:23:50,030 --> 01:23:52,590
这是一种像一些 - 

1749
01:23:52,590 --> 01:23:56,190
>> LAUREN卡瓦略：这是因为我们
不能够代表这个十进制

1750
01:23:56,190 --> 01:23:58,320
精确地与数
位的，我们有。

1751
01:23:58,320 --> 01:23:59,730
>> LUCAS FREITAS：然后是
计算机基本上是

1752
01:23:59,730 --> 01:24:01,470
给你一个垃圾数量。

1753
01:24:01,470 --> 01:24:04,530
这实际上是不可能的
数的值。

1754
01:24:04,530 --> 01:24:08,242
>> 观众：这是亲如
它可以得到[听不清]

1755
01:24:08,242 --> 01:24:09,613
使用[听不清]。

1756
01:24:09,613 --> 01:24:12,685

1757
01:24:12,685 --> 01:24:18,830
>> LAUREN卡瓦略：的言下之意
这是一个让我们说，而不是

1758
01:24:18,830 --> 01:24:27,680
为0.100014，什么的，
如果它是0.0999  - 

1759
01:24:27,680 --> 01:24:30,470
好，好。

1760
01:24:30,470 --> 01:24:38,280
让我们假设实际的答案
到，这是0.9999999。

1761
01:24:38,280 --> 01:24:40,740
这是非常接近1，但
它不完全1。

1762
01:24:40,740 --> 01:24:42,840
这是0.99999。

1763
01:24:42,840 --> 01:24:48,140
>> 这意味着，如果我采取0.999，
我投它为int，我得到0。

1764
01:24:48,140 --> 01:24:49,460
我不明白1。

1765
01:24:49,460 --> 01:24:53,050
>> LUCAS FREITAS：因为记得，铸造
从浮到整数，你只是

1766
01:24:53,050 --> 01:24:54,880
忽略所有的小数位。

1767
01:24:54,880 --> 01:24:56,400
你不理会他们。

1768
01:24:56,400 --> 01:25:00,170
有没有这样的东西作为围捕
或向下运行时，强制转换。

1769
01:25:00,170 --> 01:25:03,310
其实，有这个功能，
做四舍五入，这是非常

1770
01:25:03,310 --> 01:25:08,840
重要的，但你只是认为，当
你做类型转换，它只是

1771
01:25:08,840 --> 01:25:09,720
要删除一切。

1772
01:25:09,720 --> 01:25:13,970
所以，即使你有0.99999，这是怎么回事
就这样给0，如果你的类型转换

1773
01:25:13,970 --> 01:25:14,800
[听不清]的整数。

1774
01:25:14,800 --> 01:25:17,480
>> LAUREN卡瓦略：所以只是真正意识到
在精确的浮点

1775
01:25:17,480 --> 01:25:20,410
尤其是当你开始
使用花车在PSET1。

1776
01:25:20,410 --> 01:25:22,790
但通过应该走
提醒你这一点。

1777
01:25:22,790 --> 01:25:26,100
>> LUCAS FREITAS：实际上，它真的
难，例如，如果我这样做

1778
01:25:26,100 --> 01:25:31,570
浮动答案1比等于1.0
10，然后浮答案2

1779
01:25:31,570 --> 01:25:35,540
等于10.0比100.0。

1780
01:25:35,540 --> 01:25:36,890
它们是相同的号码，对不对？

1781
01:25:36,890 --> 01:25:38,540
0.1，对不对？

1782
01:25:38,540 --> 01:25:41,700
1比10或10比100。

1783
01:25:41,700 --> 01:25:46,360
但现在，如果我尝试看看的平等，
就像如果答案1等于回答2，

1784
01:25:46,360 --> 01:25:49,300
也许它不会实际去
是相同的东西。

1785
01:25:49,300 --> 01:25:50,720
所以彩车是有点像那个。

1786
01:25:50,720 --> 01:25:51,970
他们喜欢做的平等。

1787
01:25:51,970 --> 01:25:55,136