1
00:00:00,000 --> 00:00:04,664

2
00:00:04,664 --> 00:00:05,580
DOUG LLOYD：好吧。

3
00:00:05,580 --> 00:00:08,877
所以，现在让我们来处理一个
真正的大话题，功能。

4
00:00:08,877 --> 00:00:11,460
到目前为止，在使用过程中，所有的
我们一直在写程序

5
00:00:11,460 --> 00:00:12,969
已被写入的主内。

6
00:00:12,969 --> 00:00:14,260
他们是很简单的程序。

7
00:00:14,260 --> 00:00:16,940
你不需要把所有这些
分支机构和东西正在进行。

8
00:00:16,940 --> 00:00:18,773
我们只要适应这一切
它里面的主

9
00:00:18,773 --> 00:00:20,407
没有得到非常热烈。

10
00:00:20,407 --> 00:00:22,990
但是，随着场的推移和
当你开始制定方案

11
00:00:22,990 --> 00:00:26,260
独立，他们很可能会
开始得到了很多10余项

12
00:00:26,260 --> 00:00:27,200
或15行。

13
00:00:27,200 --> 00:00:31,400
你可能会得到数百或数千
行的代码几万。

14
00:00:31,400 --> 00:00:34,690
这真是不
那个疯狂的思想。

15
00:00:34,690 --> 00:00:39,720
因此，它可能不是一个好主意
保持所有主内。

16
00:00:39,720 --> 00:00:43,240
它可以得到一个有点难以找到
你要找如果你这样做为了什么。

17
00:00:43,240 --> 00:00:47,040
>> 幸运的是，虽然C，和几乎
所有其他编程语言

18
00:00:47,040 --> 00:00:50,386
可能与工作，允许
我们写的功能。

19
00:00:50,386 --> 00:00:52,260
而我只是要
采取快速一边在这里

20
00:00:52,260 --> 00:00:54,971
更何况，其功能是
一个地区的计算机科学。

21
00:00:54,971 --> 00:00:57,970
你会看到更多的人
多个点的过程中

22
00:00:57,970 --> 00:00:59,290
如果你继续。

23
00:00:59,290 --> 00:01:02,280
哪里有很多的
同义词相同单词。

24
00:01:02,280 --> 00:01:03,390
因此，我们调用的函数。

25
00:01:03,390 --> 00:01:05,980
但是，你也可能听到他们
称为程序，

26
00:01:05,980 --> 00:01:09,570
或方法，尤其是，如果你曾经
做过任何面向对象的编程

27
00:01:09,570 --> 00:01:11,950
before--不用担心
如果你还没有，不

28
00:01:11,950 --> 00:01:14,280
大deal--但在
审计面向对象语言

29
00:01:14,280 --> 00:01:16,129
经常调用的方法。

30
00:01:16,129 --> 00:01:17,670
有时，他们正在调用的子程序。

31
00:01:17,670 --> 00:01:20,690
但他们真的都指
到相同的基本思想。

32
00:01:20,690 --> 00:01:22,480
>> 让我们来看看这个想法是什么。

33
00:01:22,480 --> 00:01:23,310
什么是功能？

34
00:01:23,310 --> 00:01:26,470
好一个功能是真的
没有什么比一个黑盒子。

35
00:01:26,470 --> 00:01:31,430
一个黑盒子，有一组零
或多个输入和一个输出。

36
00:01:31,430 --> 00:01:33,420
因此，例如，这
可能是一个功能。

37
00:01:33,420 --> 00:01:35,510
这是一种称为FUNC函数。

38
00:01:35,510 --> 00:01:39,330
它需要三个输入的a，b，和c。

39
00:01:39,330 --> 00:01:42,580
并在该黑盒子，我们
不知道到底是什么呢，

40
00:01:42,580 --> 00:01:45,100
但它处理输入
以某种方式，然后将其

41
00:01:45,100 --> 00:01:48,680
给出了一个单一的输出，在这种情况下，Z。

42
00:01:48,680 --> 00:01:50,504
现在让它一点点
不那么抽象，我们

43
00:01:50,504 --> 00:01:52,420
可以说，也许我们
有一个调用的函数

44
00:01:52,420 --> 00:01:58,750
补充说，有三个输入A，B，和
c和处理以某种方式输出

45
00:01:58,750 --> 00:02:01,010
里面的黑匣子
产生单一的输出。

46
00:02:01,010 --> 00:02:05,190
因此，在这种情况下，如果
添加需要3，6和7。

47
00:02:05,190 --> 00:02:07,020
某处内部
添加的功能，我们会

48
00:02:07,020 --> 00:02:09,750
期望他们加在一起
以产生输出，该输出

49
00:02:09,750 --> 00:02:13,220
是3加6加7或16。

50
00:02:13,220 --> 00:02:17,940
>> 同样，你有一个调用的函数
MULT采用两个输入a和b，

51
00:02:17,940 --> 00:02:21,070
以某种方式，例如处理它们
该函数的输出

52
00:02:21,070 --> 00:02:22,920
是两个输入的乘积。

53
00:02:22,920 --> 00:02:25,080
这两个输入相乘。

54
00:02:25,080 --> 00:02:29,150
图4和5通过成为多重峰
出了事，我们预计产量

55
00:02:29,150 --> 00:02:31,090
20。

