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

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

3
00:00:05,580 --> 00:00:08,877
Så lad os nu tackle en
virkelig stort emne, funktioner.

4
00:00:08,877 --> 00:00:11,460
Indtil videre i løbet, hele
programmer, som vi har skrevet

5
00:00:11,460 --> 00:00:12,969
Der er skrevet inde i main.

6
00:00:12,969 --> 00:00:14,260
De er temmelig simple programmer.

7
00:00:14,260 --> 00:00:16,940
Du behøver ikke at have alle disse
filialer og ting foregår.

8
00:00:16,940 --> 00:00:18,773
Vi kan bare passe det hele
indersiden af ​​primære og det

9
00:00:18,773 --> 00:00:20,407
ikke får forfærdelig overvældende.

10
00:00:20,407 --> 00:00:22,990
Men da forløbet går på og
når du begynder at udvikle programmer

11
00:00:22,990 --> 00:00:26,260
uafhængigt af hinanden, er de sandsynligvis vil
at begynde at få en masse mere end 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å hundredvis eller tusindvis
eller titusinder af linjer kode.

14
00:00:31,400 --> 00:00:34,690
Og det er virkelig ikke
den skøre en tanke.

15
00:00:34,690 --> 00:00:39,720
Som sådan, er det nok ikke en god idé
at holde alt inde i main.

16
00:00:39,720 --> 00:00:43,240
Det kan få en smule vanskeligt at finde
hvad du leder efter, hvis du gør det.

17
00:00:43,240 --> 00:00:47,040
>> Heldigvis, selvom C og temmelig meget
hver anden programmeringssprog,

18
00:00:47,040 --> 00:00:50,386
kunne arbejde med, giver
os om at skrive funktioner.

19
00:00:50,386 --> 00:00:52,260
Og jeg er bare at gå til
tage en hurtig side her

20
00:00:52,260 --> 00:00:54,971
at nævne, at funktioner er
et område af datalogi.

21
00:00:54,971 --> 00:00:57,970
Og du vil se mange flere af dem på
forskellige punkter i hele forløbet

22
00:00:57,970 --> 00:00:59,290
og hvis du fortsætter på.

23
00:00:59,290 --> 00:01:02,280
Hvor der er en masse
synonymer for det samme ord.

24
00:01:02,280 --> 00:01:03,390
Så vi kalder funktionerne.

25
00:01:03,390 --> 00:01:05,980
Men du kan også høre dem
benævnt procedurer,

26
00:01:05,980 --> 00:01:09,570
eller metoder, især, hvis du har nogensinde
gjort nogen objektorienteret programmering

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

28
00:01:11,950 --> 00:01:14,280
en stor deal-- men
revision orienterede sprog

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

30
00:01:16,129 --> 00:01:17,670
Sommetider de kaldes underrutiner.

31
00:01:17,670 --> 00:01:20,690
Men de virkelig refererer alle
til den samme grundlæggende idé.

32
00:01:20,690 --> 00:01:22,480
>> Lad os se, hvad denne idé er.

33
00:01:22,480 --> 00:01:23,310
Hvad er en funktion?

34
00:01:23,310 --> 00:01:26,470
Nå en funktion er virkelig
intet mere end en sort boks.

35
00:01:26,470 --> 00:01:31,430
En sort boks, der har et sæt på nul
eller flere indgange og en enkelt udgang.

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

37
00:01:33,420 --> 00:01:35,510
Dette er en funktion kaldet funk.

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

39
00:01:39,330 --> 00:01:42,580
Og indeni, sorte boks, vi
ved ikke præcis, hvad den gør,

40
00:01:42,580 --> 00:01:45,100
men den behandler de input
på en eller anden måde, og så er det

41
00:01:45,100 --> 00:01:48,680
giver et enkelt output, i dette tilfælde, z.

42
00:01:48,680 --> 00:01:50,504
Nu for at gøre det lidt
mindre abstrakt, vi

43
00:01:50,504 --> 00:01:52,420
kunne sige, at vi måske
har en funktion kaldet

44
00:01:52,420 --> 00:01:58,750
tilføje, at tager tre indgange a, b, og
c og behandler outputtet på nogen måde

45
00:01:58,750 --> 00:02:01,010
inde den sorte boks til
producere et enkelt output.

46
00:02:01,010 --> 00:02:05,190
Så i dette tilfælde, hvis
tilføj tager 3, 6 og 7.

47
00:02:05,190 --> 00:02:07,020
Et eller andet sted inde i
tilføje funktionen, vi ville

48
00:02:07,020 --> 00:02:09,750
forventer, at lægges sammen
at producere output, som

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

50
00:02:13,220 --> 00:02:17,940
>> På samme måde har du en funktion kaldet
mult der tager to indgange, a og b,

51
00:02:17,940 --> 00:02:21,070
behandler dem på en eller anden måde, således
at produktionen af ​​funktionen

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

53
00:02:22,920 --> 00:02:25,080
De to indgange ganget sammen.

