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

2
00:00:04,664 --> 00:00:05,580
DOUG LLOYD: Très bien.

3
00:00:05,580 --> 00:00:08,877
Alors maintenant, nous allons aborder un
vraiment grand sujet, fonctions.

4
00:00:08,877 --> 00:00:11,460
Jusqu'à présent, dans le cadre, tous les
les programmes que nous avons écrit

5
00:00:11,460 --> 00:00:12,969
ont été écrit à l'intérieur de la principale.

6
00:00:12,969 --> 00:00:14,260
Ils sont des programmes assez simple.

7
00:00:14,260 --> 00:00:16,940
Vous ne devez pas avoir toutes ces
les branches et les choses qui se passent.

8
00:00:16,940 --> 00:00:18,773
Nous pouvons simplement adapter tout
à l'intérieur de ce principal et

9
00:00:18,773 --> 00:00:20,407
ne soyez pas terriblement écrasante.

10
00:00:20,407 --> 00:00:22,990
Mais que le cours se poursuit et
que vous commencez à développer des programmes

11
00:00:22,990 --> 00:00:26,260
indépendamment, ils vont probablement
pour commencer à obtenir beaucoup plus de 10

12
00:00:26,260 --> 00:00:27,200
ou 15 lignes.

13
00:00:27,200 --> 00:00:31,400
Vous pouvez obtenir des centaines ou des milliers
ou des dizaines de milliers de lignes de code.

14
00:00:31,400 --> 00:00:34,690
Et il est vraiment pas
ce fou une pensée.

15
00:00:34,690 --> 00:00:39,720
En tant que tel, il est probablement pas une bonne idée
de tout garder à l'intérieur de la principale.

16
00:00:39,720 --> 00:00:43,240
Il peut être un peu difficile à trouver
ce que vous cherchez si vous faites cela.

17
00:00:43,240 --> 00:00:47,040
>> Heureusement, si C, et à peu près
chaque autre langage de programmation qui

18
00:00:47,040 --> 00:00:50,386
pourrait travailler avec, permet
nous écrivions fonctions.

19
00:00:50,386 --> 00:00:52,260
Et je vais juste
prendre une petite parenthèse ici

20
00:00:52,260 --> 00:00:54,971
de mentionner que des fonctions est
un domaine de la science informatique.

21
00:00:54,971 --> 00:00:57,970
Et vous verrez beaucoup plus d'entre eux à
différents points tout au long

22
00:00:57,970 --> 00:00:59,290
et si vous continuez sur.

23
00:00:59,290 --> 00:01:02,280
Là où il ya un grand nombre de
synonymes pour le même mot.

24
00:01:02,280 --> 00:01:03,390
Nous appelons donc les fonctions.

25
00:01:03,390 --> 00:01:05,980
Mais vous pourriez aussi les entendre
dénommé procédures,

26
00:01:05,980 --> 00:01:09,570
ou des méthodes, en particulier, si vous avez déjà
fait toute la programmation orientée objet

27
00:01:09,570 --> 00:01:11,950
before-- et ne vous inquiétez pas
si vous ne l'avez pas, pas

28
00:01:11,950 --> 00:01:14,280
un grand Deal-- mais dans
vérification des langages orientés

29
00:01:14,280 --> 00:01:16,129
sont souvent appelées méthodes.

30
00:01:16,129 --> 00:01:17,670
Parfois, ils sont appelés des sous-routines.

31
00:01:17,670 --> 00:01:20,690
Mais ils ont vraiment se réfèrent tous
à la même idée de base.

32
00:01:20,690 --> 00:01:22,480
>> Voyons voir ce que cette idée est.

33
00:01:22,480 --> 00:01:23,310
Qu'est-ce qu'une fonction?

34
00:01:23,310 --> 00:01:26,470
Eh bien une fonction est vraiment
rien de plus qu'une boîte noire.

35
00:01:26,470 --> 00:01:31,430
Une boîte noire qui a un ensemble de zéro
ou plusieurs entrées et une seule sortie.

36
00:01:31,430 --> 00:01:33,420
Ainsi, par exemple, cette
pourrait être une fonction.

37
00:01:33,420 --> 00:01:35,510
Ceci est une fonction appelée FUNC.

38
00:01:35,510 --> 00:01:39,330
Et il faut trois entrées a, b et c.

39
00:01:39,330 --> 00:01:42,580
Et à l'intérieur de cette boîte noire, nous
je ne sais pas exactement ce qu'il fait,

40
00:01:42,580 --> 00:01:45,100
mais il traite les entrées
en quelque sorte, et puis il

41
00:01:45,100 --> 00:01:48,680
donne une sortie unique, dans ce cas, z.

42
00:01:48,680 --> 00:01:50,504
Maintenant, pour faire un peu
moins résumé, nous

43
00:01:50,504 --> 00:01:52,420
pourrait dire que peut-être nous
avoir une fonction appelée

44
00:01:52,420 --> 00:01:58,750
ajouter que prend trois entrées A, B, et
c et traite la sortie d'une certaine façon

45
00:01:58,750 --> 00:02:01,010
l'intérieur de la boîte noire
produire une seule sortie.

46
00:02:01,010 --> 00:02:05,190
Donc dans ce cas, si
ajouter prend 3, 6, et 7.

47
00:02:05,190 --> 00:02:07,020
Quelque part à l'intérieur du
ajouter la fonction, nous le ferions

48
00:02:07,020 --> 00:02:09,750
attendre d'eux pour être additionnés
pour produire la sortie, qui

49
00:02:09,750 --> 00:02:13,220
3 est plus 6 plus 7 ou 16.

50
00:02:13,220 --> 00:02:17,940
>> De même, vous avez une fonction appelée
mult qui prend deux entrées, a et b,

51
00:02:17,940 --> 00:02:21,070
les traite d'une certaine manière
que la sortie de la fonction

52
00:02:21,070 --> 00:02:22,920
est le produit des deux entrées.

53
00:02:22,920 --> 00:02:25,080
Les deux entrées multipliés ensemble.

54
00:02:25,080 --> 00:02:29,150
4 et 5 étant passé dans mult,
quelque chose se passe, nous nous attendons à la sortie

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

