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

2
00:00:04,664 --> 00:00:05,580
DOUG LLOYD: Va bene.

3
00:00:05,580 --> 00:00:08,877
Così ora affrontiamo un
davvero grande argomento, funzioni.

4
00:00:08,877 --> 00:00:11,460
Finora in corso, tutte le
programmi che ho scritto

5
00:00:11,460 --> 00:00:12,969
sono state scritte all'interno di principale.

6
00:00:12,969 --> 00:00:14,260
Sono programmi piuttosto semplici.

7
00:00:14,260 --> 00:00:16,940
Non è necessario avere tutti questi
rami e cose da fare.

8
00:00:16,940 --> 00:00:18,773
Possiamo solo andare bene tutto
interno principale e

9
00:00:18,773 --> 00:00:20,407
non ottiene terribilmente opprimente.

10
00:00:20,407 --> 00:00:22,990
Ma come il corso va avanti e
come si inizia a sviluppare programmi

11
00:00:22,990 --> 00:00:26,260
indipendentemente, sono probabilmente andando
per iniziare a ottenere molto di più di 10

12
00:00:26,260 --> 00:00:27,200
o 15 linee.

13
00:00:27,200 --> 00:00:31,400
Si potrebbe ottenere centinaia o migliaia
o decine di migliaia di linee di codice.

14
00:00:31,400 --> 00:00:34,690
E non è davvero
che un pensiero folle.

15
00:00:34,690 --> 00:00:39,720
In quanto tale, non è probabilmente una buona idea
a tenere tutto dentro di principale.

16
00:00:39,720 --> 00:00:43,240
Si può ottenere un po 'difficile da trovare
quello che stai cercando, se lo fai.

17
00:00:43,240 --> 00:00:47,040
>> Fortunatamente, però C, e praticamente
ogni altro linguaggio di programmazione che

18
00:00:47,040 --> 00:00:50,386
potrebbe funzionare con, permette
di scrivere funzioni.

19
00:00:50,386 --> 00:00:52,260
E sto solo andando a
prendere un rapido a parte qui

20
00:00:52,260 --> 00:00:54,971
contare che funzioni è
un settore di informatica.

21
00:00:54,971 --> 00:00:57,970
E vedrete molti più di loro a
vari punti del corso

22
00:00:57,970 --> 00:00:59,290
e se si continua su.

23
00:00:59,290 --> 00:01:02,280
Dove c'è un sacco di
sinonimi della stessa parola.

24
00:01:02,280 --> 00:01:03,390
Così noi chiamiamo le funzioni.

25
00:01:03,390 --> 00:01:05,980
Ma si potrebbe anche sentire loro
denominato procedure,

26
00:01:05,980 --> 00:01:09,570
o metodi, in particolare, se hai mai
fatto alcuna programmazione orientata agli oggetti

27
00:01:09,570 --> 00:01:11,950
before-- e non preoccuparti
se non, non l'hai

28
00:01:11,950 --> 00:01:14,280
un grande deal-- ma in
controllo orientato lingue

29
00:01:14,280 --> 00:01:16,129
sono spesso chiamati metodi.

30
00:01:16,129 --> 00:01:17,670
A volte si chiamano sottoprogrammi.

31
00:01:17,670 --> 00:01:20,690
Ma in realtà si riferiscono tutti
alla stessa idea di base.

32
00:01:20,690 --> 00:01:22,480
>> Vediamo cosa che idea è.

33
00:01:22,480 --> 00:01:23,310
Che cos'è una funzione?

34
00:01:23,310 --> 00:01:26,470
Beh, una funzione è davvero
niente di più che una scatola nera.

35
00:01:26,470 --> 00:01:31,430
Una scatola nera che ha una serie di a zero
o più ingressi ed una uscita.

36
00:01:31,430 --> 00:01:33,420
Così, per esempio, questo
potrebbe essere una funzione.

37
00:01:33,420 --> 00:01:35,510
Questa è una funzione chiamata funz.

38
00:01:35,510 --> 00:01:39,330
E richiede tre ingressi a, b, ec.

39
00:01:39,330 --> 00:01:42,580
E dentro quella scatola nera, abbiamo
non so esattamente ciò che fa,

40
00:01:42,580 --> 00:01:45,100
ma elabora gli ingressi
in qualche modo e poi

41
00:01:45,100 --> 00:01:48,680
dà una singola uscita, in questo caso, z.

42
00:01:48,680 --> 00:01:50,504
Ora per rendere un po '
meno astratto, abbiamo

43
00:01:50,504 --> 00:01:52,420
potremmo dire che forse noi
hanno una funzione chiamata

44
00:01:52,420 --> 00:01:58,750
Add che accetta tre ingressi a, b, e
c ed elabora l'uscita in qualche modo

45
00:01:58,750 --> 00:02:01,010
all'interno della scatola nera per
produrre una singola uscita.

46
00:02:01,010 --> 00:02:05,190
Quindi, in questo caso, se
aggiungere prende 3, 6, e 7.

47
00:02:05,190 --> 00:02:07,020
Da qualche parte dentro il
aggiungere la funzione, avremmo

48
00:02:07,020 --> 00:02:09,750
aspettarsi che essere sommati
per produrre l'output, che

49
00:02:09,750 --> 00:02:13,220
è 3 più 6, più 7 o 16.

50
00:02:13,220 --> 00:02:17,940
>> Allo stesso modo, si dispone di una funzione chiamata
mult che prende due ingressi A e B,

51
00:02:17,940 --> 00:02:21,070
li elabora in qualche modo tale
che l'uscita della funzione

52
00:02:21,070 --> 00:02:22,920
è il prodotto dei due ingressi.

53
00:02:22,920 --> 00:02:25,080
I due ingressi moltiplicati insieme.

54
00:02:25,080 --> 00:02:29,150
4 e 5 di essere passati in mult,
succede qualcosa, l'uscita ci aspettiamo

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

56
00:02:31,090 --> 00:02:32,507
Perché si parla di una scatola nera?

