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

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

3
00:00:05,580 --> 00:00:08,877
Så nu ska vi ta itu med en
riktigt stort ämne, funktioner.

4
00:00:08,877 --> 00:00:11,460
Hittills under, alla
program som vi har skrivit

5
00:00:11,460 --> 00:00:12,969
har skrivits inne i huvud.

6
00:00:12,969 --> 00:00:14,260
De är ganska enkla program.

7
00:00:14,260 --> 00:00:16,940
Du behöver inte ha alla dessa
grenar och saker som händer.

8
00:00:16,940 --> 00:00:18,773
Vi kan bara passa alla
insidan av huvud- och det

9
00:00:18,773 --> 00:00:20,407
får inte hemskt överväldigande.

10
00:00:20,407 --> 00:00:22,990
Men som kursen pågår och
när du börjar att utveckla program

11
00:00:22,990 --> 00:00:26,260
självständigt, är de förmodligen kommer
att börja få en mycket mer än 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å hundratals eller tusentals
eller tiotusentals rader kod.

14
00:00:31,400 --> 00:00:34,690
Och det är verkligen inte
den galna en tanke.

15
00:00:34,690 --> 00:00:39,720
Som sådan, är det förmodligen inte en bra idé
att hålla allt inne i huvud.

16
00:00:39,720 --> 00:00:43,240
Det kan bli lite svårt att hitta
vad du letar efter om du gör det.

17
00:00:43,240 --> 00:00:47,040
>> Lyckligtvis, även om C, och ganska mycket
varannan programmeringsspråk som

18
00:00:47,040 --> 00:00:50,386
kan arbeta med, gör
oss att skriva funktioner.

19
00:00:50,386 --> 00:00:52,260
Och jag ska bara
ta en snabb åt sidan här

20
00:00:52,260 --> 00:00:54,971
nämna att funktioner är
ett område i datavetenskap.

21
00:00:54,971 --> 00:00:57,970
Och du kommer att se många fler av dem på
olika punkter under kursens gång

22
00:00:57,970 --> 00:00:59,290
och om du fortsätter på.

23
00:00:59,290 --> 00:01:02,280
Där det finns en hel del
synonymer för samma ord.

24
00:01:02,280 --> 00:01:03,390
Så vi kallar funktioner.

25
00:01:03,390 --> 00:01:05,980
Men du kan också höra dem
kallade förfaranden,

26
00:01:05,980 --> 00:01:09,570
eller metoder, i synnerhet om du har någonsin
gjort någon objektorienterad programmering

27
00:01:09,570 --> 00:01:11,950
before-- och oroa dig inte
Om du inte har, inte

28
00:01:11,950 --> 00:01:14,280
en stor Deal-- men i
revision orienterade språk

29
00:01:14,280 --> 00:01:16,129
ofta kallas metoder.

30
00:01:16,129 --> 00:01:17,670
Ibland är kallade subrutiner.

31
00:01:17,670 --> 00:01:20,690
Men de verkligen refererar alla
till samma grundidé.

32
00:01:20,690 --> 00:01:22,480
>> Låt oss se vad den idén är.

33
00:01:22,480 --> 00:01:23,310
Vad är en funktion?

34
00:01:23,310 --> 00:01:26,470
Väl en funktion är verkligen
inget mer än en svart låda.

35
00:01:26,470 --> 00:01:31,430
En svart låda som har en uppsättning av noll
eller flera ingångar och en enda utgång.

36
00:01:31,430 --> 00:01:33,420
Så till exempel, detta
kan vara en funktion.

37
00:01:33,420 --> 00:01:35,510
Detta är en funktion som kallas funk.

38
00:01:35,510 --> 00:01:39,330
Och det krävs tre ingångar a, b och c.

39
00:01:39,330 --> 00:01:42,580
Och inuti den svarta lådan, vi
vet inte exakt vad det gör,

40
00:01:42,580 --> 00:01:45,100
men den behandlar ingångarna
på något sätt och då det

41
00:01:45,100 --> 00:01:48,680
ger en enda utgång, i detta fall, z.

42
00:01:48,680 --> 00:01:50,504
Nu för att göra det lite
mindre abstrakt, vi

43
00:01:50,504 --> 00:01:52,420
kan säga att vi kanske
ha en funktion som kallas

44
00:01:52,420 --> 00:01:58,750
lägg som tar tre ingångar a, b, och
c och bearbetar utsignalen på något sätt

45
00:01:58,750 --> 00:02:01,010
inuti den svarta lådan att
producera en enda utsignal.

46
00:02:01,010 --> 00:02:05,190
Så i detta fall, om
lägg tar 3, 6, och 7.

47
00:02:05,190 --> 00:02:07,020
Någonstans inuti
lägga funktion, vi skulle

48
00:02:07,020 --> 00:02:09,750
förvänta sig att läggas samman
för att framställa produkten, som

49
00:02:09,750 --> 00:02:13,220
är tre plus 6 plus 7 eller 16.

50
00:02:13,220 --> 00:02:17,940
>> På samma sätt har du en funktion som kallas
mult som tar två ingångar, a och b,

51
00:02:17,940 --> 00:02:21,070
bearbetar dem på något sätt en sådan
att utsignalen från funktionen

52
00:02:21,070 --> 00:02:22,920
är produkten av de två insignalerna.

53
00:02:22,920 --> 00:02:25,080
De två ingångarna multipliceras med varandra.

54
00:02:25,080 --> 00:02:29,150
4 och 5 får passera in i mult,
något händer, utgången vi förväntar oss

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

56
00:02:31,090 --> 00:02:32,507
Varför kallar vi det en svart låda?

