1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Week 4]

2
00:00:03,000 --> 00:00:05,000
[David J. Malan] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
[Dit is CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Oke, dit is CS50, en dit is het begin van week 4,

5
00:00:12,000 --> 00:00:16,000
en dit is een van de laagst mogelijke sorteeralgoritmen.

6
00:00:16,000 --> 00:00:19,000
Welke was het dat we er gewoon gekeken?

7
00:00:19,000 --> 00:00:24,000
Dat was bubble sort, om grote O (n ^ 2) + sum,

8
00:00:24,000 --> 00:00:28,000
en inderdaad we zijn niet de enigen in deze wereld lijken te weten

9
00:00:28,000 --> 00:00:30,000
wat bubble sort is of de looptijd.

10
00:00:30,000 --> 00:00:33,000
Inderdaad, dit was een interview met Eric Schmidt van Google

11
00:00:33,000 --> 00:00:45,000
en voormalig senator Barack Obama slechts een paar jaar geleden.

12
00:00:45,000 --> 00:00:48,000
>> Nu, Senator, je bent hier bij Google,

13
00:00:48,000 --> 00:00:54,000
en ik wil graag van het voorzitterschap te zien als een sollicitatiegesprek.

14
00:00:54,000 --> 00:00:58,000
Nu, het is moeilijk om een ​​baan te krijgen als president, en je gaat door de ontberingen nu.

15
00:00:58,000 --> 00:01:00,000
Het is ook moeilijk om een ​​baan bij Google.

16
00:01:00,000 --> 00:01:05,000
Wij hebben vragen, en we vragen onze kandidaten vragen,

17
00:01:05,000 --> 00:01:10,000
en deze is van Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Jullie denken dat ik een grapje maak? Het is hier.

19
00:01:14,000 --> 00:01:18,000
Wat is de meest efficiënte manier om een ​​miljoen 32-bit integers te sorteren?

20
00:01:18,000 --> 00:01:21,000
[Gelach]

21
00:01:21,000 --> 00:01:24,000
Goed

22
00:01:24,000 --> 00:01:26,000
Het spijt me. >> Nee, nee, nee, nee.

23
00:01:26,000 --> 00:01:34,000
Ik denk dat de bubble sort zou de verkeerde weg te gaan.

24
00:01:34,000 --> 00:01:39,000
>> Kom op, die hem vertelde dat?

25
00:01:39,000 --> 00:01:43,000
Vorige week herinneren namen we een pauze van code, ten minste voor een dag,

26
00:01:43,000 --> 00:01:46,000
en begon zich richt op een hoger niveau ideeën en het oplossen van problemen meer in het algemeen

27
00:01:46,000 --> 00:01:49,000
in de context van het zoeken en sorteren,

28
00:01:49,000 --> 00:01:53,000
en introduceerden wij iets dat we niet deze naam klap op vorige week,

29
00:01:53,000 --> 00:01:56,000
maar asymptotische notatie, de Big O, de Big Omega,

30
00:01:56,000 --> 00:02:00,000
en soms de Big Theta notatie, en deze waren gewoon manieren

31
00:02:00,000 --> 00:02:02,000
van het beschrijven van de looptijd van algoritmen,

32
00:02:02,000 --> 00:02:05,000
hoeveel tijd het duurt voor een algoritme om te draaien.

33
00:02:05,000 --> 00:02:08,000
>> En je kunt dat je sprak over de looptijd herinneren in termen van de omvang

34
00:02:08,000 --> 00:02:11,000
van de input, die over het algemeen noemen we n, wat het probleem ook mag zijn,

35
00:02:11,000 --> 00:02:13,000
waarbij n het aantal mensen in de kamer,

36
00:02:13,000 --> 00:02:17,000
het aantal pagina's in een telefoonboek, en we begonnen om dingen te schrijven

37
00:02:17,000 --> 00:02:21,000
zoals O (n ^ 2) of O (n) of O (n log n),

38
00:02:21,000 --> 00:02:24,000
en zelfs wanneer de wiskunde niet helemaal uit te werken zo perfect

39
00:02:24,000 --> 00:02:28,000
en het was n ² - n / 2 of iets dergelijks

40
00:02:28,000 --> 00:02:31,000
We zouden in plaats daarvan gewoon weggooien enkele van de lagere orde termen,

41
00:02:31,000 --> 00:02:34,000
en de motivatie er is dat we echt een

42
00:02:34,000 --> 00:02:37,000
soort objectieve manier van evalueren

43
00:02:37,000 --> 00:02:39,000
de prestaties van programma's of het uitvoeren van algoritmen

44
00:02:39,000 --> 00:02:42,000
dat aan het eind van de dag heeft niets bijvoorbeeld

45
00:02:42,000 --> 00:02:45,000
met de snelheid van uw computer vandaag.

46
00:02:45,000 --> 00:02:47,000
>> Bijvoorbeeld, als u de uitvoering van bubble sort,

47
00:02:47,000 --> 00:02:50,000
of u de uitvoering van samenvoegen sorteren of selectie sorteren op de computer van vandaag,

48
00:02:50,000 --> 00:02:53,000
een 2 GHz computer, en je het draait,

49
00:02:53,000 --> 00:02:56,000
en het duurt even aantal seconden, volgend jaar is er een 3 GHz

50
00:02:56,000 --> 00:02:59,000
of een 4 GHz computer, en je zou dan beweren dat "Wow, mijn algoritme

51
00:02:59,000 --> 00:03:03,000
is nu twee keer zo snel, "terwijl in werkelijkheid die duidelijk niet het geval.

52
00:03:03,000 --> 00:03:06,000
Het is gewoon de hardware heeft gekregen sneller, maar uw computer

53
00:03:06,000 --> 00:03:10,000
nog niet, en dus hebben we echt willen weggooien zaken als

54
00:03:10,000 --> 00:03:13,000
veelvouden van 2 of veelvouden van 3 als het gaat om beschrijven

55
00:03:13,000 --> 00:03:17,000
hoe snel of hoe traag een algoritme is en eigenlijk alleen maar focussen

56
00:03:17,000 --> 00:03:20,000
n on of een factor daarvan,

57
00:03:20,000 --> 00:03:24,000
wat kracht daarvan, zoals in het geval van de soorten van vorige week.

58
00:03:24,000 --> 00:03:27,000
En herinneren dat met de hulp van merge sort

59
00:03:27,000 --> 00:03:31,000
we waren in staat om te doen zo veel beter dan bubble sort en selectie sorteren

60
00:03:31,000 --> 00:03:33,000
en zelfs insertion sort.

61
00:03:33,000 --> 00:03:36,000
>> We gingen aan n log n, en opnieuw,

62
00:03:36,000 --> 00:03:39,000
herinneren eraan dat log n het algemeen verwijst naar iets dat groeit

63
00:03:39,000 --> 00:03:43,000
langzamer dan n, dus n log n tot nu toe was goed

64
00:03:43,000 --> 00:03:45,000
want het was minder dan n ².

65
00:03:45,000 --> 00:03:47,000
Maar om te bereiken n n inloggen met merge sort

66
00:03:47,000 --> 00:03:51,000
wat was de basis kiem van een idee dat we hadden om gebruik te maken

67
00:03:51,000 --> 00:03:54,000
dat we ook weer ingezet in week 0?

68
00:03:54,000 --> 00:03:58,000
Hoe hebben we slim aanpakken van de sorteer-probleem met merge sort?

69
00:03:58,000 --> 00:04:04,000
Wat was de belangrijkste inzicht, misschien?

70
00:04:04,000 --> 00:04:07,000
Wie dan ook.

71
00:04:07,000 --> 00:04:09,000
Oke, laten we een stap terug.

72
00:04:09,000 --> 00:04:11,000
Beschrijf samenvoegen sorteren in je eigen woorden.

73
00:04:11,000 --> 00:04:15,000
Hoe is het?

74
00:04:15,000 --> 00:04:17,000
Oke, we komen terug roeien naar week 0.

75
00:04:17,000 --> 00:04:19,000
Oke, ja.

76
00:04:19,000 --> 00:04:22,000
[Onverstaanbaar-student]

77
00:04:22,000 --> 00:04:26,000
Oke, goed, dus hebben we de reeks van getallen in 2 stukken.

78
00:04:26,000 --> 00:04:29,000
Wij gesorteerd elk van deze stukken, en dan hebben we samengevoegd hen,

79
00:04:29,000 --> 00:04:33,000
en we hebben gezien dit idee voor het nemen van een probleem dat is dit grote

80
00:04:33,000 --> 00:04:36,000
en hakken op in een probleem dat is dit groot of zo groot.

81
00:04:36,000 --> 00:04:38,000
>> Roep het telefoonboek voorbeeld.

82
00:04:38,000 --> 00:04:42,000
Herinneren aan de self-telling algoritme van weken geleden,

83
00:04:42,000 --> 00:04:45,000
dus samenvoegen sorteren werd samengevat in de pseudocode hier.

84
00:04:45,000 --> 00:04:48,000
Als je n elementen gegeven, eerst was het gezond verstand te controleren.

85
00:04:48,000 --> 00:04:51,000
Als n <2 doe het dan niet helemaal niets

86
00:04:51,000 --> 00:04:55,000
want als n <2 is n duidelijk 0 of 1,

87
00:04:55,000 --> 00:04:57,000
en dus als het 0 of 1 is er niets om te sorteren.

88
00:04:57,000 --> 00:04:59,000
Je bent klaar.

89
00:04:59,000 --> 00:05:01,000
Uw lijst is al triviaal gesorteerd.

90
00:05:01,000 --> 00:05:04,000
Maar voor de rest als je 2 of meer elementen hebben ga je gang en verdeel ze

91
00:05:04,000 --> 00:05:06,000
in 2 helften, links en rechts.

92
00:05:06,000 --> 00:05:09,000
Sorteer elk van deze helften en vervolgens samenvoegen gesorteerd helften.

93
00:05:09,000 --> 00:05:13,000
Maar het probleem hier is dat op het eerste gezicht dit voelt alsof we punteren.

94
00:05:13,000 --> 00:05:17,000
Dit is een ronde definitie in dat als ik je gevraagd heb om deze n elementen sorteren

95
00:05:17,000 --> 00:05:22,000
en je zegt me dat 'Oke, prima, we sorteren de n / 2 en die n / 2 elementen, "

96
00:05:22,000 --> 00:05:27,000
dan is mijn volgende vraag gaat worden "Fine, hoe ga je de n / 2 elementen sorteren?"

97
00:05:27,000 --> 00:05:30,000
>> Maar vanwege de structuur van dit programma,

98
00:05:30,000 --> 00:05:33,000
want er is dit referentiemodel, om zo te zeggen,

99
00:05:33,000 --> 00:05:39,000
dit speciale geval, dat zegt dat als n is <een aantal vaste waarde als 2 return onmiddellijk.

100
00:05:39,000 --> 00:05:42,000
Reageer niet met diezelfde ronde antwoord.

101
00:05:42,000 --> 00:05:46,000
Dit proces, zal dit cycliciteit uiteindelijk te beëindigen.

102
00:05:46,000 --> 00:05:50,000
Als ik je vraag "Sorteer n elementen," en u zegt: "Fijn, sorteren van deze n / 2,"

103
00:05:50,000 --> 00:05:53,000
dan zeg je: "Fijn, sorteren deze n / 4, n / 8, n/16,"

104
00:05:53,000 --> 00:05:56,000
uiteindelijk zult u delen door een groot genoeg aantal

105
00:05:56,000 --> 00:05:59,000
dat heb je slechts 1 element links, op welk punt je kunt zeggen,

106
00:05:59,000 --> 00:06:02,000
"Hier, hier is een gesorteerd enkel element."

107
00:06:02,000 --> 00:06:06,000
Dan is de schittering van dit algoritme hier is af te leiden uit het feit

108
00:06:06,000 --> 00:06:09,000
dat als je eenmaal al deze individueel gesorteerde lijsten,

109
00:06:09,000 --> 00:06:12,000
die allemaal van grootte 1, welke als nutteloos,

110
00:06:12,000 --> 00:06:15,000
als je eenmaal begint ze samen te voegen en samen te voegen

111
00:06:15,000 --> 00:06:19,000
bouw je uiteindelijk als Rob deed in de video een uiteindelijk gesorteerde lijst.

112
00:06:19,000 --> 00:06:22,000
>> Maar dit idee gaat veel verder dan sorteren.

113
00:06:22,000 --> 00:06:26,000
Er is dit idee ingebed in het programma bekend als recursie

114
00:06:26,000 --> 00:06:29,000
van het idee om je een programma,

115
00:06:29,000 --> 00:06:32,000
en om een ​​probleem je jezelf noemt op te lossen,

116
00:06:32,000 --> 00:06:36,000
of zet in het kader van programmeertalen u een functie,

117
00:06:36,000 --> 00:06:39,000
en om een ​​probleem op te lossen, kunt u de functie noemt jezelf

118
00:06:39,000 --> 00:06:42,000
opnieuw en opnieuw en opnieuw, maar u de functie

119
00:06:42,000 --> 00:06:44,000
kan niet bellen jezelf oneindig vele malen.

120
00:06:44,000 --> 00:06:47,000
Uiteindelijk moet je naar beneden uit, zo te zeggen,

121
00:06:47,000 --> 00:06:49,000
en hebben een aantal hard-coded basis voorwaarde dat zegt

122
00:06:49,000 --> 00:06:53,000
op dit punt noem jezelf, zodat het hele proces

123
00:06:53,000 --> 00:06:56,000
eindelijk stopt in feite.

124
00:06:56,000 --> 00:06:58,000
Wat betekent dit eigenlijk, betekenen recurse?

125
00:06:58,000 --> 00:07:01,000
>> Laten we eens kijken, of we een eenvoudige, triviaal voorbeeld maken met, laten we zeggen,

126
00:07:01,000 --> 00:07:03,000
3 personen met me hier op het podium, als iemand is comfortabel.

127
00:07:03,000 --> 00:07:06,000
1, kom naar boven, 2 en 3.

128
00:07:06,000 --> 00:07:09,000
Als je 3 wilt om hier te komen.

129
00:07:09,000 --> 00:07:12,000
Als u wilt direct naast hier staan ​​om mij in een lijn, veronderstellen dat het probleem bij de hand

130
00:07:12,000 --> 00:07:15,000
is zeer triviaal tellen van het aantal mensen die hier zijn.

131
00:07:15,000 --> 00:07:18,000
Maar eerlijk gezegd, ik ben moe van al die tellen voorbeelden.

132
00:07:18,000 --> 00:07:21,000
Dit gaat enige tijd, 1, 2, en puntje, puntje, puntje te nemen.

133
00:07:21,000 --> 00:07:23,000
Het zal eeuwig duren.

134
00:07:23,000 --> 00:07:25,000
Ik zou liever gewoon punter dit probleem helemaal met de hulp van-wat is je naam?

135
00:07:25,000 --> 00:07:27,000
Sara. >> Sara, oke.

136
00:07:27,000 --> 00:07:29,000
Kelly. >> Kelly en?

137
00:07:29,000 --> 00:07:31,000
>> Willy. >> Willy, Sara, Kelly, en Willy.

138
00:07:31,000 --> 00:07:34,000
Op dit moment heb ik de vraag gesteld door iemand

139
00:07:34,000 --> 00:07:37,000
hoeveel mensen er op dit moment, en ik heb geen idee.

140
00:07:37,000 --> 00:07:40,000
Dit is echt een lange lijst, en dus in plaats daarvan ga ik deze truc te doen.

141
00:07:40,000 --> 00:07:43,000
Ik ga naar de persoon naast me het grootste deel van het werk te doen stellen,

142
00:07:43,000 --> 00:07:46,000
en zodra ze klaar is doet het meeste werk

143
00:07:46,000 --> 00:07:49,000
Ik ga naar de minste hoeveelheid werk mogelijk te doen en gewoon voeg 1

144
00:07:49,000 --> 00:07:51,000
aan wat haar antwoord is, dus hier gaan we.

145
00:07:51,000 --> 00:07:54,000
Ik ben gevraagd hoeveel mensen er op het podium.

146
00:07:54,000 --> 00:07:57,000
Hoeveel mensen zijn op het podium aan de linkerkant van je?

147
00:07:57,000 --> 00:08:00,000
Links van mij? >> Oke, maar speel niet vals.

148
00:08:00,000 --> 00:08:04,000
Dat is goed, dat klopt, maar als we willen deze logica verder

149
00:08:04,000 --> 00:08:08,000
laten we aannemen dat je net wilt om weg te schoppen dit probleem aan de linkerkant van je,

150
00:08:08,000 --> 00:08:11,000
dus in plaats van direct antwoord te gaan en gewoon afschuiven.

151
00:08:11,000 --> 00:08:14,000
O, hoeveel mensen zijn aan de linkerkant van mij?

152
00:08:14,000 --> 00:08:16,000
Hoeveel mensen zijn aan de linkerkant?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Gelach]

155
00:08:27,000 --> 00:08:30,000
Oke, dus 0, dus wat nu Willy heeft gedaan

156
00:08:30,000 --> 00:08:33,000
wordt u terug uw antwoord deze richting te zeggen 0.

157
00:08:33,000 --> 00:08:36,000
Nu, wat moet je doen? >> 1.

158
00:08:36,000 --> 00:08:39,000
Oke, dus je bent de 1, dus u zegt: "Oke, ik ga naar 1 toe te voegen