56
00:02:31,090 --> 00:02:32,507
Pourquoi avons-nous l'appelons une boîte noire?

57
00:02:32,507 --> 00:02:34,840
Eh bien, si nous ne faisons pas la
nous fonctions, qui

58
00:02:34,840 --> 00:02:36,869
nous avons fait un peu jusqu'ici CS50.

59
00:02:36,869 --> 00:02:39,910
Nous avons vu impression f, par exemple, qui
est une fonction que nous ne écrivons

60
00:02:39,910 --> 00:02:42,305
nous-mêmes, mais nous utilisons tout le temps.

61
00:02:42,305 --> 00:02:44,180
Si nous ne sommes pas écrivons
les fonctions mêmes,

62
00:02:44,180 --> 00:02:48,450
nous ne pas vraiment besoin de savoir comment il est
effectivement mis en œuvre sous le capot.

63
00:02:48,450 --> 00:02:51,710
>> Ainsi, par exemple la boîte noire I
viens de vous montrer pour la multiplication,

64
00:02:51,710 --> 00:02:53,740
mult a, b pourrait être
defined-- et cela est juste

65
00:02:53,740 --> 00:02:57,902
certains pseudocode-- pourrait être
définie comme une fois sortie de b.

66
00:02:57,902 --> 00:02:58,860
Qui font sens, à droite.

67
00:02:58,860 --> 00:03:01,370
Si nous avons une fonction appelée
mult qui prend deux entrées.

68
00:03:01,370 --> 00:03:04,750
Nous nous attendons à ce que la sortie serait
être les deux entrées multipliées ensemble,

69
00:03:04,750 --> 00:03:06,240
une fois b.

70
00:03:06,240 --> 00:03:09,170
Mais mult pourrait également être
mise en œuvre de ce type,

71
00:03:09,170 --> 00:03:13,150
nous avons un compteur variable
se mettre à l'intérieur de mult à 0.

72
00:03:13,150 --> 00:03:18,000
Et puis nous répétons ce processus
b fois ajouter un à contrer.

73
00:03:18,000 --> 00:03:24,270
Par exemple, si l'on multiplie par 3 bis,
5b, nous pourrions dire définir compteur à 0,

74
00:03:24,270 --> 00:03:27,700
Répétez cinq fois, ajouter 3 à contrer.

75
00:03:27,700 --> 00:03:34,490
Nous commençons donc à 0 et ensuite nous faisons
cinq fois cette 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
Il est le même résultat. nous
toujours obtenir 3 fois 5 seulement

77
00:03:37,500 --> 00:03:39,500
la mise en œuvre est différente.

78
00:03:39,500 --> 00:03:41,490
>> Voilà ce que nous entendons
quand nous disons une boîte noire.

79
00:03:41,490 --> 00:03:44,406
Cela signifie simplement que nous ne nous soucions pas vraiment
comment il est mis en œuvre sous le capot

80
00:03:44,406 --> 00:03:46,170
aussi longtemps que la sortie est ce que nous attendons.

81
00:03:46,170 --> 00:03:49,045
En fait, cela fait partie du contrat
de l'utilisation des fonctions, en particulier

82
00:03:49,045 --> 00:03:50,630
fonctions que d'autres écrivent.

83
00:03:50,630 --> 00:03:53,980
Le comportement va toujours
être typique, imprévisible

84
00:03:53,980 --> 00:03:55,420
sur la base du nom de la fonction.

85
00:03:55,420 --> 00:03:57,500
Et voilà pourquoi il est vraiment
important lorsque vous écrivez fonctions

86
00:03:57,500 --> 00:04:00,020
ou lorsque d'autres gens écrivent
fonctions que vous pouvez utiliser,

87
00:04:00,020 --> 00:04:03,590
que ces fonctions doivent
, des noms relativement évidentes, claires

88
00:04:03,590 --> 00:04:04,990
et sont bien documentés.

89
00:04:04,990 --> 00:04:08,560
Ce qui est certainement le cas
pour la fonction comme l'impression f.

90
00:04:08,560 --> 00:04:09,860
>> Alors pourquoi nous utilisons des fonctions?

91
00:04:09,860 --> 00:04:14,220
Eh bien comme je le disais plus tôt, si nous écrivons
l'ensemble de notre code à l'intérieur des choses principales

92
00:04:14,220 --> 00:04:17,120
peut être vraiment lourde
et vraiment compliqué.

93
00:04:17,120 --> 00:04:19,980
Fonctions nous permettent la capacité
d'organiser les choses et de briser

94
00:04:19,980 --> 00:04:24,540
un problème très compliqué en
beaucoup sous des pièces plus faciles à gérer.

95
00:04:24,540 --> 00:04:28,130
Fonctions nous permettent également de
simplifier le processus de codage.

96
00:04:28,130 --> 00:04:33,080
Il est beaucoup plus facile à déboguer un 10
fonction de la ligne par rapport à une ligne 100

97
00:04:33,080 --> 00:04:35,890
fonction ou une fonction de 1000 de la ligne.

98
00:04:35,890 --> 00:04:38,400
Si nous avons seulement à déboguer
petits morceaux à la fois,

99
00:04:38,400 --> 00:04:42,110
ou écrire des petits morceaux de l'époque,
il fait que l'expérience de programmation

100
00:04:42,110 --> 00:04:43,070
Beaucoup mieux.

101
00:04:43,070 --> 00:04:44,910
Croyez-moi sur ce point.

102
00:04:44,910 --> 00:04:48,400
>> Enfin, si nous écrivons fonctions nous
peut réutiliser ces différentes parties.

103
00:04:48,400 --> 00:04:49,880
Les fonctions peuvent être recyclés.

104
00:04:49,880 --> 00:04:51,880
Ils peuvent être utilisés dans
d'un programme ou d'une autre.

105
00:04:51,880 --> 00:04:53,713
Vous avez déjà écrit
la fonction, tout ce que vous

106
00:04:53,713 --> 00:04:56,530
besoin de faire est de dire que le programme
où trouver cette fonction.

107
00:04:56,530 --> 00:04:59,680
Nous avons recyclage et l'utilisation
f imprimer depuis plus de 40 ans.

