1
00:00:00,000 --> 00:00:05,960
>> [音乐播放]

2
00:00:05,960 --> 00:00:08,540
>> DOUG LLOYD：嗨，让我们
谈谈C.运营商

3
00:00:08,540 --> 00:00:12,590
因此，我们已经看到的，事实上，
等于赋值运算符。

4
00:00:12,590 --> 00:00:15,510
它允许我们只是把
一个值的变量。

5
00:00:15,510 --> 00:00:18,046
这就是分配
运营商，单个等号。

6
00:00:18,046 --> 00:00:20,670
为了操纵和工作
其值和变量C，

7
00:00:20,670 --> 00:00:23,710
我们有许多运营商
在我们的处置，我们可以使用。

8
00:00:23,710 --> 00:00:25,543
让我们来看看
一些常见的

9
00:00:25,543 --> 00:00:27,430
开始的算术运算符。

10
00:00:27,430 --> 00:00:31,080
正如你所期望的，我们能做到
在C非常基本的数学运算

11
00:00:31,080 --> 00:00:36,520
我们可以加，减，乘，
使用加鸿沟号，减号，明星，

12
00:00:36,520 --> 00:00:38,422
和斜线，分别。

13
00:00:38,422 --> 00:00:40,630
这里有一对夫妇的行
代码中，我们做到这一点。

14
00:00:40,630 --> 00:00:44,150
所以，我们是int x等于y加1。

15
00:00:44,150 --> 00:00:46,460
让我们假设地方
高达上面这行代码

16
00:00:46,460 --> 00:00:49,230
我们曾说过INT y等于10。

17
00:00:49,230 --> 00:00:55,790
什么是x的值后，我
执行这个代码第一行？

18
00:00:55,790 --> 00:00:56,700
你说11？

19
00:00:56,700 --> 00:00:57,910
你会正确。

20
00:00:57,910 --> 00:00:58,420
这是为什么？

21
00:00:58,420 --> 00:00:59,790
好吧，y为10。

22
00:00:59,790 --> 00:01:03,215
有些我是说INT x等于10加1。

23
00:01:03,215 --> 00:01:04,269
10加1是11。

24
00:01:04,269 --> 00:01:08,540
所以，值11变
存储在变量x。

25
00:01:08,540 --> 00:01:09,740
不算太坏，是吗？

26
00:01:09,740 --> 00:01:14,040
>> 怎么样这下一行
代码？ x等于x次5。

27
00:01:14,040 --> 00:01:17,700
那么，在我们执行
这行代码中，x为11。

28
00:01:17,700 --> 00:01:21,237
那么，什么是价值
十大之后这行代码？

29
00:01:21,237 --> 00:01:21,820
拿第二。

30
00:01:21,820 --> 00:01:24,710

31
00:01:24,710 --> 00:01:27,620
所以，x等于x次5。

32
00:01:27,620 --> 00:01:29,850
x为11。

33
00:01:29,850 --> 00:01:32,970
所以，x等于11倍5。

34
00:01:32,970 --> 00:01:34,360
或55。

35
00:01:34,360 --> 00:01:36,490
所以，如果你说55，你是对的。

36
00:01:36,490 --> 00:01:41,770
>> 现在，它可能是一个有点混乱，但
与分配工作在C方式

37
00:01:41,770 --> 00:01:46,030
在右边的值变
分配给左边的值。

38
00:01:46,030 --> 00:01:49,090
因此，首先我们评估x次5。

39
00:01:49,090 --> 00:01:50,800
所以，11次5是55。

40
00:01:50,800 --> 00:01:53,340
然后我们存放在X中的价值。

41
00:01:53,340 --> 00:01:56,100
在11，这是有
之前，现在覆盖。

42
00:01:56,100 --> 00:01:58,280
因此，X的值现在是55。

43
00:01:58,280 --> 00:02:00,820
但愿这是非常简单的。

44
00:02:00,820 --> 00:02:04,246
>> 还有，你已经另算
恐怕未必听说过

45
00:02:04,246 --> 00:02:06,620
叫这个，但你
当然，在过去的工作

46
00:02:06,620 --> 00:02:09,470
如果你还记得长你的日子
师早在小学。