159
00:08:39,000 --> 00:08:41,000
naar wat Willy's tellen was, "zo 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Je bent nu 1, zodat uw antwoord aan de rechterkant is nu-

161
00:08:43,000 --> 00:08:45,000
1. >> En de mijne zou zijn 2.

162
00:08:45,000 --> 00:08:48,000
Goed, dus je neemt het vorige antwoord van 1,

163
00:08:48,000 --> 00:08:51,000
het toevoegen van de minimale hoeveelheid werk die je wilt doen, dat is +1.

164
00:08:51,000 --> 00:08:55,000
Je hebt nu 2, en je vervolgens met de hand me welke waarde?

165
00:08:55,000 --> 00:08:57,000
3, ik bedoel, sorry, 2.

166
00:08:57,000 --> 00:08:59,000
Goed.

167
00:08:59,000 --> 00:09:02,000
>> Nou, we hebben 0 naar links.

168
00:09:02,000 --> 00:09:05,000
Dan hadden we 1, en dan voegen we 2,

169
00:09:05,000 --> 00:09:07,000
en nu ben je gaf me het nummer 2,

170
00:09:07,000 --> 00:09:10,000
en dus ik zeg, oke, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Er zijn inderdaad 3 personen die naast mij op het podium,

172
00:09:13,000 --> 00:09:16,000
dus we konden natuurlijk gedaan hebben dit zeer lineair,

173
00:09:16,000 --> 00:09:19,000
heel veel in de voor de hand liggende manier, maar wat hebben we eigenlijk doen?

174
00:09:19,000 --> 00:09:21,000
We namen een probleem van maat 3 in eerste instantie.

175
00:09:21,000 --> 00:09:24,000
Daarna brak het naar beneden in een probleem van maat 2,

176
00:09:24,000 --> 00:09:27,000
dan is een probleem van de grootte 1, en dan uiteindelijk het nulalternatief

177
00:09:27,000 --> 00:09:29,000
was echt, oh, er is niemand daar,

178
00:09:29,000 --> 00:09:33,000
op welk punt Willy terug in feite een hard-gecodeerde antwoord een paar keer,

179
00:09:33,000 --> 00:09:36,000
en de tweede werd vervolgens omhoog borrelen, borrelen, borrelen,

180
00:09:36,000 --> 00:09:39,000
en vervolgens door toevoeging van deze extra 1

181
00:09:39,000 --> 00:09:41,000
we hebben geïmplementeerd dit basisidee van recursie.

182
00:09:41,000 --> 00:09:44,000
>> Nu in dit geval niet echt een probleem oplossen

183
00:09:44,000 --> 00:09:46,000
elke effectiever dan hebben we tot nu toe gezien.

184
00:09:46,000 --> 00:09:48,000
Maar denk over de algoritmen die we gedaan hebben op het podium tot nu toe.

185
00:09:48,000 --> 00:09:51,000
We 8 stukjes papier had op het bord,

186
00:09:51,000 --> 00:09:55,000
op video toen Sean was op zoek naar het nummer 7, en wat deed hij echt doen?

187
00:09:55,000 --> 00:09:58,000
Nou, heeft hij niet te doen elke vorm van verdeel en heers.

188
00:09:58,000 --> 00:10:01,000
Hij deed het niet elke vorm van recursie.

189
00:10:01,000 --> 00:10:03,000
In plaats van dat hij net deed deze lineaire algoritme.

190
00:10:03,000 --> 00:10:07,000
Maar als we het idee van gesorteerd nummers op het podium introduceerde leven vorige week

191
00:10:07,000 --> 00:10:09,000
toen hadden we dit instinct van het gaan naar het midden,

192
00:10:09,000 --> 00:10:13,000
op welk punt hadden we een kleine lijst van maat 4 of een andere lijst van grootte 4,

193
00:10:13,000 --> 00:10:17,000
en dan hebben we precies hetzelfde probleem hadden, dus we herhalen, herhalen, herhalen.

194
00:10:17,000 --> 00:10:19,000
Met andere woorden, we recursed.

195
00:10:19,000 --> 00:10:24,000
Hartelijk dank aan onze 3 vrijwilligers hier voor het aantonen van recursie met ons.

196
00:10:24,000 --> 00:10:28,000
>> Laten we eens kijken of we kunnen nu niet maken dit een beetje meer concreet,

197
00:10:28,000 --> 00:10:30,000
het oplossen van een probleem dat we weer konden vrij gemakkelijk te doen,

198
00:10:30,000 --> 00:10:34,000
maar we zullen het gebruiken als een opstapje naar de uitvoering van dit basisidee.

199
00:10:34,000 --> 00:10:37,000
Als ik wil de som van een aantal getallen te berekenen,

200
00:10:37,000 --> 00:10:39,000
bijvoorbeeld, als je pas in het nummer 3,

201
00:10:39,000 --> 00:10:42,000
Ik wil u de waarde van sigma 3,

202
00:10:42,000 --> 00:10:46,000
zodat de som van 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Ik wil terug te krijgen het antwoord 6,

204
00:10:48,000 --> 00:10:51,000
dus we zullen implementeren deze sigma functie, deze optelfunctie

205
00:10:51,000 --> 00:10:54,000
dat nog eens,, neemt in input, en vervolgens terug de sommatie

206
00:10:54,000 --> 00:10:57,000
van dat aantal helemaal naar beneden naar 0.

207
00:10:57,000 --> 00:10:59,000
We kunnen dit doen vrij eenvoudig, toch?

208
00:10:59,000 --> 00:11:01,000
We kunnen dit doen met een soort van looping structuur,

209
00:11:01,000 --> 00:11:04,000
dus laat me ga je gang en krijg deze gestart.

210
00:11:04,000 --> 00:11:07,000
>> Inclusief stdio.h.

211
00:11:07,000 --> 00:11:09,000
Laat me mezelf in de belangrijkste om mee te werken hier.

212
00:11:09,000 --> 00:11:12,000
Laten we dit opslaan als sigma.c.

213
00:11:12,000 --> 00:11:14,000
Dan ga ik naar binnen hier, en ik ga naar een int n verklaren,

214
00:11:14,000 --> 00:11:18,000
en ik ga het volgende doen terwijl de gebruiker niet meewerkt.

215
00:11:18,000 --> 00:11:22,000
Terwijl de gebruiker heeft gegeven mij een positief getal

216
00:11:22,000 --> 00:11:26,000
laat me ga je gang en vraagt ​​hen voor n = GetInt,

217
00:11:26,000 --> 00:11:28,000
en laat mij hen wat instructies over wat te doen,

218
00:11:28,000 --> 00:11:33,000
dus printf ("positief geheel getal please").

219
00:11:33,000 --> 00:11:39,000
Gewoon iets relatief simpels als dit zodat tegen de tijd dat we lijn 14 geraakt

220
00:11:39,000 --> 00:11:42,000
hebben we nu een positief geheel getal vermoedelijk in n.

221
00:11:42,000 --> 00:11:44,000
>> Nu gaan we iets mee doen.

222
00:11:44,000 --> 00:11:50,000
Laat me ga je gang en berekenen de sommatie, dus int som = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma is gewoon sommatie, dus ik ben gewoon te schrijven op de liefhebber manier.

224
00:11:54,000 --> 00:11:56,000
We noemen het gewoon sigma daar.

225
00:11:56,000 --> 00:11:58,000
Dat is de som, en nu ga ik het afdrukken van het resultaat,

226
00:11:58,000 --> 00:12:08,000
printf ("De som is% d \ n", som).

227
00:12:08,000 --> 00:12:11,000
En dan zal ik terug 0 voor een goede maatregel.

228
00:12:11,000 --> 00:12:15,000
We hebben alles gedaan wat dit programma vereist met uitzondering van het interessante deel,

229
00:12:15,000 --> 00:12:18,000
die is om daadwerkelijk uitvoering van de sigma-functie.

230
00:12:18,000 --> 00:12:22,000
>> Laat me hier naar beneden naar de bodem, en laat me verklaren functie sigma.

231
00:12:22,000 --> 00:12:26,000
Het moet een variabele die is van het type integer te nemen,

232
00:12:26,000 --> 00:12:30,000
en welke data type wil ik vermoedelijk terugkeren van sigma?

233
00:12:30,000 --> 00:12:34,000
Int, want ik wil het aan mijn verwachtingen op lijn 15.

234
00:12:34,000 --> 00:12:37,000
Hierin laat me gaan en uitvoering van deze

235
00:12:37,000 --> 00:12:41,000
in een mooie eenvoudige manier.

236
00:12:41,000 --> 00:12:45,000
>> Laten we verder gaan en zeggen: int som = 0,

237
00:12:45,000 --> 00:12:47,000
en nu ga ik naar hier een beetje for-lus

238
00:12:47,000 --> 00:12:50,000
dat gaat om iets als dit te zeggen,

239
00:12:50,000 --> 00:13:01,000
for (int i = 0; I <= aantal; i + +) som + = i.

240
00:13:01,000 --> 00:13:05,000
En dan ga ik som terug te keren.

241
00:13:05,000 --> 00:13:07,000
Ik zou hebben dit in een aantal manieren.

242
00:13:07,000 --> 00:13:09,000
Ik kon een while-lus.

243
00:13:09,000 --> 00:13:11,000
Ik had overgeslagen met behulp van de som variabele als ik echt zou willen,

244
00:13:11,000 --> 00:13:15,000
maar in het kort, we hoeven alleen maar een functie, dat als ik niet goof verklaart som is 0.

245
00:13:15,000 --> 00:13:18,000
Dan herhaalt zich van 0 op omhoog door het aantal,

246
00:13:18,000 --> 00:13:23,000
en op elke iteratie voegt dat de huidige waarde voor som en keert dan terug som.

247
00:13:23,000 --> 00:13:25,000
>> Nu, er is een lichte optimalisatie hier.

248
00:13:25,000 --> 00:13:29,000
Dit is waarschijnlijk een verspilde stap, maar het zij zo. Dat is prima voor nu.

249
00:13:29,000 --> 00:13:32,000
We zijn in ieder geval zijn grondige en gaan 0 helemaal naar boven.

250
00:13:32,000 --> 00:13:34,000
Niet erg hard en vrij eenvoudig,

251
00:13:34,000 --> 00:13:37,000
maar het blijkt dat met de sigma functie die we dezelfde kans hebben

252
00:13:37,000 --> 00:13:39,000
zoals we hier deden op het podium.

253
00:13:39,000 --> 00:13:42,000
Op het podium hebben we net geteld hoeveel mensen er naast me,

254
00:13:42,000 --> 00:13:47,000
maar in plaats daarvan als we wilden het nummer 3 + 2 + 1 tellen

255
00:13:47,000 --> 00:13:51,000
op tot 0 we konden net punter om een ​​functie te

256
00:13:51,000 --> 00:13:55,000
dat ik in plaats daarvan omschrijven als recursieve.

257
00:13:55,000 --> 00:13:57,000
Hier laten we het doen een snelle geestelijke gezondheid te controleren en zorg ervoor dat ik niet goof.

258
00:13:57,000 --> 00:14:00,000
>> Ik weet dat er in ieder geval een ding in dit programma, dat heb ik verkeerd gedaan.

259
00:14:00,000 --> 00:14:04,000
Als ik druk op enter ga ik elke vorm van schreeuwen tegen mij te krijgen?

260
00:14:04,000 --> 00:14:06,000
Wat ga ik worden uitgescholden over?

261
00:14:06,000 --> 00:14:11,000
Ja, ik vergat het prototype, dus ik ben een functie genaamd sigma on line 15 gebruikt,

262
00:14:11,000 --> 00:14:16,000
maar het is niet verklaard tot lijn 22, dus ik best proactief hier naar boven

263
00:14:16,000 --> 00:14:22,000
en verklaren een prototype, en ik zal zeggen int sigma (int getal), en dat is het.

264
00:14:22,000 --> 00:14:24,000
Het is uitgevoerd aan de onderkant.

265
00:14:24,000 --> 00:14:27,000
>> Of een andere manier kon ik dit oplossen,

266
00:14:27,000 --> 00:14:30,000
Ik kon bewegen de functie daar, dat is niet slecht,

267
00:14:30,000 --> 00:14:32,000
maar in ieder geval als je programma's beginnen te krijgen lang, eerlijk gezegd,

268
00:14:32,000 --> 00:14:35,000
Ik denk dat er enige waarde in altijd met de belangrijkste aan de top

269
00:14:35,000 --> 00:14:38,000
zodat je in de lezer kan het bestand openen en dan meteen zien

270
00:14:38,000 --> 00:14:40,000
wat het programma doet zonder te zoeken door middel van het

271
00:14:40,000 --> 00:14:42,000
op zoek naar die hoofdfunctie.

272
00:14:42,000 --> 00:14:49,000
Laten we hier beneden naar mijn terminal-venster, kunt u proberen om sigma maken sigma,

273
00:14:49,000 --> 00:14:51,000
en ik verpest hier ook.

274
00:14:51,000 --> 00:14:55,000
Impliciete verklaring van de functie GetInt betekent dat ik ben vergeten om wat anders te doen?

275
00:14:55,000 --> 00:14:57,000
[Onverstaanbaar-student]

276
00:14:57,000 --> 00:15:00,000
Goed, dus blijkbaar een veel voorkomende fout, dus laten we hier zet deze omhoog,

277
00:15:00,000 --> 00:15:04,000
cs50.h, en nu laten we terug gaan naar mijn terminal venster.

278
00:15:04,000 --> 00:15:08,000
>> Ik zal het scherm op, en ik zal opnieuw uit te voeren maken sigma.

279
00:15:08,000 --> 00:15:11,000
Het lijkt te zijn samengesteld. Laat me nu sigma uit te voeren.

280
00:15:11,000 --> 00:15:15,000
Ik typ in het nummer 3, en ik heb wel 6, dus niet een rigoureuze controle,

281
00:15:15,000 --> 00:15:18,000
maar in ieder geval lijkt te werken op het eerste gezicht, maar nu laten we rippen uit elkaar,

282
00:15:18,000 --> 00:15:21,000
en laten we maken gebruik van eigenlijk het idee van recursie, nogmaals,

283
00:15:21,000 --> 00:15:24,000
in een zeer eenvoudige context zodat in een enkele weken

284
00:15:24,000 --> 00:15:27,000
wanneer we beginnen met het verkennen liefhebber datastructuren dan arrays

285
00:15:27,000 --> 00:15:30,000
hebben we een ander hulpmiddel in de toolkit waarmee

286
00:15:30,000 --> 00:15:33,000
manipuleren die datastructuren zoals we zullen zien.

287
00:15:33,000 --> 00:15:36,000
Dit is de iteratieve aanpak, de loop-gebaseerde aanpak.

288
00:15:36,000 --> 00:15:39,000
>> In plaats daarvan laat ik nu doen.

289
00:15:39,000 --> 00:15:44,000
Laat ik in plaats daarvan zeggen dat de som van het aantal

290
00:15:44,000 --> 00:15:48,000
op tot 0 is echt hetzelfde als

291
00:15:48,000 --> 00:15:53,000
nummer + sigma (nummer - 1).

292
00:15:53,000 --> 00:15:57,000
Met andere woorden, net zoals op het podium sta punted aan elk van de mensen naast me,

293
00:15:57,000 --> 00:16:00,000
en zij op hun beurt hielden punteren tot we uiteindelijk een dieptepunt van Willy,

294
00:16:00,000 --> 00:16:03,000
die had een hard-gecodeerde antwoord graag 0 terug te keren.

295
00:16:03,000 --> 00:16:07,000
Hier nu zijn we net punteren naar sigma

296
00:16:07,000 --> 00:16:10,000
dezelfde functie als werd oorspronkelijk genoemd, maar de sleutel inzicht hier

297
00:16:10,000 --> 00:16:12,000
is dat we niet sigma belt identiek.

298
00:16:12,000 --> 00:16:14,000
We zijn niet passeren in n.

299
00:16:14,000 --> 00:16:17,000
We zijn duidelijk voorbij in aantal - 1,

300
00:16:17,000 --> 00:16:20,000
dus een iets kleinere probleem iets kleiner probleem.

301
00:16:20,000 --> 00:16:23,000
>> Helaas is dit niet echt een oplossing nog vast en voordat we

302
00:16:23,000 --> 00:16:26,000
wat kan worden springen als voor de hand liggend bij een aantal van u

303
00:16:26,000 --> 00:16:28,000
laat me gaan en herhaling te maken.

304
00:16:28,000 --> 00:16:30,000
Het lijkt te compileren oke.

305
00:16:30,000 --> 00:16:32,000
Laat me sigma opnieuw uit te voeren met 6.

306
00:16:32,000 --> 00:16:37,000
Oeps, laat me sigma opnieuw uit te voeren met 6.

307
00:16:37,000 --> 00:16:42,000
We hebben dit eerder gezien, zij het per ongeluk vorige keer ook.

308
00:16:42,000 --> 00:16:48,000
Waarom heb ik deze cryptische segmentation fault? Ja.

309
00:16:48,000 --> 00:16:50,000
[Onverstaanbaar-student]

310
00:16:50,000 --> 00:16:53,000
Er is geen base case, en meer specifiek, wat waarschijnlijk is er gebeurd?

311
00:16:53,000 --> 00:16:58,000
Dit is een symptoom van wat gedrag?

312
00:16:58,000 --> 00:17:00,000
Zeg het een beetje luider.

313
00:17:00,000 --> 00:17:02,000
[Onverstaanbaar-student]