108
00:04:59,680 --> 00:05:02,150
Mais il a été écrit qu'une seule fois.

109
00:05:02,150 --> 00:05:04,270
Très utile, à droite.

110
00:05:04,270 --> 00:05:04,830
Bien.

111
00:05:04,830 --> 00:05:06,040
Donc fonctions sont grands.

112
00:05:06,040 --> 00:05:06,860
Nous savons que.

113
00:05:06,860 --> 00:05:08,700
Maintenant, nous allons commencer à les écrire.

114
00:05:08,700 --> 00:05:10,830
Commençons obtenir
les dans nos programmes.

115
00:05:10,830 --> 00:05:13,869
Pour ce faire, la première
chose que nous faisons est de déclarer la fonction.

116
00:05:13,869 --> 00:05:16,160
Lorsque vous déclarez une fonction
ce que vous êtes essentiellement faire

117
00:05:16,160 --> 00:05:18,900
est de dire le compilateur,
hey, si vous le savez,

118
00:05:18,900 --> 00:05:20,850
Je vais être écrit
une fonction plus tard

119
00:05:20,850 --> 00:05:22,987
et voici ce que ça va ressembler.

120
00:05:22,987 --> 00:05:24,820
La raison en est
parce que les statisticiens peuvent

121
00:05:24,820 --> 00:05:27,900
faire des choses étranges si
ils voient un ensemble de symboles

122
00:05:27,900 --> 00:05:29,560
qu'ils ne sont pas familiers avec.

123
00:05:29,560 --> 00:05:33,000
Donc, nous donnons simplement le compilateur une
heads up, je crée une fonction

124
00:05:33,000 --> 00:05:35,492
et il va le faire.

125
00:05:35,492 --> 00:05:38,450
Les déclarations de fonctions généralement le cas
vous organisez votre code d'une manière

126
00:05:38,450 --> 00:05:41,872
que d'autres seront en mesure de
comprendre et faire usage de,

127
00:05:41,872 --> 00:05:44,330
vous souhaitez généralement de mettre tous
de vos déclarations de fonction

128
00:05:44,330 --> 00:05:48,220
tout en haut de votre code, droit
avant de commencer à écrire principale même.

129
00:05:48,220 --> 00:05:50,770
Et idéalement, il ya
une forme très standard

130
00:05:50,770 --> 00:05:53,500
que chaque déclaration de fonction suit.

131
00:05:53,500 --> 00:05:56,090
Ils ont tous à peu près ressembler à ceci.

132
00:05:56,090 --> 00:06:01,440
Il ya trois parties à une fonction
déclaration, le type de retour, nom,

133
00:06:01,440 --> 00:06:03,420
et la liste d'arguments.

134
00:06:03,420 --> 00:06:07,180
>> Maintenant, le type de retour est le type de
variable de la sortie fonction de la volonté.

135
00:06:07,180 --> 00:06:10,710
Ainsi, par exemple, si l'on repense un
il ya minutes à la multiplication de deux

136
00:06:10,710 --> 00:06:15,690
fonction des numéros, qu'attendons-nous si
nous multiplions un entier par un entier

137
00:06:15,690 --> 00:06:18,502
la sortie sera
probablement un nombre entier, à droite.

138
00:06:18,502 --> 00:06:20,710
Multiplié deux nombres entiers
ensemble, vous obtenez un nombre entier.

139
00:06:20,710 --> 00:06:24,167
Alors que le type de retour
fonction serait int.

140
00:06:24,167 --> 00:06:26,000
Nom est ce que vous voulez
d'appeler votre fonction.

141
00:06:26,000 --> 00:06:29,330
Ceci est probablement le moins important
partie de la déclaration de fonction,

142
00:06:29,330 --> 00:06:30,827
en termes de fonctionnalité.

143
00:06:30,827 --> 00:06:33,160
Mais est en fait probablement l'un
des parties les plus importantes

144
00:06:33,160 --> 00:06:36,243
de la déclaration de fonction en termes
de savoir ce que la fonction fait

145
00:06:36,243 --> 00:06:37,120
t.

146
00:06:37,120 --> 00:06:40,474
Si vous nommez votre fonction f ou g ou
h ou de mystère ou quelque chose comme ça,

147
00:06:40,474 --> 00:06:42,765
vous allez probablement obtenir
un peu trébuché à essayer

148
00:06:42,765 --> 00:06:44,650
de se rappeler ce que ces fonctions font.

149
00:06:44,650 --> 00:06:47,880
Donc, il est important de donner à votre
des noms significatifs de fonction.

150
00:06:47,880 --> 00:06:51,030
>> Enfin, liste des arguments est
la liste séparées par des virgules

151
00:06:51,030 --> 00:06:55,260
de toutes les entrées à votre fonction,
chacun d'eux ayant un type et un nom.

152
00:06:55,260 --> 00:06:57,840
Ainsi, non seulement vous avez à
spécifier le type de la variable

153
00:06:57,840 --> 00:07:00,760
la sortie fonction de la volonté,
vous aussi vous voulez spécifier

154
00:07:00,760 --> 00:07:07,694
ce type et les types de variables
fonction sera accepte comme entrées.

155
00:07:07,694 --> 00:07:08,860
Alors, faisons un exemple ici.

156
00:07:08,860 --> 00:07:10,220
Prenons juste un coup d'oeil
à un plus concrète.

157
00:07:10,220 --> 00:07:13,130
Alors, voici un exemple d'une fonction
déclaration pour une fonction qui

158
00:07:13,130 --> 00:07:14,925
ajouterait deux entiers ensemble.

159
00:07:14,925 --> 00:07:17,800
La somme des deux entiers va
un entier aussi bien, comme nous venons de

160
00:07:17,800 --> 00:07:18,450
discutée.

161
00:07:18,450 --> 00:07:21,610
Et si le type de retour,
ici en vert, serait int.

162
00:07:21,610 --> 00:07:25,190
Cela nous qui ajoutent deux ints dit juste
va, à la fin de la journée,

163
00:07:25,190 --> 00:07:28,799
sortie, ou recracher
à nous, un entier.