47
00:02:09,470 --> 00:02:11,270
这就是所谓的模运算。

48
00:02:11,270 --> 00:02:13,620
什么模所做的就是
给你剩下

49
00:02:13,620 --> 00:02:15,400
当你把两个数。

50
00:02:15,400 --> 00:02:21,750
所以，如果我说13除以
4，什么是余数？

51
00:02:21,750 --> 00:02:24,860
并且该值将被计算
由模运算符。

52
00:02:24,860 --> 00:02:28,320
>> 所以，我有一个行代码
在这里，INT m等于13模4。

53
00:02:28,320 --> 00:02:31,960
我在这里说的评论
是m的值现在为1。

54
00:02:31,960 --> 00:02:32,750
为什么这样说呢？

55
00:02:32,750 --> 00:02:36,270
好了，做长除法在你的
头，如果你和我一起承担一秒钟。

56
00:02:36,270 --> 00:02:40,070
所以，我已经4除以13。

57
00:02:40,070 --> 00:02:44,087
4进入13三倍
与余数1。

58
00:02:44,087 --> 00:02:45,920
因此，基本上，所有的
模运算符

59
00:02:45,920 --> 00:02:48,600
是它告诉你，当你
鸿沟，你得到的余数。

60
00:02:48,600 --> 00:02:51,420
你可能会认为这实际上是
不是一个十分有用的东西，

61
00:02:51,420 --> 00:02:54,350
但你会惊讶，其实，
由频率模

62
00:02:54,350 --> 00:02:55,820
运营商可以派上用场。

63
00:02:55,820 --> 00:02:58,420
>> 有几个问题
我们会做CS50的处理。

64
00:02:58,420 --> 00:03:00,545
这也是好做
像随机数。

65
00:03:00,545 --> 00:03:03,850
因此，举例来说，如果你曾经
听到一个随机数发生器，

66
00:03:03,850 --> 00:03:06,620
那将会给你一个数
从0到一些巨大的数字。

67
00:03:06,620 --> 00:03:10,390
但是，也许你才真正
需要一个从0至20。

68
00:03:10,390 --> 00:03:13,425
如果使用模运算符
在这巨大的数字，

69
00:03:13,425 --> 00:03:17,080
得到由所生成的
随机数发生器，

70
00:03:17,080 --> 00:03:20,230
你会采取一切
巨大的价值是，它除以20，

71
00:03:20,230 --> 00:03:21,210
和得到的余数。

72
00:03:21,210 --> 00:03:24,050
其余只能
其值从0到19。

73
00:03:24,050 --> 00:03:27,140
所以，你使用模运算符
利用这个庞大的数字

74
00:03:27,140 --> 00:03:29,640
和惠特尔下来到的东西
多一点有意义的。

75
00:03:29,640 --> 00:03:31,764
我敢肯定你会
能够同时使用的那些

76
00:03:31,764 --> 00:03:34,710
在未来的某个时候在CS50。

77
00:03:34,710 --> 00:03:37,030
>> 因此，C也为我们提供了一种方式
申请的算术

78
00:03:37,030 --> 00:03:39,910
操作者一个单可变
在一个小更简便方法。

79
00:03:39,910 --> 00:03:44,520
所以，在上一张幻灯片，
我们看到x等于x次5。

80
00:03:44,520 --> 00:03:45,260
这工作。

81
00:03:45,260 --> 00:03:47,660
x乘以5，然后被存储回x中。

82
00:03:47,660 --> 00:03:52,490
有一个较短的方式做到这一点，思想，
和它的语法x次等于5。

83
00:03:52,490 --> 00:03:55,020
这是完全相同的东西
说x等于x次5。

84
00:03:55,020 --> 00:03:56,824
这只是一个稍微
较短的方式做到这一点。

85
00:03:56,824 --> 00:03:58,740
而当你看到一些
分发代码或您

86
00:03:58,740 --> 00:04:01,287
看到一些示例代码
做这样的事情，

87
00:04:01,287 --> 00:04:03,120
刚刚熟悉
语法意味着什么。

88
00:04:03,120 --> 00:04:05,980
你当然不会有
使用它，但如果这样做，

89
00:04:05,980 --> 00:04:08,235
它可能使你的代码
看起来有点滑头。

