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

2
00:00:04,664 --> 00:00:05,580
DOUG LLOYD: All right.

3
00:00:05,580 --> 00:00:08,877
Så nå la oss takle en
virkelig stort tema, funksjoner.

4
00:00:08,877 --> 00:00:11,460
Så langt i løpet, hele
programmene som vi har vært å skrive

5
00:00:11,460 --> 00:00:12,969
har blitt skrevet innsiden av hoved.

6
00:00:12,969 --> 00:00:14,260
De er ganske enkle programmer.

7
00:00:14,260 --> 00:00:16,940
Du trenger ikke å ha alle disse
greiner og ting skjer.

8
00:00:16,940 --> 00:00:18,773
Vi kan bare plass til alle
innsiden av hoved og det

9
00:00:18,773 --> 00:00:20,407
blir ikke veldig overveldende.

10
00:00:20,407 --> 00:00:22,990
Men som kurset går videre og
når du begynner å utvikle programmer

11
00:00:22,990 --> 00:00:26,260
uavhengig av hverandre, er de sannsynligvis kommer
å begynne å få mye mer enn 10

12
00:00:26,260 --> 00:00:27,200
eller 15 linjer.

13
00:00:27,200 --> 00:00:31,400
Du kan få hundrevis eller tusenvis
eller titusenvis av linjer med kode.

14
00:00:31,400 --> 00:00:34,690
Og det er egentlig ikke
som gal en tanke.

15
00:00:34,690 --> 00:00:39,720
Som sådan, er det sannsynligvis ikke en god idé
å holde alt inne i hoved.

16
00:00:39,720 --> 00:00:43,240
Det kan bli litt vanskelig å finne
hva du leter etter hvis du gjør det.

17
00:00:43,240 --> 00:00:47,040
>> Heldigvis skjønt C, og ganske mye
alle andre programmeringsspråk som

18
00:00:47,040 --> 00:00:50,386
kan jobbe med, gjør det mulig
oss til å skrive funksjoner.

19
00:00:50,386 --> 00:00:52,260
Og jeg skal bare
ta en rask side her

20
00:00:52,260 --> 00:00:54,971
å nevne at funksjonene er
ett område av informatikk.

21
00:00:54,971 --> 00:00:57,970
Og du vil se mange flere av dem på
ulike punkter gjennom hele kurset

22
00:00:57,970 --> 00:00:59,290
og hvis du fortsetter videre.

23
00:00:59,290 --> 00:01:02,280
Der det er mye
synonymer for det samme ord.

24
00:01:02,280 --> 00:01:03,390
Så vi kaller funksjonene.

25
00:01:03,390 --> 00:01:05,980
Men du kan også høre dem
referert til som prosedyrer,

26
00:01:05,980 --> 00:01:09,570
eller metoder, spesielt hvis du har noen gang
gjort noen objektorientert programmering

27
00:01:09,570 --> 00:01:11,950
before-- og ikke bekymre
hvis du ikke har, ikke

28
00:01:11,950 --> 00:01:14,280
en stor deal-- men i
revisjonsorienterte språk

29
00:01:14,280 --> 00:01:16,129
er ofte kalt metoder.

30
00:01:16,129 --> 00:01:17,670
Noen ganger de kalles subrutiner.

31
00:01:17,670 --> 00:01:20,690
Men de virkelig alle refererer
til den samme grunnleggende ideen.

32
00:01:20,690 --> 00:01:22,480
>> La oss se hva den ideen er.

33
00:01:22,480 --> 00:01:23,310
Hva er en funksjon?

34
00:01:23,310 --> 00:01:26,470
Vel en funksjon er virkelig
noe mer enn en svart boks.

35
00:01:26,470 --> 00:01:31,430
En svart boks som har et sett med null
eller flere innganger og en enkelt utgang.

36
00:01:31,430 --> 00:01:33,420
Så for eksempel, dette
kan være en funksjon.

37
00:01:33,420 --> 00:01:35,510
Dette er en funksjon som heter func.

38
00:01:35,510 --> 00:01:39,330
Og det tar tre innganger a, b, og c.

39
00:01:39,330 --> 00:01:42,580
Og inni den svarte boksen, vi
vet ikke nøyaktig hva den gjør,

40
00:01:42,580 --> 00:01:45,100
men det behandler inngangene
på en eller annen måte, og da det

41
00:01:45,100 --> 00:01:48,680
gir en enkel utgang, i dette tilfellet, z.

42
00:01:48,680 --> 00:01:50,504
Nå for å gjøre det litt
mindre abstrakt, vi

43
00:01:50,504 --> 00:01:52,420
kunne si at vi kanskje
har en funksjon som kalles

44
00:01:52,420 --> 00:01:58,750
legge til at tar tre innganger a, b, og
c og behandler utgangs på noen måte

45
00:01:58,750 --> 00:02:01,010
inni den svarte boksen til
frembringe en enkelt utgang.

46
00:02:01,010 --> 00:02:05,190
Slik at i dette tilfellet, hvis
legge tar 3, 6 og 7.

47
00:02:05,190 --> 00:02:07,020
Et eller annet sted inne i
legge til funksjon, ville vi

48
00:02:07,020 --> 00:02:09,750
forventer at de skal legges sammen
for å frembringe den utgang, som

49
00:02:09,750 --> 00:02:13,220
er tre pluss seks pluss 7 eller 16.

50
00:02:13,220 --> 00:02:17,940
>> På samme måte har du en funksjon som heter
mult som tar to innganger, a og b,

51
00:02:17,940 --> 00:02:21,070
behandler dem på en eller annen måte, for eksempel
at utgangen fra funksjons

52
00:02:21,070 --> 00:02:22,920
er produktet av de to inngangene.

53
00:02:22,920 --> 00:02:25,080
De to inngangene multiplisert sammen.