57
00:02:32,507 --> 00:02:34,840
Tja, om vi inte skriver
fungerar själva, som

58
00:02:34,840 --> 00:02:36,869
Vi har gjort en hel del så långt CS50.

59
00:02:36,869 --> 00:02:39,910
Vi har sett utskrifts f, till exempel, som
är en funktion som vi inte skriva

60
00:02:39,910 --> 00:02:42,305
oss, men vi använder hela tiden.

61
00:02:42,305 --> 00:02:44,180
Om vi ​​inte skriver
funktionerna själva,

62
00:02:44,180 --> 00:02:48,450
vi egentligen inte behöver veta hur det är
faktiskt genomförs under huven.

63
00:02:48,450 --> 00:02:51,710
>> Så till exempel den svarta lådan I
bara visade dig för multiplikation,

64
00:02:51,710 --> 00:02:53,740
Multipla a, kan b vara
defined-- och detta är bara

65
00:02:53,740 --> 00:02:57,902
några pseudocode-- kunde vara
definieras som produktion gånger b.

66
00:02:57,902 --> 00:02:58,860
Det vettigt, eller hur.

67
00:02:58,860 --> 00:03:01,370
Om vi ​​har en funktion som kallas
mult som tar två ingångar.

68
00:03:01,370 --> 00:03:04,750
Vi förväntar oss att produktionen skulle
vara de två ingångarna multipliceras med varandra,

69
00:03:04,750 --> 00:03:06,240
a gånger b.

70
00:03:06,240 --> 00:03:09,170
Men mult kan också vara
genomförs så här,

71
00:03:09,170 --> 00:03:13,150
vi har en räknarvariabeln att
få ställa inuti mult till 0.

72
00:03:13,150 --> 00:03:18,000
Och då är vi upprepa denna process
b gånger lägga till en till disk.

73
00:03:18,000 --> 00:03:24,270
Till exempel, om vi multiplicerar 3a genom
5b, vi kunde säga satt mot 0,

74
00:03:24,270 --> 00:03:27,700
upprepa fem gånger, tillsätt 3 till disken.

75
00:03:27,700 --> 00:03:34,490
Så vi börjar på 0 och sedan vi
detta fem gånger 3, 6, 9, 12, 15.

76
00:03:34,490 --> 00:03:37,500
Det är samma resultat. Vi
fortfarande få 3 gånger 5 bara

77
00:03:37,500 --> 00:03:39,500
genomförandet är annorlunda.

78
00:03:39,500 --> 00:03:41,490
>> Det är vad vi menar
när vi säger en svart låda.

79
00:03:41,490 --> 00:03:44,406
Det betyder bara att vi bryr mig egentligen inte
hur det genomförs under huven

80
00:03:44,406 --> 00:03:46,170
så länge som utgången är vad vi förväntar oss.

81
00:03:46,170 --> 00:03:49,045
I själva verket är att en del av avtalet
att använda funktioner, särskilt

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

83
00:03:50,630 --> 00:03:53,980
Beteendet kommer alltid
vara typiskt, oförutsägbar

84
00:03:53,980 --> 00:03:55,420
baserat på namnet på funktionen.

85
00:03:55,420 --> 00:03:57,500
Och det är därför det är verkligen
viktigt när du skriver funktioner

86
00:03:57,500 --> 00:04:00,020
eller när andra människor skriver
funktioner som du kan använda,

87
00:04:00,020 --> 00:04:03,590
att dessa funktioner har
tydliga, relativt tydliga namn,

88
00:04:03,590 --> 00:04:04,990
och är väl dokumenterade.

89
00:04:04,990 --> 00:04:08,560
Som säkerligen är fallet
för funktion som utskrifts f.

90
00:04:08,560 --> 00:04:09,860
>> Så varför använder vi funktioner?

91
00:04:09,860 --> 00:04:14,220
Väl som jag sa tidigare, om vi skriver
all vår kod inuti viktigaste sakerna

92
00:04:14,220 --> 00:04:17,120
kan bli riktigt besvärligt
och mycket komplicerat.

93
00:04:17,120 --> 00:04:19,980
Funktioner tillåter oss förmågan
att organisera saker och bryta upp

94
00:04:19,980 --> 00:04:24,540
ett mycket komplicerat problem i
mycket mer hanterbara underdelar.

95
00:04:24,540 --> 00:04:28,130
Funktioner tillåter oss också till
förenkla kodningsprocessen.

96
00:04:28,130 --> 00:04:33,080
Det är mycket lättare att felsöka en 10
linjefunktion kontra en 100 linje

97
00:04:33,080 --> 00:04:35,890
funktion eller en 1000 linjefunktion.

98
00:04:35,890 --> 00:04:38,400
Om vi ​​har bara att felsöka
små bitar åt gången,

99
00:04:38,400 --> 00:04:42,110
eller skriva små bitar på tiden,
det gör att erfarenhet av programmering

100
00:04:42,110 --> 00:04:43,070
mycket bättre.

101
00:04:43,070 --> 00:04:44,910
Lita på mig om det.

102
00:04:44,910 --> 00:04:48,400
>> Till sist, om vi skriver funktioner vi
kan återanvända de olika delarna.

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

104
00:04:49,880 --> 00:04:51,880
De kan användas i
ett program eller en annan.

105
00:04:51,880 --> 00:04:53,713
Du har redan skrivit
funktionen, allt du

106
00:04:53,713 --> 00:04:56,530
behöver göra är att berätta att programmet
var man kan hitta denna funktion.

107
00:04:56,530 --> 00:04:59,680
Vi har återvinning och användning
print f i över 40 år.

108
00:04:59,680 --> 00:05:02,150
Men det var bara skrivit en gång.