164
00:07:28,799 --> 00:07:31,590
Étant donné ce que nous avons fait cette fonction
vouloir lui donner un nom significatif.

165
00:07:31,590 --> 00:07:33,630
Ajouter deux ints semble
appropriée, compte tenu de

166
00:07:33,630 --> 00:07:37,574
nous prenons deux entiers comme entrées
et nous espérons que les additionner.

167
00:07:37,574 --> 00:07:40,240
Il pourrait être un peu encombrant
nom et franchement cette fonction

168
00:07:40,240 --> 00:07:42,430
est probablement pas nécessaire
puisque nous avons le plus

169
00:07:42,430 --> 00:07:46,310
l'opérateur, si vous vous souvenez de notre
discussion des opérateurs, déjà.

170
00:07:46,310 --> 00:07:49,650
Mais disons simplement par souci de
argument selon lequel cette fonction est utile

171
00:07:49,650 --> 00:07:52,860
et ainsi nous l'appellerons ajouter deux ints.

172
00:07:52,860 --> 00:07:55,230
Enfin, cette fonction prend deux entrées.

173
00:07:55,230 --> 00:07:56,960
Chacune d'entre elles est un entier.

174
00:07:56,960 --> 00:07:59,900
Nous avons donc cette virgule
liste séparée par des entrées.

175
00:07:59,900 --> 00:08:02,830
Maintenant, nous voulons généralement
donner un nom à chacun d'eux

176
00:08:02,830 --> 00:08:05,070
de sorte qu'ils peuvent être utilisés
dans la fonction.

177
00:08:05,070 --> 00:08:07,180
Les noms ne sont pas terriblement important.

178
00:08:07,180 --> 00:08:11,400
>> Dans ce cas, nous ne faisons pas nécessairement
avoir un sens attaché à eux.

179
00:08:11,400 --> 00:08:13,140
Donc, nous ne pouvons les appeler a et b.

180
00:08:13,140 --> 00:08:14,257
Voilà tout à fait bien.

181
00:08:14,257 --> 00:08:16,090
Si toutefois, vous trouverez
vous dans une situation

182
00:08:16,090 --> 00:08:19,497
où les noms des variables
pourrait en fait être important,

183
00:08:19,497 --> 00:08:21,830
vous pouvez les appeler
autre chose que A et B

184
00:08:21,830 --> 00:08:24,701
de leur donner quelque chose de plus
symboliquement significatif.

185
00:08:24,701 --> 00:08:27,700
Mais dans ce cas, nous ne faisons pas vraiment
connaître autre chose à propos de la fonction.

186
00:08:27,700 --> 00:08:29,320
Nous voulons juste d'ajouter deux nombres entiers.

187
00:08:29,320 --> 00:08:32,429
Donc, nous appellerons simplement
ceux entiers a et b.

188
00:08:32,429 --> 00:08:33,990
Voilà un exemple.

189
00:08:33,990 --> 00:08:36,287
>> Pourquoi ne prenez-vous pas une seconde
de penser à celui-ci,

190
00:08:36,287 --> 00:08:38,870
comment voulez-vous écrire une fonction
déclaration pour une fonction qui

191
00:08:38,870 --> 00:08:42,940
multiplie deux nombres à virgule flottante?

192
00:08:42,940 --> 00:08:45,910
Vous rappelez-vous ce qu'est un
nombre à virgule flottante est?

193
00:08:45,910 --> 00:08:48,120
Que serait cette fonction
déclaration ressembler?

194
00:08:48,120 --> 00:08:53,330
Je recommande vraiment vous mettre en pause la vidéo
et prenez ici combien de temps vous avez besoin.

195
00:08:53,330 --> 00:08:55,521
Pensez à ce que cette
déclaration de fonction serait?

196
00:08:55,521 --> 00:08:56,770
Quel serait le type de retour est?

197
00:08:56,770 --> 00:08:58,103
Que serait un nom significatif être?

198
00:08:58,103 --> 00:08:59,580
Quelles seraient les entrées être?

199
00:08:59,580 --> 00:09:03,190
Alors pourquoi ne pas vous mettre en pause la vidéo ici
et rédaction d'une déclaration de fonction

200
00:09:03,190 --> 00:09:07,640
pour une fonction qui multiplierait
deux nombres à virgule flottante ensemble.

201
00:09:07,640 --> 00:09:09,330
Espérons que vous avez interrompu la vidéo.

202
00:09:09,330 --> 00:09:12,950
>> Donc, nous allons jeter un oeil à un exemple
d'une éventuelle déclaration.

203
00:09:12,950 --> 00:09:17,340
Flottent mult deux réaux flottent x, float y.

204
00:09:17,340 --> 00:09:19,090
Le produit de deux
nombres à virgule flottante,

205
00:09:19,090 --> 00:09:21,710
qui rappellent comment nous sont
représenter des nombres réels

206
00:09:21,710 --> 00:09:26,770
ou des numéros avec des valeurs décimales en c,
va être un certain nombre à virgule flottante.

207
00:09:26,770 --> 00:09:28,570
Lorsque vous multipliez un
décimal par un décimal,

208
00:09:28,570 --> 00:09:30,460
vous allez probablement obtenir un nombre décimal.

209
00:09:30,460 --> 00:09:31,960
Vous voulez donner un nom pertinent.

210
00:09:31,960 --> 00:09:33,810
Multiplier deux réaux semble très bien.

211
00:09:33,810 --> 00:09:36,620
Mais vous pourriez vraiment appeler ça
mult deux flotteurs, flotteurs ou mult.

212
00:09:36,620 --> 00:09:39,540
Quelque chose comme ça, aussi longtemps qu'il
a donné une signification réelle pour ce

213
00:09:39,540 --> 00:09:41,469
cette boîte noire allait faire.

214
00:09:41,469 --> 00:09:44,260
Et encore une fois, dans ce cas, nous ne faisons pas
semblent avoir un sens attaché

215
00:09:44,260 --> 00:09:46,390
aux noms de la
variables que nous passons en,

216
00:09:46,390 --> 00:09:48,645
de sorte que nous appelons simplement les x et y.