57
00:02:32,507 --> 00:02:34,840
Beh, se non stiamo scrivendo il
Funzioni noi stessi, che

58
00:02:34,840 --> 00:02:36,869
abbiamo fatto un bel po 'finora CS50.

59
00:02:36,869 --> 00:02:39,910
Abbiamo visto la stampa f, per esempio, che
è una funzione che non abbiamo scritto

60
00:02:39,910 --> 00:02:42,305
noi stessi, ma noi usa tutto il tempo.

61
00:02:42,305 --> 00:02:44,180
Se non stiamo scrivendo
le funzioni di noi stessi,

62
00:02:44,180 --> 00:02:48,450
noi non abbiamo bisogno di sapere come è
effettivamente messo in atto sotto il cofano.

63
00:02:48,450 --> 00:02:51,710
>> Così, per esempio la scatola nera I
appena mostrato per la moltiplicazione,

64
00:02:51,710 --> 00:02:53,740
mult a, b potrebbe essere
defined-- e questo è solo

65
00:02:53,740 --> 00:02:57,902
alcuni pseudocode-- potrebbe essere
definito come il rendimento a volte b.

66
00:02:57,902 --> 00:02:58,860
Che senso ha, a destra.

67
00:02:58,860 --> 00:03:01,370
Se abbiamo una funzione chiamata
mult che prende due ingressi.

68
00:03:01,370 --> 00:03:04,750
Ci si aspetterebbe che l'uscita sarebbe
essere i due ingressi moltiplicati insieme,

69
00:03:04,750 --> 00:03:06,240
a volte b.

70
00:03:06,240 --> 00:03:09,170
Ma potrebbe anche essere mult
implementato come questo,

71
00:03:09,170 --> 00:03:13,150
abbiamo una variabile contatore a
get set all'interno di mult a 0.

72
00:03:13,150 --> 00:03:18,000
E allora ripetiamo questo processo
b volte aggiungere un contatore a.

73
00:03:18,000 --> 00:03:24,270
Ad esempio, se moltiplichiamo 3a by
5b, potremmo dire impostare contatore a 0,

74
00:03:24,270 --> 00:03:27,700
ripetere cinque volte, aggiungere 3 al contatore.

75
00:03:27,700 --> 00:03:34,490
Dunque iniziamo a 0 e poi facciamo
cinque volte 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
E 'lo stesso risultato. Noi
ancora ottenere 3 volte 5 solo

77
00:03:37,500 --> 00:03:39,500
l'implementazione è diversa.

78
00:03:39,500 --> 00:03:41,490
>> Questo è ciò che intendiamo
quando diciamo una scatola nera.

79
00:03:41,490 --> 00:03:44,406
Significa solo che non mi interessa
come è implementato sotto il cofano

80
00:03:44,406 --> 00:03:46,170
finché l'uscita è quello che ci aspettiamo.

81
00:03:46,170 --> 00:03:49,045
In realtà, questo è parte del contratto
di utilizzo di funzioni, particolarmente

82
00:03:49,045 --> 00:03:50,630
funzioni che gli altri scrivono.

83
00:03:50,630 --> 00:03:53,980
Il comportamento è sempre in corso
di essere tipico, imprevedibile

84
00:03:53,980 --> 00:03:55,420
in base al nome della funzione.

85
00:03:55,420 --> 00:03:57,500
Ed è per questo che è davvero
importante quando si scrive funzioni

86
00:03:57,500 --> 00:04:00,020
o quando gli altri scrivono
funzioni che si potrebbe utilizzare,

87
00:04:00,020 --> 00:04:03,590
che tali funzioni hanno
chiare, nomi relativamente evidenti,

88
00:04:03,590 --> 00:04:04,990
e sono ben documentati.

89
00:04:04,990 --> 00:04:08,560
Che è certamente il caso
per la funzione di come la stampa f.

90
00:04:08,560 --> 00:04:09,860
>> Allora perché usiamo le funzioni?

91
00:04:09,860 --> 00:04:14,220
Beh, come ho detto prima, se scriviamo
tutto il nostro codice all'interno delle cose principali

92
00:04:14,220 --> 00:04:17,120
può ottenere davvero ingombrante
e davvero complicato.

93
00:04:17,120 --> 00:04:19,980
Funzioni ci consentono la capacità
di organizzare le cose e rompere

94
00:04:19,980 --> 00:04:24,540
un problema molto complicato in
molte sub parti più gestibili.

95
00:04:24,540 --> 00:04:28,130
Funzioni ci permettono anche di
semplificare il processo di codifica.

96
00:04:28,130 --> 00:04:33,080
E 'molto più facile per eseguire il debug di un 10
funzione di linea rispetto a una linea 100

97
00:04:33,080 --> 00:04:35,890
funzione o una funzione di 1.000 riga.

98
00:04:35,890 --> 00:04:38,400
Se non ci resta che eseguire il debug
piccoli pezzi alla volta,

99
00:04:38,400 --> 00:04:42,110
o scrivere piccoli pezzi, al momento,
rende questa esperienza di programmazione

100
00:04:42,110 --> 00:04:43,070
molto meglio.

101
00:04:43,070 --> 00:04:44,910
Fidati di me su quello.

102
00:04:44,910 --> 00:04:48,400
>> Infine, se scriviamo funzioni che
può riutilizzare quelle varie parti.

103
00:04:48,400 --> 00:04:49,880
Le funzioni possono essere riciclati.

104
00:04:49,880 --> 00:04:51,880
Possono essere utilizzati in
un programma o un altro.

105
00:04:51,880 --> 00:04:53,713
Hai già scritto
la funzione, tutto quello che

106
00:04:53,713 --> 00:04:56,530
bisogno di fare è dire che il programma
dove trovare tale funzione.

107
00:04:56,530 --> 00:04:59,680
Abbiamo riciclaggio e impiego
f stampare da oltre 40 anni.

108
00:04:59,680 --> 00:05:02,150
Ma è stato scritto solo una volta.