54
00:02:25,080 --> 00:02:29,150
4 og 5 bliver passeret ind mult,
sker noget, output vi forventer

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

56
00:02:31,090 --> 00:02:32,507
Hvorfor skal vi kalde det en sort boks?

57
00:02:32,507 --> 00:02:34,840
Tja, hvis vi ikke skrive
fungerer os selv, som

58
00:02:34,840 --> 00:02:36,869
vi har gjort en hel del hidtil CS50.

59
00:02:36,869 --> 00:02:39,910
Vi har set print f, for eksempel, som
er en funktion, som vi ikke skriver

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

61
00:02:42,305 --> 00:02:44,180
Hvis vi ikke skriver
de funktioner, os selv,

62
00:02:44,180 --> 00:02:48,450
vi ikke virkelig har brug for at vide, hvordan det er
faktisk iværksat under kølerhjelmen.

63
00:02:48,450 --> 00:02:51,710
>> Så for eksempel den sorte boks I
bare viste dig for multiplikation,

64
00:02:51,710 --> 00:02:53,740
mult a, kunne b være
defined-- og det er bare

65
00:02:53,740 --> 00:02:57,902
nogle pseudocode-- kunne være
defineret som output gange b.

66
00:02:57,902 --> 00:02:58,860
Det mening, højre.

67
00:02:58,860 --> 00:03:01,370
Hvis vi har en funktion kaldet
mult der tager to indgange.

68
00:03:01,370 --> 00:03:04,750
Vi forventer, at produktionen ville
være de to indgange multipliceret sammen,

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

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

71
00:03:09,170 --> 00:03:13,150
vi har en tæller variabel til
få sat inde i mult til 0.

72
00:03:13,150 --> 00:03:18,000
Og så skal vi gentage denne proces
b gange føje en til tæller.

73
00:03:18,000 --> 00:03:24,270
For eksempel, hvis vi ganger 3a af
5b, vi kunne sige sat imod 0,

74
00:03:24,270 --> 00:03:27,700
gentag fem gange, tilsættes 3 til tælleren.

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

76
00:03:34,490 --> 00:03:37,500
Det er det samme resultat. Vi
stadig få 3 gange 5 bare

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

78
00:03:39,500 --> 00:03:41,490
>> Det er, hvad vi mener
når vi siger en sort boks.

79
00:03:41,490 --> 00:03:44,406
Det betyder blot, at vi ikke rigtig pleje
hvordan det er implementeret under kølerhjelmen

80
00:03:44,406 --> 00:03:46,170
så længe produktionen er, hvad vi forventer.

81
00:03:46,170 --> 00:03:49,045
Faktisk, det er en del af kontrakten
for at anvende funktioner, især

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

83
00:03:50,630 --> 00:03:53,980
Adfærden er altid vil
at være typiske, uforudsigelige

84
00:03:53,980 --> 00:03:55,420
baseret på funktionens navn.

85
00:03:55,420 --> 00:03:57,500
Og det er derfor, det er virkelig
vigtigt, når man skriver funktioner

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

87
00:04:00,020 --> 00:04:03,590
at disse funktioner har
klare, relativt indlysende navne,

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

89
00:04:04,990 --> 00:04:08,560
Hvilket er helt sikkert tilfældet
for funktion som print f.

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

91
00:04:09,860 --> 00:04:14,220
Nå som jeg sagde tidligere, hvis vi skriver
alle vores kode inde af de vigtigste ting

92
00:04:14,220 --> 00:04:17,120
kan få virkelig besværligt
og virkelig kompliceret.

93
00:04:17,120 --> 00:04:19,980
Funktioner tillader os evnen
at organisere ting og bryde op

94
00:04:19,980 --> 00:04:24,540
et meget kompliceret problem ind
meget mere håndterbare sub dele.

95
00:04:24,540 --> 00:04:28,130
Funktioner også tillade os at
forenkle kodningsprocessen.

96
00:04:28,130 --> 00:04:33,080
Det er meget nemmere at fejlsøge en 10
linjefunktion versus en 100 linie

97
00:04:33,080 --> 00:04:35,890
funktion eller en 1.000 linje funktion.

98
00:04:35,890 --> 00:04:38,400
Hvis vi kun har til debug
små stykker ad gangen,

99
00:04:38,400 --> 00:04:42,110
eller skrive små stykker på det tidspunkt,
det gør, at programmeringserfaring

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

101
00:04:43,070 --> 00:04:44,910
Tro mig på at en.

102
00:04:44,910 --> 00:04:48,400
>> Endelig, hvis vi skriver funktioner vi
kan genbruge disse forskellige dele.

103
00:04:48,400 --> 00:04:49,880
Funktioner kan genbruges.

104
00:04:49,880 --> 00:04:51,880
De kan anvendes i
et eller andet program.

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

106
00:04:53,713 --> 00:04:56,530
skal gøre er fortælle, at programmet
hvor man kan finde denne funktion.

