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
そしてこれは3つの入力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
それは三つの入力、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
>> 同様に、あなたは呼び出された関数を持っています
2つの入力A、Bを取りMULT、

51
00:02:17,940 --> 00:02:21,070
そのようないくつかの方法でそれらを処理します
その関数の出力

52
00:02:21,070 --> 00:02:22,920
2つの入力の製品です。

53
00:02:22,920 --> 00:02:25,080
2つの入力が掛け合わさ。

54
00:02:25,080 --> 00:02:29,150
図4及び図5は、MULTに渡されます
何かが、私たちが期待する出力を発生します

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
我々は、例えば、プリントFを見てきました
私たちが書いていない機能があります

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、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
私たちは、呼び出された関数を使用している場合
2つの入力を取りMULT。

68
00:03:01,370 --> 00:03:04,750
我々は、出力があろうと期待されます
2つの入力は、乗算しました

69
00:03:04,750 --> 00:03:06,240
回B。

70
00:03:06,240 --> 00:03:09,170
しかし、MULTも可能性があり
このように実装、

71
00:03:09,170 --> 00:03:13,150
私たちは、カウンタ変数にを持っています
0にMULTの内部にセットされます。

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
5回繰り返して、カウンタに3を追加します。

75
00:03:27,700 --> 00:03:34,490
だから我々は、0から開始し、我々がやります
この5回の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
関数または千ライン機能。

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
その1の私を信頼します。

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
私たちは、リサイクルおよび使用してきました
40年以上にわたり、fを出力します。

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
だから我々は単にコンパイラaを与えます
ヘッドアップ、私は関数を作成しています

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
関数の3つの部分があります。
宣言、戻り値の型、名前、

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に名前を付ける場合、または
時間や謎またはそのような何か、

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
ちょうど見てみましょう
より具体的な1時。

157
00:07:10,220 --> 00:07:13,130
そこでここでは関数の例を示します。
その関数の宣言

158
00:07:13,130 --> 00:07:14,925
一緒に2つの整数を追加します。

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
それはちょうど2つのintを追加することを教えてくれる
一日の終わりに起こっています、

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
2つのintと思われる追加
考慮して、適切な

166
00:07:33,630 --> 00:07:37,574
我々は、入力として2つの整数を取っています
うまくいけば、それらを一緒に加えます。

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
ので、我々はそれが2つのintを追加呼ぶことにします。

172
00:07:52,860 --> 00:07:55,230
最後に、この関数は2つの入力を取ります。

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
だから我々はちょうどそれらと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
私達はちょうど2つの整数を追加したいです。

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
2つの浮動小数点数を乗算？

192
00:08:42,940 --> 00:08:45,910
あなたは何を覚えていますかA
浮動小数点数はありますか？

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
掛けるだろう機能のために
2つの浮動小数点数。

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、Yフロートフロート。

204
00:09:17,340 --> 00:09:19,090
2の製品
浮動小数点数、

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
2実数を掛け罰金です。

211
00:09:33,810 --> 00:09:36,620
しかし、あなたは実際にそれを呼び出すことができます
MULT 2つのfloat、または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
>> だから実際には、のがしようとすると定義してみましょう
ちょうど私達2実数を掛けます

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
ここで、それを実現する1つの方法です。

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
私達はちょうどY x回を返すことができます。

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だからyはまた、フロートです。

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
そして、2つのintを追加しようとすると定義
これは、他の関数である我々

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
我々は記入する場所を示すためにブレース
内容に、2つのintを追加

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
実装は2つのintを追加し、そのような
その関数が値を出力すると、

274
00:12:25,040 --> 00:12:29,209
それは実際には、ありません、リターン
2つの入力の合計。

275
00:12:29,209 --> 00:12:32,000
だから、前の例のように、
いくつかの異なる方法があります

276
00:12:32,000 --> 00:12:34,210
あなたは、2つのintを追加実装することができること。

277
00:12:34,210 --> 00:12:35,130
ここに1つです。

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
私は、合計がプラスBに等しいと言います。

283
00:12:47,279 --> 00:12:50,070
私たちが実際にやっているところです
仕事が追加と一緒に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
Int。

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
これは、1つの悪いスタイルです
事と本当に悪いデザイン、

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
これは、実際に追加しません
2つの整数。

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
しかし、最後の日に、それはありません
まだ出力プラス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--言い訳me--

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点cです。

319
00:14:31,042 --> 00:14:33,500
初めに、あなたは私が持っている参照してください。
私は、ポンドが含まれ、含まれ、

320
00:14:33,500 --> 00:14:35,460
標準入出力、および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
書くことになるだろう
呼び出された関数は、2つのintを追加します。

324
00:14:42,850 --> 00:14:45,780
これは、出力ANに起こっています
整数型の変数。

325
00:14:45,780 --> 00:14:47,360
つまり、この部分はここでです。

326
00:14:47,360 --> 00:14:51,950
そして、私はそれに2つの入力を持っています
aと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 int型のxコンマYを追加します。

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
カンマ区切りの入力リスト
2つの整数aとbのを期待しています。

340
00:15:38,300 --> 00:15:40,300
その場合は、呼び出すことができます
それら何でも私たちが望みます。

341
00:15:40,300 --> 00:15:42,300
それはちょうど2つの整数を期待しています。

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
整数型では、2つのintを追加
変数、我々は、zを呼んでいます。

347
00:15:56,050 --> 00:16:01,980
そして、我々は、の合計を言うことができます
％がiとパーセント私は％です。

348
00:16:01,980 --> 00:16:06,210
X、YおよびZはそれぞれ
これらのパーセント私の年代に埋めます。

349
00:16:06,210 --> 00:16:08,334
の定義は何ですか
2つのintは次のように追加しますか？

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型の合計はプラス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は、負の10と17の合計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
我々はかかるという、これまで見てきました
ボイド引数リストはありますか？

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
その場合は、関数を宣言
ボイド戻り値の型を持つように。

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
この関数は何をすべき
3つの実数値を取ることです

385
00:17:47,410 --> 00:17:51,930
それは3の長さを表します
そのパラメータとして三角形の辺、

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
これらの3つの長さかどうかに応じて、
三角形を作ることが可能です。

390
00:18:04,960 --> 00:18:09,930
あなたはそのデータ型を覚えていますか
私たちは、trueまたはfalseを示すために使用しますか？

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
より大きくなければなりません
第3辺の長さ。

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
だから、それらは、その規則です
決定する3つのかどうか

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
>> それは、これらの3つの側面であれば、真の出力は以下となります
、三角形を含むことが可能です

409
00:18:57,030 --> 00:19:01,950
そうでない場合はfalse
あなたがやった方法を確認する準備はできましたか？

410
00:19:01,950 --> 00:19:04,650
ここに1つの実装です
有効な三角形の。

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フロートYフロートZ。

416
00:19:16,630 --> 00:19:18,930
だからもう一度、この機能
3つの実数値をとります

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
そして、私たちは返すことができます
そのような状況ではfalse。

426
00:19:45,790 --> 00:19:49,010
次に、我々は確認してください
その入力のすべてのペア

427
00:19:49,010 --> 00:19:51,830
第1より大きい。

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
これらの3つの側面ため、
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