109
00:05:02,150 --> 00:05:04,270
Molto utile, a destra.

110
00:05:04,270 --> 00:05:04,830
Tutto ok.

111
00:05:04,830 --> 00:05:06,040
Così funzioni sono grandi.

112
00:05:06,040 --> 00:05:06,860
Lo sappiamo.

113
00:05:06,860 --> 00:05:08,700
Ora cominciamo a scriverli.

114
00:05:08,700 --> 00:05:10,830
Partiamo sempre
li nei nostri programmi.

115
00:05:10,830 --> 00:05:13,869
Per fare ciò, il primo
cosa che facciamo è dichiarare la funzione.

116
00:05:13,869 --> 00:05:16,160
Quando si dichiara una funzione di
quello che stai facendo fondamentalmente

117
00:05:16,160 --> 00:05:18,900
sta dicendo il compilatore,
ehi, solo così sai,

118
00:05:18,900 --> 00:05:20,850
Ho intenzione di scrivere
una funzione più tardi

119
00:05:20,850 --> 00:05:22,987
ed ecco cosa è andare a guardare come.

120
00:05:22,987 --> 00:05:24,820
La ragione di questo è
perché i compilatori può

121
00:05:24,820 --> 00:05:27,900
fare alcune cose strane se
vedono una serie di simboli

122
00:05:27,900 --> 00:05:29,560
che non sono a conoscenza.

123
00:05:29,560 --> 00:05:33,000
Quindi ci limitiamo a dare il compilatore un
testa a testa, sto creando una funzione

124
00:05:33,000 --> 00:05:35,492
e sta andando a fare questo.

125
00:05:35,492 --> 00:05:38,450
Dichiarazioni di funzione generalmente se
si sta organizzando il codice in un modo

126
00:05:38,450 --> 00:05:41,872
che altri potranno
comprendere e utilizzare,

127
00:05:41,872 --> 00:05:44,330
in genere si vuole mettere tutto
delle vostre dichiarazioni di funzione

128
00:05:44,330 --> 00:05:48,220
in cima del codice, destra
Prima di iniziare a scrivere principale anche.

129
00:05:48,220 --> 00:05:50,770
E convenientemente, c'è
una forma molto standard

130
00:05:50,770 --> 00:05:53,500
che ogni dichiarazione di funzione segue.

131
00:05:53,500 --> 00:05:56,090
Sono tutti più o meno simile a questa.

132
00:05:56,090 --> 00:06:01,440
Ci sono tre parti ad una funzione
dichiarazione, tipo di ritorno, nome,

133
00:06:01,440 --> 00:06:03,420
e elenco di argomenti.

134
00:06:03,420 --> 00:06:07,180
>> Ora il tipo di ritorno è che tipo di
variabile uscita funzione volontà.

135
00:06:07,180 --> 00:06:10,710
Così, per esempio, se pensiamo indietro un
minuto fa per la moltiplicazione di due

136
00:06:10,710 --> 00:06:15,690
funzione di numeri, che cosa ci aspettiamo se
moltiplichiamo un numero intero da un numero intero

137
00:06:15,690 --> 00:06:18,502
l'uscita sarà
probabilmente un intero, a destra.

138
00:06:18,502 --> 00:06:20,710
Moltiplicato due interi
insieme, si ottiene un numero intero.

139
00:06:20,710 --> 00:06:24,167
Così il tipo di ritorno di quella
Funzione sarebbe int.

140
00:06:24,167 --> 00:06:26,000
Il nome è quello che volete
per chiamare la funzione.

141
00:06:26,000 --> 00:06:29,330
Questo è probabilmente il meno importante
parte della dichiarazione di funzione,

142
00:06:29,330 --> 00:06:30,827
in termini di funzionalità.

143
00:06:30,827 --> 00:06:33,160
Ma in realtà è probabilmente uno
delle parti più importanti

144
00:06:33,160 --> 00:06:36,243
della dichiarazione di funzione in termini
di sapere ciò che la funzione in realtà

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

146
00:06:37,120 --> 00:06:40,474
Se si denomina la funzione F o G o
h o mistero o qualcosa del genere,

147
00:06:40,474 --> 00:06:42,765
probabilmente stai andando per ottenere
un piccolo sgambetto cercare

148
00:06:42,765 --> 00:06:44,650
di ricordare ciò che queste funzioni fanno.

149
00:06:44,650 --> 00:06:47,880
Quindi è importante dare il vostro
nomi significativi della funzione.

150
00:06:47,880 --> 00:06:51,030
>> Infine, lista degli argomenti è
l'elenco separato da virgole

151
00:06:51,030 --> 00:06:55,260
di tutti gli ingressi alla vostra funzione,
ciascuno dei quali ha un tipo e un nome.

152
00:06:55,260 --> 00:06:57,840
Quindi non solo si deve
specificare il tipo di variabile

153
00:06:57,840 --> 00:07:00,760
l'uscita funzione di volontà,
anche voi volete specificare

154
00:07:00,760 --> 00:07:07,694
che tipo e tipi di variabili dei
la funzione sarà di accettare come input.

155
00:07:07,694 --> 00:07:08,860
Allora, facciamo un esempio qui.

156
00:07:08,860 --> 00:07:10,220
Diciamo solo un'occhiata
ad una più concreta.

157
00:07:10,220 --> 00:07:13,130
Ecco un esempio di una funzione
dichiarazione di una funzione che

158
00:07:13,130 --> 00:07:14,925
vorrei aggiungere due interi insieme.

159
00:07:14,925 --> 00:07:17,800
La somma di due numeri interi sta per
essere un numero intero e, come abbiamo appena

160
00:07:17,800 --> 00:07:18,450
discusso.

161
00:07:18,450 --> 00:07:21,610
E così il tipo di ritorno,
qui nel verde, sarebbe int.

162
00:07:21,610 --> 00:07:25,190
Questo ci che aggiungono due interi dice solo
sta per, alla fine della giornata,

163
00:07:25,190 --> 00:07:28,799
uscita, o sputare indietro
a noi, un numero intero.