54
00:02:25,080 --> 00:02:29,150
4 og 5 blir vedtatt i mult,
noe skjer, resultatet vi forventer

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

56
00:02:31,090 --> 00:02:32,507
Hvorfor kaller vi det en svart boks?

57
00:02:32,507 --> 00:02:34,840
Vel, hvis vi ikke skriver det
fungerer oss selv, som

58
00:02:34,840 --> 00:02:36,869
vi har gjort ganske mye så langt CS50.

59
00:02:36,869 --> 00:02:39,910
Vi har sett print f, for eksempel, som
er en funksjon som vi ikke skrive

60
00:02:39,910 --> 00:02:42,305
oss selv, men vi bruker hele tiden.

61
00:02:42,305 --> 00:02:44,180
Hvis vi ikke skriver
funksjonene oss selv,

62
00:02:44,180 --> 00:02:48,450
vi trenger egentlig ikke å vite hvordan det er
faktisk blir gjennomført under panseret.

63
00:02:48,450 --> 00:02:51,710
>> Så for eksempel den svarte boksen jeg
bare viste deg for multiplikasjon,

64
00:02:51,710 --> 00:02:53,740
mult en kan b være
defined-- og dette er bare

65
00:02:53,740 --> 00:02:57,902
noen pseudocode-- kan være
definert som utgangs en ganger b.

66
00:02:57,902 --> 00:02:58,860
Det fornuftig, ikke sant.

67
00:02:58,860 --> 00:03:01,370
Hvis vi har en funksjon som heter
mult som tar to innganger.

68
00:03:01,370 --> 00:03:04,750
Vi forventer at produksjonen ville
være de to inngangene multiplisert sammen,

69
00:03:04,750 --> 00:03:06,240
en ganger b.

70
00:03:06,240 --> 00:03:09,170
Men kan også være mult
implementert som dette,

71
00:03:09,170 --> 00:03:13,150
vi har en teller variabel til
få satt inni mult til 0.

72
00:03:13,150 --> 00:03:18,000
Og da vi gjenta denne prosessen
b ganger legger en til disken.

73
00:03:18,000 --> 00:03:24,270
For eksempel, hvis vi multipliserer 3a ved
5b, vi kunne si sette telleren til 0,

74
00:03:24,270 --> 00:03:27,700
gjenta fem ganger, tilsett 3 til disken.

75
00:03:27,700 --> 00:03:34,490
Så vi starter på 0 og deretter vi gjør
dette fem ganger 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
Det er det samme resultatet. Vi
fortsatt få 3 ganger 5 bare

77
00:03:37,500 --> 00:03:39,500
implementeringen er forskjellig.

78
00:03:39,500 --> 00:03:41,490
>> Det er det vi mener
når vi sier en svart boks.

79
00:03:41,490 --> 00:03:44,406
Det betyr bare at vi egentlig ikke bryr seg
hvordan den er implementert under panseret

80
00:03:44,406 --> 00:03:46,170
så lenge produksjonen er hva vi forventer.

81
00:03:46,170 --> 00:03:49,045
Faktisk, det er en del av kontrakten
for å bruke funksjoner, spesielt

82
00:03:49,045 --> 00:03:50,630
funksjoner som andre skriver.

83
00:03:50,630 --> 00:03:53,980
Oppførselen er alltid kommer
å være typisk, uforutsigbar

84
00:03:53,980 --> 00:03:55,420
basert på navnet på funksjonen.

85
00:03:55,420 --> 00:03:57,500
Og det er derfor det er virkelig
viktig når du skriver funksjoner

86
00:03:57,500 --> 00:04:00,020
eller når andre folk skriver
funksjoner som du kan bruke,

87
00:04:00,020 --> 00:04:03,590
at disse funksjonene har
klare, relativt åpenbare navn,

88
00:04:03,590 --> 00:04:04,990
og er godt dokumentert.

89
00:04:04,990 --> 00:04:08,560
Som er absolutt tilfelle
for funksjonen som print f.

90
00:04:08,560 --> 00:04:09,860
>> Så hvorfor skal vi bruke funksjoner?

91
00:04:09,860 --> 00:04:14,220
Vel som jeg sa tidligere, hvis vi skriver
alle våre kode innsiden av viktigste tingene

92
00:04:14,220 --> 00:04:17,120
kan bli veldig tungvint
og veldig komplisert.

93
00:04:17,120 --> 00:04:19,980
Funksjoner tillate oss muligheten
å organisere ting og bryte opp

94
00:04:19,980 --> 00:04:24,540
et veldig komplisert problem i
mye mer håndterbare underdeler.

95
00:04:24,540 --> 00:04:28,130
Funksjoner også tillate oss å
forenkle kodingsprosessen.

96
00:04:28,130 --> 00:04:33,080
Det er mye lettere å feilsøke en 10
linje funksjon kontra en 100 linje

97
00:04:33,080 --> 00:04:35,890
funksjon eller en linje 1000 funksjon.

98
00:04:35,890 --> 00:04:38,400
Hvis vi bare nødt til å feilsøke
små biter om gangen,

99
00:04:38,400 --> 00:04:42,110
eller skrive små stykker på den tiden,
det gjør at erfaring med programmering

100
00:04:42,110 --> 00:04:43,070
mye bedre.

101
00:04:43,070 --> 00:04:44,910
Stol på meg på den.

102
00:04:44,910 --> 00:04:48,400
>> Til slutt, hvis vi skriver funksjoner vi
kan gjenbruke de forskjellige delene.

103
00:04:48,400 --> 00:04:49,880
Funksjoner kan resirkuleres.

104
00:04:49,880 --> 00:04:51,880
De kan brukes i
en program eller en annen.

105
00:04:51,880 --> 00:04:53,713
Du har allerede skrevet
funksjonen, alt du

106
00:04:53,713 --> 00:04:56,530
trenger å gjøre er å fortelle at programmet
hvor du finner den funksjonen.

