1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> SPEAKER 1: Hej alle.

3
00:00:05,680 --> 00:00:07,530
Vi kommer til at komme i gang.

4
00:00:07,530 --> 00:00:09,330
Jeg tror, ​​at folk stadig vil
at være filtrering.

5
00:00:09,330 --> 00:00:12,840
Men af ​​hensyn til tiden, så vi kan
få jer ud af her til tiden,

6
00:00:12,840 --> 00:00:14,110
vi kommer til at starte.

7
00:00:14,110 --> 00:00:18,780
Så velkommen til CS50 Quiz 0 anmeldelse.

8
00:00:18,780 --> 00:00:23,020
For dem af jer, der ikke har indset
endnu, du har et spørgsmål på onsdag.

9
00:00:23,020 --> 00:00:25,700
Woo-hoo.

10
00:00:25,700 --> 00:00:29,780
>> Hvis du ikke har startet studere endnu eller
ikke har indset, at det eksisterer endnu,

11
00:00:29,780 --> 00:00:34,070
tidligere quizzer og alle oplysninger om
din quiz er på cs50.net/quizzes.

12
00:00:34,070 --> 00:00:38,090
Der er nogle ret gode ting på der,
tidligere quizzer fra de sidste 10

13
00:00:38,090 --> 00:00:43,760
år samt oplysninger
om denne quiz og emner

14
00:00:43,760 --> 00:00:46,250
der vil blive dækket.

15
00:00:46,250 --> 00:00:48,980
Så lad os komme i gang.

16
00:00:48,980 --> 00:00:54,240
>> Så jer måske husker, den første
dag i klassen David havde disse lygter på.

17
00:00:54,240 --> 00:00:59,650
Så det væsentlige, alt, der går
på under kølerhjelmen af ​​en computer er

18
00:00:59,650 --> 00:01:00,860
gjort i binær.

19
00:01:00,860 --> 00:01:04,080
Binær betyder hvad det lyder
lignende, 0'er og 1-taller.

20
00:01:04,080 --> 00:01:09,290
Den har to værdier,
kan være repræsenteret.

21
00:01:09,290 --> 00:01:14,675
>> Så ligesom i den første dag i sektion
Da David tændt et lys

22
00:01:14,675 --> 00:01:21,990
pære til at repræsentere den, eller 1, vores computer
forstår binært som 0'er og

23
00:01:21,990 --> 00:01:24,110
1'er, til eller fra.

24
00:01:24,110 --> 00:01:25,360
Grundlæggende om Binary.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
Hvert sted er repræsenteret
i bunden to.

27
00:01:32,470 --> 00:01:36,260
Så du tilføje 2 til 0 til
1 til 2 hele vejen op.

28
00:01:36,260 --> 00:01:41,970
>> At beregne, hvad din binære er at
decimal, skal du blot følge denne ligning

29
00:01:41,970 --> 00:01:42,840
type ting.

30
00:01:42,840 --> 00:01:49,510
Hvis du har en 1 i nogen af ​​disse steder,
du gange det med uanset

31
00:01:49,510 --> 00:01:53,820
basere det er i, tilføje det op, og
du får decimal.

32
00:01:53,820 --> 00:01:57,930
Så dette er, hvordan du tæller
til 5 i binær.

33
00:01:57,930 --> 00:02:01,400
Ligesom hvad vi laver på
sidste dias, er det sådan du ville

34
00:02:01,400 --> 00:02:02,650
repræsenterer 1 til 5.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> Tilsvarende, ligesom du kan tilføje og
trække i decimal eller basere 10, eller

37
00:02:09,660 --> 00:02:13,040
virkelig helst base på kan tilføje
og trække i binær.

38
00:02:13,040 --> 00:02:18,400
Præcis hvad du ville forvente, når du
tilføje to op, hvis det er lig med større

39
00:02:18,400 --> 00:02:24,220
end 1, du bærer en 1, gør det til en 0,
og gøre den tilføjelse, at vejen, lige

40
00:02:24,220 --> 00:02:29,910
ligesom du ville forvente med regelmæssig
decimal eller anden base.

41
00:02:29,910 --> 00:02:30,970
Fedt.

42
00:02:30,970 --> 00:02:35,140
>> Så som jeg sagde før, alt det,
går under kølerhjelmen af ​​vores computer

43
00:02:35,140 --> 00:02:37,560
sker i 0'er og 1-taller, eller binær.

44
00:02:37,560 --> 00:02:43,470
Så hvordan kan vi udtrykke, for eksempel,
bogstaver eller tal eller bogstaver?

45
00:02:43,470 --> 00:02:45,560
Og svaret på det er ASCII.

46
00:02:45,560 --> 00:02:49,380
>> ASCII er en kortlægning mellem tegn
at vi normalt ville se i

47
00:02:49,380 --> 00:02:53,360
Engelsk sprog som A'er, BS,
C'er, understregningstegn, bindestreger, og

48
00:02:53,360 --> 00:02:54,910
noget lignende.

49
00:02:54,910 --> 00:02:57,260
Og det kort, der til en ASCII værdi.

50
00:02:57,260 --> 00:03:03,080
En ASCII værdi er blot et tal, der
kan forstås af computeren.

51
00:03:03,080 --> 00:03:07,430
Og ligesom du kan gøre addition og
subtraktion med tal, kan du gøre

52
00:03:07,430 --> 00:03:10,890
dem med ASCII-værdier.

53
00:03:10,890 --> 00:03:14,050
>> Så i dette eksempel, hvad
Dette vil udskrive?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
Ja, så bare Et rum B space C plads
D. Hvor blev min mus hen?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
Bemærk du kan definere en int ved 65.

58
00:03:43,380 --> 00:03:47,080
Og når du udskriver det ud ved hjælp af
procent C, vil det tolker det som et

59
00:03:47,080 --> 00:03:49,330
karakter og vil udskrive A.

60
00:03:49,330 --> 00:03:52,800
>> Tilsvarende kan du erklære
det som en char.

61
00:03:52,800 --> 00:03:56,860
Og når du printe det ud ved hjælp af procent
C, vil det fortolke denne som

62
00:03:56,860 --> 00:04:05,240
procent D. Og ligesom du kan tilføje en
nummer, kan du tilføje tegn er

63
00:04:05,240 --> 00:04:06,878
ASCII-værdier, i dette tilfælde.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> Så en lille pegepind for alle.

66
00:04:16,130 --> 00:04:19,610
5, som en streng, ikke
faktisk lig 5.

67
00:04:19,610 --> 00:04:26,610
Så hvordan kan vi konvertere
streng 5 til det hele tal 5?

68
00:04:26,610 --> 00:04:28,930
Nogen idéer?

69
00:04:28,930 --> 00:04:31,630
Ja.

70
00:04:31,630 --> 00:04:36,720
>> Så hvis vi har 5 som en streng,
vi kan trække 0.

71
00:04:36,720 --> 00:04:37,820
Og det vil give os 5.

72
00:04:37,820 --> 00:04:41,670
Og på samme måde, hvis vi har 5 som en
heltal, tilføje, at strengen 0.

73
00:04:41,670 --> 00:04:43,112
Og det giver os strengen 5.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
Fedt.

76
00:04:48,350 --> 00:04:52,940
>> Nu husker tilbage til foredrag en, hvor
vi talte om algoritmer.

77
00:04:52,940 --> 00:04:57,260
Så hvordan kan vi faktisk ønsker en computer
at gøre interessante ting?

78
00:04:57,260 --> 00:05:00,460
Du ved, bare at tilføje og fratrække
tal og trykning ting, er ikke

79
00:05:00,460 --> 00:05:01,730
det spændende.

80
00:05:01,730 --> 00:05:04,620
Normalt vi ønsker, at vores computer til
udføre en form for algoritme.

81
00:05:04,620 --> 00:05:07,820
Noget lidt mere kompleks
end blot et simpelt regnestykke.

82
00:05:07,820 --> 00:05:11,930
>> En algoritme er blot en trinvis sæt
af instruktioner til, hvordan man udfører

83
00:05:11,930 --> 00:05:14,640
en vis task--

84
00:05:14,640 --> 00:05:15,660
Ligesom en opskrift.

85
00:05:15,660 --> 00:05:19,990
Du husker måske den første dag i
klasse, hvor David havde os tælle et værelse

86
00:05:19,990 --> 00:05:22,550
af mennesker, og hvor mange mennesker
var i rummet.

87
00:05:22,550 --> 00:05:24,480
Du kan blive brugt til at tælle
én efter én.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
I dette tilfælde en lineær tid algoritme.

90
00:05:28,010 --> 00:05:31,710
>> Men David indført en algoritme til
du at tælle personer i rummet

91
00:05:31,710 --> 00:05:37,340
hvor alle står op, siger du din
nummer til en anden person, tilføjer, at

92
00:05:37,340 --> 00:05:39,200
nummer op, og en person sidder ned.

93
00:05:39,200 --> 00:05:40,410
Og du gentage det.

94
00:05:40,410 --> 00:05:42,910
Det er en type af algoritme.

95
00:05:42,910 --> 00:05:47,520
Vi kan analysere, hvordan en effektiv en
algoritme er baseret på det køres tid.

96
00:05:47,520 --> 00:05:49,680
Men vi vil snakke lidt
mere om det senere.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> Så alle algoritmer kan også
være skrevet i pseudokode.

99
00:05:57,090 --> 00:06:01,120
Pseudokode er bare en engelsk ligesom
syntaks, der anvendes til at repræsentere

100
00:06:01,120 --> 00:06:02,420
et programmeringssprog.

101
00:06:02,420 --> 00:06:06,070
For eksempel, hvis vi ønskede at spørge en bruger
at gætte min favorit nummer, vi

102
00:06:06,070 --> 00:06:08,390
kunne have pseudokode som sådan.

103
00:06:08,390 --> 00:06:09,850
>> Få en brugere gætte.

104
00:06:09,850 --> 00:06:13,570
Hvis gæt er korrekt, fortælle dem
de er korrekt, ellers fortælle dem

105
00:06:13,570 --> 00:06:15,560
de er ikke korrekt.

106
00:06:15,560 --> 00:06:22,530
Og pseudokode er en måde nemt
repræsenterer en idé eller en algoritme.

107
00:06:22,530 --> 00:06:26,910
Så nu er vi måske ønsker at rent faktisk at skrive
dette på det sprog, som computeren

108
00:06:26,910 --> 00:06:27,980
måske forståelse.

109
00:06:27,980 --> 00:06:35,660
Så vi kunne skrive vores pseudokode og
fortolke denne i kildekoden.

110
00:06:35,660 --> 00:06:41,320
>> Hidtil skal kildekode overholde
til en bestemt syntaks

111
00:06:41,320 --> 00:06:42,490
et programmeringssprog.

112
00:06:42,490 --> 00:06:45,430
Og indtil videre, i CS50, vi har
brugt det meste C.

113
00:06:45,430 --> 00:06:48,320
Så dette kan være kildekoden til ca.

114
00:06:48,320 --> 00:06:51,440
Senere i kurset, du nat komme
i kontakt med andre programmering

115
00:06:51,440 --> 00:06:52,480
sprog som PHP.

116
00:06:52,480 --> 00:06:57,540
Eller hvis du selv tager andre klasser, du
kan gøre Java, Python, eller endda OCML.

117
00:06:57,540 --> 00:07:01,570
Men i vores c programsproget, er dette
hvordan vi kan skrive kildekoden til

118
00:07:01,570 --> 00:07:04,760
pseudokoden algoritme,
Jeg har lige beskrevet tidligere.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> Så hvordan gør din computer faktisk
forstå det?

121
00:07:11,430 --> 00:07:14,490
Som jeg sagde før, er det kun virkelig
forstår nuller og ettaller.

122
00:07:14,490 --> 00:07:17,880
Så hvordan gør det får fra kilden
kode til noget, der kan være

123
00:07:17,880 --> 00:07:18,960
forstået?

124
00:07:18,960 --> 00:07:22,920
Tja, vi har noget
kaldes en compiler.

125
00:07:22,920 --> 00:07:28,450
>> Hvis du husker tilbage i de fleste af dine
psets, du havde en slags program

126
00:07:28,450 --> 00:07:30,370
skrevet i en prik C-fil.

127
00:07:30,370 --> 00:07:32,550
Og så ville du skrive make.

128
00:07:32,550 --> 00:07:35,970
Så hvad er at gøre det?

129
00:07:35,970 --> 00:07:39,970
>> Du kan skrive make til at oversætte din
program, fordi someone--

130
00:07:39,970 --> 00:07:42,730
hvem skrev din p sæt;
sandsynligvis David--

131
00:07:42,730 --> 00:07:44,190
skabt en make-fil.

132
00:07:44,190 --> 00:07:51,320
Og der fortæller at vide for at køre din
compiler, kaldet klang, der vil

133
00:07:51,320 --> 00:07:55,560
derefter kompilere din kildekode til at gøre indsigelse
kode, som er nuller og ettaller

134
00:07:55,560 --> 00:07:57,720
at din computer forstår.

135
00:07:57,720 --> 00:08:01,610
Men lidt senere, vil vi gå
mere i dybden om compilere.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> Så husker pset 0, where-- ja,
du har et spørgsmål?

138
00:08:10,800 --> 00:08:11,620
>> Publikum: [uhørligt]?

139
00:08:11,620 --> 00:08:12,490
>> SPEAKER 1: Ja.

140
00:08:12,490 --> 00:08:14,960
Jeg tror, ​​de faktisk
skal være online.

141
00:08:14,960 --> 00:08:15,120
Ja.

142
00:08:15,120 --> 00:08:16,572
>> PUBLIKUM: Er det ligesom [uhørligt]?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> SPEAKER 1: Det er ikke.

145
00:08:20,830 --> 00:08:25,810
Det er på cs50.net/quizzes.

146
00:08:25,810 --> 00:08:32,900
>> Publikum: Slash quizzer, skråstreg 2013
skråstreg 0, og bare klikke sig igennem

147
00:08:32,900 --> 00:08:35,956
quizzer i 2013 og quiz 0,
gennemgå afsnittet dias.

148
00:08:35,956 --> 00:08:40,380
>> SPEAKER 1: Ja, så hvis du fyre ønsker at
træk den op og se på det på din

149
00:08:40,380 --> 00:08:42,740
egen computer, det er også fint.

150
00:08:42,740 --> 00:08:43,130
Sig det igen.

151
00:08:43,130 --> 00:08:44,546
>> Publikum: [uhørligt].

152
00:08:44,546 --> 00:08:48,780
>> SPEAKER 1: Ja, [uhørligt]
er dummy-variabel.

153
00:08:48,780 --> 00:08:49,644
Åh, ja?

154
00:08:49,644 --> 00:08:51,372
>> Publikum: [uhørligt]?

155
00:08:51,372 --> 00:08:54,300
>> SPEAKER 1: Nej, strejker
er ikke på eksamen.

156
00:08:54,300 --> 00:08:55,950
Beklager, hendes spørgsmål var, var
strejker på eksamen.

157
00:08:55,950 --> 00:08:59,530
Og det er ikke.

158
00:08:59,530 --> 00:09:05,780
Så pset 0, bør du fyre har alle
implementeret noget ved hjælp af scratch.

159
00:09:05,780 --> 00:09:13,100
Og vi har lært nogle grundlæggende programmering
byggeklodser ved hjælp af scratch.

160
00:09:13,100 --> 00:09:15,590
>> Så lad os tage et kig på nogle
af disse byggesten

161
00:09:15,590 --> 00:09:18,170
at lave et program op.

162
00:09:18,170 --> 00:09:20,570
Først er boolsk udtryk.

163
00:09:20,570 --> 00:09:24,540
Boolske udtryk er dem og
0'er eller noget, der har

164
00:09:24,540 --> 00:09:25,700
to mulige værdier.

165
00:09:25,700 --> 00:09:30,320
I dette tilfælde, sandt eller falsk,
til eller fra, og ja eller nej.

166
00:09:30,320 --> 00:09:35,390
Et eksempel på en enkel, meget enkel,
program, der bruger en boolesk

167
00:09:35,390 --> 00:09:39,140
udtryk heroppe.

168
00:09:39,140 --> 00:09:43,220
>> Så for at boolske udtryk til
være nyttigt, har vi booleske operatorer.

169
00:09:43,220 --> 00:09:48,920
Disse er operatører, der kan anvendes
at sammenligne visse værdier.

170
00:09:48,920 --> 00:09:52,820
Så vi har og eller ikke lig med, mindre
end eller lig med, større end eller

171
00:09:52,820 --> 00:09:55,130
lig med og mindre end
eller større end.

172
00:09:55,130 --> 00:09:59,060
Men disse operatører ikke er meget nyttigt
medmindre vi kan kombinere dem i

173
00:09:59,060 --> 00:10:00,320
forhold.

174
00:10:00,320 --> 00:10:04,370
>> Så gutter måske husker fra bunden
og fra din p indstiller, at vi

175
00:10:04,370 --> 00:10:05,400
havde betingelser.

176
00:10:05,400 --> 00:10:09,710
De er væsentlige, ligesom gafler i
logikken i dit program,

177
00:10:09,710 --> 00:10:12,670
udfører afhængigt af om
en betingelse er opfyldt.

178
00:10:12,670 --> 00:10:18,150
Så en af ​​de betingelser, som vi havde
brugt mange gange i dette kursus er den

179
00:10:18,150 --> 00:10:21,470
hvis, Else hvis, og Else forhold.

180
00:10:21,470 --> 00:10:24,060
>> Her er et eksempel på, hvordan
du kan bruge det.

181
00:10:24,060 --> 00:10:28,430
Er der nogen der kender forskellen mellem
bare brug, hvis udsagn alle

182
00:10:28,430 --> 00:10:32,530
vejen ned vers, hvis andet,
hvis og ellers kombineres?

183
00:10:32,530 --> 00:10:33,013
Ja?

184
00:10:33,013 --> 00:10:34,263
>> Publikum: [uhørligt].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> SPEAKER 1: Præcis.

187
00:10:42,160 --> 00:10:50,210
Så hvis jeg havde, hvis hele vejen ned dette
måde, selv hvis denne betingelse afkast

188
00:10:50,210 --> 00:10:52,800
sandt, vil det stadig fortsætte
teste næste to.

189
00:10:52,800 --> 00:11:00,120
Henviser til, at med en ellers-hvis en anden
erklæring, hvis man returnerer true,

190
00:11:00,120 --> 00:11:02,640
de andre er ikke testet.

191
00:11:02,640 --> 00:11:05,955
Eventuelle spørgsmål om det?

192
00:11:05,955 --> 00:11:06,890
Fedt.

193
00:11:06,890 --> 00:11:12,240
>> Så du bruger en if-else af et andet
erklæring, hvis du ved, at det kun kan

194
00:11:12,240 --> 00:11:14,470
være en af ​​disse sager.

195
00:11:14,470 --> 00:11:21,550
Så vi ved hvis x er mindre end 0, er det
absolut ikke vil være

196
00:11:21,550 --> 00:11:22,890
større end 0.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> Dernæst anden byggeblok
at vi har lært er sløjfer.

199
00:11:31,480 --> 00:11:33,310
Vi har tre typer af løkker.

200
00:11:33,310 --> 00:11:35,830
For loops, mens løkker,
og gøre, mens sløjfer.

201
00:11:35,830 --> 00:11:38,730
Og generelt, når du sætter dig ned til
skrive noget, er du nødt til at beslutte,

202
00:11:38,730 --> 00:11:40,060
hvilken af ​​de tre, du vil bruge.

203
00:11:40,060 --> 00:11:41,900
Så hvordan kan vi afgøre, hvilken en?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> Vi bruger generelt en for-løkke, hvis vi kender
hvor mange gange vi ønsker at gentage

206
00:11:48,790 --> 00:11:53,650
gennem noget eller hvor mange gange
vi ønsker at udføre en opgave.

207
00:11:53,650 --> 00:11:58,830
Vi bruger mens sløjfer, hvis vi har brug for nogle
betingelse at være sandt at holde kørende.

208
00:11:58,830 --> 00:12:03,730
Og vi bruger gøre, mens meget lig
stykke tid, men vi ønsker, at vores kode til at køre på

209
00:12:03,730 --> 00:12:04,880
mindst én gang.

210
00:12:04,880 --> 00:12:09,410
>> Så gør samtidig, hvad der er i den gør, vil
altid køre mindst én gang.

211
00:12:09,410 --> 00:12:13,120
Ud over at det stykke tid, det
må ikke køre på alle, hvis det

212
00:12:13,120 --> 00:12:15,490
betingelse er ikke opfyldt.

213
00:12:15,490 --> 00:12:16,740
Eventuelle spørgsmål med det?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> Så struktur af en for-løkke.

216
00:12:22,860 --> 00:12:23,620
Du fyre har alle set dette.

217
00:12:23,620 --> 00:12:25,320
Du formatere det.

218
00:12:25,320 --> 00:12:26,600
Du har en form for tilstand.

219
00:12:26,600 --> 00:12:32,340
Så for eksempel, kan vi initialisere
som for jeg lig 0.

220
00:12:32,340 --> 00:12:34,040
i er mindre end 10.

221
00:12:34,040 --> 00:12:35,442
Og jeg ++.

222
00:12:35,442 --> 00:12:39,010
Meget enkel, som vi har gjort.

223
00:12:39,010 --> 00:12:42,210
>> For et stykke tid løkke, på samme måde, du har
at have en vis form for initialisering,

224
00:12:42,210 --> 00:12:44,980
en slags tilstand, og
en slags opdatering.

225
00:12:44,980 --> 00:12:51,990
Så vi kan gennemføre vores for-løkke også
som en while-løkke bruger denne.

226
00:12:51,990 --> 00:12:56,000
Og på samme måde med en gør while-løkke,
vi måske have nogle initialisering,

227
00:12:56,000 --> 00:12:58,640
udføre noget, opdatere den, og
derefter kontrollere tilstanden.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> Så nu funktioner.

230
00:13:05,140 --> 00:13:06,460
Vi sætter det hele sammen.

231
00:13:06,460 --> 00:13:10,140
Vi vil måske skrive nogle
form for funktion.

232
00:13:10,140 --> 00:13:12,790
Fælles funktion, som du måske
har set allerede er vigtigste.

233
00:13:12,790 --> 00:13:13,770
Main er en funktion.

234
00:13:13,770 --> 00:13:16,160
Det har en returtype, int.