90
00:04:08,235 --> 00:04:11,360
，知道你也可以使用任何
不同的运营商，我们已把

91
00:04:11,360 --> 00:04:12,660
而不是之前的时候见过。

92
00:04:12,660 --> 00:04:16,720
你可以说X加上等于5，减
等于5，倍，除和国防部。

93
00:04:16,720 --> 00:04:18,959
所有这些工作。

94
00:04:18,959 --> 00:04:21,089
>> 还有一些
这是如此普遍在C中

95
00:04:21,089 --> 00:04:24,080
我们已经决定
完善甚至进一步。

96
00:04:24,080 --> 00:04:26,916
递增1变量
或递减一个变量1

97
00:04:26,916 --> 00:04:30,040
就是这样一个普通件事 - 尤其是
当我们谈论循环待会儿

98
00:04:30,040 --> 00:04:35,240
on--，我们已经决定，而不是
说像X加等于1，

99
00:04:35,240 --> 00:04:40,190
或x等于x加1，我们甚至
总之交给了以X加再加。

100
00:04:40,190 --> 00:04:46,940
所以中，x等于x加1中，x加等于1，
和X加再加都做同样的事情。

101
00:04:46,940 --> 00:04:48,470
他们都增加x 1。

102
00:04:48,470 --> 00:04:50,630
但是，这递增
和递减1

103
00:04:50,630 --> 00:04:54,110
是如此普遍，我们有
加上加号和减号减

104
00:04:54,110 --> 00:04:59,140
这让我们速记
这进一步加剧。

105
00:04:59,140 --> 00:05:02,110
>> 所以，让我们切换齿轮第二
说说布尔表达式。

106
00:05:02,110 --> 00:05:06,340
所有这一切都是一种也属于
经营者的总类别。

107
00:05:06,340 --> 00:05:09,030
但是布尔表达式，
不像算术运算符，

108
00:05:09,030 --> 00:05:11,860
用于比较的值。

109
00:05:11,860 --> 00:05:15,550
因此，同样，所有布尔在C表达式
计算结果为两个可能的值之一，

110
00:05:15,550 --> 00:05:16,050
回忆。

111
00:05:16,050 --> 00:05:17,740
对或错。

112
00:05:17,740 --> 00:05:21,880
这是仅有的两个值
布尔变量可以承担。

113
00:05:21,880 --> 00:05:25,780
我们可以使用的结果
布尔表达式

114
00:05:25,780 --> 00:05:27,650
在很多方面编程。

115
00:05:27,650 --> 00:05:29,400
事实上，你会
这样做了不少。

116
00:05:29,400 --> 00:05:32,870
>> 例如，我们可以决定，
好吧，如果某个条件为真，

117
00:05:32,870 --> 00:05:34,665
也许我会借这个
分支下来我的代码。

118
00:05:34,665 --> 00:05:35,980
有条件的，可以这么说。

119
00:05:35,980 --> 00:05:37,970
我们将了解这些很快了。

120
00:05:37,970 --> 00:05:40,560
或者，也许，只要
这是真的，我想

121
00:05:40,560 --> 00:05:42,790
要继续这样做
一遍又一遍又一遍。

122
00:05:42,790 --> 00:05:43,480
一个循环。

123
00:05:43,480 --> 00:05:48,350
在这两种情况下，知道我们正在使用
布尔表达式，真或假，

124
00:05:48,350 --> 00:05:52,411
以决定是否
采取特定路径。

125
00:05:52,411 --> 00:05:54,660
有时，当我们正在努力
与布尔表达式，

126
00:05:54,660 --> 00:05:56,410
我们将使用BOOL型变量。

127
00:05:56,410 --> 00:05:58,461
您可能宣布
一个布尔类型的变量，

128
00:05:58,461 --> 00:06:00,210
你会在使用你的
布尔表达式。

129
00:06:00,210 --> 00:06:02,130
但是，你并不总是必须做的。

130
00:06:02,130 --> 00:06:06,690
事实证明，在C，每一个非0
值是相同的话说如此。

131
00:06:06,690 --> 00:06:10,680
如果你宣布一个
Boolean类型的变量，

132
00:06:10,680 --> 00:06:14,240
并赋予它值true，这是
与声明整数