107
00:04:56,530 --> 00:04:59,680
Vi har vært resirkulering og bruk
skrive ut f i over 40 år.

108
00:04:59,680 --> 00:05:02,150
Men det ble bare skrevet én gang.

109
00:05:02,150 --> 00:05:04,270
Ganske nyttig, ikke sant.

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

111
00:05:04,830 --> 00:05:06,040
Så funksjoner er stor.

112
00:05:06,040 --> 00:05:06,860
Vi vet det.

113
00:05:06,860 --> 00:05:08,700
La oss nå begynne å skrive dem.

114
00:05:08,700 --> 00:05:10,830
La oss begynne å bli
dem inn i våre programmer.

115
00:05:10,830 --> 00:05:13,869
For å gjøre det, det første
vi gjør er erklære funksjonen.

116
00:05:13,869 --> 00:05:16,160
Når du deklarerer en funksjon
hva du egentlig gjør

117
00:05:16,160 --> 00:05:18,900
forteller kompilatoren,
hei, bare så du vet,

118
00:05:18,900 --> 00:05:20,850
Jeg kommer til å skrive
en funksjon senere

119
00:05:20,850 --> 00:05:22,987
og her er hva det kommer til å se ut.

120
00:05:22,987 --> 00:05:24,820
Grunnen til dette er
fordi kompilatorer kan

121
00:05:24,820 --> 00:05:27,900
gjør noen rare ting hvis
de ser et sett med symboler

122
00:05:27,900 --> 00:05:29,560
at de ikke er kjent med.

123
00:05:29,560 --> 00:05:33,000
Så vi bare gi kompilatoren en
heads up, jeg skaper en funksjon

124
00:05:33,000 --> 00:05:35,492
og det kommer til å gjøre dette.

125
00:05:35,492 --> 00:05:38,450
Funksjon erklæringer generelt hvis
du organisere koden på en måte

126
00:05:38,450 --> 00:05:41,872
at andre vil kunne
forstå og gjøre bruk av,

127
00:05:41,872 --> 00:05:44,330
du generelt ønsker å sette alle
av funksjons erklæringer

128
00:05:44,330 --> 00:05:48,220
på toppen av koden din, rett
før du begynner å skrive hoved selv.

129
00:05:48,220 --> 00:05:50,770
Og praktisk, det er
en veldig standard skjema

130
00:05:50,770 --> 00:05:53,500
at hver funksjon erklæring følger.

131
00:05:53,500 --> 00:05:56,090
De er alle ganske mye ser ut som dette.

132
00:05:56,090 --> 00:06:01,440
Det er tre deler til en funksjon
erklæringen, returtype, navn,

133
00:06:01,440 --> 00:06:03,420
og argumentliste.

134
00:06:03,420 --> 00:06:07,180
>> Nå returtypen er hva slags
variable funksjonen vil produksjonen.

135
00:06:07,180 --> 00:06:10,710
Så for eksempel, hvis vi tenker tilbake en
minutt siden til å multiplisere to-

136
00:06:10,710 --> 00:06:15,690
tall funksjon, hva gjør vi forvente hvis
vi multipliserer et tall med et heltall

137
00:06:15,690 --> 00:06:18,502
produksjonen vil bli
sannsynligvis et heltall, ikke sant.

138
00:06:18,502 --> 00:06:20,710
Multiplisert to heltall
sammen, får du et heltall.

139
00:06:20,710 --> 00:06:24,167
Så avkastningen type som
funksjon ville være int.

140
00:06:24,167 --> 00:06:26,000
Navn er det du ønsker
å ringe din funksjon.

141
00:06:26,000 --> 00:06:29,330
Dette er trolig den minst viktige
del av funksjonen erklæringen

142
00:06:29,330 --> 00:06:30,827
når det gjelder funksjonalitet.

143
00:06:30,827 --> 00:06:33,160
Men faktisk er trolig en
av de viktigste delene

144
00:06:33,160 --> 00:06:36,243
av funksjonen erklæring i form
av å vite hva funksjonen faktisk

145
00:06:36,243 --> 00:06:37,120
gjør.

146
00:06:37,120 --> 00:06:40,474
Hvis du navnet ditt funksjon f eller g eller
h eller mysterium eller noe sånt,

147
00:06:40,474 --> 00:06:42,765
er du sannsynligvis kommer til å få
litt utløst opp prøver

148
00:06:42,765 --> 00:06:44,650
å huske hva disse funksjonene gjør.

149
00:06:44,650 --> 00:06:47,880
Så det er viktig å gi
funksjonens meningsfulle navn.

150
00:06:47,880 --> 00:06:51,030
>> Til slutt, er argument liste
kommaseparert liste

151
00:06:51,030 --> 00:06:55,260
av alle innganger til din funksjon,
som hver har en type og et navn.

152
00:06:55,260 --> 00:06:57,840
Så ikke bare har du til
spesifisere hva slags variabel

153
00:06:57,840 --> 00:07:00,760
Funksjonen vil utgang,
du også ønsker å spesifisere

154
00:07:00,760 --> 00:07:07,694
hva slags og hvilke variabler de
funksjon vil være å akseptere som innganger.

155
00:07:07,694 --> 00:07:08,860
Så la oss gjøre et eksempel her.

156
00:07:08,860 --> 00:07:10,220
La oss bare ta en titt
på en mer konkret en.

157
00:07:10,220 --> 00:07:13,130
Så her er et eksempel på en funksjon
erklæring for en funksjon som

158
00:07:13,130 --> 00:07:14,925
ville legge to heltall sammen.

159
00:07:14,925 --> 00:07:17,800
Summen av to heltall skal
være et heltall også, som vi bare

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

161
00:07:18,450 --> 00:07:21,610
Og så returtypen,
her i grønt, ville være int.

162
00:07:21,610 --> 00:07:25,190
Som bare forteller oss at legge to ints
kommer til, ved slutten av dagen,