235
00:13:16,160 --> 00:13:18,470
Den har en funktion navn, vigtigste.

236
00:13:18,470 --> 00:13:20,810
Og det har argumenter, argc og argv.

237
00:13:20,810 --> 00:13:24,040
Så vigtigste er bare en funktion.

238
00:13:24,040 --> 00:13:27,230
>> Andre funktioner, du måske har brugt,
printf-- printf er en function--

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
Men disse ske at have været
gennemført for os ved

241
00:13:32,010 --> 00:13:33,270
en slags bibliotek.

242
00:13:33,270 --> 00:13:37,400
Hvis du fyre huske herunder
denne CS50.h biblioteket eller

243
00:13:37,400 --> 00:13:38,510
standard I / O-bibliotek.

244
00:13:38,510 --> 00:13:39,200
Ja, spørgsmål?

245
00:13:39,200 --> 00:13:41,610
>> PUBLIKUM: Er vigtigste lige iboende i C?

246
00:13:41,610 --> 00:13:44,740
Er det bare lidt [uhørligt]?

247
00:13:44,740 --> 00:13:47,370
>> SPEAKER 1: Spørgsmålet er
hvis vigtigste er iboende i ca.

248
00:13:47,370 --> 00:13:51,460
Og ja, alle funktioner
har en hovedfunktion.

249
00:13:51,460 --> 00:13:55,290
Det er slags nødvendig for computeren
at vide, hvor du skal starte

250
00:13:55,290 --> 00:13:55,993
kører koden.

251
00:13:55,993 --> 00:13:58,108
>> PUBLIKUM: Så du ville ikke [uhørligt]?

252
00:13:58,108 --> 00:13:59,480
>> SPEAKER 1: Nej

253
00:13:59,480 --> 00:14:00,760
Andre spørgsmål?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
Fedt.

256
00:14:04,770 --> 00:14:08,050
Så ligesom du kan bruge en funktion
der er skrevet til dig, kan du også

257
00:14:08,050 --> 00:14:10,380
skriv din egen funktion.

258
00:14:10,380 --> 00:14:17,050
Dette er en funktion, som nogen måske
har skrevet til beregne volumen

259
00:14:17,050 --> 00:14:18,395
af q, f.eks.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
Der er en tilbagevenden typen her, i dette tilfælde
int, vores funktion navn q og vores

262
00:14:29,500 --> 00:14:31,360
liste over parametre.

263
00:14:31,360 --> 00:14:34,550
>> Og bemærk, at du skal skrive data
type af den parameter, du vil

264
00:14:34,550 --> 00:14:38,660
bruge ellers funktionen ikke
vide, hvad slags

265
00:14:38,660 --> 00:14:41,650
parameter skal jeg acceptere.

266
00:14:41,650 --> 00:14:48,110
Så i dette tilfælde, vi ønsker
et heltal som vores input.

267
00:14:48,110 --> 00:14:50,390
Så hvorfor vi måske ønsker at bruge funktioner?

268
00:14:50,390 --> 00:14:52,800
>> Først og fremmest godt for organisationen.

269
00:14:52,800 --> 00:14:56,350
De hjælpe med at bryde op din kode i
mere organiseret bidder og gøre

270
00:14:56,350 --> 00:14:57,960
det lettere at læse.

271
00:14:57,960 --> 00:14:59,760
Forenkling.

272
00:14:59,760 --> 00:15:01,740
Det er godt for design.

273
00:15:01,740 --> 00:15:04,570
Når du læser et stykke kode
og den vigtigste funktion er virkelig,

274
00:15:04,570 --> 00:15:07,750
virkelig lang, kan det være sværere at
grund om, hvad der foregår.

275
00:15:07,750 --> 00:15:11,710
Så hvis du bryde det ned i funktioner,
det kan være lettere at læse.

276
00:15:11,710 --> 00:15:12,750
Og genbruge-evne.

277
00:15:12,750 --> 00:15:16,940
Hvis du har en bid af kode, der bliver
kaldet eller køre flere gange,

278
00:15:16,940 --> 00:15:20,690
i stedet for at omskrive denne kode 10 gange
i din primære funktion, kan du

279
00:15:20,690 --> 00:15:21,440
ønsker at genbruge det.

280
00:15:21,440 --> 00:15:25,740
Og så hver gang du skal bruge det
stykke kode, kalder funktionen.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> Så nu, hvis vi husker tilbage til bunden,
Vi talte også om nogle begreber,

283
00:15:35,380 --> 00:15:37,680
hvoraf den ene er trådning.

284
00:15:37,680 --> 00:15:41,120
Tråden er begrebet multiple
sekvenser kode

285
00:15:41,120 --> 00:15:43,040
udførelse på samme tid.

286
00:15:43,040 --> 00:15:47,490
Så tænke tilbage på dag ét, hvor David havde
du fyre tælle antallet af

287
00:15:47,490 --> 00:15:48,440
mennesker i lokalet.

288
00:15:48,440 --> 00:15:50,550
>> Væsentlige, hvad der foregik
på, er alle af jer var

289
00:15:50,550 --> 00:15:52,370
kører separate tråde.

290
00:15:52,370 --> 00:15:55,540
Og de tråde kom sammen
at få en slags svar.

291
00:15:55,540 --> 00:15:58,890
Ligeledes i Scratch, når du har
flere sprites, kan du

292
00:15:58,890 --> 00:16:01,070
har en kat og en hund.

293
00:16:01,070 --> 00:16:08,770
Og de ville være samtidigt
kører deres egne scripts.

294
00:16:08,770 --> 00:16:10,020
Det er et eksempel på gevind.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> Og det andet koncept, som var
indført i bunden var begivenheder.

297
00:16:18,000 --> 00:16:22,550
Og begivenheder er, når flere dele af
din kode kommunikere med hinanden.

298
00:16:22,550 --> 00:16:26,840
I Scratch, var dette, når du har brugt den
rundsendingskontrolnummer og Når jeg

299
00:16:26,840 --> 00:16:29,500
Modtag blokke.

300
00:16:29,500 --> 00:16:35,170
>> Og også i Problem Set 4, så vi
en lille smule af begivenheder så godt.

301
00:16:35,170 --> 00:16:38,250
I gutter kunne have brugt
den Gevent biblioteket.

302
00:16:38,250 --> 00:16:42,450
Og der var en funktion waitForClick
hvor du ventede

303
00:16:42,450 --> 00:16:44,300
for brugeren at klikke.

304
00:16:44,300 --> 00:16:47,870
Og dit klik, i dette tilfælde ville være
begivenheden og vente på klik er dit

305
00:16:47,870 --> 00:16:49,120
hændelseshandler.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> Og også hele køre dine psets
og arbejde på din psets, du

308
00:16:58,630 --> 00:17:01,920
kunne have været i kontakt med
nogle af disse kommandoer.

309
00:17:01,920 --> 00:17:05,579
Dette er, hvad du har skrevet i din
terminalvindue eller hvad vindue

310
00:17:05,579 --> 00:17:12,119
der viser op på din g redigere til,
væsentlige navigere din computer.

311
00:17:12,119 --> 00:17:19,440
>> Så for eksempel, LS lister
indholdet af en mappe.

312
00:17:19,440 --> 00:17:22,510
Gør mappe opretter en ny mappe.

313
00:17:22,510 --> 00:17:24,819
CD, skift bibliotek.

314
00:17:24,819 --> 00:17:28,400
RM, fjerne sletter en fil
eller en mappe.

315
00:17:28,400 --> 00:17:31,050
Og derefter fjerne mappe
fjerner en mappe.

316
00:17:31,050 --> 00:17:32,300
>> Publikum: [uhørligt]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> SPEAKER 1: Ja, selvfølgelig.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
Beklager, det spørgsmål var, hvis du
vil foreslå at sætte dette

321
00:17:46,040 --> 00:17:48,840
på bedrager ark.

322
00:17:48,840 --> 00:17:49,440
Det kunne hjælpe.

323
00:17:49,440 --> 00:17:51,490
Hvis du har plads, kan du sætte det på.

324
00:17:51,490 --> 00:17:56,170
Det er også bare generelt gode nok
at huske, fordi når du bruger den

325
00:17:56,170 --> 00:17:59,060
du måske bare ønsker at
har det udenad.

326
00:17:59,060 --> 00:18:02,750
Det vil gøre dit liv meget lettere.

327
00:18:02,750 --> 00:18:04,000
Har jeg besvare dit spørgsmål?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> Så nu har vi talt en lille smule
kort om biblioteker.

330
00:18:14,290 --> 00:18:18,570
Men de to vigtigste, at vi har været
hjælp hidtil i kurset er

331
00:18:18,570 --> 00:18:20,860
standard I / O og CS50.

332
00:18:20,860 --> 00:18:25,410
Hvilken slags ting er inkluderet
i standard I / O-bibliotek?

333
00:18:25,410 --> 00:18:28,410
>> Ja, så vidt vi har brugt printf.

334
00:18:28,410 --> 00:18:31,150
I CS50, har vi brugt GetInt
og getString.

335
00:18:31,150 --> 00:18:37,200
Og strengen datatype også sker
skal deklareres i denne CS50 bibliotek.

336
00:18:37,200 --> 00:18:40,250
Vi taler lidt mere i dybden om
hvordan biblioteker fungerer, og hvordan de

337
00:18:40,250 --> 00:18:41,870
interagere med resten af ​​din kode.

338
00:18:41,870 --> 00:18:46,220
Men det er de to vigtigste, at vi
være kommet i kontakt med så langt i

339
00:18:46,220 --> 00:18:48,430
kurset.

340
00:18:48,430 --> 00:18:50,050
>> Typer.

341
00:18:50,050 --> 00:18:58,120
Disse er gode til at huske hvor meget
hver type er repræsenteret ved eller hvordan

342
00:18:58,120 --> 00:19:02,840
mange byte hver type requires--

343
00:19:02,840 --> 00:19:04,990
int, 4 byte; char, 1 byte.

344
00:19:04,990 --> 00:19:06,550
Float er 4 byte.

345
00:19:06,550 --> 00:19:07,782
Hvad er en dobbelt?

346
00:19:07,782 --> 00:19:09,032
>> Publikum: [uhørligt].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> SPEAKER 1: Ja, så en svømmer
men dobbelt størrelse.

349
00:19:16,240 --> 00:19:17,150
Hvad med en lang?

350
00:19:17,150 --> 00:19:18,400
>> Publikum: [uhørligt].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> SPEAKER 1: OK.

353
00:19:24,680 --> 00:19:25,410
Hvad er en lang?

354
00:19:25,410 --> 00:19:26,660
>> Publikum: [uhørligt].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> SPEAKER 1: Ja, det dobbelte en int.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
Ja.

359
00:19:34,705 --> 00:19:36,100
>> Publikum: [uhørligt].

360
00:19:36,100 --> 00:19:38,030
>> SPEAKER 1: Lang [uhørligt].

361
00:19:38,030 --> 00:19:41,860
Og så en lang lang er det dobbelte.

362
00:19:41,860 --> 00:19:42,814
>> PUBLIKUM: Nej, nej.

363
00:19:42,814 --> 00:19:47,107
En lang er blot en int.

364
00:19:47,107 --> 00:19:50,910
Det afhænger af arkitekturen
før [uhørligt]

365
00:19:50,910 --> 00:19:52,922
og int har samme størrelse.

366
00:19:52,922 --> 00:19:54,172
[Uhørligt].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> SPEAKER 1: Så en lang og
en int er de samme.

369
00:20:00,920 --> 00:20:02,943
Og så en lang lang
er dobbelt int.

370
00:20:02,943 --> 00:20:03,910
Fedt.

371
00:20:03,910 --> 00:20:05,550
Og så, hvad der er den sidste type?

372
00:20:05,550 --> 00:20:06,510
>> Publikum: Pointer.

373
00:20:06,510 --> 00:20:10,350
>> SPEAKER 1: Ja, så vi lærte
lidt om pointere.

374
00:20:10,350 --> 00:20:14,015
Og uanset hvad en pointer er
peger til-- det kunne være en char stjerne

375
00:20:14,015 --> 00:20:15,880
eller en int star--

376
00:20:15,880 --> 00:20:20,530
det er altid 4 bytes for en pointer.

377
00:20:20,530 --> 00:20:21,633
Spørgsmål om det?

378
00:20:21,633 --> 00:20:22,116
Ja?

379
00:20:22,116 --> 00:20:24,531
>> Publikum: [uhørligt]?

380
00:20:24,531 --> 00:20:29,530
>> SPEAKER 1: Så en lang og en int er
den samme i denne CS50 apparatet.

381
00:20:29,530 --> 00:20:32,302
>> PUBLIKUM: Apparatet er helt
udskiftelige.

382
00:20:32,302 --> 00:20:33,510
>> SPEAKER 1: Ja.

383
00:20:33,510 --> 00:20:36,610
Så en lang lang er dobbelt en int.

384
00:20:36,610 --> 00:20:39,250
>> PUBLIKUM: Dette er den 32 bit?

385
00:20:39,250 --> 00:20:40,620
>> SPEAKER 1: 32 bit, ja.

386
00:20:40,620 --> 00:20:43,572
>> PUBLIKUM: Så [uhørligt]?

387
00:20:43,572 --> 00:20:46,790
>> SPEAKER 1: Ja, hvis det ikke gør
udtrykkeligt siger, du

388
00:20:46,790 --> 00:20:47,870
bør påtage sig en 32 bit.

389
00:20:47,870 --> 00:20:50,040
>> PUBLIKUM: Det vil sige noget
som antager en

390
00:20:50,040 --> 00:20:51,498
arkitektur ligesom apparatet.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
For 64 bit, de eneste ting,
forandring er længes og henvisninger.

393
00:21:01,710 --> 00:21:05,614
De har begge [uhørligt].

394
00:21:05,614 --> 00:21:06,590
>> SPEAKER 1: Ja?

395
00:21:06,590 --> 00:21:07,566
>> Publikum: Spørgsmål.

396
00:21:07,566 --> 00:21:10,982
Så på den ene af de praksis quizzer,
den beder om en usigneret int.

397
00:21:10,982 --> 00:21:15,374
Så hvordan ville det bestemmes
fra en int [uhørligt]?

398
00:21:15,374 --> 00:21:18,140
>> SPEAKER 1: en usigneret
i er også 4 byte.

399
00:21:18,140 --> 00:21:21,172
Men hvad er anderledes ved en underskrevet
int og en unsigned int?

400
00:21:21,172 --> 00:21:22,422
>> Publikum: [uhørligt].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> SPEAKER 1: Højre.

403
00:21:25,630 --> 00:21:27,570
Man kan repræsentere negative værdier.

404
00:21:27,570 --> 00:21:28,580
Men hvordan gør den det?

405
00:21:28,580 --> 00:21:30,536
>> Publikum: [uhørligt].

406
00:21:30,536 --> 00:21:36,370
>> SPEAKER 1: Ja, det sparer 1
bit til at repræsentere tegn.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
Den underskrevne har én bit,
repræsenterer tegn.

409
00:21:45,040 --> 00:21:48,886
Og usigneret bare er alle positive.

410
00:21:48,886 --> 00:21:50,365
>> Publikum: OK.

411
00:21:50,365 --> 00:21:54,230
Så du siger, at en dobbelt er
to gange størrelsen af ​​en flyder?

412
00:21:54,230 --> 00:21:58,202
>> SPEAKER 1: Dobbelt er dobbelt
på størrelse med en float, ja.

413
00:21:58,202 --> 00:22:01,639
>> Publikum: Hvordan virker en pegepind
til en lang lang [uhørligt]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> SPEAKER 1: Så spørgsmålet er hvordan gør
markøren til en lang long--

416
00:22:10,870 --> 00:22:13,800
Hvordan er det kun fire byte, når man
en lang lang sine 8 byte.

417
00:22:13,800 --> 00:22:17,310
Så husk hvad er en pointer,
det væsentlige i det basisværdi.

418
00:22:17,310 --> 00:22:19,046
>> Publikum: [uhørligt].

419
00:22:19,046 --> 00:22:22,670
>> SPEAKER 1: Ja, så en pegepind
er blot en hukommelse.

420
00:22:22,670 --> 00:22:28,040
Så det er ligegyldigt, hvor meget plads
at pointeren peger på.

421
00:22:28,040 --> 00:22:32,060
Det behøver kun 4 byte til at holde styr
af denne hukommelse.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
Andre spørgsmål?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
Fedt.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> Så det sidste, jeg har
er standard output.

428
00:22:47,460 --> 00:22:51,020
Du skal bruge dem ofte
nok, at du kan huske.

429
00:22:51,020 --> 00:22:54,800
Men det er, når vi bruger
printf, f.eks.

430
00:22:54,800 --> 00:22:59,260
Og vi har disse pladsholdere,
blev kaldt format koder.

431
00:22:59,260 --> 00:23:03,910
>> Så procent C char procent i for int,
og vi kan også bruge procent d.

432
00:23:03,910 --> 00:23:05,130
Det er den samme ting.

433
00:23:05,130 --> 00:23:08,200
Men generelt, i CS50 vi
forsøger at bruge procent i.

434
00:23:08,200 --> 00:23:09,860
Procent f float.

435
00:23:09,860 --> 00:23:15,620
Procent ld for lang lang og
procent s for streng.

436
00:23:15,620 --> 00:23:18,550
>> Ligeledes har vi brugt et par
af disse escape-sekvenser.

437
00:23:18,550 --> 00:23:22,431
For eksempel backslash n for ny linje.

438
00:23:22,431 --> 00:23:26,910
Dette er blot for, når du formaterer
din kode til print f.

439
00:23:26,910 --> 00:23:27,260
Ja?

440
00:23:27,260 --> 00:23:28,906
>> Publikum: Hvad er procent d efter?

441
00:23:28,906 --> 00:23:31,850
>> SPEAKER 1: Så spørgsmålet
er, hvad der er procent d efter?

442
00:23:31,850 --> 00:23:33,270
Procent d er for ints.

443
00:23:33,270 --> 00:23:37,392
Procent d og procent i er den samme.

444
00:23:37,392 --> 00:23:41,130
>> Publikum: Hvad er forskellen mellem
backslash n og backslash r?

445
00:23:41,130 --> 00:23:45,300
>> SPEAKER 1: Så spørgsmålet er, hvad er
Forskellen mellem slør n og

446
00:23:45,300 --> 00:23:48,615
modreaktion r?

447
00:23:48,615 --> 00:23:50,906
Jeg tror backslash R er--

448
00:23:50,906 --> 00:23:54,340
>> PUBLIKUM: Så backslash r bare indebærer
vender tilbage til begyndelsen af ​​linjen

449
00:23:54,340 --> 00:23:56,670
uden faktisk at gå til en ny linje.

450
00:23:56,670 --> 00:24:01,000
Så hvis du udskriver en backslash R og du
gå tilbage til begyndelsen af ​​linjen

451
00:24:01,000 --> 00:24:04,005
så du udskriver flere ting, du overskriver
de ting, der allerede er på

452
00:24:04,005 --> 00:24:04,390
[Uhørligt].

453
00:24:04,390 --> 00:24:06,725
Betragtninger, n faktisk går til en ny
linje og går til [uhørligt].

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> SPEAKER 1: Jamen, alle andre spørgsmål?

456
00:24:13,915 --> 00:24:15,430
Okay.

457
00:24:15,430 --> 00:24:18,617
Jeg har tænkt mig at aflevere det ud til
Dan, som vil fortsætte.

458
00:24:18,617 --> 00:24:25,078
>> [Applaus]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN: All righty.

461
00:25:09,720 --> 00:25:18,590
Så jeg vil tale om en anden bred
vifte af idéer fra den klasse, der er

462
00:25:18,590 --> 00:25:23,220
groft repræsentant for uge to og
starten af ​​uge tre starter ud

463
00:25:23,220 --> 00:25:28,690
med støbning, der er bare en måde at
behandling af en værdi af en bestemt type, som

464
00:25:28,690 --> 00:25:30,830
en værdi af en anden type.

465
00:25:30,830 --> 00:25:34,110
Så vi kan gøre dette med tegn til
int'er, flåd til int'er, og

466
00:25:34,110 --> 00:25:35,360
lange længes til det dobbelte.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> Alle disse ting kan bruges som måder
til behandling af nogle numeriske værdi

469
00:25:44,500 --> 00:25:48,370
minus char som nogle andre
numerisk værdi.

470
00:25:48,370 --> 00:25:54,480
Så der er nogle problemer med dette, af
kursus, som kommer, når du kaster

471
00:25:54,480 --> 00:25:57,860
ting som float til int'er.

472
00:25:57,860 --> 00:26:00,500
Så det er lidt underligt.

473
00:26:00,500 --> 00:26:03,170
Vi har en svømmer, som er 1,31.

474
00:26:03,170 --> 00:26:05,220
Vi formere den ved 10.000.

475
00:26:05,220 --> 00:26:08,380
Og så skal vi udskrive det som en int.

476
00:26:08,380 --> 00:26:09,630
Hvad betyder dette output?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10.000 gange 1,31.

479
00:26:14,020 --> 00:26:18,761
Så 13.000, er, at gætte?

480
00:26:18,761 --> 00:26:20,685
>> Publikum: Jeg tror, ​​det er 10.000.

481
00:26:20,685 --> 00:26:24,234
>> DAN: Så jeg multiplicere det med 10.000
før jeg kaster den.

482
00:26:24,234 --> 00:26:25,202
>> Publikum: Oh.

483
00:26:25,202 --> 00:26:27,622
Ville der ikke være en 9
og nogle 0 tal?

484
00:26:27,622 --> 00:26:29,270
>> DAN: Du har måske nogle underlige cifre.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
Så lige, det er 1,3 gange 10.000.

487
00:26:37,670 --> 00:26:40,040
Så det er 13.000.

488
00:26:40,040 --> 00:26:41,313
Og denne ekstra weird--

489
00:26:41,313 --> 00:26:42,160
>> Publikum: 13.100.

490
00:26:42,160 --> 00:26:42,650
>> DAN: 13.100.

491
00:26:42,650 --> 00:26:44,910
Tak, Rob.

492
00:26:44,910 --> 00:26:46,610
Og denne ekstra weirdness--

493
00:26:46,610 --> 00:26:48,060
dette 9,9--

494
00:26:48,060 --> 00:26:53,860
er simpelthen fordi denne støbning
endte afrunding hvor

495
00:26:53,860 --> 00:26:55,394
det bør ikke have.