109
00:05:02,150 --> 00:05:04,270
Ganska bra, eller hur.

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

111
00:05:04,830 --> 00:05:06,040
Så fungerar är stora.

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

113
00:05:06,860 --> 00:05:08,700
Nu börja skriva dem.

114
00:05:08,700 --> 00:05:10,830
Låt oss börja få
dem i våra program.

115
00:05:10,830 --> 00:05:13,869
För att göra detta, den första
vi gör är deklarera funktionen.

116
00:05:13,869 --> 00:05:16,160
När du deklarerar en funktion
vad du i princip göra

117
00:05:16,160 --> 00:05:18,900
säger kompilatorn,
hej, bara så ni vet,

118
00:05:18,900 --> 00:05:20,850
Jag kommer att skriva
en funktion senare

119
00:05:20,850 --> 00:05:22,987
och här är vad det kommer att se ut.

120
00:05:22,987 --> 00:05:24,820
Anledningen till detta är
eftersom kompilatorer kan

121
00:05:24,820 --> 00:05:27,900
göra några konstiga saker om
de ser en uppsättning av symboler

122
00:05:27,900 --> 00:05:29,560
att de inte är bekanta med.

123
00:05:29,560 --> 00:05:33,000
Så vi bara ge kompilatorn en
heads up, jag skapar en funktion

124
00:05:33,000 --> 00:05:35,492
och det kommer att göra detta.

125
00:05:35,492 --> 00:05:38,450
Funktionsdeklarationer i allmänhet om så
du organiserar din kod på ett sätt

126
00:05:38,450 --> 00:05:41,872
att andra kommer att kunna
förstå och dra nytta av,

127
00:05:41,872 --> 00:05:44,330
du vanligtvis vill sätta alla
av dina funktionsdeklarationer

128
00:05:44,330 --> 00:05:48,220
högst upp på din kod, höger
innan du börjar skriva på även.

129
00:05:48,220 --> 00:05:50,770
Och enkelt, det finns
en mycket standardformulär

130
00:05:50,770 --> 00:05:53,500
att varje funktion Förklaringen överensstämmer.

131
00:05:53,500 --> 00:05:56,090
De alla ganska mycket ser ut så här.

132
00:05:56,090 --> 00:06:01,440
Det finns tre delar till en funktion
deklaration, returtyp, namn,

133
00:06:01,440 --> 00:06:03,420
och argumentlistan.

134
00:06:03,420 --> 00:06:07,180
>> Nu returtypen är vilken typ av
variabel funktionen kommer utgång.

135
00:06:07,180 --> 00:06:10,710
Så till exempel, om vi tänker tillbaka
minut sedan till att multiplicera två

136
00:06:10,710 --> 00:06:15,690
nummer funktion, vad förväntar vi oss om
vi multiplicera ett heltal med ett heltal

137
00:06:15,690 --> 00:06:18,502
utgången kommer att vara
förmodligen ett heltal, rätt.

138
00:06:18,502 --> 00:06:20,710
Multiplicerat två heltal
tillsammans, får du ett heltal.

139
00:06:20,710 --> 00:06:24,167
Så returtyp av att
funktion skulle vara int.

140
00:06:24,167 --> 00:06:26,000
Namn är vad du vill
att ringa din funktion.

141
00:06:26,000 --> 00:06:29,330
Detta är förmodligen den minst viktiga
del av funktionsdeklarationen,

142
00:06:29,330 --> 00:06:30,827
när det gäller funktionalitet.

143
00:06:30,827 --> 00:06:33,160
Men är faktiskt förmodligen en
av de viktigaste delarna

144
00:06:33,160 --> 00:06:36,243
av funktionsdeklarationen när det gäller
att veta vad funktionen faktiskt

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

146
00:06:37,120 --> 00:06:40,474
Om du namnger din funktion f eller g eller
h eller mystik eller nåt sånt,

147
00:06:40,474 --> 00:06:42,765
du förmodligen kommer att få
lite löst upp försöker

148
00:06:42,765 --> 00:06:44,650
komma ihåg vad dessa funktioner gör.

149
00:06:44,650 --> 00:06:47,880
Så det är viktigt att ge din
funktionens meningsfulla namn.

150
00:06:47,880 --> 00:06:51,030
>> Slutligen är argumentlistan
kommaseparerad lista

151
00:06:51,030 --> 00:06:55,260
av alla ingångarna till din funktion,
vilka vardera har en typ och ett namn.

152
00:06:55,260 --> 00:06:57,840
Så inte bara har du att
ange vilken typ av variabel

153
00:06:57,840 --> 00:07:00,760
funktionen att mata ut,
du också vill ange

154
00:07:00,760 --> 00:07:07,694
vilken typ och typer av variabler i
Funktionen kommer att acceptera som insatsvaror.

155
00:07:07,694 --> 00:07:08,860
Så låt oss göra ett exempel här.

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

157
00:07:10,220 --> 00:07:13,130
Så här är ett exempel på en funktion
deklaration för en funktion som

158
00:07:13,130 --> 00:07:14,925
skulle lägga till två heltal tillsammans.

159
00:07:14,925 --> 00:07:17,800
Summan av två heltal kommer att
vara ett heltal också, eftersom vi bara

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

161
00:07:18,450 --> 00:07:21,610
Och så returtypen,
här i grönt, skulle vara int.

162
00:07:21,610 --> 00:07:25,190
Som bara berättar att lägga till två Ints
kommer att, vid slutet av dagen,

163
00:07:25,190 --> 00:07:28,799
utgång, eller spotta tillbaka
ut till oss, ett heltal.