163
00:07:25,190 --> 00:07:28,799
utgang, eller spytte det tilbake
ut til oss, et heltall.

164
00:07:28,799 --> 00:07:31,590
Gitt hva denne funksjonen gjør vi
ønsker å gi det et meningsfullt navn.

165
00:07:31,590 --> 00:07:33,630
Legg to ints virker
hensiktsmessig, med tanke

166
00:07:33,630 --> 00:07:37,574
vi tar to heltall som innganger
og forhåpentligvis legge dem sammen.

167
00:07:37,574 --> 00:07:40,240
Det kan være litt av en tungvint
navn og ærlig denne funksjonen

168
00:07:40,240 --> 00:07:42,430
er sannsynligvis ikke nødvendig
siden vi har tilsetting

169
00:07:42,430 --> 00:07:46,310
operatør, hvis du husker fra vår
drøfting av operatører, tidligere.

170
00:07:46,310 --> 00:07:49,650
Men la oss bare si for moro skyld
Argumentet om at denne funksjonen er nyttig

171
00:07:49,650 --> 00:07:52,860
og så får vi kalle det legge to ints.

172
00:07:52,860 --> 00:07:55,230
Til slutt, tar denne funksjonen to innganger.

173
00:07:55,230 --> 00:07:56,960
Som hver for seg er et heltall.

174
00:07:56,960 --> 00:07:59,900
Så vi har denne komma
separert liste med innganger.

175
00:07:59,900 --> 00:08:02,830
Nå er vi generelt ønsker å
gi et navn til hver av dem

176
00:08:02,830 --> 00:08:05,070
slik at de kan benyttes
i funksjonen.

177
00:08:05,070 --> 00:08:07,180
Navnene er ikke veldig viktig.

178
00:08:07,180 --> 00:08:11,400
>> I dette tilfellet har vi ikke nødvendigvis
har noen betydning knyttet til dem.

179
00:08:11,400 --> 00:08:13,140
Så vi kan bare kalle dem a og b.

180
00:08:13,140 --> 00:08:14,257
Det er helt greit.

181
00:08:14,257 --> 00:08:16,090
Hvis derimot, finner du
selv i en situasjon

182
00:08:16,090 --> 00:08:19,497
hvor navnene på de variable
faktisk kan være viktig,

183
00:08:19,497 --> 00:08:21,830
kan det være lurt å ringe dem
noe annet enn en, og b

184
00:08:21,830 --> 00:08:24,701
å gi dem noe mer
symbolsk meningsfylt.

185
00:08:24,701 --> 00:08:27,700
Men i dette tilfellet, gjør vi egentlig ikke
vite noe annet om funksjonen.

186
00:08:27,700 --> 00:08:29,320
Vi vil bare legge til to heltall.

187
00:08:29,320 --> 00:08:32,429
Så får vi bare kalle
de heltall a og b.

188
00:08:32,429 --> 00:08:33,990
Det er ett eksempel.

189
00:08:33,990 --> 00:08:36,287
>> Hvorfor ikke ta en ekstra
å tenke på dette,

190
00:08:36,287 --> 00:08:38,870
hvordan ville du skriver en funksjon
erklæring for en funksjon som

191
00:08:38,870 --> 00:08:42,940
multipliserer to flyttall?

192
00:08:42,940 --> 00:08:45,910
Husker du hva en
flyttall er?

193
00:08:45,910 --> 00:08:48,120
Hva ville denne funksjonen
erklæring se ut?

194
00:08:48,120 --> 00:08:53,330
Jeg faktisk anbefale deg pause videoen
her og ta hvor mye tid du trenger.

195
00:08:53,330 --> 00:08:55,521
Tenk på hva dette
funksjon erklæring ville være?

196
00:08:55,521 --> 00:08:56,770
Hva ville returtypen være?

197
00:08:56,770 --> 00:08:58,103
Hva ville et meningsfullt navn være?

198
00:08:58,103 --> 00:08:59,580
Hva ville inngangene være?

199
00:08:59,580 --> 00:09:03,190
Så hvorfor ikke du pause videoen her
og skrive opp en funksjon erklæring

200
00:09:03,190 --> 00:09:07,640
for en funksjon som ville formere
to flyttall sammen.

201
00:09:07,640 --> 00:09:09,330
Forhåpentligvis du stoppet videoen.

202
00:09:09,330 --> 00:09:12,950
>> Så la oss ta en titt på et eksempel
av en mulig erklæring.

203
00:09:12,950 --> 00:09:17,340
Flyte mult to Reals flyte x, float y.

204
00:09:17,340 --> 00:09:19,090
Produktet av to
flyttall,

205
00:09:19,090 --> 00:09:21,710
som husker er hvordan vi
representere reelle tall

206
00:09:21,710 --> 00:09:26,770
eller tall med desimaltall i c,
kommer til å være et desimaltall.

207
00:09:26,770 --> 00:09:28,570
Når du multipliserer et
desimal av en desimal,

208
00:09:28,570 --> 00:09:30,460
er du sannsynligvis kommer til å få en desimal.

209
00:09:30,460 --> 00:09:31,960
Du ønsker å gi det et relevant navn.

210
00:09:31,960 --> 00:09:33,810
Multiplisere to Reals virker fint.

211
00:09:33,810 --> 00:09:36,620
Men du kan virkelig kalle det
mult to flyter, eller mult flyter.

212
00:09:36,620 --> 00:09:39,540
Noe sånt, så lenge det
ga noen faktiske betydningen til hva

213
00:09:39,540 --> 00:09:41,469
denne svarte boksen skulle gjøre.

214
00:09:41,469 --> 00:09:44,260
Og igjen, i dette tilfellet, gjør vi ikke
ser ut til å ha noen mening festet

215
00:09:44,260 --> 00:09:46,390
til navnene på
variabler vi passerer i,