217
00:09:48,645 --> 00:09:51,020
Maintenant, si vous les appelez quelque chose
d'autre, qui est tout à fait bien.

218
00:09:51,020 --> 00:09:53,310
En fait, si vous avez fait
cette déclaration à la place

219
00:09:53,310 --> 00:09:55,450
utiliser des doubles à la place
des flotteurs, si vous vous souvenez

220
00:09:55,450 --> 00:09:59,100
que les doubles sont un autre
de façon plus précise

221
00:09:59,100 --> 00:10:02,330
spécifier des nombres réels ou
variables à virgule flottante.

222
00:10:02,330 --> 00:10:03,620
Cela est tout à fait bien aussi.

223
00:10:03,620 --> 00:10:04,670
Soit un de ceux serait bien.

224
00:10:04,670 --> 00:10:06,711
En fait, il y en a plusieurs
différentes combinaisons

225
00:10:06,711 --> 00:10:08,410
des façons de déclarer cette fonction.

226
00:10:08,410 --> 00:10:10,884
Mais ce sont deux très bons.

227
00:10:10,884 --> 00:10:12,550
Nous avons déclaré une fonction, qui est très bien.

228
00:10:12,550 --> 00:10:15,700
Nous avons dit ce que le compilateur
est, ce que nous allons faire.

229
00:10:15,700 --> 00:10:17,630
Maintenant, nous allons écrire cette fonction.

230
00:10:17,630 --> 00:10:20,750
Donnons-lui une définition,
de telle sorte que l'intérieur de la boîte noire

231
00:10:20,750 --> 00:10:22,840
comportement prévisible qui se passe.

232
00:10:22,840 --> 00:10:26,270
En fait, nous multiplions deux réel
numéros ensemble, ou d'ajouter des numéros

233
00:10:26,270 --> 00:10:29,760
ensemble, ou de faire quoi que ce soit
que nous avons demandé à notre fonction de faire.

234
00:10:29,760 --> 00:10:32,780
>> Donc, en fait, nous allons chercher à définir
multiplier deux nombres réels que nous venons

235
00:10:32,780 --> 00:10:35,350
parlé il ya une seconde.

236
00:10:35,350 --> 00:10:38,560
Maintenant, le début de
une définition de fonction

237
00:10:38,560 --> 00:10:41,720
ressemble presque exactement le même
comme une déclaration de fonction.

238
00:10:41,720 --> 00:10:43,170
Je dois tous les deux ici.

239
00:10:43,170 --> 00:10:47,770
Au sommet se trouve la déclaration de fonction,
type, nom, séparées par des virgules argumentation

240
00:10:47,770 --> 00:10:49,410
liste, point-virgule.

241
00:10:49,410 --> 00:10:53,800
Le point-virgule indique que
qui est une déclaration de fonction.

242
00:10:53,800 --> 00:10:57,060
Le début de la fonction
définition ressemble presque exactement

243
00:10:57,060 --> 00:11:03,790
même, le type, le nom, séparées par des virgules
liste des arguments, pas de point-virgule,

244
00:11:03,790 --> 00:11:05,206
ouvrir accolade.

245
00:11:05,206 --> 00:11:07,580
L'accolade ouverte, tout comme
nous avons fait avec les principaux,

246
00:11:07,580 --> 00:11:09,540
signifie que nous sommes maintenant
en commençant à définir

247
00:11:09,540 --> 00:11:14,567
ce qui se passe à l'intérieur de la boîte noire qui
nous avons décidé de l'appeler mult deux réaux.

248
00:11:14,567 --> 00:11:15,900
Voici une façon de le mettre en œuvre.

249
00:11:15,900 --> 00:11:20,370
Nous pourrions dire, nous pourrions déclarer une nouvelle
variable de flotteur appelé type de produit

250
00:11:20,370 --> 00:11:24,020
et affecter cette variable
à la valeur x fois y.

251
00:11:24,020 --> 00:11:27,306
Et puis retourner le produit.

252
00:11:27,306 --> 00:11:28,430
Qu'est-ce que signifie ici le retour.

253
00:11:28,430 --> 00:11:31,090
Bien retour est la manière
nous indiquons que Voilà comment

254
00:11:31,090 --> 00:11:33,400
nous passons la sortie arrière.

255
00:11:33,400 --> 00:11:38,160
Donc retourner quelque chose, est le même que,
ceci est la sortie de la boîte noire.

256
00:11:38,160 --> 00:11:40,732
Voilà donc comment vous le faites.

257
00:11:40,732 --> 00:11:42,190
Voici une autre façon de le mettre en œuvre.

258
00:11:42,190 --> 00:11:45,050
Nous ne pouvions tout simplement retourner x fois y.

259
00:11:45,050 --> 00:11:45,870
x est un flotteur.

260
00:11:45,870 --> 00:11:46,660
Y est un flotteur.

261
00:11:46,660 --> 00:11:48,490
Donc x fois y est aussi un flotteur.

262
00:11:48,490 --> 00:11:50,750
Nous ne même pas besoin de
créer une autre variable.

263
00:11:50,750 --> 00:11:56,750
Voilà donc une autre façon de
mettre en œuvre la même boîte noire exacte.

264
00:11:56,750 --> 00:11:58,570
>> Maintenant, prenez un moment,
pause nouveau la vidéo,

265
00:11:58,570 --> 00:12:01,680
et d'essayer de définir ajouter deux ints,
qui est l'autre fonction que nous

266
00:12:01,680 --> 00:12:03,090
parlé il ya un instant.

267
00:12:03,090 --> 00:12:06,440
Encore une fois ici, je l'ai mis la fonction
déclaration, et ainsi le point-virgule,

268
00:12:06,440 --> 00:12:08,420
et une accolade ouverte
bouclés et un fermé

269
00:12:08,420 --> 00:12:12,080
accolade pour indiquer où nous allons remplir
dans le contenu de deux ints ajouter,

270
00:12:12,080 --> 00:12:15,530
afin que nous définissons le particulier
comportement à l'intérieur de la boîte noire.

271
00:12:15,530 --> 00:12:16,380
Donc, mettre en pause la vidéo.