314
00:17:02,000 --> 00:17:05,000
Het is een oneindige lus effectief, en het probleem met oneindige lussen

315
00:17:05,000 --> 00:17:08,000
wanneer recursie betrokken in dit geval een functie die zichzelf,

316
00:17:08,000 --> 00:17:10,000
wat er gebeurt elke keer als je belt een functie?

317
00:17:10,000 --> 00:17:13,000
Nou, terugdenken aan hoe we aangelegd het geheugen in een computer.

318
00:17:13,000 --> 00:17:16,000
We gezegd dat er dit stuk genoemd geheugen stack dat onderaan

319
00:17:16,000 --> 00:17:19,000
en elke keer als je belt een functie een beetje meer geheugen wordt gezet

320
00:17:19,000 --> 00:17:24,000
Op deze zogenaamde stapel met die functie lokale variabelen of parameters,

321
00:17:24,000 --> 00:17:27,000
dus als sigma belt sigma gesprekken sigma belt sigma

322
00:17:27,000 --> 00:17:29,000
 noemt sigma waar komt dit verhaal eindigen?

323
00:17:29,000 --> 00:17:31,000
>> Nou, het uiteindelijk overschrijdingen het totale bedrag

324
00:17:31,000 --> 00:17:33,000
van het geheugen dat u beschikbaar hebben op uw computer.

325
00:17:33,000 --> 00:17:37,000
U overspoeld het segment dat je moet blijven binnen,

326
00:17:37,000 --> 00:17:40,000
en u deze segmentatie fout te krijgen, core dumped,

327
00:17:40,000 --> 00:17:43,000
en wat core dumped betekent is dat ik nu een bestand genaamd kern hebben

328
00:17:43,000 --> 00:17:46,000
Dit is een bestand met nullen en enen

329
00:17:46,000 --> 00:17:49,000
die daadwerkelijk in de toekomst zal zijn diagnostisch nuttig.

330
00:17:49,000 --> 00:17:52,000
Als het niet voor de hand om u waar uw bug is

331
00:17:52,000 --> 00:17:54,000
je kunt eigenlijk doen een beetje van forensische analyse, om zo te zeggen,

332
00:17:54,000 --> 00:17:58,000
op deze core dump file, wat, nogmaals, is gewoon een hele hoop van nullen en enen

333
00:17:58,000 --> 00:18:02,000
dat vertegenwoordigt in wezen de staat van uw programma in het geheugen

334
00:18:02,000 --> 00:18:05,000
Momenteel crashte op deze manier.

335
00:18:05,000 --> 00:18:11,000
>> De oplossing hier is dat we niet zomaar blindelings terugkeren sigma,

336
00:18:11,000 --> 00:18:14,000
+ het aantal sigma een iets kleiner probleem.

337
00:18:14,000 --> 00:18:16,000
We moeten een soort van base case hier hebben,

338
00:18:16,000 --> 00:18:19,000
en wat moet de base case waarschijnlijk?

339
00:18:19,000 --> 00:18:22,000
[Onverstaanbaar-student]

340
00:18:22,000 --> 00:18:25,000
Oke, dus zolang het aantal positieve is dat we moeten eigenlijk terug dit,

341
00:18:25,000 --> 00:18:29,000
of anders gezegd, als getal, bijvoorbeeld <= aan 0

342
00:18:29,000 --> 00:18:32,000
weet je wat, ik vooruit ga en terug 0,

343
00:18:32,000 --> 00:18:36,000
net als Willy deed, en anders ga ik om verder te gaan

344
00:18:36,000 --> 00:18:41,000
en terug te keren dit, dus het is niet zo veel korter

345
00:18:41,000 --> 00:18:44,000
dan de iteratieve versie die we opgezweept het eerste gebruik van een for-lus,

346
00:18:44,000 --> 00:18:48,000
maar merkt dat er dit soort van elegantie aan.

347
00:18:48,000 --> 00:18:51,000
In plaats van een getal en het uitvoeren van alle deze wiskunde

348
00:18:51,000 --> 00:18:54,000
en het toevoegen van dingen met lokale variabelen

349
00:18:54,000 --> 00:18:57,000
je in plaats daarvan te zeggen: "Oke, als dit een super eenvoudig probleem,

350
00:18:57,000 --> 00:19:01,000
zoals het aantal is <0, laat me onmiddellijk 0 terug te keren. "

351
00:19:01,000 --> 00:19:03,000
>> We gaan niet aan de ondersteuning van negatieve getallen moeite,

352
00:19:03,000 --> 00:19:05,000
dus ik ga hard code de waarde 0.

353
00:19:05,000 --> 00:19:08,000
Maar voor de rest, om dit idee van het optellen te implementeren

354
00:19:08,000 --> 00:19:11,000
al deze getallen bij elkaar kun je effectief neem een ​​hapje

355
00:19:11,000 --> 00:19:14,000
uit van het probleem, net als wij deden hier op het podium,

356
00:19:14,000 --> 00:19:18,000
dan punter de rest van het probleem naar de volgende persoon,

357
00:19:18,000 --> 00:19:20,000
maar in dit geval de volgende persoon zelf.

358
00:19:20,000 --> 00:19:22,000
Het is een identiek genaamd functie.

359
00:19:22,000 --> 00:19:25,000
Net voorbij het een kleiner en kleiner probleem telkens

360
00:19:25,000 --> 00:19:28,000
en ook al hebben we niet helemaal geformaliseerd dingen in de code hier in

361
00:19:28,000 --> 00:19:33,000
dit is precies wat er gaande was in week 0 met het telefoonboek.

362
00:19:33,000 --> 00:19:36,000
Dit is precies wat er gaande was in afgelopen weken met Sean

363
00:19:36,000 --> 00:19:39,000
en met onze demonstraties van het zoeken naar nummers.

364
00:19:39,000 --> 00:19:42,000
Het nemen van een probleem en te delen opnieuw en opnieuw.

365
00:19:42,000 --> 00:19:44,000
>> Met andere woorden, er is een manier om nu te vertalen

366
00:19:44,000 --> 00:19:47,000
deze echte wereld construct, dit hogere niveau constructie

367
00:19:47,000 --> 00:19:51,000
van verdeel en heers en iets te doen opnieuw en opnieuw

368
00:19:51,000 --> 00:19:56,000
in de code, dus dit is iets wat we zullen weer te zien in de tijd.

369
00:19:56,000 --> 00:20:00,000
Nu, als een terzijde, als je nieuw bent bij recursie moet je op zijn minst begrijpen nu

370
00:20:00,000 --> 00:20:02,000
waarom dit grappig.

371
00:20:02,000 --> 00:20:05,000
Ik ga naar google.com,

372
00:20:05,000 --> 00:20:17,000
en ik ga op zoek naar een aantal tips en trucs over recursie, in te voeren.

373
00:20:17,000 --> 00:20:21,000
Vertel de persoon naast je als ze niet lachen op dit moment.

374
00:20:21,000 --> 00:20:23,000
Bedoelde u recursie?

375
00:20:23,000 --> 00:20:25,000
Bedoelde u-ah, daar gaan we.

376
00:20:25,000 --> 00:20:28,000
Oke, nu dat is de rest van iedereen.

377
00:20:28,000 --> 00:20:30,000
Een beetje Paasei er ergens ingebed in Google.

378
00:20:30,000 --> 00:20:33,000
Even terzijde, een van de links die we op de website van de cursus

379
00:20:33,000 --> 00:20:36,000
voor vandaag is juist dit raster van verschillende sorteren algoritmen,

380
00:20:36,000 --> 00:20:39,000
waarvan sommige hebben we gekeken naar vorige week, maar wat er leuk is aan deze visualisatie

381
00:20:39,000 --> 00:20:43,000
als je probeert om je geest wrap rond diverse zaken gerelateerd aan de algoritmen

382
00:20:43,000 --> 00:20:46,000
weten dat u nu heel eenvoudig beginnen met verschillende soorten ingangen.

383
00:20:46,000 --> 00:20:50,000
De ingangen alle omgekeerd ingangen meestal gesorteerd, de ingangen willekeurige enzovoort.

384
00:20:50,000 --> 00:20:53,000
Als je probeert om, opnieuw, te onderscheiden die dingen in je geest

385
00:20:53,000 --> 00:20:57,000
beseffen dat deze URL op de website van de cursus op de Lectures pagina

386
00:20:57,000 --> 00:21:00,000
kan je helpen reden door een aantal van deze.

387
00:21:00,000 --> 00:21:05,000
>> Vandaag hebben we eindelijk om dit probleem op te lossen terug van een tijdje,

388
00:21:05,000 --> 00:21:08,000
en dat was dat deze swap functie gewoon niet werken,

389
00:21:08,000 --> 00:21:12,000
en wat was het fundamentele probleem met deze functie swap,

390
00:21:12,000 --> 00:21:15,000
waarvan het doel was wederom een ​​waarde wisselen hier en hier

391
00:21:15,000 --> 00:21:17,000
zodanig dat dit gebeurt?

392
00:21:17,000 --> 00:21:20,000
Deze niet echt werken. Waarom?

393
00:21:20,000 --> 00:21:22,000
Ja.

394
00:21:22,000 --> 00:21:28,000
[Onverstaanbaar-student]

395
00:21:28,000 --> 00:21:31,000
Precies, de verklaring voor deze bugginess

396
00:21:31,000 --> 00:21:34,000
simpelweg omdat wanneer u belt functies in C

397
00:21:34,000 --> 00:21:38,000
en die functies te nemen argumenten, zoals a en b hier,

398
00:21:38,000 --> 00:21:42,000
u passeert in kopieën van welke waarde u het verstrekken van die functie.

399
00:21:42,000 --> 00:21:46,000
U bent niet verstrekken van de oorspronkelijke waarden zelf,

400
00:21:46,000 --> 00:21:49,000
dus we zagen dit in het kader van buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, die een beetje zoiets als dit zag.

402
00:21:52,000 --> 00:21:57,000
>> Herinneren dat we x en y geïnitialiseerd op 1 en 2 respectievelijk.

403
00:21:57,000 --> 00:21:59,000
Vervolgens hebben we uitgeprint wat ze waren.

404
00:21:59,000 --> 00:22:03,000
Vervolgens heb ik beweerde dat ik ze wisselen door te bellen naar swap van x, y.

405
00:22:03,000 --> 00:22:06,000
Maar het probleem was dat de swapping werkte,

406
00:22:06,000 --> 00:22:10,000
maar alleen in het kader van de swap functioneren zelf.

407
00:22:10,000 --> 00:22:13,000
Zodra we raken lijn 40 die verwisseld waarden

408
00:22:13,000 --> 00:22:16,000
werden weggegooid, en dus niets

409
00:22:16,000 --> 00:22:21,000
in de oorspronkelijke functie belangrijkste was eigenlijk helemaal veranderd,

410
00:22:21,000 --> 00:22:26,000
dus als je denkt dat toen over hoe dit eruit ziet in termen van ons geheugen

411
00:22:26,000 --> 00:22:29,000
als dit linkerkant van het bord staat voor-

412
00:22:29,000 --> 00:22:33,000
en ik zal mijn best doen voor iedereen om te zien-als dit linkerkant van het bord

413
00:22:33,000 --> 00:22:37,000
vertegenwoordigt, zeg, uw RAM-geheugen, en de stapel gaat over opgroeien op deze manier,

414
00:22:37,000 --> 00:22:43,000
en we noemen een functie als hoofd-, en de belangrijkste heeft 2 lokale variabelen, x en y,

415
00:22:43,000 --> 00:22:48,000
laten we hier beschrijven die als x, en laten we deze hier beschrijven als y,

416
00:22:48,000 --> 00:22:55,000
en laten we in de waarden 1 en 2, dus dit hier de belangrijkste is,

417
00:22:55,000 --> 00:22:58,000
en als belangrijkste noemt de swap-functie van het besturingssysteem

418
00:22:58,000 --> 00:23:02,000
geeft de swap-functie zijn eigen baan van het geheugen op de stack,

419
00:23:02,000 --> 00:23:04,000
zijn eigen frame op de stapel, om zo te zeggen.

420
00:23:04,000 --> 00:23:08,000
Het wijst ook 32 bits voor deze ints.

421
00:23:08,000 --> 00:23:11,000
Het overkomt noemen ze a en b, maar dat is volkomen willekeurig.

422
00:23:11,000 --> 00:23:13,000
Het zou hen geroepen heb wat het wil, maar wat gebeurt er als de belangrijkste

423
00:23:13,000 --> 00:23:19,000
oproepen swap is duurt dit 1, plaatst een kopie daar, plaatst een kopie daar.

424
00:23:19,000 --> 00:23:23,000
>> Er is 1 andere lokale variabele in ruil, hoewel, genoemd wat? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, dus laat me mezelf nog een 32 bits hier,

426
00:23:27,000 --> 00:23:29,000
en wat heb ik gedaan in deze functie?

427
00:23:29,000 --> 00:23:34,000
Ik zei int tmp krijgt een, dus een heeft 1, dus ik deed dit toen we voor het laatst gespeeld met dit voorbeeld.

428
00:23:34,000 --> 00:23:39,000
Dan krijgt a b, dus b is 2, dus nu dit wordt 2,

429
00:23:39,000 --> 00:23:42,000
en nu b krijgt temp, dus temp is 1,

430
00:23:42,000 --> 00:23:44,000
dus nu b wordt dit.

431
00:23:44,000 --> 00:23:46,000
Dat is geweldig. Het werkte.

432
00:23:46,000 --> 00:23:49,000
Maar zodra de functie terugkeert

433
00:23:49,000 --> 00:23:52,000
swap geheugen verdwijnt effectief, zodat het kan worden hergebruikt

434
00:23:52,000 --> 00:23:58,000
door een andere functie in de toekomst en voornaamste is uiteraard volledig ongewijzigd.

435
00:23:58,000 --> 00:24:00,000
We moeten een manier fundamenteel oplossen van dit probleem,

436
00:24:00,000 --> 00:24:03,000
en vandaag gaan we eindelijk een manier om dit te doen, waarbij

437
00:24:03,000 --> 00:24:06,000
we kunnen introduceren iets genaamd een pointer.

438
00:24:06,000 --> 00:24:09,000
Het blijkt dat we dit probleem oplossen

439
00:24:09,000 --> 00:24:12,000
niet door het passeren van de kopieën van x-en y-

440
00:24:12,000 --> 00:24:18,000
maar in plaats daarvan door het passeren in wat, denk je, denk om de swap-functie?

441
00:24:18,000 --> 00:24:20,000
Ja, hoe zit het met het adres?

442
00:24:20,000 --> 00:24:22,000
We hebben nog niet echt gesproken over adressen in veel detail,

443
00:24:22,000 --> 00:24:25,000
maar als dit bord is mijn computer het geheugen

444
00:24:25,000 --> 00:24:28,000
We kunnen zeker gaan nummeren van de bytes in mijn RAM-geheugen

445
00:24:28,000 --> 00:24:31,000
en zeggen dat dit byte # 1, is dit byte # 2, # 3 byte,

446
00:24:31,000 --> 00:24:35,000
byte # 4, byte # ... 2 miljard als ik 2 gigabyte aan RAM-geheugen,

447
00:24:35,000 --> 00:24:38,000
dus we konden zeker komen met een aantal willekeurige nummering

448
00:24:38,000 --> 00:24:41,000
voor elke individuele bytes in het geheugen van de computer wordt.

449
00:24:41,000 --> 00:24:43,000
>> Wat als in plaats daarvan als ik roep swap

450
00:24:43,000 --> 00:24:47,000
in plaats van pas in kopieën van x-en y-

451
00:24:47,000 --> 00:24:51,000
waarom niet ik in plaats daarvan geschiedde in het adres van x hier,

452
00:24:51,000 --> 00:24:55,000
het adres van y hier in wezen het postadres

453
00:24:55,000 --> 00:24:59,000
van x en y want dan ruilen, als hij op de hoogte

454
00:24:59,000 --> 00:25:01,000
het adres in het geheugen van x en y,

455
00:25:01,000 --> 00:25:04,000
dan ruilen, als we getraind hem een ​​beetje,

456
00:25:04,000 --> 00:25:07,000
hij zou kunnen rijden naar dat adres, om zo te zeggen,

457
00:25:07,000 --> 00:25:11,000
x, en verander het getal daar, dan rijden naar het adres van y,

458
00:25:11,000 --> 00:25:16,000
daar verandert het nummer, zelfs wanneer niet daadwerkelijk krijgen kopieën van die waarden zelf,

459
00:25:16,000 --> 00:25:19,000
dus ook al hadden we het over dit als de belangrijkste geheugen van

460
00:25:19,000 --> 00:25:23,000
en dit als swap geheugen van de machtigen en de gevaarlijke deel van C

461
00:25:23,000 --> 00:25:28,000
is dat elke functie kan het geheugen raken overal in de computer,

462
00:25:28,000 --> 00:25:32,000
en dit is krachtig in dat je heel fancy dingen doen met computerprogramma's in C.

463
00:25:32,000 --> 00:25:36,000
Dit is gevaarlijk, want je kunt ook verpesten heel gemakkelijk.

464
00:25:36,000 --> 00:25:39,000
In feite een van de meest gebruikte manieren programma's tegenwoordig worden benut

465
00:25:39,000 --> 00:25:42,000
nog steeds voor een programmeur niet te realiseren