216
00:09:46,390 --> 00:09:48,645
så vi bare ringe dem x og y.

217
00:09:48,645 --> 00:09:51,020
Nå hvis du kaller dem noe
annet, det er helt greit.

218
00:09:51,020 --> 00:09:53,310
Faktisk, hvis du gjorde
denne erklæringen i stedet

219
00:09:53,310 --> 00:09:55,450
bruker dobles i stedet
av flyter, hvis du husker

220
00:09:55,450 --> 00:09:59,100
som dobler er en annen
måte til mer presist

221
00:09:59,100 --> 00:10:02,330
oppgi reelle tall eller
flyt variabler.

222
00:10:02,330 --> 00:10:03,620
Det er helt greit også.

223
00:10:03,620 --> 00:10:04,670
Enten en av dem ville være fint.

224
00:10:04,670 --> 00:10:06,711
Faktisk er det flere
ulike kombinasjoner

225
00:10:06,711 --> 00:10:08,410
måter å erklære denne funksjonen.

226
00:10:08,410 --> 00:10:10,884
Men dette er to ganske gode.

227
00:10:10,884 --> 00:10:12,550
Vi har erklært en funksjon, det er flott.

228
00:10:12,550 --> 00:10:15,700
Vi har fortalt kompilatoren hva det
er, hva vi skal gjøre.

229
00:10:15,700 --> 00:10:17,630
Nå la oss faktisk skrive denne funksjonen.

230
00:10:17,630 --> 00:10:20,750
La oss gi den en definisjon,
slik at inni den svarte boksen

231
00:10:20,750 --> 00:10:22,840
forutsigbar oppførsel som skjer.

232
00:10:22,840 --> 00:10:26,270
Faktisk er vi multiplisere to reelle
tallene sammen, eller legge til tall

233
00:10:26,270 --> 00:10:29,760
sammen, eller gjøre hva det er
at vi bedt vår funksjon å gjøre.

234
00:10:29,760 --> 00:10:32,780
>> Så faktisk, la oss prøve og definere
multiplisere to Reals som vi bare

235
00:10:32,780 --> 00:10:35,350
snakket om en andre siden.

236
00:10:35,350 --> 00:10:38,560
Nå begynnelsen av
en funksjonsdefinisjon

237
00:10:38,560 --> 00:10:41,720
ser nesten nøyaktig det samme
som en funksjon erklæring.

238
00:10:41,720 --> 00:10:43,170
Jeg har begge av dem her.

239
00:10:43,170 --> 00:10:47,770
På toppen er funksjonen erklæring,
type, navn, kommaseparert argument

240
00:10:47,770 --> 00:10:49,410
listen, semikolon.

241
00:10:49,410 --> 00:10:53,800
Semikolon indikerer at
som er en funksjon erklæring.

242
00:10:53,800 --> 00:10:57,060
Begynnelsen av funksjonen
definisjon ser nesten nøyaktig

243
00:10:57,060 --> 00:11:03,790
det samme, type, navn, kommaseparert
argumentliste, ingen semikolon,

244
00:11:03,790 --> 00:11:05,206
åpne klammeparentes.

245
00:11:05,206 --> 00:11:07,580
Den åpne klammeparentes, akkurat som
vi har gjort med hoved,

246
00:11:07,580 --> 00:11:09,540
betyr at vi nå
begynner å definere

247
00:11:09,540 --> 00:11:14,567
hva som skjer inni den svarte boksen som
Vi har besluttet å kalle mult to Reals.

248
00:11:14,567 --> 00:11:15,900
Her er en måte å gjennomføre det.

249
00:11:15,900 --> 00:11:20,370
Vi kan si, vi kunne erklære en ny
variabel av type float kalt produktet

250
00:11:20,370 --> 00:11:24,020
og tilordne den variabelen
til verdien x ganger y.

251
00:11:24,020 --> 00:11:27,306
Og deretter returnere produktet.

252
00:11:27,306 --> 00:11:28,430
Hva betyr retur mener her.

253
00:11:28,430 --> 00:11:31,090
Vel tilbake er veien
Vi viser at er hvordan

254
00:11:31,090 --> 00:11:33,400
vi passerer utgangs ut igjen.

255
00:11:33,400 --> 00:11:38,160
Så tilbake noe, er den samme som,
Dette er resultatet av den sorte boksen.

256
00:11:38,160 --> 00:11:40,732
Så det er hvordan du gjør det.

257
00:11:40,732 --> 00:11:42,190
Her er en annen måte å gjennomføre det.

258
00:11:42,190 --> 00:11:45,050
Vi kunne bare gå tilbake x ganger y.

259
00:11:45,050 --> 00:11:45,870
x er en flottør.

260
00:11:45,870 --> 00:11:46,660
y er en float.

261
00:11:46,660 --> 00:11:48,490
Så x ganger y er også en flåte.

262
00:11:48,490 --> 00:11:50,750
Vi trenger ikke engang å
opprette en annen variabel.

263
00:11:50,750 --> 00:11:56,750
Så det er en annen måte å
gjennomføre nøyaktig samme sorte boksen.

264
00:11:56,750 --> 00:11:58,570
>> Nå tar et øyeblikk,
pause videoen igjen,

265
00:11:58,570 --> 00:12:01,680
og prøve og definere legge to ints,
som er den andre funksjon som vi

266
00:12:01,680 --> 00:12:03,090
snakket om et øyeblikk siden.

267
00:12:03,090 --> 00:12:06,440
Igjen her, har jeg satt funksjonen
erklæringen, og så semikolon,

268
00:12:06,440 --> 00:12:08,420
og en åpen klammeparentes
og en lukket krøllete

269
00:12:08,420 --> 00:12:12,080
brace for å indikere hvor vi vil fylle
i innholdet legge to ints,