164
00:07:28,799 --> 00:07:31,590
Dato ciò che questa funzione fa abbiamo
vuole dare un nome significativo.

165
00:07:31,590 --> 00:07:33,630
Aggiungere due interi sembra
del caso, tenendo conto

166
00:07:33,630 --> 00:07:37,574
stiamo prendendo due interi come input
e, auspicabilmente, sommandoli.

167
00:07:37,574 --> 00:07:40,240
Potrebbe essere un po 'di un ingombrante
nome e francamente questa funzione

168
00:07:40,240 --> 00:07:42,430
è probabilmente non necessario
dal momento che abbiamo l'aggiunta

169
00:07:42,430 --> 00:07:46,310
operatore, se vi ricordate dal nostro
discussione degli operatori, in precedenza.

170
00:07:46,310 --> 00:07:49,650
Ma diciamo solo che per amor di
tesi che questa funzione è utile

171
00:07:49,650 --> 00:07:52,860
e così lo chiameremo aggiungere due int.

172
00:07:52,860 --> 00:07:55,230
Infine, la funzione prende due ingressi.

173
00:07:55,230 --> 00:07:56,960
Ciascuno dei quali è un numero intero.

174
00:07:56,960 --> 00:07:59,900
Quindi abbiamo questa virgola
elenco separato degli ingressi.

175
00:07:59,900 --> 00:08:02,830
Ora noi generalmente vogliamo
dare un nome a ciascuno di essi

176
00:08:02,830 --> 00:08:05,070
in modo che possano essere utilizzati
all'interno della funzione.

177
00:08:05,070 --> 00:08:07,180
I nomi non sono terribilmente importante.

178
00:08:07,180 --> 00:08:11,400
>> In questo caso, noi non necessariamente
avere un significato ad essi connessi.

179
00:08:11,400 --> 00:08:13,140
Così possiamo solo chiamarli a e b.

180
00:08:13,140 --> 00:08:14,257
Questo è totalmente bene.

181
00:08:14,257 --> 00:08:16,090
Se, tuttavia, si trova
in una situazione

182
00:08:16,090 --> 00:08:19,497
dove i nomi delle variabili
potrebbe effettivamente essere importante,

183
00:08:19,497 --> 00:08:21,830
si potrebbe desiderare di chiamarli
qualcosa di diverso a e b

184
00:08:21,830 --> 00:08:24,701
per dare loro qualcosa in più
simbolicamente significativa.

185
00:08:24,701 --> 00:08:27,700
Ma in questo caso, non lo facciamo davvero
sapere altro sulla funzione.

186
00:08:27,700 --> 00:08:29,320
Vogliamo solo aggiungere due interi.

187
00:08:29,320 --> 00:08:32,429
Quindi ci limiteremo a chiamare
quelli interi a e b.

188
00:08:32,429 --> 00:08:33,990
Questo è un esempio.

189
00:08:33,990 --> 00:08:36,287
>> Perché non si prende un secondo
di pensare a questo,

190
00:08:36,287 --> 00:08:38,870
come è possibile scrivere una funzione
dichiarazione di una funzione che

191
00:08:38,870 --> 00:08:42,940
Moltiplica due numeri floating point?

192
00:08:42,940 --> 00:08:45,910
Ti ricordi che cosa un
numero in virgola mobile è?

193
00:08:45,910 --> 00:08:48,120
Cosa sarebbe questa funzione
dichiarazione simile?

194
00:08:48,120 --> 00:08:53,330
Io in realtà consiglio di mettere in pausa il video
qui e prendere quanto tempo hai bisogno.

195
00:08:53,330 --> 00:08:55,521
Pensate a che cosa questo
dichiarazione di funzione sarebbe?

196
00:08:55,521 --> 00:08:56,770
Quale sarebbe il tipo di ritorno sarà?

197
00:08:56,770 --> 00:08:58,103
Cosa sarebbe un nome significativo essere?

198
00:08:58,103 --> 00:08:59,580
Quali sarebbero gli ingressi essere?

199
00:08:59,580 --> 00:09:03,190
Allora perché non si mette in pausa il video qui
e scrivere-up una dichiarazione di funzione

200
00:09:03,190 --> 00:09:07,640
per una funzione che moltiplicare
due numeri in virgola mobile insieme.

201
00:09:07,640 --> 00:09:09,330
Speriamo che hai messo in pausa il video.

202
00:09:09,330 --> 00:09:12,950
>> Quindi, diamo un'occhiata a un esempio
di una possibile dichiarazione.

203
00:09:12,950 --> 00:09:17,340
Float mult due reali galleggiano x, y galleggiante.

204
00:09:17,340 --> 00:09:19,090
Il prodotto di due
numeri in virgola mobile,

205
00:09:19,090 --> 00:09:21,710
che ricorda il modo in cui sono
rappresentare i numeri reali

206
00:09:21,710 --> 00:09:26,770
o numeri con valori decimali in c,
sta per essere un numero in virgola mobile.

207
00:09:26,770 --> 00:09:28,570
Quando si moltiplicano un
decimali da un decimale,

208
00:09:28,570 --> 00:09:30,460
probabilmente stai andando per ottenere un decimale.

209
00:09:30,460 --> 00:09:31,960
Si vuole dare un nome rilevante.

210
00:09:31,960 --> 00:09:33,810
Moltiplicare due reali sembra che vada bene.

211
00:09:33,810 --> 00:09:36,620
Ma si potrebbe davvero chiamare
mult due galleggianti, o galleggianti mult.

212
00:09:36,620 --> 00:09:39,540
Qualcosa di simile, purché
ha dato un po 'di vero significato a ciò che

213
00:09:39,540 --> 00:09:41,469
questa scatola nera stava per fare.

214
00:09:41,469 --> 00:09:44,260
E ancora, in questo caso, non lo facciamo
sembra avere alcun significato collegato

215
00:09:44,260 --> 00:09:46,390
per i nomi dei
variabili stiamo passando in,