164
00:07:28,799 --> 00:07:31,590
Med tanke på vad den här funktionen gör vi
vill ge det ett lämpligt namn.

165
00:07:31,590 --> 00:07:33,630
Lägg till två Ints verkar
lämpligt, med tanke på

166
00:07:33,630 --> 00:07:37,574
vi tar två heltal som insatsvaror
och förhoppningsvis lägga samman dem.

167
00:07:37,574 --> 00:07:40,240
Det kan vara lite av en besvärlig
namn och ärligt talat denna funktion

168
00:07:40,240 --> 00:07:42,430
är förmodligen inte nödvändigt
eftersom vi har tillsats

169
00:07:42,430 --> 00:07:46,310
operatör, om du minns från vår
diskussion om operatörer, tidigare.

170
00:07:46,310 --> 00:07:49,650
Men låt oss bara säga skull
Argumentet att denna funktion är användbar

171
00:07:49,650 --> 00:07:52,860
och så vi kallar man lägga två Ints.

172
00:07:52,860 --> 00:07:55,230
Slutligen tar denna funktion två ingångar.

173
00:07:55,230 --> 00:07:56,960
Var och en av vilka är ett heltal.

174
00:07:56,960 --> 00:07:59,900
Så vi har denna kommatecken
separerad lista av insatsvaror.

175
00:07:59,900 --> 00:08:02,830
Nu är vi i allmänhet vill
namnge en av dem

176
00:08:02,830 --> 00:08:05,070
så att de kan användas
inom funktionen.

177
00:08:05,070 --> 00:08:07,180
Namnen är inte särskilt viktig.

178
00:08:07,180 --> 00:08:11,400
>> I det här fallet har vi inte nödvändigtvis
har någon mening knutna till dem.

179
00:08:11,400 --> 00:08:13,140
Så vi kan bara kalla dem a och b.

180
00:08:13,140 --> 00:08:14,257
Det är helt bra.

181
00:08:14,257 --> 00:08:16,090
Men om du hittar
själv i en situation

182
00:08:16,090 --> 00:08:19,497
där namnen på variablerna
kan faktiskt vara viktigt,

183
00:08:19,497 --> 00:08:21,830
kanske du vill kalla dem
något annat än a och b

184
00:08:21,830 --> 00:08:24,701
att ge dem något mer
symboliskt meningsfullt.

185
00:08:24,701 --> 00:08:27,700
Men i detta fall, gör vi inte riktigt
vet något annat om funktionen.

186
00:08:27,700 --> 00:08:29,320
Vi vill bara lägga till två heltal.

187
00:08:29,320 --> 00:08:32,429
Så vi ska bara ringa
de heltal a och b.

188
00:08:32,429 --> 00:08:33,990
Det är ett exempel.

189
00:08:33,990 --> 00:08:36,287
>> Varför tar du inte en sekund
att tänka på detta,

190
00:08:36,287 --> 00:08:38,870
hur skulle du skriver en funktion
deklaration för en funktion som

191
00:08:38,870 --> 00:08:42,940
multiplicerar två flyttal?

192
00:08:42,940 --> 00:08:45,910
Minns du vad en
flyttal är?

193
00:08:45,910 --> 00:08:48,120
Vad skulle denna funktion
deklaration ser ut?

194
00:08:48,120 --> 00:08:53,330
Jag rekommenderar verkligen du pausa videon
här och ta hur mycket tid du behöver.

195
00:08:53,330 --> 00:08:55,521
Tänk på vad detta
funktionsdeklarationen skulle vara?

196
00:08:55,521 --> 00:08:56,770
Vad skulle returtypen vara?

197
00:08:56,770 --> 00:08:58,103
Vad skulle ett meningsfullt namn vara?

198
00:08:58,103 --> 00:08:59,580
Vad skulle ingångarna vara?

199
00:08:59,580 --> 00:09:03,190
Så varför inte göra en paus i videon här
och skriva upp en funktion deklaration

200
00:09:03,190 --> 00:09:07,640
för en funktion som skulle föröka
två flyttal tillsammans.

201
00:09:07,640 --> 00:09:09,330
Förhoppningsvis du pausade videon.

202
00:09:09,330 --> 00:09:12,950
>> Så låt oss ta en titt på ett exempel
av en möjlig förklaring.

203
00:09:12,950 --> 00:09:17,340
Float Mult två realer flyta x, float y.

204
00:09:17,340 --> 00:09:19,090
Produkten från två
flyttal,

205
00:09:19,090 --> 00:09:21,710
som minns är hur vi
representera reella tal

206
00:09:21,710 --> 00:09:26,770
eller siffror med decimalvärden i c,
kommer att bli ett flyttal.

207
00:09:26,770 --> 00:09:28,570
När du multiplicerar en
decimal av en decimal,

208
00:09:28,570 --> 00:09:30,460
du förmodligen kommer att få en decimal.

209
00:09:30,460 --> 00:09:31,960
Du vill ge det en relevant namn.

210
00:09:31,960 --> 00:09:33,810
Multiplicera två realer verkar bra.

211
00:09:33,810 --> 00:09:36,620
Men du kan verkligen kalla det
Mult två flottörer eller Mult flottörer.

212
00:09:36,620 --> 00:09:39,540
Något liknande, så länge som det
gav några verkliga innebörden av vad

213
00:09:39,540 --> 00:09:41,469
denna svarta lådan skulle göra.

214
00:09:41,469 --> 00:09:44,260
Och återigen, i det här fallet har vi inte
verkar ha någon mening fäst

215
00:09:44,260 --> 00:09:46,390
till namnen på de
variabler vi passerar i,

216
00:09:46,390 --> 00:09:48,645
så vi bara kalla dem x och y.