270
00:12:12,080 --> 00:12:15,530
slik at vi definerer den spesielle
atferd inne den svarte boksen.

271
00:12:15,530 --> 00:12:16,380
Så pause videoen.

272
00:12:16,380 --> 00:12:18,790
Og ta så mye tid som
du må prøve og definere

273
00:12:18,790 --> 00:12:25,040
en implementering av legge to ints, slik
at når funksjonen utmater en verdi,

274
00:12:25,040 --> 00:12:29,209
den gjør det, faktisk, retur
summen av de to inngangene.

275
00:12:29,209 --> 00:12:32,000
Så akkurat som forrige eksempel,
Det er flere forskjellige måter

276
00:12:32,000 --> 00:12:34,210
at du kan gjennomføre legge to ints.

277
00:12:34,210 --> 00:12:35,130
Her er en.

278
00:12:35,130 --> 00:12:37,172
Her inne i oransje har jeg
bare hadde noen comments--

279
00:12:37,172 --> 00:12:38,880
Jeg har akkurat lagt noen
kommentarer for å indikere

280
00:12:38,880 --> 00:12:41,400
hva som skjer på hver linje med kode.

281
00:12:41,400 --> 00:12:45,430
Så jeg erklære en variabel
kalt summen av typen int.

282
00:12:45,430 --> 00:12:47,279
Jeg sier sum tilsvarer et pluss b.

283
00:12:47,279 --> 00:12:50,070
Det er der vi faktisk gjør
arbeidet tilsette A og B sammen.

284
00:12:50,070 --> 00:12:51,850
Og jeg kommer tilbake sum.

285
00:12:51,850 --> 00:12:56,460
Og det er fornuftig fordi
Summen er en variabel av type int.

286
00:12:56,460 --> 00:13:00,180
Og hva er dataene skriver at dette
funksjon forteller meg at det kommer til produksjon?

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

288
00:13:00,680 --> 00:13:03,072
Så jeg er tilbake sum, som
er et helt tall variabel.

289
00:13:03,072 --> 00:13:06,030
Og det er fornuftig gitt hva vi har
erklært og definert vår funksjon

290
00:13:06,030 --> 00:13:07,320
å gjøre.

291
00:13:07,320 --> 00:13:09,700
>> Nå kan du også definere
funksjonen på denne måten,

292
00:13:09,700 --> 00:13:15,260
int sum tilsvarer et pluss B-- hoppe over den
først step-- og deretter returnere sum.

293
00:13:15,260 --> 00:13:17,760
Nå kan du også
implementert det på denne måten,

294
00:13:17,760 --> 00:13:19,180
som jeg ikke anbefaler.

295
00:13:19,180 --> 00:13:22,540
Dette er dårlig stil for én
ting og virkelig dårlig design,

296
00:13:22,540 --> 00:13:24,420
men det gjør i virkeligheten arbeid.

297
00:13:24,420 --> 00:13:30,199
Hvis du tar denne koden, som er int
legge dårlig huggorm dot c, og bruke det.

298
00:13:30,199 --> 00:13:31,990
Det faktisk legger
to heltall sammen.

299
00:13:31,990 --> 00:13:37,632
Det er en veldig dårlig gjennomføring
av denne spesielle oppførsel.

300
00:13:37,632 --> 00:13:38,340
Men det fungerer.

301
00:13:38,340 --> 00:13:41,200
Det er bare her for å illustrere
punktet at vi egentlig ikke

302
00:13:41,200 --> 00:13:44,530
seg hva som skjer på innsiden
den svarte boksen, så lenge

303
00:13:44,530 --> 00:13:46,510
som den har den produksjonen som vi forventer.

304
00:13:46,510 --> 00:13:48,870
Dette er en dårlig utformet svart boks.

305
00:13:48,870 --> 00:13:53,801
Men på slutten av dagen, gjør det
fortsatt produksjon summen av a pluss b.

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

307
00:13:54,300 --> 00:13:56,320
Så vi har erklært funksjoner.

308
00:13:56,320 --> 00:13:57,490
Og vi har definert funksjon.

309
00:13:57,490 --> 00:13:58,540
Så det er veldig bra.

310
00:13:58,540 --> 00:14:03,020
Nå la oss begynne å bruke funksjonene
at vi har deklarert og vi har definert.

311
00:14:03,020 --> 00:14:05,960
Å kalle en function-- det er faktisk
ganske easy-- alt du trenger å gjøre

312
00:14:05,960 --> 00:14:09,070
er pass det riktige argumenter,
argumenter av datatype

313
00:14:09,070 --> 00:14:11,600
at det forventer, og
deretter tildele retur

314
00:14:11,600 --> 00:14:15,190
verdien av denne funksjon
og dette-- unnskyldning me--

315
00:14:15,190 --> 00:14:19,390
tilordne returverdien av denne funksjonen
til noe av riktig type.

316
00:14:19,390 --> 00:14:22,410
>> Så la oss ta en titt på
dette i praksis i en fil

317
00:14:22,410 --> 00:14:27,730
kalt huggorm en prikk c, som
Jeg har i min CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Så her er huggorm en prikk c.

319
00:14:31,042 --> 00:14:33,500
I begynnelsen ser du jeg har
min inneholder, pund inkluderer,

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

321
00:14:35,460 --> 00:14:37,700
Og så har jeg min funksjon erklæring.

322
00:14:37,700 --> 00:14:39,570
Det er der jeg er
forteller kompilatoren jeg er

323
00:14:39,570 --> 00:14:42,850
skal skrive en
funksjon kalt legge to ints.

324
00:14:42,850 --> 00:14:45,780
Det kommer til å sende ut et
heltall type variabel.

325
00:14:45,780 --> 00:14:47,360
Det er det denne delen er rett her.

326
00:14:47,360 --> 00:14:51,950
Og så har jeg to innganger til det en
og b, som hver for seg er et heltall.