496
00:26:55,394 --> 00:26:55,871
Ja.

497
00:26:55,871 --> 00:26:58,256
>> PUBLIKUM: Støbningen sker
efter noget andet?

498
00:26:58,256 --> 00:27:03,865
>> DAN: Så fordi jeg har dette på tryk, det
gør denne multiplikation, før det

499
00:27:03,865 --> 00:27:05,230
gør denne støbning.

500
00:27:05,230 --> 00:27:06,140
>> Publikum: [uhørligt].

501
00:27:06,140 --> 00:27:11,350
>> DAN: Jeg tror, ​​det ville kaste først,
yeah, hvilket ville være 10.000.

502
00:27:11,350 --> 00:27:12,610
Noget andet?

503
00:27:12,610 --> 00:27:13,330
Fedt.

504
00:27:13,330 --> 00:27:16,344
Så dette er 13.099.

505
00:27:16,344 --> 00:27:17,840
Hvorfor sker det?

506
00:27:17,840 --> 00:27:18,900
Unøjagtighed.

507
00:27:18,900 --> 00:27:21,020
>> Flydere er ikke perfekte.

508
00:27:21,020 --> 00:27:27,550
De kan kun repræsentere tal til en
vist antal betydende cifre.

509
00:27:27,550 --> 00:27:35,120
Så hvis vi udskrive 8 signa figner på
denne float, får vi en slags

510
00:27:35,120 --> 00:27:36,800
grimme leder nummer.

511
00:27:36,800 --> 00:27:45,580
Og det er fordi 1,31 kan ikke præcist
være repræsenteret ved simpel

512
00:27:45,580 --> 00:27:49,000
beføjelser to i maskinen.

513
00:27:49,000 --> 00:27:53,530
Så det ender med at tage den nærmeste
gætte, der ender

514
00:27:53,530 --> 00:27:55,710
være lidt lav.

515
00:27:55,710 --> 00:27:57,730
Mening?

516
00:27:57,730 --> 00:27:59,110
OK.

517
00:27:59,110 --> 00:28:05,840
>> Nu tændes er en anderledes måde at
gør betingede sætninger, hvor alle

518
00:28:05,840 --> 00:28:09,900
vi interesserer os er en enkelt variabel.

519
00:28:09,900 --> 00:28:16,570
Så i dette eksempel, er vi
få et helt tal fra brugeren.

520
00:28:16,570 --> 00:28:21,070
Og så ser vi på
hvad det er heltallet.

521
00:28:21,070 --> 00:28:23,500
Formentlig er det antal
mellem én og fire.

522
00:28:23,500 --> 00:28:24,800
Det er, hvad vi beder om.

523
00:28:24,800 --> 00:28:28,450
>> Så du gør en switch af
variabelnavnet.

524
00:28:28,450 --> 00:28:34,290
Så kan du oprette tilfælde af mulig
værdier, det kunne være.

525
00:28:34,290 --> 00:28:37,730
Så tilfælde man siger det er lavt.

526
00:28:37,730 --> 00:28:41,080
Og så bryder du at komme ud
af switch tilstand,

527
00:28:41,080 --> 00:28:43,270
du ikke holde ud.

528
00:28:43,270 --> 00:28:44,830
>> I næste case--

529
00:28:44,830 --> 00:28:46,940
så tilfælde to og sag three--

530
00:28:46,940 --> 00:28:51,920
hvis det er tilfældet to det bare falder ned til
den første linje kode det opfatter som med

531
00:28:51,920 --> 00:28:55,400
case tre, indtil den ser en pause.

532
00:28:55,400 --> 00:29:00,430
Så grunden til at du får tilfælde en til
kun udskrive lav er fordi jeg

533
00:29:00,430 --> 00:29:01,890
har denne pause her.

534
00:29:01,890 --> 00:29:05,360
Hvis jeg, siger, ignoreret dette break--
hvis jeg kastede denne breakaway--

535
00:29:05,360 --> 00:29:09,740
det vil trykke lav, og det ville
udskrive midten, og så ville det gå i stykker.

536
00:29:09,740 --> 00:29:12,200
>> Så pauser er en vigtig del
af skifte betingelser og

537
00:29:12,200 --> 00:29:14,340
de skal være der.

538
00:29:14,340 --> 00:29:20,070
Eventuelle sager, der ikke udtrykkeligt nævnt
håndteres af standard

539
00:29:20,070 --> 00:29:26,645
tilfældet i kontakten og skal kastes.

540
00:29:26,645 --> 00:29:31,363
>> PUBLIKUM: Så 1, 2, 3,
og 4 vil være n?

541
00:29:31,363 --> 00:29:33,310
>> DAN: Værdier, n kan være.

542
00:29:33,310 --> 00:29:34,654
Ja.

543
00:29:34,654 --> 00:29:35,146
Ja?

544
00:29:35,146 --> 00:29:37,606
>> PUBLIKUM: Så når du har
at [uhørligt]?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> DAN: Du ville udskrive lavt, og derefter
det ville udskrive midten, og

547
00:29:46,830 --> 00:29:47,400
så ville det bryde.

548
00:29:47,400 --> 00:29:50,244
>> Publikum: Hvorfor skulle udskrives
midten, hvis [uhørligt]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> DAN: Så alt under en sag
før en pause falder ind under.

551
00:30:00,550 --> 00:30:09,390
Så tilfælde en udskrift er nedenunder sag
en som er det følgende print.

552
00:30:09,390 --> 00:30:09,890
Ja?

553
00:30:09,890 --> 00:30:11,140
>> Publikum: [uhørligt]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> DAN: Så dette nummer er blot et særligt
værdi, at denne variabel

556
00:30:22,170 --> 00:30:23,420
kan tage, ikke?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
Giver det mening?

559
00:30:28,490 --> 00:30:28,990
Ja.

560
00:30:28,990 --> 00:30:31,490
>> Publikum: [uhørligt]?

561
00:30:31,490 --> 00:30:34,130
>> DAN: Ja, sag to ville udskrive
midten og derefter bryde.

562
00:30:34,130 --> 00:30:35,380
>> Publikum: [uhørligt]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> DAN: Jeg tror nogen?

565
00:30:40,050 --> 00:30:43,855
Hvilke andre datatyper
kan du skifte over?

566
00:30:43,855 --> 00:30:46,320
>> Publikum: Du kan skifte
i forhold til eventuelle datatyper.

567
00:30:46,320 --> 00:30:50,905
Men det betyder kun noget over tegn
og int'er og den slags, da

568
00:30:50,905 --> 00:30:55,600
hvis du skifter over en pegepind
der ikke rigtig mening,

569
00:30:55,600 --> 00:30:59,555
skifte over belastninger, hvis det endda lad os
du gør det, på grund af floating point

570
00:30:59,555 --> 00:31:02,840
i præcision, ville du ikke rigtig
ønsker at gøre det alligevel.

571
00:31:02,840 --> 00:31:07,320
Så temmelig meget, blot int'er og
tegn og den slags.

572
00:31:07,320 --> 00:31:12,360
>> DAN: Ja, det er, når du har eksplicit
værdier, som du ved, jeg tror, ​​kan være

573
00:31:12,360 --> 00:31:14,250
at en switch er faktisk nyttigt.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
Godt?

576
00:31:18,990 --> 00:31:21,370
OK.

577
00:31:21,370 --> 00:31:26,180
>> Scope er det interval, en erklæret
variabel strækker sig.

578
00:31:26,180 --> 00:31:32,190
Så i denne lille bid af kode, jeg har,
det ville være fuld af fejl.

579
00:31:32,190 --> 00:31:41,450
Og årsagen er jeg erklærede denne int
I inden for omfanget af denne for-løkken.

580
00:31:41,450 --> 00:31:46,390
Og så prøver jeg at henvise til, at
Jeg uden for denne for-løkke rækkevidde.

581
00:31:46,390 --> 00:31:50,330
>> Så dybest set, kan du tænke rækkevidde
som noget, du erklære

582
00:31:50,330 --> 00:31:59,750
med inde i et sæt krøllede parenteser kun
eksisterer inden for disse krøllede parenteser.

583
00:31:59,750 --> 00:32:04,990
Og hvis du prøver og bruge denne variabel
uden for disse krøllede parenteser, vil du

584
00:32:04,990 --> 00:32:08,356
får en fejl fra compileren.

585
00:32:08,356 --> 00:32:08,812
Ja?

586
00:32:08,812 --> 00:32:09,724
>> PUBLIKUM: Så denne ene ikke virker?

587
00:32:09,724 --> 00:32:11,790
>> DAN: Det virker ikke, ja.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
Strenge.

590
00:32:18,660 --> 00:32:19,780
String en char *.

591
00:32:19,780 --> 00:32:22,250
De er nøjagtig det samme.

592
00:32:22,250 --> 00:32:25,540
De er blot pegepinde til tegn.

593
00:32:25,540 --> 00:32:33,000
Og alle strenge, som du har skulle ende
med omvendt skråstreg nul, hvilket er lige

594
00:32:33,000 --> 00:32:34,410
a c konvention.

595
00:32:34,410 --> 00:32:36,680
>> Det kaldes NULL terminator.

596
00:32:36,680 --> 00:32:39,050
Og NULL--

597
00:32:39,050 --> 00:32:41,670
hovedstad N, hovedstaden U, kapital
L, kapital jeg--

598
00:32:41,670 --> 00:32:44,290
er ikke det samme som det
NULL terminator.

599
00:32:44,290 --> 00:32:46,640
Dette er en pointer.

600
00:32:46,640 --> 00:32:48,280
Dette er et tegn.

601
00:32:48,280 --> 00:32:49,530
De er meget forskellige.

602
00:32:49,530 --> 00:32:50,200
Husk det.

603
00:32:50,200 --> 00:32:52,320
Det vil være på quizzen, sandsynligvis.

604
00:32:52,320 --> 00:32:54,040
Jeg har ikke set quizzen.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
Ja?

607
00:32:58,840 --> 00:33:01,232
>> PUBLIKUM: Så NULL er, siger, markøren?

608
00:33:01,232 --> 00:33:01,995
>> DAN: Ja.

609
00:33:01,995 --> 00:33:05,170
>> PUBLIKUM: Hvad betyder [uhørligt]?

610
00:33:05,170 --> 00:33:10,050
>> DAN: Hvis siger, er malloc kaldes, når du
ikke har nok hukommelse til at få

611
00:33:10,050 --> 00:33:14,400
uanset størrelse, du beder om,
malloc vil returnere NULL.

612
00:33:14,400 --> 00:33:19,550
Det er, dybest set, når en funktion er
formodes at returnere en pegepind, du

613
00:33:19,550 --> 00:33:22,600
nødt til at tjekke mod NUL fordi
NULL er en smuk god--

614
00:33:22,600 --> 00:33:25,260
det er, en slags, skraldet værdi.

615
00:33:25,260 --> 00:33:27,050
Det er et nul så langt som pejlemærker gå.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> Når du kalder en funktion,
der returnerer en pointer.

618
00:33:32,250 --> 00:33:35,960
Du vil ønsker at tjekke for at være
sikker på, at denne pointer er ikke NULL

619
00:33:35,960 --> 00:33:37,760
fordi NULL er meget almindeligt.

620
00:33:37,760 --> 00:33:40,160
Det er en slags skrald afkast.

621
00:33:40,160 --> 00:33:44,902
Så hvis noget ikke gå til højre,
bare returnere NULL i stedet.

622
00:33:44,902 --> 00:33:45,898
>> Publikum: [uhørligt]?

623
00:33:45,898 --> 00:33:48,922
>> DAN: Ja, og det er dette.

624
00:33:48,922 --> 00:33:51,750
>> Publikum: [uhørligt]?

625
00:33:51,750 --> 00:33:52,800
>> DAN: Stav det som dette.

626
00:33:52,800 --> 00:33:54,150
Det er NULL terminatoren.

627
00:33:54,150 --> 00:33:56,560
Det er små bogstaver N-U-L-L, hvis
du stave det.

628
00:33:56,560 --> 00:33:59,860
>> Publikum: Og jeg gik bare
tilbage og testede det.

629
00:33:59,860 --> 00:34:03,010
Og hvis du prøver at sætte et decimaltal
værdi ind i en switch, vil det råber på dig

630
00:34:03,010 --> 00:34:05,916
sagde erklæring kræver udtryk
af heltal type.

631
00:34:05,916 --> 00:34:07,166
>> DAN: Værsgo.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
Men ja, hvad var spørgsmålet igen?

634
00:34:12,246 --> 00:34:13,496
>> Publikum: [uhørligt]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> DAN: Så hovedstad N, hovedstaden U, kapital
L, kapital L er et virkeligt C ting.

637
00:34:23,679 --> 00:34:29,719
Det er NULL-pointer og vil
kun behandles som sådan.

638
00:34:29,719 --> 00:34:33,530
Du vil ikke nogensinde forsøge og stave
NULL karakter og se nogen

639
00:34:33,530 --> 00:34:35,630
anden måde end dette.

640
00:34:35,630 --> 00:34:36,610
Ja?

641
00:34:36,610 --> 00:34:42,490
>> PUBLIKUM: Så vender tilbage til char max eller
noget i noterne, ville det

642
00:34:42,490 --> 00:34:43,960
inkarnere den samme funktion
som [uhørligt]?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> PUBLIKUM: Så er du henviser til
returnering char max fra getchar, eller

645
00:34:54,949 --> 00:34:55,444
uanset hvad det er?

646
00:34:55,444 --> 00:34:55,940
>> Publikum: Ja.

647
00:34:55,940 --> 00:34:58,620
>> PUBLIKUM: Ja, så den generelle
betegnelse for alle disse ting

648
00:34:58,620 --> 00:34:59,920
er sentinel værdier.

649
00:34:59,920 --> 00:35:03,640
Så ligesom vender tilbage int max fra GetInt
og char max fra getchar, det er

650
00:35:03,640 --> 00:35:06,010
formodes at være ligesom, okay, hvis
disse ting vender tilbage til os,

651
00:35:06,010 --> 00:35:07,210
noget gik galt.

652
00:35:07,210 --> 00:35:09,950
>> For pegepinde, vi bare tilfældigvis har
denne sentinel værdi, at alle

653
00:35:09,950 --> 00:35:10,750
enig om.

654
00:35:10,750 --> 00:35:13,210
Og dette er den ting du vender tilbage
når tingene går galt.

655
00:35:13,210 --> 00:35:15,910
Så char max er hvad vi bruger
at repræsentere noget

656
00:35:15,910 --> 00:35:18,100
ligesom NULL eller getchar.

657
00:35:18,100 --> 00:35:23,420
>> PUBLIKUM: Så hvis du tester getchar,
kan du bare sætte NUL?

658
00:35:23,420 --> 00:35:23,910
Ville det gøre en forskel?

659
00:35:23,910 --> 00:35:25,400
>> DAN: Du kunne ikke lige tjekke NULL.

660
00:35:25,400 --> 00:35:30,130
Du er nødt til at kontrollere char max fordi
returværdi fra funktionen er

661
00:35:30,130 --> 00:35:35,416
et tegn ikke en pointer.

662
00:35:35,416 --> 00:35:35,888
Ja?

663
00:35:35,888 --> 00:35:38,248
>> Publikum: Dette spørgsmål spørger
efter strengen længde.

664
00:35:38,248 --> 00:35:40,136
Er der omfatter NULL karakter?

665
00:35:40,136 --> 00:35:41,000
>> DAN: Nej

666
00:35:41,000 --> 00:35:45,930
Og det er faktisk hvordan strenglængde
kender til at stoppe, fordi det går gennem

667
00:35:45,930 --> 00:35:49,070
Deres vifte af tegn, indtil
det ser en null-tegn.

668
00:35:49,070 --> 00:35:51,030
Og så er det ligesom, alle
Okay, jeg er færdig.

669
00:35:51,030 --> 00:35:52,130
>> Publikum: [uhørligt] fem?

670
00:35:52,130 --> 00:35:53,990
>> DAN: Hej ville være fem.

671
00:35:53,990 --> 00:35:55,240
Yep.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
Så arrays kontinuerlig
blokke af hukommelse.

674
00:36:02,880 --> 00:36:08,480
De har øjeblikkelig adgang ved at sige
navn på den array og derefter i krøllet

675
00:36:08,480 --> 00:36:16,720
seler, uanset indeks, du vil gå
at, de er indekseret fra nul til

676
00:36:16,720 --> 00:36:20,100
længden af ​​array minus 1.

677
00:36:20,100 --> 00:36:23,070
>> Og de er anmeldt af den type
ting, som du opbevaring i

678
00:36:23,070 --> 00:36:29,750
matrix, navnet på arrayet, og derefter
uanset størrelsen er af denne matrix.

679
00:36:29,750 --> 00:36:36,660
Så dette er en char array af længde
seks, der har disse værdier.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
Ja?

682
00:36:42,700 --> 00:36:43,950
>> Publikum: [uhørligt]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> DAN: Ja.

685
00:36:48,460 --> 00:36:51,340
>> Publikum: [uhørligt]?

686
00:36:51,340 --> 00:36:56,700
>> DAN: Hvis du har, hvad der foregår
i array allerede.

687
00:36:56,700 --> 00:37:02,260
Så du kan specificere dette i stedet som,
sige, fjeldørred, uanset navnet på din

688
00:37:02,260 --> 00:37:12,200
array er tomme parenteser lig krøllet
afstive H komma E komma L komma L komma

689
00:37:12,200 --> 00:37:16,290
O komma NULL karakter
og krøllet parentes.

690
00:37:16,290 --> 00:37:18,180
Det ville også virke som en erklæring.

691
00:37:18,180 --> 00:37:20,886
>> Publikum: [uhørligt]?

692
00:37:20,886 --> 00:37:23,110
>> DAN: Så skal du have
størrelse allerede.

693
00:37:23,110 --> 00:37:23,896
>> Publikum: [uhørligt]?

694
00:37:23,896 --> 00:37:25,146
>> DAN: Ja.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
Alle righty.

697
00:37:32,420 --> 00:37:36,430
Kommandolinjeargumenter er en måde at
få input fra brugeren som

698
00:37:36,430 --> 00:37:39,380
argumenter til main.

699
00:37:39,380 --> 00:37:40,600
Vigtigste tager to argumenter.

700
00:37:40,600 --> 00:37:47,680
Antallet af argumenter, der bliver
føres langs kommandolinjen og en

701
00:37:47,680 --> 00:37:55,340
streng vektor eller et strengtabel
af alle de argumenter.

702
00:37:55,340 --> 00:38:07,840
>> Så hvis jeg, siger, kaldes en funktion, såsom
en prik ud 1 rum, 2 rum, tre,

703
00:38:07,840 --> 00:38:10,110
argc ville være 4.

704
00:38:10,110 --> 00:38:17,370
Og argv 0 ville være en prik ud.

705
00:38:17,370 --> 00:38:19,130
Argv1 ville være 1.

706
00:38:19,130 --> 00:38:23,030
argv2 ville være 2. argv3 ville være
3, i dette særlige tilfælde.

707
00:38:23,030 --> 00:38:23,310
Ja?

708
00:38:23,310 --> 00:38:25,400
>> Publikum: [uhørligt]?

709
00:38:25,400 --> 00:38:34,010
>> DAN: Det sidste element i array
fordi array er længden argc plus

710
00:38:34,010 --> 00:38:41,050
en af ​​arqB, det sidste element
er NULL-pointer.

711
00:38:41,050 --> 00:38:42,580
Det er argc plus 1.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
Så i tilfælde af, at jeg lige har sagt, det
ville blive argv 0 er en prik ud.

714
00:38:52,150 --> 00:38:56,330
argv 1 er 1. argv2 er 2. argv 3 er 3.

715
00:38:56,330 --> 00:39:03,490
argv 4, der er en større
end argc ville være NULL.

716
00:39:03,490 --> 00:39:04,870
>> Og det er NULL-pointer.

717
00:39:04,870 --> 00:39:06,590
Ja.

718
00:39:06,590 --> 00:39:11,250
Og det er fordi strengen er
en char stjerne er en pointer.

719
00:39:11,250 --> 00:39:14,102
Så det skal være den samme type.

720
00:39:14,102 --> 00:39:14,595
Ja?

721
00:39:14,595 --> 00:39:16,074
>> Publikum: To spørgsmål.

722
00:39:16,074 --> 00:39:21,004
Så man, hvad er forskellen mellem
denne og andre end én type getString

723
00:39:21,004 --> 00:39:22,483
i brugerens motor?

724
00:39:22,483 --> 00:39:25,934
Og to, gemmes i
Deres seneste hukommelse?

725
00:39:25,934 --> 00:39:28,399
Så ligesom, getString ville
være [uhørligt]?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN: Hvor er det opbevares?

728
00:39:33,650 --> 00:39:34,905
Jeg ved ikke, hvor den er gemt.

729
00:39:34,905 --> 00:39:40,000
>> PUBLIKUM: Så faktisk, du ved, hvordan nogen
funktion, du kalder det er argumenter

730
00:39:40,000 --> 00:39:42,170
gemmes i stakken?

731
00:39:42,170 --> 00:39:46,610
Så argc og argv er argumenter til main
og de er på stakken, eller virkelig

732
00:39:46,610 --> 00:39:49,131
lige over, hvad du mener som
starten af ​​stakken.

733
00:39:49,131 --> 00:39:53,490
Hvad var den anden del
af spørgsmålet?

734
00:39:53,490 --> 00:39:56,821
>> PUBLIKUM: Så hvad er [uhørligt]?

735
00:39:56,821 --> 00:40:00,990
>> DAN: Ja, det er bare en anden måde
for at få input fra brugeren.

736
00:40:00,990 --> 00:40:06,030
Denne ene er lidt mere effektiv og
det er mere handy for scripts, fordi du

737
00:40:06,030 --> 00:40:10,070
kan bare passere argumenter til din primære
funktion snarere end at skulle vente

738
00:40:10,070 --> 00:40:13,400
for brugere, hvis du ikke har nogen brugere.

739
00:40:13,400 --> 00:40:16,280
>> PUBLIKUM: Og ja, få strygere
ville være [uhørligt].

740
00:40:16,280 --> 00:40:17,922
Det ville gemme de ting, du har brug for.

741
00:40:17,922 --> 00:40:18,834
>> DAN: Ja?

742
00:40:18,834 --> 00:40:21,114
>> Publikum: [uhørligt]?

743
00:40:21,114 --> 00:40:27,545
>> DAN: Ja, argv 0 altid omfatter
prik skråstreg af funktionen opkald.