56
00:02:31,090 --> 00:02:32,507
为什么我们把它叫做一个黑盒子？

57
00:02:32,507 --> 00:02:34,840
那么，如果我们不写
自己的功能，这

58
00:02:34,840 --> 00:02:36,869
我们已经做了相当多至今CS50。

59
00:02:36,869 --> 00:02:39,910
我们已经看到打印楼为例，它
是我们没有写一个函数

60
00:02:39,910 --> 00:02:42,305
我们自己，但我们用所有的时间。

61
00:02:42,305 --> 00:02:44,180
如果我们不写
该功能我们自己，

62
00:02:44,180 --> 00:02:48,450
我们并不真正需要知道它是如何
引擎盖下的实际执行。

63
00:02:48,450 --> 00:02:51,710
>> 因此，例如，所述黑盒我
刚才给你看的乘法，

64
00:02:51,710 --> 00:02:53,740
MULT的a，b可以是
defined--而这仅仅是

65
00:02:53,740 --> 00:02:57,902
一些pseudocode--可能
定义为输出乘以B。

66
00:02:57,902 --> 00:02:58,860
有意义的，正确的。

67
00:02:58,860 --> 00:03:01,370
如果我们有一个调用的函数
MULT这有两个输入端。

68
00:03:01,370 --> 00:03:04,750
我们预期的产量将
是两个输入相乘，

69
00:03:04,750 --> 00:03:06,240
A乘以B。

70
00:03:06,240 --> 00:03:09,170
但多重峰也可以是
这样的实施，

71
00:03:09,170 --> 00:03:13,150
我们有一个计数器变量
得到MULT的内部设置为0。

72
00:03:13,150 --> 00:03:18,000
随后，我们重复此过程
b乘以一个添加到柜台。

73
00:03:18,000 --> 00:03:24,270
举例来说，如果我们用乘以3A
5B，我们可以说计数器设置为0，

74
00:03:24,270 --> 00:03:27,700
重复五次，加3计数器。

75
00:03:27,700 --> 00:03:34,490
因此，我们从0开始，然后我们做
这五次3，6，9，12，15。

76
00:03:34,490 --> 00:03:37,500
这是同样的结果。我们
仍然获得3次5只

77
00:03:37,500 --> 00:03:39,500
实施是不同的。

78
00:03:39,500 --> 00:03:41,490
>> 这就是我们的意思
当我们说一个黑盒子。

79
00:03:41,490 --> 00:03:44,406
这只是意味着我们真的不关心
它是如何在引擎盖下实现的

80
00:03:44,406 --> 00:03:46,170
只要输出是我们所期望的。

81
00:03:46,170 --> 00:03:49,045
事实上，这是合同的组成部分
使用功能，特别是

82
00:03:49,045 --> 00:03:50,630
功能别人写的。

83
00:03:50,630 --> 00:03:53,980
行为总是会
是典型的，不可预测的

84
00:03:53,980 --> 00:03:55,420
基于功能的名称。

85
00:03:55,420 --> 00:03:57,500
这就是为什么它是真的
重要的，当你写的函数

86
00:03:57,500 --> 00:04:00,020
或者当其他人写的
你可以使用的功能，

87
00:04:00,020 --> 00:04:03,590
这些职能有
明确的，比较明显的名字，

88
00:04:03,590 --> 00:04:04,990
并且有据可查。

89
00:04:04,990 --> 00:04:08,560
这是肯定的情况下，
对于像打印f函数。

90
00:04:08,560 --> 00:04:09,860
>> 那么，为什么我们使用的功能呢？

91
00:04:09,860 --> 00:04:14,220
那么正如我刚才所说，如果我们写
我们所有的代码，主要里面的东西

92
00:04:14,220 --> 00:04:17,120
能得到真正麻烦的
并且非常复杂。

93
00:04:17,120 --> 00:04:19,980
功能让我们的能力
组织的事而分手

94
00:04:19,980 --> 00:04:24,540
一个非常复杂的问题分解成
很多更易于管理的子部分。

95
00:04:24,540 --> 00:04:28,130
功能也让我们
简化编码过程。

96
00:04:28,130 --> 00:04:33,080
这是一个更容易调试10
线功能与100线

97
00:04:33,080 --> 00:04:35,890
功能或1000线功能。

98
00:04:35,890 --> 00:04:38,400
如果我们只需要调试
小件的时间，

99
00:04:38,400 --> 00:04:42,110
或者写小片的时候，
这使得该编程经验

100
00:04:42,110 --> 00:04:43,070
好了很多。

101
00:04:43,070 --> 00:04:44,910
相信我在那一个。

102
00:04:44,910 --> 00:04:48,400
>> 最后，如​​果我们写的功能我们
可重复使用的各个部分。

103
00:04:48,400 --> 00:04:49,880
功能可循环使用。

104
00:04:49,880 --> 00:04:51,880
它们可被用
一个程序或其他。

105
00:04:51,880 --> 00:04:53,713
你已经写
该功能，你

106
00:04:53,713 --> 00:04:56,530
需要做的就是告诉程序
在哪里可以找到该功能。

107
00:04:56,530 --> 00:04:59,680
我们一直在循环使用
打印的f超过40年。

108
00:04:59,680 --> 00:05:02,150
但当时只写了一次。