107
00:04:56,530 --> 00:04:59,680
Vi har genbrug og hjælp
udskrive f i over 40 år.

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

109
00:05:02,150 --> 00:05:04,270
Temmelig anvendelige, højre.

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

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

112
00:05:06,040 --> 00:05:06,860
Vi ved, at.

113
00:05:06,860 --> 00:05:08,700
Lad os nu begynde at skrive dem.

114
00:05:08,700 --> 00:05:10,830
Lad os begynde at få
dem ind i vores programmer.

115
00:05:10,830 --> 00:05:13,869
For at gøre det, den første
ting, vi gør, er at erklære funktionen.

116
00:05:13,869 --> 00:05:16,160
Når du erklærer en funktion
hvad du dybest set gør

117
00:05:16,160 --> 00:05:18,900
fortæller compileren,
hey, bare så du ved,

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

119
00:05:20,850 --> 00:05:22,987
og her er hvad det kommer til at se ud.

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

121
00:05:24,820 --> 00:05:27,900
gøre nogle underlige ting, hvis
de ser et sæt af symboler

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

123
00:05:29,560 --> 00:05:33,000
Så vi bare give den compiler en
heads up, jeg skaber en funktion

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

125
00:05:35,492 --> 00:05:38,450
Funktion erklæringer generelt hvis
du organisere din kode på en måde,

126
00:05:38,450 --> 00:05:41,872
at andre vil kunne
forstå og gøre brug af,

127
00:05:41,872 --> 00:05:44,330
du generelt ønsker at sætte alle
af din funktion erklæringer

128
00:05:44,330 --> 00:05:48,220
på selve toppen af ​​din kode, højre
før du begynder at skrive vigtigste selv.

129
00:05:48,220 --> 00:05:50,770
Og bekvemt, der er
en meget standardformular

130
00:05:50,770 --> 00:05:53,500
at enhver funktion Erklæringen følger.

131
00:05:53,500 --> 00:05:56,090
De alle temmelig meget se sådan ud.

132
00:05:56,090 --> 00:06:01,440
Der er tre dele til en funktion
erklæring, returtype, navn,

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

134
00:06:03,420 --> 00:06:07,180
>> Nu afkastet type er, hvad slags
variabel funktionen udsendes.

135
00:06:07,180 --> 00:06:10,710
Så for eksempel, hvis vi tænker tilbage
minut siden til at gange to

136
00:06:10,710 --> 00:06:15,690
tal-funktion, hvad forventer vi, hvis
vi ganger et helt tal med et tal,

137
00:06:15,690 --> 00:06:18,502
output vil være
sandsynligvis et heltal, højre.

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

139
00:06:20,710 --> 00:06:24,167
Så returtypen af ​​denne
funktion ville være int.

140
00:06:24,167 --> 00:06:26,000
Navn er, hvad du vil
at ringe til din funktion.

141
00:06:26,000 --> 00:06:29,330
Dette er sandsynligvis den mindst vigtige
del af funktionserklæringen,

142
00:06:29,330 --> 00:06:30,827
med hensyn til funktionalitet.

143
00:06:30,827 --> 00:06:33,160
Men er faktisk nok en
af de vigtigste dele

144
00:06:33,160 --> 00:06:36,243
af funktionen erklæring i form
at vide, hvad den funktion faktisk

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

146
00:06:37,120 --> 00:06:40,474
Hvis du navngiver din funktion f eller g eller
h eller mystik eller noget lignende,

147
00:06:40,474 --> 00:06:42,765
du sandsynligvis vil få
lidt udløst at forsøge

148
00:06:42,765 --> 00:06:44,650
at huske, hvad disse funktioner gør.

149
00:06:44,650 --> 00:06:47,880
Så det er vigtigt at give din
funktionens meningsfulde navne.

150
00:06:47,880 --> 00:06:51,030
>> Endelig argumentliste er
den kommasepareret liste

151
00:06:51,030 --> 00:06:55,260
af alle input til din funktion,
der hver især har en type og et navn.

152
00:06:55,260 --> 00:06:57,840
Så ikke nok med at du er nødt til at
angive, hvilken type variabel

153
00:06:57,840 --> 00:07:00,760
Funktionen output,
du også ønsker at specificere

154
00:07:00,760 --> 00:07:07,694
hvilken type og typer af variabler de
Funktionen vil acceptere som input.

155
00:07:07,694 --> 00:07:08,860
Så lad os gøre et eksempel her.

156
00:07:08,860 --> 00:07:10,220
Lad os bare tage et kig
ved en mere konkret en.

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

158
00:07:13,130 --> 00:07:14,925
ville tilføje to heltal sammen.

159
00:07:14,925 --> 00:07:17,800
Summen af ​​to tal vil
være et heltal samt, som vi lige

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

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

162
00:07:21,610 --> 00:07:25,190
Der bare fortæller os, at tilføje to ints
vil, ved slutningen af ​​dagen,