744
00:40:27,545 --> 00:40:28,042
Ja?

745
00:40:28,042 --> 00:40:29,292
>> Publikum: [uhørligt]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> DAN: Ja, hver af argumenterne er
endte i null-tegn, fordi de

748
00:40:37,310 --> 00:40:38,310
er strenge.

749
00:40:38,310 --> 00:40:40,892
>> Publikum: [uhørligt]?

750
00:40:40,892 --> 00:40:44,116
>> DAN: Ja, argv argc er en NULL-pointer.

751
00:40:44,116 --> 00:40:45,112
>> Publikum: [uhørligt]?

752
00:40:45,112 --> 00:40:47,104
>> DAN: Oh yeah.

753
00:40:47,104 --> 00:40:48,100
Ja, undskyld.

754
00:40:48,100 --> 00:40:49,594
>> PUBLIKUM: Så [uhørligt]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> DAN: Så spørgsmålet er, hvis du havde
kommandolinje prik skråstreg en prik ud 1, 2,

757
00:41:16,340 --> 00:41:20,410
ville antallet af kommandolinjen
argumenter være to eller ville det være tre?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> PUBLIKUM: Jeg tror det ikke
virkelig ligegyldigt.

760
00:41:28,240 --> 00:41:31,370
Jeg plejer at sige, åh, du ikke passere
eventuelle kommandolinjeargumenter når

761
00:41:31,370 --> 00:41:32,730
selvfølgelig, du kaldte funktionen.

762
00:41:32,730 --> 00:41:37,950
Så jeg har en tendens til vokalt udelukke
funktion fra kommandolinjen

763
00:41:37,950 --> 00:41:40,350
argumenter, selvom det er
inkluderet i argv.

764
00:41:40,350 --> 00:41:42,600
>> DAN: Men hvis det var på test--

765
00:41:42,600 --> 00:41:46,550
yeah-- og også hvis du siger noget
ligesom argc lig med 3,

766
00:41:46,550 --> 00:41:48,512
du er i sikker stående.

767
00:41:48,512 --> 00:41:49,416
Ja?

768
00:41:49,416 --> 00:41:50,666
>> Publikum: [uhørligt]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> DAN: Jeg tror, ​​at hvis stedet for at kalde dette
i argc og string argv parentes

771
00:42:09,510 --> 00:42:14,350
men holdt de samme typer og blot kaldes
dem noget andet som en

772
00:42:14,350 --> 00:42:16,640
og B, ville det stadig arbejde?

773
00:42:16,640 --> 00:42:18,790
Og det ville stadig arbejde,
du ville bare--

774
00:42:18,790 --> 00:42:21,520
stedet for at bruge argc--
du ville bruge a og b.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
Ja?

777
00:42:25,408 --> 00:42:26,658
>> Publikum: [uhørligt]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> DAN: Så spørgsmålet er getString er
skal opbevares hukommelse i bunke

780
00:42:38,850 --> 00:42:42,280
fordi getString er char *.

781
00:42:42,280 --> 00:42:47,530
Den gemmer hukommelse i den bunke, fordi det
Nu kalder malloc inden den faktiske

782
00:42:47,530 --> 00:42:49,258
implementering af getString.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
OK, bevæger sig på.

785
00:42:55,090 --> 00:42:55,950
>> Sikkerhed.

786
00:42:55,950 --> 00:43:01,090
Så for at være virkelig sikker, du stole på nogen
en, og du tillader ingen adgang til nogen

787
00:43:01,090 --> 00:43:04,540
af dine oplysninger, hvilket er grunden
alle bygger deres egne maskiner,

788
00:43:04,540 --> 00:43:09,580
deres egne styresystemer, alle deres
programmer fra bunden, og naturligvis

789
00:43:09,580 --> 00:43:13,410
ikke forbindelse til andre maskiner
via internettet.

790
00:43:13,410 --> 00:43:17,350
Så computere er usikre.

791
00:43:17,350 --> 00:43:19,200
De virkelig er.

792
00:43:19,200 --> 00:43:20,940
Vi er nødt til at stole på andre mennesker.

793
00:43:20,940 --> 00:43:26,500
>> Og tanken om at sikkerhed er, at du er
forsøger at begrænse mængden af

794
00:43:26,500 --> 00:43:27,540
tillid til, at du har brug for.

795
00:43:27,540 --> 00:43:32,080
Og et af de midler du gøre det
er gennem kryptering.

796
00:43:32,080 --> 00:43:34,950
Kryptografi er det væsentlige,
vi har hemmeligheder.

797
00:43:34,950 --> 00:43:38,880
>> Nogle gange er vi nødt til at passere vores hemmeligheder
sammen igennem, siger, internet eller

798
00:43:38,880 --> 00:43:39,980
andre ting.

799
00:43:39,980 --> 00:43:43,180
Og vi ønsker ikke folk
at kende disse hemmeligheder.

800
00:43:43,180 --> 00:43:50,100
Så vi kryptere vores hemmeligheder i en måde
at vi håber ingen kan regne ud.

801
00:43:50,100 --> 00:43:51,600
>> Så vi used--

802
00:43:51,600 --> 00:43:54,340
gennem løbet af denne klasse--

803
00:43:54,340 --> 00:44:00,750
ting som Cæsar cipher og
[Uhørlig], som begge er meget, meget

804
00:44:00,750 --> 00:44:03,200
usikre måder at kryptere ting.

805
00:44:03,200 --> 00:44:07,930
De er nemme at regne ud, hvad de
er, og hvad dine hemmeligheder er.

806
00:44:07,930 --> 00:44:12,130
Den virkelige verden bruger meget mere
komplicerede kryptering ordninger.

807
00:44:12,130 --> 00:44:13,880
Og vi vil ikke komme ind
meget mere end det.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> Debugging.

810
00:44:19,430 --> 00:44:20,785
GDB er bedst.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
Jeg har tænkt mig at understrege dette igen.

813
00:44:25,810 --> 00:44:30,920
Brug GDB hele tiden hver
gang du har et problem.

814
00:44:30,920 --> 00:44:36,030
Kommandoer, der er nyttige i GDB, er
knække, hvilket du passerer enten en linje

815
00:44:36,030 --> 00:44:41,330
nummer, en funktion navn, hovedsageligt
hvor i din kode du ønsker at stoppe,

816
00:44:41,330 --> 00:44:45,600
og være i stand til at tage kontrol.

817
00:44:45,600 --> 00:44:54,140
>> Udskriv tager en variabel og udskriver
hvad denne variabel er på dette

818
00:44:54,140 --> 00:44:55,990
punkt i din udførelse.

819
00:44:55,990 --> 00:45:00,130
Næste flytter din henrettelse
langs et trin.

820
00:45:00,130 --> 00:45:05,050
Og trin trin inde i en funktion
i din udførelse.

821
00:45:05,050 --> 00:45:10,480
>> Andre ting er kørt, som er, hvordan
du faktisk køre din kode.

822
00:45:10,480 --> 00:45:16,630
Fortsæt tager alle de nødvendige skridt
for at komme til næste knækpunkt.

823
00:45:16,630 --> 00:45:18,300
Og der er mange, mange andre.

824
00:45:18,300 --> 00:45:19,040
Slå dem op.

825
00:45:19,040 --> 00:45:19,901
De er store.

826
00:45:19,901 --> 00:45:20,863
Ja?

827
00:45:20,863 --> 00:45:22,113
>> Publikum: [uhørligt]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> DAN: Ja, der er en debugger.

830
00:45:28,200 --> 00:45:34,230
Så en debugger er et program,
lader dig debug dit program.

831
00:45:34,230 --> 00:45:39,931
Det er ikke et program, der finder fejl for
dig, ville dog, at være stor.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> Og sidst for mig er søgning.

834
00:45:46,040 --> 00:45:51,470
Så de typer af søgning, som vi talte
om i denne klasse er lineær søgning,

835
00:45:51,470 --> 00:45:55,960
der er bare, at man ser gennem hver
element i søgerummet, en

836
00:45:55,960 --> 00:46:00,410
element ad gangen, indtil du finder det
du leder efter, eller indtil du når

837
00:46:00,410 --> 00:46:03,350
slutningen af ​​din søgning rum, hvor
punkt du siger, at du ikke kunne finde

838
00:46:03,350 --> 00:46:06,360
det element, som du ledte efter.

839
00:46:06,360 --> 00:46:13,450
Og dette finder i bedste konstant tid,
der er 0 1 og i værste lineær

840
00:46:13,450 --> 00:46:16,070
tid, hvilket er 0 n.

841
00:46:16,070 --> 00:46:19,250
>> Binær søgning, som skal
beskidte elementer.

842
00:46:19,250 --> 00:46:24,230
Du går til midten af ​​dine elementer,
se, om det element, du leder efter

843
00:46:24,230 --> 00:46:30,120
er større eller mindre end bestanddelen
at du er på midten.

844
00:46:30,120 --> 00:46:36,510
Det er det større, siger du, at bunden
af din søgning plads er din

845
00:46:36,510 --> 00:46:41,550
aktuelle placering i midten,
og du genstarter processen.

846
00:46:41,550 --> 00:46:46,150
Hvis det er mindre, du ser sige
at det-- Ja, hvad sker der?

847
00:46:46,150 --> 00:46:47,400
>> Publikum: [uhørligt]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> DAN: Ja.

850
00:46:54,260 --> 00:46:58,360
Enhver form for sortering, der er blevet undervist i
klassen er fair spil til testen.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [Latter]

853
00:47:04,920 --> 00:47:10,260
>> DAN: Og det faktum, at du ikke har haft
at gøre det for et problem, sæt, det er fair

854
00:47:10,260 --> 00:47:12,420
spil til testen.

855
00:47:12,420 --> 00:47:15,186
>> Publikum: Kan vi gå over det, hvordan til--

856
00:47:15,186 --> 00:47:17,052
>> DAN: Det vil blive gået over.

857
00:47:17,052 --> 00:47:20,496
>> SPEAKER 2: Selve koden for
[Uhørligt] er på study.cs50.net.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
Så hvis du ser på praksis problemet
i fletningen slags side

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, der er koden
til gennemførelse fusionere slags.

861
00:47:35,880 --> 00:47:38,550
Så du behøver ikke nødt til at gennemføre
det selv i aften.

862
00:47:38,550 --> 00:47:42,090
Men sørg for at du forstår det snarere
end blot huske det.

863
00:47:42,090 --> 00:47:45,035
>> Publikum: [uhørligt]?

864
00:47:45,035 --> 00:47:49,720
>> SPEAKER 2: sammenfletning slags side
study.cs50.net, der er en praksis

865
00:47:49,720 --> 00:47:53,570
problem, hvis du klikker gennem
problem, til allersidst er der en

866
00:47:53,570 --> 00:47:56,280
løsning, som er sammenfletningen
sortere gennemførelse.

867
00:47:56,280 --> 00:47:58,510
Men sørg for at du forstår det
snarere end blot at huske det

868
00:47:58,510 --> 00:47:59,760
eller kopiere det ned.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> Publikum: Og et fuldgyldigt
problem for eksamen ville være

871
00:48:06,340 --> 00:48:07,990
noget lignende her er en liste.

872
00:48:07,990 --> 00:48:12,100
Hvad betyder denne liste se ud efter
et skridt af markeringer slags eller

873
00:48:12,100 --> 00:48:13,330
indsættelse sortere eller hvad.

874
00:48:13,330 --> 00:48:14,940
Et komplet iteration af listen.

875
00:48:14,940 --> 00:48:18,530
Så selvom du ikke ender med at skulle
kode til det, er du nødt til at forstå det

876
00:48:18,530 --> 00:48:20,440
nok til at vide, hvordan det går
at ændre dette array.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> DAN: Det er det for mig.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [Applaus]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: Hej alle.

883
00:49:07,410 --> 00:49:08,390
Mit navn er Lucas.

884
00:49:08,390 --> 00:49:16,840
Jeg har tænkt mig at tale om rekursion, alle
den slags, som vi har lært, og en

885
00:49:16,840 --> 00:49:18,050
lille smule af alle markører.

886
00:49:18,050 --> 00:49:18,740
OK?

887
00:49:18,740 --> 00:49:20,340
Så først og fremmest, rekursion.

888
00:49:20,340 --> 00:49:22,951
Hvad betyder det at sige, at
en funktion er rekursiv?

889
00:49:22,951 --> 00:49:24,675
>> Publikum: Kalder sig.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: OK, kalder sig selv, ja.

891
00:49:26,500 --> 00:49:27,700
Så ligesom dette billede, for eksempel.

892
00:49:27,700 --> 00:49:30,280
Det er som på billedet inde
af et billede og så videre.

893
00:49:30,280 --> 00:49:35,740
Så for eksempel, kan du have-- som Dan
der talte om binær søgning.

894
00:49:35,740 --> 00:49:41,840
En måde, hvorpå binær søgning er
rekursive er det faktum, at du er

895
00:49:41,840 --> 00:49:43,130
forsøger at finde et nummer.

896
00:49:43,130 --> 00:49:44,250
Så du går til midten.

897
00:49:44,250 --> 00:49:47,130
Og så skal du tjekke, om tallene dér
i venstre og højre.

898
00:49:47,130 --> 00:49:49,650
>> Og så hvis du finder ud af antallet er
vil være på venstre side, det er det samme

899
00:49:49,650 --> 00:49:53,340
ting som at gøre søgningen igen, men
lige på venstre side af listen.

900
00:49:53,340 --> 00:49:57,350
Så det er sådan det lyder
ligesom det er rekursiv.

901
00:49:57,350 --> 00:50:01,870
Så det er derfor, du fyre har rekursive
løsning for sammenfletning slags.

902
00:50:01,870 --> 00:50:04,270
>> OK, så her er et eksempel.

903
00:50:04,270 --> 00:50:07,280
Så lad os sige, at jeg ønsker at vælge
alle tallene fra 1 til n.

904
00:50:07,280 --> 00:50:13,790
Jeg kan indse, at summen af ​​n
nummer er n plus n minus 1 til 1.

905
00:50:13,790 --> 00:50:17,810
Men så, hvis jeg ser på n minus 1 plus
n minus 2 plus 1, der er den samme

906
00:50:17,810 --> 00:50:20,680
ting som opsummering numre
op til n minus 1.

907
00:50:20,680 --> 00:50:25,890
Så jeg kan sige summen af ​​et lige beløb
lig n plus summen af ​​n minus 1.

908
00:50:25,890 --> 00:50:28,010
Giver det mening?

909
00:50:28,010 --> 00:50:32,630
>> Og jeg ville også have noget andet
kaldet base case, som er, at

910
00:50:32,630 --> 00:50:37,440
summen af ​​de tal op
til nul ville være nul.

911
00:50:37,440 --> 00:50:42,770
Så så snart jeg kommer til det antal
nul, jeg ophører med at tælle.

912
00:50:42,770 --> 00:50:45,330
Giver det mening?

913
00:50:45,330 --> 00:50:48,120
>> Så her er et eksempel på, hvordan
Jeg kan gennemføre det.

914
00:50:48,120 --> 00:50:49,860
Så jeg har denne funktion i nogle.

915
00:50:49,860 --> 00:50:51,700
Det tager et heltal n.

916
00:50:51,700 --> 00:50:56,300
Så her jeg først kontrollere, om n er
mindre end eller lig med nul.

917
00:50:56,300 --> 00:51:00,310
Så hvis det er mindre end eller lig med nul, jeg
returnere nul, som er vores base case.

918
00:51:00,310 --> 00:51:05,690
Ellers kan jeg bare returnere n plus
summen af ​​tallene fra

919
00:51:05,690 --> 00:51:07,190
en til n minus en.

920
00:51:07,190 --> 00:51:09,360
Mening?

921
00:51:09,360 --> 00:51:10,100
OK.

922
00:51:10,100 --> 00:51:11,610
>> Så her er hvad det ser ud.

923
00:51:11,610 --> 00:51:15,260
Du har sum af 2 ligemænd
2 plus et beløb på 1.

924
00:51:15,260 --> 00:51:18,930
Og nogle af 1 er 1 plus
summen af ​​0, hvilket er 0.

925
00:51:18,930 --> 00:51:20,216
Mening?

926
00:51:20,216 --> 00:51:25,342
Så hvis vi ser på stakken af ​​din
program, det er hvad det ligner.

927
00:51:25,342 --> 00:51:26,820
>> Først har vi den primære funktion.

928
00:51:26,820 --> 00:51:30,320
Og derefter den vigtigste funktion
kaldet sum 2.

929
00:51:30,320 --> 00:51:36,690
Og så sum 2 kommer til at sige, åh, sum
2 er lig med 2, plus summen af ​​en.

930
00:51:36,690 --> 00:51:39,460
Så jeg tilføje beløb på 1 til stakken.

931
00:51:39,460 --> 00:51:43,860
Og summen af ​​1 kommer til at kalde summen af
0, hvilket også vil blive tilføjet

932
00:51:43,860 --> 00:51:44,630
til stakken.

933
00:51:44,630 --> 00:51:49,240
Og så hver af disse dem, der er
oven på en anden er nødt til at vende tilbage

934
00:51:49,240 --> 00:51:52,020
før de andre kan holde ud.

935
00:51:52,020 --> 00:51:56,240
>> Så for eksempel her summen af ​​0,
først, vil vende tilbage 0.

936
00:51:56,240 --> 00:51:58,320
Og vælg derefter beløb på 1.

937
00:51:58,320 --> 00:52:00,850
Så summen af ​​1 kommer til at
tilbage 1 til et beløb på 2.

938
00:52:00,850 --> 00:52:03,900
Og endelig, summen af ​​2 går
at returnere 3 til main.

939
00:52:03,900 --> 00:52:05,320
Giver det mening?

940
00:52:05,320 --> 00:52:09,496
>> Det er virkelig vigtigt at forstå, hvordan
stakken fungerer og forsøge at

941
00:52:09,496 --> 00:52:11,980
se, om det giver mening.

942
00:52:11,980 --> 00:52:13,260
OK, så sortering.

943
00:52:13,260 --> 00:52:16,170
Så hvorfor sortering vigtigt,
først og fremmest?

944
00:52:16,170 --> 00:52:18,260
Hvorfor skal vi bekymre os?

945
00:52:18,260 --> 00:52:20,310
Anyone?

946
00:52:20,310 --> 00:52:20,695
Giv mig et eksempel?

947
00:52:20,695 --> 00:52:21,040
Ja?

948
00:52:21,040 --> 00:52:22,968
>> Publikum: [uhørligt].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: Ja, OK.

950
00:52:24,700 --> 00:52:26,090
Så du kan søge mere effektivt.

951
00:52:26,090 --> 00:52:28,580
Det er en god måde.

952
00:52:28,580 --> 00:52:32,462
Så, for eksempel, har vi en masse
ting, faktisk i vores liv,

953
00:52:32,462 --> 00:52:32,920
sorteres.

954
00:52:32,920 --> 00:52:34,830
F.eks ordbøger.

955
00:52:34,830 --> 00:52:39,210
>> Det er meget vigtigt at have alle
ord i en slags for at vi

956
00:52:39,210 --> 00:52:41,970
kan få adgang til nemt.

957
00:52:41,970 --> 00:52:43,280
Så det er, hvad han sagde.

958
00:52:43,280 --> 00:52:45,530
Du kan søge mere effektivt.

959
00:52:45,530 --> 00:52:48,740
Tænk på, hvor svært det ville være at have en
ordbog hvor ordene er i

960
00:52:48,740 --> 00:52:49,500
tilfældig rækkefølge.

961
00:52:49,500 --> 00:52:53,120
Du bliver nødt til at se på, temmelig meget,
hvert eneste ord, indtil du finder den

962
00:52:53,120 --> 00:52:54,720
ord, du leder efter.

963
00:52:54,720 --> 00:52:58,710
>> Hvis du bruger Facebook også, når
du kigger på dine venner, er du

964
00:52:58,710 --> 00:53:03,540
kommer til at se, at Facebook sætte dit
tættere vens oven på dem

965
00:53:03,540 --> 00:53:05,470
at du ikke taler med så meget.

966
00:53:05,470 --> 00:53:08,080
Hvis du går hele vejen til bunden af
din venneliste, du kommer til at se

967
00:53:08,080 --> 00:53:11,250
folk, at du sandsynligvis ikke engang
huske, at du er venner med.

968
00:53:11,250 --> 00:53:14,590
Og det er fordi Facebook sorterer
dine venner baseret på, hvor

969
00:53:14,590 --> 00:53:16,472
tæt du er på dem.

970
00:53:16,472 --> 00:53:17,930
>> Så organisere data.

971
00:53:17,930 --> 00:53:18,450
Også Pokemon.

972
00:53:18,450 --> 00:53:21,400
Så du se, at alle Pokemons
har numre.

973
00:53:21,400 --> 00:53:27,210
Og det er som en nem
måde adgang til data.

974
00:53:27,210 --> 00:53:29,050
>> Publikum: Adgang Pokemon.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: Ja.

976
00:53:29,890 --> 00:53:32,395
>> Publikum: [uhørligt].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: Jep.

978
00:53:33,460 --> 00:53:35,140
OK, så udvælgelse slags.

979
00:53:35,140 --> 00:53:41,610
Valg slags kommer til at vælge den
mindste usorteret værdi af en liste hver

980
00:53:41,610 --> 00:53:43,300
gang i hver iteration.

981
00:53:43,300 --> 00:53:46,800
Det er lidt ligesom den slags, som du gør
i dit hoved, når du forsøger at

982
00:53:46,800 --> 00:53:48,430
sortere en liste på hånden.

983
00:53:48,430 --> 00:53:51,990
>> Dybest set, alt du skal gøre er, at du ser
til det mindste antal.

984
00:53:51,990 --> 00:53:54,280
Du sætter den i det sorterede liste.

985
00:53:54,280 --> 00:53:56,230
Og så skal du kigge efter den
næstmindste antal.

986
00:53:56,230 --> 00:54:00,080
Og så skal du holde gør
der og så videre.

987
00:54:00,080 --> 00:54:04,600
>> Så valg Sorter er dybest set dig
vælger, hver gang den mindste

988
00:54:04,600 --> 00:54:05,750
usorteret værdi.

989
00:54:05,750 --> 00:54:10,840
Sæt i slutningen af ​​den sorteres
en del af listen.

990
00:54:10,840 --> 00:54:12,370
Og holde gør det.