133
00:06:14,240 --> 00:06:17,410
并分配给它的价值
1，2，3，或任何真正的价值

134
00:06:17,410 --> 00:06:19,580
任何0以外。

135
00:06:19,580 --> 00:06:22,690
因为在C，每一个非0值是true。

136
00:06:22,690 --> 00:06:24,820
0，另一方面，是假的。

137
00:06:24,820 --> 00:06:27,162
这可能会派上
方便后来才知道，

138
00:06:27,162 --> 00:06:28,620
但只是要记住。

139
00:06:28,620 --> 00:06:31,890
我们并不总是有使用
布尔类型变量的时候，我们

140
00:06:31,890 --> 00:06:34,980
正在与布尔表达式。

141
00:06:34,980 --> 00:06:37,890
>> 有两种主要类型布尔
表达式我们将与。

142
00:06:37,890 --> 00:06:40,640
逻辑运算符和
关系运算符。

143
00:06:40,640 --> 00:06:42,640
还有就是语言
不是非常重要。

144
00:06:42,640 --> 00:06:44,970
这真的只是我如何将它们分组。

145
00:06:44,970 --> 00:06:49,222
你一定会，我想，赶紧
意识到发生了什么关系运算符是，

146
00:06:49,222 --> 00:06:51,680
根据他们是什么时，我们
在第二谈论它们。

147
00:06:51,680 --> 00:06:54,250
不过不用担心一定
记住这个词的逻辑运算符

148
00:06:54,250 --> 00:06:55,460
或关系运算符。

149
00:06:55,460 --> 00:07:00,070
我只是用它来组
他们在一个合理的方式。

150
00:07:00,070 --> 00:07:02,620
>> 那么，让我们来看看
三个逻辑运算

151
00:07:02,620 --> 00:07:04,970
我们会看到不少
在CS50编程位

152
00:07:04,970 --> 00:07:06,710
在编程更普遍。

153
00:07:06,710 --> 00:07:10,470
逻辑与是真实的，如果和
只有当两个操作数是正确的。

154
00:07:10,470 --> 00:07:11,775
否则为false。

155
00:07:11,775 --> 00:07:12,650
哪里是什么意思？

156
00:07:12,650 --> 00:07:15,840
所以，让我们说我在
指向我的代码，我有

157
00:07:15,840 --> 00:07:18,310
两个变量，x和y。

158
00:07:18,310 --> 00:07:21,620
我想，以决定是否
做一些事情在我的代码

159
00:07:21,620 --> 00:07:25,780
基于如果x为真和y是真实的。

160
00:07:25,780 --> 00:07:27,730
我只是想，如果这样做
他们两人都是真实的，

161
00:07:27,730 --> 00:07:30,980
否则，我不希望走这
路径，因为它不会帮助我。

162
00:07:30,980 --> 00:07:37,420
我能说的是如果x &&年。

163
00:07:37,420 --> 00:07:42,380
这将是一个合乎逻辑的布尔
表达比较X和Y

164
00:07:42,380 --> 00:07:45,240
并采取一定的路径
根据他们的值。

165
00:07:45,240 --> 00:07:48,400
所以，如果x是真，y为真
基于此真值表就到这里，

166
00:07:48,400 --> 00:07:50,430
只有这样，我们走这条路。

167
00:07:50,430 --> 00:07:52,940
如果x，＆＆Y。

168
00:07:52,940 --> 00:07:58,320
这只是true--的，只
如果X是真实的，y是真实的。

169
00:07:58,320 --> 00:08:00,850
如果其中一个是假的，
正如我们所看到的真值表，

170
00:08:00,850 --> 00:08:02,370
然后x和y是不正确的。

171
00:08:02,370 --> 00:08:07,660
因此，X＆Y是假的。

172
00:08:07,660 --> 00:08:12,044
>> 逻辑或为真，当且仅
如果至少一个操作数是真实的。

173
00:08:12,044 --> 00:08:12,710
否则为false。

174
00:08:12,710 --> 00:08:15,760
因此，逻辑与要求
x和y是真实的。

175
00:08:15,760 --> 00:08:21,185
逻辑或需要X是真实的或y
是真实的或x和y是真实的。