216
00:09:46,390 --> 00:09:48,645
così abbiamo appena li chiamiamo xe y.

217
00:09:48,645 --> 00:09:51,020
Ora, se si chiama loro qualcosa
altro, che è totalmente bene.

218
00:09:51,020 --> 00:09:53,310
Infatti, se l'avete fatto
tale dichiarazione invece

219
00:09:53,310 --> 00:09:55,450
utilizzando invece raddoppia
di galleggianti, se vi ricordate

220
00:09:55,450 --> 00:09:59,100
che doppi sono una diversa
senso più precisamente

221
00:09:59,100 --> 00:10:02,330
specificare i numeri reali o
floating point variabili.

222
00:10:02,330 --> 00:10:03,620
Questo è del tutto troppo bene.

223
00:10:03,620 --> 00:10:04,670
Uno di quelli che sarebbe bene.

224
00:10:04,670 --> 00:10:06,711
In realtà, ci sono diversi
diverse combinazioni

225
00:10:06,711 --> 00:10:08,410
di modi per dichiarare questa funzione.

226
00:10:08,410 --> 00:10:10,884
Ma questi sono due quelli abbastanza buoni.

227
00:10:10,884 --> 00:10:12,550
Abbiamo dichiarato una funzione, che è grande.

228
00:10:12,550 --> 00:10:15,700
Abbiamo detto al compilatore che cosa
è, quello che stiamo andando a fare.

229
00:10:15,700 --> 00:10:17,630
Ora diamo effettivamente scrivere quella funzione.

230
00:10:17,630 --> 00:10:20,750
Diamogli una definizione,
in modo che dentro la scatola nera

231
00:10:20,750 --> 00:10:22,840
comportamento prevedibile sta accadendo.

232
00:10:22,840 --> 00:10:26,270
In realtà, stiamo moltiplicando due reali
numeri insieme, o numeri aggiungendo

233
00:10:26,270 --> 00:10:29,760
insieme, o fare qualunque cosa sia
che abbiamo chiesto alla nostra funzione per fare.

234
00:10:29,760 --> 00:10:32,780
>> Quindi, in realtà, proviamo e definire
moltiplicare due reali che abbiamo appena

235
00:10:32,780 --> 00:10:35,350
parlato di un secondo fa.

236
00:10:35,350 --> 00:10:38,560
Ora l'inizio
una definizione di funzione

237
00:10:38,560 --> 00:10:41,720
sembra quasi esattamente la stessa
come una dichiarazione di funzione.

238
00:10:41,720 --> 00:10:43,170
Ho sia di loro qui.

239
00:10:43,170 --> 00:10:47,770
Nella parte superiore è la dichiarazione di funzione,
tipo, nome, separati da virgola argomento

240
00:10:47,770 --> 00:10:49,410
lista, punto e virgola.

241
00:10:49,410 --> 00:10:53,800
Il punto e virgola indica che
che è una dichiarazione di funzione.

242
00:10:53,800 --> 00:10:57,060
L'inizio della funzione
definizione appare quasi esattamente

243
00:10:57,060 --> 00:11:03,790
lo stesso, tipo, nome, separati da virgola
elenco di argomenti, senza virgola,

244
00:11:03,790 --> 00:11:05,206
aprire parentesi graffa.

245
00:11:05,206 --> 00:11:07,580
La parentesi graffa aperta, proprio come
abbiamo fatto con principale,

246
00:11:07,580 --> 00:11:09,540
significa che siamo ora
cominciando a definire

247
00:11:09,540 --> 00:11:14,567
ciò che accade dentro la scatola nera che
abbiamo deciso di chiamare mult due reali.

248
00:11:14,567 --> 00:11:15,900
Ecco un modo per la sua attuazione.

249
00:11:15,900 --> 00:11:20,370
Potremmo dire, potremmo dichiarare una nuova
variabile di tipo float chiamata di prodotto

250
00:11:20,370 --> 00:11:24,020
e assegnare tale variabile
al valore x volte a.

251
00:11:24,020 --> 00:11:27,306
E poi restituire il prodotto.

252
00:11:27,306 --> 00:11:28,430
Cosa vuol dire ritorno qui.

253
00:11:28,430 --> 00:11:31,090
Beh ritorno è il modo
Vi segnaliamo che è come

254
00:11:31,090 --> 00:11:33,400
stiamo passando l'uscita sul retro.

255
00:11:33,400 --> 00:11:38,160
Così restituire qualcosa, è lo stesso,
questo è l'uscita della scatola nera.

256
00:11:38,160 --> 00:11:40,732
Ecco come si fa.

257
00:11:40,732 --> 00:11:42,190
Ecco un altro modo per la sua attuazione.

258
00:11:42,190 --> 00:11:45,050
Potremmo tornare x volte a.

259
00:11:45,050 --> 00:11:45,870
x è un galleggiante.

260
00:11:45,870 --> 00:11:46,660
y è un float.

261
00:11:46,660 --> 00:11:48,490
Quindi x y volte è anche un galleggiante.

262
00:11:48,490 --> 00:11:50,750
Non abbiamo nemmeno bisogno di
creare un'altra variabile.

263
00:11:50,750 --> 00:11:56,750
Quindi questo è un modo diverso di
implementare esattamente la stessa scatola nera.

264
00:11:56,750 --> 00:11:58,570
>> Ora prendete un momento,
sospendere nuovamente il video,

265
00:11:58,570 --> 00:12:01,680
e cercare di definire aggiungere due interi,
che è l'altra funzione che

266
00:12:01,680 --> 00:12:03,090
parlato un momento fa.

267
00:12:03,090 --> 00:12:06,440
Anche in questo caso, ho messo la funzione
dichiarazione, e così il punto e virgola,

268
00:12:06,440 --> 00:12:08,420
e una parentesi graffa aperta
e un riccio chiuso

269
00:12:08,420 --> 00:12:12,080
tutore per indicare dove riempiremo
nei contenuti di aggiungere due interi,

270
00:12:12,080 --> 00:12:15,530
così che definiamo particolare
comportamento all'interno della scatola nera.