272
00:12:16,380 --> 00:12:18,790
Et de prendre autant de temps que
vous devez essayer de définir

273
00:12:18,790 --> 00:12:25,040
une mise en œuvre de deux ints ajouter, tels
que lorsque la fonction génère une valeur,

274
00:12:25,040 --> 00:12:29,209
elle le fait, en réalité, le retour
la somme des deux entrées.

275
00:12:29,209 --> 00:12:32,000
Ainsi, tout comme dans l'exemple précédent,
il existe plusieurs façons différentes

276
00:12:32,000 --> 00:12:34,210
que vous pourriez mettre en œuvre ajouter deux ints.

277
00:12:34,210 --> 00:12:35,130
Voilà un.

278
00:12:35,130 --> 00:12:37,172
Ici en orange, je l'ai
juste eu une certaine comments--

279
00:12:37,172 --> 00:12:38,880
Je viens d'ajouter un peu
commentaires pour indiquer

280
00:12:38,880 --> 00:12:41,400
ce qui se passe sur chaque ligne de code.

281
00:12:41,400 --> 00:12:45,430
Je déclare donc une variable
appelé somme de type int.

282
00:12:45,430 --> 00:12:47,279
Je dis somme équivaut à un plus b.

283
00:12:47,279 --> 00:12:50,070
Voilà où nous en sommes en train de faire
le travail en ajoutant A et B ensemble.

284
00:12:50,070 --> 00:12:51,850
Et je reviens somme.

285
00:12:51,850 --> 00:12:56,460
Et cela fait sens parce
somme est une variable de type int.

286
00:12:56,460 --> 00:13:00,180
Et quel est le type de données que cette
fonction me dit que ça va vers la sortie?

287
00:13:00,180 --> 00:13:00,680
Int.

288
00:13:00,680 --> 00:13:03,072
Donc, je suis de retour somme, qui
est une variable entière.

289
00:13:03,072 --> 00:13:06,030
Et qui est logique étant donné ce que nous avons
déclaré et défini notre fonction

290
00:13:06,030 --> 00:13:07,320
faire.

291
00:13:07,320 --> 00:13:09,700
>> Maintenant, vous pouvez également définir
la fonction de cette façon,

292
00:13:09,700 --> 00:13:15,260
int somme est égale à un plus b-- sauter cette
step-- premier et ensuite, retourner somme.

293
00:13:15,260 --> 00:13:17,760
Maintenant, vous pourriez avoir aussi
mise en œuvre de cette façon,

294
00:13:17,760 --> 00:13:19,180
que je ne recommande pas très.

295
00:13:19,180 --> 00:13:22,540
Cela est mauvais style pour un
chose et vraiment mauvaise conception,

296
00:13:22,540 --> 00:13:24,420
mais elle, en fait, le travail.

297
00:13:24,420 --> 00:13:30,199
Si vous prenez ce code, qui est int
ajouter mauvaise additionneur point c, et l'utiliser.

298
00:13:30,199 --> 00:13:31,990
Il ne fait ajouter
deux entiers ensemble.

299
00:13:31,990 --> 00:13:37,632
Il est une très mauvaise mise en œuvre
de ce comportement particulier.

300
00:13:37,632 --> 00:13:38,340
Mais il ne fonctionne.

301
00:13:38,340 --> 00:13:41,200
Il est juste ici pour illustrer
au point que nous ne faisons pas vraiment

302
00:13:41,200 --> 00:13:44,530
soucier de ce qui se passe à l'intérieur
la boîte noire, aussi longtemps

303
00:13:44,530 --> 00:13:46,510
comme il a la sortie que l'on attend.

304
00:13:46,510 --> 00:13:48,870
Ceci est une boîte noire mal conçu.

305
00:13:48,870 --> 00:13:53,801
Mais à la fin de la journée, il ne
sortie encore la somme de a plus b.

306
00:13:53,801 --> 00:13:54,300
Bien.

307
00:13:54,300 --> 00:13:56,320
Donc, nous avons déclaré fonctions.

308
00:13:56,320 --> 00:13:57,490
Et nous avons une fonction définie.

309
00:13:57,490 --> 00:13:58,540
Voilà donc vraiment bon.

310
00:13:58,540 --> 00:14:03,020
Maintenant, nous allons commencer à utiliser les fonctions
que nous avons déclaré et nous avons défini.

311
00:14:03,020 --> 00:14:05,960
Pour appeler un function-- il est fait
jolie easy-- tout ce que vous devez faire

312
00:14:05,960 --> 00:14:09,070
est le transmettre arguments appropriés,
arguments du type de données

313
00:14:09,070 --> 00:14:11,600
qu'il attend, et
puis affecter le retour

314
00:14:11,600 --> 00:14:15,190
La valeur de cette fonction
et this-- excuse moi--

315
00:14:15,190 --> 00:14:19,390
affecter la valeur de retour de cette fonction
à quelque chose du type correct.

316
00:14:19,390 --> 00:14:22,410
>> Donc, nous allons jeter un oeil à
dans la pratique dans un fichier

317
00:14:22,410 --> 00:14:27,730
appelé sommateur 1 point c, qui
Je dois à mon CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Voici donc sommateur 1 point c.

319
00:14:31,042 --> 00:14:33,500
Au début, vous voyez, je dois
ma comprend, livre comprennent,

320
00:14:33,500 --> 00:14:35,460
norme IO, et CS50 dot h.

321
00:14:35,460 --> 00:14:37,700
Et puis je dois ma déclaration de fonction.

322
00:14:37,700 --> 00:14:39,570
Ceci est où je suis
dire le compilateur je suis

323
00:14:39,570 --> 00:14:42,850
va être la rédaction d'un
fonction appelée ajouter deux ints.

324
00:14:42,850 --> 00:14:45,780
Il va sortir un
type integer variable.

325
00:14:45,780 --> 00:14:47,360
Voilà ce que cette partie se trouve ici.

326
00:14:47,360 --> 00:14:51,950
Et puis je dois deux entrées vers un
et b, dont chacun est un nombre entier.

327
00:14:51,950 --> 00:14:58,250
A l'intérieur de la principale, je demande à l'utilisateur
entrée en disant, me donner un nombre entier.