991
00:54:12,370 --> 00:54:15,890
Så lad os hurtigt se, hvad
dette ligner.

992
00:54:15,890 --> 00:54:19,340
Så her er den sorteres
og usorteret liste.

993
00:54:19,340 --> 00:54:23,350
>> Så for den sorteres i listen,
Det er i første omgang tom.

994
00:54:23,350 --> 00:54:26,760
Og så jeg har tænkt mig at vælge
mindste antal her, hvilket er 2.

995
00:54:26,760 --> 00:54:30,650
Så jeg får nummer 2, og jeg sætter
i den forreste del af listen.

996
00:54:30,650 --> 00:54:34,910
Og så vil jeg kigge efter den næstmindste
element, som er 3.

997
00:54:34,910 --> 00:54:37,050
Så jeg sætte det i slutningen
af sorteret liste.

998
00:54:37,050 --> 00:54:38,140
Og så vil jeg holde gør det.

999
00:54:38,140 --> 00:54:40,040
Jeg finde 4 og sætte det i slutningen.

1000
00:54:40,040 --> 00:54:41,360
Find 5 og sætte det i slutningen.

1001
00:54:41,360 --> 00:54:44,830
>> Og se på, hvordan alle disse tider,
Jeg siger sætte det i slutningen er,

1002
00:54:44,830 --> 00:54:46,850
dybest set, bytte to værdier.

1003
00:54:46,850 --> 00:54:48,100
OK?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
Og så den sidste, du bare
har endnu et element.

1006
00:54:52,825 --> 00:54:55,870
Så det er allerede ordnet.

1007
00:54:55,870 --> 00:54:57,800
>> OK, så indsættelse slags.

1008
00:54:57,800 --> 00:55:03,180
Indsættelse slags du vil også have
at ting at have en sorteret og

1009
00:55:03,180 --> 00:55:04,690
en usorteret liste.

1010
00:55:04,690 --> 00:55:14,540
Det eneste er, at hver gang der
du tilføjer et element til det sorteres

1011
00:55:14,540 --> 00:55:18,170
liste, skal du blot vælge det element,
er foran usorteret liste.

1012
00:55:18,170 --> 00:55:20,880
Og så du kommer til at finde, hvad
stilling det bør være i det sorterede

1013
00:55:20,880 --> 00:55:22,300
en del af listen.

1014
00:55:22,300 --> 00:55:25,840
>> Lad os se hvad det er så
dette giver mere mening.

1015
00:55:25,840 --> 00:55:29,360
Så i første omgang, for eksempel, jeg prøver
at indsætte nummer tre i

1016
00:55:29,360 --> 00:55:30,680
sorterede del af listen.

1017
00:55:30,680 --> 00:55:31,800
Så listen ikke har noget.

1018
00:55:31,800 --> 00:55:34,160
Så jeg kan bare sætte tallet 3.

1019
00:55:34,160 --> 00:55:37,480
>> Nu ønsker jeg at føje nummeret 5 til
det sorterede del af listen.

1020
00:55:37,480 --> 00:55:38,900
Så jeg ser på nummer 5.

1021
00:55:38,900 --> 00:55:40,450
Jeg bemærker, at det er større end 3.

1022
00:55:40,450 --> 00:55:41,980
Så jeg ved, at det har at være efter 3.

1023
00:55:41,980 --> 00:55:44,100
Så jeg sætte 3 og 5.

1024
00:55:44,100 --> 00:55:45,940
>> Så jeg ønsker at indsætte nummer 2.

1025
00:55:45,940 --> 00:55:51,630
Jeg bemærker, at nummer 2 er faktisk
vare så både 3 og 5.

1026
00:55:51,630 --> 00:55:54,580
Så jeg faktisk nødt til at sætte det hele
måde i begyndelsen af ​​listen.

1027
00:55:54,580 --> 00:55:59,030
Så jeg er nødt til, slags, flytte alle de
elementer i sorteret liste, så jeg kan

1028
00:55:59,030 --> 00:56:01,970
gøre plads til nummer 2.

1029
00:56:01,970 --> 00:56:03,160
>> Så vil jeg se antallet 6.

1030
00:56:03,160 --> 00:56:05,450
Jeg kan se, at det skulle være efter 5.

1031
00:56:05,450 --> 00:56:06,240
Så jeg sætte det der.

1032
00:56:06,240 --> 00:56:07,965
Og endelig, jeg ser på nummer 4.

1033
00:56:07,965 --> 00:56:11,030
Og jeg bemærker det bør
være mellem 3 og 5.

1034
00:56:11,030 --> 00:56:14,870
Og så sætter jeg det der, og skift
alle de andre elementer.

1035
00:56:14,870 --> 00:56:16,120
Mening?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> Bubble Sort.

1038
00:56:19,150 --> 00:56:25,730
Så boble slags er dybest set, hvad du er
kommer til at do-- vi kalder det boble

1039
00:56:25,730 --> 00:56:30,113
sortere fordi du går gennem list--
det er faktisk bedre, hvis jeg viser bare

1040
00:56:30,113 --> 00:56:32,300
du kan lide denne--

1041
00:56:32,300 --> 00:56:35,030
og du kommer til at sammenligne
tilstødende numre.

1042
00:56:35,030 --> 00:56:38,410
Og du kommer til at bytte deres
positioner, hvis de ikke er

1043
00:56:38,410 --> 00:56:39,190
i den rigtige rækkefølge.

1044
00:56:39,190 --> 00:56:42,570
>> Så dybest set, hvad der foregår på
ske er her, for eksempel,

1045
00:56:42,570 --> 00:56:44,160
du har 8 og 6.

1046
00:56:44,160 --> 00:56:47,270
Du ved, at det sorterede ordre vil
faktisk være 6 og 5, højre?

1047
00:56:47,270 --> 00:56:49,540
Så du kommer til at bytte de ordrer.

1048
00:56:49,540 --> 00:56:51,370
Så ser jeg 8 og 4 her.

1049
00:56:51,370 --> 00:56:52,250
Og jeg gør det samme.

1050
00:56:52,250 --> 00:56:53,400
Jeg bytter igen.

1051
00:56:53,400 --> 00:56:55,070
Og endelig, 2 og 8.

1052
00:56:55,070 --> 00:56:56,670
Jeg også bytte dem.

1053
00:56:56,670 --> 00:57:01,690
>> Det hedder Bubble Sortér fordi efter
hver af disse gentagelser, faktisk

1054
00:57:01,690 --> 00:57:05,910
det største antal på listen får alle
vejen til enden af ​​listen.

1055
00:57:05,910 --> 00:57:06,940
Giver det mening?

1056
00:57:06,940 --> 00:57:11,880
Fordi det holder bytte det
og flytte den til højre.

1057
00:57:11,880 --> 00:57:14,440
>> OK, så dette er den anden iteration.

1058
00:57:14,440 --> 00:57:17,200
Det ville være det samme.

1059
00:57:17,200 --> 00:57:20,190
Jeg vil gøre en swap og
derefter den sidste.

1060
00:57:20,190 --> 00:57:23,290
Jeg, at der ikke er nogen swaps
og listen er sorteret.

1061
00:57:23,290 --> 00:57:27,460
Så i Bubble Sorter, vi dybest set holde
at gå gennem listen og bytte

1062
00:57:27,460 --> 00:57:32,310
ting, indtil jeg bemærke, at jeg ikke gjorde
eventuelle swaps gør at iteration, som

1063
00:57:32,310 --> 00:57:34,270
betyder, at listen allerede er sorteret.

1064
00:57:34,270 --> 00:57:35,520
Mening?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> Lad os snakke lidt
om køretid.

1067
00:57:40,870 --> 00:57:45,165
Så tror du fyre huske Big
O, Omega, og Theta?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
Ja?

1070
00:57:50,990 --> 00:57:53,070
OK, hvad er Big O, først og fremmest?

1071
00:57:53,070 --> 00:57:54,315
>> Publikum: [uhørligt].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: Ja, det hedder et worst case
runtime, hvilket blot betyder, at det er

1073
00:57:59,070 --> 00:58:03,470
hvor meget du forvente, at programmet
at tage til at køre.

1074
00:58:03,470 --> 00:58:04,910
Ligesom i form af--

1075
00:58:04,910 --> 00:58:06,660
i denne case-- n.

1076
00:58:06,660 --> 00:58:09,150
Antallet af elementer i
liste i værste fald.

1077
00:58:09,150 --> 00:58:12,520
Ligesom i det værst tænkelige tilfælde.

1078
00:58:12,520 --> 00:58:17,100
>> Så for Bubble Sorter, for eksempel
Vi har store O n firkant.

1079
00:58:17,100 --> 00:58:20,580
Hvorfor har vi det?

1080
00:58:20,580 --> 00:58:24,716
Hvorfor er Bubble Sorter Big O n firkant?

1081
00:58:24,716 --> 00:58:27,614
>> Publikum: [uhørligt].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: Ja, så det værste tilfælde vil være
at jeg bliver nødt til at gøre n iterationer.

1083
00:58:35,670 --> 00:58:39,260
Så hver af iterationer vil
bringe det største element til enden

1084
00:58:39,260 --> 00:58:40,290
af listen.

1085
00:58:40,290 --> 00:58:44,230
Så det værste tilfælde er, at jeg har
at gøre det ting n gange.

1086
00:58:44,230 --> 00:58:48,550
Og for hver af de gange, jeg er nødt til at
gøre n swaps, fordi jeg er nødt til at sammenligne

1087
00:58:48,550 --> 00:58:49,870
hver to elementer.

1088
00:58:49,870 --> 00:58:53,730
Så det er derfor, det n kvadreret
fordi det er n gange n.

1089
00:58:53,730 --> 00:59:00,120
>> Derefter valg Sorter er også n firkantet
fordi der for hver iteration, jeg er nødt til at

1090
00:59:00,120 --> 00:59:02,650
se på hvert enkelt element
på listen.

1091
00:59:02,650 --> 00:59:04,980
Og derefter finde den mindste,
hvilket betyder, at jeg er nødt til at

1092
00:59:04,980 --> 00:59:06,130
se gennem n elementer.

1093
00:59:06,130 --> 00:59:11,750
Og jeg er nødt til at gøre, at n gange, fordi
Jeg er nødt til at vælge alle de n elementer.

1094
00:59:11,750 --> 00:59:18,273
>> En indsættelse slags er også n firkantet
fordi det værst tænkelige scenarie vil

1095
00:59:18,273 --> 00:59:20,950
være én, jeg er nødt til at indsætte
n tal, right?

1096
00:59:20,950 --> 00:59:22,765
Så jeg ved allerede, at jeg har tænkt mig
at have n iterationer.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
Men for hver af disse numre, hvis jeg havde
at se på alle tallene i

1099
00:59:29,840 --> 00:59:34,380
det sorteret liste og sætte det hele vejen
i front, vil det være n firkantet

1100
00:59:34,380 --> 00:59:36,230
fordi det vil være n gange n igen.

1101
00:59:36,230 --> 00:59:38,280
Mening?

1102
00:59:38,280 --> 00:59:41,512
Hvad med omega?

1103
00:59:41,512 --> 00:59:42,886
>> Publikum: [uhørligt].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: Det er i bedste fald.

1105
00:59:44,620 --> 00:59:48,810
Så det er ligesom i en masse gange for
sortering, i bedste fald er

1106
00:59:48,810 --> 00:59:50,660
når listen allerede er sorteret.

1107
00:59:50,660 --> 00:59:52,670
Så du behøver ikke rigtig har
at gøre noget.

1108
00:59:52,670 --> 00:59:56,290
Bubble Sortér har den bedste
case scenario af n.

1109
00:59:56,290 --> 00:59:58,820
Har du fyre vide hvorfor?

1110
00:59:58,820 --> 01:00:00,620
>> Publikum: [uhørligt].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: Ja, hvis du holder styr på
hvorvidt data ration havde nogen swaps eller

1112
01:00:05,640 --> 01:00:10,533
ikke, ligesom hvis du har noget sat til
tilfældet, hvis der var en iteration, hvis

1113
01:00:10,533 --> 01:00:15,140
Listen er allerede sorteret, dybest set,
hvad der kommer til at ske, er jeg har tænkt mig at

1114
01:00:15,140 --> 01:00:17,890
prøv at bytte hver to
tilstødende elementer.

1115
01:00:17,890 --> 01:00:19,920
Jeg har tænkt mig at se, at
der er ingen swaps.

1116
01:00:19,920 --> 01:00:21,230
Og jeg bare tilbage med det samme.

1117
01:00:21,230 --> 01:00:24,240
>> Så det betyder, at jeg bare var nødt til
gå gennem listen én gang.

1118
01:00:24,240 --> 01:00:28,990
Så det er n fordi jeg ser
på n elementer.

1119
01:00:28,990 --> 01:00:30,930
Hvorfor udvælgelse sortere n Square?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> Ja, selv om listen er sorteret for
hver iteration af udvælgelse slags, jeg

1122
01:00:45,520 --> 01:00:47,590
nødt til at vælge det mindste element.

1123
01:00:47,590 --> 01:00:49,980
Så det betyder, at jeg har ud for at se
på alle elementerne i usorteret

1124
01:00:49,980 --> 01:00:53,350
liste og finde den mindste
for hver iteration.

1125
01:00:53,350 --> 01:00:54,600
Giver det mening?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> Og indsættelse sværd er N fordi det i
tilfælde at jeg forsøger at indsætte

1128
01:01:04,690 --> 01:01:09,320
numre og alle de tal, når jeg
forsøger at indsætte dem, jeg se, at de

1129
01:01:09,320 --> 01:01:10,510
er i den rigtige position.

1130
01:01:10,510 --> 01:01:15,120
Jeg behøver ikke at gå tjekke alle de andre
numre i usorteret liste.

1131
01:01:15,120 --> 01:01:17,170
Så det er derfor, det vil være n.

1132
01:01:17,170 --> 01:01:19,480
Mening?

1133
01:01:19,480 --> 01:01:21,035
Og hvad er theta?

1134
01:01:21,035 --> 01:01:23,410
>> Publikum: [uhørligt].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: Hvad, undskyld?

1136
01:01:24,380 --> 01:01:24,960
Sig det igen.

1137
01:01:24,960 --> 01:01:25,666
>> Publikum: [uhørligt].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: Præcis.

1139
01:01:26,490 --> 01:01:31,280
Så du kan se, at kun udvælgelse
lagret i Flet slags har thetas.

1140
01:01:31,280 --> 01:01:39,920
Og det er fordi du kun har theta
hvis både Big O og Omega er de samme.

1141
01:01:39,920 --> 01:01:41,520
OK.

1142
01:01:41,520 --> 01:01:44,210
Og endelig, flette art er, i logn.

1143
01:01:44,210 --> 01:01:48,910
>> Og så, som Dan sagde, Flet slags
er lidt ligesom på samme måde som

1144
01:01:48,910 --> 01:01:50,320
du gør binær søgning.

1145
01:01:50,320 --> 01:01:53,530
Så får du listen.

1146
01:01:53,530 --> 01:01:55,170
Og du kommer til at skære i halve.

1147
01:01:55,170 --> 01:02:00,580
Og så skal du skære dem
i mindre halvdele.

1148
01:02:00,580 --> 01:02:01,730
Og så skal du flette dem.

1149
01:02:01,730 --> 01:02:02,960
Du fyre huske, ikke?

1150
01:02:02,960 --> 01:02:04,960
OK, da han sagde.

1151
01:02:04,960 --> 01:02:08,330
>> OK, pointere.

1152
01:02:08,330 --> 01:02:11,078
Så hvad er en pointer?

1153
01:02:11,078 --> 01:02:12,050
>> Publikum: [uhørligt].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: En adresse.

1155
01:02:12,820 --> 01:02:13,720
OK.

1156
01:02:13,720 --> 01:02:18,530
Jeg ved, at David viser en flok
videoer af Binky og ting, der peger

1157
01:02:18,530 --> 01:02:19,080
hinanden.

1158
01:02:19,080 --> 01:02:22,960
Men jeg kan lide at tænke på pegepinde
som blot en adresse.

1159
01:02:22,960 --> 01:02:26,110
Så det er en variabel, der går
at lagre en adresse.

1160
01:02:26,110 --> 01:02:31,940
>> Så det er bare denne særlige variabel
der er fire bytes langt.

1161
01:02:31,940 --> 01:02:36,550
Husk, at pointer til noget er
altid fire byte længe for vores 32-bit

1162
01:02:36,550 --> 01:02:39,370
maskine, så tilfældet med
apparatet.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
Og det har bare lokationen
af en variabel inde i den.

1165
01:02:47,050 --> 01:02:50,240
>> OK, så der er denne hukommelse, dybest set.

1166
01:02:50,240 --> 01:02:57,420
Så hver blok af hukommelse har faktisk en
etiket, som er adressen på den

1167
01:02:57,420 --> 01:02:58,890
slotty hukommelse.

1168
01:02:58,890 --> 01:03:02,370
Så det betyder, at jeg kan have
en pegepind, der peger på

1169
01:03:02,370 --> 01:03:03,380
enhver af disse adresser.

1170
01:03:03,380 --> 01:03:09,930
Så grunden til, at vi vil bruge pegepinde er
hvis jeg er nødt til at huske placeringen

1171
01:03:09,930 --> 01:03:12,300
at en bestemt variabel er en hukommelse.

1172
01:03:12,300 --> 01:03:16,560
>> Og jer huske, at en af ​​dem
sager var, hvis jeg har en funktion

1173
01:03:16,560 --> 01:03:20,820
hvis jeg har faktisk vil have dig til
bytte for reals, jeg faktisk

1174
01:03:20,820 --> 01:03:22,110
nødt til at sende en pegepind.

1175
01:03:22,110 --> 01:03:23,460
Ikke variablen.

1176
01:03:23,460 --> 01:03:25,200
Har du fyre huske det?

1177
01:03:25,200 --> 01:03:26,450
Forskellen between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
hvad er navnet?

1180
01:03:34,120 --> 01:03:36,010
Opkald efter værdi og kalder
ved henvisning, right?

1181
01:03:36,010 --> 01:03:36,840
>> OK, ja.

1182
01:03:36,840 --> 01:03:38,330
Så ring efter værdi.

1183
01:03:38,330 --> 01:03:43,570
Når du bare sende en variabel til
fungere du bare sende en værdi.

1184
01:03:43,570 --> 01:03:45,610
Så du faktisk sender
en kopi af den variable.

1185
01:03:45,610 --> 01:03:49,720
Og dit program kunne ikke pleje mindre
om, hvis den samme variabel faktisk

1186
01:03:49,720 --> 01:03:51,650
gør en kopi.

1187
01:03:51,650 --> 01:03:56,330
>> Og ringer ved henvisning betyder, at
Jeg er faktisk at sende en kopi af det

1188
01:03:56,330 --> 01:03:57,550
pointer til denne variabel.

1189
01:03:57,550 --> 01:04:00,970
Så det betyder, at jeg sender den
Placeringen af ​​denne variabel.

1190
01:04:00,970 --> 01:04:04,440
Så fornemmer jeg har placeringen af
variabel, når jeg kalder funktionen

1191
01:04:04,440 --> 01:04:09,700
med pegepinde, jeg er i stand til rent faktisk at
ændre de data, der var i main.

1192
01:04:09,700 --> 01:04:12,050
Mening?

1193
01:04:12,050 --> 01:04:17,560
>> Selv om markøren er en kopi, den
pointer stadig har den rigtige adresse på

1194
01:04:17,560 --> 01:04:20,090
den variabel, jeg ønsker at ændre.

1195
01:04:20,090 --> 01:04:21,920
Mening?

1196
01:04:21,920 --> 01:04:24,290
>> Så skaber pointere.

1197
01:04:24,290 --> 01:04:28,410
Husk, markøren altid har
den type, som det peger

1198
01:04:28,410 --> 01:04:29,890
til og derefter en stjerne.

1199
01:04:29,890 --> 01:04:31,030
Og så skal du sætte navn.

1200
01:04:31,030 --> 01:04:35,765
Så husk, at når du har
uanset stjerne, det er ligesom en pointer til

1201
01:04:35,765 --> 01:04:38,990
at uanset variabel
skrive, at du havde.

1202
01:04:38,990 --> 01:04:42,850
>> Så her i stjerne, for eksempel, er det
en pointer og et heltal.

1203
01:04:42,850 --> 01:04:47,680
Og så char stjerne er en pointer
char stjerne og så videre.

1204
01:04:47,680 --> 01:04:47,960
Ja?

1205
01:04:47,960 --> 01:04:52,710
>> Publikum: Hvad hvis vi har en
pointer til n til stjerne på x.

1206
01:04:52,710 --> 01:04:55,255
Jeg ved, der skaber en pointer til x.

1207
01:04:55,255 --> 01:04:59,432
Er det også erklære x et heltal?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: OK, så når du siger n stjerne x,
du er ikke at skabe en pointer til en

1209
01:05:05,170 --> 01:05:06,000
variabel x.

1210
01:05:06,000 --> 01:05:08,170
Du opretter en pegepind hedder x.

1211
01:05:08,170 --> 01:05:09,396
>> Publikum: [uhørligt].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: Så når jeg siger n stjerne x, jeg er
sige, hey, i hukommelsen, vil jeg

1213
01:05:14,250 --> 01:05:16,390
få en af ​​disse tre bokse.

1214
01:05:16,390 --> 01:05:20,750
Og jeg har tænkt mig at sige, at det
bliver x, hvilket er

1215
01:05:20,750 --> 01:05:22,000
kommer til at være en pegepind.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
Og noget af interesse, pegepinde
er, at vi siger, at de har

1218
01:05:30,640 --> 01:05:32,620
4 bytes for en 32-bit maskine.

1219
01:05:32,620 --> 01:05:36,320
Og grunden til det er, fordi
4 byte er 32-bit.

1220
01:05:36,320 --> 01:05:40,490
>> Og maskiner, der er 64 bits faktisk
har pointere adresser

1221
01:05:40,490 --> 01:05:43,480
som er 64 bit lange.

1222
01:05:43,480 --> 01:05:49,820
Så det betyder bare, at størrelsen af ​​den
adresser i maskinen er anderledes.

1223
01:05:49,820 --> 01:05:52,270
>> Så Referer og dereferere.

1224
01:05:52,270 --> 01:05:54,310
Der er to operatører, der
jer skal huske.

1225
01:05:54,310 --> 01:05:55,450
Den første er tegnet.