217
00:09:48,645 --> 00:09:51,020
Nu om du kallar dem något
annars, det är helt bra.

218
00:09:51,020 --> 00:09:53,310
I själva verket, om du gjorde
denna förklaring i stället

219
00:09:53,310 --> 00:09:55,450
med användning av dubbel istället
av flyter, om ni minns

220
00:09:55,450 --> 00:09:59,100
att dubbel är en annan
sätt att mer precist

221
00:09:59,100 --> 00:10:02,330
ange reella tal eller
flyttal variabler.

222
00:10:02,330 --> 00:10:03,620
Det är helt bra också.

223
00:10:03,620 --> 00:10:04,670
Antingen en av dem skulle vara bra.

224
00:10:04,670 --> 00:10:06,711
I själva verket finns det flera
olika kombinationer

225
00:10:06,711 --> 00:10:08,410
sätt att förklara denna funktion.

226
00:10:08,410 --> 00:10:10,884
Men dessa är två ganska bra.

227
00:10:10,884 --> 00:10:12,550
Vi har förklarat en funktion, det är bra.

228
00:10:12,550 --> 00:10:15,700
Vi har berättat kompilatorn vad det
är, vad vi ska göra.

229
00:10:15,700 --> 00:10:17,630
Nu ska vi faktiskt skriver denna funktion.

230
00:10:17,630 --> 00:10:20,750
Låt oss ge det en definition,
så att insidan den svarta lådan

231
00:10:20,750 --> 00:10:22,840
förutsägbart beteende som händer.

232
00:10:22,840 --> 00:10:26,270
I själva verket är vi multiplicera två real
siffror tillsammans, eller lägga till nummer

233
00:10:26,270 --> 00:10:29,760
tillsammans, eller göra vad det är
att vi bad vår funktion att göra.

234
00:10:29,760 --> 00:10:32,780
>> Så i själva verket, låt oss försöka definiera
multiplicera två realer som vi just

235
00:10:32,780 --> 00:10:35,350
talade om en sekund sedan.

236
00:10:35,350 --> 00:10:38,560
Nu i början av
en funktionsdefinition

237
00:10:38,560 --> 00:10:41,720
ser nästan exakt samma
som en funktion deklaration.

238
00:10:41,720 --> 00:10:43,170
Jag har dem båda här.

239
00:10:43,170 --> 00:10:47,770
På toppen är funktionsdeklarationen,
typ, namn, kommaseparerad argument

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

241
00:10:49,410 --> 00:10:53,800
Semikolon indikerar att
som är en funktion deklaration.

242
00:10:53,800 --> 00:10:57,060
Början av funktionen
definition ser nästan exakt

243
00:10:57,060 --> 00:11:03,790
samma, typ, namn, kommaseparerad
argumentlistan, ingen semikolon,

244
00:11:03,790 --> 00:11:05,206
öppna klammerparentes.

245
00:11:05,206 --> 00:11:07,580
Den öppna klammerparentes, precis som
vi har gjort med huvud,

246
00:11:07,580 --> 00:11:09,540
innebär att vi nu
börjar definiera

247
00:11:09,540 --> 00:11:14,567
vad som händer inuti den svarta lådan som
Vi har valt att kalla Mult två reals.

248
00:11:14,567 --> 00:11:15,900
Här är ett sätt att genomföra det.

249
00:11:15,900 --> 00:11:20,370
Vi skulle kunna säga, vi kunde deklarera en ny
variabel av typen float kallas produkt

250
00:11:20,370 --> 00:11:24,020
och tilldela variabel
till värdet x gånger y.

251
00:11:24,020 --> 00:11:27,306
Och sedan tillbaka produkten.

252
00:11:27,306 --> 00:11:28,430
Vad betyder avkastning menar här.

253
00:11:28,430 --> 00:11:31,090
Väl avkastning är vägen
Vi visar att det är hur

254
00:11:31,090 --> 00:11:33,400
vi passerar utgången backa ur.

255
00:11:33,400 --> 00:11:38,160
Så tillbaka något, är densamma som,
detta är utsignalen från den svarta lådan.

256
00:11:38,160 --> 00:11:40,732
Så det är hur du gör det.

257
00:11:40,732 --> 00:11:42,190
Här är ett annat sätt att genomföra det.

258
00:11:42,190 --> 00:11:45,050
Vi kunde bara tillbaka x gånger y.

259
00:11:45,050 --> 00:11:45,870
x är ett flöte.

260
00:11:45,870 --> 00:11:46,660
y är ett flöte.

261
00:11:46,660 --> 00:11:48,490
Så x gånger y är också en flottör.

262
00:11:48,490 --> 00:11:50,750
Vi behöver inte ens till
skapa en annan variabel.

263
00:11:50,750 --> 00:11:56,750
Så det är ett annat sätt att
genomföra exakt samma svarta lådan.

264
00:11:56,750 --> 00:11:58,570
>> Ta nu en stund,
pausa videon igen,

265
00:11:58,570 --> 00:12:01,680
och försöka definiera lägga till två Ints,
vilket är den andra funktionen som vi

266
00:12:01,680 --> 00:12:03,090
talade om för en stund sedan.

267
00:12:03,090 --> 00:12:06,440
Även här har jag lagt funktionen
deklarationen, och så semikolon,

268
00:12:06,440 --> 00:12:08,420
och ett öppet klammerparentes
och ett stängt lockigt

269
00:12:08,420 --> 00:12:12,080
stag för att ange var vi kommer att fylla
i innehållet i lägga till två Ints,

270
00:12:12,080 --> 00:12:15,530
så att vi definierar den speciella
beteende i den svarta lådan.