176
00:08:21,185 --> 00:08:23,310
因此，我们再次一种发现
自己的处境

177
00:08:23,310 --> 00:08:26,460
我们要去的地方我们的代码，
而我们达到了一个岔路口。

178
00:08:26,460 --> 00:08:29,850
我们要下去一
如果x为true特定路径

179
00:08:29,850 --> 00:08:33,299
或y是真实的，但不
不一定，如果无一不是如此。

180
00:08:33,299 --> 00:08:35,830
但是，如果有可能两者都是真实的。

181
00:08:35,830 --> 00:08:38,460
因此，如果x为true，Y是
真的，我们会走这条路。

182
00:08:38,460 --> 00:08:39,066
x是真实的。

183
00:08:39,066 --> 00:08:40,190
其中之一是真的吧？

184
00:08:40,190 --> 00:08:42,080
如果x为true，y是真实的。

185
00:08:42,080 --> 00:08:44,910
如果x是真实的，并且y是假的，
其中之一仍然是正确的。

186
00:08:44,910 --> 00:08:48,020
因此，x或y仍然是正确的。

187
00:08:48,020 --> 00:08:52,290
如果x是假的，并且y是真实的，
其中之一仍然是真实的，对不对？

188
00:08:52,290 --> 00:08:53,290
y是真实的，在这种情况下。

189
00:08:53,290 --> 00:08:57,950
所以，这是真的，X或Y是真实的。

190
00:08:57,950 --> 00:09:02,620
只有当x为false而y是假的
我们不走这条路，

191
00:09:02,620 --> 00:09:04,454
因为x和y都不是真实的。

192
00:09:04,454 --> 00:09:06,370
现在，如果你正在寻找
屏幕现在

193
00:09:06,370 --> 00:09:09,062
，不知道是什么
符号是用于逻辑OR，

194
00:09:09,062 --> 00:09:10,270
这就是所谓的竖线。

195
00:09:10,270 --> 00:09:13,730
如果你在看你的键盘
一分钟，因为我现在做，

196
00:09:13,730 --> 00:09:16,940
它通常略高于
回车键，大多数键盘上，

197
00:09:16,940 --> 00:09:19,630
在同一个按键反斜杠。

198
00:09:19,630 --> 00:09:22,790
这也是通常是正确的
旁边的方括号。

199
00:09:22,790 --> 00:09:27,240
因此，它可能是一个关键的，你
没有输入非常近。

200
00:09:27,240 --> 00:09:29,700
但是，如果你曾经做的
逻辑比较，

201
00:09:29,700 --> 00:09:31,882
因为我们会做一个
很多在使用过程中，它的

202
00:09:31,882 --> 00:09:33,840
将是有用的，以
找到钥匙并用它。

203
00:09:33,840 --> 00:09:38,340
因此，它通常在相同的密钥
作为反斜线正上方输入。

204
00:09:38,340 --> 00:09:39,757
>> 最终的逻辑运算符是没有的。

205
00:09:39,757 --> 00:09:41,131
而不是是相当简单的。

206
00:09:41,131 --> 00:09:42,830
它反转操作数的值。

207
00:09:42,830 --> 00:09:46,080
如果x是真的，那不是X是假的。

208
00:09:46,080 --> 00:09:49,960
如果x为假，那么不是X是真的。

209
00:09:49,960 --> 00:09:53,850
有时你会听到这个符号
发音为爆炸或感叹号

210
00:09:53,850 --> 00:09:55,231
或不。

211
00:09:55,231 --> 00:09:56,730
这是几乎所有的同样的事情。

212
00:09:56,730 --> 00:10:00,185
如果你听到了口语和
你不知道这意味着什么，

213
00:10:00,185 --> 00:10:02,310
它只是感叹
点，但有时它的

214
00:10:02,310 --> 00:10:04,215
叫上几个不同的事情。

215
00:10:04,215 --> 00:10:06,340
好吧，让需要
关心逻辑运算符。

216
00:10:06,340 --> 00:10:08,640
那么，让我们来谈谈
关系运算符。

217
00:10:08,640 --> 00:10:11,610
同样，如果你熟悉这个
算术早在小学的时候，

218
00:10:11,610 --> 00:10:13,870
你可能熟悉
用了这些工作了。