466
00:25:42,000 --> 00:25:45,000
dat hij of zij is waardoor een data

467
00:25:45,000 --> 00:25:49,000
geschreven worden op een locatie in het geheugen, dat niet de bedoeling was.

468
00:25:49,000 --> 00:25:51,000
>> Bijvoorbeeld, hij of zij verklaart een array van maat 10

469
00:25:51,000 --> 00:25:56,000
maar dan per ongeluk probeert tot 11 bytes gebracht die array van het geheugen,

470
00:25:56,000 --> 00:25:59,000
en je begint te raken delen van het geheugen die niet meer geldig zijn.

471
00:25:59,000 --> 00:26:02,000
Gewoon om contextuele dit, kunnen sommige van jullie weten dat

472
00:26:02,000 --> 00:26:06,000
software vraagt ​​vaak u voor serienummers of registratie sleutels,

473
00:26:06,000 --> 00:26:08,000
Photoshop en Word en programma's als dit.

474
00:26:08,000 --> 00:26:12,000
Er bestaan ​​scheuren, zoals sommigen van jullie weten, waar je online kan een beetje programma uit te voeren,

475
00:26:12,000 --> 00:26:14,000
en voila, niet meer verzoek om een ​​serienummer.

476
00:26:14,000 --> 00:26:16,000
Hoe wordt dat het werken?

477
00:26:16,000 --> 00:26:21,000
In veel gevallen zijn deze dingen zijn gewoon te vinden in de computers

478
00:26:21,000 --> 00:26:24,000
tekstsegmenten in werkelijke van de computer nullen en enen

479
00:26:24,000 --> 00:26:28,000
waar is die functie waar het serienummer wordt gevraagd,

480
00:26:28,000 --> 00:26:31,000
en u overschrijven die ruimte, of terwijl het programma loopt

481
00:26:31,000 --> 00:26:33,000
je kunt achterhalen waar de sleutel is werkelijk opgeslagen

482
00:26:33,000 --> 00:26:37,000
met behulp van iets genaamd een debugger, en je kunt software op die manier te kraken.

483
00:26:37,000 --> 00:26:40,000
Dit wil niet dat dit onze doelstelling zeggen voor de komende paar dagen,

484
00:26:40,000 --> 00:26:42,000
maar het heeft zeer reële-wereld vertakkingen.

485
00:26:42,000 --> 00:26:45,000
Dat men er met betrekking diefstal van software,

486
00:26:45,000 --> 00:26:47,000
maar er is ook een compromis van complete machines.

487
00:26:47,000 --> 00:26:50,000
>> In feite, als websites deze dagen worden benut

488
00:26:50,000 --> 00:26:53,000
en gecompromitteerd en data wordt gelekt en wachtwoorden worden gestolen

489
00:26:53,000 --> 00:26:58,000
dit zeer vaak betrekking op slecht beheer van het geheugen,

490
00:26:58,000 --> 00:27:01,000
of, in het geval van databases, het niet anticiperen

491
00:27:01,000 --> 00:27:03,000
hoor en wederhoor ingang, zodat er meer op dat er in de komende weken,

492
00:27:03,000 --> 00:27:07,000
maar voor nu slechts een sneak preview van de soort schade die u kunt doen

493
00:27:07,000 --> 00:27:11,000
door niet helemaal begrijpen hoe dingen werken onder de kap.

494
00:27:11,000 --> 00:27:14,000
Laten we gaan over het begrijpen waarom dit is gebroken

495
00:27:14,000 --> 00:27:17,000
met een instrument dat zal meer en meer nuttige

496
00:27:17,000 --> 00:27:19,000
als onze programma's steeds complexer.

497
00:27:19,000 --> 00:27:21,000
Tot nu toe als je hebt gehad een bug in uw programma

498
00:27:21,000 --> 00:27:23,000
hoe ben je gek over debuggen het?

499
00:27:23,000 --> 00:27:25,000
Wat heb je technieken tot nu toe, of geleerd door uw TF

500
00:27:25,000 --> 00:27:27,000
of gewoon autodidact?

501
00:27:27,000 --> 00:27:29,000
[Student] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, dus printf is waarschijnlijk je vriend in dat als u wilt zien

503
00:27:31,000 --> 00:27:33,000
wat is er aan de binnenkant van uw programma

504
00:27:33,000 --> 00:27:36,000
zet je gewoon printf hier, printf hier, printf hier.

505
00:27:36,000 --> 00:27:38,000
Dan moet je het draait, en je krijgt een heleboel dingen op het scherm

506
00:27:38,000 --> 00:27:43,000
die u kunt gebruiken om vervolgens af te leiden wat er werkelijk mis gaat in uw programma.

507
00:27:43,000 --> 00:27:45,000
>> Printf heeft de neiging om een ​​zeer krachtig ding,

508
00:27:45,000 --> 00:27:47,000
maar het is een zeer handmatig proces.

509
00:27:47,000 --> 00:27:49,000
Je moet hier zet een printf, een printf hier,

510
00:27:49,000 --> 00:27:51,000
en als je het binnen zetten van een lus je zou kunnen krijgen 100 lijnen

511
00:27:51,000 --> 00:27:53,000
van de output die je dan moeten uitpluizen.

512
00:27:53,000 --> 00:27:58,000
Het is niet een erg gebruiksvriendelijk of interactieve mechanisme voor debuggen van programma's,

513
00:27:58,000 --> 00:28:00,000
maar gelukkig bestaat er alternatieven.

514
00:28:00,000 --> 00:28:03,000
Er is een programma, bijvoorbeeld, genaamd GDB, de GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
dat is een beetje geheimzinnig in de manier waarop je het gebruikt.

516
00:28:06,000 --> 00:28:08,000
Het is een beetje ingewikkeld, maar eerlijk gezegd,

517
00:28:08,000 --> 00:28:11,000
dit is een van die dingen waar als je in deze en volgende week

518
00:28:11,000 --> 00:28:14,000
de extra uren om zoiets als GDB begrijpen

519
00:28:14,000 --> 00:28:18,000
het bespaart u waarschijnlijk tientallen uren op de lange termijn,

520
00:28:18,000 --> 00:28:21,000
dus met dat, laat me je een teaser van hoe dit ding werkt.

521
00:28:21,000 --> 00:28:23,000
>> Ik ben in mijn terminal-venster.

522
00:28:23,000 --> 00:28:26,000
Laat me gaan, en slaat deze programma buggy3.

523
00:28:26,000 --> 00:28:28,000
Het is al up-to-date.

524
00:28:28,000 --> 00:28:31,000
Laat ik voer het uit, net als wij deden een tijdje terug, en inderdaad, het is gebroken.

525
00:28:31,000 --> 00:28:34,000
Maar waarom is dit? Misschien heb ik het verpest de swap-functie.

526
00:28:34,000 --> 00:28:37,000
Misschien is het een en b. Ik ben niet helemaal verplaatsen ze rond correct.

527
00:28:37,000 --> 00:28:39,000
Laat me ga je gang en doen.

528
00:28:39,000 --> 00:28:43,000
In plaats van alleen buggy3 draaien Laat me maar dit programma GDB te voeren,

529
00:28:43,000 --> 00:28:48,000
en ik ga om het te vertellen aan buggy3 lopen,

530
00:28:48,000 --> 00:28:52,000
en ik ga een command line argument-tui omvatten,

531
00:28:52,000 --> 00:28:55,000
en wij zetten dit in de toekomst problemen op spec te herinneren.

532
00:28:55,000 --> 00:28:57,000
En nu dit zwart-wit-interface dook dat, nogmaals,

533
00:28:57,000 --> 00:28:59,000
is een beetje overweldigend op het eerste, want er is dit allemaal

534
00:28:59,000 --> 00:29:02,000
informatie over de garantie hier beneden, maar in ieder geval is er iets bekend.

535
00:29:02,000 --> 00:29:04,000
In de bovenkant van het venster is mijn werkelijke code,

536
00:29:04,000 --> 00:29:08,000
en als ik ga hier laat mij gaat u naar de top van mijn dossier,

537
00:29:08,000 --> 00:29:11,000
en inderdaad, er is buggy3.c, en kennisgeving aan de onderkant van dit venster

538
00:29:11,000 --> 00:29:13,000
Ik heb deze GDB prompt.

539
00:29:13,000 --> 00:29:16,000
>> Dit is niet hetzelfde als mijn normale John Harvard prompt.

540
00:29:16,000 --> 00:29:19,000
Dit is een aanwijzing dat gaat mij toe om GDB te controleren.

541
00:29:19,000 --> 00:29:21,000
GDB is een debugger.

542
00:29:21,000 --> 00:29:24,000
Een debugger is een programma waarmee u door

543
00:29:24,000 --> 00:29:27,000
uitvoering van uw programma regel voor regel voor regel,

544
00:29:27,000 --> 00:29:30,000
langs de weg doen wat je wilt het programma,

545
00:29:30,000 --> 00:29:33,000
zelfs belfuncties, of op zoek, nog belangrijker,

546
00:29:33,000 --> 00:29:35,000
op verschillende variabele waarden.

547
00:29:35,000 --> 00:29:37,000
Laten we verder gaan en dit doen.

548
00:29:37,000 --> 00:29:40,000
Ik ga om verder te gaan en in run typ bij GDB's prompt,

549
00:29:40,000 --> 00:29:43,000
dus merken in de linkerbenedenhoek van het scherm heb ik getypt lopen,

550
00:29:43,000 --> 00:29:45,000
en ik heb druk op enter, en wat deed dat te doen?

551
00:29:45,000 --> 00:29:50,000
Het liep letterlijk mijn programma, maar ik heb niet echt veel zien gaan hier

552
00:29:50,000 --> 00:29:55,000
want ik heb niet echt verteld de debugger

553
00:29:55,000 --> 00:29:57,000
om te pauzeren op een bepaald moment in de tijd.

554
00:29:57,000 --> 00:29:59,000
Gewoon typen run loopt het programma.

555
00:29:59,000 --> 00:30:01,000
Ik denk niet echt zien niets. Ik kan het niet manipuleren.

556
00:30:01,000 --> 00:30:03,000
>> In plaats daarvan laat mij dit doen.

557
00:30:03,000 --> 00:30:08,000
Op dit GDB prompt laat me in plaats daarvan breuk typen, in te voeren.

558
00:30:08,000 --> 00:30:10,000
Dat is niet wat ik bedoelde te typen.

559
00:30:10,000 --> 00:30:13,000
Laten we in plaats daarvan typ pauze belangrijkste.

560
00:30:13,000 --> 00:30:15,000
Met andere woorden, ik wil zoiets als een breekpunt in te stellen,

561
00:30:15,000 --> 00:30:18,000
die treffend wordt genoemd omdat het zal breken of te pauzeren

562
00:30:18,000 --> 00:30:21,000
uitvoering van uw programma op die bepaalde plaats.

563
00:30:21,000 --> 00:30:23,000
Belangrijkste is de naam van mijn functie.

564
00:30:23,000 --> 00:30:25,000
Merk op dat GDB is behoorlijk slim.

565
00:30:25,000 --> 00:30:28,000
Het bedacht dat de belangrijkste gebeurt er met ongeveer beginnen bij regel 18

566
00:30:28,000 --> 00:30:32,000
van buggy3.c, en dan hier op te merken in de linkerbovenhoek

567
00:30:32,000 --> 00:30:34,000
b + ligt direct naast lijn 18.

568
00:30:34,000 --> 00:30:38,000
Dat is me eraan herinneren dat ik een breekpunt op lijn 18.

569
00:30:38,000 --> 00:30:42,000
Deze keer als ik run wilt typen, ik ga mijn programma uit te voeren

570
00:30:42,000 --> 00:30:45,000
tot het hits dat breekpunt,

571
00:30:45,000 --> 00:30:48,000
zodat het programma wordt onderbroken voor mij op lijn 18.

572
00:30:48,000 --> 00:30:50,000
Daar gaan we, uit te voeren.

573
00:30:50,000 --> 00:30:53,000
Niets lijkt te zijn gebeurd, maar een termijn van ten linksonder

574
00:30:53,000 --> 00:30:58,000
start programma, buggy3, breekpunt 1 in de belangrijkste bij buggy3.c lijn 18.

575
00:30:58,000 --> 00:31:00,000
Wat kan ik nu doen?

576
00:31:00,000 --> 00:31:03,000
>> Merk op dat ik kan beginnen met het typen zaken als print,

577
00:31:03,000 --> 00:31:08,000
niet printf, print x, en nu dat is vreemd.

578
00:31:08,000 --> 00:31:11,000
De $ 1 is gewoon een nieuwsgierigheid, zoals we zullen zien

579
00:31:11,000 --> 00:31:14,000
telkens als u print iets krijg je een nieuwe $ waarde.

580
00:31:14,000 --> 00:31:18,000
Dat is, zodat u kunt terug te verwijzen naar de vorige waarden voor het geval dat,

581
00:31:18,000 --> 00:31:21,000
maar voor nu wat druk wordt me te vertellen is dat de waarde van x op dit punt in het verhaal

582
00:31:21,000 --> 00:31:26,000
kennelijk 134514032.

583
00:31:26,000 --> 00:31:29,000
Wat? Waar kwam dat zelfs vandaan?

584
00:31:29,000 --> 00:31:31,000
[Onverstaanbaar-student]

585
00:31:31,000 --> 00:31:34,000
Inderdaad, dit is wat we noemen een vuilnis waarde, en we hebben niet gesproken over dit nog niet,

586
00:31:34,000 --> 00:31:37,000
maar de reden dat je variabelen te initialiseren

587
00:31:37,000 --> 00:31:40,000
is natuurlijk zo dat ze enige waarde die je wilt dat ze te hebben.

588
00:31:40,000 --> 00:31:44,000
Maar de vangst is te herinneren dat u de variabelen declareren

589
00:31:44,000 --> 00:31:46,000
zoals ik deed een ogenblik geleden in mijn sigma voorbeeld

590
00:31:46,000 --> 00:31:48,000
zonder dat het geven van een waarde.

591
00:31:48,000 --> 00:31:50,000
Herinneren wat ik deed hier over in sigma.

592
00:31:50,000 --> 00:31:52,000
Ik verklaarde n, maar welke waarde heb ik geven?

593
00:31:52,000 --> 00:31:56,000
Geen, omdat ik wist dat er in de volgende paar regels

594
00:31:56,000 --> 00:31:59,000
GetInt zou zorgen voor het probleem van toe te kennen binnenkant van n.

595
00:31:59,000 --> 00:32:02,000
>> Maar op dit punt in het verhaal van lijn 11

596
00:32:02,000 --> 00:32:05,000
en lijn 12 en lijn 13 en lijn 14

597
00:32:05,000 --> 00:32:08,000
gedurende al die verschillende lijnen wat is de waarde van n?

598
00:32:08,000 --> 00:32:10,000
In C je weet het gewoon niet.

599
00:32:10,000 --> 00:32:14,000
Het is over het algemeen wat vuilnis waarde, sommige volledig willekeurig getal

600
00:32:14,000 --> 00:32:17,000
dat is overgebleven in hoofdzaak uit een aantal eerdere functie

601
00:32:17,000 --> 00:32:21,000
te zijn uitgevoerd, zodat uw programma draait

602
00:32:21,000 --> 00:32:24,000
herinneren eraan dat de functie-functie, de functie, de functie krijgt.

603
00:32:24,000 --> 00:32:27,000
Al deze frames te krijgen op het geheugen, en dan die functies terug,

604
00:32:27,000 --> 00:32:31,000
en net zoals ik suggereerde met de gum hun geheugen uiteindelijk wordt hergebruikt.

605
00:32:31,000 --> 00:32:37,000
Nou, het is gewoon zo gebeurt het dat deze variabele x in dit programma

606
00:32:37,000 --> 00:32:41,000
lijkt te hebben bevat een aantal vuilnis waarde als 134514032

607
00:32:41,000 --> 00:32:44,000
van sommige vorige functie, niet een die ik geschreven heb.

608
00:32:44,000 --> 00:32:47,000
Het kan iets die effectief geleverd met het besturingssysteem,

609
00:32:47,000 --> 00:32:49,000
een functie onder de kap.

610
00:32:49,000 --> 00:32:52,000
>> Oke, dat is prima, maar laten we nu verder te gaan naar de volgende regel.

611
00:32:52,000 --> 00:32:55,000
Als ik typ "volgende" bij mijn GDB prompt en ik druk op enter,

612
00:32:55,000 --> 00:32:58,000
merkt dat de aandacht verplaatst naar lijn 19,

613
00:32:58,000 --> 00:33:01,000
maar de logische implicatie is dat lijn 18

614
00:33:01,000 --> 00:33:06,000
is nu klaar uitvoeren, dus als ik weer typ "print x"

615
00:33:06,000 --> 00:33:10,000
Ik zou nu zie 1, en inderdaad, dat doe ik.

616
00:33:10,000 --> 00:33:14,000
Nogmaals, de $ spul is een manier van GDB u eraan te herinneren

617
00:33:14,000 --> 00:33:17,000
wat de geschiedenis van de prints zijn die je gedaan hebt.

618
00:33:17,000 --> 00:33:21,000
Laat me nu ga je gang en uit te printen y, en inderdaad, y wat gekke prijs ook,

619
00:33:21,000 --> 00:33:24,000
maar geen groot probleem, omdat in lijn 19 zijn we op het punt om het toe te wijzen

620
00:33:24,000 --> 00:33:27,000
de waarde 2, dus laat me weer typ "next".