271
00:12:15,530 --> 00:12:16,380
Så pausa videon.

272
00:12:16,380 --> 00:12:18,790
Och ta så mycket tid som
du måste försöka definiera

273
00:12:18,790 --> 00:12:25,040
en implementering av lägga till två ints, såsom
att när funktionen utmatar ett värde,

274
00:12:25,040 --> 00:12:29,209
den gör det, i själva verket, retur
summan av de två ingångarna.

275
00:12:29,209 --> 00:12:32,000
Så precis som det tidigare exemplet,
det finns flera olika sätt

276
00:12:32,000 --> 00:12:34,210
att du skulle kunna genomföra lägga till två Ints.

277
00:12:34,210 --> 00:12:35,130
Här är en.

278
00:12:35,130 --> 00:12:37,172
Här inne i orange har jag
bara hade några comments--

279
00:12:37,172 --> 00:12:38,880
Jag har just lagt några
kommentarer för att indikera

280
00:12:38,880 --> 00:12:41,400
vad som händer på varje kodrad.

281
00:12:41,400 --> 00:12:45,430
Så jag deklarerar en variabel
kallas summan av typen int.

282
00:12:45,430 --> 00:12:47,279
Jag säger summan är lika med ett plus b.

283
00:12:47,279 --> 00:12:50,070
Det är där vi faktiskt gör
arbetet att lägga a och b tillsammans.

284
00:12:50,070 --> 00:12:51,850
Och jag återvänder summa.

285
00:12:51,850 --> 00:12:56,460
Och det är vettigt eftersom
Summan är en variabel av typen int.

286
00:12:56,460 --> 00:13:00,180
Och vad är den datatyp som detta
Funktionen säger mig att det kommer att produktionen?

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

288
00:13:00,680 --> 00:13:03,072
Så jag åter summa som
är en heltalsvariabel.

289
00:13:03,072 --> 00:13:06,030
Och det är vettigt med tanke på vad vi har
deklareras och definierat vår funktion

290
00:13:06,030 --> 00:13:07,320
att göra.

291
00:13:07,320 --> 00:13:09,700
>> Nu kan du också definiera
funktionen på detta sätt,

292
00:13:09,700 --> 00:13:15,260
int summa motsvarar en plus b-- hoppa över den
först step-- och sedan tillbaka summan.

293
00:13:15,260 --> 00:13:17,760
Nu kan du också
genomfört det här sättet,

294
00:13:17,760 --> 00:13:19,180
som jag starkt rekommenderar inte.

295
00:13:19,180 --> 00:13:22,540
Detta är dåligt stil för en
sak och verkligen dålig design,

296
00:13:22,540 --> 00:13:24,420
men den gör det, i själva verket, arbete.

297
00:13:24,420 --> 00:13:30,199
Om du tar den här koden, som är int
lägg dålig adderaren punkt c, och använda den.

298
00:13:30,199 --> 00:13:31,990
Det faktiskt tillför
två heltal tillsammans.

299
00:13:31,990 --> 00:13:37,632
Det är en mycket dålig implementering
av denna speciella beteende.

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

301
00:13:38,340 --> 00:13:41,200
Det är bara här för att illustrera
den punkt som vi egentligen inte

302
00:13:41,200 --> 00:13:44,530
bry sig om vad som händer inuti
den svarta lådan, så länge

303
00:13:44,530 --> 00:13:46,510
eftersom det har utgång som vi förväntar oss.

304
00:13:46,510 --> 00:13:48,870
Detta är ett dåligt utformade svart låda.

305
00:13:48,870 --> 00:13:53,801
Men i slutet av dagen, gör det
fortfarande utgång summan av ett plus b.

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

307
00:13:54,300 --> 00:13:56,320
Så vi har förklarat funktioner.

308
00:13:56,320 --> 00:13:57,490
Och vi har definierat funktionen.

309
00:13:57,490 --> 00:13:58,540
Så det är riktigt bra.

310
00:13:58,540 --> 00:14:03,020
Nu börjar använda funktionerna
att vi har deklarerats och vi har definierat.

311
00:14:03,020 --> 00:14:05,960
Om du vill ringa ett function-- det faktiskt
ganska easy-- allt du behöver göra

312
00:14:05,960 --> 00:14:09,070
är ge det lämpliga argument,
argument datatyp

313
00:14:09,070 --> 00:14:11,600
att det förväntar sig och
sedan tilldela retur

314
00:14:11,600 --> 00:14:15,190
värdet av denna funktion
och this-- vändning mig--

315
00:14:15,190 --> 00:14:19,390
tilldela returvärdet för denna funktion
till något av rätt typ.

316
00:14:19,390 --> 00:14:22,410
>> Så låt oss ta en titt på
detta i praktiken i en fil

317
00:14:22,410 --> 00:14:27,730
kallas adderare 1 dot c, som
Jag har i min CS50 IDE.

318
00:14:27,730 --> 00:14:31,042
Så här är adderare 1 dot c.

319
00:14:31,042 --> 00:14:33,500
I början ser jag har
min omfattar pund inkluderar,

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

321
00:14:35,460 --> 00:14:37,700
Och då jag har min funktionsdeklarationen.

322
00:14:37,700 --> 00:14:39,570
Det är där jag är
berättar kompilatorn jag

323
00:14:39,570 --> 00:14:42,850
kommer att skriva en
Funktionen kallas lägga till två Ints.

324
00:14:42,850 --> 00:14:45,780
Det kommer att mata ut en
heltalstyp variabel.

325
00:14:45,780 --> 00:14:47,360
Det är vad den här delen är rätt här.

