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