163
00:07:25,190 --> 00:07:28,799
output eller spytte den tilbage
ud til os, et heltal.

164
00:07:28,799 --> 00:07:31,590
I betragtning af, hvad denne funktion gør vi
ønsker at give det et meningsfuldt navn.

165
00:07:31,590 --> 00:07:33,630
Tilføj to ints synes
hensigtsmæssigt i betragtning

166
00:07:33,630 --> 00:07:37,574
vi tager to heltal som input
og forhåbentlig tilføje dem sammen.

167
00:07:37,574 --> 00:07:40,240
Det kan være lidt af en besværlig
navn og helt ærligt denne funktion

168
00:07:40,240 --> 00:07:42,430
er sandsynligvis ikke nødvendig
da vi har tilføjelsen

169
00:07:42,430 --> 00:07:46,310
operatør, hvis du husker fra vores
diskussion af operatører, der tidligere.

170
00:07:46,310 --> 00:07:49,650
Men lad os bare sige til skyld
argument om, at denne funktion er nyttig

171
00:07:49,650 --> 00:07:52,860
og så vi vil kalde det tilføje to ints.

172
00:07:52,860 --> 00:07:55,230
Endelig denne funktion tager to indgange.

173
00:07:55,230 --> 00:07:56,960
Som hver især er et helt tal.

174
00:07:56,960 --> 00:07:59,900
Så vi har denne komma
adskilt liste af input.

175
00:07:59,900 --> 00:08:02,830
Nu vi generelt ønsker at
give et navn til hver af dem

176
00:08:02,830 --> 00:08:05,070
således at de kan anvendes
i funktionen.

177
00:08:05,070 --> 00:08:07,180
Navnene er ikke frygtelig vigtig.

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

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

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

181
00:08:14,257 --> 00:08:16,090
Hvis du imidlertid finde
dig selv i en situation,

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

183
00:08:19,497 --> 00:08:21,830
du måske ønsker at kalde dem
noget andet end a og b

184
00:08:21,830 --> 00:08:24,701
at give dem noget mere
symbolsk meningsfuldt.

185
00:08:24,701 --> 00:08:27,700
Men i dette tilfælde, har vi ikke rigtig
vide noget andet om funktion.

186
00:08:27,700 --> 00:08:29,320
Vi vil blot tilføje to heltal.

187
00:08:29,320 --> 00:08:32,429
Så vi vil bare kalde
disse tal a og b.

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

189
00:08:33,990 --> 00:08:36,287
>> Hvorfor tager du ikke tage en anden
at tænke på denne ene,

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

191
00:08:38,870 --> 00:08:42,940
ganger to floating point tal?

192
00:08:42,940 --> 00:08:45,910
Kan du huske, hvad en
decimaltal er?

193
00:08:45,910 --> 00:08:48,120
Hvad ville denne funktion
erklæring ud?

194
00:08:48,120 --> 00:08:53,330
Jeg faktisk anbefale dig at holde pause videoen
her og tage, hvor meget tid du har brug for.

195
00:08:53,330 --> 00:08:55,521
Tænk over, hvad dette
funktion erklæring ville være?

196
00:08:55,521 --> 00:08:56,770
Hvad ville afkastet typen være?

197
00:08:56,770 --> 00:08:58,103
Hvad ville en meningsfyldt navn være?

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

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

200
00:09:03,190 --> 00:09:07,640
for en funktion, der ville formere
to flydende komma tal sammen.

201
00:09:07,640 --> 00:09:09,330
Forhåbentlig du standsede videoen.

202
00:09:09,330 --> 00:09:12,950
>> Så lad os tage et kig på et eksempel
af en mulig erklæring.

203
00:09:12,950 --> 00:09:17,340
Float mult to reals flyde x, float y.

204
00:09:17,340 --> 00:09:19,090
Produktet af to
flydende tal,

205
00:09:19,090 --> 00:09:21,710
som husker er, hvordan vi
repræsentere reelle tal

206
00:09:21,710 --> 00:09:26,770
eller tal med decimalværdier i C,
vil være et decimaltal.

207
00:09:26,770 --> 00:09:28,570
Når du ganger en
decimal af en decimal,

208
00:09:28,570 --> 00:09:30,460
du sandsynligvis vil få en decimal.

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

210
00:09:31,960 --> 00:09:33,810
Formere to reals virker fint.

211
00:09:33,810 --> 00:09:36,620
Men du virkelig kunne kalde det
mult to flydere eller mult flåd.

212
00:09:36,620 --> 00:09:39,540
Noget lignende, så længe det
gav nogle egentlige betydning til hvad

213
00:09:39,540 --> 00:09:41,469
denne sorte boks ville gøre.

214
00:09:41,469 --> 00:09:44,260
Og igen, i dette tilfælde, har vi ikke
synes at have nogen betydning knyttet

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

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

217
00:09:48,645 --> 00:09:51,020
Nu, hvis du kalder dem noget
andet, det er helt fint.

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