109
00:05:02,150 --> 00:05:04,270
非常有用的，正确的。

110
00:05:04,270 --> 00:05:04,830
好吧。

111
00:05:04,830 --> 00:05:06,040
因此，功能是巨大的。

112
00:05:06,040 --> 00:05:06,860
我们知道。

113
00:05:06,860 --> 00:05:08,700
现在，让我们开始写他们。

114
00:05:08,700 --> 00:05:10,830
让我们开始获得
他们进入我们的节目。

115
00:05:10,830 --> 00:05:13,869
为了做到这一点，在第一
我们做的事情就是声明函数。

116
00:05:13,869 --> 00:05:16,160
在声明函数
什么你基本上是在做

117
00:05:16,160 --> 00:05:18,900
告诉编译器，
哎，只是让你知道，

118
00:05:18,900 --> 00:05:20,850
我要编写
后来一个函数

119
00:05:20,850 --> 00:05:22,987
这里就是它会是什么样子。

120
00:05:22,987 --> 00:05:24,820
这样做的原因是
因为编译器能够

121
00:05:24,820 --> 00:05:27,900
如果做一些奇怪的事情
他们看到一组符号

122
00:05:27,900 --> 00:05:29,560
他们是不熟悉的。

123
00:05:29,560 --> 00:05:33,000
所以，我们只是给编译器
抬起头来，我创建一个函数

124
00:05:33,000 --> 00:05:35,492
并且它会做到这一点。

125
00:05:35,492 --> 00:05:38,450
函数声明一般如果
你组织你的代码的方式

126
00:05:38,450 --> 00:05:41,872
其他人将能
了解和利用，

127
00:05:41,872 --> 00:05:44,330
您通常希望把所有
你的函数声明

128
00:05:44,330 --> 00:05:48,220
在你的代码的最顶部，右
你开始写主之前。

129
00:05:48,220 --> 00:05:50,770
方便，还有
一个非常标准的形式

130
00:05:50,770 --> 00:05:53,500
每一个函数声明如下。

131
00:05:53,500 --> 00:05:56,090
他们都非常期待这样的。

132
00:05:56,090 --> 00:06:01,440
有三部分功能
声明，返回类型，名称，

133
00:06:01,440 --> 00:06:03,420
和参数列表。

134
00:06:03,420 --> 00:06:07,180
>> 现在，返回类型是什么样的
变量函数将输出。

135
00:06:07,180 --> 00:06:10,710
因此，例如，如果我们想回
分钟前到乘法2

136
00:06:10,710 --> 00:06:15,690
号码功能，我们期待什么，如果
我们用一个整数乘以整数

137
00:06:15,690 --> 00:06:18,502
输出将是
可能是一个整数，对吧。

138
00:06:18,502 --> 00:06:20,710
乘两个整数
在一起，你会得到一个整数。

139
00:06:20,710 --> 00:06:24,167
因此，返回类型
功能将是int。

140
00:06:24,167 --> 00:06:26,000
名字是你想要的
打电话给你的功能。

141
00:06:26,000 --> 00:06:29,330
这可能是最重要的
函数声明的一部分，

142
00:06:29,330 --> 00:06:30,827
在功能方面。

143
00:06:30,827 --> 00:06:33,160
但实际上可能是1
最重要的部分

144
00:06:33,160 --> 00:06:36,243
无论在函数声明
知道什么实际的作用

145
00:06:36,243 --> 00:06:37,120
确实。

146
00:06:37,120 --> 00:06:40,474
如果你的名字你函数f和g或
H或神秘，或类似的东西，

147
00:06:40,474 --> 00:06:42,765
你可能会得到
一个小绊倒努力

148
00:06:42,765 --> 00:06:44,650
要记住这些函​​数的功能。

149
00:06:44,650 --> 00:06:47,880
因此，它给重要的是你
功能的有意义的名称。

150
00:06:47,880 --> 00:06:51,030
>> 最后，参数列表
逗号分隔的列表

151
00:06:51,030 --> 00:06:55,260
的全部投入到你的函数，
每个都具有一个类型和名称。

152
00:06:55,260 --> 00:06:57,840
所以，你不仅需要
指定变量是什么类型的

153
00:06:57,840 --> 00:07:00,760
该功能将输出，
你也想​​说明

154
00:07:00,760 --> 00:07:07,694
什么类型和种类的变量
功能将被接受作为输入。

155
00:07:07,694 --> 00:07:08,860
因此，让我们做一个例子在这里。

156
00:07:08,860 --> 00:07:10,220
就让我们一起来看看
在一个更具体的之一。

157
00:07:10,220 --> 00:07:13,130
所以这里有一个函数的例子
声明一个函数，

158
00:07:13,130 --> 00:07:14,925
将两个整数相加在一起。

159
00:07:14,925 --> 00:07:17,800
两个整数之和要
是一个整数为好，因为我们刚刚

160
00:07:17,800 --> 00:07:18,450
讨论。

161
00:07:18,450 --> 00:07:21,610
这样一来，返回类型，
这里的绿色，将是int。

162
00:07:21,610 --> 00:07:25,190
这只是告诉我们，增加两个整数
将要在这一天结束时，

163
00:07:25,190 --> 00:07:28,799
输出或吐回
出来给我们，一个整数。