271
00:12:15,530 --> 00:12:16,380
Quindi mettere in pausa il video.

272
00:12:16,380 --> 00:12:18,790
E prendere tutto il tempo
è necessario cercare di definire

273
00:12:18,790 --> 00:12:25,040
un'implementazione di aggiungere due interi, come ad
che quando la funzione genera un valore,

274
00:12:25,040 --> 00:12:29,209
lo fa, infatti, il ritorno
la somma dei due ingressi.

275
00:12:29,209 --> 00:12:32,000
Così, proprio come nell'esempio precedente,
ci sono diversi modi

276
00:12:32,000 --> 00:12:34,210
che si potrebbe implementare aggiungere due int.

277
00:12:34,210 --> 00:12:35,130
Eccone uno.

278
00:12:35,130 --> 00:12:37,172
Qui in arancione ho
solo avuto qualche comments--

279
00:12:37,172 --> 00:12:38,880
Ho appena aggiunto un po '
commenti per indicare

280
00:12:38,880 --> 00:12:41,400
cosa sta succedendo su ogni riga di codice.

281
00:12:41,400 --> 00:12:45,430
Quindi dichiaro una variabile
chiamato somma di tipo int.

282
00:12:45,430 --> 00:12:47,279
Dico somma è uguale a più b.

283
00:12:47,279 --> 00:12:50,070
Ecco dove stiamo effettivamente facendo
il lavoro aggiungendo un insieme e b.

284
00:12:50,070 --> 00:12:51,850
E torno somma.

285
00:12:51,850 --> 00:12:56,460
E questo ha un senso perché
somma è una variabile di tipo int.

286
00:12:56,460 --> 00:13:00,180
E qual è il tipo di dati che questo
Funzione mi dice che sta andando a uscita?

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

288
00:13:00,680 --> 00:13:03,072
Così sto tornando somma,
è una variabile intera.

289
00:13:03,072 --> 00:13:06,030
E questo ha un senso dato quello che abbiamo
dichiarato e definito la nostra funzione

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

291
00:13:07,320 --> 00:13:09,700
>> Ora è anche possibile definire
la funzione in questo modo,

292
00:13:09,700 --> 00:13:15,260
int somma risulti un plus b-- ignorare che
prima step-- e poi, tornare somma.

293
00:13:15,260 --> 00:13:17,760
Ora si potrebbe avere anche
implementato in questo modo,

294
00:13:17,760 --> 00:13:19,180
che vi consiglio non consiglio.

295
00:13:19,180 --> 00:13:22,540
Questo è un male per uno stile
cosa e davvero cattiva progettazione,

296
00:13:22,540 --> 00:13:24,420
ma, di fatto, il lavoro.

297
00:13:24,420 --> 00:13:30,199
Se si prende questo codice, che è di tipo int
aggiungere male vipera punto c, e usarlo.

298
00:13:30,199 --> 00:13:31,990
In realtà fa aggiungere
due interi insieme.

299
00:13:31,990 --> 00:13:37,632
E 'una molto scarsa attuazione
di questo particolare comportamento.

300
00:13:37,632 --> 00:13:38,340
Ma non funziona.

301
00:13:38,340 --> 00:13:41,200
E 'qui solo per illustrare
al punto che non lo facciamo davvero

302
00:13:41,200 --> 00:13:44,530
importa ciò che accade all'interno
la scatola nera, il tempo

303
00:13:44,530 --> 00:13:46,510
in quanto ha l'output che ci aspettiamo.

304
00:13:46,510 --> 00:13:48,870
Si tratta di una scatola nera mal progettato.

305
00:13:48,870 --> 00:13:53,801
Ma alla fine della giornata, lo fa
uscita ancora la somma di a più b.

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

307
00:13:54,300 --> 00:13:56,320
Così abbiamo funzioni dichiarate.

308
00:13:56,320 --> 00:13:57,490
E abbiamo funzione di definito.

309
00:13:57,490 --> 00:13:58,540
Ecco, questo è veramente buono.

310
00:13:58,540 --> 00:14:03,020
Ora cominciamo a utilizzare le funzioni
che abbiamo dichiarato e abbiamo definito.

311
00:14:03,020 --> 00:14:05,960
Per chiamare un function-- in realtà
piuttosto easy-- tutto quello che dovete fare

312
00:14:05,960 --> 00:14:09,070
è passarlo argomenti appropriati,
argomenti del tipo di dati

313
00:14:09,070 --> 00:14:11,600
che si aspetta, e
quindi assegnare il ritorno

314
00:14:11,600 --> 00:14:15,190
valore di tale funzione
Questa poi scusa me--

315
00:14:15,190 --> 00:14:19,390
assegnare il valore di ritorno di quella funzione
a qualcosa del tipo corretto.

316
00:14:19,390 --> 00:14:22,410
>> Quindi cerchiamo di avere uno sguardo a
in pratica in un file

317
00:14:22,410 --> 00:14:27,730
chiamato vipera 1 punto c, che
Ho in CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Così qui è vipera 1 punto c.

319
00:14:31,042 --> 00:14:33,500
All'inizio vedete che io ho
il mio include, libbra comprendono,

320
00:14:33,500 --> 00:14:35,460
IO standard, e CS50 puntino h.

321
00:14:35,460 --> 00:14:37,700
E poi io ho la mia dichiarazione di funzione.

322
00:14:37,700 --> 00:14:39,570
Questo è dove sono
dice al compilatore sono

323
00:14:39,570 --> 00:14:42,850
intenzione di scrivere un
funzione chiamata aggiungere due int.

324
00:14:42,850 --> 00:14:45,780
Sta andando a emettere un
variabile di tipo integer.

325
00:14:45,780 --> 00:14:47,360
Questo è ciò che questa parte è proprio qui.

326
00:14:47,360 --> 00:14:51,950
E poi ho due ingressi di un
e b, ciascuno dei quali è un numero intero.