1226
01:05:55,450 --> 01:05:56,810
Den anden er stjerne.

1227
01:05:56,810 --> 01:06:05,060
Bliv ikke forvirret af denne stjerne og dette
Star, fordi huske, at i

1228
01:06:05,060 --> 01:06:06,950
dette tilfældet, har du n stjerne.

1229
01:06:06,950 --> 01:06:08,700
>> Det er ligesom et hele sammen.

1230
01:06:08,700 --> 01:06:10,720
Der er ingen n plads stjerne.

1231
01:06:10,720 --> 01:06:12,070
Så det betyder, at det er den type.

1232
01:06:12,070 --> 01:06:14,870
Husk, at når du har
den variable stjerne, er du

1233
01:06:14,870 --> 01:06:16,230
taler om den type.

1234
01:06:16,230 --> 01:06:20,540
>> Når du har bare stjerne og derefter
navnet på variablen, betyder det, at

1235
01:06:20,540 --> 01:06:24,100
du dereferere markøren, som
betyder, at du kigger på den

1236
01:06:24,100 --> 01:06:28,290
pointer, at finde den adresse, det er
peger på, at gå til den adresse,

1237
01:06:28,290 --> 01:06:30,850
og kigge på, når
du har der.

1238
01:06:30,850 --> 01:06:34,310
Så jeg fortæller mine elever, at når du har
stjerne, bør du tænke, at det er

1239
01:06:34,310 --> 01:06:36,850
forkortelse af indhold.

1240
01:06:36,850 --> 01:06:39,770
>> Så hvis du har en pegepind, og du
gøre stjerne pointer, det er

1241
01:06:39,770 --> 01:06:41,720
indhold af markøren.

1242
01:06:41,720 --> 01:06:44,580
Så du gå til hvad det peger på
og se på den konstante indhold.

1243
01:06:44,580 --> 01:06:47,730
Og tegnet er den samme
ting som adresse.

1244
01:06:47,730 --> 01:06:52,560
>> Så hvis jeg har en variabel et-- ligesom, lad os
sige, at jeg gjorde int a er lig 3--

1245
01:06:52,560 --> 01:06:56,900
hvis jeg ønsker at finde adressen på det
variabel en hukommelse, kan jeg bare gøre

1246
01:06:56,900 --> 01:06:58,240
Ampersand en.

1247
01:06:58,240 --> 01:07:00,280
Så det er adressen på en.

1248
01:07:00,280 --> 01:07:01,530
Mening?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> Så her er et eksempel.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
Dette mangler int b og int c.

1253
01:07:11,530 --> 01:07:16,520
Så int a er lig med 3 betyder, at
Jeg har tænkt mig at gå til hukommelsen.

1254
01:07:16,520 --> 01:07:19,870
Og jeg har tænkt mig at finde en slot
og sætte tallet 3 her.

1255
01:07:19,870 --> 01:07:22,200
>> Og så int B svarer til 4.

1256
01:07:22,200 --> 01:07:23,100
Jeg har tænkt mig at gøre det samme.

1257
01:07:23,100 --> 01:07:25,840
Gå til hukommelsen og sætte et nummer
4 i en af ​​kasserne.

1258
01:07:25,840 --> 01:07:27,100
Og int lig 5.

1259
01:07:27,100 --> 01:07:29,740
Find en anden boks og sætte et nummer 5.

1260
01:07:29,740 --> 01:07:36,160
>> Så hvad er denne linje laver ud?
n stjerne pa lig tegnet en.

1261
01:07:36,160 --> 01:07:37,800
Så først og fremmest, n stjerne pa.

1262
01:07:37,800 --> 01:07:39,050
Hvad laver den?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> Publikum: [uhørligt].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: Ja, så n stjerne pa, første,
erklærer en pointer kaldet pa.

1266
01:07:47,890 --> 01:07:53,720
Og så er det at tildele værdien af
at markøren skal være adressen på en.

1267
01:07:53,720 --> 01:07:55,790
Så Ampersand en.

1268
01:07:55,790 --> 01:07:58,510
Så, hvis jeg gør stjerne pb,
hvad er en stjerne pb?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> Åh, undskyld.

1271
01:08:03,150 --> 01:08:06,330
Dette er også mangler. n stjerne pb.

1272
01:08:06,330 --> 01:08:07,905
Jeg mener stjerne pc.

1273
01:08:07,905 --> 01:08:11,200
Jeg er så ked af det.

1274
01:08:11,200 --> 01:08:11,940
Det er den samme ting.

1275
01:08:11,940 --> 01:08:16,408
Men nu er jeg god ar skabe en pegepind
til b og derefter en pegepind til c.

1276
01:08:16,408 --> 01:08:16,886
Ja?

1277
01:08:16,886 --> 01:08:18,136
>> Publikum: [uhørligt]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: Ja.

1280
01:08:26,670 --> 01:08:32,630
Så hvis du går til hukommelse og du går til
den boks, der er designeret til pa,

1281
01:08:32,630 --> 01:08:37,149
du faktisk kommer til at
se en adresse på en.

1282
01:08:37,149 --> 01:08:38,399
OK?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
Ja?

1285
01:08:43,300 --> 01:08:45,605
>> Publikum: [uhørligt]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: Ja, pointer er en adresse.

1287
01:08:49,260 --> 01:08:50,120
Glem aldrig det.

1288
01:08:50,120 --> 01:08:52,800
Det er ligesom det vigtigste
del om pointere.

1289
01:08:52,800 --> 01:08:56,180
Der er opbevaring og adresse
til nogle variabel.

1290
01:08:56,180 --> 01:08:56,890
Noget andet?

1291
01:08:56,890 --> 01:08:58,370
Andre spørgsmål?

1292
01:08:58,370 --> 01:08:59,189
OK.

1293
01:08:59,189 --> 01:09:00,399
>> Så Pointers og arrays.

1294
01:09:00,399 --> 01:09:08,189
Husk, at når jeg gør int matrix 3,
Dybest set, hvad jeg gør, er jeg, venlig

1295
01:09:08,189 --> 01:09:12,779
af, erklærede i en pegepind.

1296
01:09:12,779 --> 01:09:18,960
Så array er slags ligesom en pointer til en
bestemt sted i hukommelsen, hvor jeg

1297
01:09:18,960 --> 01:09:21,999
tildelt tre pladser til heltal.

1298
01:09:21,999 --> 01:09:23,430
Giver det mening?

1299
01:09:23,430 --> 01:09:30,250
>> Så når jeg gør int matrix 3, hvad jeg
gør, dybest set, er at skabe tre

1300
01:09:30,250 --> 01:09:31,479
slots i hukommelsen.

1301
01:09:31,479 --> 01:09:33,899
Så jeg bare finde tre pladser i hukommelsen.

1302
01:09:33,899 --> 01:09:38,810
Så hvis jeg gør, så en stjerne array, det
dybest set betyder indholdet af array,

1303
01:09:38,810 --> 01:09:46,180
hvilket betyder at jeg slette markøren, går jeg
til det sted, som det er at pege på,

1304
01:09:46,180 --> 01:09:47,939
og jeg sætter nummer et.

1305
01:09:47,939 --> 01:09:53,729
>> Og så, hvis jeg gør stjerne matrix plus 1,
det er det samme som at gøre matrix

1306
01:09:53,729 --> 01:09:59,690
beslag én, som bare betyder, at jeg går til
det sted, at det peger på.

1307
01:09:59,690 --> 01:10:03,000
Og så plus 1 mærker
mig flytte en position.

1308
01:10:03,000 --> 01:10:06,510
Så jeg går til denne position, faktisk,
og sætte nummer to.

1309
01:10:06,510 --> 01:10:10,900
>> Og så, endelig, når jeg gør
matrix plus 2, jeg går til, hvor

1310
01:10:10,900 --> 01:10:11,825
arrayets peger på.

1311
01:10:11,825 --> 01:10:14,690
Og så vil jeg flytte til hukommelse blokke.

1312
01:10:14,690 --> 01:10:16,240
Og så sætter jeg nummer tre her.

1313
01:10:16,240 --> 01:10:16,600
Ja?

1314
01:10:16,600 --> 01:10:21,400
>> PUBLIKUM: Så stjerne array er simpelthen
siger den allerførste punkt.

1315
01:10:21,400 --> 01:10:25,090
Og du kan tilføje 1, bare fordi
vi er kun virkelig

1316
01:10:25,090 --> 01:10:27,295
refererer den første adresse.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: Ja.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
Hvorfor har vi for eksempel sige matrix
0, array 1, og array 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
Jeg siger, hvorfor gør du 0,
1, 2, 3 i stedet for 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
En af grundene er, én computer
programmører foretrækker at starte

1323
01:10:46,550 --> 01:10:47,750
tælle fra 0.

1324
01:10:47,750 --> 01:10:52,370
To er fordi når du gør matrix 0,
det er det samme som at gøre matrix

1325
01:10:52,370 --> 01:10:56,330
plus 0, hvilket betyder, at jeg går til
denne stilling, og jeg gør ikke

1326
01:10:56,330 --> 01:10:59,320
springe nogen hukommelse blokke.

1327
01:10:59,320 --> 01:11:01,750
Så jeg tror ikke flytte nogen hukommelse blokke.

1328
01:11:01,750 --> 01:11:02,015
Ja?

1329
01:11:02,015 --> 01:11:03,265
>> Publikum: [uhørligt]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: Så hun spørger, hvad der er
forskellen mellem at gøre

1332
01:11:12,670 --> 01:11:14,000
dette eller laver malloc.

1333
01:11:14,000 --> 01:11:17,550
En af forskellene er, at
int matrix 3 er at skabe et

1334
01:11:17,550 --> 01:11:19,260
array på stakken.

1335
01:11:19,260 --> 01:11:23,080
Og når jeg gør malloc, det
skaber på den bunke.

1336
01:11:23,080 --> 01:11:25,250
Giver det mening?

1337
01:11:25,250 --> 01:11:28,870
>> Så hvordan gør malloc rent faktisk arbejder?

1338
01:11:28,870 --> 01:11:32,245
Så hvorfor skal vi overhovedet bruge malloc?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
Din compiler slags tal ud alle
de variabler, du har erklæret.

1341
01:11:39,700 --> 01:11:44,040
Og han skaber plads til alle
af dem i stakken.

1342
01:11:44,040 --> 01:11:47,180
Så alle dine variabler går
at være et sted i stakken.

1343
01:11:47,180 --> 01:11:49,460
Så her er de miljøvariabler.

1344
01:11:49,460 --> 01:11:53,850
>> Så dybest set, plads for disse variabler
i hukommelsen er afsat på

1345
01:11:53,850 --> 01:11:55,080
kompilere tid.

1346
01:11:55,080 --> 01:11:58,790
Så det betyder, at din computer har
at kende alle disse variabler

1347
01:11:58,790 --> 01:11:59,790
forhånd.

1348
01:11:59,790 --> 01:12:02,500
Det behøver ikke at vide, hvad værdi
du kommer til at sætte i dem.

1349
01:12:02,500 --> 01:12:05,490
Men det er nødvendigt at vide, hvordan
meget hukommelse du har brug for.

1350
01:12:05,490 --> 01:12:09,380
>> Men lad os nu sige, at for eksempel,
du opretter en matrix eller tage en

1351
01:12:09,380 --> 01:12:13,430
streng, som du tager
fra brugeren.

1352
01:12:13,430 --> 01:12:17,300
Du ved ikke, hvor længe strengen
vil være, for eksempel.

1353
01:12:17,300 --> 01:12:20,600
Så du ved ikke præcis, hvor mange
hukommelse blokke du tildele, ikke?

1354
01:12:20,600 --> 01:12:24,120
>> Så det giver ikke rigtig mening for
dig at sige sætte 100 tegn.

1355
01:12:24,120 --> 01:12:26,420
Og hvad så, hvis brugeren skriver 150?

1356
01:12:26,420 --> 01:12:27,670
Du kommer til at blive skruet.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> Så dybest set, kan du ikke være sikker på, hvordan
meget hukommelse du har brug for at afsætte

1359
01:12:34,620 --> 01:12:35,960
når du kompilere programmet.

1360
01:12:35,960 --> 01:12:38,240
Du skal bare vide, at der på køretid.

1361
01:12:38,240 --> 01:12:39,950
Så det er derfor du har den bunke.

1362
01:12:39,950 --> 01:12:47,610
Så bunke vil have hukommelse
at du tildele under

1363
01:12:47,610 --> 01:12:50,810
programmets varighed kører.

1364
01:12:50,810 --> 01:12:55,780
>> Så dybest set, når du gør malloc, hvad
du laver er allokering af hukommelse på

1365
01:12:55,780 --> 01:13:00,160
runtime, hvilket betyder, at du er
beslutter ret i det øjeblik, du

1366
01:13:00,160 --> 01:13:02,670
skal have denne hukommelse.

1367
01:13:02,670 --> 01:13:04,210
Så det er når du tildele den.

1368
01:13:04,210 --> 01:13:06,430
Giver det mening?

1369
01:13:06,430 --> 01:13:11,690
>> Så husk, stakken har variabler
der er oprettet på kompilere tid.

1370
01:13:11,690 --> 01:13:14,560
Og så den bunke har variabler
der er skabt som du gå

1371
01:13:14,560 --> 01:13:15,600
med allokere for eksempel.

1372
01:13:15,600 --> 01:13:16,850
>> Publikum: [uhørligt]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: So getString er
vil kalde malloc.

1375
01:13:24,340 --> 01:13:26,710
Lad mig tale om malloc, og
Jeg forklarer getString.

1376
01:13:26,710 --> 01:13:32,000
Så malloc er det samme
som allokering af hukommelse.

1377
01:13:32,000 --> 01:13:34,600
Så det kommer til at tildele
hukommelse på den bunke.

1378
01:13:34,600 --> 01:13:40,010
Og det kommer til at returnere en pointer til
hvor at hukommelsen var tildelt på.

1379
01:13:40,010 --> 01:13:43,090
>> Så når du do--

1380
01:13:43,090 --> 01:13:44,910
her for example--

1381
01:13:44,910 --> 01:13:45,830
n stjerne pointer.

1382
01:13:45,830 --> 01:13:50,520
Og så pointer lig malloc
størrelse tommer gange 10.

1383
01:13:50,520 --> 01:13:52,110
Jeg skaber en pointer.

1384
01:13:52,110 --> 01:13:59,020
Og så er jeg tildele denne pointer til
værdien af ​​markøren at allokere

1385
01:13:59,020 --> 01:13:59,680
giver mig.

1386
01:13:59,680 --> 01:14:04,150
>> Så jeg beder malloc kan du tildele
plads til 10 heltal.

1387
01:14:04,150 --> 01:14:05,390
Det er, hvad det siger.

1388
01:14:05,390 --> 01:14:09,020
Og malloc giver mig tilbage
pointer til dette sted.

1389
01:14:09,020 --> 01:14:11,460
Mening?

1390
01:14:11,460 --> 01:14:12,270
OK.

1391
01:14:12,270 --> 01:14:17,940
Jeg Og getString er, dybest set, gør en
ringe til malloc, så du kan tildele

1392
01:14:17,940 --> 01:14:21,680
hukommelse under runtime.

1393
01:14:21,680 --> 01:14:26,460
>> Husk altid at tjekke for null
fordi allokere vil returnere null

1394
01:14:26,460 --> 01:14:28,200
hvis det ikke kan allokere hukommelse.

1395
01:14:28,200 --> 01:14:31,660
Lad os sige, at du beder om en latterlig
mængde hukommelse.

1396
01:14:31,660 --> 01:14:33,950
Din computer er ikke til at være
stand til at afsætte så meget.

1397
01:14:33,950 --> 01:14:36,410
>> Så malloc er bare
at returnere nul.

1398
01:14:36,410 --> 01:14:42,210
Så husk altid at kontrollere, om
pointer, som du fik fra malloc er

1399
01:14:42,210 --> 01:14:45,640
null eller ikke, for hvis det er, kan du
være dereferere en pegepind og

1400
01:14:45,640 --> 01:14:48,340
forårsager bivirkninger fejl.

1401
01:14:48,340 --> 01:14:50,930
Og endelig, glem ikke
din gratis hukommelse.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc skaber hukommelse i den bunke.

1404
01:15:00,560 --> 01:15:03,436
Og du er nødt til at frigøre hukommelse
før programmet slutter.

1405
01:15:03,436 --> 01:15:05,370
OK, det er alt for mig.

1406
01:15:05,370 --> 01:15:07,900
Beklager, Rob.

1407
01:15:07,900 --> 01:15:07,950
Tak.

1408
01:15:07,950 --> 01:15:09,878
>> [Applaus]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: Nogle sidste spørgsmål
før Rob kommer?

1410
01:15:12,679 --> 01:15:13,138
Nej?

1411
01:15:13,138 --> 01:15:13,597
Ja?

1412
01:15:13,597 --> 01:15:15,892
>> Publikum: Jeg kunne ikke se
denne ene online.

1413
01:15:15,892 --> 01:15:17,269
Har du uploadet det endnu?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS: Jeg tror Dave er
uploade det snart.

1415
01:15:19,106 --> 01:15:19,880
>> DAVE: Det vil blive offentliggjort.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: Det vil være online.

1417
01:15:20,310 --> 01:15:21,175
>> PUBLIKUM: Det er op.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: Det er op?

1419
01:15:22,090 --> 01:15:23,157
OK.

1420
01:15:23,157 --> 01:15:23,644
Ja?

1421
01:15:23,644 --> 01:15:27,053
>> Publikum: [uhørligt]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: Ja, du skal befri alle
hukommelse, der er sat i bunke.

1423
01:15:30,285 --> 01:15:31,535
>> Publikum: [uhørligt]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: Ja.

1426
01:15:36,160 --> 01:15:39,980
Enhver tid, at du har en kultur malloc,
du bør have en kultur fri

1427
01:15:39,980 --> 01:15:42,640
efter at du stopper med at bruge denne variabel.

1428
01:15:42,640 --> 01:15:44,800
Så malloc og fri er
altid sammen.

1429
01:15:44,800 --> 01:15:45,410
Deres bedste venner.

1430
01:15:45,410 --> 01:15:46,720
Ja.

1431
01:15:46,720 --> 01:15:47,970
Rob?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> ROB: Jeg vil gå hurtigt.

1434
01:15:56,850 --> 01:16:00,466
Og også den video vil blive sat op.

1435
01:16:00,466 --> 01:16:01,716
Jeg har den mikrofon på.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> OK, så uge fem ting.

1438
01:16:26,230 --> 01:16:27,970
Første ting vi har, er stakken.

1439
01:16:27,970 --> 01:16:33,390
Så husk, at der er kun én stak
ramme per aktiv funktion opkald.

1440
01:16:33,390 --> 01:16:34,710
Vi vil se, at i et sekund.

1441
01:16:34,710 --> 01:16:37,850
Og også huske, hvad der faktisk går
i hver stak ramme vil være

1442
01:16:37,850 --> 01:16:41,880
de lokale variabler af vores funktioner,
de argumenter, der er gået ind i vores

1443
01:16:41,880 --> 01:16:43,880
funktioner, sammen med et par
andre ting, du ikke rigtig

1444
01:16:43,880 --> 01:16:45,260
behøver at bekymre sig om.

1445
01:16:45,260 --> 01:16:50,950
>> Så her er et eksempel program,
varsel, vigtigste er printfing afkastet

1446
01:16:50,950 --> 01:16:52,830
værdi foo 4.

1447
01:16:52,830 --> 01:16:57,930
foo er bare at returnere
Værdien af ​​bar 4 komma 6.

1448
01:16:57,930 --> 01:17:02,380
Og bar vil sætte nogle lokale
variabel n svarende til 4 gange 6.

1449
01:17:02,380 --> 01:17:03,920
Og derefter vende tilbage n.

1450
01:17:03,920 --> 01:17:09,130
>> Så lad os se på stakken hele
den faktiske iteration af dette program.

1451
01:17:09,130 --> 01:17:10,500
Så der er i bunden af ​​vores stak.

1452
01:17:10,500 --> 01:17:12,620
Husk, at stakken vokser op.

1453
01:17:12,620 --> 01:17:15,370
Så i bunden af ​​vores stak, vi
har en stak ramme til main.

1454
01:17:15,370 --> 01:17:17,000
Når programmet starter, vigtigste
vil altid være på

1455
01:17:17,000 --> 01:17:18,560
bunden af ​​vores stak.

1456
01:17:18,560 --> 01:17:20,880
>> Og hvad der er inde i vores
stakramme til main?

1457
01:17:20,880 --> 01:17:23,810
Så selv om der ikke er nogen lokal
variable til main, som jeg sagde før,

1458
01:17:23,810 --> 01:17:29,670
vi har argc og RGV optage plads
indersiden af ​​hoved stakramme.

1459
01:17:29,670 --> 01:17:33,260
Så vigtigste er nu at gå til
kalder funktionen foo.

1460
01:17:33,260 --> 01:17:35,125
Og det betyder foo vil
få sin egen stakramme.

1461
01:17:35,125 --> 01:17:36,970
>> Så nu er vi inde i
funktionen foo.

1462
01:17:36,970 --> 01:17:38,610
Og hvad der skal gå i
foo stak ramme?

1463
01:17:38,610 --> 01:17:41,100
Nå, foo har et argument n.

1464
01:17:41,100 --> 01:17:45,440
Og n er lig med 4, da det er hvad
vigtigste passerer som foo argument.

1465
01:17:45,440 --> 01:17:48,490
>> Så nu foo kommer til at kalde bar.

1466
01:17:48,490 --> 01:17:52,070
Hvad er bar kommer til at have inde
af sin 'stak ramme?

1467
01:17:52,070 --> 01:17:55,610
Det har x lig med 4 y lig med seks.

1468
01:17:55,610 --> 01:17:58,540
Det er ikke alle, at vi er nødt til
i stakramme fordi bar

1469
01:17:58,540 --> 01:18:00,580
har også en lokal variabel n.

1470
01:18:00,580 --> 01:18:03,370
Og n vi vil sættes lig med 24.

1471
01:18:03,370 --> 01:18:05,750
>> Så nu bar kommer til at vende tilbage n.

1472
01:18:05,750 --> 01:18:09,300
Så bar vender tilbage 24 til
stakrammen foo.

1473
01:18:09,300 --> 01:18:12,560
Og fordi bar vender nu tilbage, at
betyder, at vi popping stakramme