164
00:07:28,799 --> 00:07:31,590
鉴于这是什么功能呢，我们
想给它一个有意义的名字。

165
00:07:31,590 --> 00:07:33,630
添加两个整数似乎
相应的，在考虑

166
00:07:33,630 --> 00:07:37,574
我们正在采取两个整数作为输入
并希望将它们放在一起。

167
00:07:37,574 --> 00:07:40,240
这可能是一个有点繁琐
名称并坦言这个功能

168
00:07:40,240 --> 00:07:42,430
可能是没有必要的
因为我们有加

169
00:07:42,430 --> 00:07:46,310
运营商，如果你还记得我们的
讨论运营商，之前。

170
00:07:46,310 --> 00:07:49,650
但是，让我们只说为求
参数，这个功能非常有用

171
00:07:49,650 --> 00:07:52,860
所以我们就叫它添加两个整数。

172
00:07:52,860 --> 00:07:55,230
最后，这个函数有两个输入端。

173
00:07:55,230 --> 00:07:56,960
其中每一个是一个整数。

174
00:07:56,960 --> 00:07:59,900
因此，我们有这个逗号
输入分隔的列表。

175
00:07:59,900 --> 00:08:02,830
现在，我们一般要
他们每个人给一个名字

176
00:08:02,830 --> 00:08:05,070
以便它们可用于
内的功能。

177
00:08:05,070 --> 00:08:07,180
的名称是不是非常重要的。

178
00:08:07,180 --> 00:08:11,400
>> 在这种情况下，我们并不一定
附加有任何意义。

179
00:08:11,400 --> 00:08:13,140
因此，我们可以叫他们a和b。

180
00:08:13,140 --> 00:08:14,257
这是完全正常。

181
00:08:14,257 --> 00:08:16,090
但是，如果你发现
自己的情况

182
00:08:16,090 --> 00:08:19,497
其中变量的名称
实际上可能是重要的，

183
00:08:19,497 --> 00:08:21,830
你可能想打电话给他们
东西比a和b其他

184
00:08:21,830 --> 00:08:24,701
给他们更多的东西
象征意义。

185
00:08:24,701 --> 00:08:27,700
但是，在这种情况下，我们真的不
知道什么对的功能。

186
00:08:27,700 --> 00:08:29,320
我们只是想增加两个整数。

187
00:08:29,320 --> 00:08:32,429
所以我们只需要调用
这些整数a和b。

188
00:08:32,429 --> 00:08:33,990
这是一个例子。

189
00:08:33,990 --> 00:08:36,287
>> 你为什么不拿第二
想想这一块，

190
00:08:36,287 --> 00:08:38,870
你会如何​​编写一个函数
声明一个函数，

191
00:08:38,870 --> 00:08:42,940
将两个浮点数？

192
00:08:42,940 --> 00:08:45,910
你还记得什么
浮点数是？

193
00:08:45,910 --> 00:08:48,120
什么将这项功能
声明是什么样子？

194
00:08:48,120 --> 00:08:53,330
事实上，我建议你暂停视频
在这里，把你需要多少时间。

195
00:08:53,330 --> 00:08:55,521
想想这是什么
函数的声明会是什么？

196
00:08:55,521 --> 00:08:56,770
什么会返回类型是什么？

197
00:08:56,770 --> 00:08:58,103
什么有意义的名称是什么？

198
00:08:58,103 --> 00:08:59,580
什么投入呢？

199
00:08:59,580 --> 00:09:03,190
那么，为什么你在这里暂停视频
并写了一个函数声明

200
00:09:03,190 --> 00:09:07,640
因为这将成倍功能
两个浮点数在一起。

201
00:09:07,640 --> 00:09:09,330
希望你暂停视频。

202
00:09:09,330 --> 00:09:12,950
>> 因此，让我们来看看一个例子
的一个可能的声明。

203
00:09:12,950 --> 00:09:17,340
浮法MULT 2雷亚尔浮动的x，浮法年。

204
00:09:17,340 --> 00:09:19,090
两种产品
浮点数

205
00:09:19,090 --> 00:09:21,710
这还记得是怎么我们
代表实数

206
00:09:21,710 --> 00:09:26,770
或具有在C十进制值号码，
将是一个浮点数。

207
00:09:26,770 --> 00:09:28,570
当你乘一个
十进制转换成十进制，

208
00:09:28,570 --> 00:09:30,460
你可能会得到一个小数。

209
00:09:30,460 --> 00:09:31,960
你想给它一个相关名称。

210
00:09:31,960 --> 00:09:33,810
将两个实数似乎罚款。

211
00:09:33,810 --> 00:09:36,620
但是，你真的可以称之为
MULT两个浮点数，或MULT浮动。

212
00:09:36,620 --> 00:09:39,540
类似的东西，只要它
提出了一些实际的意义是什么

213
00:09:39,540 --> 00:09:41,469
这个黑盒子的打算。

214
00:09:41,469 --> 00:09:44,260
再次，在这种情况下，我们不
似乎有什么意义连接

215
00:09:44,260 --> 00:09:46,390
到的名字
变量，我们正在传递，

216
00:09:46,390 --> 00:09:48,645
所以我们只是叫他们x和y。

217
00:09:48,645 --> 00:09:51,020
现在，如果你打电话给他们的东西
否则，这是完全罚款。