219
00:09:53,310 --> 00:09:55,450
hjælp doubler i stedet
af flåd, hvis du husker

220
00:09:55,450 --> 00:09:59,100
at double er en anden
måde at mere præcist

221
00:09:59,100 --> 00:10:02,330
specificere reelle tal eller
floating point variabler.

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

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

224
00:10:04,670 --> 00:10:06,711
I virkeligheden er der flere
forskellige kombinationer

225
00:10:06,711 --> 00:10:08,410
måder at erklære denne funktion.

226
00:10:08,410 --> 00:10:10,884
Men det er to temmelig gode.

227
00:10:10,884 --> 00:10:12,550
Vi har erklæret en funktion, det er fantastisk.

228
00:10:12,550 --> 00:10:15,700
Vi har fortalt compiler, hvad det
er, hvad vi skal gøre.

229
00:10:15,700 --> 00:10:17,630
Lad os nu rent faktisk at skrive denne funktion.

230
00:10:17,630 --> 00:10:20,750
Lad os give det en definition,
så inde den sorte boks

231
00:10:20,750 --> 00:10:22,840
forudsigelig adfærd, der sker.

232
00:10:22,840 --> 00:10:26,270
Faktisk er vi multiplicere to real
tal sammen, eller tilføje numre

233
00:10:26,270 --> 00:10:29,760
sammen, eller gør, hvad det er
at vi spurgte vores funktion at gøre.

234
00:10:29,760 --> 00:10:32,780
>> Så i virkeligheden, lad os prøve og definere
formere to reals, som vi netop

235
00:10:32,780 --> 00:10:35,350
talte om en anden siden.

236
00:10:35,350 --> 00:10:38,560
Nu begyndelsen af
en funktion definition

237
00:10:38,560 --> 00:10:41,720
ser næsten nøjagtigt det samme
som en funktion erklæring.

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

239
00:10:43,170 --> 00:10:47,770
Øverst er den funktion erklæring,
type, navn, kommasepareret argument

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

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

242
00:10:53,800 --> 00:10:57,060
Begyndelsen af ​​funktionen
definition ser næsten præcis

243
00:10:57,060 --> 00:11:03,790
den samme, type, navn, kommasepareret
argument liste, ingen semikolon,

244
00:11:03,790 --> 00:11:05,206
åbne krøllede klammeparentes.

245
00:11:05,206 --> 00:11:07,580
Den åbne krøllede bandage, ligesom
vi har gjort med de vigtigste,

246
00:11:07,580 --> 00:11:09,540
betyder, at vi nu er
begynder at definere

247
00:11:09,540 --> 00:11:14,567
hvad der sker inde i sorte boks, der
vi har besluttet at kalde mult to reals.

248
00:11:14,567 --> 00:11:15,900
Her er en måde at gennemføre den.

249
00:11:15,900 --> 00:11:20,370
Vi kunne sige, at vi kunne erklære en ny
variabel af typen float kaldet produkt

250
00:11:20,370 --> 00:11:24,020
og tildele den pågældende variabel
til værdien x gange y.

251
00:11:24,020 --> 00:11:27,306
Og derefter vende tilbage produkt.

252
00:11:27,306 --> 00:11:28,430
Hvad betyder tilbagevenden mener her.

253
00:11:28,430 --> 00:11:31,090
Nå afkast er den måde
vi angiver, er, hvordan

254
00:11:31,090 --> 00:11:33,400
vi passerer output bakke ud.

255
00:11:33,400 --> 00:11:38,160
Så returnere noget, er den samme som,
dette er outputtet af den sorte boks.

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

257
00:11:40,732 --> 00:11:42,190
Her er en anden måde at gennemføre den.

258
00:11:42,190 --> 00:11:45,050
Vi kunne bare vende tilbage x gange y.

259
00:11:45,050 --> 00:11:45,870
x er en svømmer.

260
00:11:45,870 --> 00:11:46,660
y er en svømmer.

261
00:11:46,660 --> 00:11:48,490
Så x gange y er også en flyder.

262
00:11:48,490 --> 00:11:50,750
Vi behøver ikke engang at
oprette en anden variabel.

263
00:11:50,750 --> 00:11:56,750
Så det er en anderledes måde at
gennemføre nøjagtig samme sorte boks.

264
00:11:56,750 --> 00:11:58,570
>> Nu tage et øjeblik,
pause videoen igen,

265
00:11:58,570 --> 00:12:01,680
og prøv og definere tilføje to ints,
som er den anden funktion, som vi

266
00:12:01,680 --> 00:12:03,090
talte om for et øjeblik siden.

267
00:12:03,090 --> 00:12:06,440
Igen her, jeg har lagt den funktion
erklæring, og så semikolon,

268
00:12:06,440 --> 00:12:08,420
og en åben krøllet tandbøjle
og en lukket krøllet

269
00:12:08,420 --> 00:12:12,080
tandbøjle til at angive, hvor vi vil fylde
i indholdet af tilføje to ints,

