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
[Dette er CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> Okay, det er CS50, og dette er begyndelsen af ​​uge 4,

5
00:00:12,000 --> 00:00:16,000
og dette er en af ​​de langsomste mulige sortering algoritmer.

6
00:00:16,000 --> 00:00:19,000
Hvilken en var det, at vi har lige set der?

7
00:00:19,000 --> 00:00:24,000
Det var boble sortere, for big O (n ^ 2) + sum,

8
00:00:24,000 --> 00:00:28,000
og faktisk er vi ikke de eneste i denne verden for at synes at vide

9
00:00:28,000 --> 00:00:30,000
hvilken boble slags er eller dens køretid.

10
00:00:30,000 --> 00:00:33,000
Faktisk var dette et interview med Eric Schmidt fra Google

11
00:00:33,000 --> 00:00:45,000
og tidligere senator Barack Obama blot et par år siden.

12
00:00:45,000 --> 00:00:48,000
>> Nu, Senator, du er her hos Google,

13
00:00:48,000 --> 00:00:54,000
og jeg kan lide at tænke på formandskabet som en jobsamtale.

14
00:00:54,000 --> 00:00:58,000
Nu er det svært at få et job som præsident, og du går igennem strabadserne nu.

15
00:00:58,000 --> 00:01:00,000
Det er også svært at få et job hos Google.

16
00:01:00,000 --> 00:01:05,000
Vi har spørgsmål, og vi beder vores kandidater spørgsmål,

17
00:01:05,000 --> 00:01:10,000
og denne ene er fra Larry Schwimmer.

18
00:01:10,000 --> 00:01:14,000
Du fyre tror jeg laver sjov? Det er lige her.

19
00:01:14,000 --> 00:01:18,000
Hvad er den mest effektive måde at sortere en million 32-bit heltal?

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

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

22
00:01:24,000 --> 00:01:26,000
Jeg er ked af det. >> Nej, nej, nej, nej.

23
00:01:26,000 --> 00:01:34,000
Jeg tror boble slags ville være den forkerte vej at gå.

24
00:01:34,000 --> 00:01:39,000
>> Kom nu, der fortalte ham det?

25
00:01:39,000 --> 00:01:43,000
Sidste uge husker vi tog en pause fra kode, i det mindste for en dag,

26
00:01:43,000 --> 00:01:46,000
og begyndte at fokusere på nogle højere niveau ideer og problemløsning mere generelt

27
00:01:46,000 --> 00:01:49,000
i forbindelse med søgning og sortering,

28
00:01:49,000 --> 00:01:53,000
og vi introducerede noget, som vi ikke klaske dette navn på i sidste uge,

29
00:01:53,000 --> 00:01:56,000
men asymptotisk notation, Big O, Big Omega,

30
00:01:56,000 --> 00:02:00,000
og nogle gange Big Theta notation, og disse var simpelthen måder

31
00:02:00,000 --> 00:02:02,000
at beskrive køretiden for algoritmer,

32
00:02:02,000 --> 00:02:05,000
hvor lang tid det tager for en algoritme til at køre.

33
00:02:05,000 --> 00:02:08,000
>> Og du kan huske, at du talte om den løbende tid med hensyn til størrelse

34
00:02:08,000 --> 00:02:11,000
af input, som vi generelt kalder n, hvad problemet kan være,

35
00:02:11,000 --> 00:02:13,000
hvor n er antallet af personer i lokalet,

36
00:02:13,000 --> 00:02:17,000
antallet af sider i en telefonbog, og vi begyndte at skrive ting ud

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

38
00:02:21,000 --> 00:02:24,000
og selv når det math ikke helt finde ud af så perfekt

39
00:02:24,000 --> 00:02:28,000
og det var n ² - n / 2 eller noget i den retning

40
00:02:28,000 --> 00:02:31,000
ville vi i stedet bare smide nogle af de lavere ordens led,

41
00:02:31,000 --> 00:02:34,000
og motivationen er der, at vi virkelig ønsker en

42
00:02:34,000 --> 00:02:37,000
slags objektiv måde at vurdere

43
00:02:37,000 --> 00:02:39,000
udførelse af programmer eller udførelse af algoritmer

44
00:02:39,000 --> 00:02:42,000
at ved udgangen af ​​dagen har intet at gøre, for eksempel,

45
00:02:42,000 --> 00:02:45,000
med hastigheden på din computer i dag.

46
00:02:45,000 --> 00:02:47,000
>> For eksempel, hvis du implementerer boble sortere

47
00:02:47,000 --> 00:02:50,000
eller du implementere fusionere sortere eller udvælgelse sortere på dagens computer,

48
00:02:50,000 --> 00:02:53,000
en 2 GHz computer, og du kører det,

49
00:02:53,000 --> 00:02:56,000
og det tager nogle antal sekunder, næste år er der en 3 GHz

50
00:02:56,000 --> 00:02:59,000
eller en 4 GHz computer, og du kan derefter hævde, at "Wow, min algoritme

51
00:02:59,000 --> 00:03:03,000
er nu dobbelt så hurtigt, "når de i virkeligheden, der er naturligvis ikke tilfældet.

52
00:03:03,000 --> 00:03:06,000
Det er bare hardwaren har fået hurtigere, men din computer

53
00:03:06,000 --> 00:03:10,000
har ikke, og så vi virkelig ønsker at smide ting som

54
00:03:10,000 --> 00:03:13,000
multipla af 2 eller multipla af 3, når det kommer til at beskrive

55
00:03:13,000 --> 00:03:17,000
hvor hurtigt eller hvor langsomt en algoritme er og virkelig bare fokusere

56
00:03:17,000 --> 00:03:20,000
på n eller en faktor deraf,

57
00:03:20,000 --> 00:03:24,000
vis magt deraf som i tilfælde af den type fra sidste uge.

58
00:03:24,000 --> 00:03:27,000
Og huske på, at med hjælp fra fletningen sort

59
00:03:27,000 --> 00:03:31,000
vi var i stand til at gøre så meget bedre end boble sortere og udvælgelse sortere

60
00:03:31,000 --> 00:03:33,000
og endda insertion art.

61
00:03:33,000 --> 00:03:36,000
>> Vi kom ned til n log n, og igen,

62
00:03:36,000 --> 00:03:39,000
minde om, at log n generelt henviser til noget, der vokser

63
00:03:39,000 --> 00:03:43,000
langsommere da n, så n log n hidtil var god

64
00:03:43,000 --> 00:03:45,000
fordi det var mindre end n ².

65
00:03:45,000 --> 00:03:47,000
Men for at opnå n log n med fletningen sort

66
00:03:47,000 --> 00:03:51,000
hvad var det grundlæggende kimen til en idé om, at vi var nødt til at udnytte

67
00:03:51,000 --> 00:03:54,000
at vi også udnyttes igen i uge 0?

68
00:03:54,000 --> 00:03:58,000
Hvordan kunne vi løse sortering problemet behændigt med fletningen slags?

69
00:03:58,000 --> 00:04:04,000
Hvad var nøglen indsigt, måske?

70
00:04:04,000 --> 00:04:07,000
Nogen overhovedet.

71
00:04:07,000 --> 00:04:09,000
Okay, lad os tage et skridt tilbage.

72
00:04:09,000 --> 00:04:11,000
Beskriv fusionere sortere i dine egne ord.

73
00:04:11,000 --> 00:04:15,000
Hvordan virkede det?

74
00:04:15,000 --> 00:04:17,000
Okay, vi ro tilbage til uge 0.

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

76
00:04:19,000 --> 00:04:22,000
[Uhørlig-studerende]

77
00:04:22,000 --> 00:04:26,000
Okay, godt, så vi delte den vifte af numre i 2 stykker.

78
00:04:26,000 --> 00:04:29,000
Vi sorteres hver af disse stykker, og så har vi fusioneret dem,

79
00:04:29,000 --> 00:04:33,000
og vi har set denne idé før om at tage et problem, der er så store

80
00:04:33,000 --> 00:04:36,000
og hakke det op i et problem, der er så store eller dette store.

81
00:04:36,000 --> 00:04:38,000
>> Recall telefonbogen eksempel.

82
00:04:38,000 --> 00:04:42,000
Hent det selv-tælling algoritme fra uger siden,

83
00:04:42,000 --> 00:04:45,000
så fusionere art, er blevet sammenfattet af denne pseudokode her.

84
00:04:45,000 --> 00:04:48,000
Når du er givet n elementer, først var det sanity check.

85
00:04:48,000 --> 00:04:51,000
Hvis n <2 så skal du ikke gøre noget som helst

86
00:04:51,000 --> 00:04:55,000
for hvis n <2 så n er naturligvis 0 eller 1,

87
00:04:55,000 --> 00:04:57,000
og så hvis det er enten 0 eller 1 der er ikke noget at sortere.

88
00:04:57,000 --> 00:04:59,000
Du er færdig.

89
00:04:59,000 --> 00:05:01,000
Din liste er allerede trivielt sorteres.

90
00:05:01,000 --> 00:05:04,000
Men ellers hvis du har 2 eller flere elementer gå videre og opdele dem

91
00:05:04,000 --> 00:05:06,000
i 2 halvdele,. venstre og højre

92
00:05:06,000 --> 00:05:09,000
Sortere hver af disse halvdele, og derefter flette de sorterede halvdele.

93
00:05:09,000 --> 00:05:13,000
Men problemet her er, at ved første øjekast dette føles som om vi punting.

94
00:05:13,000 --> 00:05:17,000
Det er en cirkulær definition i, at hvis jeg har bedt dig at sortere disse n elementer

95
00:05:17,000 --> 00:05:22,000
og du fortæller mig "Okay, fint, vi sortere de n / 2, og dem n / 2 elementer,"

96
00:05:22,000 --> 00:05:27,000
så mit næste spørgsmål vil være "Fine, hvordan kan du sortere n / 2 elementer?"

97
00:05:27,000 --> 00:05:30,000
>> Men på grund af strukturen af ​​programmet,

98
00:05:30,000 --> 00:05:33,000
fordi der er denne oprindelige sag, så at sige,

99
00:05:33,000 --> 00:05:39,000
dette særlige tilfælde, der siger, at hvis n er <nogle fast værdi ligesom 2 tilbage med det samme.

100
00:05:39,000 --> 00:05:42,000
Må ikke reagere med det samme cirkulære svar.

101
00:05:42,000 --> 00:05:46,000
Denne proces vil denne cyclicity sidst ende.

102
00:05:46,000 --> 00:05:50,000
Hvis jeg spørger dig "Sort disse n elementer", og du siger, "Fint, sortere disse n / 2,"

103
00:05:50,000 --> 00:05:53,000
så du siger, "Fint, sortere disse n / 4, n / 8, N/16,"

104
00:05:53,000 --> 00:05:56,000
sidste ende vil du dividere med en stor nok tal

105
00:05:56,000 --> 00:05:59,000
at du har kun 1 element til venstre, hvorefter du kan sige,

106
00:05:59,000 --> 00:06:02,000
"Her, her er en sorteret enkelt element."

107
00:06:02,000 --> 00:06:06,000
Så glans af denne algoritme op her er at udlede fra det faktum

108
00:06:06,000 --> 00:06:09,000
at når du har alle disse individuelt sorterede lister,

109
00:06:09,000 --> 00:06:12,000
som alle er af størrelse 1, som synes at være ubrugelig,

110
00:06:12,000 --> 00:06:15,000
når du begynder at lægge dem sammen og lægge dem sammen

111
00:06:15,000 --> 00:06:19,000
du opbygge endelig som Rob gjorde i videoen en endelig sorteret liste.

112
00:06:19,000 --> 00:06:22,000
>> Men denne idé rækker langt ud over sortering.

113
00:06:22,000 --> 00:06:26,000
Der er denne idé indlejret i dette program kaldet rekursion,

114
00:06:26,000 --> 00:06:29,000
ideen, hvor du er et program,

115
00:06:29,000 --> 00:06:32,000
og at løse et problem du kalder dig selv,

116
00:06:32,000 --> 00:06:36,000
eller sættes i forbindelse med programmeringssprog du er en funktion,

117
00:06:36,000 --> 00:06:39,000
og for at løse et problem, du funktionen kalde dig

118
00:06:39,000 --> 00:06:42,000
igen og igen og igen, men du funktionen

119
00:06:42,000 --> 00:06:44,000
kan ikke kalde dig uendeligt mange gange.

120
00:06:44,000 --> 00:06:47,000
Til sidst er du nødt til bunden ud, så at sige,

121
00:06:47,000 --> 00:06:49,000
og har nogle hard-coded basis betingelse, siger

122
00:06:49,000 --> 00:06:53,000
på dette tidspunkt at kalde sig selv, således at hele processen

123
00:06:53,000 --> 00:06:56,000
endelig rent faktisk stopper.

124
00:06:56,000 --> 00:06:58,000
Hvad betyder det egentlig, at recurse?

125
00:06:58,000 --> 00:07:01,000
>> Lad os se, om vi kan gøre en enkel, triviel eksempel med, siger,

126
00:07:01,000 --> 00:07:03,000
3 personer med mig op her på scenen, hvis nogen er komfortabel.

127
00:07:03,000 --> 00:07:06,000
1, kom op, 2 og 3.

128
00:07:06,000 --> 00:07:09,000
Hvis du 3 ønsker at komme herop.

129
00:07:09,000 --> 00:07:12,000
Hvis du ønsker at stå lige ved siden af ​​mig her i en linje, formoder, at problemet ved hånden

130
00:07:12,000 --> 00:07:15,000
er meget trivielt tælle antallet af mennesker, der er her.

131
00:07:15,000 --> 00:07:18,000
Men helt ærligt, jeg er træt af alle disse tælle eksempler.

132
00:07:18,000 --> 00:07:21,000
Dette vil tage nogen tid, 1, 2, og prik, prik, prik.

133
00:07:21,000 --> 00:07:23,000
Det kommer til at tage for evigt.

134
00:07:23,000 --> 00:07:25,000
Jeg vil hellere bare punt dette problem helt ved hjælp af-hvad er dit navn?

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

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

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

138
00:07:31,000 --> 00:07:34,000
Lige nu har jeg fået stillet spørgsmålet af en person

139
00:07:34,000 --> 00:07:37,000
hvor mange mennesker er op på dette tidspunkt, og jeg har ingen idé.

140
00:07:37,000 --> 00:07:40,000
Dette er en virkelig lang liste, og så i stedet vil jeg gøre dette trick.

141
00:07:40,000 --> 00:07:43,000
Jeg har tænkt mig at spørge personen ved siden af ​​mig at gøre det meste af arbejdet,

142
00:07:43,000 --> 00:07:46,000
og når hun er færdig laver det meste af arbejdet

143
00:07:46,000 --> 00:07:49,000
Jeg har tænkt mig at gøre den mindste mængde af arbejde muligt og bare tilføje 1

144
00:07:49,000 --> 00:07:51,000
til, hvad hendes svar er, så here we go.

145
00:07:51,000 --> 00:07:54,000
Jeg er blevet spurgt om, hvor mange mennesker er på scenen.

146
00:07:54,000 --> 00:07:57,000
Hvor mange mennesker er på scenen til venstre for dig?

147
00:07:57,000 --> 00:08:00,000
Den venstre af mig? >> Okay, men ikke snyde.

148
00:08:00,000 --> 00:08:04,000
Det er godt, det er korrekt, men hvis vi ønsker at fortsætte denne logik

149
00:08:04,000 --> 00:08:08,000
lad os antage, at du ligeledes ønsker at punt dette problem til venstre for dig,

150
00:08:08,000 --> 00:08:11,000
så i stedet for svar direkte gå videre og bare give sorteper.

151
00:08:11,000 --> 00:08:14,000
Åh, hvor mange mennesker er til venstre for mig?

152
00:08:14,000 --> 00:08:16,000
Hvor mange mennesker er til venstre?

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

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

155
00:08:27,000 --> 00:08:30,000
Okay, så 0, så hvad nu Willy har gjort

156
00:08:30,000 --> 00:08:33,000
er du har returneret dit svar denne retning siger 0.

157
00:08:33,000 --> 00:08:36,000
Nu, hvad skal du så gøre? >> 1.

158
00:08:36,000 --> 00:08:39,000
Okay, så du er den 1, så du siger, "Okay, jeg skal tilføje 1

159
00:08:39,000 --> 00:08:41,000
at uanset Willy tælleretning var, "så 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Du er nu 1, så dit svar til højre er nu-

161
00:08:43,000 --> 00:08:45,000
1. >> Og mine ville være 2.

162
00:08:45,000 --> 00:08:48,000
Godt, så du tager den tidligere svar på 1,

163
00:08:48,000 --> 00:08:51,000
tilsætte den minimale mængde arbejde, du ønsker at gøre, hvilket er +1.

164
00:08:51,000 --> 00:08:55,000
Du har nu 2, og du derefter give mig hvilken værdi?

165
00:08:55,000 --> 00:08:57,000
3, jeg mener, undskyld, 2.

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

167
00:08:59,000 --> 00:09:02,000
>> Nå, vi havde 0 til venstre.

168
00:09:02,000 --> 00:09:05,000
Derefter havde vi 1 og derefter tilføjer vi 2,

169
00:09:05,000 --> 00:09:07,000
og nu er du rakte mig et 2-tal,

170
00:09:07,000 --> 00:09:10,000
og så jeg siger, okay, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Der er faktisk 3 personer stående ved siden af ​​mig på nuværende tidspunkt,

172
00:09:13,000 --> 00:09:16,000
så vi kunne har naturligvis gjort det meget lineært,

173
00:09:16,000 --> 00:09:19,000
meget i indlysende måde, men hvad gjorde vi virkelig gøre?

174
00:09:19,000 --> 00:09:21,000
Vi tog et problem med størrelse 3. oprindeligt.

175
00:09:21,000 --> 00:09:24,000
Vi derefter brød det ned til et problem af størrelse 2,

176
00:09:24,000 --> 00:09:27,000
derefter et problem af størrelse 1, og derefter endelig hovedforslaget

177
00:09:27,000 --> 00:09:29,000
var virkelig, oh, der er ingen der,

178
00:09:29,000 --> 00:09:33,000
på hvilket tidspunkt Willy vendte faktisk en hard-coded svar et par gange,

179
00:09:33,000 --> 00:09:36,000
og den anden blev derefter boblet op, boblede op, boblede op,

180
00:09:36,000 --> 00:09:39,000
og derefter ved tilsætning i denne ene yderligere 1

181
00:09:39,000 --> 00:09:41,000
vi har implementeret denne grundlæggende idé om rekursion.

182
00:09:41,000 --> 00:09:44,000
>> Nu, i dette tilfælde det virkelig ikke løse et problem

183
00:09:44,000 --> 00:09:46,000
mere effektivt, så vi har set hidtil.

184
00:09:46,000 --> 00:09:48,000
Men tænk over de algoritmer vi har gjort på scenen hidtil.

185
00:09:48,000 --> 00:09:51,000
Vi havde 8 stykker papir på tavlen,

186
00:09:51,000 --> 00:09:55,000
på video, når Sean var på udkig efter det nummer 7, og hvad gjorde han virkelig gøre?

187
00:09:55,000 --> 00:09:58,000
Tja, han ikke gøre nogen form for del og hersk.

188
00:09:58,000 --> 00:10:01,000
Han gjorde ikke gøre nogen form for rekursion.

189
00:10:01,000 --> 00:10:03,000
Snarere han bare gjorde det lineære algoritme.

190
00:10:03,000 --> 00:10:07,000
Men da vi introducerede ideen om sorteret numre på scenen lever i sidste uge

191
00:10:07,000 --> 00:10:09,000
derefter havde vi dette instinkt for at gå til midten,

192
00:10:09,000 --> 00:10:13,000
på hvilket punkt vi havde en mindre liste over størrelse 4 eller anden liste over størrelse 4,

193
00:10:13,000 --> 00:10:17,000
og derefter havde vi nøjagtig samme problem, så vi gentog, gentog, gentages.

194
00:10:17,000 --> 00:10:19,000
Med andre ord rekursivt vi.

195
00:10:19,000 --> 00:10:24,000
Mange tak til vores 3 frivillige her for at demonstrere rekursion med os.

196
00:10:24,000 --> 00:10:28,000
>> Lad os se om vi ikke kan gøre det nu lidt mere konkret,

197
00:10:28,000 --> 00:10:30,000
løse et problem, at vi igen kunne gøre temmelig let,

198
00:10:30,000 --> 00:10:34,000
men vi vil bruge det som et springbræt til gennemførelse af denne grundtanke.

199
00:10:34,000 --> 00:10:37,000
Hvis jeg ønsker at beregne summen af ​​en masse numre,

200
00:10:37,000 --> 00:10:39,000
for eksempel, hvis du passerer i nummer 3

201
00:10:39,000 --> 00:10:42,000
Jeg vil gerne give dig værdien af ​​sigma 3,

202
00:10:42,000 --> 00:10:46,000
så summen af ​​3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Jeg ønsker at komme tilbage svaret 6,

204
00:10:48,000 --> 00:10:51,000
så vi vil gennemføre denne sigma funktion, denne summation funktion

205
00:10:51,000 --> 00:10:54,000
at, igen, tager i input, og returnerer derefter summation

206
00:10:54,000 --> 00:10:57,000
dette nummer hele vejen ned til 0.

207
00:10:57,000 --> 00:10:59,000
Vi kunne gøre det temmelig simpelt, ikke?

208
00:10:59,000 --> 00:11:01,000
Vi kunne gøre det med en vis form for looping struktur,

209
00:11:01,000 --> 00:11:04,000
så lad mig gå videre og få det i gang.

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

211
00:11:07,000 --> 00:11:09,000
Lad mig få mig ind i main at arbejde med her.

212
00:11:09,000 --> 00:11:12,000
Lad os gemme det som sigma.c.

213
00:11:12,000 --> 00:11:14,000
Så jeg har tænkt mig at gå ind her, og jeg har tænkt mig at erklære en int n,

214
00:11:14,000 --> 00:11:18,000
og jeg har tænkt mig at gøre følgende, mens brugeren ikke samarbejder.

215
00:11:18,000 --> 00:11:22,000
Selvom brugeren ikke har givet mig et positivt tal

216
00:11:22,000 --> 00:11:26,000
Lad mig gå videre og bede dem for n = GetInt,

217
00:11:26,000 --> 00:11:28,000
og lad mig give dem nogle instrukser om, hvad de skal gøre,

218
00:11:28,000 --> 00:11:33,000
så printf ("Positive heltal please").

219
00:11:33,000 --> 00:11:39,000
Bare noget relativt simpelt som dette, så ved den tid, vi ramt linie 14

220
00:11:39,000 --> 00:11:42,000
vi nu har et positivt heltal formentlig i n.

221
00:11:42,000 --> 00:11:44,000
>> Lad os nu gøre noget ved det.

222
00:11:44,000 --> 00:11:50,000
Lad mig gå videre og beregne summation, så int sum = sigma (n).

223
00:11:50,000 --> 00:11:54,000
Sigma er bare summation, så jeg bare skrive det på amatør måde.

224
00:11:54,000 --> 00:11:56,000
Vi vil bare kalde det sigma der.

225
00:11:56,000 --> 00:11:58,000
Det er summen, og nu jeg har tænkt mig at udskrive resultatet,

226
00:11:58,000 --> 00:12:08,000
printf ("Summen er% d, \ n", sum).

227
00:12:08,000 --> 00:12:11,000
Og så vil jeg vende tilbage 0 for god foranstaltning.

228
00:12:11,000 --> 00:12:15,000
Vi har gjort alt, hvad dette program kræver undtagen den interessante del,

229
00:12:15,000 --> 00:12:18,000
der er rent faktisk at gennemføre den sigma-funktionen.

230
00:12:18,000 --> 00:12:22,000
>> Lad mig gå ned her til bunden, og lad mig erklære funktion sigma.

231
00:12:22,000 --> 00:12:26,000
Det er nødt til at tage en variabel, der er af typen heltal,

232
00:12:26,000 --> 00:12:30,000
og hvad datatype ønsker jeg at vende tilbage formentlig fra sigma?

233
00:12:30,000 --> 00:12:34,000
Int., fordi jeg ønsker det til at matche mine forventninger på linje 15.

234
00:12:34,000 --> 00:12:37,000
Herinde lad mig gå videre og gennemføre denne

235
00:12:37,000 --> 00:12:41,000
i en temmelig ligetil måde.

236
00:12:41,000 --> 00:12:45,000
>> Lad os gå videre og sige int sum = 0,

237
00:12:45,000 --> 00:12:47,000
og nu jeg har tænkt mig at gå har en lidt for løkke her

238
00:12:47,000 --> 00:12:50,000
der kommer til at sige noget som dette,

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

240
00:13:01,000 --> 00:13:05,000
Og så jeg har tænkt mig at vende tilbage sum.

241
00:13:05,000 --> 00:13:07,000
Jeg kunne have gennemført dette i en række forskellige måder.

242
00:13:07,000 --> 00:13:09,000
Jeg kunne have brugt en while-løkke.

243
00:13:09,000 --> 00:13:11,000
Jeg kunne have sprunget med sum variabel, hvis jeg virkelig ville,

244
00:13:11,000 --> 00:13:15,000
men kort sagt, vi bare have en funktion, at hvis jeg ikke gjorde goof erklærer sum er 0.

245
00:13:15,000 --> 00:13:18,000
Så gentages fra 0 på op gennem nummer,

246
00:13:18,000 --> 00:13:23,000
og på hver iteration tilføjer den nuværende værdi for sum og derefter vender tilbage sum.

247
00:13:23,000 --> 00:13:25,000
>> Nu er der er en lille optimering her.

248
00:13:25,000 --> 00:13:29,000
Dette er sandsynligvis et spildt skridt, men så må det være. Det er fint for nu.

249
00:13:29,000 --> 00:13:32,000
Vi er i det mindste at være grundig og går 0 hele vejen på op.

250
00:13:32,000 --> 00:13:34,000
Ikke meget hårdt og temmelig ligetil,

251
00:13:34,000 --> 00:13:37,000
men det viser sig, at med den sigma funktion, vi har de samme muligheder

252
00:13:37,000 --> 00:13:39,000
som vi gjorde her på scenen.

253
00:13:39,000 --> 00:13:42,000
På scenen har vi bare talt, hvor mange mennesker var ved siden af ​​mig,

254
00:13:42,000 --> 00:13:47,000
men i stedet, hvis vi ønskede at tælle antallet 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
på ned til 0 vi kunne ligeledes punt til en funktion

256
00:13:51,000 --> 00:13:55,000
at I stedet vil betegne som rekursiv.

257
00:13:55,000 --> 00:13:57,000
Her lad os gøre en hurtig tilregnelighed kontrollere og sørge for jeg ikke goof.

258
00:13:57,000 --> 00:14:00,000
>> Jeg ved, der er mindst én ting i dette program, som jeg gjorde forkert.

259
00:14:00,000 --> 00:14:04,000
Da jeg ramte ind skal jeg få nogen form for råben på mig?

260
00:14:04,000 --> 00:14:06,000
Hvad skal jeg være råbte på om?

261
00:14:06,000 --> 00:14:11,000
Ja, jeg glemte prototypen, så jeg bruger en funktion kaldet sigma på linie 15,

262
00:14:11,000 --> 00:14:16,000
men det er ikke erklæret indtil linie 22, så jeg bedst proaktivt gå op her

263
00:14:16,000 --> 00:14:22,000
og erklære en prototype, og jeg vil sige int sigma (int tal), og det er det.

264
00:14:22,000 --> 00:14:24,000
Det er implementeret i bunden.

265
00:14:24,000 --> 00:14:27,000
>> Eller en anden måde jeg kunne løse dette,

266
00:14:27,000 --> 00:14:30,000
Jeg kunne flytte funktionen deroppe, hvilket ikke er dårligt,

267
00:14:30,000 --> 00:14:32,000
men i hvert fald når dine programmer begynder at blive lang, helt ærligt,

268
00:14:32,000 --> 00:14:35,000
Jeg tror der er en vis værdi i altid at have main øverst

269
00:14:35,000 --> 00:14:38,000
så du i læseren kan åbne filen og derefter straks se

270
00:14:38,000 --> 00:14:40,000
hvad programmet gør uden at skulle søge igennem det

271
00:14:40,000 --> 00:14:42,000
udkig efter at hovedfunktion.

272
00:14:42,000 --> 00:14:49,000
Lad os gå ned til min terminal vindue her, prøve at lave sigma gøre sigma,

273
00:14:49,000 --> 00:14:51,000
og jeg skruet op her også.

274
00:14:51,000 --> 00:14:55,000
Implicit erklæring af funktionen GetInt betyder, at jeg har glemt at gøre, hvad ellers?

275
00:14:55,000 --> 00:14:57,000
[Uhørlig-studerende]

276
00:14:57,000 --> 00:15:00,000
Godt, så tilsyneladende en almindelig fejl, så lad os sætte dette op her,

277
00:15:00,000 --> 00:15:04,000
cs50.h, og lad os nu gå tilbage til min terminal vindue.

278
00:15:04,000 --> 00:15:08,000
>> Jeg vil rydde skærmen, og jeg vil køre lave sigma.

279
00:15:08,000 --> 00:15:11,000
Det synes at have kompileret. Lad mig nu køre sigma.

280
00:15:11,000 --> 00:15:15,000
Jeg vil skrive i nummer 3, og jeg fik 6, så ikke en streng kontrol,

281
00:15:15,000 --> 00:15:18,000
men i det mindste ser ud til at virke ved første øjekast, men lad os nu rive det fra hinanden,

282
00:15:18,000 --> 00:15:21,000
og lad os faktisk udnytter ideen om rekursion, igen,

283
00:15:21,000 --> 00:15:24,000
i en meget enkel sammenhæng, således at i et par uger

284
00:15:24,000 --> 00:15:27,000
når vi begynder at udforske mere avanceret datastrukturer end arrays

285
00:15:27,000 --> 00:15:30,000
Vi har endnu et værktøj i værktøjskassen med til at

286
00:15:30,000 --> 00:15:33,000
manipulere disse datastrukturer som vi vil se.

287
00:15:33,000 --> 00:15:36,000
Dette er den iterative tilgang, løkken tilgang.

288
00:15:36,000 --> 00:15:39,000
>> Lad mig i stedet nu gøre dette.

289
00:15:39,000 --> 00:15:44,000
Lad mig i stedet sige, at summen af ​​antal

290
00:15:44,000 --> 00:15:48,000
ned til 0 er virkelig den samme som

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

292
00:15:53,000 --> 00:15:57,000
Med andre ord, jeg ligesom på scenen hasard til hver af de mennesker ud for mig,

293
00:15:57,000 --> 00:16:00,000
og de til gengæld holdt punting indtil vi endelig fladede ud på Willy,

294
00:16:00,000 --> 00:16:03,000
der havde til at returnere en hard-coded svar ligesom 0.

295
00:16:03,000 --> 00:16:07,000
Her nu er vi ligeledes punting til sigma

296
00:16:07,000 --> 00:16:10,000
den samme funktion som oprindeligt blev kaldt, men den centrale indsigt her

297
00:16:10,000 --> 00:16:12,000
er, at vi ikke kalder sigma ens.

298
00:16:12,000 --> 00:16:14,000
Vi er ikke passerer i n.

299
00:16:14,000 --> 00:16:17,000
Vi er helt klart passerer i nummer - 1,

300
00:16:17,000 --> 00:16:20,000
så en lidt mindre problem, lidt mindre problem.

301
00:16:20,000 --> 00:16:23,000
>> Desværre er det ikke helt en løsning endnu, og før vi retter

302
00:16:23,000 --> 00:16:26,000
hvad der kan springe ud som indlysende på nogle af jer

303
00:16:26,000 --> 00:16:28,000
Lad mig gå videre og kør gøre.

304
00:16:28,000 --> 00:16:30,000
Det synes at kompilere okay.

305
00:16:30,000 --> 00:16:32,000
Lad mig køre sigma med 6.

306
00:16:32,000 --> 00:16:37,000
Whoops, lad mig køre sigma med 6.

307
00:16:37,000 --> 00:16:42,000
Vi har set det før, men ved et uheld sidste gang så godt.

308
00:16:42,000 --> 00:16:48,000
Hvorfor fik jeg denne kryptiske segmenteringsfejl? Yeah.

309
00:16:48,000 --> 00:16:50,000
[Uhørlig-studerende]

310
00:16:50,000 --> 00:16:53,000
Der er ingen base case, og mere specifikt, hvad sandsynligvis sket?

311
00:16:53,000 --> 00:16:58,000
Det er et symptom på, hvad adfærd?

312
00:16:58,000 --> 00:17:00,000
Sig det lidt højere.

313
00:17:00,000 --> 00:17:02,000
[Uhørlig-studerende]

314
00:17:02,000 --> 00:17:05,000
Det er en uendelig løkke effektivt, og problemet med uendelige løkker

315
00:17:05,000 --> 00:17:08,000
når de involverer rekursion i dette tilfælde, en funktion kalder sig selv,

316
00:17:08,000 --> 00:17:10,000
hvad der sker, hver gang du kalder en funktion?

317
00:17:10,000 --> 00:17:13,000
Nå, tænker tilbage på, hvordan vi lagde ud hukommelsen i en computer.

318
00:17:13,000 --> 00:17:16,000
Vi sagde, at der er denne luns af hukommelse kaldet stakken, der er i bunden,

319
00:17:16,000 --> 00:17:19,000
og hver gang du kalder en funktion lidt mere hukommelse bliver sat

320
00:17:19,000 --> 00:17:24,000
på denne såkaldte stak, der indeholder denne funktion lokale variabler eller parametre,

321
00:17:24,000 --> 00:17:27,000
så hvis sigma opkald sigma opkald sigma opkald sigma

322
00:17:27,000 --> 00:17:29,000
 kalder sigma hvor kommer denne historie ende?

323
00:17:29,000 --> 00:17:31,000
>> Godt, det i sidste ende overskridelser det samlede beløb

324
00:17:31,000 --> 00:17:33,000
af hukommelse, som du har til rådighed til din computer.

325
00:17:33,000 --> 00:17:37,000
Du overskridelse det segment, som du forventes at holde sig inden,

326
00:17:37,000 --> 00:17:40,000
og du får denne segmentering fejl, core dumpet,

327
00:17:40,000 --> 00:17:43,000
og hvad kerne dumpet betyder er, at jeg nu har en fil kaldet kerne

328
00:17:43,000 --> 00:17:46,000
der er en fil, der indeholder nuller og ettaller

329
00:17:46,000 --> 00:17:49,000
der faktisk i fremtiden vil være diagnostisk anvendeligt.

330
00:17:49,000 --> 00:17:52,000
Hvis det ikke er indlysende for dig, hvor din bug er

331
00:17:52,000 --> 00:17:54,000
du kan faktisk gøre en smule af retskemisk analyse, så at sige,

332
00:17:54,000 --> 00:17:58,000
på dette core dump fil, er der, igen, bare en hel masse nuller og ettaller

333
00:17:58,000 --> 00:18:02,000
der hovedsageligt repræsenterer tilstanden af ​​dit program i hukommelsen

334
00:18:02,000 --> 00:18:05,000
det øjeblik det nedstyrtede på denne måde.

335
00:18:05,000 --> 00:18:11,000
>> Rettelsen her er, at vi ikke bare kan blindt returnere sigma,

336
00:18:11,000 --> 00:18:14,000
antallet + sigma af en lidt mindre problem.

337
00:18:14,000 --> 00:18:16,000
Vi er nødt til at have en form for base case her,

338
00:18:16,000 --> 00:18:19,000
og hvad skal den oprindelige sag sandsynligvis være?

339
00:18:19,000 --> 00:18:22,000
[Uhørlig-studerende]

340
00:18:22,000 --> 00:18:25,000
Okay, så længe antallet er positiv bør vi faktisk returnere dette,

341
00:18:25,000 --> 00:18:29,000
eller sagt på en anden måde, hvis antal er, sige, <= til 0

342
00:18:29,000 --> 00:18:32,000
ved du hvad, jeg vil gå videre og returnere 0,

343
00:18:32,000 --> 00:18:36,000
meget gerne Willy gjorde, og andet, vil jeg gå videre

344
00:18:36,000 --> 00:18:41,000
og returnere dette, så det er ikke så meget kortere

345
00:18:41,000 --> 00:18:44,000
end den iterative version, som vi har pisket op først med en for-løkke,

346
00:18:44,000 --> 00:18:48,000
men bemærker, at der er denne form for elegance til det.

347
00:18:48,000 --> 00:18:51,000
I stedet for at returnere nogle antallet og udføre al den matematiske

348
00:18:51,000 --> 00:18:54,000
og tilføje ting op med lokale variable

349
00:18:54,000 --> 00:18:57,000
du i stedet sige "Okay, hvis det er et super let problem,

350
00:18:57,000 --> 00:19:01,000
ligesom antallet er <0, så lad mig straks returnere 0 ".

351
00:19:01,000 --> 00:19:03,000
>> Vi vil ikke gider støtte negative tal,

352
00:19:03,000 --> 00:19:05,000
så jeg har tænkt mig at hårdt kode værdien 0.

353
00:19:05,000 --> 00:19:08,000
Men ellers, at gennemføre denne idé om at summere

354
00:19:08,000 --> 00:19:11,000
alle disse tal sammen kan du effektivt tage en lille bid

355
00:19:11,000 --> 00:19:14,000
ud af problemet, vi meget gerne gjorde her på scenen,

356
00:19:14,000 --> 00:19:18,000
derefter punt resten af ​​problemet til den næste person,

357
00:19:18,000 --> 00:19:20,000
men i dette tilfælde den næste person selv.

358
00:19:20,000 --> 00:19:22,000
Det er en identisk navngivne funktion.

359
00:19:22,000 --> 00:19:25,000
Bare give det en mindre og mindre og mindre problem hver gang,

360
00:19:25,000 --> 00:19:28,000
og selvom vi ikke helt har formaliserede ting i kode her

361
00:19:28,000 --> 00:19:33,000
Dette er præcis, hvad der foregik i uge 0 med telefonbogen.

362
00:19:33,000 --> 00:19:36,000
Dette er præcis, hvad der foregik i de seneste uger med Sean

363
00:19:36,000 --> 00:19:39,000
og med vores demonstrationer af at søge efter numre.

364
00:19:39,000 --> 00:19:42,000
Det tager et problem og dividere det igen og igen.

365
00:19:42,000 --> 00:19:44,000
>> Med andre ord, er der en måde nu at oversætte

366
00:19:44,000 --> 00:19:47,000
denne virkelige verden konstruktion, dette højere niveau konstruktion

367
00:19:47,000 --> 00:19:51,000
af del og hersk og gør noget igen og igen

368
00:19:51,000 --> 00:19:56,000
i kode, så dette er noget, vi vil se igen over tid.

369
00:19:56,000 --> 00:20:00,000
Nu, som en sidebemærkning, hvis du er ny til rekursion, bør du i det mindste forstå nu

370
00:20:00,000 --> 00:20:02,000
hvorfor det er sjovt.

371
00:20:02,000 --> 00:20:05,000
Jeg har tænkt mig at gå til google.com,

372
00:20:05,000 --> 00:20:17,000
og jeg har tænkt mig at søge efter nogle tips og tricks om rekursion, skal du indtaste.

373
00:20:17,000 --> 00:20:21,000
Fortæl personen ved siden af ​​dig, hvis de ikke grinede lige nu.

374
00:20:21,000 --> 00:20:23,000
Mente du rekursion?

375
00:20:23,000 --> 00:20:25,000
Mente du-ah, der går vi.

376
00:20:25,000 --> 00:20:28,000
Okay, nu er resten af ​​alle.

377
00:20:28,000 --> 00:20:30,000
En lille påske æg indlejret et eller andet sted der i Google.

378
00:20:30,000 --> 00:20:33,000
Som en sidebemærkning, en af ​​de links vi sætter på kursets hjemmeside

379
00:20:33,000 --> 00:20:36,000
for i dag er netop denne gitter af forskellige metoder til sortering algoritmer,

380
00:20:36,000 --> 00:20:39,000
hvoraf nogle vi kiggede på i sidste uge, men hvad er rart om denne visualisering

381
00:20:39,000 --> 00:20:43,000
som du forsøger at pakke dit sind omkring forskellige ting i forbindelse med algoritmer

382
00:20:43,000 --> 00:20:46,000
vide, at du kan meget nemt nu starte med forskellige typer input.

383
00:20:46,000 --> 00:20:50,000
Indgangene alle vendt, inputtene meste sorteres, de input tilfældig og så videre.

384
00:20:50,000 --> 00:20:53,000
Som du forsøger at, igen, skelne disse ting i dit sind

385
00:20:53,000 --> 00:20:57,000
indse, at denne webadresse på kursets hjemmeside på Foredrag siden

386
00:20:57,000 --> 00:21:00,000
kan hjælpe dig årsag gennem nogle af dem.

387
00:21:00,000 --> 00:21:05,000
>> I dag får vi endelig at løse dette problem fra et stykke tid tilbage,

388
00:21:05,000 --> 00:21:08,000
som var, at denne swap-funktion bare ikke virkede,

389
00:21:08,000 --> 00:21:12,000
og hvad var det grundlæggende problem med denne funktion swap,

390
00:21:12,000 --> 00:21:15,000
hvis formål var igen at udveksle en værdi her og her

391
00:21:15,000 --> 00:21:17,000
således at dette sker?

392
00:21:17,000 --> 00:21:20,000
Dette har ikke rent faktisk arbejder. Hvorfor?

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

394
00:21:22,000 --> 00:21:28,000
[Uhørlig-studerende]

395
00:21:28,000 --> 00:21:31,000
Præcis, forklaringen på denne bugginess

396
00:21:31,000 --> 00:21:34,000
simpelthen var fordi når du kalder funktioner i C

397
00:21:34,000 --> 00:21:38,000
og disse funktioner tager argumenter, som a og b her,

398
00:21:38,000 --> 00:21:42,000
du passerer i kopier, uanset deres værdi, du leverer til den pågældende funktion.

399
00:21:42,000 --> 00:21:46,000
Du er ikke at give de oprindelige værdier selv,

400
00:21:46,000 --> 00:21:49,000
så vi så det i forbindelse med buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, som kiggede lidt noget som dette.

402
00:21:52,000 --> 00:21:57,000
>> Minde om, at vi havde x og y initialiseres til 1 og 2, henholdsvis.

403
00:21:57,000 --> 00:21:59,000
Vi derefter trykt ud af, hvad de var.

404
00:21:59,000 --> 00:22:03,000
Jeg hævdede derefter, at jeg var bytte dem ved at kalde swap af x, y.

405
00:22:03,000 --> 00:22:06,000
Men problemet var, at bytte bearbejdet,

406
00:22:06,000 --> 00:22:10,000
men kun i omfanget af swap fungere selv.

407
00:22:10,000 --> 00:22:13,000
Så snart vi ramte linie 40 dem byttet værdier

408
00:22:13,000 --> 00:22:16,000
blev smidt væk, og så intet

409
00:22:16,000 --> 00:22:21,000
i den oprindelige funktion main blev faktisk ændret på alle,

410
00:22:21,000 --> 00:22:26,000
så hvis du tror dengang, hvad det ligner i forhold til vores hukommelse

411
00:22:26,000 --> 00:22:29,000
hvis denne venstre side af brættet repræsenterer-

412
00:22:29,000 --> 00:22:33,000
og jeg vil gøre mit bedste for alle at se denne-hvis denne venstre side af brættet

413
00:22:33,000 --> 00:22:37,000
betegner fx din RAM, og stablen vil vokse på op på denne måde,

414
00:22:37,000 --> 00:22:43,000
og vi kalder en funktion som main, og vigtigste har 2 lokale variabler, x og y,

415
00:22:43,000 --> 00:22:48,000
lad os beskrive dem som x her, og lad os beskrive disse som y her,

416
00:22:48,000 --> 00:22:55,000
og lad os sætte i værdierne 1 og 2, så dette her er main,

417
00:22:55,000 --> 00:22:58,000
og når main kalder swap-funktion operativsystemet

418
00:22:58,000 --> 00:23:02,000
giver swap-funktionen sin egen skår af hukommelse på stakken,

419
00:23:02,000 --> 00:23:04,000
sin egen ramme på stakken, så at sige.

420
00:23:04,000 --> 00:23:08,000
Endvidere fordeler 32 bit for disse int'er.

421
00:23:08,000 --> 00:23:11,000
Det sker for at kalde dem A og B, men det er helt vilkårlig.

422
00:23:11,000 --> 00:23:13,000
Det kunne have kaldt dem, hvad det vil, men hvad sker der, når main

423
00:23:13,000 --> 00:23:19,000
opkald swap er det tager denne 1, sætter en kopi der sætter en kopi der.

424
00:23:19,000 --> 00:23:23,000
>> Der er 1 anden lokal variabel i swap, dog kaldes hvad? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, så lad mig give mig en anden 32 bits her,

426
00:23:27,000 --> 00:23:29,000
og hvad gjorde jeg gøre i denne funktion?

427
00:23:29,000 --> 00:23:34,000
Jeg sagde int tmp får en, så en har 1, så jeg gjorde det, da vi sidst spillede med dette eksempel.

428
00:23:34,000 --> 00:23:39,000
Så en bliver b, så b er 2, så nu det bliver 2,

429
00:23:39,000 --> 00:23:42,000
og nu B får temp, så temp er 1,

430
00:23:42,000 --> 00:23:44,000
så nu B bliver dette.

431
00:23:44,000 --> 00:23:46,000
Det er godt. Det virkede.

432
00:23:46,000 --> 00:23:49,000
Men så så snart funktionen returnerer

433
00:23:49,000 --> 00:23:52,000
swap hukommelse effektivt forsvinder, således at det kan genbruges

434
00:23:52,000 --> 00:23:58,000
som en anden funktion i fremtiden, hoved og er naturligvis fuldstændig uændrede.

435
00:23:58,000 --> 00:24:00,000
Vi har brug for en måde fundamentalt at løse dette problem,

436
00:24:00,000 --> 00:24:03,000
og i dag får vi endelig en måde at gøre dette, hvorved

437
00:24:03,000 --> 00:24:06,000
vi kan indføre noget, der hedder en pegepind.

438
00:24:06,000 --> 00:24:09,000
Det viser sig, at vi kan løse dette problem

439
00:24:09,000 --> 00:24:12,000
ikke ved at passere i kopier af x og y

440
00:24:12,000 --> 00:24:18,000
men i stedet ved at passere i hvad, tror du, at swap-funktion?

441
00:24:18,000 --> 00:24:20,000
Ja, hvad med adressen?

442
00:24:20,000 --> 00:24:22,000
Vi har ikke rigtig talt om adresser i mange detaljer,

443
00:24:22,000 --> 00:24:25,000
men hvis denne tavle er min computers hukommelse

444
00:24:25,000 --> 00:24:28,000
Vi kunne godt begynde at nummerere bytes i min RAM

445
00:24:28,000 --> 00:24:31,000
og sige dette er byte # 1, det er byte # 2, byte # 3,

446
00:24:31,000 --> 00:24:35,000
byte # 4, byte # ... 2 milliarder, hvis jeg har 2 GB RAM,

447
00:24:35,000 --> 00:24:38,000
så vi kan helt sikkert komme med nogle vilkårlig nummersystem

448
00:24:38,000 --> 00:24:41,000
for alle de enkelte bytes i min computers hukommelse.

449
00:24:41,000 --> 00:24:43,000
>> Hvad hvis i stedet, når jeg ringer swap

450
00:24:43,000 --> 00:24:47,000
snarere end pass i kopier af x og y

451
00:24:47,000 --> 00:24:51,000
hvorfor ikke jeg i stedet passere adressen på x her,

452
00:24:51,000 --> 00:24:55,000
adressen på y her det væsentlige postadresse

453
00:24:55,000 --> 00:24:59,000
af x og y fordi så bytte, hvis han underrettet

454
00:24:59,000 --> 00:25:01,000
Den adresse i hukommelsen af ​​x og y,

455
00:25:01,000 --> 00:25:04,000
så bytte, hvis vi trænet ham en lille smule,

456
00:25:04,000 --> 00:25:07,000
han potentielt kunne køre til denne adresse, så at sige,

457
00:25:07,000 --> 00:25:11,000
x, og ændre antallet der, så køre til adressen y,

458
00:25:11,000 --> 00:25:16,000
ændre antallet der, selvom det ikke er faktisk at få kopier af disse værdier selv,

459
00:25:16,000 --> 00:25:19,000
så selvom vi talte om det som værende main hukommelse

460
00:25:19,000 --> 00:25:23,000
og dette som værende swap hukommelse den magtfulde og den farlige del af C

461
00:25:23,000 --> 00:25:28,000
er, at enhver funktion kan røre hukommelse overalt i computeren,

462
00:25:28,000 --> 00:25:32,000
og det er stærk i at du kan gøre meget smarte ting med edb-programmer i C.

463
00:25:32,000 --> 00:25:36,000
Det er farligt, fordi du også kan skrue op meget let.

464
00:25:36,000 --> 00:25:39,000
Faktisk er en af ​​de mest almindelige måder for programmer i disse dage udnyttes

465
00:25:39,000 --> 00:25:42,000
stadig er en programmør ikke at realisere

466
00:25:42,000 --> 00:25:45,000
at han eller hun er at tillade en data

467
00:25:45,000 --> 00:25:49,000
at blive skrevet på et sted i hukommelsen, der ikke var tiltænkt.

468
00:25:49,000 --> 00:25:51,000
>> For eksempel, erklærer han eller hun et array af størrelse 10

469
00:25:51,000 --> 00:25:56,000
men så ved et uheld forsøger at sætte 11 bytes i denne vifte af hukommelse,

470
00:25:56,000 --> 00:25:59,000
og du begynder at røre dele af hukommelsen, der ikke længere er gyldige.

471
00:25:59,000 --> 00:26:02,000
Blot for at kontekstuelle dette, vil nogle af jer ved, at

472
00:26:02,000 --> 00:26:06,000
software ofte beder dig om serienumre eller registreringsnøgler,

473
00:26:06,000 --> 00:26:08,000
Photoshop og Word og programmer som dette.

474
00:26:08,000 --> 00:26:12,000
Der findes revner, som nogle af jer ved, online, hvor du kan køre et lille program,

475
00:26:12,000 --> 00:26:14,000
og voila, ikke mere anmodning om et serienummer.

476
00:26:14,000 --> 00:26:16,000
Hvordan er det i orden?

477
00:26:16,000 --> 00:26:21,000
I mange tilfælde er disse ting er simpelthen at finde i de computere

478
00:26:21,000 --> 00:26:24,000
tekstsegmenter i computerens faktiske nuller og ettaller

479
00:26:24,000 --> 00:26:28,000
hvor er denne funktion, hvor serienummeret er anmodet om,

480
00:26:28,000 --> 00:26:31,000
og du overskriver det rum, eller mens programmet kører

481
00:26:31,000 --> 00:26:33,000
du kan regne ud, hvor nøglen er faktisk gemt

482
00:26:33,000 --> 00:26:37,000
bruger noget, der hedder en debugger, og du kan knække software på den måde.

483
00:26:37,000 --> 00:26:40,000
Dette er ikke til at sige, at dette er vores mål for de næste par dage,

484
00:26:40,000 --> 00:26:42,000
men det har meget virkelige verden forgreninger.

485
00:26:42,000 --> 00:26:45,000
At man tilfældigvis involvere tyveri af software,

486
00:26:45,000 --> 00:26:47,000
men der er også et kompromis af hele maskiner.

487
00:26:47,000 --> 00:26:50,000
>> Faktisk hjemmesider, når disse dage udnyttes

488
00:26:50,000 --> 00:26:53,000
og kompromitteret og data er lækket og passwords bliver stjålet

489
00:26:53,000 --> 00:26:58,000
dette meget ofte vedrører dårlig forvaltning af ens hukommelse,

490
00:26:58,000 --> 00:27:01,000
eller, i tilfælde af databaser, manglende foregribe

491
00:27:01,000 --> 00:27:03,000
kontradiktorisk input, så mere om det i de kommende uger,

492
00:27:03,000 --> 00:27:07,000
men for nu bare en forsmag på den slags skader, som du kan gøre

493
00:27:07,000 --> 00:27:11,000
ved ikke helt forstå, hvordan tingene fungerer under hætten.

494
00:27:11,000 --> 00:27:14,000
Lad os gå om at forstå, hvorfor dette er brudt

495
00:27:14,000 --> 00:27:17,000
med et værktøj, der bliver mere og mere nyttigt

496
00:27:17,000 --> 00:27:19,000
som vores programmer får mere kompleks.

497
00:27:19,000 --> 00:27:21,000
Så langt når du har haft en fejl i dit program

498
00:27:21,000 --> 00:27:23,000
hvordan har du gået om debugging det?

499
00:27:23,000 --> 00:27:25,000
Hvad har dine teknikker været hidtil, uanset om undervist af din TF

500
00:27:25,000 --> 00:27:27,000
eller bare selvlært?

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

502
00:27:29,000 --> 00:27:31,000
Printf, så printf har sandsynligvis været din ven i, at hvis du ønsker at se

503
00:27:31,000 --> 00:27:33,000
hvad der foregår inde i dit program

504
00:27:33,000 --> 00:27:36,000
du bare sætte printf her, printf her, printf her.

505
00:27:36,000 --> 00:27:38,000
Så kan du køre det, og du får en hel masse ting på skærmen

506
00:27:38,000 --> 00:27:43,000
som du kan bruge til så udlede, hvad der faktisk går galt i dit program.

507
00:27:43,000 --> 00:27:45,000
>> Printf tendens til at være en meget kraftfuld ting,

508
00:27:45,000 --> 00:27:47,000
men det er en meget manuel proces.

509
00:27:47,000 --> 00:27:49,000
Du er nødt til at sætte en printf her, en printf her,

510
00:27:49,000 --> 00:27:51,000
og hvis du sætte det ind i en løkke kan du få 100 linjer

511
00:27:51,000 --> 00:27:53,000
af produktionen, som du derefter nødt til at finkæmme igennem.

512
00:27:53,000 --> 00:27:58,000
Det er ikke en meget brugervenlig og interaktiv mekanisme til debugging-programmer,

513
00:27:58,000 --> 00:28:00,000
men heldigvis findes der alternativer.

514
00:28:00,000 --> 00:28:03,000
Der er et program, for eksempel, kaldet GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
der er en lille mystisk i, hvordan du bruger det.

516
00:28:06,000 --> 00:28:08,000
Det er en lidt kompleks, men helt ærligt,

517
00:28:08,000 --> 00:28:11,000
dette er en af ​​de ting, hvor, hvis du lægger i denne og næste uge

518
00:28:11,000 --> 00:28:14,000
den ekstra time til at forstå noget som GDB

519
00:28:14,000 --> 00:28:18,000
det vil spare dig formentlig titusinder af timer i det lange løb,

520
00:28:18,000 --> 00:28:21,000
så med det, lad mig give dig en smagsprøve på, hvordan det virker.

521
00:28:21,000 --> 00:28:23,000
>> Jeg er i min terminal vindue.

522
00:28:23,000 --> 00:28:26,000
Lad mig gå videre og kompilere dette program, buggy3.

523
00:28:26,000 --> 00:28:28,000
Det er allerede ajour.

524
00:28:28,000 --> 00:28:31,000
Lad mig køre det ligesom vi gjorde et stykke tid siden, og ja, er det brudt.

525
00:28:31,000 --> 00:28:34,000
Men hvorfor er dette? Måske jeg skruet op swap-funktionen.

526
00:28:34,000 --> 00:28:37,000
Måske er det a og b. Jeg er ikke helt flytte dem rundt korrekt.

527
00:28:37,000 --> 00:28:39,000
Lad mig gå videre og gøre det.

528
00:28:39,000 --> 00:28:43,000
I stedet for bare at køre buggy3 lad mig i stedet køre dette program GDB,

529
00:28:43,000 --> 00:28:48,000
og jeg har tænkt mig at fortælle det til at køre buggy3,

530
00:28:48,000 --> 00:28:52,000
og jeg har tænkt mig at inkludere en kommandolinje argument,-TUI,

531
00:28:52,000 --> 00:28:55,000
og vi vil sætte dette i fremtidige problemer på spec at minde.

532
00:28:55,000 --> 00:28:57,000
Og nu denne sorte og hvide brugergrænseflade dukkede op, igen,

533
00:28:57,000 --> 00:28:59,000
er lidt overvældende i starten, fordi der er alt dette

534
00:28:59,000 --> 00:29:02,000
garantioplysninger hernede, men i det mindste er der noget velkendt.

535
00:29:02,000 --> 00:29:04,000
I toppen af ​​vinduet er mit konkrete kode

536
00:29:04,000 --> 00:29:08,000
og hvis jeg rulle op her lad mig rulle til selve toppen af ​​min fil,

537
00:29:08,000 --> 00:29:11,000
og ja, der er buggy3.c, og meddelelse nederst i dette vindue

538
00:29:11,000 --> 00:29:13,000
Jeg har denne GDB prompt.

539
00:29:13,000 --> 00:29:16,000
>> Dette er ikke det samme som min normale John Harvard prompt.

540
00:29:16,000 --> 00:29:19,000
Dette er en prompt, der kommer til at tillade mig at styre GDB.

541
00:29:19,000 --> 00:29:21,000
GDB er en debugger.

542
00:29:21,000 --> 00:29:24,000
En debugger er et program som lader dig gå igennem

543
00:29:24,000 --> 00:29:27,000
udførelsen af ​​dit program linje for linje for linje,

544
00:29:27,000 --> 00:29:30,000
undervejs gør noget, du vil til programmet,

545
00:29:30,000 --> 00:29:33,000
selv kalde funktioner, eller ser, endnu vigtigere,

546
00:29:33,000 --> 00:29:35,000
ved forskellige variable værdier.

547
00:29:35,000 --> 00:29:37,000
Lad os gå videre og gøre det.

548
00:29:37,000 --> 00:29:40,000
Jeg har tænkt mig at gå videre og skrive køre på GDB er hurtig,

549
00:29:40,000 --> 00:29:43,000
så mærke nederst til venstre på skærmen, jeg har indtastet løbe,

550
00:29:43,000 --> 00:29:45,000
og jeg har ramt ind, og hvad gjorde det så?

551
00:29:45,000 --> 00:29:50,000
Det bogstaveligt løb mit program, men jeg havde faktisk ikke se meget gå på her

552
00:29:50,000 --> 00:29:55,000
fordi jeg ikke har faktisk fortalt fejlsøgeren

553
00:29:55,000 --> 00:29:57,000
at holde pause på et bestemt tidspunkt.

554
00:29:57,000 --> 00:29:59,000
Bare skrive run kører programmet.

555
00:29:59,000 --> 00:30:01,000
Jeg kan faktisk ikke se noget. Jeg kan ikke manipulere det.

556
00:30:01,000 --> 00:30:03,000
>> I stedet lad mig gøre det her.

557
00:30:03,000 --> 00:30:08,000
På dette GDB prompt lad mig i stedet skrive pause, skal du indtaste.

558
00:30:08,000 --> 00:30:10,000
Det er ikke hvad jeg mente at skrive.

559
00:30:10,000 --> 00:30:13,000
Lad os i stedet skrive break main.

560
00:30:13,000 --> 00:30:15,000
Med andre ord ønsker jeg at sætte noget, der hedder et breakpoint,

561
00:30:15,000 --> 00:30:18,000
som er rammende navn, fordi det vil bryde eller pause

562
00:30:18,000 --> 00:30:21,000
udførelsen af ​​dit program på det pågældende sted.

563
00:30:21,000 --> 00:30:23,000
Main er navnet på min funktion.

564
00:30:23,000 --> 00:30:25,000
Bemærk, at GDB er temmelig smart.

565
00:30:25,000 --> 00:30:28,000
Det regnede ud, at main sker for at starte nogenlunde på linie 18

566
00:30:28,000 --> 00:30:32,000
af buggy3.c, og derefter mærke her øverst til venstre

567
00:30:32,000 --> 00:30:34,000
b + er ret ud til linje 18.

568
00:30:34,000 --> 00:30:38,000
Det er at minde mig om, at jeg har sat et breakpoint på linje 18.

569
00:30:38,000 --> 00:30:42,000
Denne gang når jeg skriver løb, vil jeg køre mit program

570
00:30:42,000 --> 00:30:45,000
indtil den rammer det breakpoint,

571
00:30:45,000 --> 00:30:48,000
så programmet vil pause for mig på linje 18.

572
00:30:48,000 --> 00:30:50,000
Her går vi, kører.

573
00:30:50,000 --> 00:30:53,000
Intet ser ud til at være sket, men varsel nederst til venstre

574
00:30:53,000 --> 00:30:58,000
starter programmet, buggy3, skillepunkt 1 i main på buggy3.c linje 18.

575
00:30:58,000 --> 00:31:00,000
Hvad kan jeg gøre nu?

576
00:31:00,000 --> 00:31:03,000
>> Bemærk, at jeg kan begynde at skrive ting som print,

577
00:31:03,000 --> 00:31:08,000
ikke printf, udskrive x, og nu, er underligt.

578
00:31:08,000 --> 00:31:11,000
De $ 1 er blot en nysgerrighed, som vi vil se

579
00:31:11,000 --> 00:31:14,000
hver gang du udskriver noget, man får en ny $ værdi.

580
00:31:14,000 --> 00:31:18,000
Det er så du kan henvise tilbage til tidligere værdier just in case,

581
00:31:18,000 --> 00:31:21,000
men for nu, hvad print fortæller mig, er, at værdien af ​​x på dette tidspunkt i historien

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

583
00:31:26,000 --> 00:31:29,000
Hvad? Hvor kom det selv kommer fra?

584
00:31:29,000 --> 00:31:31,000
[Uhørlig-studerende]

585
00:31:31,000 --> 00:31:34,000
Faktisk er det, hvad vi vil kalde en skraldespand værdi, og vi har ikke talt om det endnu,

586
00:31:34,000 --> 00:31:37,000
men grunden til, at du initialiserer variabler

587
00:31:37,000 --> 00:31:40,000
er naturligvis så, at de har en vis værdi, som du vil have dem til at have.

588
00:31:40,000 --> 00:31:44,000
Men fangsten huske, at du kan erklære variabler

589
00:31:44,000 --> 00:31:46,000
ligesom jeg gjorde for et øjeblik siden i min sigma eksempel

590
00:31:46,000 --> 00:31:48,000
uden at give dem en værdi.

591
00:31:48,000 --> 00:31:50,000
Recall, hvad jeg gjorde herovre i sigma.

592
00:31:50,000 --> 00:31:52,000
Jeg erklærede n, men hvilken værdi har jeg give det?

593
00:31:52,000 --> 00:31:56,000
Ingen, fordi jeg vidste, at i de næste par linier

594
00:31:56,000 --> 00:31:59,000
GetInt ville tage sig af problemet med at sætte en værdi inde i n.

595
00:31:59,000 --> 00:32:02,000
>> Men på dette tidspunkt i historien af ​​linje 11

596
00:32:02,000 --> 00:32:05,000
og linie 12 og linie 13 og linie 14

597
00:32:05,000 --> 00:32:08,000
i alle de flere linjer, der er værdien af ​​n?

598
00:32:08,000 --> 00:32:10,000
I C du bare ikke kender.

599
00:32:10,000 --> 00:32:14,000
Det er generelt en garbage værdi, mens fuldstændig tilfældigt tal

600
00:32:14,000 --> 00:32:17,000
der er tilovers hovedsagelig fra nogle tidligere funktion

601
00:32:17,000 --> 00:32:21,000
er blevet kørt, så dit program kører

602
00:32:21,000 --> 00:32:24,000
minde om, at funktionen får funktion, funktion, funktion.

603
00:32:24,000 --> 00:32:27,000
Alle disse rammer bliver sat på hukommelsen, og derefter disse funktioner tilbage,

604
00:32:27,000 --> 00:32:31,000
og ligesom jeg foreslog med viskelæderet deres hukommelse er efterhånden genbrugt.

605
00:32:31,000 --> 00:32:37,000
Nå, det bare så sker det, at denne variabel x i dette program

606
00:32:37,000 --> 00:32:41,000
synes at have indeholdt noget skrald værdi ligesom 134514032

607
00:32:41,000 --> 00:32:44,000
fra nogle tidligere funktion. ikke en, som jeg skrev

608
00:32:44,000 --> 00:32:47,000
Det kunne være noget, der kommer effektivt med operativsystemet,

609
00:32:47,000 --> 00:32:49,000
en funktion under hætten.

610
00:32:49,000 --> 00:32:52,000
>> Okay, det er fint, men lad os nu gå videre til den næste linje.

611
00:32:52,000 --> 00:32:55,000
Hvis jeg skriver "næste" på min GDB prompt og jeg ramte ind,

612
00:32:55,000 --> 00:32:58,000
bemærke, at fremhæve bevæger sig ned til linjen 19,

613
00:32:58,000 --> 00:33:01,000
men den logiske konsekvens er, at ledningen 18

614
00:33:01,000 --> 00:33:06,000
har nu afsluttet udføre, så hvis jeg igen skriver "print x"

615
00:33:06,000 --> 00:33:10,000
Jeg vil nu se henholdsvis 1, og ja, jeg gør.

616
00:33:10,000 --> 00:33:14,000
Igen $ stuff er en måde at GDB minde dig

617
00:33:14,000 --> 00:33:17,000
hvad historien om udskrifter er, at du har gjort.

618
00:33:17,000 --> 00:33:21,000
Lad mig nu gå videre og udskrive y, og ja, y er nogle skøre værdi samt,

619
00:33:21,000 --> 00:33:24,000
men nogen big deal, fordi i linie 19 vi er ved at tildele det

620
00:33:24,000 --> 00:33:27,000
værdien 2, så lad mig skrive "næste" igen.

621
00:33:27,000 --> 00:33:29,000
Og nu vi er på printf linje.

622
00:33:29,000 --> 00:33:31,000
Lad mig gøre print x.

623
00:33:31,000 --> 00:33:34,000
Lad mig gøre print y. Helt ærligt, jeg får lidt træt af udskrivning af denne.

624
00:33:34,000 --> 00:33:38,000
Lad mig i stedet skrive "skærm x" og "display y,"

625
00:33:38,000 --> 00:33:41,000
og nu hver gang jeg skriver en kommando i fremtiden

626
00:33:41,000 --> 00:33:45,000
Jeg vil blive mindet om, hvad der er x og y, hvad er x og y, hvad er x og y.

627
00:33:45,000 --> 00:33:48,000
>> Jeg kan også, som en sidebemærkning, skriv "info locals."

628
00:33:48,000 --> 00:33:50,000
Info er en speciel kommando.

629
00:33:50,000 --> 00:33:52,000
Locals betyder, at det viser mig de lokale variabler.

630
00:33:52,000 --> 00:33:55,000
Just in case jeg glemmer eller det er en vanvittig, kompliceret funktion

631
00:33:55,000 --> 00:33:57,000
at jeg eller en anden skrev info locals vil fortælle dig

632
00:33:57,000 --> 00:34:00,000
hvad er alle de lokale variabler i dette lokal funktion

633
00:34:00,000 --> 00:34:03,000
at du måske bekymre sig om, hvis du ønsker at stikke rundt.

634
00:34:03,000 --> 00:34:07,000
Nu printf er ved at udføre, så lad mig gå videre og bare skrive "næste".

635
00:34:07,000 --> 00:34:10,000
Fordi vi er i dette miljø, vi faktisk ikke se det

636
00:34:10,000 --> 00:34:14,000
eksekvere hernede, men bemærker det bliver lidt mishandlede her.

637
00:34:14,000 --> 00:34:17,000
Men bemærk det er tvingende skærmen dér,

638
00:34:17,000 --> 00:34:21,000
så det er ikke et perfekt program her, men det er okay, fordi jeg altid kan stikke omkring

639
00:34:21,000 --> 00:34:23,000
brug af udskriftsmedier, hvis jeg vil.

640
00:34:23,000 --> 00:34:26,000
>> Lad mig skrive næste gang, og nu her er den interessante del.

641
00:34:26,000 --> 00:34:29,000
På dette tidspunkt i historien y er 2, og x er 1,

642
00:34:29,000 --> 00:34:32,000
som foreslået her, og igen,

643
00:34:32,000 --> 00:34:35,000
Grunden til dette er automatisk viser nu, er fordi jeg brugte kommandoen

644
00:34:35,000 --> 00:34:40,000
display x og display y, så det øjeblik, jeg skriver næste

645
00:34:40,000 --> 00:34:43,000
i teorien x og y skal blive byttet.

646
00:34:43,000 --> 00:34:45,000
Nu ved vi allerede, at der ikke vil være tilfældet,

647
00:34:45,000 --> 00:34:49,000
men vi vil se på et øjeblik, hvordan vi kan dykke dybere for at finde ud af hvorfor det er sandt.

648
00:34:49,000 --> 00:34:54,000
Næste, og desværre, y er stadig 2 og x er stadig 1, og jeg kan bekræfte så meget.

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

650
00:34:56,000 --> 00:34:59,000
Faktisk har ingen swapping faktisk er sket, så lad os starte dette over.

651
00:34:59,000 --> 00:35:01,000
Det er klart swap er brudt.

652
00:35:01,000 --> 00:35:04,000
Lad os i stedet skrive "run" igen.

653
00:35:04,000 --> 00:35:07,000
Lad mig sige ja, jeg vil genstarte den fra begyndelsen, skal du indtaste.

654
00:35:07,000 --> 00:35:09,000
>> Nu er jeg tilbage op på linie 18.

655
00:35:09,000 --> 00:35:11,000
Nu opdager x og y er skrald værdier igen.

656
00:35:11,000 --> 00:35:15,000
Next, næste dernæst næste.

657
00:35:15,000 --> 00:35:17,000
Hvis jeg får keder jeg kan også bare skrive n for næste.

658
00:35:17,000 --> 00:35:21,000
Du kan forkorte det til den kortest mulige sekvens af tegn.

659
00:35:21,000 --> 00:35:23,000
Swap er nu brudt.

660
00:35:23,000 --> 00:35:25,000
Lad os dykke i, så i stedet for at skrive næste,

661
00:35:25,000 --> 00:35:30,000
nu jeg har tænkt mig at skrive trin, så at jeg stepping inde i denne funktion

662
00:35:30,000 --> 00:35:33,000
så jeg kan gå igennem det, så jeg ramte trin og derefter indtaste.

663
00:35:33,000 --> 00:35:37,000
Bemærk, at fremhæve hopper ned lavere i mit program til linje 36.

664
00:35:37,000 --> 00:35:39,000
Nu hvad er de lokale variable?

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

666
00:35:41,000 --> 00:35:43,000
Intet bare endnu, fordi vi ikke har fået til den linje,

667
00:35:43,000 --> 00:35:47,000
så lad os gå videre og sige "næste".

668
00:35:47,000 --> 00:35:50,000
Nu synes vi at have tmp, print tmp.

669
00:35:50,000 --> 00:35:52,000
Garbage værdi, right? Det tror jeg.

670
00:35:52,000 --> 00:35:55,000
Hvad udskrive en, print b, 1 og 2?

671
00:35:55,000 --> 00:35:58,000
I et øjeblik, så så snart jeg skriver næste gang

672
00:35:58,000 --> 00:36:02,000
tmp vil tage på en værdi på 1, forhåbentlig,

673
00:36:02,000 --> 00:36:05,000
fordi tmp vil blive tildeles værdien for en.

674
00:36:05,000 --> 00:36:08,000
>> Nu lad os gøre udskrive en, print b,

675
00:36:08,000 --> 00:36:11,000
men nu udskrive tmp, og det er faktisk 1.

676
00:36:11,000 --> 00:36:14,000
Lad mig gøre næste. Lad mig gøre næste.

677
00:36:14,000 --> 00:36:16,000
Jeg er færdig med swap-funktion.

678
00:36:16,000 --> 00:36:19,000
Jeg er stadig inde i den på linje 40, så lad mig udskrive en,

679
00:36:19,000 --> 00:36:22,000
print b, og jeg er ligeglad med, hvad tmp er.

680
00:36:22,000 --> 00:36:27,000
Det ligner swap er korrekt, når det kommer til at bytte a og b..

681
00:36:27,000 --> 00:36:31,000
Men hvis jeg nu skrive næste, jeg hopper tilbage til linje 25,

682
00:36:31,000 --> 00:36:34,000
og selvfølgelig, hvis jeg skriver i x-og print y

683
00:36:34,000 --> 00:36:38,000
de er stadig uændret, så vi har ikke løst problemet.

684
00:36:38,000 --> 00:36:41,000
Men diagnostisk nu måske med denne GDB program

685
00:36:41,000 --> 00:36:44,000
vi har i det mindste fået et skridt tættere på at forstå

686
00:36:44,000 --> 00:36:47,000
hvad der går galt uden at skulle strøelse vores kode ved at sætte en printf her,

687
00:36:47,000 --> 00:36:50,000
printf her, printf her og derefter kører det igen og igen

688
00:36:50,000 --> 00:36:52,000
forsøger at finde ud af, hvad der går galt.

689
00:36:52,000 --> 00:36:55,000
>> Jeg har tænkt mig at gå videre og afslutte ud af dette helt med op.

690
00:36:55,000 --> 00:36:57,000
Det kommer til at så sige, "Quit alligevel?" Ja.

691
00:36:57,000 --> 00:37:00,000
Nu er jeg tilbage på min normale prompt, og jeg er færdig med at bruge GDB.

692
00:37:00,000 --> 00:37:03,000
Som en sidebemærkning, behøver du ikke at bruge denne-TUI flag.

693
00:37:03,000 --> 00:37:07,000
Faktisk hvis du udelade det får væsentlige den nederste halvdel af skærmen.

694
00:37:07,000 --> 00:37:11,000
Hvis jeg skriv derefter pause main og derefter køre

695
00:37:11,000 --> 00:37:15,000
Jeg kan stadig køre mit program, men hvad den vil gøre, er mere tekstuelt

696
00:37:15,000 --> 00:37:18,000
bare vise mig den aktuelle linje én ad gangen.

697
00:37:18,000 --> 00:37:21,000
The-TUI, tekstuelle brugergrænseflade,

698
00:37:21,000 --> 00:37:25,000
bare viser dig mere af programmet på én gang, hvilket er sandsynligvis en smule begrebsmæssigt lettere.

699
00:37:25,000 --> 00:37:27,000
Men ja, jeg kan bare gøre som det næste, næste, næste,

700
00:37:27,000 --> 00:37:30,000
og jeg har tænkt mig at se en linje ad gangen, og hvis jeg virkelig ønsker at se, hvad der foregår

701
00:37:30,000 --> 00:37:35,000
Jeg kan skrive listen og se en hel masse tilstødende linjer.

702
00:37:35,000 --> 00:37:39,000
>> Der er en video, som vi har bedt om, at du ser for problemer sæt 3

703
00:37:39,000 --> 00:37:43,000
hvor Nate dækker nogle af de snørklede af GDB,

704
00:37:43,000 --> 00:37:46,000
og dette er en af ​​de ting, ærligt, hvor nogle ikke-triviel procentdel af dig

705
00:37:46,000 --> 00:37:49,000
vil aldrig røre GDB, og det vil være en dårlig ting

706
00:37:49,000 --> 00:37:53,000
fordi bogstaveligt vil du ende med at bruge mere tid senere dette semester

707
00:37:53,000 --> 00:37:56,000
jagter ned bugs så ville du hvis du lægger i denne halve time / time

708
00:37:56,000 --> 00:38:00,000
denne og næste uge læring for at blive fortrolig med GDB.

709
00:38:00,000 --> 00:38:02,000
Printf var din ven.

710
00:38:02,000 --> 00:38:05,000
GDB skulle nu være din ven.

711
00:38:05,000 --> 00:38:08,000
>> Eventuelle spørgsmål om GDB?

712
00:38:08,000 --> 00:38:12,000
Og her er en hurtig liste over nogle af de mest kraftfulde og nyttige kommandoer.

713
00:38:12,000 --> 00:38:15,000
Ja. >> Kan du udskrive en streng?

714
00:38:15,000 --> 00:38:17,000
Kan du udskrive en streng? Absolut.

715
00:38:17,000 --> 00:38:19,000
Det behøver ikke at bare være heltal.

716
00:38:19,000 --> 00:38:22,000
Hvis en variabel s er en streng bare skrive på tryk s.

717
00:38:22,000 --> 00:38:24,000
Det vil vise dig, hvad denne streng variabel er.

718
00:38:24,000 --> 00:38:26,000
[Uhørlig-studerende]

719
00:38:26,000 --> 00:38:28,000
Det vil give dig adressen og selve strengen.

720
00:38:28,000 --> 00:38:32,000
Det vil vise jer begge.

721
00:38:32,000 --> 00:38:34,000
Og en sidste ting, bare fordi det er godt at vide for.

722
00:38:34,000 --> 00:38:37,000
Backtrace og ramme, så lad mig dykke ned i denne ene sidste gang,

723
00:38:37,000 --> 00:38:39,000
samme nøjagtige program med GDB.

724
00:38:39,000 --> 00:38:44,000
Lad mig gå videre og køre den tekstuelle brugergrænseflade version,

725
00:38:44,000 --> 00:38:46,000
bryde main.

726
00:38:46,000 --> 00:38:49,000
Lad mig gå videre og køre igen. Her er jeg.

727
00:38:49,000 --> 00:38:55,000
Lad mig gå næste, næste, næste, næste, næste, step, indtaste.

728
00:38:55,000 --> 00:39:00,000
>> Og nu vel er jeg nu i swap bevidst, men jeg er ligesom "Damn, hvad var værdien af ​​x?"

729
00:39:00,000 --> 00:39:02,000
Jeg kan ikke gøre x længere.

730
00:39:02,000 --> 00:39:05,000
Jeg kan ikke gøre y fordi de ikke er i omfang.

731
00:39:05,000 --> 00:39:07,000
De er ikke i sammenhæng, men ikke noget problem.

732
00:39:07,000 --> 00:39:09,000
Jeg kan skrive backtrace.

733
00:39:09,000 --> 00:39:13,000
Det viser mig alle de funktioner, der er udført frem til dette tidspunkt.

734
00:39:13,000 --> 00:39:16,000
Bemærk, at en på bunden, main, flugter med main

735
00:39:16,000 --> 00:39:18,000
være på bunden af ​​vores billede her.

736
00:39:18,000 --> 00:39:22,000
Det faktum, at swap er over det linjer op med swap værende over den i hukommelsen her,

737
00:39:22,000 --> 00:39:26,000
og hvis jeg ønsker at komme tilbage til main midlertidigt jeg kan sige "frame".

738
00:39:26,000 --> 00:39:30,000
Hvilket nummer? Main er ramme # 1.

739
00:39:30,000 --> 00:39:32,000
Jeg har tænkt mig at gå videre og sige "frame 1".

740
00:39:32,000 --> 00:39:36,000
>> Nu er jeg tilbage i main, og jeg kan udskrive x, og jeg kan udskrive y,

741
00:39:36,000 --> 00:39:40,000
men jeg kan ikke udskrive en eller b..

742
00:39:40,000 --> 00:39:43,000
Men jeg kan, hvis jeg siger, "Okay, vent lige lidt. Hvor var swap?"

743
00:39:43,000 --> 00:39:46,000
Lad mig gå videre og sige "frame 0".

744
00:39:46,000 --> 00:39:48,000
Nu er jeg tilbage, hvor jeg ønsker at være, og som en sidebemærkning,

745
00:39:48,000 --> 00:39:52,000
der er andre kommandoer også gerne hvis du virkelig at kede skrive næste, næste, næste, næste,

746
00:39:52,000 --> 00:39:56,000
du kan generelt sige ting som "næste 10", og der vil gå gennem de næste 10 linjer.

747
00:39:56,000 --> 00:39:59,000
Du kan også skrive "fortsæt", når du virkelig få dødtrætte af at træde igennem.

748
00:39:59,000 --> 00:40:05,000
Fortsæt vil køre dit program uden afbrydelse, indtil den rammer en anden breakpoint,

749
00:40:05,000 --> 00:40:07,000
enten i en løkke eller sænke ned i dit program.

750
00:40:07,000 --> 00:40:11,000
>> I dette tilfælde har vi fortsatte til slutningen, og programmet forlades normalt.

751
00:40:11,000 --> 00:40:13,000
Dette er en fancy måde, ringere proces.

752
00:40:13,000 --> 00:40:16,000
Bare dit program forlades normalt.

753
00:40:16,000 --> 00:40:24,000
Mere om det i videoen og debugging sessioner til at komme.

754
00:40:24,000 --> 00:40:26,000
Det var en masse.

755
00:40:26,000 --> 00:40:35,000
Lad os tage vores 5-minutters pause her, og vi vil vende tilbage med struct og filer.

756
00:40:35,000 --> 00:40:38,000
>> Hvis du har dykket ned denne uges Pset allerede

757
00:40:38,000 --> 00:40:41,000
vil du vide, at vi bruger i fordelingen koden,

758
00:40:41,000 --> 00:40:45,000
kildekoden, som vi leverer til dig som udgangspunkt, nogle nye teknikker.

759
00:40:45,000 --> 00:40:50,000
Især introducerede vi den nye søgeord kaldet struct, for struktur,

760
00:40:50,000 --> 00:40:53,000
så vi kan oprette tilpassede variabler slags.

761
00:40:53,000 --> 00:40:57,000
Vi har også indført begrebet fil I / O, fil input og output,

762
00:40:57,000 --> 00:41:00,000
og det er, så vi kan spare staten

763
00:41:00,000 --> 00:41:03,000
af din Scramble bord til en fil på disk

764
00:41:03,000 --> 00:41:06,000
således at de pædagogiske stipendiater og jeg kan forstå

765
00:41:06,000 --> 00:41:09,000
hvad der foregår inde i dit program uden at skulle manuelt spille

766
00:41:09,000 --> 00:41:11,000
snesevis af spil Scramble.

767
00:41:11,000 --> 00:41:13,000
Vi kan gøre det mere automatisk at.

768
00:41:13,000 --> 00:41:18,000
>> Denne idé om en struct løser en temmelig overbevisende problem.

769
00:41:18,000 --> 00:41:21,000
Antag, at vi ønsker at gennemføre nogle program

770
00:41:21,000 --> 00:41:25,000
at en eller anden måde holder styr på oplysninger om studerende,

771
00:41:25,000 --> 00:41:28,000
og studerende kan have for eksempel et ID, et navn

772
00:41:28,000 --> 00:41:31,000
og et hus på et sted som Harvard, så disse er 3 stykker af information

773
00:41:31,000 --> 00:41:34,000
vi ønsker at holde rundt, så lad mig gå videre og begynde at skrive et lille program her,

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

775
00:41:38,000 --> 00:41:42,000
Lad mig gøre omfatte cs50.h.

776
00:41:42,000 --> 00:41:44,000
Og derefter starte min vigtigste funktion.

777
00:41:44,000 --> 00:41:46,000
Jeg gider ikke med nogen kommandolinjeargumenter,

778
00:41:46,000 --> 00:41:49,000
og her vil jeg gerne have en elev, så jeg har tænkt mig at sige

779
00:41:49,000 --> 00:41:54,000
en elev har et navn, så jeg har tænkt mig at sige "string navn."

780
00:41:54,000 --> 00:41:59,000
Så jeg har tænkt mig at sige en studerende også har et ID, så int id,

781
00:41:59,000 --> 00:42:03,000
og en elev har et hus, så jeg vil også sige "streng hus."

782
00:42:03,000 --> 00:42:06,000
Så vil jeg bestille disse lidt mere rent som denne.

783
00:42:06,000 --> 00:42:11,000
Okay, nu har jeg 3 variable med til at repræsentere en studerende, så "en studerende".

784
00:42:11,000 --> 00:42:15,000
>> Og nu vil jeg gerne udfylde disse værdier, så lad mig gå videre og sige noget i retning af

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

786
00:42:18,000 --> 00:42:21,000
Navnet kommer til at få David.

787
00:42:21,000 --> 00:42:24,000
Lad os sige hus kommer til at få Mather,

788
00:42:24,000 --> 00:42:31,000
og så jeg har tænkt mig at gøre noget vilkårligt lignende printf ("% s,

789
00:42:31,000 --> 00:42:37,000
hvis ID er% d, bor i% s.

790
00:42:37,000 --> 00:42:41,000
Og nu, hvad jeg ønsker at tilslutte her, den ene efter den anden?

791
00:42:41,000 --> 00:42:47,000
Navn, id, hus, return 0.

792
00:42:47,000 --> 00:42:50,000
Okay, medmindre jeg skruet op et eller andet sted her

793
00:42:50,000 --> 00:42:54,000
Jeg tror, ​​vi har en temmelig god program, der gemmer én studerende.

794
00:42:54,000 --> 00:42:57,000
Selvfølgelig er det ikke så interessant. Hvad hvis jeg ønsker at have 2 studerende?

795
00:42:57,000 --> 00:42:59,000
Det er ikke nogen big deal. Jeg kan støtte 2 personer.

796
00:42:59,000 --> 00:43:03,000
Lad mig gå videre og fremhæve dette og gå ned her,

797
00:43:03,000 --> 00:43:09,000
og jeg kan sige "id = 456" for en som Rob, der bor i Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Okay, vent, men jeg kan ikke kalde disse de samme ting,

799
00:43:12,000 --> 00:43:15,000
og det ser ud som om, jeg bliver nødt til at kopiere dette,

800
00:43:15,000 --> 00:43:19,000
så lad mig sige, at disse vil være Davids variabler,

801
00:43:19,000 --> 00:43:23,000
og lad mig få nogle eksemplarer af disse for Rob.

802
00:43:23,000 --> 00:43:27,000
Vi kalder disse Robs men dette kommer ikke til at virke nu

803
00:43:27,000 --> 00:43:33,000
fordi jeg har-vent, lad os ændre mig til ID1, NAME1 og House1.

804
00:43:33,000 --> 00:43:35,000
Rob vil være 2, 2.

805
00:43:35,000 --> 00:43:42,000
Jeg har fået at ændre dette her, her, her, her, her, her.

806
00:43:42,000 --> 00:43:45,000
Vent, hvad med Tommy? Lad os gøre det igen.

807
00:43:45,000 --> 00:43:49,000
Selvfølgelig, hvis du stadig mener, det er en god måde at gøre dette, det er ikke,

808
00:43:49,000 --> 00:43:52,000
så copy / paste dårligt.

809
00:43:52,000 --> 00:43:55,000
Men vi løst dette for en uge siden.

810
00:43:55,000 --> 00:43:59,000
>> Hvad var vores løsning, når vi ønskede at have flere forekomster af samme datatype?

811
00:43:59,000 --> 00:44:01,000
[Studerende] Et array.

812
00:44:01,000 --> 00:44:03,000
Et array, så lad mig prøve at rydde op.

813
00:44:03,000 --> 00:44:07,000
Lad mig gøre nogle plads til mig på toppen, og lad mig i stedet gøre det her.

814
00:44:07,000 --> 00:44:12,000
Vi kalder disse mennesker, og i stedet vil jeg sige "int ids",

815
00:44:12,000 --> 00:44:14,000
og jeg har tænkt mig at understøtte 3 os for nu.

816
00:44:14,000 --> 00:44:18,000
Jeg har tænkt mig at sige "strengnavne", og jeg vil støtte 3 af os,

817
00:44:18,000 --> 00:44:22,000
og så jeg har tænkt mig at sige "streng huse," og jeg har tænkt mig at understøtte 3 af os.

818
00:44:22,000 --> 00:44:26,000
Nu her i stedet for David at få sine egne lokale variable

819
00:44:26,000 --> 00:44:28,000
vi kan slippe af med dem.

820
00:44:28,000 --> 00:44:30,000
Det føles godt, at vi er rengøring dette op.

821
00:44:30,000 --> 00:44:35,000
Jeg kan så sige David vil være [0] og navne [0]

822
00:44:35,000 --> 00:44:38,000
og huse [0].

823
00:44:38,000 --> 00:44:41,000
Og så Rob vi kan ligeledes spare på dette.

824
00:44:41,000 --> 00:44:46,000
Lad os sætte dette ned her, så han kommer til at vilkårligt være ids [1].

825
00:44:46,000 --> 00:44:50,000
Han kommer til at være navne [1],

826
00:44:50,000 --> 00:44:53,000
og så endelig huse [1].

827
00:44:53,000 --> 00:44:57,000
>> Stadig lidt kedelig, og nu har jeg til at finde ud af dette,

828
00:44:57,000 --> 00:45:03,000
så lad os sige "navne [0], id [0], huse [0],

829
00:45:03,000 --> 00:45:06,000
og lad os pluralize dette.

830
00:45:06,000 --> 00:45:09,000
Ids, ids, ids.

831
00:45:09,000 --> 00:45:12,000
Og igen, jeg gør det, så igen, jeg allerede ty til copy / paste igen,

832
00:45:12,000 --> 00:45:14,000
så odds er der er en anden løsning her.

833
00:45:14,000 --> 00:45:18,000
Jeg kan sikkert rydde op yderligere med en løkke eller sådan noget,

834
00:45:18,000 --> 00:45:21,000
så kort sagt, er det lidt bedre, men stadig føles

835
00:45:21,000 --> 00:45:24,000
Jeg ty til copy / paste, men selv dette, jeg hævder,

836
00:45:24,000 --> 00:45:27,000
er egentlig ikke fundamentalt den rigtige løsning, fordi

837
00:45:27,000 --> 00:45:29,000
hvad nu hvis engang vi beslutter du hvad?

838
00:45:29,000 --> 00:45:32,000
Vi bør virkelig have været lagring e-mail adresser for David og Rob

839
00:45:32,000 --> 00:45:34,000
og alle andre i dette program.

840
00:45:34,000 --> 00:45:36,000
Vi bør også gemme telefonnumre.

841
00:45:36,000 --> 00:45:39,000
Vi bør også gemme akutte kontaktnumre.

842
00:45:39,000 --> 00:45:41,000
Vi har alle disse stykker af data, som vi ønsker at gemme,

843
00:45:41,000 --> 00:45:43,000
så hvordan kan du gå om at gøre det?

844
00:45:43,000 --> 00:45:46,000
>> Du erklærer en anden række i toppen, og så er du manuelt tilføje

845
00:45:46,000 --> 00:45:49,000
en e-mailadresse [0], e-mail-adresse [1]

846
00:45:49,000 --> 00:45:51,000
for David og Rob og så videre.

847
00:45:51,000 --> 00:45:56,000
Men der er egentlig bare en underliggende antagelse dette design

848
00:45:56,000 --> 00:45:59,000
at jeg bruger den ære systemet at vide, at

849
00:45:59,000 --> 00:46:03,000
[I] i hvert af de adskillige arrays

850
00:46:03,000 --> 00:46:06,000
bare så sker at henvise til den samme person,

851
00:46:06,000 --> 00:46:10,000
så [0] i ids er nummer 123,

852
00:46:10,000 --> 00:46:13,000
og jeg har tænkt mig at antage, at navne [0]

853
00:46:13,000 --> 00:46:16,000
er den samme persons navn og huse [0]

854
00:46:16,000 --> 00:46:21,000
er den samme person hus og så fremdeles for alle de forskellige arrays som jeg opretter.

855
00:46:21,000 --> 00:46:24,000
Men bemærk, at der ikke er nogen fundamental kobling

856
00:46:24,000 --> 00:46:27,000
blandt disse 3 stykker information, id, navn og hus,

857
00:46:27,000 --> 00:46:32,000
selvom virksomheden, vi forsøger at model i dette program er ikke arrays.

858
00:46:32,000 --> 00:46:35,000
Arrays er netop denne programmatiske måde at gøre dette.

859
00:46:35,000 --> 00:46:38,000
Hvad vi virkelig ønsker at modellere i vores program er en person

860
00:46:38,000 --> 00:46:41,000
ligesom David, en person som Rob inden i hvilken

861
00:46:41,000 --> 00:46:46,000
eller indkapsling er et navn og id og et hus.

862
00:46:46,000 --> 00:46:49,000
>> Kan vi på en måde udtryk for denne idé om indkapsling

863
00:46:49,000 --> 00:46:52,000
hvorved en person har et ID, et navn og et hus

864
00:46:52,000 --> 00:46:55,000
og ikke ty til virkelig dette hack, hvor vi bare

865
00:46:55,000 --> 00:46:58,000
tillid til, at beslaget noget

866
00:46:58,000 --> 00:47:02,000
henviser til det samme humane enhed i hver af disse forskellige arrays?

867
00:47:02,000 --> 00:47:04,000
Vi kan faktisk gøre dette.

868
00:47:04,000 --> 00:47:08,000
Lad mig gå over main for nu, og lad mig skabe min egen datatype

869
00:47:08,000 --> 00:47:10,000
for virkelig første gang.

870
00:47:10,000 --> 00:47:14,000
Vi brugte denne teknik i Scramble,

871
00:47:14,000 --> 00:47:17,000
men her vil jeg gå videre og oprette en datatype,

872
00:47:17,000 --> 00:47:19,000
og ved du hvad, jeg vil kalde det studerende eller person,

873
00:47:19,000 --> 00:47:23,000
og jeg har tænkt mig at bruge typedef for definere en type.

874
00:47:23,000 --> 00:47:25,000
Jeg har tænkt mig at sige, at dette er en struktur,

875
00:47:25,000 --> 00:47:29,000
og så er denne struktur vil være af typen studerende, vil vi sige,

876
00:47:29,000 --> 00:47:31,000
selvom det er en smule dateret nu for mig.

877
00:47:31,000 --> 00:47:33,000
Vi vil sige "int id."

878
00:47:33,000 --> 00:47:35,000
Vi vil sige "string navn."

879
00:47:35,000 --> 00:47:37,000
Så vil vi sige "string hus,"

880
00:47:37,000 --> 00:47:40,000
så nu ved udgangen af ​​disse få linjer kode

881
00:47:40,000 --> 00:47:45,000
Jeg har netop lært Klang, at der findes

882
00:47:45,000 --> 00:47:49,000
en datatype udover int'er, foruden strygere, foruden fordobler udover flåd.

883
00:47:49,000 --> 00:47:54,000
>> Fra dette tidspunkt linie 11, er der nu en ny datatype kaldet studerende,

884
00:47:54,000 --> 00:47:58,000
og nu kan jeg erklære en elev variabel overalt jeg ønsker,

885
00:47:58,000 --> 00:48:01,000
så lad mig rulle ned her til folk.

886
00:48:01,000 --> 00:48:05,000
Nu kan jeg slippe af med dette, og jeg kan gå tilbage ned til David her,

887
00:48:05,000 --> 00:48:10,000
og for David jeg kan faktisk sige, at David,

888
00:48:10,000 --> 00:48:13,000
Vi kan bogstaveligt talt navngive variablen efter mig selv,

889
00:48:13,000 --> 00:48:16,000
vil være af typen studerende.

890
00:48:16,000 --> 00:48:18,000
Det ser måske lidt underligt, men det er ikke så forskellig

891
00:48:18,000 --> 00:48:22,000
fra at erklære noget som en int eller en streng eller en flyder.

892
00:48:22,000 --> 00:48:24,000
Det bare så sker at blive kaldt studerende nu,

893
00:48:24,000 --> 00:48:28,000
og hvis jeg ønsker at sætte noget inde i denne struktur

894
00:48:28,000 --> 00:48:31,000
Jeg nu nødt til at bruge et nyt stykke syntaks, men det er temmelig ligetil,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "David" i hovedstaden D,

896
00:48:39,000 --> 00:48:42,000
og david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
og nu kan jeg slippe af med denne ting her.

898
00:48:46,000 --> 00:48:51,000
Bemærke, at vi har nu redesignet vores program i virkelig en langt bedre måde

899
00:48:51,000 --> 00:48:54,000
i det nu vores program afspejler den virkelige verden.

900
00:48:54,000 --> 00:48:57,000
>> Der er en real-verden opfattelse af en person eller en studerende.

901
00:48:57,000 --> 00:49:02,000
Her har vi nu en C version af en person eller mere specifikt en elev.

902
00:49:02,000 --> 00:49:05,000
Inde i denne person er disse relevante egenskaber,

903
00:49:05,000 --> 00:49:10,000
ID, navn og hus, så Rob væsentlige bliver det samme hernede,

904
00:49:10,000 --> 00:49:14,000
så studerende røve, og 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
Den omstændighed, at den variable hedder Rob er en slags meningsløs.

907
00:49:20,000 --> 00:49:22,000
Vi kunne have kaldt det x eller y eller z.

908
00:49:22,000 --> 00:49:25,000
Vi har lige kaldte den Rob at være semantisk konsistent,

909
00:49:25,000 --> 00:49:28,000
men virkelig navnet er inde i nævnte felt selv,

910
00:49:28,000 --> 00:49:30,000
så nu har jeg det.

911
00:49:30,000 --> 00:49:33,000
Også dette ikke føler sig som det bedste design i, at jeg har hårdt kodet David.

912
00:49:33,000 --> 00:49:35,000
Jeg har hårdt kodet Rob.

913
00:49:35,000 --> 00:49:39,000
Og jeg stadig nødt til at ty til nogle kopiere og indsætte hver gang jeg vil have nye variabler.

914
00:49:39,000 --> 00:49:43,000
Desuden har jeg til tilsyneladende at give hver af disse variabler et navn,

915
00:49:43,000 --> 00:49:46,000
selvom jeg vil meget hellere beskrive disse variabler

916
00:49:46,000 --> 00:49:48,000
 mere generisk som studerende.

917
00:49:48,000 --> 00:49:52,000
>> Nu kan vi fusionere de idéer, der har arbejdet godt for os

918
00:49:52,000 --> 00:49:56,000
og i stedet sige: "Ved du hvad, giv mig en variabel kaldet studerende,

919
00:49:56,000 --> 00:50:01,000
og lad os har det være af størrelse 3, "så nu kan jeg forfine dette yderligere,

920
00:50:01,000 --> 00:50:04,000
slippe af med den manuelt erklærede David,

921
00:50:04,000 --> 00:50:08,000
og jeg kan i stedet sige noget lignende studerende [0] her.

922
00:50:08,000 --> 00:50:11,000
Jeg kan så sige studerende [0] her,

923
00:50:11,000 --> 00:50:14,000
studerende [0] her, og så videre, og jeg kan gå rundt

924
00:50:14,000 --> 00:50:16,000
og rense det op for Rob.

925
00:50:16,000 --> 00:50:19,000
Jeg kunne også gå om nu måske tilføje en løkke

926
00:50:19,000 --> 00:50:23,000
og ved hjælp GetString og GetInt til rent faktisk at få disse værdier fra brugeren.

927
00:50:23,000 --> 00:50:27,000
Jeg kunne gå om at tilføje en konstant, fordi det er generelt dårlig praksis

928
00:50:27,000 --> 00:50:29,000
til hårdt kode nogle vilkårlige tal som 3 lige her

929
00:50:29,000 --> 00:50:33,000
og så bare huske, at du skal sætte højst 3 studerende i det.

930
00:50:33,000 --> 00:50:36,000
Det ville nok være bedre at bruge # define øverst på min fil

931
00:50:36,000 --> 00:50:40,000
og faktor, der ud, så ja, lad mig gå videre og generalisere dette.

932
00:50:40,000 --> 00:50:43,000
>> Lad mig åbne et eksempel, som er blandt nutidens

933
00:50:43,000 --> 00:50:46,000
eksempler på forhånd, structs1.

934
00:50:46,000 --> 00:50:49,000
Dette er en mere komplet program, der bruger # define op her

935
00:50:49,000 --> 00:50:51,000
og siger, at vi bliver nødt til 3 studerende som standard.

936
00:50:51,000 --> 00:50:54,000
Her er jeg erklære en klasse til en værdi af studerende,

937
00:50:54,000 --> 00:50:57,000
så en klasse med elever, og nu er jeg bruger en løkke

938
00:50:57,000 --> 00:51:00,000
bare for at gøre koden lidt mere elegant, befolker klasse

939
00:51:00,000 --> 00:51:05,000
med brugerens input, gentage så fra i = 0 på op til studerende, hvilket er 3.

940
00:51:05,000 --> 00:51:07,000
Og så vil jeg bede brugeren i denne version

941
00:51:07,000 --> 00:51:10,000
 hvad er den studerendes ID, og ​​jeg får det med GetInt.

942
00:51:10,000 --> 00:51:13,000
Hvad er elevens navn, og så får jeg det med GetString.

943
00:51:13,000 --> 00:51:15,000
Hvad er den studerendes hus? Jeg får det med GetString.

944
00:51:15,000 --> 00:51:19,000
Og så i bunden her jeg netop besluttet at ændre

945
00:51:19,000 --> 00:51:22,000
hvordan jeg udskriver disse ud og til rent faktisk at bruge en løkke,

946
00:51:22,000 --> 00:51:24,000
og som jeg udskriver?

947
00:51:24,000 --> 00:51:27,000
Ifølge kommentaren jeg udskriver nogen i Mather,

948
00:51:27,000 --> 00:51:30,000
og det er det så Rob og Tommy og så videre-faktisk Tommys i Mather.

949
00:51:30,000 --> 00:51:34,000
Tommy og David ville blive trykt i denne sag, men hvordan er denne arbejdsmetode?

950
00:51:34,000 --> 00:51:40,000
Vi har ikke set denne funktion før, men tage et gæt på, hvad dette betyder.

951
00:51:40,000 --> 00:51:42,000
Sammenligner strenge.

952
00:51:42,000 --> 00:51:45,000
>> Det er lidt ikke-indlysende, hvordan den sammenligner strenge, fordi det viser sig

953
00:51:45,000 --> 00:51:49,000
hvis det giver 0, som betyder, at strengene er ens.

954
00:51:49,000 --> 00:51:53,000
Hvis den returnerer en -1, der betyder man kommer alfabetisk før den anden,

955
00:51:53,000 --> 00:51:57,000
og hvis det returnerer en det betyder, at andre ord kommer alfabetisk

956
00:51:57,000 --> 00:52:00,000
før den anden, og du kan se online eller på manden side

957
00:52:00,000 --> 00:52:04,000
at se præcis, hvilken vej er der, men alt dette er nu gør, er det siger

958
00:52:04,000 --> 00:52:09,000
hvis [i]. hus er lig med "Mather"

959
00:52:09,000 --> 00:52:13,000
derefter gå videre og printe ud så og så er i Mather.

960
00:52:13,000 --> 00:52:16,000
Men her er noget, vi ikke har set før, og vi vil komme tilbage til dette.

961
00:52:16,000 --> 00:52:21,000
Jeg mindes ikke nogensinde at skulle gøre dette i nogen af ​​mine programmer.

962
00:52:21,000 --> 00:52:24,000
Free er tilsyneladende under henvisning til hukommelse, hvilket frigør hukommelse,

963
00:52:24,000 --> 00:52:31,000
men hvad hukommelse er jeg åbenbart frigøre i denne løkke i bunden af ​​dette program?

964
00:52:31,000 --> 00:52:34,000
Det ser ud som jeg befri en persons navn

965
00:52:34,000 --> 00:52:37,000
og en persons hus, men hvorfor er det?

966
00:52:37,000 --> 00:52:41,000
>> Det viser sig, alle disse uger, at du har brugt GetString

967
00:52:41,000 --> 00:52:45,000
vi har sådan været at indføre en fejl ind i hver eneste af dine programmer.

968
00:52:45,000 --> 00:52:51,000
GetString ved design tildeler hukommelse, så det kan vende tilbage til dig en streng,

969
00:52:51,000 --> 00:52:55,000
ligesom David, eller Rob, og du kan derefter gøre hvad du vil

970
00:52:55,000 --> 00:52:59,000
med denne streng i dit program, fordi vi har reserveret hukommelsen for dig.

971
00:52:59,000 --> 00:53:02,000
Problemet er al den tid, hver gang du ringer GetString

972
00:53:02,000 --> 00:53:05,000
Vi har forfatterne GetString, er blevet anmodet operativsystemet

973
00:53:05,000 --> 00:53:07,000
at give os en smule af RAM til denne streng.

974
00:53:07,000 --> 00:53:09,000
Giv os en smule af RAM for denne næste streng.

975
00:53:09,000 --> 00:53:11,000
Giv os nogle flere RAM til dette næste streng.

976
00:53:11,000 --> 00:53:13,000
Hvad du, programmøren, har aldrig gjort

977
00:53:13,000 --> 00:53:15,000
giver os, at hukommelsen tilbage,

978
00:53:15,000 --> 00:53:17,000
så for disse flere uger alle de programmer, du har skrevet

979
00:53:17,000 --> 00:53:20,000
have haft, hvad der kaldes en hukommelse spring, hvorved de fortsætte med at bruge

980
00:53:20,000 --> 00:53:24,000
mere og mere hukommelse, hver gang du ringer GetString, og det er fint.

981
00:53:24,000 --> 00:53:27,000
Vi bevidst gøre det i de første uger, fordi det ikke er så interessant

982
00:53:27,000 --> 00:53:29,000
at skulle bekymre sig om, hvor strengen kommer fra.

983
00:53:29,000 --> 00:53:34,000
Alt du ønsker, er det ord Rob at komme tilbage, når brugeren skriver det i.

984
00:53:34,000 --> 00:53:38,000
>> Men bevæger sig fremad vi nu er nødt til at begynde at få mere sofistikerede om dette.

985
00:53:38,000 --> 00:53:42,000
Hver gang vi tildeler hukommelse vi bedre til sidst aflevere den tilbage.

986
00:53:42,000 --> 00:53:45,000
Ellers i den virkelige verden på din Mac eller pc, du måtte have lejlighedsvis oplevet

987
00:53:45,000 --> 00:53:50,000
symptomer, hvor din computer er ved at gå i stå til sidst

988
00:53:50,000 --> 00:53:54,000
eller den dumme spindende badebold er bare besat computerens

989
00:53:54,000 --> 00:53:56,000
Hele opmærksomhed, og du kan ikke gøre noget.

990
00:53:56,000 --> 00:54:00,000
Det kan forklares med et vilkårligt antal bugs, men blandt de mulige fejl

991
00:54:00,000 --> 00:54:03,000
er ting kaldes memory leaks, hvorved en person, der skrev, at stykke software

992
00:54:03,000 --> 00:54:07,000
du bruger ikke huske at frigøre hukommelse

993
00:54:07,000 --> 00:54:10,000
at han eller hun spurgte operativsystemet for,

994
00:54:10,000 --> 00:54:14,000
ikke bruger GetString, fordi det er en CS50 ting, men ved hjælp af lignende funktioner

995
00:54:14,000 --> 00:54:16,000
der spørger operativsystemet for hukommelse.

996
00:54:16,000 --> 00:54:19,000
Hvis du eller de skrue op og faktisk aldrig returnere at hukommelsen

997
00:54:19,000 --> 00:54:24,000
et symptom på det kan være, at et program bremser og bremser og sinker

998
00:54:24,000 --> 00:54:26,000
medmindre du huske at ringe gratis.

999
00:54:26,000 --> 00:54:28,000
>> Vi vil komme tilbage til, hvornår og hvorfor du ville ringe gratis,

1000
00:54:28,000 --> 00:54:32,000
men lad os gå videre bare for god foranstaltning, og prøve at køre dette program.

1001
00:54:32,000 --> 00:54:35,000
Dette blev kaldt structs1, skal du indtaste.

1002
00:54:35,000 --> 00:54:40,000
Lad mig gå videre og køre 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, og vi ser David i Mather, Tommys i Mather.

1005
00:54:50,000 --> 00:54:53,000
Dette er blot en lille tilregnelighed kontrollere, at programmet virker.

1006
00:54:53,000 --> 00:54:56,000
Nu desværre dette program er lidt frustrerende i det

1007
00:54:56,000 --> 00:55:00,000
Jeg gjorde alt det arbejde, jeg har skrevet i 9 forskellige strenge, tryk Enter,

1008
00:55:00,000 --> 00:55:04,000
fik at vide, der var i Mather, men naturligvis jeg vidste hvem der var i Mather allerede fordi jeg har skrevet det.

1009
00:55:04,000 --> 00:55:07,000
Det ville være mindst rart, hvis dette program er mere som en database

1010
00:55:07,000 --> 00:55:10,000
og det faktisk husker, hvad jeg har skrevet i

1011
00:55:10,000 --> 00:55:12,000
så jeg aldrig igen nødt til at indtaste disse studerende registreringer.

1012
00:55:12,000 --> 00:55:15,000
Måske er det ligesom en registrarial system.

1013
00:55:15,000 --> 00:55:21,000
>> Vi kan gøre dette ved at bruge denne teknik, der kendes som en fil I / O, fil input og output,

1014
00:55:21,000 --> 00:55:24,000
en meget generisk måde at sige enhver tid, du ønsker at læse filer eller skrive filer

1015
00:55:24,000 --> 00:55:26,000
du kan gøre dette med et bestemt sæt af funktioner.

1016
00:55:26,000 --> 00:55:29,000
Lad mig gå videre og åbne dette eksempel structs2.c,

1017
00:55:29,000 --> 00:55:33,000
som er næsten identisk, men lad os se hvad det nu gør.

1018
00:55:33,000 --> 00:55:36,000
På toppen af ​​filen I erklærer en klasse.

1019
00:55:36,000 --> 00:55:38,000
Jeg derefter udfylde klassen med brugerens input,

1020
00:55:38,000 --> 00:55:41,000
så disse linjer kode er præcis som før.

1021
00:55:41,000 --> 00:55:45,000
Så hvis jeg rulle ned her jeg udskriver alle, der er i Mather vilkårligt gerne før,

1022
00:55:45,000 --> 00:55:47,000
men dette er en interessant ny funktion.

1023
00:55:47,000 --> 00:55:51,000
Disse linjer kode er nye, og de indfører noget her,

1024
00:55:51,000 --> 00:55:55,000
Fil, alle hætter, og det har * i her.

1025
00:55:55,000 --> 00:55:58,000
Lad mig flytte dette herovre, a * herovre så godt.

1026
00:55:58,000 --> 00:56:00,000
>> Denne funktion vi ikke har set før, fopen,

1027
00:56:00,000 --> 00:56:03,000
men det betyder fil åben, så lad os skimme gennem disse,

1028
00:56:03,000 --> 00:56:05,000
og det er noget, vi vil komme tilbage til i fremtidige psets,

1029
00:56:05,000 --> 00:56:10,000
men denne linje her hovedsagelig åbner en fil kaldet database,

1030
00:56:10,000 --> 00:56:13,000
og det specifikt åbner det på en sådan måde, at det kan gøre, hvad med det?

1031
00:56:13,000 --> 00:56:15,000
[Uhørlig-studerende]

1032
00:56:15,000 --> 00:56:19,000
Højre, så "w" betyder bare den fortæller operativsystemet

1033
00:56:19,000 --> 00:56:21,000
åbne denne fil på en sådan måde, at jeg kan skrive til den.

1034
00:56:21,000 --> 00:56:23,000
Jeg ønsker ikke at læse det. Jeg ønsker ikke at bare se på det.

1035
00:56:23,000 --> 00:56:26,000
Jeg ønsker at ændre det og tilføje ting potentielt til det,

1036
00:56:26,000 --> 00:56:28,000
og filen vil blive kaldt database.

1037
00:56:28,000 --> 00:56:30,000
Dette kunne kaldes noget.

1038
00:56:30,000 --> 00:56:32,000
Dette kunne være database.txt. Dette kunne være. Db.

1039
00:56:32,000 --> 00:56:37,000
Dette kunne være et ord som foo, men jeg vilkårligt valgte at navngive filen databasen.

1040
00:56:37,000 --> 00:56:42,000
Dette er en lille tilregnelighed kontrollere, at vi vil komme tilbage til i stor detalje over tid,

1041
00:56:42,000 --> 00:56:47,000
hvis fp, for fil pointer, ikke er lig med NULL betyder alt er godt.

1042
00:56:47,000 --> 00:56:51,000
>> Lang historie kort, funktioner som fopen nogle gange mislykkes.

1043
00:56:51,000 --> 00:56:53,000
Måske filen findes ikke. Måske er du ud af diskplads.

1044
00:56:53,000 --> 00:56:55,000
Måske har du ikke har tilladelse til mappen,

1045
00:56:55,000 --> 00:56:58,000
så hvis fopen returnerer null noget slemt er sket.

1046
00:56:58,000 --> 00:57:02,000
Omvendt, hvis fopen ikke returnerer null alle er godt

1047
00:57:02,000 --> 00:57:04,000
og jeg kan begynde at skrive til denne fil.

1048
00:57:04,000 --> 00:57:06,000
Her er et nyt trick.

1049
00:57:06,000 --> 00:57:08,000
Dette er en for-løkke, der er iteration over hver af mine studerende,

1050
00:57:08,000 --> 00:57:10,000
og det ser så ligner det, vi har gjort før,

1051
00:57:10,000 --> 00:57:15,000
men denne funktion er en fætter af printf kaldet fprintf for filen printf,

1052
00:57:15,000 --> 00:57:18,000
og bemærk det er anderledes på kun 2 måder.

1053
00:57:18,000 --> 00:57:20,000
Én, den starter med f stedet for p,

1054
00:57:20,000 --> 00:57:23,000
men derefter sin første argument er tilsyneladende hvad?

1055
00:57:23,000 --> 00:57:25,000
[Studerende] File. >> Det er en fil.

1056
00:57:25,000 --> 00:57:30,000
Denne ting kaldet fp, som vi vil i sidste ende drille hinanden, hvad en fil pointer er,

1057
00:57:30,000 --> 00:57:35,000
men for nu fp simpelthen er den fil, som jeg har åbnet,

1058
00:57:35,000 --> 00:57:41,000
så fprintf her siger udskrive denne brugers ID til filen, ikke til skærmen.

1059
00:57:41,000 --> 00:57:44,000
Udskriv brugerens navn til filen, ikke til skærmen,

1060
00:57:44,000 --> 00:57:47,000
huset til filen, ikke til skærmen, og derefter ned her, naturligvis,

1061
00:57:47,000 --> 00:57:50,000
lukker filen, og derefter ned her gratis hukommelsen.

1062
00:57:50,000 --> 00:57:53,000
>> Den eneste forskel mellem denne version 2 og version 1

1063
00:57:53,000 --> 00:57:58,000
er indførelsen af ​​fopen og denne fil med *

1064
00:57:58,000 --> 00:58:01,000
og denne opfattelse af fprintf, så lad os se hvad slutresultatet er.

1065
00:58:01,000 --> 00:58:03,000
Lad mig gå ind i min terminal vindue.

1066
00:58:03,000 --> 00:58:06,000
Lad mig løbe structs2, skal du indtaste.

1067
00:58:06,000 --> 00:58:09,000
Ligner alt er godt. Lad os køre 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, enter.

1070
00:58:19,000 --> 00:58:23,000
Ligner det opførte sig det samme, men hvis jeg nu gøre ls

1071
00:58:23,000 --> 00:58:28,000
mærke til, hvad filen er her blandt alle min kode, database,

1072
00:58:28,000 --> 00:58:32,000
så lad os åbne det, gedit af database, og se på det.

1073
00:58:32,000 --> 00:58:34,000
Det er ikke den mest sexede af filformater.

1074
00:58:34,000 --> 00:58:38,000
Det er virkelig et stykke af data linie efter linie per linje,

1075
00:58:38,000 --> 00:58:42,000
men dem af jer, der bruger Excel eller CSV-filer, kommaseparerede værdier,

1076
00:58:42,000 --> 00:58:47,000
Jeg kunne helt sikkert have brugt fprintf til stedet måske gøre noget som dette

1077
00:58:47,000 --> 00:58:50,000
så jeg kunne faktisk skabe hvad der svarer til en Excel-fil

1078
00:58:50,000 --> 00:58:53,000
ved at adskille tingene med kommaer, ikke kun nye linjer.

1079
00:58:53,000 --> 00:58:56,000
>> I dette tilfælde, hvis jeg i stedet havde brugt kommaer i stedet for nye linjer

1080
00:58:56,000 --> 00:59:01,000
Jeg kunne bogstaveligt åbne denne database fil i Excel, hvis jeg i stedet gjort det ser sådan ud.

1081
00:59:01,000 --> 00:59:03,000
Kort sagt, at vi nu har beføjelse til at skrive til filer

1082
00:59:03,000 --> 00:59:07,000
Vi kan nu begynde vedvarende data, holde det rundt på disken

1083
00:59:07,000 --> 00:59:10,000
så vi kan holde oplysninger omkring igen og igen.

1084
00:59:10,000 --> 00:59:14,000
Læg mærke til et par andre ting, der er nu en smule mere velkendt.

1085
00:59:14,000 --> 00:59:16,000
På toppen af ​​denne C-fil vi en typedef

1086
00:59:16,000 --> 00:59:21,000
fordi vi ønskede at skabe en datatype, der repræsenterer et ord,

1087
00:59:21,000 --> 00:59:25,000
så denne type kaldes ord, og inde i denne struktur

1088
00:59:25,000 --> 00:59:27,000
det er lidt amatør nu.

1089
00:59:27,000 --> 00:59:30,000
Hvorfor er et ord, der består af tilsyneladende et array?

1090
00:59:30,000 --> 00:59:33,000
Hvad er et ord bare intuitivt?

1091
00:59:33,000 --> 00:59:35,000
>> Det er et array af tegn.

1092
00:59:35,000 --> 00:59:37,000
Det er en sekvens af tegn tilbage til back to back.

1093
00:59:37,000 --> 00:59:41,000
Bogstaver i alle hætter sker for at være vi vilkårligt sige den maksimale længde

1094
00:59:41,000 --> 00:59:44,000
af et ord i ordbogen, som vi benytter til Scramble.

1095
00:59:44,000 --> 00:59:46,000
Hvorfor har jeg en +1?

1096
00:59:46,000 --> 00:59:48,000
Den null-tegn.

1097
00:59:48,000 --> 00:59:51,000
Recall når vi gjorde Bananagrams eksempel vi har brug for en særlig værdi

1098
00:59:51,000 --> 00:59:55,000
ved slutningen af ​​ordet for at holde styr

1099
00:59:55,000 --> 00:59:59,000
hvor ord faktisk endte, og da problemet indstillede specifikationen siger

1100
00:59:59,000 --> 01:00:03,000
her vi forbinder med et bestemt ord en boolesk værdi,

1101
01:00:03,000 --> 01:00:05,000
et flag, så at sige, sandt eller falsk.

1102
01:00:05,000 --> 01:00:09,000
Har du fundet dette ord allerede, fordi vi indser

1103
01:00:09,000 --> 01:00:13,000
vi virkelig har brug for en måde at huske ikke kun, hvad et ord er i Scramble

1104
01:00:13,000 --> 01:00:15,000
men uanset om du, den menneskelige, har fundet det

1105
01:00:15,000 --> 01:00:20,000
så hvis du finder ordet "det" du kan ikke bare skrive, skal du indtaste den, indtaster, skal du indtaste

1106
01:00:20,000 --> 01:00:23,000
og få 3 point, 3 point, 3 point, 3 point.

1107
01:00:23,000 --> 01:00:26,000
Vi ønsker at være i stand til at sortliste disse ord ved at sætte en bool

1108
01:00:26,000 --> 01:00:29,000
til sand, hvis du allerede har fundet det, og så det er derfor vi

1109
01:00:29,000 --> 01:00:31,000
indkapslet den i denne struktur.

1110
01:00:31,000 --> 01:00:35,000
>> Nu, her nede i Scramble der er denne anden struct kaldet ordbog.

1111
01:00:35,000 --> 01:00:39,000
Fraværende her er ordet typedef for i dette tilfælde

1112
01:00:39,000 --> 01:00:43,000
vi havde brug for at indkapsle ideen om en ordbog,

1113
01:00:43,000 --> 01:00:46,000
og en ordbog indeholder en hel masse ord,

1114
01:00:46,000 --> 01:00:49,000
som det fremgår af dette array, og hvor mange af disse ord er der?

1115
01:00:49,000 --> 01:00:51,000
Nå, uanset denne variabel kaldet størrelse siger.

1116
01:00:51,000 --> 01:00:53,000
Men vi skal bare have en ordbog.

1117
01:00:53,000 --> 01:00:55,000
Vi har ikke brug for en datatype kaldet ordbog.

1118
01:00:55,000 --> 01:00:58,000
Vi skal bare have en af ​​dem, så viser det sig i C

1119
01:00:58,000 --> 01:01:03,000
at hvis du ikke siger typedef, du bare sige struct, så inde i de krøllede parenteser

1120
01:01:03,000 --> 01:01:05,000
du lægger dine variabler, så du sætte navn.

1121
01:01:05,000 --> 01:01:09,000
Dette er at erklære en variabel kaldet ordbog

1122
01:01:09,000 --> 01:01:11,000
der ser sådan ud.

1123
01:01:11,000 --> 01:01:16,000
I modsætning hertil er disse linier skabe en genanvendelig datastruktur kaldet ord

1124
01:01:16,000 --> 01:01:19,000
at du kan oprette flere kopier af, ligesom vi oprettede

1125
01:01:19,000 --> 01:01:22,000
flere kopier af studerende.

1126
01:01:22,000 --> 01:01:24,000
>> Hvad betyder dette i sidste ende tillader os at gøre?

1127
01:01:24,000 --> 01:01:30,000
Lad mig gå tilbage til, lad os sige, en enklere eksempel fra enklere gange,

1128
01:01:30,000 --> 01:01:34,000
og lad mig åbne op, lad os sige, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Problemet her ved hånden er faktisk skrælle

1130
01:01:38,000 --> 01:01:41,000
laget af en streng og begynder at tage off disse støttehjul

1131
01:01:41,000 --> 01:01:44,000
fordi det viser sig, at en streng al denne tid

1132
01:01:44,000 --> 01:01:47,000
er, som vi lovede i uge 1 egentlig bare et kaldenavn,

1133
01:01:47,000 --> 01:01:51,000
et synonym fra CS50 bibliotek til noget, der ser lidt mere kryptisk,

1134
01:01:51,000 --> 01:01:53,000
char *, og vi har set denne stjerne før.

1135
01:01:53,000 --> 01:01:55,000
Vi så det i forbindelse med filerne.

1136
01:01:55,000 --> 01:01:59,000
>> Lad os nu se, hvorfor vi har gemt denne detalje i et stykke tid nu.

1137
01:01:59,000 --> 01:02:02,000
Her er en fil, der hedder compare1.c,

1138
01:02:02,000 --> 01:02:07,000
og den tilsyneladende beder brugeren om 2 strenge, s og t,

1139
01:02:07,000 --> 01:02:11,000
og så det forsøger at sammenligne disse strenge for ligestilling på linje 26,

1140
01:02:11,000 --> 01:02:14,000
og hvis de er lige det siger: "Du har skrevet det samme,"

1141
01:02:14,000 --> 01:02:17,000
og hvis de ikke er lige det siger: "Du har skrevet forskellige ting."

1142
01:02:17,000 --> 01:02:19,000
Lad mig gå videre og køre dette program.

1143
01:02:19,000 --> 01:02:23,000
Lad mig gå ind i min kilde bibliotek, gøre en compare1. Det kompileret okay.

1144
01:02:23,000 --> 01:02:25,000
Lad mig løbe compare1.

1145
01:02:25,000 --> 01:02:27,000
Jeg vil zoome ind, skal du indtaste.

1146
01:02:27,000 --> 01:02:29,000
Sig noget. HEJ.

1147
01:02:29,000 --> 01:02:32,000
Jeg vil sige noget igen. HEJ.

1148
01:02:32,000 --> 01:02:34,000
Jeg absolut ikke skrive forskellige ting.

1149
01:02:34,000 --> 01:02:37,000
>> Lad mig prøve det igen. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Bestemt ikke anderledes, så hvad sker der her?

1151
01:02:40,000 --> 01:02:44,000
Nå, hvad der virkelig bliver sammenlignet i linje 26?

1152
01:02:44,000 --> 01:02:46,000
[Uhørlig-studerende]

1153
01:02:46,000 --> 01:02:49,000
Ja, så viser det sig, at en streng, datatype, er lidt af en hvid løgn.

1154
01:02:49,000 --> 01:02:53,000
En streng er en char *, men hvad er en char *?

1155
01:02:53,000 --> 01:02:56,000
En char *, som de siger, er en pointer,

1156
01:02:56,000 --> 01:03:00,000
og en pointer er faktisk en adresse,

1157
01:03:00,000 --> 01:03:05,000
en sum placering i hukommelsen, og hvis du tilfældigvis har indtastet et ord som HELLO,

1158
01:03:05,000 --> 01:03:08,000
husker fra tidligere diskussioner af strenge

1159
01:03:08,000 --> 01:03:16,000
det er ligesom ordet HELLO.

1160
01:03:16,000 --> 01:03:19,000
Husk, at et ord som HELLO kan repræsenteres

1161
01:03:19,000 --> 01:03:22,000
som en matrix af tegn som denne

1162
01:03:22,000 --> 01:03:25,000
og derpå med et specielt tegn for enden kaldes nul-karakteren,

1163
01:03:25,000 --> 01:03:27,000
som \ betegner.

1164
01:03:27,000 --> 01:03:29,000
Hvad er egentlig en streng?

1165
01:03:29,000 --> 01:03:32,000
Bemærk, at dette er flere bidder af hukommelse,

1166
01:03:32,000 --> 01:03:36,000
og i virkeligheden, er enden af ​​det kun kendt når du kigger gennem hele strengen

1167
01:03:36,000 --> 01:03:38,000
udkig efter den særlige null-tegn.

1168
01:03:38,000 --> 01:03:41,000
Men hvis det er en luns af hukommelsen fra min computers hukommelse,

1169
01:03:41,000 --> 01:03:44,000
lad os vilkårligt sige, at denne streng lige fået heldig,

1170
01:03:44,000 --> 01:03:47,000
og det fik placeret i begyndelsen af ​​min computers RAM.

1171
01:03:47,000 --> 01:03:54,000
Dette er byte 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Når jeg siger noget som GetString og jeg gør string s = GetString

1173
01:04:02,000 --> 01:04:04,000
hvad der virkelig bliver returneret?

1174
01:04:04,000 --> 01:04:08,000
For disse sidste mange uger, er hvad der virkelig bliver gemt i s

1175
01:04:08,000 --> 01:04:13,000
er ikke denne streng i sig selv, men i dette tilfælde, hvad der bliver gemt, er

1176
01:04:13,000 --> 01:04:18,000
tallet 0 fordi hvad GetString faktisk gør

1177
01:04:18,000 --> 01:04:20,000
er det ikke fysisk returnere en streng.

1178
01:04:20,000 --> 01:04:22,000
Det gør ikke engang virkelig gøre konceptuelle mening.

1179
01:04:22,000 --> 01:04:24,000
Hvad det gør tilbagevenden er et tal.

1180
01:04:24,000 --> 01:04:28,000
Dette antal er adressen på HELLO i hukommelsen,

1181
01:04:28,000 --> 01:04:32,000
og snor s derefter, hvis vi skrælle dette lag, er streng ikke eksisterer i virkeligheden.

1182
01:04:32,000 --> 01:04:35,000
Det er kun en forenkling i CS50 biblioteket.

1183
01:04:35,000 --> 01:04:38,000
>> Dette er virkelig er noget, der hedder char *.

1184
01:04:38,000 --> 01:04:41,000
Char giver mening, fordi hvad er et ord, ligesom HELLO?

1185
01:04:41,000 --> 01:04:44,000
Tja, det er en serie af chars, en række tegn.

1186
01:04:44,000 --> 01:04:47,000
Char * betyder adressen på en karakter,

1187
01:04:47,000 --> 01:04:50,000
så hvad betyder det at returnere en streng?

1188
01:04:50,000 --> 01:04:53,000
En dejlig og enkel måde for at returnere en streng

1189
01:04:53,000 --> 01:04:57,000
er snarere end at forsøge at regne ud, hvordan jeg vender tilbage til 5 eller 6 forskellige byte

1190
01:04:57,000 --> 01:05:01,000
Lad mig vende tilbage til den adresse, som byte?

1191
01:05:01,000 --> 01:05:03,000
Den første.

1192
01:05:03,000 --> 01:05:06,000
Med andre ord, lad mig give dig adressen på en karakter i hukommelsen.

1193
01:05:06,000 --> 01:05:10,000
Det er, hvad char * repræsenterer, adressen på en enkelt karakter i hukommelsen.

1194
01:05:10,000 --> 01:05:12,000
Ring denne variabel s.

1195
01:05:12,000 --> 01:05:15,000
Opbevares i s at bestemt adresse, som jeg vilkårligt sagt er 0,

1196
01:05:15,000 --> 01:05:19,000
bare for at holde tingene enkle, men i virkeligheden er det generelt et større antal.

1197
01:05:19,000 --> 01:05:21,000
>> Vent et øjeblik.

1198
01:05:21,000 --> 01:05:23,000
Hvis du kun giver mig adressen på det første tegn, hvordan jeg ved, hvad adressen er

1199
01:05:23,000 --> 01:05:25,000
af det andet tegn, den tredje, den fjerde og den femte?

1200
01:05:25,000 --> 01:05:27,000
[Uhørlig-studerende]

1201
01:05:27,000 --> 01:05:31,000
Du skal kun vide, hvor slutningen af ​​strengen er ved hjælp af denne handy trick,

1202
01:05:31,000 --> 01:05:35,000
så når du bruger noget som printf, hvad printf bogstaveligt tager som sit argument,

1203
01:05:35,000 --> 01:05:39,000
minde om, at vi bruger denne% s pladsholder, og så skal du passere i

1204
01:05:39,000 --> 01:05:41,000
den variabel, der er lagring af en streng.

1205
01:05:41,000 --> 01:05:47,000
Hvad du virkelig passerer er adressen på det første tegn i denne streng.

1206
01:05:47,000 --> 01:05:50,000
Printf bruger derefter en for-løkke eller en while-løkke med modtagelsen af ​​adresse,

1207
01:05:50,000 --> 01:05:53,000
for eksempel, 0 så lad mig gøre det nu,

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n", s);

1209
01:06:02,000 --> 01:06:07,000
Når jeg kalder printf ("% s \ n", s), hvad jeg virkelig give printf med

1210
01:06:07,000 --> 01:06:13,000
er adressen på det første tegn i s, som i dette vilkårlig tilfælde er H.

1211
01:06:13,000 --> 01:06:16,000
>> Hvordan printf vide, hvad der præcist skal vises på skærmen?

1212
01:06:16,000 --> 01:06:19,000
Den person, der gennemføres printf implementeret en while-løkke eller en for-løkke

1213
01:06:19,000 --> 01:06:23,000
der siger ikke denne karakter lig med den særlige null-tegn?

1214
01:06:23,000 --> 01:06:25,000
Hvis ikke, udskrive det. Hvad med denne her?

1215
01:06:25,000 --> 01:06:28,000
Hvis ikke udskrive det, udskrive den, udskrive den, udskrive den.

1216
01:06:28,000 --> 01:06:32,000
Åh, denne ene er speciel. Afbryde udskrivningen og vende tilbage til brugeren.

1217
01:06:32,000 --> 01:06:35,000
Og det er bogstaveligt talt alt, hvad der er sket under hætten,

1218
01:06:35,000 --> 01:06:38,000
og det er en masse at fordøje på den første dag i en klasse,

1219
01:06:38,000 --> 01:06:43,000
men for nu er det virkelig den byggesten i at forstå alt

1220
01:06:43,000 --> 01:06:46,000
der har stået på indersiden af ​​vores computers hukommelse,

1221
01:06:46,000 --> 01:06:49,000
og til sidst vil vi drille dette fra hinanden med lidt hjælp

1222
01:06:49,000 --> 01:06:51,000
fra en af ​​vores venner på Stanford.

1223
01:06:51,000 --> 01:06:56,000
>> Professor Nick Parlante på Stanford har gjort dette vidunderlige video sekvens

1224
01:06:56,000 --> 01:06:58,000
fra alle mulige forskellige sprog, der indførte

1225
01:06:58,000 --> 01:07:00,000
denne lille Claymation karakter Binky.

1226
01:07:00,000 --> 01:07:03,000
Stemmen du er ved at høre på blot et par sekunder smagsprøve

1227
01:07:03,000 --> 01:07:05,000
er, at en Stanford professor, og du får

1228
01:07:05,000 --> 01:07:07,000
kun 5 eller 6 sekunder af dette lige nu,

1229
01:07:07,000 --> 01:07:09,000
men det er den note om, hvor vi vil slutte i dag

1230
01:07:09,000 --> 01:07:11,000
og begynde på onsdag.

1231
01:07:11,000 --> 01:07:15,000
Jeg giver dig Pointer Sjov med Binky, preview.

1232
01:07:15,000 --> 01:07:18,000
[♪ Music ♪] [Professor Parlante] Hey, Binky.

1233
01:07:18,000 --> 01:07:21,000
Vågn op. Det er tid til pointer sjov.

1234
01:07:21,000 --> 01:07:24,000
[Binky] Hvad er det? Lær om pointers?

1235
01:07:24,000 --> 01:07:26,000
Oh, goody!

1236
01:07:26,000 --> 01:07:29,000
>> Vi vil se dig på onsdag.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]