218
00:09:51,020 --> 00:09:53,310
事实上，如果你这样做
该声明代替

219
00:09:53,310 --> 00:09:55,450
用双打，而不是
彩车，如果你还记得

220
00:09:55,450 --> 00:09:59,100
双打是一个不同的
的方式来更精确地

221
00:09:59,100 --> 00:10:02,330
指定实数或
浮点变量。

222
00:10:02,330 --> 00:10:03,620
这是完全正常了。

223
00:10:03,620 --> 00:10:04,670
无论是其中的一个就可以了。

224
00:10:04,670 --> 00:10:06,711
实际上，有几个
不同的组合

225
00:10:06,711 --> 00:10:08,410
办法宣称此功能。

226
00:10:08,410 --> 00:10:10,884
但是，这是两个非常好的。

227
00:10:10,884 --> 00:10:12,550
我们声明的函数，这是伟大的。

228
00:10:12,550 --> 00:10:15,700
我们已经告诉编译器是什么
是，我们要怎么做。

229
00:10:15,700 --> 00:10:17,630
现在，让我们实际写的功能。

230
00:10:17,630 --> 00:10:20,750
让我们给它一个定义，
使里面的黑盒子

231
00:10:20,750 --> 00:10:22,840
可预测的行为发生。

232
00:10:22,840 --> 00:10:26,270
事实上，我们正在成倍两个实
数字加在一起，或添加号

233
00:10:26,270 --> 00:10:29,760
在一起，或做不管它是什么
我们要求我们的函数来完成。

234
00:10:29,760 --> 00:10:32,780
>> 所以，事实上，让我们尝试并确定
将两个实数，我们刚

235
00:10:32,780 --> 00:10:35,350
谈到一秒钟前。

236
00:10:35,350 --> 00:10:38,560
现在开始
函数定义

237
00:10:38,560 --> 00:10:41,720
看起来几乎一模一样
作为一个函数声明。

238
00:10:41,720 --> 00:10:43,170
我有他们两个在这里。

239
00:10:43,170 --> 00:10:47,770
在顶部是函数声明，
类型，名称，逗号隔开说法

240
00:10:47,770 --> 00:10:49,410
列表中，分号。

241
00:10:49,410 --> 00:10:53,800
分号表明，
这是一个函数声明。

242
00:10:53,800 --> 00:10:57,060
该函数的开始
定义看起来几乎一模一样

243
00:10:57,060 --> 00:11:03,790
同样，类型，名称，逗号分隔
参数列表，别无分号，

244
00:11:03,790 --> 00:11:05,206
打开大括号。

245
00:11:05,206 --> 00:11:07,580
花括号，就像
我们一直在做与主，

246
00:11:07,580 --> 00:11:09,540
意味着我们现在
开始确定

247
00:11:09,540 --> 00:11:14,567
暗箱内发生的事情是
我们已经决定把MULT 2雷亚尔。

248
00:11:14,567 --> 00:11:15,900
这是实现它的一种方式。

249
00:11:15,900 --> 00:11:20,370
我们可以说，我们可以宣布一个新的
float类型叫做产品变动

250
00:11:20,370 --> 00:11:24,020
并指定该变量
到值x乘以y。

251
00:11:24,020 --> 00:11:27,306
然后返回产品。

252
00:11:27,306 --> 00:11:28,430
这是什么意思返回这里。

253
00:11:28,430 --> 00:11:31,090
那么回报的方式
我们表明，是如何

254
00:11:31,090 --> 00:11:33,400
我们传递的输出退了出去。

255
00:11:33,400 --> 00:11:38,160
所以返回的东西，是一样的，
这是黑盒的输出。

256
00:11:38,160 --> 00:11:40,732
所以，这就是你如何做到这一点。

257
00:11:40,732 --> 00:11:42,190
这里是另一种方式来实现它。

258
00:11:42,190 --> 00:11:45,050
我们可以只返回X乘以y。

259
00:11:45,050 --> 00:11:45,870
x是一个浮动。

260
00:11:45,870 --> 00:11:46,660
y是一个浮动。

261
00:11:46,660 --> 00:11:48,490
所以x次Ÿ也是浮动。

262
00:11:48,490 --> 00:11:50,750
我们甚至不需要到
创建另一个变量。

263
00:11:50,750 --> 00:11:56,750
所以这是一个不同的方式来
实行完全相同的黑盒子。

264
00:11:56,750 --> 00:11:58,570
>> 现在花一点时间，
再次暂停视频，

265
00:11:58,570 --> 00:12:01,680
和尝试，并定义添加两个整数，
这是其他函数，我们

266
00:12:01,680 --> 00:12:03,090
刚才讲到。

267
00:12:03,090 --> 00:12:06,440
同样在这里，我已经把功能
报关等分号，

268
00:12:06,440 --> 00:12:08,420
和开放的大括号
和封闭的卷曲

269
00:12:08,420 --> 00:12:12,080
括号来表示，我们将填写
在内容添加两个整数，

270
00:12:12,080 --> 00:12:15,530
让我们定义的特定
行为里面的黑盒子。

271
00:12:15,530 --> 00:12:16,380
因此，暂停视频。

272
00:12:16,380 --> 00:12:18,790
并采取尽可能多的时间
你需要尝试和定义

273
00:12:18,790 --> 00:12:25,040
的实现添加两个整数，比如
当函数输出值，