1474
01:18:12,560 --> 01:18:14,250
til bar fra i stakken.

1475
01:18:14,250 --> 01:18:18,430
Så al den hukommelse, der bar havde været
bruger, er nu fra stakken.

1476
01:18:18,430 --> 01:18:21,550
>> Nu er foo også går
at returnere 24 til vigtigste.

1477
01:18:21,550 --> 01:18:25,470
Så nu, at foo vender tilbage, hukommelsen
at foo brugte i sin "

1478
01:18:25,470 --> 01:18:27,550
Væk er også stakramme.

1479
01:18:27,550 --> 01:18:29,660
Og nu, hoved kommer til at kalde printf.

1480
01:18:29,660 --> 01:18:31,660
Så printf er bare en anden funktion.

1481
01:18:31,660 --> 01:18:35,320
Når vi kalder printf, går det at være
en anden stak ramme for printf

1482
01:18:35,320 --> 01:18:36,470
funktion opkald.

1483
01:18:36,470 --> 01:18:37,990
>> Hvad er det vi passerer printf?

1484
01:18:37,990 --> 01:18:40,090
Det er, hvad der kommer til at gå
på stakramme.

1485
01:18:40,090 --> 01:18:44,970
I det mindste, vi passerer
at procent Jeg Backslash n og

1486
01:18:44,970 --> 01:18:47,180
argumentet 24.

1487
01:18:47,180 --> 01:18:50,370
Det kunne have mere i det stakramme
hvis printf sker for at være at bruge nogle

1488
01:18:50,370 --> 01:18:51,200
lokale variable.

1489
01:18:51,200 --> 01:18:51,920
Vi ved det ikke.

1490
01:18:51,920 --> 01:18:53,810
>> Men alle, der går i printf s
stak ramme.

1491
01:18:53,810 --> 01:18:55,740
Det kommer til at udføre printf.

1492
01:18:55,740 --> 01:18:56,830
Så printf er gjort.

1493
01:18:56,830 --> 01:18:57,820
Det vil vende tilbage.

1494
01:18:57,820 --> 01:18:58,960
Endelig vigtigste er gjort.

1495
01:18:58,960 --> 01:18:59,860
Main vil vende tilbage.

1496
01:18:59,860 --> 01:19:02,020
Og så vores program er færdig.

1497
01:19:02,020 --> 01:19:02,480
Ja?

1498
01:19:02,480 --> 01:19:04,505
>> Publikum: Ser du [uhørligt]

1499
01:19:04,505 --> 01:19:05,900
argumenter [uhørligt]

1500
01:19:05,900 --> 01:19:06,830
parametre?

1501
01:19:06,830 --> 01:19:09,970
>> ROB: Så der er en subtil forskel
mellem argumenter og parametre.

1502
01:19:09,970 --> 01:19:14,400
Og virkelig, i fælles tale, har en tendens folk
at bare blande dem op hele tiden.

1503
01:19:14,400 --> 01:19:17,550
Men parametre er det formelle
Navnet på den ting.

1504
01:19:17,550 --> 01:19:20,180
>> Så argc og argv er
parametre til main.

1505
01:19:20,180 --> 01:19:23,440
Argumenter er, hvad du rent faktisk
passere i som disse parametre.

1506
01:19:23,440 --> 01:19:28,340
Så der, når jeg ringer foo på 4, 4
er det argument jeg passerer ind.

1507
01:19:28,340 --> 01:19:31,460
Og parameteren n indersiden af
foo, tager på værdien 4

1508
01:19:31,460 --> 01:19:32,880
siden 4. var argumentet.

1509
01:19:32,880 --> 01:19:35,826
>> Publikum: [uhørligt]?

1510
01:19:35,826 --> 01:19:37,880
>> ROB: n er en lokal variabel til bar.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
n er stadig gælder for foo men
Det er en parameter til foo.

1513
01:19:44,960 --> 01:19:48,190
Det er ikke en lokal variabel.

1514
01:19:48,190 --> 01:19:48,546
Ja?

1515
01:19:48,546 --> 01:19:51,180
>> Publikum: [uhørligt]?

1516
01:19:51,180 --> 01:19:55,400
>> ROB: foo er bare ringer bar og
returnering Whatever Bar afkast.

1517
01:19:55,400 --> 01:19:56,786
>> Publikum: [uhørligt]?

1518
01:19:56,786 --> 01:19:59,591
>> ROB: Ja, bare for at se flere
stakrammer.

1519
01:19:59,591 --> 01:20:00,082
Ja?

1520
01:20:00,082 --> 01:20:03,519
>> Publikum: Hvorfor blev foo kaldet
før printf?

1521
01:20:03,519 --> 01:20:05,920
>> ROB: Hvorfor blev foo kaldt før printf?

1522
01:20:05,920 --> 01:20:10,740
Så jeg kunne have, i stedet gjort noget
ligesom int x lig foo 4

1523
01:20:10,740 --> 01:20:12,980
og printes x.

1524
01:20:12,980 --> 01:20:17,900
Men i stedet jeg kombinerede funktion
anløbe printf argument.

1525
01:20:17,900 --> 01:20:23,670
>> Men bemærk, at vi kan faktisk ikke
udføre opkald til printf indtil vi

1526
01:20:23,670 --> 01:20:25,610
regne ud, hvad foo af 4 er.

1527
01:20:25,610 --> 01:20:27,480
Så vi kommer til at vurdere dette.

1528
01:20:27,480 --> 01:20:32,504
Og kun en gang det er gjort går
at komme tilbage og evaluere denne.

1529
01:20:32,504 --> 01:20:32,990
Ja?

1530
01:20:32,990 --> 01:20:37,364
>> Publikum: Da både bar [uhørligt]

1531
01:20:37,364 --> 01:20:41,738
værdi, hvorfor vi ikke har [uhørligt]?

1532
01:20:41,738 --> 01:20:44,400
>> ROB: De helt bør være int.

1533
01:20:44,400 --> 01:20:46,260
Det blev ikke fanget i
flere omgange.

1534
01:20:46,260 --> 01:20:49,010
Så det burde være int bar og int
foo da begge de

1535
01:20:49,010 --> 01:20:50,460
vender heltal.

1536
01:20:50,460 --> 01:20:54,214
Void er kun, hvis de ikke kommer
at returnere de faktiske værdier.

1537
01:20:54,214 --> 01:20:54,692
Ja?

1538
01:20:54,692 --> 01:20:58,038
>> Publikum: Hvis du havde en linje over
tilbagevenden [uhørligt]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ROB: En linje over afkastet?

1541
01:21:03,730 --> 01:21:04,410
>> Publikum: Ja.

1542
01:21:04,410 --> 01:21:10,780
Ligesom hvis du gjorde printf og [uhørligt]
ville det udskrives to gange?

1543
01:21:10,780 --> 01:21:12,992
>> ROB: Så indersiden af ​​foo?

1544
01:21:12,992 --> 01:21:15,945
Hvis vi havde en printf lige her?

1545
01:21:15,945 --> 01:21:16,750
>> Publikum: Ja.

1546
01:21:16,750 --> 01:21:19,510
>> ROB: Så hvis vi havde en printf ret
her, ville det udskrives én gang.

1547
01:21:19,510 --> 01:21:23,400
Da vi ringer foo en gang til højre
her, så vil vi ramt printf.

1548
01:21:23,400 --> 01:21:24,620
Så vil vi ringe til baren.

1549
01:21:24,620 --> 01:21:25,710
Og så foo vil vende tilbage.

1550
01:21:25,710 --> 01:21:26,275
Og det er det.

1551
01:21:26,275 --> 01:21:30,985
Vi har kun nogensinde støder
printf én gang.

1552
01:21:30,985 --> 01:21:31,482
Ja?

1553
01:21:31,482 --> 01:21:32,973
>> Publikum: [uhørligt]

1554
01:21:32,973 --> 01:21:37,950
printf kald foo, fordi vi er først
kalder printf og så vi passerer

1555
01:21:37,950 --> 01:21:38,580
argumenterne.

1556
01:21:38,580 --> 01:21:40,960
>> ROB: Så i teorien, er ikke
printf ringer foo?

1557
01:21:40,960 --> 01:21:42,220
Så nej.

1558
01:21:42,220 --> 01:21:47,360
Bare den rækkefølge, C kommer til at
udføre disse ting er, før vi kan

1559
01:21:47,360 --> 01:21:49,800
kalde en funktion, alle de argumenter
til den funktion at

1560
01:21:49,800 --> 01:21:51,600
fuldstændigt evalueret.

1561
01:21:51,600 --> 01:21:53,540
Så er det helt evalueret?

1562
01:21:53,540 --> 01:21:54,610
Ja, det er bare en snor.

1563
01:21:54,610 --> 01:21:55,480
Det er bare en værdi.

1564
01:21:55,480 --> 01:21:57,200
>> Så har vi helt
evaluere dette.

1565
01:21:57,200 --> 01:21:59,720
Når dette er gjort, nu alle
sine argumenter evalueres.

1566
01:21:59,720 --> 01:22:01,982
Og nu kan vi gøre det
ringe til printf.

1567
01:22:01,982 --> 01:22:02,478
Ja?

1568
01:22:02,478 --> 01:22:03,966
>> Publikum: Et spørgsmål.

1569
01:22:03,966 --> 01:22:06,942
Hvis du har en ugyldig funktion, skal
du har tilbagevenden semikolon?

1570
01:22:06,942 --> 01:22:09,910
>> ROB: Du behøver ikke en tilbagevenden semikolon
hvis du har en void funktion.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
OK.

1573
01:22:14,780 --> 01:22:15,830
Så nu nogle bunke ting.

1574
01:22:15,830 --> 01:22:19,640
Så bunke er, hvordan vi kommer til at beskæftige sig
med dynamisk hukommelse ledelse.

1575
01:22:19,640 --> 01:22:23,100
Og dette er direkte i modstrid med den
stak, som vi ville kalde automatisk

1576
01:22:23,100 --> 01:22:24,100
hukommelse ledelse.

1577
01:22:24,100 --> 01:22:27,140
>> Så på stakken, du aldrig rigtig har
at beskæftige sig med, hvordan lokale variable

1578
01:22:27,140 --> 01:22:30,400
bliver skubbet og dukkede alle
disse stakrammer og alt det der.

1579
01:22:30,400 --> 01:22:31,070
Du behøver ikke at bekymre dig om det.

1580
01:22:31,070 --> 01:22:32,070
Det er automatisk.

1581
01:22:32,070 --> 01:22:36,990
Så den bunke er manuel.

1582
01:22:36,990 --> 01:22:38,070
Og [uhørligt]

1583
01:22:38,070 --> 01:22:41,260
kommer fra disse funktioner
malloc og fri.

1584
01:22:41,260 --> 01:22:43,550
>> Så her er et andet program.

1585
01:22:43,550 --> 01:22:47,145
Alt, hvad vi gør, er mallocing
et heltal.

1586
01:22:47,145 --> 01:22:49,360
Vi gemmer det i stjerne x.

1587
01:22:49,360 --> 01:22:52,520
Selvfølgelig, vi er nødt til at kontrollere
for at se, hvis x er nul.

1588
01:22:52,520 --> 01:22:56,400
Så vi vil bare angive, hvad
x peger på til 50.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
Udskriv hvad x peger på,
print x, og derefter frit x.

1591
01:23:03,260 --> 01:23:08,920
>> Så hvordan er dette rent faktisk kommer til at se
hvis vi ser på vores stak og bunke?

1592
01:23:08,920 --> 01:23:10,950
Så vi starter igen.

1593
01:23:10,950 --> 01:23:12,580
Bunden af ​​vores stak som før.

1594
01:23:12,580 --> 01:23:15,930
Husk, at dig bunke direkte
imod stakken?

1595
01:23:15,930 --> 01:23:18,850
Så vi bliver nødt til det
øverst på vores bunke deroppe.

1596
01:23:18,850 --> 01:23:22,590
>> Så bunden af ​​vores stak, har vi
vores stakramme til main.

1597
01:23:22,590 --> 01:23:28,000
Det har plads til argc, argv, og vi
nu har en lokal variabel x, som

1598
01:23:28,000 --> 01:23:30,030
er en int stjerne.

1599
01:23:30,030 --> 01:23:32,240
Så vi kommer til at gentage
gennem dette program.

1600
01:23:32,240 --> 01:23:34,420
Første ting vi har, er
et opkald til malloc.

1601
01:23:34,420 --> 01:23:36,250
>> Så vi laver et opkald til malloc.

1602
01:23:36,250 --> 01:23:37,100
Allokere er en funktion.

1603
01:23:37,100 --> 01:23:38,770
Det kommer til at få en stak ramme.

1604
01:23:38,770 --> 01:23:40,180
Hvad skal vi passerer at malloc?

1605
01:23:40,180 --> 01:23:41,610
Det kommer til at gå inde
af stakken rammen.

1606
01:23:41,610 --> 01:23:45,130
Vi passerer størrelse af n, hvilket er 4.

1607
01:23:45,130 --> 01:23:49,700
Så der er gået til malloc.

1608
01:23:49,700 --> 01:23:50,910
>> Hvad betyder malloc gøre?

1609
01:23:50,910 --> 01:23:53,820
Det griber os nogle plads på den bunke.

1610
01:23:53,820 --> 01:23:55,320
Så vi kommer til at gå til den bunke.

1611
01:23:55,320 --> 01:23:57,990
Og vi kommer til at få fat i
4 byte fra bunke.

1612
01:23:57,990 --> 01:24:01,500
Så lad os bare give det
en vilkårlig adresse.

1613
01:24:01,500 --> 01:24:06,680
0x123 Bare foregive, at er en
adresse, der er på den bunke.

1614
01:24:06,680 --> 01:24:12,300
>> Så hvad er egentlig inde i det
region hukommelse på adressen Ox123?

1615
01:24:12,300 --> 01:24:13,080
Garbage.

1616
01:24:13,080 --> 01:24:15,270
Så vi har ikke gemt noget i det.

1617
01:24:15,270 --> 01:24:18,830
Så så vidt vi ved, er det
kunne være noget.

1618
01:24:18,830 --> 01:24:20,560
Du bør ikke antage det er nul.

1619
01:24:20,560 --> 01:24:23,870
Det er mest sandsynligt ikke nul.

1620
01:24:23,870 --> 01:24:26,260
>> Så nu malloc afkast.

1621
01:24:26,260 --> 01:24:28,020
Og hvad gør vi, når malloc returnerer?

1622
01:24:28,020 --> 01:24:29,800
Vi sætter hvad den returnerer.

1623
01:24:29,800 --> 01:24:32,290
Vi sætter x lig med hvad
det tilbage.

1624
01:24:32,290 --> 01:24:33,690
Så hvad er det at vende tilbage?

1625
01:24:33,690 --> 01:24:38,150
Det vender tilbage 0x123 da det er den
adresse på blokken hukommelse, som det

1626
01:24:38,150 --> 01:24:40,850
netop tildelt i den bunke.

1627
01:24:40,850 --> 01:24:47,160
>> Så returnere 0x123 x skal nu være indstillet
svarende til 0x123, som billedligt,

1628
01:24:47,160 --> 01:24:52,940
vi ofte trække så x med et virkeligt
pil peger på den pågældende blok.

1629
01:24:52,940 --> 01:24:55,820
Men x er bare opbevaring denne adresse.

1630
01:24:55,820 --> 01:24:58,670
Så nu er vi nødt til at tjekke hvis x er nul.

1631
01:24:58,670 --> 01:24:59,120
Det er ikke nul.

1632
01:24:59,120 --> 01:25:02,170
Vi forestiller os at der malloc lykkedes.

1633
01:25:02,170 --> 01:25:04,950
>> Så nu stjerne X er lig 50.

1634
01:25:04,950 --> 01:25:08,450
Så stjerne husker det betyder
gå til denne adresse.

1635
01:25:08,450 --> 01:25:12,700
Så 0x123 Vi kommer til at
gå til denne adresse.

1636
01:25:12,700 --> 01:25:14,660
Så det bringer os deroppe.

1637
01:25:14,660 --> 01:25:16,310
Hvad gør vi på denne adresse?

1638
01:25:16,310 --> 01:25:19,020
Vi opbevaring 50.

1639
01:25:19,020 --> 01:25:22,500
>> Så efter denne linje, det er, hvad
tingene kommer til at se ud.

1640
01:25:22,500 --> 01:25:24,640
Så nu er det ikke længere
skrald deroppe.

1641
01:25:24,640 --> 01:25:28,910
Nu ved vi, at 50 er i den
bestemt adresse, fordi

1642
01:25:28,910 --> 01:25:32,410
vi indstille den til det.

1643
01:25:32,410 --> 01:25:32,790
OK?

1644
01:25:32,790 --> 01:25:34,370
Så nu vil vi til at udskrive f.

1645
01:25:34,370 --> 01:25:38,490
>> Så først vil vi udskrive stjerne x.

1646
01:25:38,490 --> 01:25:39,640
Så hvad er stjerne x?

1647
01:25:39,640 --> 01:25:44,300
Igen stjerne x betyder gå til
ting at x peger på.

1648
01:25:44,300 --> 01:25:47,140
Så x er lagring 0x123 Gå til det.

1649
01:25:47,140 --> 01:25:48,490
Vi får 50.

1650
01:25:48,490 --> 01:25:50,540
Så udskrive f det.

1651
01:25:50,540 --> 01:25:54,900
Og det betyder, at det kommer til at udskrive 50.

1652
01:25:54,900 --> 01:25:56,850
Og så der returnerer.

1653
01:25:56,850 --> 01:25:58,340
>> Og så har vi den anden printf.

1654
01:25:58,340 --> 01:25:59,370
Vi er nu procent s.

1655
01:25:59,370 --> 01:26:01,680
Hvis du ikke har set det, det er
bare hvordan du udskriver en pegepind.

1656
01:26:01,680 --> 01:26:04,960
Så vi har procent i, procent
f, og alle af dem, der allerede.

1657
01:26:04,960 --> 01:26:07,160
Så procent p, udskrive en pegepind.

1658
01:26:07,160 --> 01:26:08,920
>> Så x er en pointer.

1659
01:26:08,920 --> 01:26:13,440
Så hvis vi skal til at udskrive x selv,
vi udskriver hvad er faktisk inde

1660
01:26:13,440 --> 01:26:19,220
x, hvilket er 0x123 Så den første
print f kommer til at udskrive 50.

1661
01:26:19,220 --> 01:26:23,620
Det andet tryk f går
at udskrive 0x123 Ja?

1662
01:26:23,620 --> 01:26:27,460
>> PUBLIKUM: Bruger du procent
x for at udskrive en pointer?

1663
01:26:27,460 --> 01:26:31,200
>> ROB: Så bruger du procent
x for at udskrive en pointer?

1664
01:26:31,200 --> 01:26:38,350
Så du kan, men procent x er bare,
generelt, for ligesom, hvis du har nogle

1665
01:26:38,350 --> 01:26:40,325
heltal og du vil udskrive
det som en hexadecimal.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
Det er bare, hvordan du gør det.

1668
01:26:44,880 --> 01:26:47,160
>> Ud fra følgende betragtninger procent d ville
udskrives som decimal.

1669
01:26:47,160 --> 01:26:50,310
Der har blev vi får procent
d. i er lige heltal.

1670
01:26:50,310 --> 01:26:52,690
procent p er specifikt
til pointere.

1671
01:26:52,690 --> 01:26:54,060
>> Så x er en pointer.

1672
01:26:54,060 --> 01:26:56,360
Vi ønsker at bruge procent s.

1673
01:26:56,360 --> 01:26:57,937
Men procent x kunne arbejde.

1674
01:26:57,937 --> 01:26:58,414
Ja?

1675
01:26:58,414 --> 01:26:59,664
>> Publikum: [uhørligt]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ROB: Ja.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
I det mindste for dette call-- så jeg
har ikke taget det her.

1680
01:27:13,440 --> 01:27:19,850
Men disse to argumenter er nødvendigvis
Indersiden af ​​stakramme

1681
01:27:19,850 --> 01:27:23,040
sammen med eventuelle lokale variable
printf sker for at være bruger.

1682
01:27:23,040 --> 01:27:27,020
Og så det næste opkald til printf nu
indersiden af ​​printf stakramme er

1683
01:27:27,020 --> 01:27:33,960
procent p omvendt skråstreg n og uanset
værdi af x er, hvilket er 0x123.

1684
01:27:33,960 --> 01:27:34,425
Ja?

1685
01:27:34,425 --> 01:27:35,675
>> Publikum: [uhørligt]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ROB: Det vil udskrive noget
der ligner dette.

1688
01:27:40,880 --> 01:27:41,846
>> Publikum: [uhørligt].

1689
01:27:41,846 --> 01:27:44,510
>> ROB: Så det udskriver det i adresse formularen.

1690
01:27:44,510 --> 01:27:47,003
Det ligner en adresse.

1691
01:27:47,003 --> 01:27:47,494
Ja?

1692
01:27:47,494 --> 01:27:49,458
>> Publikum: [uhørligt]?

1693
01:27:49,458 --> 01:27:51,075
>> ROB: Hvorfor er hvad?

1694
01:27:51,075 --> 01:27:52,920
>> Publikum: [uhørligt]?

1695
01:27:52,920 --> 01:27:55,240
>> ROB: Hvorfor er denne pointer 4 byte?

1696
01:27:55,240 --> 01:27:58,500
Så der er en hel masse
af 0'er foran dette.

1697
01:27:58,500 --> 01:28:03,740
Så det er virkelig 0x0000000123.

1698
01:28:03,740 --> 01:28:06,510
På en 64-bit-system, der ville være
en hel masse flere nuller.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
Ja?

1701
01:28:11,900 --> 01:28:13,150
>> Publikum: [uhørligt].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ROB: Så den første printf
vil print--

1704
01:28:21,130 --> 01:28:21,980
>> Publikum: [uhørligt].

1705
01:28:21,980 --> 01:28:24,420
>> ROB: Ja, det vil udskrive
hvad x peger på.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
Stjerne siger, hvad er det
ting peger på.

1708
01:28:29,070 --> 01:28:30,300
Grib den.

1709
01:28:30,300 --> 01:28:31,455
Så hvad er det peger på?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
Grib den.

1712
01:28:32,410 --> 01:28:33,390
Det er, hvad vi kommer til at udskrive.

1713
01:28:33,390 --> 01:28:37,020
Henviser til, at den næste, vi er
bare udskriver x selv.