327
00:14:51,950 --> 00:14:58,250
Innsiden av hoved, jeg ber brukeren om
innspill ved å si, gi meg et heltall.

328
00:14:58,250 --> 00:15:01,040
Og de blir bedt om å glemme
int, som er en funksjon som

329
00:15:01,040 --> 00:15:03,240
inngår i CS50 biblioteket.

330
00:15:03,240 --> 00:15:07,660
Og som blir lagret i
x, et heltall variabel.

331
00:15:07,660 --> 00:15:09,886
>> Så vi ber dem om et annet heltall.

332
00:15:09,886 --> 00:15:13,070
Vi får et annet heltall
og lagre det i y.

333
00:15:13,070 --> 00:15:17,990
Og så, her på linje 28, er
hvor vi gjør vår funksjon samtale.

334
00:15:17,990 --> 00:15:23,770
Vi sier, int z equals
tilsett 2 ints x komma y.

335
00:15:23,770 --> 00:15:25,980
Ser du hvorfor dette er fornuftig?

336
00:15:25,980 --> 00:15:29,710
x er et helt tall og type variabel
y er et helt tall type variabel.

337
00:15:29,710 --> 00:15:31,220
Så det er bra.

338
00:15:31,220 --> 00:15:34,570
Det fornuftig med hva vår funksjon
erklæring på linje 17 ser ut.

339
00:15:34,570 --> 00:15:38,300
Kommaseparert innspill liste
forventer to heltall, a og b.

340
00:15:38,300 --> 00:15:40,300
I så tilfelle, kan vi kalle
dem hva vi vil.

341
00:15:40,300 --> 00:15:42,300
Det forventer bare to heltall.

342
00:15:42,300 --> 00:15:44,930
Og x er et helt tall og y er et helt tall.

343
00:15:44,930 --> 00:15:45,640
Som fungerer.

344
00:15:45,640 --> 00:15:48,680
>> Og vi vet at funksjonen skal
å sende ut et heltall i tillegg.

345
00:15:48,680 --> 00:15:51,290
Og så er vi lagrer
Utgangen av funksjon,

346
00:15:51,290 --> 00:15:56,050
legge to ints, i en heltallstype
variabel, som vi kaller z.

347
00:15:56,050 --> 00:16:01,980
Og så kan vi si, summen av
prosent i og prosent i er prosent i.

348
00:16:01,980 --> 00:16:06,210
henholdsvis x, y og z
fylle de prosent i tallet.

349
00:16:06,210 --> 00:16:08,334
Hva er definisjonen av
legge to ints se ut?

350
00:16:08,334 --> 00:16:09,125
Det er ganske enkelt.

351
00:16:09,125 --> 00:16:11,270
Det er en av de vi
bare så en andre siden,

352
00:16:11,270 --> 00:16:14,390
int sum tilsvarer et pluss b retur sum.

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

354
00:16:15,420 --> 00:16:17,270
La oss lagre filen.

355
00:16:17,270 --> 00:16:22,080
Og deretter ned her på min terminal
Jeg kommer til å gjøre huggorm 1,

356
00:16:22,080 --> 00:16:23,000
og jeg tømme skjermen min.

357
00:16:23,000 --> 00:16:25,791
Jeg kommer til å zoome inn fordi jeg vet
det er litt vanskelig å se.

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

359
00:16:31,520 --> 00:16:33,770
>> Så vi kompilere dette programmet som huggorm en.

360
00:16:33,770 --> 00:16:37,910
Så vi kan gjøre dot slash huggorm en.

361
00:16:37,910 --> 00:16:40,060
Gi meg et heltall, 10.

362
00:16:40,060 --> 00:16:42,380
Gi meg et annet heltall, 20.

363
00:16:42,380 --> 00:16:45,200
Summen av 10 og 20 er 30.

364
00:16:45,200 --> 00:16:47,615
Så vi har gjort en vellykket funksjonskall.

365
00:16:47,615 --> 00:16:55,820
Du kan kjøre funksjonen igjen, negative
10, er 17 summen av negative 10 og 17 7.

366
00:16:55,820 --> 00:16:57,120
Denne funksjonen fungerer.

367
00:16:57,120 --> 00:16:59,240
Det har oppførselen
at vi forventer det.

368
00:16:59,240 --> 00:17:03,610
Og så har vi gjort en vellykket
funksjon, definisjon, erklæring,

369
00:17:03,610 --> 00:17:07,288
og en vellykket funksjon samtale.

370
00:17:07,288 --> 00:17:09,079
Par diverse
punkter om funksjoner

371
00:17:09,079 --> 00:17:10,611
før vi avslutter denne delen.

372
00:17:10,611 --> 00:17:12,319
Husker fra vår
omtale av datatyper,

373
00:17:12,319 --> 00:17:16,109
tidligere, som fungerer
kan noen ganger ta noen innganger.

374
00:17:16,109 --> 00:17:17,930
Hvis det er tilfelle, vi
erklære funksjonen

375
00:17:17,930 --> 00:17:19,788
som å ha et tomrom argument listen.

376
00:17:19,788 --> 00:17:21,579
Husker du hva den
vanligste funksjonen

377
00:17:21,579 --> 00:17:25,036
vi har sett så langt som tar
et tomrom argument listen er?

378
00:17:25,036 --> 00:17:27,300
Det viktigste.

379
00:17:27,300 --> 00:17:30,850
Husker også at funksjonen noen ganger
ikke egentlig har en utgang.

380
00:17:30,850 --> 00:17:34,210
I så fall, vi erklærer funksjonen
som å ha et tomrom returtype.

381
00:17:34,210 --> 00:17:37,880
La oss avslutte denne delen av
takle en praksis problem.

382
00:17:37,880 --> 00:17:39,900
>> Så her er problemet lagt ut.

383
00:17:39,900 --> 00:17:43,630
Jeg vil du skal skrive en funksjon
kalt gyldig trekant.