328
00:14:58,250 --> 00:15:01,040
Et ils sont invités à oublier
int, qui est une fonction qui

329
00:15:01,040 --> 00:15:03,240
est inclus dans la bibliothèque de CS50.

330
00:15:03,240 --> 00:15:07,660
Et qui est stocké dans
x, une variable entière.

331
00:15:07,660 --> 00:15:09,886
>> Ensuite, nous les invite pour un autre entier.

332
00:15:09,886 --> 00:15:13,070
Nous obtenons un autre entier
et stocker que dans y.

333
00:15:13,070 --> 00:15:17,990
Et puis, ici, à la ligne 28, est
où nous faisons notre appel de fonction.

334
00:15:17,990 --> 00:15:23,770
Nous disons, int égale Z
ajouter 2 ints x virgule y.

335
00:15:23,770 --> 00:15:25,980
Voyez-vous pourquoi cela a un sens?

336
00:15:25,980 --> 00:15:29,710
x est une variable de type entier et
y est une variable de type entier.

337
00:15:29,710 --> 00:15:31,220
Donc, ce qui est bon.

338
00:15:31,220 --> 00:15:34,570
Qui font sens avec ce que notre fonction
Déclaration sur la ligne 17 ressemble.

339
00:15:34,570 --> 00:15:38,300
La liste d'entrée séparées par des virgules
attend deux entiers, a et b.

340
00:15:38,300 --> 00:15:40,300
Dans ce cas, nous pouvons appeler
eux ce que nous voulons.

341
00:15:40,300 --> 00:15:42,300
Il attend juste deux entiers.

342
00:15:42,300 --> 00:15:44,930
Et x est un nombre entier et y est un nombre entier.

343
00:15:44,930 --> 00:15:45,640
Ça fonctionne.

344
00:15:45,640 --> 00:15:48,680
>> Et nous savons que la fonction va
pour délivrer un entiers ainsi.

345
00:15:48,680 --> 00:15:51,290
Et nous sommes donc stocker les
sortie de la fonction,

346
00:15:51,290 --> 00:15:56,050
ajouter deux ints, dans un type entier
variable, qui nous appelons z.

347
00:15:56,050 --> 00:16:01,980
Et alors nous pouvons dire, la somme de
i pour cent pour cent et i est i pour cent.

348
00:16:01,980 --> 00:16:06,210
respectivement x, y et z
remplissage dans ceux de i pour cent.

349
00:16:06,210 --> 00:16:08,334
Quelle est la définition de
ajouter deux ints ressemblent?

350
00:16:08,334 --> 00:16:09,125
Il est assez simple.

351
00:16:09,125 --> 00:16:11,270
Il est l'un de ceux que nous
juste vu il ya une seconde,

352
00:16:11,270 --> 00:16:14,390
int somme équivaut à une somme plus b de retour.

353
00:16:14,390 --> 00:16:15,420
Est ce que ça marche?

354
00:16:15,420 --> 00:16:17,270
Sauvons le fichier.

355
00:16:17,270 --> 00:16:22,080
Et puis ici, sur ma borne
Je vais faire une addition,

356
00:16:22,080 --> 00:16:23,000
et je effacer mon écran.

357
00:16:23,000 --> 00:16:25,791
Je vais agrandir parce que je sais
il est un peu difficile à voir.

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

359
00:16:31,520 --> 00:16:33,770
>> Donc, nous compilons ce programme comme additionneur 1.

360
00:16:33,770 --> 00:16:37,910
Donc, nous pouvons faire dot slash sommateur 1.

361
00:16:37,910 --> 00:16:40,060
Donnez-moi un entier, 10.

362
00:16:40,060 --> 00:16:42,380
Donnez-moi un autre entier, 20.

363
00:16:42,380 --> 00:16:45,200
La somme de 10 et 20 est de 30.

364
00:16:45,200 --> 00:16:47,615
Nous avons donc fait un appel de fonction avec succès.

365
00:16:47,615 --> 00:16:55,820
Vous pouvez exécuter de nouveau la fonction, négative
10, 17 somme de négative 10 et 17 est 7.

366
00:16:55,820 --> 00:16:57,120
Cette fonction fonctionne.

367
00:16:57,120 --> 00:16:59,240
Il a le comportement
que nous nous attendons à.

368
00:16:59,240 --> 00:17:03,610
Et donc nous avons fait un succès
la fonction, la définition, la déclaration,

369
00:17:03,610 --> 00:17:07,288
et un appel de fonction avec succès.

370
00:17:07,288 --> 00:17:09,079
Couple divers
les points sur les fonctions

371
00:17:09,079 --> 00:17:10,611
Avant de conclure cette section.

372
00:17:10,611 --> 00:17:12,319
Rappel de notre
discussion de types de données,

373
00:17:12,319 --> 00:17:16,109
précédemment, qui fonctionne
peut parfois prendre aucune entrée.

374
00:17:16,109 --> 00:17:17,930
Si tel est le cas, nous
déclarer la fonction

375
00:17:17,930 --> 00:17:19,788
comme ayant une liste d'arguments vide.

376
00:17:19,788 --> 00:17:21,579
Vous rappelez-vous ce que le
plus fonction commune

377
00:17:21,579 --> 00:17:25,036
nous avons vu jusqu'à présent qui prend
une liste d'argument vide est?

378
00:17:25,036 --> 00:17:27,300
Il est principale.

379
00:17:27,300 --> 00:17:30,850
Rappelons également que la fonction parfois
ne disposent pas réellement une sortie.

380
00:17:30,850 --> 00:17:34,210
Dans ce cas, nous déclarons la fonction
comme ayant un type de retour void.

381
00:17:34,210 --> 00:17:37,880
Terminons cette section par
la lutte contre un problème de pratique.

382
00:17:37,880 --> 00:17:39,900
>> Alors, voici le problème énoncé.

383
00:17:39,900 --> 00:17:43,630
Je veux que vous écrivez une fonction
appelle le triangle valide.

384
00:17:43,630 --> 00:17:47,410
Qu'est-ce que cette fonction devrait faire
est de prendre trois nombres réels