274
00:12:25,040 --> 00:12:29,209
确实如此，实际上，回
的两个输入端的总和。

275
00:12:29,209 --> 00:12:32,000
所以，就像前面的例子，
有几种不同的方式

276
00:12:32,000 --> 00:12:34,210
你可以实现添加两个整数。

277
00:12:34,210 --> 00:12:35,130
这里有一个。

278
00:12:35,130 --> 00:12:37,172
在这里橙色我有
只是有一些comments--

279
00:12:37,172 --> 00:12:38,880
我只是增加了一些
意见指出

280
00:12:38,880 --> 00:12:41,400
什么在每一行代码。

281
00:12:41,400 --> 00:12:45,430
所以，我声明一个变量
所谓类型为int的总和。

282
00:12:45,430 --> 00:12:47,279
我说的总和等于a与b。

283
00:12:47,279 --> 00:12:50,070
这就是我们实际上做
工作添加A和B一起。

284
00:12:50,070 --> 00:12:51,850
我回到总和。

285
00:12:51,850 --> 00:12:56,460
这是有道理的，因为
总之是一个int类型的变量。

286
00:12:56,460 --> 00:13:00,180
什么是数据类型，这
功能告诉我这是怎么回事输出？

287
00:13:00,180 --> 00:13:00,680
诠释。

288
00:13:00,680 --> 00:13:03,072
所以我回国总和，这
是一个整型变量。

289
00:13:03,072 --> 00:13:06,030
这是有道理的给予我们所
声明和定义我们的函数

290
00:13:06,030 --> 00:13:07,320
去做。

291
00:13:07,320 --> 00:13:09,700
>> 现在，您也可以定义
该功能通过这种方式，

292
00:13:09,700 --> 00:13:15,260
INT总和等于加b--跳过
第一step--然后返回总和。

293
00:13:15,260 --> 00:13:17,760
现在，你可以有也
实现这种方式，

294
00:13:17,760 --> 00:13:19,180
我强烈不推荐。

295
00:13:19,180 --> 00:13:22,540
这是不好的风格一
的事情，真的很糟糕的设计，

296
00:13:22,540 --> 00:13:24,420
但它确实，实际上工作。

297
00:13:24,420 --> 00:13:30,199
如果你把这个代码，这为int
加上糟糕的加法点C，并使用它。

298
00:13:30,199 --> 00:13:31,990
它实际上确实增加
两个整数在一起。

299
00:13:31,990 --> 00:13:37,632
这是一个非常糟糕的实现
这种特定的行为。

300
00:13:37,632 --> 00:13:38,340
但它确实工作。

301
00:13:38,340 --> 00:13:41,200
它只是在这里说明
我们真的不点

302
00:13:41,200 --> 00:13:44,530
关心会发生什么内
黑盒子，只要

303
00:13:44,530 --> 00:13:46,510
因为它具有我们希望的输出。

304
00:13:46,510 --> 00:13:48,870
这是一个设计不当的黑盒子。

305
00:13:48,870 --> 00:13:53,801
但在最后一天，但它确实
仍然输出的a与b之和。

306
00:13:53,801 --> 00:13:54,300
好吧。

307
00:13:54,300 --> 00:13:56,320
因此，我们声明的函数。

308
00:13:56,320 --> 00:13:57,490
而我们定义的功能。

309
00:13:57,490 --> 00:13:58,540
所以，这真的很好。

310
00:13:58,540 --> 00:14:03,020
现在，让我们开始使用功能
我们已经宣布，我们已经定义。

311
00:14:03,020 --> 00:14:05,960
要调用function--它实际上
漂亮easy--所有你需要做的

312
00:14:05,960 --> 00:14:09,070
是它传递合适的参数，
该数据类型的参数

313
00:14:09,070 --> 00:14:11,600
它预计，和
然后分配收益

314
00:14:11,600 --> 00:14:15,190
该函数的值
和this--借口我 - 

315
00:14:15,190 --> 00:14:19,390
分配一个函数的返回值
的东西正确的类型。

316
00:14:19,390 --> 00:14:22,410
>> 因此，让我们来看看
这在实践中的文件

317
00:14:22,410 --> 00:14:27,730
所谓加法器1点C，这
我在我的CS50的IDE。

318
00:14:27,730 --> 00:14:31,042
因此，这里是加法器1个点以下。

319
00:14:31,042 --> 00:14:33,500
在开始的时候你看我有
我包括，一斤包括，

320
00:14:33,500 --> 00:14:35,460
标准IO和CS50点小时。

321
00:14:35,460 --> 00:14:37,700
然后，我有我的函数声明。

322
00:14:37,700 --> 00:14:39,570
这就是我
告诉编译器，我

323
00:14:39,570 --> 00:14:42,850
要编写一个
函数调用添加两个整数。

324
00:14:42,850 --> 00:14:45,780
这将输出
整型变量。

325
00:14:45,780 --> 00:14:47,360
这就是这部分就在这里什么。

326
00:14:47,360 --> 00:14:51,950
然后，我有两个输入给它的
和b，其各自是一个整数。

327
00:14:51,950 --> 00:14:58,250
里面的主，我询问用户
说输入，给我一个整数。

328
00:14:58,250 --> 00:15:01,040
而系统会提示他们忘记
int，它是一个函数，