326
00:14:47,360 --> 00:14:51,950
Och då jag har två ingångar till en
och B, som var och en är ett heltal.

327
00:14:51,950 --> 00:14:58,250
Inuti huvud, ber jag användaren
ingång genom att säga, ge mig ett heltal.

328
00:14:58,250 --> 00:15:01,040
Och de uppmanas att glömma
int, vilket är en funktion som

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

330
00:15:03,240 --> 00:15:07,660
Och det får lagras i
x, en heltalsvariabel.

331
00:15:07,660 --> 00:15:09,886
>> Då kan vi få dem till ett annat heltal.

332
00:15:09,886 --> 00:15:13,070
Vi får ett annat heltal
och lagra det i y.

333
00:15:13,070 --> 00:15:17,990
Och sedan, här på ledningen 28, är
där vi gör vår funktionsanrop.

334
00:15:17,990 --> 00:15:23,770
Vi säger, int z jämlikar
tillsätt 2 Ints x kommatecken y.

335
00:15:23,770 --> 00:15:25,980
Ser du varför detta är vettigt?

336
00:15:25,980 --> 00:15:29,710
x är ett heltal typ variabel och
y är ett heltal typ variabel.

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

338
00:15:31,220 --> 00:15:34,570
Det vettigt med vad vår funktion
deklaration på rad 17 ser ut.

339
00:15:34,570 --> 00:15:38,300
Den kommaseparerad ingångslista
Parlamentet förväntar sig två heltal, a och b.

340
00:15:38,300 --> 00:15:40,300
I så fall kan vi ringa
dem vad vi vill.

341
00:15:40,300 --> 00:15:42,300
Det förväntar sig bara två heltal.

342
00:15:42,300 --> 00:15:44,930
Och x är ett heltal och y är ett heltal.

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

344
00:15:45,640 --> 00:15:48,680
>> Och vi vet att funktionen går
att mata ut en heltal också.

345
00:15:48,680 --> 00:15:51,290
Och så vi lagrar
utmatning av funktionen,

346
00:15:51,290 --> 00:15:56,050
lägga till två ints, i ett heltal typ
variabel, som vi kallar z.

347
00:15:56,050 --> 00:16:01,980
Och då kan vi säga, summan av
procent i och procent i är procent i.

348
00:16:01,980 --> 00:16:06,210
x, y och z respektive
fylla i de procent i talet.

349
00:16:06,210 --> 00:16:08,334
Vad är definitionen av
lägga till två Ints ser ut?

350
00:16:08,334 --> 00:16:09,125
Det är ganska enkelt.

351
00:16:09,125 --> 00:16:11,270
Det är en av de vi
bara såg en sekund sedan,

352
00:16:11,270 --> 00:16:14,390
int summa motsvarar en plus b returbelopp.

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

354
00:16:15,420 --> 00:16:17,270
Låt oss spara filen.

355
00:16:17,270 --> 00:16:22,080
Och sedan ner här på min terminal
Jag kommer att göra adderaren 1,

356
00:16:22,080 --> 00:16:23,000
och rensar jag min skärm.

357
00:16:23,000 --> 00:16:25,791
Jag kommer att zooma in eftersom jag vet
det är lite svårt att se.

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

359
00:16:31,520 --> 00:16:33,770
>> Så vi sammanställa det här programmet som adderare 1.

360
00:16:33,770 --> 00:16:37,910
Så vi kan göra punkt snedstreck adderare 1.

361
00:16:37,910 --> 00:16:40,060
Ge mig ett heltal, 10.

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

363
00:16:42,380 --> 00:16:45,200
Summan av 10 och 20 är 30.

364
00:16:45,200 --> 00:16:47,615
Så vi gjorde ett lyckat anrop funktion.

365
00:16:47,615 --> 00:16:55,820
Du kan köra funktionen igen, negativ
10, är ​​17 summan av -10 och 17 7.

366
00:16:55,820 --> 00:16:57,120
Den här funktionen fungerar.

367
00:16:57,120 --> 00:16:59,240
Den har beteendet
att vi förväntar oss att.

368
00:16:59,240 --> 00:17:03,610
Och så har vi gjort en lyckad
funktion, definition, förklaring,

369
00:17:03,610 --> 00:17:07,288
och ett lyckat anrop funktion.

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

371
00:17:09,079 --> 00:17:10,611
innan vi avslutar det här avsnittet.

372
00:17:10,611 --> 00:17:12,319
Minns från vår
diskussion om datatyper,

373
00:17:12,319 --> 00:17:16,109
tidigare, som fungerar
kan ibland ta några ingångar.

374
00:17:16,109 --> 00:17:17,930
Om så är fallet, vi
förklara funktion

375
00:17:17,930 --> 00:17:19,788
såsom att ha en tomrumsargumentlistan.

376
00:17:19,788 --> 00:17:21,579
Minns du vad
vanligaste funktion

377
00:17:21,579 --> 00:17:25,036
vi har sett hittills som tar
ett tomrum argumentlistan är?

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

379
00:17:27,300 --> 00:17:30,850
Minns också att funktionen ibland
faktiskt inte har en utgång.

380
00:17:30,850 --> 00:17:34,210
I så fall, deklarerar vi funktionen
ha en typ void avkastning.

381
00:17:34,210 --> 00:17:37,880
Låt oss avsluta detta avsnitt
att ta itu med en praxis problem.

382
00:17:37,880 --> 00:17:39,900
>> Så här är problemet anges.

383
00:17:39,900 --> 00:17:43,630
Jag vill att du ska skriva en funktion
kallas giltiga triangel.

384
00:17:43,630 --> 00:17:47,410
Vad den här funktionen ska göra
är att ta tre reella tal