385
00:17:47,410 --> 00:17:51,930
qui représentent les longueurs des trois
côtés d'un triangle que ses paramètres,

386
00:17:51,930 --> 00:17:54,550
ou de ses arguments, ou de son
inputs-- un autre ensemble de synonymes

387
00:17:54,550 --> 00:17:57,340
que vous pourriez rencontrer.

388
00:17:57,340 --> 00:18:01,120
Cette fonction devrait
soit vraie ou fausse sortie

389
00:18:01,120 --> 00:18:04,960
selon que ces trois longueurs
sont capables de faire un triangle.

390
00:18:04,960 --> 00:18:09,930
Vous souvenez-vous du type de données qui
nous avons utilisé pour indiquer vrai ou faux?

391
00:18:09,930 --> 00:18:11,436
Maintenant, comment appliquez-vous cela?

392
00:18:11,436 --> 00:18:13,810
Eh bien savent qu'il ya un couple
des règles concernant les triangles

393
00:18:13,810 --> 00:18:15,480
qui sont réellement utiles à connaître.

394
00:18:15,480 --> 00:18:18,292
Un triangle ne peut avoir
côtés avec longueur positive.

395
00:18:18,292 --> 00:18:19,000
Ça a du sens.

396
00:18:19,000 --> 00:18:21,432
Vous dites probablement, duh.

397
00:18:21,432 --> 00:18:23,390
L'autre chose à noter
cependant, est que la somme

398
00:18:23,390 --> 00:18:25,484
des longueurs de toute
deux côtés du triangle

399
00:18:25,484 --> 00:18:27,650
doit être supérieure à la
longueur du troisième côté.

400
00:18:27,650 --> 00:18:28,690
Voilà effectivement vrai.

401
00:18:28,690 --> 00:18:34,150
Vous ne pouvez pas avoir un triangle de côtés 1,
2 et 4, par exemple, parce que 1 plus 2

402
00:18:34,150 --> 00:18:36,270
est inférieure ou égale à 4.

403
00:18:36,270 --> 00:18:38,870
Donc, ce sont les règles qui
déterminer si oui ou non les trois

404
00:18:38,870 --> 00:18:42,740
entrées peuvent théoriquement former un triangle.

405
00:18:42,740 --> 00:18:46,360
Alors, prenez quelques minutes
et déclarer et ensuite définir

406
00:18:46,360 --> 00:18:49,810
cette fonction appelée valide
triangle, de telle sorte qu'il fait

407
00:18:49,810 --> 00:18:51,650
a le comportement spécifié ici.

408
00:18:51,650 --> 00:18:57,030
>> Il va afficher vrai si ces trois côtés
sont capables de comporter un triangle,

409
00:18:57,030 --> 00:19:01,950
et faux sinon
Prêt pour voir comment vous avez fait?

410
00:19:01,950 --> 00:19:04,650
Voici une mise en œuvre
triangle valide.

411
00:19:04,650 --> 00:19:05,770
Il est pas le seul.

412
00:19:05,770 --> 00:19:07,770
Les vôtres peuvent varier légèrement.

413
00:19:07,770 --> 00:19:11,040
Mais celui-ci ne, en fait, ont
le comportement que nous attendons.

414
00:19:11,040 --> 00:19:14,450
Nous déclarons notre fonction au
très haut, bool triangle valide

415
00:19:14,450 --> 00:19:16,630
flotter x float y flotteur z.

416
00:19:16,630 --> 00:19:18,930
Encore une fois, cette fonction
prend trois nombres réels

417
00:19:18,930 --> 00:19:22,280
que ses arguments, flottant
variables de valeur du point,

418
00:19:22,280 --> 00:19:26,510
et délivre un vrai ou faux
valeur, qui est un booléen, rappel.

419
00:19:26,510 --> 00:19:28,660
Voilà pourquoi le type de retour est bool.

420
00:19:28,660 --> 00:19:30,016
Ensuite, nous définissons la fonction.

421
00:19:30,016 --> 00:19:33,140
La première chose que nous faisons est de vérifier pour vous assurer
que tous les côtés sont positifs.

422
00:19:33,140 --> 00:19:37,010
Si x est inférieur ou égal
à 0, ou si y est égal à 0,

423
00:19:37,010 --> 00:19:41,050
ou si z est inférieure ou égale à 0,
cela ne peut éventuellement être un triangle.

424
00:19:41,050 --> 00:19:42,380
Ils ne possèdent pas les côtés positifs.

425
00:19:42,380 --> 00:19:45,790
Et afin que nous puissions revenir
faux dans cette situation.

426
00:19:45,790 --> 00:19:49,010
Ensuite, nous vérifions pour vous assurer
que chaque paire d'entrées

427
00:19:49,010 --> 00:19:51,830
est supérieure à la troisième.

428
00:19:51,830 --> 00:19:54,530
>> Donc, si x + y est moins
supérieur ou égal à z,

429
00:19:54,530 --> 00:19:57,060
ou si x est plus z moins
supérieure ou égale à y,

430
00:19:57,060 --> 00:20:01,730
ou si y plus z est inférieur ou égal à
x, qui a également ne peut pas être un triangle valide.

431
00:20:01,730 --> 00:20:03,800
Donc, nous revenons encore faux.

432
00:20:03,800 --> 00:20:06,900
En supposant que nous passions à la fois des contrôles
cependant, alors nous pouvons retourner vrai.

433
00:20:06,900 --> 00:20:09,440
Parce que ces trois côtés
sont capables de returning--

434
00:20:09,440 --> 00:20:11,647
de création d'un triangle valide.

435
00:20:11,647 --> 00:20:12,230
Et c'est tout.

436
00:20:12,230 --> 00:20:13,830
Vous avez maintenant déclarée et définie.

437
00:20:13,830 --> 00:20:17,330
Et vous pourrez peut-être maintenant
utiliser et appeler cette fonction.

438
00:20:17,330 --> 00:20:19,470
Bon travail.

439
00:20:19,470 --> 00:20:20,650
Je suis Doug Lloyd.

440
00:20:20,650 --> 00:20:22,820
Ceci est CS50.

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