329
00:15:01,040 --> 00:15:03,240
包含在CS50库。

330
00:15:03,240 --> 00:15:07,660
而这被存储在
X，整数变量。

331
00:15:07,660 --> 00:15:09,886
>> 然后，我们提示他们输入另一个整数。

332
00:15:09,886 --> 00:15:13,070
我们得到另一个整数
并存储y中。

333
00:15:13,070 --> 00:15:17,990
然后，在这里第28行，是
在这里，我们让我们的函数调用。

334
00:15:17,990 --> 00:15:23,770
我们说，INT z等于
加2个整数x逗号年。

335
00:15:23,770 --> 00:15:25,980
你明白为什么这是有道理的？

336
00:15:25,980 --> 00:15:29,710
x为整数变量类型和
y是一个整数类型的变量。

337
00:15:29,710 --> 00:15:31,220
所以这是很好的。

338
00:15:31,220 --> 00:15:34,570
有意义的什么我们的函数
声明在第17行的样子。

339
00:15:34,570 --> 00:15:38,300
用逗号分隔的输入列表
预计两个整数，a和b。

340
00:15:38,300 --> 00:15:40,300
在这种情况下，我们可以调用
他们可以随心所欲。

341
00:15:40,300 --> 00:15:42,300
它只是需要两个整数。

342
00:15:42,300 --> 00:15:44,930
和x为整数，y为整数。

343
00:15:44,930 --> 00:15:45,640
这一工程。

344
00:15:45,640 --> 00:15:48,680
>> 我们知道，函数是怎么回事
输出一个整数为好。

345
00:15:48,680 --> 00:15:51,290
因此，我们的存储
函数的输出，

346
00:15:51,290 --> 00:15:56,050
添加两个整数，在整型
变量，我们称之为ž。

347
00:15:56,050 --> 00:16:01,980
然后，我们可以说，总和
我百分之百分之和我是百分之我。

348
00:16:01,980 --> 00:16:06,210
分别的x，y和z
填写这些百分比我的。

349
00:16:06,210 --> 00:16:08,334
的定义是什么
添加两个整数是什么样子？

350
00:16:08,334 --> 00:16:09,125
这是很简单的。

351
00:16:09,125 --> 00:16:11,270
它是那些一个大家
刚刚看到一秒钟前，

352
00:16:11,270 --> 00:16:14,390
INT总和等于a与b的回报总和。

353
00:16:14,390 --> 00:16:15,420
工作的呢？

354
00:16:15,420 --> 00:16:17,270
让我们来保存文件。

355
00:16:17,270 --> 00:16:22,080
然后放在这儿我的终端
我会做加法器1，

356
00:16:22,080 --> 00:16:23,000
我清楚我的屏幕。

357
00:16:23,000 --> 00:16:25,791
我要放大，因为我知道，
这是一个有点难以看到。

358
00:16:25,791 --> 00:16:31,520

359
00:16:31,520 --> 00:16:33,770
>> 因此，我们编译这个程序是加法器1。

360
00:16:33,770 --> 00:16:37,910
因此，我们可以做点斜线加法器1。

361
00:16:37,910 --> 00:16:40,060
给我一个整数，10。

362
00:16:40,060 --> 00:16:42,380
给我另一个整数，20。

363
00:16:42,380 --> 00:16:45,200
的10和20的总和为30。

364
00:16:45,200 --> 00:16:47,615
所以我们做了一个成功的函数调用。

365
00:16:47,615 --> 00:16:55,820
您可以再次运行该功能，负
10，17和的负10和17是7。

366
00:16:55,820 --> 00:16:57,120
此功能。

367
00:16:57,120 --> 00:16:59,240
它的行为
我们期待它。

368
00:16:59,240 --> 00:17:03,610
所以，我们做了一个成功的
函数的定义，声明，

369
00:17:03,610 --> 00:17:07,288
而一个成功的函数调用。

370
00:17:07,288 --> 00:17:09,079
情侣杂
关于功能点

371
00:17:09,079 --> 00:17:10,611
我们结束本节之前。

372
00:17:10,611 --> 00:17:12,319
回想一下我们的
数据类型的讨论中，

373
00:17:12,319 --> 00:17:16,109
先前，该功能
有时可以不取输入。

374
00:17:16,109 --> 00:17:17,930
如果是这样的话，我们
声明函数

375
00:17:17,930 --> 00:17:19,788
为具有空参数列表。

376
00:17:19,788 --> 00:17:21,579
你还记得什么
最常用的功能

377
00:17:21,579 --> 00:17:25,036
我们到目前为止看到的需要
一个void参数列表？

378
00:17:25,036 --> 00:17:27,300
它的主要。

379
00:17:27,300 --> 00:17:30,850
有时还记得那个函数
实际上并没有输出。

380
00:17:30,850 --> 00:17:34,210
在这种情况下，我们声明函数
为具有void返回类型。

381
00:17:34,210 --> 00:17:37,880
让我们通过结束本节
解决实践问题。

382
00:17:37,880 --> 00:17:39,900
>> 因此，这里的布局问题。

383
00:17:39,900 --> 00:17:43,630
我要你写一个函数
所谓有效的三角形。

384
00:17:43,630 --> 00:17:47,410
这是什么功能应该做的
是采取三个实数