1714
01:28:37,020 --> 01:28:38,850
Hvad er der inde for f?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
OK.

1717
01:28:44,500 --> 01:28:46,620
>> Og så, endelig, vi har fri.

1718
01:28:46,620 --> 01:28:48,040
Hvad skal vi passerer at befri?

1719
01:28:48,040 --> 01:28:49,470
Vi passerer x.

1720
01:28:49,470 --> 01:28:52,380
Den tid jeg faktisk viste
det i stakken rammen.

1721
01:28:52,380 --> 01:28:56,370
>> Så vi passerer værdien
0x123 at befri.

1722
01:28:56,370 --> 01:28:59,070
Så nu fri ved, okay,
Jeg nødt til at gå op til den bunke

1723
01:28:59,070 --> 01:29:00,050
og gratis at hukommelsen.

1724
01:29:00,050 --> 01:29:03,920
Det er ikke længere bruger hvad
er på adressen 0x123.

1725
01:29:03,920 --> 01:29:07,010
>> Så fri kommer til at frigive
at der fra den bunke.

1726
01:29:07,010 --> 01:29:09,490
Nu er vores bunke er tom igen.

1727
01:29:09,490 --> 01:29:11,120
Vi har ingen memory leaks.

1728
01:29:11,120 --> 01:29:12,940
Nu gratis vil vende tilbage.

1729
01:29:12,940 --> 01:29:16,130
Bemærk, at x er stadig 0x123.

1730
01:29:16,130 --> 01:29:18,240
Men det er nu ikke gyldig hukommelse.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
Vi bør ikke længere dereference x.

1733
01:29:23,986 --> 01:29:24,440
Ja?

1734
01:29:24,440 --> 01:29:27,240
>> PUBLIKUM: Er returnere 0 overflødig?

1735
01:29:27,240 --> 01:29:28,290
>> ROB: Er returen 0 overflødig?

1736
01:29:28,290 --> 01:29:31,110
Ja.

1737
01:29:31,110 --> 01:29:33,950
Vi har lige sat det der, fordi
vi har en tilbagevenden én efter luft.

1738
01:29:33,950 --> 01:29:36,830
Så det er ligesom, ja, lader
omfatter afkastet 0.

1739
01:29:36,830 --> 01:29:37,310
Ja?

1740
01:29:37,310 --> 01:29:38,560
>> Publikum: [uhørligt]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ROB: Så efter gratis x, hvad der sker, hvis
vi forsøger at dereference markøren?

1743
01:29:45,580 --> 01:29:47,240
Det er muligt, at noget går galt.

1744
01:29:47,240 --> 01:29:49,330
Det er muligt, at vi stadig får 50.

1745
01:29:49,330 --> 01:29:53,590
>> Det er muligt, også, at denne hukommelse er
nu bliver brugt til noget andet.

1746
01:29:53,590 --> 01:29:57,140
Så det er udefineret adfærd.

1747
01:29:57,140 --> 01:30:00,772
Og udefineret betyder noget
kan ske.

1748
01:30:00,772 --> 01:30:01,250
Ja?

1749
01:30:01,250 --> 01:30:02,500
>> Publikum: [uhørligt]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ROB: Nej, så hvis du tildeler
x til noget andet.

1752
01:30:10,830 --> 01:30:15,870
Så hvis lige her sagde vi x lig
malloc noget else--

1753
01:30:15,870 --> 01:30:17,100
malloc størrelse event--

1754
01:30:17,100 --> 01:30:20,180
så den oprindelige blok
hukommelse ikke er frigjort.

1755
01:30:20,180 --> 01:30:21,490
Og vi har officielt mistet det.

1756
01:30:21,490 --> 01:30:23,150
Det er en hukommelsesfejl.

1757
01:30:23,150 --> 01:30:25,090
Vi har mistet alle referencer
denne blok af hukommelse.

1758
01:30:25,090 --> 01:30:26,827
Så der er ingen måde, vi nogensinde kan frigøre det.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
OK, så derefter returnere 0 betyder gjort.

1761
01:30:36,630 --> 01:30:37,900
>> Okay, så stak overløb.

1762
01:30:37,900 --> 01:30:39,320
Hvad er meningen her?

1763
01:30:39,320 --> 01:30:41,210
Så husk, at bunke på vej ned.

1764
01:30:41,210 --> 01:30:43,480
Stak er på vej op.

1765
01:30:43,480 --> 01:30:48,000
Så det var eksemplet fra forelæsningen
Jeg tror, ​​hvis vigtigste er bare at

1766
01:30:48,000 --> 01:30:51,380
kalder denne funktion foo, som vil
at kalde sig rekursivt igen og

1767
01:30:51,380 --> 01:30:52,320
igen.

1768
01:30:52,320 --> 01:30:55,370
>> Så stak rammer kommer til at
arbejder nøjagtig det samme.

1769
01:30:55,370 --> 01:30:58,130
Så vi vil til at begynde med de vigtigste
som bunden stakramme.

1770
01:30:58,130 --> 01:31:02,000
Derefter vigtigste kommer til at kalde foo, som
kommer til at få en stak ramme.

1771
01:31:02,000 --> 01:31:04,260
>> Derefter foo kommer til at kalde foo
igen, som kommer til at få

1772
01:31:04,260 --> 01:31:05,500
anden stakramme.

1773
01:31:05,500 --> 01:31:08,270
Og så igen, og igen, og igen,
og igen, indtil i sidste ende, vi løber

1774
01:31:08,270 --> 01:31:09,190
i bunke.

1775
01:31:09,190 --> 01:31:11,990
Så dette er, hvordan vi får
en stak overflow.

1776
01:31:11,990 --> 01:31:14,910
Og på dette punkt, du seg fejl.

1777
01:31:14,910 --> 01:31:17,335
Eller ville du virkelig seg fejl før
dette punkt, men ja.

1778
01:31:17,335 --> 01:31:19,660
>> PUBLIKUM: Er kerne dumpe
samme som seg skyld?

1779
01:31:19,660 --> 01:31:26,140
>> ROB: Så du se segmentering
fejl kerne dumpet.

1780
01:31:26,140 --> 01:31:28,760
Du får en kerne dump når
du seg fejl.

1781
01:31:28,760 --> 01:31:32,580
Og det er ligesom et dump af alle de
indholdet af din nuværende hukommelse, så

1782
01:31:32,580 --> 01:31:36,670
at du kan prøve og identificere
hvorfor du seg afbrudt.

1783
01:31:36,670 --> 01:31:37,135
Ja?

1784
01:31:37,135 --> 01:31:38,385
>> Publikum: [uhørligt]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ROB: Så en segmentering betyder fejl
der er en stak overflow.

1787
01:31:45,460 --> 01:31:47,060
Så ikke nødvendigvis.

1788
01:31:47,060 --> 01:31:49,880
En segmenteringsfejl betyder, at du er
rørende hukommelse på en måde,

1789
01:31:49,880 --> 01:31:50,880
du bør ikke være.

1790
01:31:50,880 --> 01:31:54,750
Så en måde for at sker er, når
du stak overflow, begynder vi rørende

1791
01:31:54,750 --> 01:31:58,736
hukommelse på en måde, vi ikke bør være.

1792
01:31:58,736 --> 01:31:59,208
Ja?

1793
01:31:59,208 --> 01:32:00,458
>> Publikum: [uhørligt]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ROB: Så inde i en uendelig løkke.

1796
01:32:05,830 --> 01:32:08,770
Ligesom, det er ligesom en rekursiv uendelig
loop og så vi får en anden

1797
01:32:08,770 --> 01:32:09,770
stakramme hver gang.

1798
01:32:09,770 --> 01:32:13,540
Men lige inden for en regelmæssig
uendelig mens en--

1799
01:32:13,540 --> 01:32:16,390
Nå, lad os ikke endda udskrive F--

1800
01:32:16,390 --> 01:32:17,040
gøre noget.

1801
01:32:17,040 --> 01:32:18,390
Uanset hvad.

1802
01:32:18,390 --> 01:32:20,610
>> Vi kommer ikke til at være at få
anden stakramme.

1803
01:32:20,610 --> 01:32:22,530
Vi vil bare holde looping
i denne enkelt instruktion.

1804
01:32:22,530 --> 01:32:23,920
Stakken er ikke vokser.

1805
01:32:23,920 --> 01:32:27,290
Det er det faktum, at hver rekursive
opkald giver os en stak ramme.

1806
01:32:27,290 --> 01:32:31,231
Det er derfor, vi får en stak overflow.

1807
01:32:31,231 --> 01:32:31,728
Ja?

1808
01:32:31,728 --> 01:32:38,189
>> PUBLIKUM: Så hvis du sagde at få
mens loop og derefter [uhørligt]?

1809
01:32:38,189 --> 01:32:42,000
>> ROB: Så hvis inde i while-løkken
der var en printf, du stadig ville

1810
01:32:42,000 --> 01:32:42,790
ikke seg fejl.

1811
01:32:42,790 --> 01:32:46,090
Jeg vidste bare ikke lyst til at forvirre tingene.

1812
01:32:46,090 --> 01:32:46,610
Det ville sløjfe.

1813
01:32:46,610 --> 01:32:48,225
Du vil få en enkelt stak
Ramme til printf.

1814
01:32:48,225 --> 01:32:49,580
>> Så printf ville returnere.

1815
01:32:49,580 --> 01:32:50,280
Så ville du sløjfe igen.

1816
01:32:50,280 --> 01:32:51,460
Du vil få en enkelt stak
Ramme til printf.

1817
01:32:51,460 --> 01:32:52,850
Det ville returnere.

1818
01:32:52,850 --> 01:32:54,060
Enkelt stakramme.

1819
01:32:54,060 --> 01:33:00,215
Så du ikke får denne uendelige
hober sig op stakrammer.

1820
01:33:00,215 --> 01:33:03,185
>> Publikum: [uhørligt]?

1821
01:33:03,185 --> 01:33:04,040
>> ROB: Ja.

1822
01:33:04,040 --> 01:33:09,360
Så denne stakoverløb sker
fordi ingen af ​​disse

1823
01:33:09,360 --> 01:33:11,600
opkald til foo vender tilbage.

1824
01:33:11,600 --> 01:33:15,250
Så hvis vi vender tilbage, så ville vi
begynder at tabe stakrammer.

1825
01:33:15,250 --> 01:33:17,870
Og så ville vi ikke stable overløb.

1826
01:33:17,870 --> 01:33:20,070
Og det er derfor, du har brug for en base case
for dine personlige funktioner.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
Ja?

1829
01:33:23,479 --> 01:33:27,375
>> PUBLIKUM: Er den potentielle størrelse og
stak til bunke det samme for

1830
01:33:27,375 --> 01:33:29,880
alle programmer?

1831
01:33:29,880 --> 01:33:31,910
>> ROB: Groft.

1832
01:33:31,910 --> 01:33:35,090
Er den potentielle størrelse af stakken og
dyngen den samme for alle programmer?

1833
01:33:35,090 --> 01:33:37,180
Groft.

1834
01:33:37,180 --> 01:33:40,080
Der er en vis randomisering til
hvor stakken starter og

1835
01:33:40,080 --> 01:33:42,400
hvor bunke starter.

1836
01:33:42,400 --> 01:33:45,870
Hvis du tilfældigvis har en hel masse
globale variabler og ting, kan du

1837
01:33:45,870 --> 01:33:49,520
tage væk fra noget plads
til din bunke.

1838
01:33:49,520 --> 01:33:54,060
>> På et 64-bit system, du næsten
har uendelig hukommelse.

1839
01:33:54,060 --> 01:33:55,820
Der er bare så meget.

1840
01:33:55,820 --> 01:33:59,250
Mellem 32 bit og 64 bit, at
er en betydelig forskel.

1841
01:33:59,250 --> 01:34:02,350
>> Du kommer til at få en hel masse mere
stable og bunke plads på en 64-bit

1842
01:34:02,350 --> 01:34:05,810
system, fordi der er bare mere
adresser, som de kan bruge.

1843
01:34:05,810 --> 01:34:09,360
Men på et individuelt system, vil det
være omtrent den samme mængde af stakken

1844
01:34:09,360 --> 01:34:10,785
og bunke plads.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
Okay.

1847
01:34:15,530 --> 01:34:18,220
>> Så sidste ting er kompilering.

1848
01:34:18,220 --> 01:34:19,810
Så du bør vide denne proces.

1849
01:34:19,810 --> 01:34:22,240
Der er fire store trin.

1850
01:34:22,240 --> 01:34:24,400
Så det første bør man
være let at huske.

1851
01:34:24,400 --> 01:34:25,085
Præ-behandling.

1852
01:34:25,085 --> 01:34:28,390
Det har præfikset pre i det.

1853
01:34:28,390 --> 01:34:32,080
Så det kommer før alt andet.

1854
01:34:32,080 --> 01:34:34,000
>> De ting at huske er hash.

1855
01:34:34,000 --> 01:34:37,250
Så hash definerer og hash omfatter
i hver af disse.

1856
01:34:37,250 --> 01:34:39,560
De er alle pre-processoren
direktiver.

1857
01:34:39,560 --> 01:34:42,030
Det er de ting, at de
pre-processoren tager sig af.

1858
01:34:42,030 --> 01:34:43,680
>> Så hvad gør en pre-processor gøre?

1859
01:34:43,680 --> 01:34:44,850
Det er en virkelig dum ting.

1860
01:34:44,850 --> 01:34:49,380
Alt det er i stand til, er alle disse
kopiere og klippe og indsætte operationer.

1861
01:34:49,380 --> 01:34:51,790
>> Så hash omfatter standard I0 prik time.

1862
01:34:51,790 --> 01:34:52,990
Hvad er der at gøre?

1863
01:34:52,990 --> 01:34:56,610
Det er opsigtsvækkende standard I0 prik h
fil og indsætte den i toppen

1864
01:34:56,610 --> 01:34:58,960
hvor det siger hash indeholder
standard I0 prik timer.

1865
01:34:58,960 --> 01:35:02,480
>> Og enhver hash definere, at vi har
set, hvad det gør?

1866
01:35:02,480 --> 01:35:06,730
Dens kopiere den værdi, hash
defineret er defineret som og indsætte som

1867
01:35:06,730 --> 01:35:08,500
uanset hvor du bruger værdien.

1868
01:35:08,500 --> 01:35:13,400
Så forprocessoren gør bare virkelig
simple tekstbaserede operationer.

1869
01:35:13,400 --> 01:35:15,870
Det gør ikke noget smart.

1870
01:35:15,870 --> 01:35:18,920
Så alt andet er
mere kompliceret.

1871
01:35:18,920 --> 01:35:22,970
>> Så nu, at præprocessoren
gjort, vi faktisk kompilere.

1872
01:35:22,970 --> 01:35:24,320
Så hvad betyder kompilere betyde?

1873
01:35:24,320 --> 01:35:27,310
Vi overvåger nu gå fra C-kode
til samling kode.

1874
01:35:27,310 --> 01:35:27,570
Ja?

1875
01:35:27,570 --> 01:35:28,820
>> Publikum: [uhørligt]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ROB: Ja, vi fanget det.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
Så kompilering.

1880
01:35:38,660 --> 01:35:40,310
Vi går fra C til montering.

1881
01:35:40,310 --> 01:35:42,470
Så dette er et virkeligt sprogforandring.

1882
01:35:42,470 --> 01:35:45,240
Kompilering selv betyder at gå fra
højniveausprog til

1883
01:35:45,240 --> 01:35:47,340
et lavere niveau sprog.

1884
01:35:47,340 --> 01:35:50,720
>> Og C er et højniveausprog
i forhold til samlingen.

1885
01:35:50,720 --> 01:35:52,320
Hvad er samling?

1886
01:35:52,320 --> 01:35:56,440
Dets instruktioner, der er, temmelig
meget, lavet til din CPU.

1887
01:35:56,440 --> 01:35:59,130
Men computeren stadig gør
ikke forstå forsamling.

1888
01:35:59,130 --> 01:36:01,570
Det kun forstår ettaller og nuller.

1889
01:36:01,570 --> 01:36:06,160
Så næste skridt er at samle, som
bringer os fra disse instruktioner, som

1890
01:36:06,160 --> 01:36:08,760
din CPU forstår og faktisk
oversætter dem til

1891
01:36:08,760 --> 01:36:10,820
de ettaller og nuller.

1892
01:36:10,820 --> 01:36:13,570
>> Så C til samling til binær.

1893
01:36:13,570 --> 01:36:15,870
Men jeg har ikke en eksekverbar endnu.

1894
01:36:15,870 --> 01:36:19,550
Så tænk på det CS50 biblioteket.

1895
01:36:19,550 --> 01:36:23,070
Vi har givet dig med en binær for
denne CS50 bibliotek, som har getString

1896
01:36:23,070 --> 01:36:24,400
og GetInt og alt det der.

1897
01:36:24,400 --> 01:36:25,700
>> Men det CS50 library--

1898
01:36:25,700 --> 01:36:27,650
i og for itself-- er ikke eksekverbar.

1899
01:36:27,650 --> 01:36:29,570
Det har ikke en hovedfunktion.

1900
01:36:29,570 --> 01:36:32,230
Det er bare en flok af binære
som du kan bruge.

1901
01:36:32,230 --> 01:36:41,730
Så forbinder er, hvordan vi samle alle
disse forskellige binære filer

1902
01:36:41,730 --> 01:36:43,110
i et virkeligt eksekverbar.

1903
01:36:43,110 --> 01:36:45,900
En, som du kan skrive
prik skråstreg en prik ud.

1904
01:36:45,900 --> 01:36:51,660
>> Så dette er ligesom den fil, du
skrev, - uanset dit program er--

1905
01:36:51,660 --> 01:36:53,620
Ceaser prik C.

1906
01:36:53,620 --> 01:36:55,100
Men nu er det blevet udarbejdet
ned til binær.

1907
01:36:55,100 --> 01:36:56,480
Så Ceaser prik o.

1908
01:36:56,480 --> 01:36:59,620
Og det er vores CS50 biblioteker binær.

1909
01:36:59,620 --> 01:37:02,284
Og de bliver kombineret
i en enkelt eksekverbar.

1910
01:37:02,284 --> 01:37:02,758
Ja?

1911
01:37:02,758 --> 01:37:04,008
>> Publikum: [uhørligt]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ROB: Så først omfatte husk,
hash omfatte, er faktisk en

1914
01:37:12,710 --> 01:37:13,810
pre-processoren trin.

1915
01:37:13,810 --> 01:37:14,750
Men det er adskilt.

1916
01:37:14,750 --> 01:37:20,730
Hvis du ikke bruger nogen funktioner, der
er uden for din enkelt fil og derefter,

1917
01:37:20,730 --> 01:37:26,100
nej, behøver du ikke at linke noget
da du har alt.

1918
01:37:26,100 --> 01:37:30,310
>> Når det er sagt, printf bliver bundet ind.

1919
01:37:30,310 --> 01:37:32,820
Hvis du nogensinde bruger printf, det er noget
der skal være forbundet i

1920
01:37:32,820 --> 01:37:35,740
fordi du ikke skrive det.

1921
01:37:35,740 --> 01:37:39,530
Og faktisk printf automatisk
forbundet i.

1922
01:37:39,530 --> 01:37:42,760
Du ved, hvordan på kommandolinjen, eller når
du skriver gøre, du ser det har

1923
01:37:42,760 --> 01:37:46,690
dash l CS50, som har link
i CS50 biblioteket?

1924
01:37:46,690 --> 01:37:49,070
Printf, og den slags, der foregår
at være forbundet automatisk.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
Alle andre spørgsmål om noget?

1927
01:37:53,930 --> 01:37:56,280
>> Publikum: [uhørligt]?

1928
01:37:56,280 --> 01:37:58,300
>> ROB: Sammenkædning?

1929
01:37:58,300 --> 01:38:03,450
Vi har en hel bunke af
forskellige binære filer.

1930
01:38:03,450 --> 01:38:06,410
Dette er den kanoniske eksempel
at vi bruger, er CS50 biblioteket.

1931
01:38:06,410 --> 01:38:09,960
Vi har samlet og givet til dig
binær for denne CS50 bibliotek.

1932
01:38:09,960 --> 01:38:12,410
>> Du ønsker at bruge getString
i dit program.

1933
01:38:12,410 --> 01:38:14,750
Så du gå og bruge getString.

1934
01:38:14,750 --> 01:38:19,700
Men uden min binær kode til
GetString, når du kompilere din kode

1935
01:38:19,700 --> 01:38:23,140
ned, kan du faktisk ikke køre din
program, fordi getString String er

1936
01:38:23,140 --> 01:38:25,080
endnu ikke defineret.

1937
01:38:25,080 --> 01:38:29,220
>> Det er kun, når du linker i min binær
som indeholder getString der nu alle

1938
01:38:29,220 --> 01:38:31,130
Okay, jeg kan faktisk
udføre getString.

1939
01:38:31,130 --> 01:38:32,330
Min fil er færdig.

1940
01:38:32,330 --> 01:38:34,208
Og jeg kan køre dette.

1941
01:38:34,208 --> 01:38:34,697
Ja?

1942
01:38:34,697 --> 01:38:37,631
>> PUBLIKUM: Er koble konvertere
den binære til eksekverbare?

1943
01:38:37,631 --> 01:38:42,032
Så selvom du ikke har andre
biblioteker, ville det stadig være

1944
01:38:42,032 --> 01:38:44,477
nødvendigt at oversætte
det [uhørligt]?

1945
01:38:44,477 --> 01:38:48,640
>> ROB: Så en eksekverbar
er stadig i binær.

1946
01:38:48,640 --> 01:38:51,750
Det er bare at kombinere en helhed
bundt af binære filer.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> Publikum: Tak så meget.

1949
01:38:56,591 --> 01:38:58,560
>> ROB: Intet problem.

1950
01:38:58,560 --> 01:38:59,540
Andre spørgsmål?

1951
01:38:59,540 --> 01:39:02,001
Ellers er vi alle indstillet.

1952
01:39:02,001 --> 01:39:02,690
Okay.

1953
01:39:02,690 --> 01:39:02,990
Tak.

1954
01:39:02,990 --> 01:39:03,590
>> [Applaus]

1955
01:39:03,590 --> 01:39:04,490
>> PUBLIKUM: Tak.

1956
01:39:04,490 --> 01:39:05,740
>> ROB: Ja.

1957
01:39:05,740 --> 01:39:06,582