621
00:33:27,000 --> 00:33:29,000
En nu we het toch over de printf lijn.

622
00:33:29,000 --> 00:33:31,000
Laat mij afdruk x.

623
00:33:31,000 --> 00:33:34,000
Laat mij afdrukken y. Eerlijk gezegd, ik word een beetje moe van het drukken dit.

624
00:33:34,000 --> 00:33:38,000
Laat mij in plaats daarvan "scherm x" en "display y ', typt u

625
00:33:38,000 --> 00:33:41,000
en nu elke keer als ik typ een opdracht in de toekomst

626
00:33:41,000 --> 00:33:45,000
Ik zal herinnerd worden aan wat x en y, wat is x en y, wat is x en y.

627
00:33:45,000 --> 00:33:48,000
>> Ik kan ook, als een terzijde, type in "info lokale bevolking."

628
00:33:48,000 --> 00:33:50,000
Info is een speciaal commando.

629
00:33:50,000 --> 00:33:52,000
Locals betekent dat het toont me de lokale variabelen.

630
00:33:52,000 --> 00:33:55,000
Voor het geval ik het vergeet of dit is een gekke, gecompliceerde functie

631
00:33:55,000 --> 00:33:57,000
dat ik of iemand anders heeft geschreven info lokale bevolking zal u vertellen

632
00:33:57,000 --> 00:34:00,000
wat zijn alle lokale variabelen binnen deze lokale functie

633
00:34:00,000 --> 00:34:03,000
die u zou kunnen schelen als je wilt rondneuzen.

634
00:34:03,000 --> 00:34:07,000
Nu, printf staat op het punt uit te voeren, dus laat me ga je gang en typ je gewoon "volgende".

635
00:34:07,000 --> 00:34:10,000
Omdat we in deze omgeving dat we niet echt zien van het

636
00:34:10,000 --> 00:34:14,000
hier uit te voeren naar beneden, maar let op het wordt hier een beetje verminkte.

637
00:34:14,000 --> 00:34:17,000
Maar let op het is het scherm zijn er dwingende,

638
00:34:17,000 --> 00:34:21,000
dus het is niet een perfect programma hier, maar dat is oke, want ik kan altijd rond te snuffelen

639
00:34:21,000 --> 00:34:23,000
met behulp van druk als ik dat wil.

640
00:34:23,000 --> 00:34:26,000
>> Laat me typ de volgende weer, en nu hier is het interessante deel.

641
00:34:26,000 --> 00:34:29,000
Op dit punt in het verhaal y is 2, en x 1,

642
00:34:29,000 --> 00:34:32,000
zoals voorgesteld hier, en opnieuw,

643
00:34:32,000 --> 00:34:35,000
De reden dat dit automatisch weergeven van nu is, want ik gebruik het commando

644
00:34:35,000 --> 00:34:40,000
scherm x en y scherm, dus het moment dat ik typ volgende

645
00:34:40,000 --> 00:34:43,000
in theorie X en Y moeten worden verwisseld.

646
00:34:43,000 --> 00:34:45,000
Nu, we weten al dat niet gaat het geval zijn,

647
00:34:45,000 --> 00:34:49,000
maar we zullen zien in een moment hoe we dieper om erachter te komen waarom dat is waar.

648
00:34:49,000 --> 00:34:54,000
Volgende helaas en, y is nog steeds 2 en x is nog steeds 1, en ik kan bevestigen zo veel.

649
00:34:54,000 --> 00:34:56,000
Print x, print y.

650
00:34:56,000 --> 00:34:59,000
Inderdaad, geen swapping eigenlijk is gebeurd, dus laten we beginnen dit over.

651
00:34:59,000 --> 00:35:01,000
Het is duidelijk dat swap is gebroken.

652
00:35:01,000 --> 00:35:04,000
Laten we in plaats daarvan "run" weer te typen.

653
00:35:04,000 --> 00:35:07,000
Laat ik zeggen ja, ik wil het opnieuw vanaf het begin, in te voeren.

654
00:35:07,000 --> 00:35:09,000
>> Nu ben ik een back-up op regel 18.

655
00:35:09,000 --> 00:35:11,000
Let nu op x en y zijn weer vuilnis waarden.

656
00:35:11,000 --> 00:35:15,000
Volgende, volgende, volgende, volgende.

657
00:35:15,000 --> 00:35:17,000
Als ik me verveel ik kan ook gewoon type N voor de volgende.

658
00:35:17,000 --> 00:35:21,000
U kunt afkorten aan de kortst mogelijke reeks tekens.

659
00:35:21,000 --> 00:35:23,000
Swap is nu gebroken.

660
00:35:23,000 --> 00:35:25,000
Laten we duiken in, dus in plaats van te typen volgende,

661
00:35:25,000 --> 00:35:30,000
nu ga ik naar stap typen zodat ik ga naar binnen stappen van deze functie

662
00:35:30,000 --> 00:35:33,000
zodat ik kan er doorheen lopen, dus ik raakte stap en voer.

663
00:35:33,000 --> 00:35:37,000
Merk op dat de aandacht springt naar beneden lager in mijn programma op lijn 36.

664
00:35:37,000 --> 00:35:39,000
Nu, wat zijn de lokale variabelen?

665
00:35:39,000 --> 00:35:41,000
Info lokale bevolking.

666
00:35:41,000 --> 00:35:43,000
Niets gewoon nog niet omdat we niet hebben gekregen om die lijn,

667
00:35:43,000 --> 00:35:47,000
dus laten we verder gaan en zeggen: "volgende".

668
00:35:47,000 --> 00:35:50,000
Nu lijken we tmp, print tmp hebben.

669
00:35:50,000 --> 00:35:52,000
Garbage waarde, toch? Ik denk het wel.

670
00:35:52,000 --> 00:35:55,000
Hoe zit het met het afdrukken van een, print b, 1 en 2?

671
00:35:55,000 --> 00:35:58,000
In een moment, zodra ik typ volgende weer

672
00:35:58,000 --> 00:36:02,000
tmp gaat nemen op een waarde van 1, hopelijk,

673
00:36:02,000 --> 00:36:05,000
omdat tmp zal worden toegewezen aan de waarde van een.

674
00:36:05,000 --> 00:36:08,000
>> Nu gaan we een-, print-b te drukken,

675
00:36:08,000 --> 00:36:11,000
maar nu afdrukken tmp, en het is inderdaad 1.

676
00:36:11,000 --> 00:36:14,000
Laat mij gaan doen. Laat mij gaan doen.

677
00:36:14,000 --> 00:36:16,000
Ik ben klaar met de swap-functie.

678
00:36:16,000 --> 00:36:19,000
Ik ben binnen nog steeds van het in lijn 40, dus laat me het afdrukken van een,

679
00:36:19,000 --> 00:36:22,000
afdrukken b, en kan me niet schelen wat tmp is.

680
00:36:22,000 --> 00:36:27,000
Het lijkt erop dat swap is correct als het gaat om swapping a en b.

681
00:36:27,000 --> 00:36:31,000
Maar als ik nu naast typen, ik ga terug naar regel 25,

682
00:36:31,000 --> 00:36:34,000
en natuurlijk, als ik typ in x en druk y

683
00:36:34,000 --> 00:36:38,000
ze zijn nog steeds onveranderd, dus we hebben niet het probleem opgelost.

684
00:36:38,000 --> 00:36:41,000
Maar diagnostisch nu misschien met deze GDB programma

685
00:36:41,000 --> 00:36:44,000
we hebben in ieder geval gekregen een stap dichter bij het begrijpen

686
00:36:44,000 --> 00:36:47,000
wat is er mis zonder strooisel onze code door er een printf hier,

687
00:36:47,000 --> 00:36:50,000
printf hier, printf hier en dan loopt het opnieuw en opnieuw

688
00:36:50,000 --> 00:36:52,000
proberen te achterhalen wat er fout gaat.

689
00:36:52,000 --> 00:36:55,000
>> Ik ga om verder te gaan en uit te stoppen met dit geheel met stoppen.

690
00:36:55,000 --> 00:36:57,000
Het zal dan zeggen, "Quit eigenlijk?" Ja.

691
00:36:57,000 --> 00:37:00,000
Nu ben ik terug op mijn normale prompt, en ik ben klaar met behulp van GDB.

692
00:37:00,000 --> 00:37:03,000
Even terzijde, heb je niet nodig om deze-tui vlag.

693
00:37:03,000 --> 00:37:07,000
In feite, als je het weg laten je in wezen de onderste helft van het scherm.

694
00:37:07,000 --> 00:37:11,000
Als ik typ pauze belangrijkste en voer

695
00:37:11,000 --> 00:37:15,000
Ik kan nog steeds lopen mijn programma, maar wat het zal doen, is meer tekstueel

696
00:37:15,000 --> 00:37:18,000
gewoon laat me de huidige regel een voor een.

697
00:37:18,000 --> 00:37:21,000
De-tui, tekstuele gebruikersinterface,

698
00:37:21,000 --> 00:37:25,000
gewoon laat u meer van het programma in een keer, dat is waarschijnlijk een beetje conceptueel eenvoudiger.

699
00:37:25,000 --> 00:37:27,000
Maar inderdaad, ik kan gewoon gaan doen, volgende, volgende,

700
00:37:27,000 --> 00:37:30,000
en ik ga om een ​​lijn te zien in een tijd, en als ik echt wil zien wat er aan de hand

701
00:37:30,000 --> 00:37:35,000
Ik kan typen lijst en zie een hele hoop van naburige lijnen.

702
00:37:35,000 --> 00:37:39,000
>> Er is een video die we hebben gevraagd dat u pas op voor probleem sets 3

703
00:37:39,000 --> 00:37:43,000
waarin Nate dekt een deel van de fijne kneepjes van het GDB,

704
00:37:43,000 --> 00:37:46,000
en dit is een van die dingen, eerlijk, waar een aantal niet-triviale percentage van je

705
00:37:46,000 --> 00:37:49,000
zal nooit aan GDB, en dat zal een slechte zaak

706
00:37:49,000 --> 00:37:53,000
want letterlijk zul je uiteindelijk meer tijd besteden aan later dit semester

707
00:37:53,000 --> 00:37:56,000
jagen bugs dan zou je als je in dat half uur / uur

708
00:37:56,000 --> 00:38:00,000
deze en volgende week leren om comfortabel te krijgen met GDB.

709
00:38:00,000 --> 00:38:02,000
Printf was je vriend.

710
00:38:02,000 --> 00:38:05,000
GDB moet nu je vriend.

711
00:38:05,000 --> 00:38:08,000
>> Eventuele vragen over GDB?

712
00:38:08,000 --> 00:38:12,000
En hier is een korte lijst van enkele van de meest krachtige en nuttige commando's.

713
00:38:12,000 --> 00:38:15,000
Ja. >> Kunt u een string?

714
00:38:15,000 --> 00:38:17,000
Kunt u een string? Absoluut.

715
00:38:17,000 --> 00:38:19,000
Het hoeft niet alleen gehele getallen.

716
00:38:19,000 --> 00:38:22,000
Als een variabele s is een string typ je gewoon in print s.

717
00:38:22,000 --> 00:38:24,000
Het zal je laten zien wat die string variabele is.

718
00:38:24,000 --> 00:38:26,000
[Onverstaanbaar-student]

719
00:38:26,000 --> 00:38:28,000
Het geeft je het adres en de string zelf.

720
00:38:28,000 --> 00:38:32,000
Het zal u tonen beide.

721
00:38:32,000 --> 00:38:34,000
En een laatste ding, alleen maar omdat deze zijn goed om te weten.

722
00:38:34,000 --> 00:38:37,000
Backtrace en frame, laat mij duiken in deze nog een laatste keer,

723
00:38:37,000 --> 00:38:39,000
exact dezelfde programma met GDB.

724
00:38:39,000 --> 00:38:44,000
Laat me ga je gang en laat de tekstuele gebruikersinterface versie,

725
00:38:44,000 --> 00:38:46,000
breken belangrijkste.

726
00:38:46,000 --> 00:38:49,000
Laat me ga je gang en start opnieuw. Hier ben ik.

727
00:38:49,000 --> 00:38:55,000
Laat me nu gaan volgende, volgende, volgende, volgende, volgende, stap, in te voeren.

728
00:38:55,000 --> 00:39:00,000
>> En nu veronderstel dat ik nu bewust in ruil, maar ik heb zoiets van "Damn, wat was de waarde van x? '

729
00:39:00,000 --> 00:39:02,000
Ik kan niet meer doen x.

730
00:39:02,000 --> 00:39:05,000
Ik kan het niet y, omdat ze niet in omvang.

731
00:39:05,000 --> 00:39:07,000
Ze zijn niet in de juiste context, maar geen probleem.

732
00:39:07,000 --> 00:39:09,000
Ik kan typen backtrace.

733
00:39:09,000 --> 00:39:13,000
Dat toont mij alle functies die zijn uitgevoerd tot dit punt in de tijd.

734
00:39:13,000 --> 00:39:16,000
Merk op dat de een op de bodem hoofdzaak samenvalt met belangrijkste

735
00:39:16,000 --> 00:39:18,000
wezen op de bodem van onze foto hier.

736
00:39:18,000 --> 00:39:22,000
Het feit dat swap is boven het lijnen met swap wordt boven in het geheugen hier,

737
00:39:22,000 --> 00:39:26,000
en als ik wil terug tijdelijk naar hoofd kan ik zeggen "frame".

738
00:39:26,000 --> 00:39:30,000
Welk nummer? Belangrijkste is frame # 1.

739
00:39:30,000 --> 00:39:32,000
Ik ga om verder te gaan en te zeggen "frame 1."

740
00:39:32,000 --> 00:39:36,000
>> Nu ben ik terug in de belangrijkste, en ik kan printen x, en ik kan afdrukken y,

741
00:39:36,000 --> 00:39:40,000
maar ik kan niet afdrukken op a of b.

742
00:39:40,000 --> 00:39:43,000
Maar ik kan als ik zeg, "Oke, wacht even. Waar was de swap?"

743
00:39:43,000 --> 00:39:46,000
Laat me ga je gang en zeg "frame 0."

744
00:39:46,000 --> 00:39:48,000
Nu ben ik terug waar ik wil zijn, en als een terzijde,

745
00:39:48,000 --> 00:39:52,000
er zijn andere commando's ook, alsof je echt vervelen typen volgende, volgende, volgende, volgende,

746
00:39:52,000 --> 00:39:56,000
kunt u over het algemeen dingen zeggen als "next 10," en dat zal u door de volgende 10 regels.

747
00:39:56,000 --> 00:39:59,000
U kunt ook schrijven "continue" als je echt beu stappen doorheen.

748
00:39:59,000 --> 00:40:05,000
Ga verder zal lopen uw programma zonder onderbreking totdat hij raakt een andere breekpunt,

749
00:40:05,000 --> 00:40:07,000
hetzij in een lus of lager in uw programma.

750
00:40:07,000 --> 00:40:11,000
>> In dit geval bleef het einde, en het programma verlaten normaal.

751
00:40:11,000 --> 00:40:13,000
Dit is een mooie manier om, inferieure proces.

752
00:40:13,000 --> 00:40:16,000
Gewoon het programma verlaten normaal.

753
00:40:16,000 --> 00:40:24,000
Meer daarover in de video en bij het debuggen sessies te komen.

754
00:40:24,000 --> 00:40:26,000
Dat was veel.

755
00:40:26,000 --> 00:40:35,000
Laten we hier nemen onze 5-minuten pauze, en we zullen terug met structs en bestanden.

756
00:40:35,000 --> 00:40:38,000
>> Als u dook PSET deze week al

757
00:40:38,000 --> 00:40:41,000
zult u weten dat we gebruiken in de verdeelsleutel,

758
00:40:41,000 --> 00:40:45,000
de broncode die wij aan u als uitgangspunt, een aantal nieuwe technieken.

759
00:40:45,000 --> 00:40:50,000
In het bijzonder, introduceerden we dit nieuwe zoekwoord genaamd struct, voor structuur,

760
00:40:50,000 --> 00:40:53,000
zodat wij aangepaste variabelen van soorten.

761
00:40:53,000 --> 00:40:57,000
We hebben ook introduceerde de notie van file I / O, invoer-en uitvoerbestanden,

762
00:40:57,000 --> 00:41:00,000
en dit is, zodat we kunnen besparen de staat

763
00:41:00,000 --> 00:41:03,000
van uw Scramble bord naar een bestand op schijf

764
00:41:03,000 --> 00:41:06,000
zodat het onderwijs jongens en ik kan begrijpen

765
00:41:06,000 --> 00:41:09,000
wat is er aan de binnenkant van uw programma zonder handmatig te spelen

766
00:41:09,000 --> 00:41:11,000
tientallen games van Scramble.

767
00:41:11,000 --> 00:41:13,000
We kunnen dit doen meer automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Dit idee van een struct lost een vrij dwingende probleem.

769
00:41:18,000 --> 00:41:21,000
Stel dat we willen wat programma uit te voeren

770
00:41:21,000 --> 00:41:25,000
dat houdt een of andere manier spoor van informatie over studenten,

771
00:41:25,000 --> 00:41:28,000
en studenten zou kunnen hebben, bijvoorbeeld een ID, een naam

772
00:41:28,000 --> 00:41:31,000
en een huis op een plek als Harvard, dus deze zijn 3 stukjes informatie