219
00:10:13,870 --> 00:10:15,411
这些行为完全如你所期望。

220
00:10:15,411 --> 00:10:19,800
所以不到这是真的，在这
例如，如果x小于y。

221
00:10:19,800 --> 00:10:24,380
所以，如果x是4，y是
6，x是小于y。

222
00:10:24,380 --> 00:10:26,035
这是真的。

223
00:10:26,035 --> 00:10:27,910
小于或等于
工作得同样。

224
00:10:27,910 --> 00:10:33,020
如果x是4，y是4，则
x小于或等于y。

225
00:10:33,020 --> 00:10:35,310
比...更棒。 x是比y大。

226
00:10:35,310 --> 00:10:39,310
和大于或等于中，x
大于或等于y。

227
00:10:39,310 --> 00:10:41,745
如果这是真的，那么你会
传递表情，

228
00:10:41,745 --> 00:10:44,490
你会往下走
在路上这条道路。

229
00:10:44,490 --> 00:10:48,590
如果你有一个如果x大于Y，
并且x是，实际上比y大，

230
00:10:48,590 --> 00:10:51,670
你会做什么是
受这一条件。

231
00:10:51,670 --> 00:10:54,396
>> 请注意，我们没有
少于单个字符

232
00:10:54,396 --> 00:10:57,020
或等于，因为你可能会
熟悉的数学课本。

233
00:10:57,020 --> 00:10:59,874
所以，我们比符号少，
其次是一个等号。

234
00:10:59,874 --> 00:11:01,790
这就是我们代表
大于或等于以下。

235
00:11:01,790 --> 00:11:04,490
同样，我们做的
为大于或等于。

236
00:11:04,490 --> 00:11:06,698
>> 最后的两个关系
运算是很重要

237
00:11:06,698 --> 00:11:09,320
正在测试的平等和不平等。

238
00:11:09,320 --> 00:11:13,380
所以，如果x等于等于Y，是真实的
如果x和y的值是相同的。

239
00:11:13,380 --> 00:11:19,610
如果x为10，y为10，然后
x等于等于y是真实的。

240
00:11:19,610 --> 00:11:26,010
如果x是10和y为11中，x
等于等于y是不正确的。

241
00:11:26,010 --> 00:11:29,680
我们还可以利用不平等测试
惊叹号或爆炸与否，

242
00:11:29,680 --> 00:11:30,330
再次。

243
00:11:30,330 --> 00:11:35,049
如果x不是等于y，如果
这就是我们这里使用的测试，

244
00:11:35,049 --> 00:11:35,840
我们会好到哪里去。

245
00:11:35,840 --> 00:11:40,340
所以，如果x不等于
Y，我们会走这条路。

246
00:11:40,340 --> 00:11:41,441
>> 要非常小心这里。

247
00:11:41,441 --> 00:11:44,440
这是一个非常常见的mistake--和
一个我确实做了不少的时候

248
00:11:44,440 --> 00:11:47,340
我是越来越started--
不小心误

249
00:11:47,340 --> 00:11:51,690
赋值运算符，单等号，
对于相等比较运营商，

250
00:11:51,690 --> 00:11:52,582
双等于。

251
00:11:52,582 --> 00:11:54,540
它会导致一些奇怪的
在你的代码的行为，

252
00:11:54,540 --> 00:11:56,730
通常编译器会
提醒你一下，当您尝试

253
00:11:56,730 --> 00:11:59,910
和编译代码，但有时
您可能能够瞒天过海。

254
00:11:59,910 --> 00:12:02,770
这并不一定是好事
您通过瞒天过海，但。

255
00:12:02,770 --> 00:12:04,710
正是如此，如果你正在做的
一个不平等的测试，

256
00:12:04,710 --> 00:12:07,970
如果你正在检查是否将两个
不同的变量具有相同的值

257
00:12:07,970 --> 00:12:11,980
他们在里面，请务必使用
等于平等，而不是单一的平等。

258
00:12:11,980 --> 00:12:15,450
而这样的程序将
有你想要的行为。

259
00:12:15,450 --> 00:12:18,400
我是道格·劳埃德，这是CS50。

260
00:12:18,400 --> 00:12:20,437