327
00:14:51,950 --> 00:14:58,250
All'interno di principale, chiedo l'utente per
Ingresso dicendo, dammi un numero intero.

328
00:14:58,250 --> 00:15:01,040
E sono chiesto di dimenticare
int, che è una funzione che

329
00:15:01,040 --> 00:15:03,240
è incluso nella libreria CS50.

330
00:15:03,240 --> 00:15:07,660
E che viene memorizzato in
x, una variabile intera.

331
00:15:07,660 --> 00:15:09,886
>> Poi li abbiamo richiesta di un altro intero.

332
00:15:09,886 --> 00:15:13,070
Otteniamo un altro intero
e memorizzare che in y.

333
00:15:13,070 --> 00:15:17,990
E poi, qui sulla linea 28, è
dove facciamo la nostra chiamata di funzione.

334
00:15:17,990 --> 00:15:23,770
Stiamo dicendo, pari z int
aggiungere 2 int x virgola y.

335
00:15:23,770 --> 00:15:25,980
Capite perché questo ha un senso?

336
00:15:25,980 --> 00:15:29,710
x è una variabile di tipo intero e
y è una variabile di tipo integer.

337
00:15:29,710 --> 00:15:31,220
Quindi, questo è un bene.

338
00:15:31,220 --> 00:15:34,570
Che senso ha con ciò che la nostra funzione
Dichiarazione sulla linea 17 assomiglia.

339
00:15:34,570 --> 00:15:38,300
La lista di input separati da virgole
prevede due interi, a e b.

340
00:15:38,300 --> 00:15:40,300
In questo caso, possiamo chiamare
loro tutto ciò che vogliamo.

341
00:15:40,300 --> 00:15:42,300
Si aspetta solo due interi.

342
00:15:42,300 --> 00:15:44,930
E X è un numero intero e y è un numero intero.

343
00:15:44,930 --> 00:15:45,640
Che funzioni.

344
00:15:45,640 --> 00:15:48,680
>> E sappiamo che la funzione sta andando
all'uscita un interi pure.

345
00:15:48,680 --> 00:15:51,290
E così abbiamo memorizzato la
uscita della funzione,

346
00:15:51,290 --> 00:15:56,050
aggiungere due interi, in un tipo intero
variabile, che noi stiamo chiamando z.

347
00:15:56,050 --> 00:16:01,980
E allora possiamo dire, la somma di
cento per cento ie i è cento i.

348
00:16:01,980 --> 00:16:06,210
rispettivamente x, yez
compilando quelli per cento i di.

349
00:16:06,210 --> 00:16:08,334
Qual è la definizione di
aggiungono due interi assomigliano?

350
00:16:08,334 --> 00:16:09,125
E 'piuttosto semplice.

351
00:16:09,125 --> 00:16:11,270
E 'uno di quelli che abbiamo
appena visto un secondo fa,

352
00:16:11,270 --> 00:16:14,390
int somma risulti una somma più b ritorno.

353
00:16:14,390 --> 00:16:15,420
funziona?

354
00:16:15,420 --> 00:16:17,270
Salviamo il file.

355
00:16:17,270 --> 00:16:22,080
E poi qui sul mio terminale
Io vado a fare vipera 1,

356
00:16:22,080 --> 00:16:23,000
e a cancellare il mio schermo.

357
00:16:23,000 --> 00:16:25,791
Io vado per ingrandire perché so
è un po 'difficile da vedere.

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

359
00:16:31,520 --> 00:16:33,770
>> Quindi si compila questo programma come vipera 1.

360
00:16:33,770 --> 00:16:37,910
Così possiamo fare puntino barra vipera 1.

361
00:16:37,910 --> 00:16:40,060
Dammi un numero intero, 10.

362
00:16:40,060 --> 00:16:42,380
Dammi un altro intero, 20.

363
00:16:42,380 --> 00:16:45,200
La somma di 10 e 20 è 30.

364
00:16:45,200 --> 00:16:47,615
Così abbiamo fatto una chiamata di funzione di successo.

365
00:16:47,615 --> 00:16:55,820
È possibile eseguire la funzione di nuovo, negativo
10, 17 somma di negativo 10 e 17 è 7.

366
00:16:55,820 --> 00:16:57,120
Questa funzione è attiva.

367
00:16:57,120 --> 00:16:59,240
Ha il comportamento
che ci aspettiamo che.

368
00:16:59,240 --> 00:17:03,610
E così abbiamo fatto un successo
la funzione, la definizione, la dichiarazione,

369
00:17:03,610 --> 00:17:07,288
e una chiamata di funzione di successo.

370
00:17:07,288 --> 00:17:09,079
Coppia varie
punti sulle funzioni

371
00:17:09,079 --> 00:17:10,611
prima di concludere questa sezione.

372
00:17:10,611 --> 00:17:12,319
Ricordiamo dal nostro
discussione di tipi di dati,

373
00:17:12,319 --> 00:17:16,109
precedenza, che funziona
a volte può prendere nessun ingresso.

374
00:17:16,109 --> 00:17:17,930
Se questo è il caso,
dichiarare la funzione

375
00:17:17,930 --> 00:17:19,788
come avere una lista di argomenti vuoto.

376
00:17:19,788 --> 00:17:21,579
Ti ricordi quello che il
più funzione comune

377
00:17:21,579 --> 00:17:25,036
abbiamo visto finora che prende
un elenco di argomenti vuoto è?

378
00:17:25,036 --> 00:17:27,300
E 'principale.

379
00:17:27,300 --> 00:17:30,850
Ricordiamo inoltre che la funzione a volte
in realtà non dispone di un'uscita.

380
00:17:30,850 --> 00:17:34,210
In quel caso, dichiariamo la funzione
come avere un tipo restituito nulla.

381
00:17:34,210 --> 00:17:37,880
Concludiamo questa sezione
affrontare un problema pratica.

382
00:17:37,880 --> 00:17:39,900
>> Quindi, ecco il problema definito.

383
00:17:39,900 --> 00:17:43,630
Voglio che scrive una funzione
chiamato triangolo valida.