773
00:41:31,000 --> 00:41:34,000
we willen rond houden, dus laat me ga je gang en beginnen met het schrijven van een klein programma hier,

774
00:41:34,000 --> 00:41:38,000
onder meer stdio.h.

775
00:41:38,000 --> 00:41:42,000
Laat mij het doen zijn cs50.h.

776
00:41:42,000 --> 00:41:44,000
En dan beginnen mijn belangrijkste functie.

777
00:41:44,000 --> 00:41:46,000
Ik zal niet de moeite met een command line argumenten,

778
00:41:46,000 --> 00:41:49,000
en hier wil ik een student, dus ik ga zeggen

779
00:41:49,000 --> 00:41:54,000
een student heeft een naam, dus ik ga zeggen "string naam."

780
00:41:54,000 --> 00:41:59,000
Dan ga ik zeggen dat een student ook een ID heeft, dus int id,

781
00:41:59,000 --> 00:42:03,000
en een student heeft een huis, dus ik ben ook gaan zeggen "string huis."

782
00:42:03,000 --> 00:42:06,000
Dan zal ik deze bestellen een beetje schoner als dit.

783
00:42:06,000 --> 00:42:11,000
Oke, nu heb ik 3 variabelen waarmee een student te vertegenwoordigen, dus "een student."

784
00:42:11,000 --> 00:42:15,000
>> En nu wil ik deze waarden te bevolken, dus laat me ga je gang en zeg iets als

785
00:42:15,000 --> 00:42:18,000
"Id = 123."

786
00:42:18,000 --> 00:42:21,000
Naam gaat David te krijgen.

787
00:42:21,000 --> 00:42:24,000
Laten we zeggen dat huis gaat Mather krijgen,