270
00:12:12,080 --> 00:12:15,530
så vi definerer de særlige
adfærd inde i sorte boks.

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

272
00:12:16,380 --> 00:12:18,790
Og tage så meget tid som
du nødt til at forsøge at definere

273
00:12:18,790 --> 00:12:25,040
en implementering af add to ints, såsom
at når funktionen afgiver en værdi,

274
00:12:25,040 --> 00:12:29,209
det gør i virkeligheden, afkast
Summen af ​​de to indgange.

275
00:12:29,209 --> 00:12:32,000
Så ligesom det foregående eksempel,
Der er flere forskellige måder

276
00:12:32,000 --> 00:12:34,210
at man kunne implementere tilføje to ints.

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

278
00:12:35,130 --> 00:12:37,172
Herinde i orange har jeg
lige haft nogle comments--

279
00:12:37,172 --> 00:12:38,880
Jeg har lige tilføjet nogle
kommentarer for at indikere

280
00:12:38,880 --> 00:12:41,400
hvad der sker på hver linje kode.

281
00:12:41,400 --> 00:12:45,430
Så jeg erklærer en variabel
kaldes summen af ​​typen int.

282
00:12:45,430 --> 00:12:47,279
Jeg siger sum lig et plus b.

283
00:12:47,279 --> 00:12:50,070
Det er, hvor vi rent faktisk gør
arbejdet tilføje A og B tilsammen.

284
00:12:50,070 --> 00:12:51,850
Og jeg vender tilbage sum.

285
00:12:51,850 --> 00:12:56,460
Og det giver mening, fordi
sum er en variabel af typen int.

286
00:12:56,460 --> 00:13:00,180
Og hvad er de data, skriver, at dette
Funktionen fortæller mig det kommer til at output?

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

288
00:13:00,680 --> 00:13:03,072
Så jeg vender tilbage sum, som
er en heltalsvariabel.

289
00:13:03,072 --> 00:13:06,030
Og det giver mening givet, hvad vi har
erklæret og defineret vores funktion

290
00:13:06,030 --> 00:13:07,320
at gøre.

291
00:13:07,320 --> 00:13:09,700
>> Nu kan du også definere
funktionen denne måde,

292
00:13:09,700 --> 00:13:15,260
int sum lig et plus B-- springe, at
først step-- og derefter returnere summen.

293
00:13:15,260 --> 00:13:17,760
Nu kunne du også have
implementeret det på denne måde,

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

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

296
00:13:22,540 --> 00:13:24,420
men det gør faktisk arbejde.

297
00:13:24,420 --> 00:13:30,199
Hvis du tager denne kode, som er int
tilføje dårlig adder dot c, og bruge det.

298
00:13:30,199 --> 00:13:31,990
Det faktisk gør tilføje
to heltal sammen.

299
00:13:31,990 --> 00:13:37,632
Det er en meget dårlig gennemførelse
af denne særlige adfærd.

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

301
00:13:38,340 --> 00:13:41,200
Det er bare her for at illustrere
det punkt, at vi ikke rigtig

302
00:13:41,200 --> 00:13:44,530
ligeglad med, hvad der sker inde
den sorte boks, så længe

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

304
00:13:46,510 --> 00:13:48,870
Dette er en dårligt konstrueret sort boks.

305
00:13:48,870 --> 00:13:53,801
Men i slutningen af ​​dagen, det gør
stadig output summen af ​​et plus b.

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

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

308
00:13:56,320 --> 00:13:57,490
Og vi har defineret funktion.

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

310
00:13:58,540 --> 00:14:03,020
Lad os nu begynde at bruge funktionerne
at vi har erklæret, og vi har defineret.

311
00:14:03,020 --> 00:14:05,960
At kalde en function-- er det faktisk
temmelig easy-- alt du behøver at gøre

312
00:14:05,960 --> 00:14:09,070
er passere det passende argumenter,
argumenter for datatypen

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

314
00:14:11,600 --> 00:14:15,190
Værdien af ​​denne funktion
og her-- undskyldning mig--

315
00:14:15,190 --> 00:14:19,390
tildele returværdien af ​​denne funktion
til noget af den korrekte type.

316
00:14:19,390 --> 00:14:22,410
>> Så lad os få et kig på
det i praksis i en fil

317
00:14:22,410 --> 00:14:27,730
kaldet adder 1 dot C, som
Jeg har i min CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Så her er adder 1 dot c.

319
00:14:31,042 --> 00:14:33,500
I begyndelsen ser du, jeg har
min indbefatter pund omfatter,

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 funktion erklæring.

322
00:14:37,700 --> 00:14:39,570
Det er her, jeg er
fortæller compileren jeg

323
00:14:39,570 --> 00:14:42,850
vil være at skrive en
funktion kaldet tilføje to ints.

324
00:14:42,850 --> 00:14:45,780
Det kommer til at afgive et
heltalstype variabel.