385
00:17:47,410 --> 00:17:51,930
代表三个的长度
一个三角形作为其参数的两侧，

386
00:17:51,930 --> 00:17:54,550
或者它的参数，或者其
inputs--另一组同义词

387
00:17:54,550 --> 00:17:57,340
你可能会遇到的问题。

388
00:17:57,340 --> 00:18:01,120
这应该功能
无论是输出真或假

389
00:18:01,120 --> 00:18:04,960
这取决于这三个长度
有能力作出一个三角形。

390
00:18:04,960 --> 00:18:09,930
你还记得的数据类型
我们用来表示真的还是假的？

391
00:18:09,930 --> 00:18:11,436
现在，你如何实现这一点？

392
00:18:11,436 --> 00:18:13,810
都知道有一对夫妇
关于三角形规则

393
00:18:13,810 --> 00:18:15,480
这实际上是需要了解的。

394
00:18:15,480 --> 00:18:18,292
三角形只能有
两面带正长度。

395
00:18:18,292 --> 00:18:19,000
这就说得通了。

396
00:18:19,000 --> 00:18:21,432
你可能会说，真不错。

397
00:18:21,432 --> 00:18:23,390
另外要注意的
虽然，是总和

398
00:18:23,390 --> 00:18:25,484
的任何长度的
三角形的两边

399
00:18:25,484 --> 00:18:27,650
必须大于
长度的第三边的。

400
00:18:27,650 --> 00:18:28,690
这是真的。

401
00:18:28,690 --> 00:18:34,150
你不能有边1的三角形，
2和4中，例如，因为1加2

402
00:18:34,150 --> 00:18:36,270
是不大于4。

403
00:18:36,270 --> 00:18:38,870
因此，这些都是规则
确定是否三

404
00:18:38,870 --> 00:18:42,740
输入可以设想形成一个三角形。

405
00:18:42,740 --> 00:18:46,360
因此，需要一两分钟
并宣布再定义

406
00:18:46,360 --> 00:18:49,810
这个功能称为有效
实际上三角形，使得其

407
00:18:49,810 --> 00:18:51,650
在这里有规定的行为。

408
00:18:51,650 --> 00:18:57,030
>> 它会输出真实的，如果这三个方面
能够包括一个三角形，

409
00:18:57,030 --> 00:19:01,950
否则为假
准备看你怎么做？

410
00:19:01,950 --> 00:19:04,650
这里有一个实施
有效的三角形。

411
00:19:04,650 --> 00:19:05,770
这不是唯一的一个。

412
00:19:05,770 --> 00:19:07,770
你可能会略有不同。

413
00:19:07,770 --> 00:19:11,040
但是，这一次呢，其实，有
我们期望的行为。

414
00:19:11,040 --> 00:19:14,450
我们宣布我们的函数在
极顶，布尔有效的三角

415
00:19:14,450 --> 00:19:16,630
浮x浮动Ÿ浮动ž。

416
00:19:16,630 --> 00:19:18,930
如此反复，该功能
有三个实数

417
00:19:18,930 --> 00:19:22,280
它的参数，浮动
点值的变量，

418
00:19:22,280 --> 00:19:26,510
并输出真或假
值，这是一个布尔值，召回。

419
00:19:26,510 --> 00:19:28,660
所以这就是为什么返回类型为布尔。

420
00:19:28,660 --> 00:19:30,016
然后，我们定义的功能。

421
00:19:30,016 --> 00:19:33,140
我们做的第一件事是检查，以确保
所有的边都是正的。

422
00:19:33,140 --> 00:19:37,010
如果x小于或等于
为0，或如果y等于0，

423
00:19:37,010 --> 00:19:41,050
或者如果z为小于或等于0，
这不可能是一个三角形。

424
00:19:41,050 --> 00:19:42,380
它们不具有正面侧。

425
00:19:42,380 --> 00:19:45,790
因此，我们可以返回
假在这种情况下。

426
00:19:45,790 --> 00:19:49,010
接下来，我们检查以确保
每对输入

427
00:19:49,010 --> 00:19:51,830
大于第三个。

428
00:19:51,830 --> 00:19:54,530
>> 所以如果x加y是少
大于或等于z，

429
00:19:54,530 --> 00:19:57,060
或者如果x加z是少
大于或等于y，

430
00:19:57,060 --> 00:20:01,730
或者如果y加z为小于或等于
的x，也不能有效的三角形。

431
00:20:01,730 --> 00:20:03,800
因此，我们返回false了。

432
00:20:03,800 --> 00:20:06,900
假设我们通过两个检查
虽然，那么我们就可以返回true。

433
00:20:06,900 --> 00:20:09,440
由于这三面
能够returning--的

434
00:20:09,440 --> 00:20:11,647
中创建一个有效的三角形。

435
00:20:11,647 --> 00:20:12,230
就是这样。

436
00:20:12,230 --> 00:20:13,830
现在，您已经声明和定义。

437
00:20:13,830 --> 00:20:17,330
你也许可以现在
使用和调用此函数。

438
00:20:17,330 --> 00:20:19,470
做得好。

439
00:20:19,470 --> 00:20:20,650
我是道格·劳埃德。

440
00:20:20,650 --> 00:20:22,820
这是CS50。

441
00:20:22,820 --> 00:20:24,340