384
00:17:43,630 --> 00:17:47,410
Hva denne funksjonen gjør
er å ta tre reelle tall

385
00:17:47,410 --> 00:17:51,930
som representerer lengden av de tre
sidene av en trekant som parametere,

386
00:17:51,930 --> 00:17:54,550
eller argumentene, eller dens
inputs-- et annet sett med synonymer

387
00:17:54,550 --> 00:17:57,340
at du kan støte på.

388
00:17:57,340 --> 00:18:01,120
Denne funksjonen bør
enten utgang sant eller usant

389
00:18:01,120 --> 00:18:04,960
avhengig av om de tre lengder
er i stand til å lage en trekant.

390
00:18:04,960 --> 00:18:09,930
Husker du den datatypen som
vi pleide å indikere sant eller usant?

391
00:18:09,930 --> 00:18:11,436
Nå hvordan implementerer du dette?

392
00:18:11,436 --> 00:18:13,810
Vel vet det er et par
av reglene om trekanter

393
00:18:13,810 --> 00:18:15,480
som faktisk er nyttig å vite.

394
00:18:15,480 --> 00:18:18,292
En trekant kan bare ha
sider med positiv lengde.

395
00:18:18,292 --> 00:18:19,000
Det er fornuftig.

396
00:18:19,000 --> 00:18:21,432
Du er nok å si, duh.

397
00:18:21,432 --> 00:18:23,390
Den andre ting å merke seg
skjønt, er at summen

398
00:18:23,390 --> 00:18:25,484
av lengdene av alle
to sider av trekanten

399
00:18:25,484 --> 00:18:27,650
må være større enn den
lengden av den tredje side.

400
00:18:27,650 --> 00:18:28,690
Det er faktisk sant.

401
00:18:28,690 --> 00:18:34,150
Du kan ikke ha en trekant med sider 1,
2 og 4, for eksempel fordi en pluss 2

402
00:18:34,150 --> 00:18:36,270
ikke er større enn fire.

403
00:18:36,270 --> 00:18:38,870
Så de er de reglene som
bestemme hvorvidt eller ikke de tre

404
00:18:38,870 --> 00:18:42,740
Inngangene kan tenkes å danne en trekant.

405
00:18:42,740 --> 00:18:46,360
Så ta et par minutter
og erklære og deretter definere

406
00:18:46,360 --> 00:18:49,810
Denne funksjonen kalles gyldig
trekant, slik at det faktisk

407
00:18:49,810 --> 00:18:51,650
har atferden som er angitt her.

408
00:18:51,650 --> 00:18:57,030
>> Det vil produksjonen sant hvis disse tre sider
er i stand til omfattende en trekant,

409
00:18:57,030 --> 00:19:01,950
og falsk ellers
Klar for å se hvordan du gjorde?

410
00:19:01,950 --> 00:19:04,650
Her er en implementering
av gyldig trekant.

411
00:19:04,650 --> 00:19:05,770
Det er ikke den eneste.

412
00:19:05,770 --> 00:19:07,770
Yours kan variere noe.

413
00:19:07,770 --> 00:19:11,040
Men dette gjør, faktisk, har
atferd som vi forventer.

414
00:19:11,040 --> 00:19:14,450
Vi erklærer vår funksjon på
Helt øverst, bool gyldig trekant

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

416
00:19:16,630 --> 00:19:18,930
Så igjen, denne funksjonen
tar tre reelle tall

417
00:19:18,930 --> 00:19:22,280
som sine argumenter, flytende
punkt verdi variabler,

418
00:19:22,280 --> 00:19:26,510
og utganger en sann eller usann
verdi, som er en boolsk, tilbakekalling.

419
00:19:26,510 --> 00:19:28,660
Så det er derfor returtypen er bool.

420
00:19:28,660 --> 00:19:30,016
Deretter definerer vi funksjonen.

421
00:19:30,016 --> 00:19:33,140
Første vi gjør er å sjekke for å være sikker
at alle sidene er positive.

422
00:19:33,140 --> 00:19:37,010
Dersom x er mindre enn eller lik
til 0, eller når y er lik 0,

423
00:19:37,010 --> 00:19:41,050
eller hvis z er mindre enn eller lik 0,
som ikke kan muligens være en trekant.

424
00:19:41,050 --> 00:19:42,380
De har ikke positive sider.

425
00:19:42,380 --> 00:19:45,790
Og så kan vi gå tilbake
false i den situasjonen.

426
00:19:45,790 --> 00:19:49,010
Neste, vi må du kontrollere
at hvert par av innganger

427
00:19:49,010 --> 00:19:51,830
er større enn den tredje.

428
00:19:51,830 --> 00:19:54,530
>> Så hvis x pluss y er mindre
enn eller lik z,

429
00:19:54,530 --> 00:19:57,060
eller hvis x pluss z er mindre
enn eller lik y,

430
00:19:57,060 --> 00:20:01,730
eller hvis y pluss z er mindre enn eller lik
x, som også kan være en gyldig trekant.

431
00:20:01,730 --> 00:20:03,800
Så vi return false igjen.

432
00:20:03,800 --> 00:20:06,900
Antar vi passert både av kontrollene
skjønt, så vi kan returnere true.

433
00:20:06,900 --> 00:20:09,440
Fordi disse tre sider
er i stand til returning--

434
00:20:09,440 --> 00:20:11,647
for å skape en gyldig trekant.

435
00:20:11,647 --> 00:20:12,230
Og det er det.

436
00:20:12,230 --> 00:20:13,830
Du har nå erklært og definert.

437
00:20:13,830 --> 00:20:17,330
Og du kan være i stand til å nå
bruke og kaller denne funksjonen.

438
00:20:17,330 --> 00:20:19,470
God jobb.

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

440
00:20:20,650 --> 00:20:22,820
Dette er CS50.

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