325
00:14:45,780 --> 00:14:47,360
Det er, hvad denne del er lige her.

326
00:14:47,360 --> 00:14:51,950
Og så har jeg to indgange til det en
og b, som hver især er et helt tal.

327
00:14:51,950 --> 00:14:58,250
Inde i main, spørger jeg brugeren om
input ved at sige, giv mig et heltal.

328
00:14:58,250 --> 00:15:01,040
Og de bliver bedt om at glemme
int, som er en funktion, der

329
00:15:01,040 --> 00:15:03,240
er inkluderet i CS50 biblioteket.

330
00:15:03,240 --> 00:15:07,660
Og der bliver lagret i
X, en heltalsvariabel.

331
00:15:07,660 --> 00:15:09,886
>> Så vi beder dem til en anden heltal.

332
00:15:09,886 --> 00:15:13,070
Vi får en anden heltal
og gemme det i y.

333
00:15:13,070 --> 00:15:17,990
Og så, her på linje 28, er
hvor vi gør vores funktion opkald.

334
00:15:17,990 --> 00:15:23,770
Vi siger, int z ligemænd
tilføje 2 ints x komma y.

335
00:15:23,770 --> 00:15:25,980
Kan du se, hvorfor det giver mening?

336
00:15:25,980 --> 00:15:29,710
x er et heltal variabel af og
y er et heltal typen variabel.

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

338
00:15:31,220 --> 00:15:34,570
Det mening med, hvad vores funktion
erklæring on line 17 ser ud.

339
00:15:34,570 --> 00:15:38,300
Den kommasepareret input liste
forventer to heltal, a og b.

340
00:15:38,300 --> 00:15:40,300
I dette tilfælde kan vi kalder
dem, hvad vi ønsker.

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

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

343
00:15:44,930 --> 00:15:45,640
Der virker.

344
00:15:45,640 --> 00:15:48,680
>> Og vi ved, at funktionen går
til udsendelse af et heltal så godt.

345
00:15:48,680 --> 00:15:51,290
Og så er vi opbevare
output af funktionen,

346
00:15:51,290 --> 00:15:56,050
tilføje to ints, i en heltalstype
variabel, som vi kalder z.

347
00:15:56,050 --> 00:16:01,980
Og så kan vi sige, at summen af
procent i og procent i er procent i.

348
00:16:01,980 --> 00:16:06,210
x, y og z henholdsvis
udfylde dem procent vigtigst.

349
00:16:06,210 --> 00:16:08,334
Hvad er definitionen af
tilføje to ints se ud?

350
00:16:08,334 --> 00:16:09,125
Det er ret simpelt.

351
00:16:09,125 --> 00:16:11,270
Det er en af ​​dem, vi
lige set en anden siden,

352
00:16:11,270 --> 00:16:14,390
int sum lig et plus b afkast sum.

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

354
00:16:15,420 --> 00:16:17,270
Lad os gemme filen.

355
00:16:17,270 --> 00:16:22,080
Og derefter ned her på min terminal
Jeg har tænkt mig at gøre adder 1,

356
00:16:22,080 --> 00:16:23,000
og jeg rydde min skærm.

357
00:16:23,000 --> 00:16:25,791
Jeg har tænkt mig at zoome ind, fordi jeg ved
det er lidt svært at se.

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

359
00:16:31,520 --> 00:16:33,770
>> Så vi kompilere dette program som adder 1.

360
00:16:33,770 --> 00:16:37,910
Så vi kan gøre dot skråstreg adder 1.

361
00:16:37,910 --> 00:16:40,060
Giv mig et heltal, 10.

362
00:16:40,060 --> 00:16:42,380
Giv mig en anden heltal, 20.

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

364
00:16:45,200 --> 00:16:47,615
Så vi lavede en vellykket funktionskald.

365
00:16:47,615 --> 00:16:55,820
Du kan køre funktionen igen, negativ
10, 17 Summen af ​​negativ 10 og 17 er 7.

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

367
00:16:57,120 --> 00:16:59,240
Det har adfærd
at vi forventer, at det.

368
00:16:59,240 --> 00:17:03,610
Og så har vi lavet en vellykket
funktion, definition, erklæring,

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

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

371
00:17:09,079 --> 00:17:10,611
før vi konkludere dette afsnit.

372
00:17:10,611 --> 00:17:12,319
Husker fra vores
diskussion af datatyper,

373
00:17:12,319 --> 00:17:16,109
tidligere, at funktioner
kan nogle gange tage nogen indgange.

374
00:17:16,109 --> 00:17:17,930
Hvis det er tilfældet, vi
erklære funktionen

375
00:17:17,930 --> 00:17:19,788
som havende en liste void argument.

376
00:17:19,788 --> 00:17:21,579
Kan du huske, hvad den
mest almindelige funktion

377
00:17:21,579 --> 00:17:25,036
vi har set hidtil, der tager
et tomrum argument liste er?

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