384
00:17:43,630 --> 00:17:47,410
Ciò che questa funzione dovrebbe fare
è prendere tre numeri reali

385
00:17:47,410 --> 00:17:51,930
che rappresentano le lunghezze dei tre
lati di un triangolo come i suoi parametri,

386
00:17:51,930 --> 00:17:54,550
o dei suoi argomenti, o la sua
inputs-- un'altra serie di sinonimi

387
00:17:54,550 --> 00:17:57,340
che si potrebbero incontrare.

388
00:17:57,340 --> 00:18:01,120
Questa funzione dovrebbe
sia uscita vero o falso

389
00:18:01,120 --> 00:18:04,960
a seconda che questi tre lunghezze
sono in grado di fare un triangolo.

390
00:18:04,960 --> 00:18:09,930
Vi ricordate il tipo di dati che
abbiamo usato per indicare vero o falso?

391
00:18:09,930 --> 00:18:11,436
Ora come si fa a implementare questo?

392
00:18:11,436 --> 00:18:13,810
Beh so che ci sono un paio
di norme in materia di triangoli

393
00:18:13,810 --> 00:18:15,480
che sono in realtà utile conoscere.

394
00:18:15,480 --> 00:18:18,292
Un triangolo può avere solo
lati con lunghezza positiva.

395
00:18:18,292 --> 00:18:19,000
Ciò ha senso.

396
00:18:19,000 --> 00:18:21,432
Probabilmente stai dicendo, duh.

397
00:18:21,432 --> 00:18:23,390
L'altra cosa da notare
però, è che la somma

398
00:18:23,390 --> 00:18:25,484
delle lunghezze di qualsiasi
due lati del triangolo

399
00:18:25,484 --> 00:18:27,650
deve essere maggiore del
lunghezza del terzo lato.

400
00:18:27,650 --> 00:18:28,690
Che in realtà è vero.

401
00:18:28,690 --> 00:18:34,150
Non si può avere un triangolo di lati 1,
2 e 4, per esempio, perché 1 più 2

402
00:18:34,150 --> 00:18:36,270
non è superiore a 4.

403
00:18:36,270 --> 00:18:38,870
Così quelli sono le regole che
determinare se i tre

404
00:18:38,870 --> 00:18:42,740
ingressi possono concepibilmente formare un triangolo.

405
00:18:42,740 --> 00:18:46,360
Quindi prendere un paio di minuti
e dichiarare e quindi definire

406
00:18:46,360 --> 00:18:49,810
questa funzione chiamata valida
triangolo, tale che effettivamente

407
00:18:49,810 --> 00:18:51,650
ha il comportamento specificato.

408
00:18:51,650 --> 00:18:57,030
>> Il risultato sarà vero se quei tre lati
sono in grado di comprendere un triangolo,

409
00:18:57,030 --> 00:19:01,950
e false altrimenti
Pronti a vedere come hai fatto?

410
00:19:01,950 --> 00:19:04,650
Ecco una implementazione
triangolo valida.

411
00:19:04,650 --> 00:19:05,770
Non è l'unico.

412
00:19:05,770 --> 00:19:07,770
Distinti potrebbe variare leggermente.

413
00:19:07,770 --> 00:19:11,040
Ma di questo, infatti, hanno
il comportamento che ci aspettiamo.

414
00:19:11,040 --> 00:19:14,450
Dichiariamo la nostra funzione in
molto alto, bool triangolo valido

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

416
00:19:16,630 --> 00:19:18,930
Quindi, di nuovo, questa funzione
prende tre numeri reali

417
00:19:18,930 --> 00:19:22,280
come i suoi argomenti, galleggiante
variabili valore punto,

418
00:19:22,280 --> 00:19:26,510
ed emetterà un vero o falso
valore, che è un valore booleano, richiamo.

419
00:19:26,510 --> 00:19:28,660
Ecco, questo è il motivo per cui il tipo di ritorno è bool.

420
00:19:28,660 --> 00:19:30,016
Poi definiamo la funzione.

421
00:19:30,016 --> 00:19:33,140
La prima cosa che facciamo è controllare che
che tutti i lati sono positivi.

422
00:19:33,140 --> 00:19:37,010
Se x è minore o uguale
a 0, o se y è uguale a 0,

423
00:19:37,010 --> 00:19:41,050
o se z è minore o uguale a 0,
che non può eventualmente essere un triangolo.

424
00:19:41,050 --> 00:19:42,380
Non hanno lati positivi.

425
00:19:42,380 --> 00:19:45,790
E così possiamo tornare
falso in questa situazione.

426
00:19:45,790 --> 00:19:49,010
Avanti, controlliamo per essere sicuri
che ogni coppia di ingressi

427
00:19:49,010 --> 00:19:51,830
è maggiore rispetto alla terza.

428
00:19:51,830 --> 00:19:54,530
>> Quindi, se x + y è meno
o uguale a z,

429
00:19:54,530 --> 00:19:57,060
o se x + z è meno
o uguale a y,

430
00:19:57,060 --> 00:20:01,730
o se y + z è minore o uguale a
x, che, inoltre, non può essere un triangolo valida.

431
00:20:01,730 --> 00:20:03,800
Così torniamo di nuovo falso.

432
00:20:03,800 --> 00:20:06,900
Supponendo che abbiamo superato entrambi i controlli
anche se, allora possiamo tornare vero.

433
00:20:06,900 --> 00:20:09,440
Perché quei tre lati
sono in grado di returning--

434
00:20:09,440 --> 00:20:11,647
creazione di un triangolo valida.

435
00:20:11,647 --> 00:20:12,230
E questo è tutto.

436
00:20:12,230 --> 00:20:13,830
Avete ora dichiarata e definita.

437
00:20:13,830 --> 00:20:17,330
E si può essere in grado di ora
usare e chiamare questa funzione.

438
00:20:17,330 --> 00:20:19,470
Ottimo lavoro.

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

440
00:20:20,650 --> 00:20:22,820
Questo è CS50.

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