788
00:42:24,000 --> 00:42:31,000
en dan ga ik iets doen willekeurig zoals printf ("% s,

789
00:42:31,000 --> 00:42:37,000
waarvan de ID is% d, woont in% s.

790
00:42:37,000 --> 00:42:41,000
En nu, wat wil ik de stekker in hier, de een na de andere?

791
00:42:41,000 --> 00:42:47,000
Naam, id, huis, return 0.

792
00:42:47,000 --> 00:42:50,000
Oke, tenzij ik het verpest hier ergens

793
00:42:50,000 --> 00:42:54,000
Ik denk dat we een vrij goed programma dat een student opgeslagen.

794
00:42:54,000 --> 00:42:57,000
Natuurlijk, dit is niet zo interessant. Wat als ik wil 2 studenten hebben?

795
00:42:57,000 --> 00:42:59,000
Dat is geen big deal. Ik kan ondersteunen 2 personen.

796
00:42:59,000 --> 00:43:03,000
Laat me gaan en te markeren dit en hier naar beneden gaan,

797
00:43:03,000 --> 00:43:09,000
en ik kan "id = 456" zeggen voor iemand als Rob woont in Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Oke, wacht, maar ik kan niet bellen deze hetzelfde,

799
00:43:12,000 --> 00:43:15,000
en het lijkt erop dat ik ga te hebben om deze te kopiëren,

800
00:43:15,000 --> 00:43:19,000
zo wil ik zeggen dat deze zullen Davids variabelen,

801
00:43:19,000 --> 00:43:23,000
en laat me een aantal kopieën van deze te krijgen voor Rob.

802
00:43:23,000 --> 00:43:27,000
We noemen deze Rob, maar dit is niet van plan om te werken nu

803
00:43:27,000 --> 00:43:33,000
want ik heb-wacht, laten we mij veranderen in ID1, naam1 en House1.

804
00:43:33,000 --> 00:43:35,000
Rob zal zijn 2, 2.

805
00:43:35,000 --> 00:43:42,000
Ik heb om dit te veranderen hier, hier, hier, hier, hier, hier.

806
00:43:42,000 --> 00:43:45,000
Wacht, hoe zit het met Tommy? Laten we dit weer.

807
00:43:45,000 --> 00:43:49,000
Natuurlijk, als je nog steeds denkt dat dit een goede manier om dit te doen, het is niet,

808
00:43:49,000 --> 00:43:52,000
dus kopiëren / plakken slecht.

809
00:43:52,000 --> 00:43:55,000
Maar we losten dit een week geleden.

810
00:43:55,000 --> 00:43:59,000
>> Wat was onze oplossing toen we wilden meerdere exemplaren van hetzelfde gegevenstype hebben?

811
00:43:59,000 --> 00:44:01,000
[Studenten] Een array.

812
00:44:01,000 --> 00:44:03,000
Een array, dus laat me proberen om dit op te ruimen.

813
00:44:03,000 --> 00:44:07,000
Laat me wat ruimte voor mezelf aan de top, en laat me in plaats daarvan dit hier doen.

814
00:44:07,000 --> 00:44:12,000
We noemen deze mensen, en in plaats daarvan ik ga zeggen: "int id,"

815
00:44:12,000 --> 00:44:14,000
en ik ga tot en met 3 van ons te steunen voor nu.

816
00:44:14,000 --> 00:44:18,000
Ik ga zeggen "string namen," en ik zal steunen 3 van ons,

817
00:44:18,000 --> 00:44:22,000
en dan ga ik om te zeggen "string huizen," en ik ga tot en met 3 van ons te steunen.

818
00:44:22,000 --> 00:44:26,000
Nu in hier in plaats van David om zijn eigen lokale variabelen

819
00:44:26,000 --> 00:44:28,000
kunnen we te ontdoen van die.

820
00:44:28,000 --> 00:44:30,000
Dat voelt goed dat we dit opruimen.

821
00:44:30,000 --> 00:44:35,000
Ik kan dan zeggen David gaat worden [0] en namen [0]

822
00:44:35,000 --> 00:44:38,000
en huizen [0].

823
00:44:38,000 --> 00:44:41,000
Rob en we kunnen eveneens besparen op deze.

824
00:44:41,000 --> 00:44:46,000
Laten we dit hier beneden, dus hij gaat willekeurig zijn ids [1].

825
00:44:46,000 --> 00:44:50,000
Hij gaat zijn namen [1],

826
00:44:50,000 --> 00:44:53,000
en tenslotte huizen [1].

827
00:44:53,000 --> 00:44:57,000
>> Nog steeds een beetje vervelend, en nu heb ik om dit uit,

828
00:44:57,000 --> 00:45:03,000
dus laten we zeggen "namen [0], id [0], huizen [0],

829
00:45:03,000 --> 00:45:06,000
en laten we meervoudig maken dit.

830
00:45:06,000 --> 00:45:09,000
Ids, ids, ids.

831
00:45:09,000 --> 00:45:12,000
En nogmaals, ik doe het, dus nogmaals, ik ben al toevlucht te kopiëren / plakken weer,

832
00:45:12,000 --> 00:45:14,000
dus kansen zijn er hier een andere oplossing.

833
00:45:14,000 --> 00:45:18,000
Ik kan waarschijnlijk dit opruimen verder met een lus of iets dergelijks,

834
00:45:18,000 --> 00:45:21,000
Dus in het kort, het is een beetje beter, maar nog steeds voelt als

835
00:45:21,000 --> 00:45:24,000
Ik ben toevlucht te kopiëren / plakken, maar zelfs dit, ik beweer,

836
00:45:24,000 --> 00:45:27,000
is niet echt fundamenteel de juiste oplossing, omdat

837
00:45:27,000 --> 00:45:29,000
wat als we besluiten ergens weet je wat?

838
00:45:29,000 --> 00:45:32,000
We hebben echt had moeten opslaan van e-mailadressen voor David en Rob

839
00:45:32,000 --> 00:45:34,000
en iedereen in dit programma.

840
00:45:34,000 --> 00:45:36,000
We moeten ook telefoonnummers.

841
00:45:36,000 --> 00:45:39,000
We moeten ook slaan nood telefoonnummers.

842
00:45:39,000 --> 00:45:41,000
We hebben al deze stukjes data die we willen opslaan,

843
00:45:41,000 --> 00:45:43,000
dus hoe ga je over om dat te doen?

844
00:45:43,000 --> 00:45:46,000
>> U verklaart een andere array op de top, en dan moet je handmatig toevoegen

845
00:45:46,000 --> 00:45:49,000
Een e-mailadres [0], e-mailadres [1]

846
00:45:49,000 --> 00:45:51,000
David en Rob enzovoort.

847
00:45:51,000 --> 00:45:56,000
Maar er is eigenlijk alleen maar een veronderstelling die ten grondslag liggen dit ontwerp

848
00:45:56,000 --> 00:45:59,000
dat ik met behulp van de honor-systeem om te weten dat

849
00:45:59,000 --> 00:46:03,000
[I] in elk van de verschillende arrays

850
00:46:03,000 --> 00:46:06,000
gewoon zo gebeurt om te verwijzen naar dezelfde persoon,

851
00:46:06,000 --> 00:46:10,000
dus [0] in ids is nummer 123,

852
00:46:10,000 --> 00:46:13,000
en ik ga die namen aannemen [0]

853
00:46:13,000 --> 00:46:16,000
is dezelfde persoon de naam en huizen [0]

854
00:46:16,000 --> 00:46:21,000
is dezelfde persoon huis enzovoort voor alle verschillende arrays die ik maak.

855
00:46:21,000 --> 00:46:24,000
Maar let erop dat er geen fundamentele koppeling

856
00:46:24,000 --> 00:46:27,000
onder die drie stukjes informatie, id, naam en huis,

857
00:46:27,000 --> 00:46:32,000
hoewel de entiteit we te modelleren proberen in dit programma is niet arrays.

858
00:46:32,000 --> 00:46:35,000
Arrays zijn alleen deze programmatische manier om dit te doen.

859
00:46:35,000 --> 00:46:38,000
Wat we echt willen modelleren in ons programma is een persoon

860
00:46:38,000 --> 00:46:41,000
als David, een persoon als Rob binnenkant van die

861
00:46:41,000 --> 00:46:46,000
of inkapselen is een naam en ID en een huis.

862
00:46:46,000 --> 00:46:49,000
>> Kunnen we een of andere manier uitdrukken dit idee van inkapseling

863
00:46:49,000 --> 00:46:52,000
waarbij een persoon heeft een ID, een naam en een huis

864
00:46:52,000 --> 00:46:55,000
en niet hun toevlucht tot echt deze hack waarbij we gewoon

865
00:46:55,000 --> 00:46:58,000
vertrouwen dat beugel iets

866
00:46:58,000 --> 00:47:02,000
verwijst naar dezelfde menselijke entiteit in elk van deze verschillende arrays?

867
00:47:02,000 --> 00:47:04,000
We kunnen dit doen.

868
00:47:04,000 --> 00:47:08,000
Laat me boven hoofd gaan voor nu, en laat mij mijn eigen data type

869
00:47:08,000 --> 00:47:10,000
voor echt de eerste keer.

870
00:47:10,000 --> 00:47:14,000
We gebruikten deze techniek in Scramble,

871
00:47:14,000 --> 00:47:17,000
maar hier ga ik verder te gaan en een data type te maken,

872
00:47:17,000 --> 00:47:19,000
en weet je wat, ik ga noemen student of persoon,

873
00:47:19,000 --> 00:47:23,000
en ik ga gebruiken typedef voor definiëren een type.

874
00:47:23,000 --> 00:47:25,000
Ik ga zeggen dat dit is een structuur,

875
00:47:25,000 --> 00:47:29,000
en dan deze structuur gaat worden van het type student, zullen we zeggen,

876
00:47:29,000 --> 00:47:31,000
ook al is het nu een beetje gedateerd voor mij.

877
00:47:31,000 --> 00:47:33,000
We zeggen "int id."

878
00:47:33,000 --> 00:47:35,000
We zeggen "string naam."

879
00:47:35,000 --> 00:47:37,000
Dan zullen we zeggen "string huis"

880
00:47:37,000 --> 00:47:40,000
dus nu aan het einde van deze paar regels code

881
00:47:40,000 --> 00:47:45,000
Ik heb net geleerd clang dat er sprake is

882
00:47:45,000 --> 00:47:49,000
een gegevenstype naast ints, naast strijkers, naast verdubbelt, naast praalwagens.

883
00:47:49,000 --> 00:47:54,000
>> Vanaf dit moment in de tijd lijn 11, is er nu een nieuw gegevenstype genoemd studenten,

884
00:47:54,000 --> 00:47:58,000
en nu kan ik verklaren een student variabele waar ik wil,

885
00:47:58,000 --> 00:48:01,000
dus laat me ga hier naar mensen.

886
00:48:01,000 --> 00:48:05,000
Nu kan ik te ontdoen van deze, en ik kan terug naar beneden naar David hier,

887
00:48:05,000 --> 00:48:10,000
en voor David kan ik eigenlijk zeggen dat David,

888
00:48:10,000 --> 00:48:13,000
kunnen we de variabele letterlijk vernoemen mezelf,

889
00:48:13,000 --> 00:48:16,000
gaat worden van het type student.

890
00:48:16,000 --> 00:48:18,000
Dit ziet er misschien een beetje raar, maar dit is niet zo heel verschillend

891
00:48:18,000 --> 00:48:22,000
uit verklaren iets als een int of een string of een float.

892
00:48:22,000 --> 00:48:24,000
Het gebeurt gewoon zo genoemd te worden studenten nu,

893
00:48:24,000 --> 00:48:28,000
en als ik iets wil zetten binnen van deze structuur

894
00:48:28,000 --> 00:48:31,000
Ik heb nu een nieuw stuk van de syntaxis te gebruiken, maar het is vrij eenvoudig,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" in de hoofdstad van D,

896
00:48:39,000 --> 00:48:42,000
en david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
en nu kan ik hier te ontdoen van dit spul.

898
00:48:46,000 --> 00:48:51,000
Merk op dat we nu onze vernieuwde programma in echt een veel betere manier

899
00:48:51,000 --> 00:48:54,000
in dat nu ons programma weerspiegelt de echte wereld.

900
00:48:54,000 --> 00:48:57,000
>> Er is een real-world notie van een persoon of een student.

901
00:48:57,000 --> 00:49:02,000
Hier hebben we nu een C-versie van een persoon of meer specifiek een student.

902
00:49:02,000 --> 00:49:05,000
Binnenkant van die persoon zijn deze relevante kenmerken,

903
00:49:05,000 --> 00:49:10,000
ID, naam en huis, dus Rob wordt in wezen hetzelfde hier beneden,

904
00:49:10,000 --> 00:49:14,000
zodat studenten rob, en nu rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Rob."

906
00:49:17,000 --> 00:49:20,000
Het feit dat de variabele heet Rob soort is zinloos.

907
00:49:20,000 --> 00:49:22,000
We konden noemen het x-of y-of z.

908
00:49:22,000 --> 00:49:25,000
We noemden het Rob te zijn semantisch consistent,

909
00:49:25,000 --> 00:49:28,000
maar echt de naam is binnenkant van dat veld zelf,

910
00:49:28,000 --> 00:49:30,000
dus nu heb ik dit.

911
00:49:30,000 --> 00:49:33,000
Dit betekent ook niet het gevoel dat het beste ontwerp in dat ik hard heb gecodeerd David.

912
00:49:33,000 --> 00:49:35,000
Ik heb hard gecodeerd Rob.

913
00:49:35,000 --> 00:49:39,000
En ik heb nog een beroep doen op een aantal kopieer-en elke keer als ik wil nieuwe variabelen plakken.

914
00:49:39,000 --> 00:49:43,000
Bovendien, ik moet blijkbaar geven elk van deze variabelen een naam,

915
00:49:43,000 --> 00:49:46,000
hoewel ik zou veel liever beschrijven deze variabelen

916
00:49:46,000 --> 00:49:48,000
 meer in het algemeen als studenten.

917
00:49:48,000 --> 00:49:52,000
>> Nu kunnen we samenvoegen de ideeën die zijn goed voor ons werken

918
00:49:52,000 --> 00:49:56,000
en in plaats daarvan zeggen: "Weet je wat, geef me een variabele genaamd studenten,

919
00:49:56,000 --> 00:50:01,000
en laten we hebben het van grootte 3, "dus nu kan ik dit verder te verfijnen,

920
00:50:01,000 --> 00:50:04,000
zich te ontdoen van de handmatig verklaarde David,

921
00:50:04,000 --> 00:50:08,000
en ik kan in plaats daarvan iets zeggen als studenten [0] hier.

922
00:50:08,000 --> 00:50:11,000
Ik kan dan zeggen studenten [0] hier,

923
00:50:11,000 --> 00:50:14,000
studenten [0] hier, enzovoort, en ik kan gaan rond

924
00:50:14,000 --> 00:50:16,000
en schoon dat voor Rob.

925
00:50:16,000 --> 00:50:19,000
Ik zou ook gaan over het nu misschien het toevoegen van een lus

926
00:50:19,000 --> 00:50:23,000
en het gebruik van GetString en GetInt om daadwerkelijk deze waarden te krijgen van de gebruiker.

927
00:50:23,000 --> 00:50:27,000
Ik zou kunnen gaan over het toevoegen van een constante, want dit is over het algemeen een slechte gewoonte

928
00:50:27,000 --> 00:50:29,000
naar de harde code een aantal willekeurig aantal als 3 hier

929
00:50:29,000 --> 00:50:33,000
en dan gewoon onthouden dat je moet niet meer dan 3 studenten in te stoppen.

930
00:50:33,000 --> 00:50:36,000
Het zou waarschijnlijk beter zijn om # gebruik te definiëren aan de bovenkant van mijn dossier

931
00:50:36,000 --> 00:50:40,000
en factor die uit zo, inderdaad, laat me ga je gang en generaliseren dit.

932
00:50:40,000 --> 00:50:43,000
>> Laat me open te stellen een voorbeeld dat is onder de huidige

933
00:50:43,000 --> 00:50:46,000
voorbeelden vooraf structs1.

934
00:50:46,000 --> 00:50:49,000
Dit is een compleet programma dat gebruik maakt van # hier definiëren up

935
00:50:49,000 --> 00:50:51,000
en zegt dat we gaan 3 studenten hebben standaard.

936
00:50:51,000 --> 00:50:54,000
Hier ben ik waarbij een klasse ter waarde van studenten,

937
00:50:54,000 --> 00:50:57,000
dus een klaslokaal van studenten, en nu ben ik met behulp van een lus

938
00:50:57,000 --> 00:51:00,000
alleen maar om de code een beetje meer elegante, bevolken de klas

939
00:51:00,000 --> 00:51:05,000
met input van de gebruiker, dus herhalen van i = 0 op maximaal studenten, dat is 3.

940
00:51:05,000 --> 00:51:07,000
En dan heb ik de gebruiker vragen in deze versie

941
00:51:07,000 --> 00:51:10,000
 wat is de student-ID, en ik krijg het met GetInt.

942
00:51:10,000 --> 00:51:13,000
Wat is de student de naam, en dan krijg ik het met GetString.

943
00:51:13,000 --> 00:51:15,000
Wat is de student het huis? Ik krijg het met GetString.

944
00:51:15,000 --> 00:51:19,000
En dan aan de onderkant ik hier net besloten om te veranderen

945
00:51:19,000 --> 00:51:22,000
hoe ik deze af te drukken en om daadwerkelijk gebruik maken van een lus,

946
00:51:22,000 --> 00:51:24,000
En wie ben ik afdrukken?

947
00:51:24,000 --> 00:51:27,000
Volgens de opmerking die ik heb afgedrukt iedereen in Mather,

948
00:51:27,000 --> 00:51:30,000
en dat is het dus Rob en Tommy enzovoort-eigenlijk Tommy's in Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy en David zou worden afgedrukt in dit geval, maar hoe wordt dit werkt?

950
00:51:34,000 --> 00:51:40,000
We hebben niet gezien deze functie voor, maar neem een ​​gok wat dit doet.

951
00:51:40,000 --> 00:51:42,000
Vergelijkt strings.

952
00:51:42,000 --> 00:51:45,000
>> Het is een beetje niet-duidelijk hoe het strings vergelijkt want het blijkt

953
00:51:45,000 --> 00:51:49,000
als het resultaat 0, dat betekent dat de snaren zijn gelijk.

954
00:51:49,000 --> 00:51:53,000
Als het weer een -1 dat betekent een komt alfabetisch vóór de andere,

955
00:51:53,000 --> 00:51:57,000
en als het terugkeert +1 dat betekent dat de andere woord komt alfabetisch

956
00:51:57,000 --> 00:52:00,000
voor de andere, en je kunt kijken online of in de man pagina

957
00:52:00,000 --> 00:52:04,000
om precies te zien welke kant is dat, maar dit alles wordt nu aan het doen is het zegt

958
00:52:04,000 --> 00:52:09,000
als de [i]. woning is gelijk aan "Mather"

959
00:52:09,000 --> 00:52:13,000
dan ga je gang en ga zo maar uit te printen en zo is in Mather.

960
00:52:13,000 --> 00:52:16,000
Maar hier is iets wat we niet eerder hebben gezien, en we zullen terugkeren naar dit.

961
00:52:16,000 --> 00:52:21,000
Ik kan me niet herinneren ooit te hebben om dit te doen in een van mijn programma's.

962
00:52:21,000 --> 00:52:24,000
Gratis is blijkbaar verwijst naar het geheugen, het vrijmaken van geheugen,

963
00:52:24,000 --> 00:52:31,000
maar wat geheugen ben ik blijkbaar te bevrijden in deze lus aan de onderkant van dit programma?

964
00:52:31,000 --> 00:52:34,000
Het lijkt alsof ik het vrijmaken van iemands naam

965
00:52:34,000 --> 00:52:37,000
en een persoon het huis, maar waarom is dat?

966
00:52:37,000 --> 00:52:41,000
>> Het blijkt al die weken dat u geweest bent GetString met behulp van

967
00:52:41,000 --> 00:52:45,000
we hebben soort van is de invoering van een bug in elke een van uw programma's.

968
00:52:45,000 --> 00:52:51,000
GetString het ontwerp geheugen toewijst, zodat het kan terugkeren naar je een string,

969
00:52:51,000 --> 00:52:55,000
als David, of Rob, en je kunt dan doen wat je wilt

970
00:52:55,000 --> 00:52:59,000
met die string in je programma, want we hebben het geheugen voor u gereserveerd.

971
00:52:59,000 --> 00:53:02,000
Het probleem is al die tijd elke keer als je belt getString

972
00:53:02,000 --> 00:53:05,000
wij, de auteurs van GetString, zijn gevraagd het besturingssysteem

973
00:53:05,000 --> 00:53:07,000
om ons een beetje van RAM voor deze string.

974
00:53:07,000 --> 00:53:09,000
Geef ons een beetje van RAM voor deze volgende string.

975
00:53:09,000 --> 00:53:11,000
Geef ons wat meer RAM-geheugen voor deze volgende string.

976
00:53:11,000 --> 00:53:13,000
Wat u, de programmeur, nog nooit gedaan

977
00:53:13,000 --> 00:53:15,000
geeft ons dat het geheugen terug,

978
00:53:15,000 --> 00:53:17,000
dus voor deze enkele weken alle programma's die u hebt geschreven

979
00:53:17,000 --> 00:53:20,000
hebben gehad wat een geheugen sprong genoemd waarbij ze blijven gebruiken

980
00:53:20,000 --> 00:53:24,000
meer en meer geheugen elke keer als je belt GetString, en dat is prima.

981
00:53:24,000 --> 00:53:27,000
We hebben bewust doen dat in de eerste weken, want het is niet zo interessant

982
00:53:27,000 --> 00:53:29,000
om zorgen te maken over waar de string vandaan komt.

983
00:53:29,000 --> 00:53:34,000
Alles wat je wilt is het woord Rob om terug te komen wanneer de gebruiker het erin

984
00:53:34,000 --> 00:53:38,000
>> Maar vooruit hebben we nu om te beginnen om meer geavanceerde hierover.

985
00:53:38,000 --> 00:53:42,000
Elke keer dat we geheugen toewijzen we beter uiteindelijk geef het terug.

986
00:53:42,000 --> 00:53:45,000
Anders in de echte wereld op je Mac of PC die u zou kunnen hebben af ​​en toe ervaren

987
00:53:45,000 --> 00:53:50,000
symptomen waar de computer is tot stilstand uiteindelijk

988
00:53:50,000 --> 00:53:54,000
of de domme draaiende strandbal is gewoon het bezetten van de computer

989
00:53:54,000 --> 00:53:56,000
volledige aandacht en je kunt geen dingen doen.

990
00:53:56,000 --> 00:54:00,000
Dat kan worden verklaard door een aantal bugs, maar onder hen mogelijke bugs

991
00:54:00,000 --> 00:54:03,000
worden dingen genoemd geheugenlekken waarbij iemand die schreef dat stukje software

992
00:54:03,000 --> 00:54:07,000
die u gebruikt niet herinneren om geheugen vrij te

993
00:54:07,000 --> 00:54:10,000
dat hij of zij gevraagd het besturingssysteem voor,

994
00:54:10,000 --> 00:54:14,000
niet gebruikt GetString, want dat is een CS50 ding, maar met behulp van soortgelijke functies

995
00:54:14,000 --> 00:54:16,000
dat het besturingssysteem voor het geheugen vragen.

996
00:54:16,000 --> 00:54:19,000
Als u of ze verpesten en eigenlijk nooit terug te keren dat het geheugen

997
00:54:19,000 --> 00:54:24,000
een symptoom van dat kan zijn dat een programma vertraagt ​​en vertraagt ​​en vertraagt

998
00:54:24,000 --> 00:54:26,000
tenzij je nog te bellen gratis.

999
00:54:26,000 --> 00:54:28,000
>> We komen terug naar wanneer en waarom je zou kunnen noemen gratis,

1000
00:54:28,000 --> 00:54:32,000
maar laten we gaan gewoon voor een goede maatregel en probeer het uitvoeren van dit bijzondere programma.

1001
00:54:32,000 --> 00:54:35,000
Dit werd genoemd structs1, in te voeren.

1002
00:54:35,000 --> 00:54:40,000
Laat me ga je gang en lopen structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Tommy Mather, en we zien Davids in Mather, Tommy's in Mather.

1005
00:54:50,000 --> 00:54:53,000
Dit is slechts een kleine sanity check dat het programma werkt.

1006
00:54:53,000 --> 00:54:56,000
Nu, helaas, is dit programma een beetje frustrerend in die

1007
00:54:56,000 --> 00:55:00,000
Ik wist al dat werk, ik typte in 9 verschillende strings, druk op enter,

1008
00:55:00,000 --> 00:55:04,000
werd verteld, die was in Mather, maar natuurlijk wist ik wie was al in Mather, omdat ik getypt.

1009
00:55:04,000 --> 00:55:07,000
Het zou in ieder geval mooi zijn als dit programma is meer als een database

1010
00:55:07,000 --> 00:55:10,000
en het herinnert eigenlijk wat ik heb getypt in

1011
00:55:10,000 --> 00:55:12,000
dus ik nooit meer in te voeren deze student records.

1012
00:55:12,000 --> 00:55:15,000
Misschien is het als een registrarial systeem.

1013
00:55:15,000 --> 00:55:21,000
>> We kunnen dit doen met behulp van deze techniek die bekend staat als file I / O, invoer-en uitvoerbestanden,

1014
00:55:21,000 --> 00:55:24,000
een zeer algemene manier om te zeggen wanneer u bestanden wilt lezen of bestanden weg te schrijven

1015
00:55:24,000 --> 00:55:26,000
U kunt dit doen met een bepaalde set van functies.

1016
00:55:26,000 --> 00:55:29,000
Laat me gaan en open dit voorbeeld structs2.c,

1017
00:55:29,000 --> 00:55:33,000
dat is bijna identiek, maar laten we eens kijken wat het nu doet.

1018
00:55:33,000 --> 00:55:36,000
Aan het begin van het bestand Ik verklaar een klas van leerlingen.

1019
00:55:36,000 --> 00:55:38,000
Vervolgens heb ik bevolken de klasse met input van de gebruiker,

1020
00:55:38,000 --> 00:55:41,000
dus die regels code zijn precies als vroeger.

1021
00:55:41,000 --> 00:55:45,000
En als ik naar beneden scrollen hier druk ik iedereen die in Mather willekeurig als voorheen,

1022
00:55:45,000 --> 00:55:47,000
maar dit is een interessante nieuwe functie.

1023
00:55:47,000 --> 00:55:51,000
Deze regels code zijn nieuw, en ze introduceren hier iets,

1024
00:55:51,000 --> 00:55:55,000
FILE, alle doppen, en het heeft * hier ook.

1025
00:55:55,000 --> 00:55:58,000
Laat me dit bewegen over hier, een * hier ook.

1026
00:55:58,000 --> 00:56:00,000
>> Deze functie hebben we nog niet eerder gezien, fopen,

1027
00:56:00,000 --> 00:56:03,000
maar het bestand open betekent, dus de magere laat door middel van deze,

1028
00:56:03,000 --> 00:56:05,000
en dit is iets wat we weer terug te komen in de toekomst psets,

1029
00:56:05,000 --> 00:56:10,000
maar deze lijn hier opent in wezen een bestand met de naam database,

1030
00:56:10,000 --> 00:56:13,000
en opent het bijzonder zodanig dat het kan wat te doen?

1031
00:56:13,000 --> 00:56:15,000
[Onverstaanbaar-student]

1032
00:56:15,000 --> 00:56:19,000
Juist, dus "w" gewoon betekent dat het het besturingssysteem te vertellen

1033
00:56:19,000 --> 00:56:21,000
open dit bestand op een zodanige wijze dat ik kan schrijven.

1034
00:56:21,000 --> 00:56:23,000
Ik wil niet om het te lezen. Ik wil niet alleen kijken naar het.

1035
00:56:23,000 --> 00:56:26,000
Ik wil om het te veranderen en mogelijk toe te voegen materiaal aan,

1036
00:56:26,000 --> 00:56:28,000
en het bestand zal worden genoemd database.

1037
00:56:28,000 --> 00:56:30,000
Dit kan worden genoemd niets.

1038
00:56:30,000 --> 00:56:32,000
Dit kan database.txt. Dit kan. Db.

1039
00:56:32,000 --> 00:56:37,000
Dit kan een woord als foo zijn, maar ik willekeurig gekozen om de file database te noemen.

1040
00:56:37,000 --> 00:56:42,000
Dit is een beetje sanity check dat we terugkomen om in detail na verloop van tijd,

1041
00:56:42,000 --> 00:56:47,000
indien fp, voor bestands pointer, is niet gelijk aan NULL, dat betekent dat alles in orde is.

1042
00:56:47,000 --> 00:56:51,000
>> Lang verhaal kort, functies als fopen soms niet.

1043
00:56:51,000 --> 00:56:53,000
Misschien is het bestand niet bestaat. Misschien bent u op schijfruimte.

1044
00:56:53,000 --> 00:56:55,000
Misschien heb je geen rechten om deze map,

1045
00:56:55,000 --> 00:56:58,000
dus als fopen null retourneert iets ergs gebeurd.

1046
00:56:58,000 --> 00:57:02,000
Omgekeerd, als fopen niet terugkeert null alles in orde is

1047
00:57:02,000 --> 00:57:04,000
en ik kan beginnen met het schrijven naar dit bestand.

1048
00:57:04,000 --> 00:57:06,000
Hier is een nieuwe truc.

1049
00:57:06,000 --> 00:57:08,000
Dit is een lus die is itereren over elk van mijn leerlingen,

1050
00:57:08,000 --> 00:57:10,000
en dit ziet er zo vergelijkbaar met wat we al eerder gedaan,

1051
00:57:10,000 --> 00:57:15,000
maar deze functie is een neef van printf fprintf riep op tot bestand printf,

1052
00:57:15,000 --> 00:57:18,000
en let op het is anders in slechts 2 manieren.

1053
00:57:18,000 --> 00:57:20,000
, Start het met f plaats van p,

1054
00:57:20,000 --> 00:57:23,000
maar dan is het eerste argument is blijkbaar wat?

1055
00:57:23,000 --> 00:57:25,000
[Studenten] File. >> Het is een bestand.

1056
00:57:25,000 --> 00:57:30,000
Dit ding heet fp, die we uiteindelijk plagen elkaar wat een bestands pointer is,

1057
00:57:30,000 --> 00:57:35,000
maar voor nu fp vertegenwoordigt enkel het bestand dat ik heb geopend,

1058
00:57:35,000 --> 00:57:41,000
dus fprintf hier zegt print deze gebruiker ID van het dossier, niet op het scherm.

1059
00:57:41,000 --> 00:57:44,000
Print de gebruiker de naam van het bestand, niet op het scherm,

1060
00:57:44,000 --> 00:57:47,000
het huis naar het bestand niet op het scherm, en vervolgens naar beneden hier, uiteraard,

1061
00:57:47,000 --> 00:57:50,000
sluit het bestand, en dan naar beneden hier gratis het geheugen.

1062
00:57:50,000 --> 00:57:53,000
>> Het enige verschil tussen deze versie 2 en versie 1

1063
00:57:53,000 --> 00:57:58,000
is de introductie van fopen en dit bestand met *

1064
00:57:58,000 --> 00:58:01,000
en dit idee van fprintf, dus laten we eens kijken wat het eindresultaat is.

1065
00:58:01,000 --> 00:58:03,000
Laat me gaan in mijn terminal-venster.

1066
00:58:03,000 --> 00:58:06,000
Laat me lopen structs2, in te voeren.

1067
00:58:06,000 --> 00:58:09,000
Het lijkt erop dat alles in orde is. Laten we herhaling structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Tommy Mather, in te voeren.

1070
00:58:19,000 --> 00:58:23,000
Het lijkt alsof het gedroeg zich hetzelfde, maar als ik nu doe ls

1071
00:58:23,000 --> 00:58:28,000
merken wat bestand is hier onder al mijn code, database,

1072
00:58:28,000 --> 00:58:32,000
dus laten we open dat, gedit van database, en kijk naar dat.

1073
00:58:32,000 --> 00:58:34,000
Het is niet de meest sexy van bestandsindelingen.

1074
00:58:34,000 --> 00:58:38,000
Het is echt een stukje van gegevens regel per regel per regel,

1075
00:58:38,000 --> 00:58:42,000
maar degenen onder u die gebruik maken van Excel-of CSV-bestanden, door komma's gescheiden waarden,

1076
00:58:42,000 --> 00:58:47,000
Ik zou zeker fprintf hebben gebruikt in plaats misschien iets doen als dit

1077
00:58:47,000 --> 00:58:50,000
zodat ik kon eigenlijk maken het equivalent van een Excel-bestand

1078
00:58:50,000 --> 00:58:53,000
door het scheiden van dingen met komma's, niet alleen nieuwe lijnen.

1079
00:58:53,000 --> 00:58:56,000
>> In dit geval, als ik had gebruikt in plaats komma's in plaats van nieuwe lijnen

1080
00:58:56,000 --> 00:59:01,000
Ik kon deze database bestand letterlijk te openen in Excel of ik in plaats daarvan maakte het er als volgt uitzien.

1081
00:59:01,000 --> 00:59:03,000
Kortom, nu we de macht hebben om te schrijven naar bestanden

1082
00:59:03,000 --> 00:59:07,000
kunnen we nu beginnen aanhoudende gegevens, het houden van het rond op de disc

1083
00:59:07,000 --> 00:59:10,000
zodat wij zorgen ervoor dat informatie rond opnieuw en opnieuw.

1084
00:59:10,000 --> 00:59:14,000
Let op een paar andere dingen die nu een beetje meer vertrouwd.

1085
00:59:14,000 --> 00:59:16,000
Bovenaan dit bestand C we een typedef

1086
00:59:16,000 --> 00:59:21,000
want we wilden een gegevenstype dat een woord vertegenwoordigt te maken,

1087
00:59:21,000 --> 00:59:25,000
dus dit type heet woord, en de binnenkant van deze structuur

1088
00:59:25,000 --> 00:59:27,000
het is een beetje liefhebber nu.

1089
00:59:27,000 --> 00:59:30,000
Waarom is een woord dat is samengesteld van blijkbaar een array?

1090
00:59:30,000 --> 00:59:33,000
Wat is een woord net intuïtief?

1091
00:59:33,000 --> 00:59:35,000
>> Het is een array van karakters.

1092
00:59:35,000 --> 00:59:37,000
Het is een reeks tekens rug aan rug aan rug.

1093
00:59:37,000 --> 00:59:41,000
BRIEVEN in alle caps gebeurt te zijn we willekeurig zeggen dat de maximale lengte

1094
00:59:41,000 --> 00:59:44,000
van een woord in het woordenboek dat we gebruiken voor Scramble.

1095
00:59:44,000 --> 00:59:46,000
Waarom heb ik een +1?

1096
00:59:46,000 --> 00:59:48,000
De nul karakter.

1097
00:59:48,000 --> 00:59:51,000
Denk aan toen we de Bananagrams voorbeeld hebben we een speciale waarde die nodig is

1098
00:59:51,000 --> 00:59:55,000
aan het einde van het woord in te houden

1099
00:59:55,000 --> 00:59:59,000
waar woorden feitelijk heeft beëindigd, en het probleem set specificatie zegt

1100
00:59:59,000 --> 01:00:03,000
hier zijn we associëren met een bepaald woord een booleaanse waarde,

1101
01:00:03,000 --> 01:00:05,000
een vlag, om zo te zeggen, waar of onwaar.

1102
01:00:05,000 --> 01:00:09,000
Heeft u ook dit woord al, omdat we ons realiseren

1103
01:00:09,000 --> 01:00:13,000
we echt behoefte aan een manier van herinneren niet alleen wat een woord is in Scramble

1104
01:00:13,000 --> 01:00:15,000
maar of u, de mens, heb het gevonden

1105
01:00:15,000 --> 01:00:20,000
zodat als je vindt het woord "het" kun je niet alleen de typen, in te voeren, het, voer, de, voert u

1106
01:00:20,000 --> 01:00:23,000
en krijgt 3 punten, 3 punten, 3 punten, 3 punten.

1107
01:00:23,000 --> 01:00:26,000
We willen in staat zijn om dat woord blacklist door het instellen van een bool

1108
01:00:26,000 --> 01:00:29,000
op true wanneer u al gevonden, en dus dat is waarom we

1109
01:00:29,000 --> 01:00:31,000
ingekapseld in deze structuur.

1110
01:00:31,000 --> 01:00:35,000
>> Nu, hier in Scramble is er die andere struct genaamd woordenboek.

1111
01:00:35,000 --> 01:00:39,000
Hier afwezig is het woord typedef omdat in dit geval

1112
01:00:39,000 --> 01:00:43,000
moesten we het idee van een woordenboek in te kapselen,

1113
01:00:43,000 --> 01:00:46,000
en een woordenboek bevat een hele hoop woorden,

1114
01:00:46,000 --> 01:00:49,000
zoals gesuggereerd in deze array, en hoeveel van die woorden zijn er?

1115
01:00:49,000 --> 01:00:51,000
Nou, wat deze variabele genaamd omvang zegt.

1116
01:00:51,000 --> 01:00:53,000
Maar we hoeven alleen maar een woordenboek.

1117
01:00:53,000 --> 01:00:55,000
Wij hebben geen behoefte aan een gegevenstype genoemd dictionary.

1118
01:00:55,000 --> 01:00:58,000
We hoeven alleen maar een van hen, zo blijkt in C

1119
01:00:58,000 --> 01:01:03,000
dat als je niet zeggen typedef, alleen jij struct zeggen, dan is binnen de accolades

1120
01:01:03,000 --> 01:01:05,000
je je variabelen, dan zet je de naam.

1121
01:01:05,000 --> 01:01:09,000
Dit is te verklaren een variabele genaamd woordenboek

1122
01:01:09,000 --> 01:01:11,000
dat ziet er zo uit.

1123
01:01:11,000 --> 01:01:16,000
Daarentegen zijn deze lijnen creëren van een herbruikbare gegevens structuur genaamd woord

1124
01:01:16,000 --> 01:01:19,000
dat u kunt meerdere kopieën van, net als wij geschapen

1125
01:01:19,000 --> 01:01:22,000
meerdere exemplaren van studenten.

1126
01:01:22,000 --> 01:01:24,000
>> Wat betekent dit uiteindelijk kunnen we doen?

1127
01:01:24,000 --> 01:01:30,000
Laat me gaan terug in, laten we zeggen, een eenvoudiger voorbeeld van eenvoudiger tijden,

1128
01:01:30,000 --> 01:01:34,000
en laat me open te stellen, laten we zeggen, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Het probleem hier bij de hand is om daadwerkelijk schillen terug

1130
01:01:38,000 --> 01:01:41,000
de laag van een string en beginnen opstijgen deze zijwieltjes

1131
01:01:41,000 --> 01:01:44,000
omdat gebleken is dat een reeks al die tijd

1132
01:01:44,000 --> 01:01:47,000
is zoals we beloofd in week 1 eigenlijk gewoon een bijnaam,

1133
01:01:47,000 --> 01:01:51,000
een synoniem van de CS50 bibliotheek voor iets dat ziet er een beetje meer cryptische,

1134
01:01:51,000 --> 01:01:53,000
char *, en we hebben gezien deze ster voor.

1135
01:01:53,000 --> 01:01:55,000
We zagen het in de context van bestanden.

1136
01:01:55,000 --> 01:01:59,000
>> Laten we nu zien waarom we zijn ondergedoken dit detail enige tijd.

1137
01:01:59,000 --> 01:02:02,000
Hier is een bestand met de naam compare1.c,

1138
01:02:02,000 --> 01:02:07,000
en vraagt ​​de gebruiker kennelijk 2 strings, s en t,

1139
01:02:07,000 --> 01:02:11,000
en dan probeert die strings te vergelijken voor gelijkheid in de lijn 26,

1140
01:02:11,000 --> 01:02:14,000
en als ze gelijk het zegt: "Je hebt getypt hetzelfde,"

1141
01:02:14,000 --> 01:02:17,000
en als ze niet gelijk zijn het zegt: "Je hebt getypt verschillende dingen."

1142
01:02:17,000 --> 01:02:19,000
Laat me ga je gang en uitvoeren van dit programma.

1143
01:02:19,000 --> 01:02:23,000
Laat me gaan in mijn bron directory, maak een compare1. Het is goed samengesteld.

1144
01:02:23,000 --> 01:02:25,000
Laat me lopen compare1.

1145
01:02:25,000 --> 01:02:27,000
Ik zal inzoomen, in te voeren.

1146
01:02:27,000 --> 01:02:29,000
Zeg iets. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Ik zal weer iets zeggen. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Ik zeker niet typen verschillende dingen.

1149
01:02:34,000 --> 01:02:37,000
>> Laat ik nog eens proberen. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Zeker niet anders, dus wat is er hier aan de hand?

1151
01:02:40,000 --> 01:02:44,000
Nou, wat er echt wordt vergeleken in lijn 26?

1152
01:02:44,000 --> 01:02:46,000
[Onverstaanbaar-student]

1153
01:02:46,000 --> 01:02:49,000
Ja, dus het blijkt dat een string, data type, is een soort van een leugentje om bestwil.

1154
01:02:49,000 --> 01:02:53,000
Een string is een char *, maar wat is een char *?

1155
01:02:53,000 --> 01:02:56,000
Een char *, zoals ze zeggen, is een pointer,

1156
01:02:56,000 --> 01:03:00,000
en een pointer is in feite een adres,

1157
01:03:00,000 --> 01:03:05,000
een bedrag locatie in het geheugen, en als je toevallig hebt getypt in een woord als HELLO,

1158
01:03:05,000 --> 01:03:08,000
herinneren uit het verleden discussies van strings

1159
01:03:08,000 --> 01:03:16,000
dit is zoals het woord HELLO.

1160
01:03:16,000 --> 01:03:19,000
Vergeet niet dat een woord als HELLO kan worden weergegeven

1161
01:03:19,000 --> 01:03:22,000
als een array van karakters zoals deze

1162
01:03:22,000 --> 01:03:25,000
en vervolgens met een speciaal teken op het einde wel de nul-karakter,

1163
01:03:25,000 --> 01:03:27,000
als de \ duidt.

1164
01:03:27,000 --> 01:03:29,000
Wat is eigenlijk een string?

1165
01:03:29,000 --> 01:03:32,000
Merk op dat dit meerdere delen van het geheugen,

1166
01:03:32,000 --> 01:03:36,000
en in feite, is het einde van het pas gekend wanneer je kijkt door de hele reeks

1167
01:03:36,000 --> 01:03:38,000
op zoek naar de speciale nul karakter.

1168
01:03:38,000 --> 01:03:41,000
Maar als dit is een stuk van het geheugen uit het geheugen van mijn computer,

1169
01:03:41,000 --> 01:03:44,000
laten we willekeurig zeggen dat deze string gewoon geluk hebben,

1170
01:03:44,000 --> 01:03:47,000
en het werd geplaatst aan het begin van RAM-geheugen van mijn computer.

1171
01:03:47,000 --> 01:03:54,000
Dit byte 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Als ik zeg iets als GetString en ik doe string s = GetString

1173
01:04:02,000 --> 01:04:04,000
wat er echt wordt teruggestuurd?

1174
01:04:04,000 --> 01:04:08,000
Voor deze laatste paar weken, wat is er eigenlijk wordt opgeslagen in s

1175
01:04:08,000 --> 01:04:13,000
niet per se deze string, maar in dit geval wat is opgeslagen

1176
01:04:13,000 --> 01:04:18,000
het getal 0, want wat GetString eigenlijk doet

1177
01:04:18,000 --> 01:04:20,000
is het niet fysiek terug een string.

1178
01:04:20,000 --> 01:04:22,000
Dat heeft niet eens echt conceptuele zin.

1179
01:04:22,000 --> 01:04:24,000
Wat het doet terugkeer is een nummer.

1180
01:04:24,000 --> 01:04:28,000
Dat aantal is het adres van HELLO in het geheugen,

1181
01:04:28,000 --> 01:04:32,000
en string s dan, als we schillen terug deze laag, is string niet echt bestaat.

1182
01:04:32,000 --> 01:04:35,000
Het is slechts een vereenvoudiging van de CS50 bibliotheek.

1183
01:04:35,000 --> 01:04:38,000
>> Dit is echt iets genaamd char *.

1184
01:04:38,000 --> 01:04:41,000
Char is logisch, want wat is een woord, zoals HELLO?

1185
01:04:41,000 --> 01:04:44,000
Nou, het is een serie van tekens, een reeks tekens.

1186
01:04:44,000 --> 01:04:47,000
Char * betekent het adres van een karakter,

1187
01:04:47,000 --> 01:04:50,000
dus wat betekent het om een ​​string terug te keren?

1188
01:04:50,000 --> 01:04:53,000
Een leuke, eenvoudige manier om terug te keren een string

1189
01:04:53,000 --> 01:04:57,000
is in plaats van te proberen om erachter te komen hoe ik terug naar 5 of 6 verschillende bytes

1190
01:04:57,000 --> 01:05:01,000
laat mij terugkeren naar het adres van die byte?

1191
01:05:01,000 --> 01:05:03,000
De eerste.

1192
01:05:03,000 --> 01:05:06,000
Met andere woorden, laat me je het adres van een personage in het geheugen.

1193
01:05:06,000 --> 01:05:10,000
Dat char * staat, het adres van een teken in het geheugen.

1194
01:05:10,000 --> 01:05:12,000
Bel die variabele s.

1195
01:05:12,000 --> 01:05:15,000
Bewaren in s die bepaalde adres, dat willekeurig zei ik 0 is,

1196
01:05:15,000 --> 01:05:19,000
alleen maar om het simpel te houden, maar in werkelijkheid is het over het algemeen een groter aantal.

1197
01:05:19,000 --> 01:05:21,000
>> Wacht eens even.

1198
01:05:21,000 --> 01:05:23,000
Als je alleen geeft me het adres van het eerste teken, hoe kan ik weten wat het adres is

1199
01:05:23,000 --> 01:05:25,000
het tweede teken, de derde, de vierde en de vijfde?

1200
01:05:25,000 --> 01:05:27,000
[Onverstaanbaar-student]

1201
01:05:27,000 --> 01:05:31,000
Je hoeft alleen weet waar het einde van de string is door middel van deze handige truc,

1202
01:05:31,000 --> 01:05:35,000
dus als je iets als printf, wat printf letterlijk neemt als argument,

1203
01:05:35,000 --> 01:05:39,000
herinneren dat we deze% s tijdelijke aanduiding te gebruiken, en dan pas in

1204
01:05:39,000 --> 01:05:41,000
de variabele dat is het opslaan van een string.

1205
01:05:41,000 --> 01:05:47,000
Wat je echt voorbij is het adres van het eerste teken van die string.

1206
01:05:47,000 --> 01:05:50,000
Printf gebruikt dan een for-lus of een while-lus na ontvangst van dat adres,

1207
01:05:50,000 --> 01:05:53,000
bijvoorbeeld 0, dus laat mij nu dit,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Toen ik noem printf ("% s \ n", s); wat ik echt het verstrekken van printf met

1210
01:06:07,000 --> 01:06:13,000
is het adres van het eerste teken in s, in dit geval willekeurig H.

1211
01:06:13,000 --> 01:06:16,000
>> Hoe printf weet wat er precies om weer te geven op het scherm?

1212
01:06:16,000 --> 01:06:19,000
De persoon die geïmplementeerd printf implementeerde een while-lus of een for-lus

1213
01:06:19,000 --> 01:06:23,000
dat zegt heeft dit karakter gelijk zijn aan de speciale null karakter?

1214
01:06:23,000 --> 01:06:25,000
Zo niet, print het uit. Wat dacht je van deze?

1215
01:06:25,000 --> 01:06:28,000
Zo niet af te drukken, printen, afdrukken, afdrukken.

1216
01:06:28,000 --> 01:06:32,000
Oh, deze is speciaal. Stop met afdrukken en terug te keren naar de gebruiker.

1217
01:06:32,000 --> 01:06:35,000
En dat is letterlijk alles wat er gebeurt onder de motorkap,

1218
01:06:35,000 --> 01:06:38,000
en dat is veel te verteren in de eerste dag van een klasse,

1219
01:06:38,000 --> 01:06:43,000
maar voor nu is het echt de bouwsteen van begrip alles

1220
01:06:43,000 --> 01:06:46,000
dat er aan de hand aan de binnenkant van het geheugen van onze computer,

1221
01:06:46,000 --> 01:06:49,000
en uiteindelijk zullen we plagen Dit apart met een beetje hulp

1222
01:06:49,000 --> 01:06:51,000
van een van onze vrienden aan de Stanford.

1223
01:06:51,000 --> 01:06:56,000
>> Professor Nick Parlante aan de Stanford heeft gedaan dit prachtige video-opname

1224
01:06:56,000 --> 01:06:58,000
uit allerlei verschillende talen die geïntroduceerd

1225
01:06:58,000 --> 01:07:00,000
deze kleine Claymation karakter Binky.

1226
01:07:00,000 --> 01:07:03,000
De stem die je gaat horen in slechts een paar seconden sneak preview

1227
01:07:03,000 --> 01:07:05,000
is dat van een Stanford professor, en je krijgt

1228
01:07:05,000 --> 01:07:07,000
slechts 5 of 6 seconden van dit recht nu,

1229
01:07:07,000 --> 01:07:09,000
maar dit is de noot waarop we concluderen vandaag

1230
01:07:09,000 --> 01:07:11,000
en beginnen op woensdag.

1231
01:07:11,000 --> 01:07:15,000
Ik geef je Pointer Plezier met Binky, de preview.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ Music] [Professor Parlante] Hey, Binky.

1233
01:07:18,000 --> 01:07:21,000
Wakker worden. Het is tijd voor pointer plezier.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Wat is dat? Meer informatie over pointers?

1235
01:07:24,000 --> 01:07:26,000
Oh, goody!

1236
01:07:26,000 --> 01:07:29,000
>> We zullen je op woensdag.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]