379
00:17:27,300 --> 00:17:30,850
Husk også, at funktionen nogle gange
faktisk ikke har en udgang.

380
00:17:30,850 --> 00:17:34,210
I så fald erklærer vi funktionen
som havende en void returtype.

381
00:17:34,210 --> 00:17:37,880
Lad os slutte dette afsnit af
tackle en praksis problem.

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

383
00:17:39,900 --> 00:17:43,630
Jeg vil have dig til at skrive en funktion
kaldes gyldige trekant.

384
00:17:43,630 --> 00:17:47,410
Hvad denne funktion bør gøre
er at tage tre reelle tal

385
00:17:47,410 --> 00:17:51,930
som repræsenterer længderne af de tre
sider af en trekant, som dens parametre,

386
00:17:51,930 --> 00:17:54,550
eller sine argumenter, eller dens
inputs-- andet sæt synonymer

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

388
00:17:57,340 --> 00:18:01,120
Denne funktion bør
enten udgang sandt eller falsk

389
00:18:01,120 --> 00:18:04,960
afhængigt af, om disse tre længder
er i stand til at gøre en trekant.

390
00:18:04,960 --> 00:18:09,930
Kan du huske den datatype,
Vi bruges til at angive sande eller falske?

391
00:18:09,930 --> 00:18:11,436
Nu hvordan kan du gennemføre denne?

392
00:18:11,436 --> 00:18:13,810
Nå ved, der er et par
af reglerne om trekanter

393
00:18:13,810 --> 00:18:15,480
der er faktisk nyttigt at vide.

394
00:18:15,480 --> 00:18:18,292
En trekant kan kun have
sider med positiv længde.

395
00:18:18,292 --> 00:18:19,000
Det giver mening.

396
00:18:19,000 --> 00:18:21,432
Du er sikkert at sige, duh.

397
00:18:21,432 --> 00:18:23,390
Den anden ting at bemærke
er imidlertid, at summen

398
00:18:23,390 --> 00:18:25,484
af længderne af alle
to sider af trekanten

399
00:18:25,484 --> 00:18:27,650
skal være større end den
længden af ​​den tredje side.

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

401
00:18:28,690 --> 00:18:34,150
Du kan ikke have en trekant af siderne 1,
2 og 4, for eksempel, fordi 1 plus 2

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

403
00:18:36,270 --> 00:18:38,870
Så det er de regler, der
afgøre, om tre eller ikke

404
00:18:38,870 --> 00:18:42,740
indgange kan tænkes at danne en trekant.

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

406
00:18:46,360 --> 00:18:49,810
denne funktion kaldes gyldige
trekant, således at det faktisk

407
00:18:49,810 --> 00:18:51,650
har adfærden angivet her.

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

409
00:18:57,030 --> 00:19:01,950
og ellers false
Klar til at se, hvordan du gjorde?

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

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

412
00:19:05,770 --> 00:19:07,770
Med venlig kan variere en smule.

413
00:19:07,770 --> 00:19:11,040
Men dette gør, i virkeligheden har
den adfærd, vi forventer.

414
00:19:11,040 --> 00:19:14,450
Vi erklærer vores funktion på
helt i top, bool gyldigt trekant

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

416
00:19:16,630 --> 00:19:18,930
Så igen, denne funktion
tager tre reelle tal

417
00:19:18,930 --> 00:19:22,280
som sine argumenter, flydende
punkt værdi variabler,

418
00:19:22,280 --> 00:19:26,510
og udsender et sandt eller falsk
værdi, som er en boolesk, tilbagekaldelse.

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

420
00:19:28,660 --> 00:19:30,016
Så vi definere funktionen.

421
00:19:30,016 --> 00:19:33,140
Første ting vi gør, er tjekke for at sikre
at alle siderne er positive.

422
00:19:33,140 --> 00:19:37,010
Hvis x er mindre end eller lig
til 0, eller hvis y er lig med 0,

423
00:19:37,010 --> 00:19:41,050
eller hvis z er mindre end eller lig med 0,
der kan umuligt 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å vi kan vende tilbage
falsk i den situation.

426
00:19:45,790 --> 00:19:49,010
Næste vi kontrollere, at
at hvert par indgange

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

428
00:19:51,830 --> 00:19:54,530
>> Så hvis x plus y er mindre
end eller lig med z,

429
00:19:54,530 --> 00:19:57,060
eller hvis X plus Z er mindre
end eller lig med y,

430
00:19:57,060 --> 00:20:01,730
eller hvis y plus z er mindre end eller lig med
x, der også kan ikke være en gyldig trekant.

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

432
00:20:03,800 --> 00:20:06,900
Hvis man antager, vi passerede begge kontroller
selv, så kan vi vende tilbage sandt.

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 at skabe 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 nu erklæret og defineret.

437
00:20:13,830 --> 00:20:17,330
Og du kan være i stand til nu
bruge og kalder denne funktion.

438
00:20:17,330 --> 00:20:19,470
Godt arbejde.

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

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

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