385
00:17:47,410 --> 00:17:51,930
som representerar längden på tre
sidor av en triangel som dess parametrar,

386
00:17:51,930 --> 00:17:54,550
eller dess argument, eller dess
inputs-- annan uppsättning synonymer

387
00:17:54,550 --> 00:17:57,340
som du kan stöta på.

388
00:17:57,340 --> 00:18:01,120
Denna funktion bör
antingen utgång sant eller falskt

389
00:18:01,120 --> 00:18:04,960
beroende på om dessa tre längder
är kapabla att göra en triangel.

390
00:18:04,960 --> 00:18:09,930
Kommer du ihåg datatyp som
vi används för att ange sant eller falskt?

391
00:18:09,930 --> 00:18:11,436
Nu hur gör du genomföra detta?

392
00:18:11,436 --> 00:18:13,810
Tja vet att det finns ett par
av reglerna om trianglar

393
00:18:13,810 --> 00:18:15,480
som är faktiskt bra att veta.

394
00:18:15,480 --> 00:18:18,292
En triangel kan bara ha
sidor med positiv längd.

395
00:18:18,292 --> 00:18:19,000
Det känns logiskt.

396
00:18:19,000 --> 00:18:21,432
Du förmodligen säger, duh.

397
00:18:21,432 --> 00:18:23,390
Den andra saken att notera
är dock att summan

398
00:18:23,390 --> 00:18:25,484
av längderna av varje
två sidor av triangeln

399
00:18:25,484 --> 00:18:27,650
måste vara större än den
längden på den tredje sidan.

400
00:18:27,650 --> 00:18:28,690
Det är faktiskt sant.

401
00:18:28,690 --> 00:18:34,150
Du kan inte ha en triangel av sidorna 1,
2 och 4, till exempel på grund 1 plus 2

402
00:18:34,150 --> 00:18:36,270
inte är större än fyra.

403
00:18:36,270 --> 00:18:38,870
Så de är de regler som
bestämma om tre eller inte

404
00:18:38,870 --> 00:18:42,740
ingångar kan tänkas bilda en triangel.

405
00:18:42,740 --> 00:18:46,360
Så ta ett par minuter
och deklarera och sedan definiera

406
00:18:46,360 --> 00:18:49,810
denna funktion kallas giltiga
triangel, så att det faktiskt

407
00:18:49,810 --> 00:18:51,650
har beteendet som anges här.

408
00:18:51,650 --> 00:18:57,030
>> Det kommer ut sant om dessa tre sidor
är i stånd att innefattande en triangel,

409
00:18:57,030 --> 00:19:01,950
och i annat fall false
Redo att se hur du gjorde?

410
00:19:01,950 --> 00:19:04,650
Här är en implementering
giltig triangel.

411
00:19:04,650 --> 00:19:05,770
Det är inte den enda.

412
00:19:05,770 --> 00:19:07,770
Yours kan variera något.

413
00:19:07,770 --> 00:19:11,040
Men detta gör, i själva verket har
det beteende som vi förväntar oss.

414
00:19:11,040 --> 00:19:14,450
Vi förklarar vår funktion vid
högst upp, bool giltigt triangel

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

416
00:19:16,630 --> 00:19:18,930
Så återigen, denna funktion
tar tre reella tal

417
00:19:18,930 --> 00:19:22,280
som dess argument, flytande
punkt värde variabler,

418
00:19:22,280 --> 00:19:26,510
och matar ut en sant eller falskt
värde, vilket är en Boolean, återkallelse.

419
00:19:26,510 --> 00:19:28,660
Så det är därför returtypen är bool.

420
00:19:28,660 --> 00:19:30,016
Då kan vi definiera funktionen.

421
00:19:30,016 --> 00:19:33,140
Första vi gör är kontrollera att
att alla sidorna är positiva.

422
00:19:33,140 --> 00:19:37,010
Om x är mindre än eller lika
till 0, eller om y är lika med 0,

423
00:19:37,010 --> 00:19:41,050
eller om z är mindre än eller lika med 0,
som inte kan möjligen vara en triangel.

424
00:19:41,050 --> 00:19:42,380
De har inte positiva sidor.

425
00:19:42,380 --> 00:19:45,790
Och så att vi kan återvända
falskt i den situationen.

426
00:19:45,790 --> 00:19:49,010
Därefter kontrollerar vi att se till att
att varje par av ingångar

427
00:19:49,010 --> 00:19:51,830
är större än det tredje en.

428
00:19:51,830 --> 00:19:54,530
>> Så om x plus y är mindre
än eller lika med z,

429
00:19:54,530 --> 00:19:57,060
eller om x plus z är mindre
än eller lika med y,

430
00:19:57,060 --> 00:20:01,730
eller om y plus z är mindre än eller lika med
x, som också kan inte vara ett giltigt triangel.

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

432
00:20:03,800 --> 00:20:06,900
Förutsatt vi passerade båda kontrollerna
Men då kan vi return true.

433
00:20:06,900 --> 00:20:09,440
Eftersom dessa tre sidor
är kapabla att returning--

434
00:20:09,440 --> 00:20:11,647
att skapa en giltig triangel.

435
00:20:11,647 --> 00:20:12,230
Och det är allt.

436
00:20:12,230 --> 00:20:13,830
Du har nu förklarat och definieras.

437
00:20:13,830 --> 00:20:17,330
Och du kanske kan nu
använda och kalla den här funktionen.

438
00:20:17,330 --> 00:20:19,470
Bra jobbat.

439
00:20:19,470 --> 00:20:20,650
Jag är Doug Lloyd.

440
00:20:20,650 --> 00:20:22,820
Detta är CS50.

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