1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Review] [Quiz 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Dette er CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Hej, alle sammen.

5
00:00:10,000 --> 00:00:15,000
Velkommen til revision session for Quiz 0, som finder sted denne onsdag.

6
00:00:15,000 --> 00:00:19,000
Hvad vi vil gøre i aften, jeg er sammen med 3 andre TF'er,

7
00:00:19,000 --> 00:00:24,000
og sammen vil vi gå gennem en gennemgang af, hvad vi har gjort i løbet hidtil.

8
00:00:24,000 --> 00:00:27,000
Det kommer ikke til at være 100% dækkende, men det bør give dig en bedre idé

9
00:00:27,000 --> 00:00:31,000
af, hvad du allerede har ned og hvad du stadig nødt til at studere inden onsdag.

10
00:00:31,000 --> 00:00:34,000
Og velkommen til at hæve din hånd med spørgsmål, som vi skal sammen,

11
00:00:34,000 --> 00:00:38,000
men husk på, at vi også vil have en lille smule tid på end-

12
00:00:38,000 --> 00:00:41,000
hvis vi komme igennem med et par minutter til overs til at gøre generelle spørgsmål,

13
00:00:41,000 --> 00:00:47,000
så holder det i tankerne, og så vil vi starte ved begyndelsen med uge 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 anmeldelse!] [Part 0] [Lexi Ross] Men før vi gør det lad os tale om

15
00:00:50,000 --> 00:00:53,000
logistikken i quizzen.

16
00:00:53,000 --> 00:00:55,000
>> [Logistik] [Quiz finder sted onsdag 10/10 i stedet for foredrag]

17
00:00:55,000 --> 00:00:57,000
>> [(Se http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf for detaljer)] Det er på ONSDAG 10 okt.

18
00:00:57,000 --> 00:01:00,000
>> Det er denne onsdag, og hvis du går til denne webadresse her,

19
00:01:00,000 --> 00:01:03,000
som også er tilgængelig fra CS50.net-der er et link til det,

20
00:01:03,000 --> 00:01:06,000
du kan se oplysninger om, hvor gå ud fra

21
00:01:06,000 --> 00:01:10,000
dit efternavn eller skole tilhørsforhold samt

22
00:01:10,000 --> 00:01:14,000
det fortæller om præcis, hvad quizzen vil dække og de typer af spørgsmål, som du kommer til at få.

23
00:01:14,000 --> 00:01:19,000
Husk, at du også vil have en chance for at gennemgå for quizzen i snit,

24
00:01:19,000 --> 00:01:21,000
så dine TF'er skal gå over nogle praksis problemer,

25
00:01:21,000 --> 00:01:29,000
og det er en anden god chance for at se, hvor du stadig nødt til at studere op til quizzen.

26
00:01:29,000 --> 00:01:32,000
Lad os starte ved begyndelsen med Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Husk lidt er blot et 0 eller et 1,

28
00:01:35,000 --> 00:01:38,000
og en byte er en samling af 8 af disse bit.

29
00:01:38,000 --> 00:01:42,000
Lad os se på denne samling af bits lige her.

30
00:01:42,000 --> 00:01:44,000
Vi bør være i stand til at regne ud hvor mange bit der er.

31
00:01:44,000 --> 00:01:48,000
Hvor vi tælle der er bare 8 af dem, otte 0 eller 1 enheder.

32
00:01:48,000 --> 00:01:51,000
Og da der er 8 bit, det er 1 byte,

33
00:01:51,000 --> 00:01:53,000
og lad os konvertere det til hexadecimal.

34
00:01:53,000 --> 00:01:58,000
Hexadecimal er base 16, og det er ret nemt at konvertere

35
00:01:58,000 --> 00:02:01,000
et tal i binær, hvilket er hvad det er, til et i hexadecimal.

36
00:02:01,000 --> 00:02:04,000
Alt hvad vi gør, er vi ser på grupper af 4,

37
00:02:04,000 --> 00:02:07,000
og vi konvertere dem til den relevante hexadecimale tegn.

38
00:02:07,000 --> 00:02:11,000
Vi starter med det yderste højre gruppe af 4, så 0011.

39
00:02:11,000 --> 00:02:16,000
Det kommer til at være en 1 og en 2, så sammen det gør 3.

40
00:02:16,000 --> 00:02:19,000
Og så lad os se på den anden blok af 4.

41
00:02:19,000 --> 00:02:24,000
1101. Det kommer til at være en 1, en 4, og en 8.

42
00:02:24,000 --> 00:02:28,000
Sammen der kommer til at være 13, hvilket gør D.

43
00:02:28,000 --> 00:02:32,000
Og vi vil huske, at i hexadecimal vi ikke bare gå 0 til 9.

44
00:02:32,000 --> 00:02:36,000
Vi går 0 til F, så efter 9, 10 svarer til A,

45
00:02:36,000 --> 00:02:40,000
11 til B, et cetera hvor F er 15.

46
00:02:40,000 --> 00:02:44,000
Her 13 er en D,

47
00:02:44,000 --> 00:02:49,000
så at konvertere det til decimal alt, hvad vi gør, er vi faktisk

48
00:02:49,000 --> 00:02:52,000
behandler hver position som en potens af 2.

49
00:02:52,000 --> 00:02:58,000
Det er en 1, en 2, nul 4s, nul 8s, en 16, et cetera,

50
00:02:58,000 --> 00:03:03,000
og det er lidt svært at beregne i dit hoved, men hvis vi går til det næste dias

51
00:03:03,000 --> 00:03:05,000
Vi kan se svaret på det.

52
00:03:05,000 --> 00:03:09,000
>> Grundlæggende vil vi på tværs fra højre tilbage til venstre,

53
00:03:09,000 --> 00:03:14,000
og vi multiplicere hvert ciffer ved den tilsvarende potens af 2.

54
00:03:14,000 --> 00:03:19,000
Og husk, for hexadecimal vi betegne disse tal med 0x ved begyndelsen

55
00:03:19,000 --> 00:03:23,000
så vi ikke forveksle det med et decimaltal.

56
00:03:23,000 --> 00:03:29,000
Fortsat på, er dette en ASCII tabel,

57
00:03:29,000 --> 00:03:35,000
og hvad vi bruger ASCII for at kortlægge fra karakterer til numeriske værdier.

58
00:03:35,000 --> 00:03:39,000
Husk i kryptografi Pset vi gjort udstrakt brug af ASCII tabel

59
00:03:39,000 --> 00:03:43,000
for at anvende forskellige metoder til kryptering,

60
00:03:43,000 --> 00:03:47,000
Den Cæsar og Vigenère cifferliste, at konvertere forskellige bogstaver

61
00:03:47,000 --> 00:03:52,000
i en streng ifølge den nøgle, som brugeren.

62
00:03:52,000 --> 00:03:56,000
Lad os se på en lille smule af ASCII matematik.

63
00:03:56,000 --> 00:04:02,000
Se på 'P' + 1, i karakter form, der vil være Q,

64
00:04:02,000 --> 00:04:07,000
og husk, at '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Og præcis hvordan ville vi konvertere mellem disse 2 former?

66
00:04:10,000 --> 00:04:13,000
Det er faktisk ikke alt for hårdt.

67
00:04:13,000 --> 00:04:16,000
For at få 5 vi trækker '0 '

68
00:04:16,000 --> 00:04:20,000
fordi der er 5 pladser mellem '0 'og '5'.

69
00:04:20,000 --> 00:04:23,000
For at gå den anden vej vi blot tilføje 0,

70
00:04:23,000 --> 00:04:25,000
så det er lidt ligesom almindelig aritmetik.

71
00:04:25,000 --> 00:04:29,000
Bare husk, at når noget har anførselstegn omkring det, det er et tegn

72
00:04:29,000 --> 00:04:37,000
og svarer således til en værdi i ASCII tabel.

73
00:04:37,000 --> 00:04:40,000
Flytning ind i mere generelle datalogiske emner.

74
00:04:40,000 --> 00:04:43,000
Vi lærte, hvad en algoritme er, og hvordan vi bruger programmering

75
00:04:43,000 --> 00:04:45,000
at implementere algoritmer.

76
00:04:45,000 --> 00:04:48,000
Nogle eksempler på algoritmer er noget virkelig simpelt lignende

77
00:04:48,000 --> 00:04:51,000
kontrollere, om et tal er lige eller ulige.

78
00:04:51,000 --> 00:04:54,000
Til det husker vi at moder antallet af 2 og kontrollere, om resultatet er 0.

79
00:04:54,000 --> 00:04:57,000
Hvis det er tilfældet, er det endnu. Hvis ikke, det er underligt.

80
00:04:57,000 --> 00:04:59,000
Og det er et eksempel på en virkelig grundlæggende algoritme.

81
00:04:59,000 --> 00:05:02,000
>> Lidt af en mere involveret man er binær søgning,

82
00:05:02,000 --> 00:05:05,000
som vi vil gå over senere i gennemgangen session.

83
00:05:05,000 --> 00:05:09,000
Og programmering er det udtryk, vi bruger til at tage en algoritme

84
00:05:09,000 --> 00:05:15,000
og omdanne den til at kode computeren kan læse.

85
00:05:15,000 --> 00:05:20,000
2 eksempler på programmering er Scratch,

86
00:05:20,000 --> 00:05:22,000
hvilket er, hvad vi gjorde i uge 0.

87
00:05:22,000 --> 00:05:25,000
Selvom vi egentlig ikke skrive koden ud, det er en måde at gennemføre

88
00:05:25,000 --> 00:05:29,000
denne algoritme, som udskriver tallene 1-10,

89
00:05:29,000 --> 00:05:32,000
og her har vi at gøre det samme i C-programmeringssproget.

90
00:05:32,000 --> 00:05:41,000
Det er funktionelt tilsvarende, bare skrevet på forskellige sprog eller syntaks.

91
00:05:41,000 --> 00:05:44,000
Vi derefter lærte om boolean udtryk,

92
00:05:44,000 --> 00:05:48,000
og en boolean er en værdi, der er enten sand eller falsk,

93
00:05:48,000 --> 00:05:51,000
og her oftentimes boolean udtryk

94
00:05:51,000 --> 00:05:55,000
gå indersiden af ​​betingelser, så hvis (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
godt, vi allerede sat x = 5, så denne betingelse vil evaluere til true.

96
00:06:00,000 --> 00:06:03,000
Og hvis det er sandt, hvad koden er under betingelse

97
00:06:03,000 --> 00:06:08,000
vil blive evalueret af computeren, således at strengen skal udskrives

98
00:06:08,000 --> 00:06:12,000
til standard output, og udtrykket tilstand

99
00:06:12,000 --> 00:06:16,000
refererer til, hvad der er i parentes i if-sætningen.

100
00:06:16,000 --> 00:06:20,000
Husk alle operatører.

101
00:06:20,000 --> 00:06:26,000
Husk det er && og | | når vi forsøger at kombinere 2 eller flere betingelser,

102
00:06:26,000 --> 00:06:30,000
== Ikke = at kontrollere, om 2 ting er ens.

103
00:06:30,000 --> 00:06:36,000
Husk, at = er for tildeling hvorimod == er en boolsk operator.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ og derefter De sidste 2 er selvforklarende.

105
00:06:41,000 --> 00:06:45,000
En generel gennemgang af boolesk logik her.

106
00:06:45,000 --> 00:06:48,000
Og boolske udtryk er også vigtige i loops,

107
00:06:48,000 --> 00:06:50,000
som vi vil gå over nu.

108
00:06:50,000 --> 00:06:56,000
Vi lærte omkring 3 typer af løkker hidtil i CS50, for mens, og gøre, mens.

109
00:06:56,000 --> 00:06:59,000
Og det er vigtigt at vide, at mens det for de fleste formål

110
00:06:59,000 --> 00:07:02,000
vi rent faktisk kan bruge enhver form for løkke generelt

111
00:07:02,000 --> 00:07:06,000
der er visse typer af formål eller fælles mønstre

112
00:07:06,000 --> 00:07:09,000
i programmeringen, der specifikt kræver en af ​​disse loops

113
00:07:09,000 --> 00:07:13,000
der gør den til den mest effektive eller elegant at kode det på den måde.

114
00:07:13,000 --> 00:07:18,000
Lad os gå over, hvad hver af disse sløjfer tendens til at blive anvendt til oftest.

115
00:07:18,000 --> 00:07:21,000
>> I en for-løkke vi generelt allerede ved, hvor mange gange vi ønsker at gentage.

116
00:07:21,000 --> 00:07:24,000
Det er, hvad vi lægger i den tilstand.

117
00:07:24,000 --> 00:07:28,000
For, i = 0, i <10, f.eks.

118
00:07:28,000 --> 00:07:31,000
Vi ved allerede, at vi ønsker at gøre noget 10 gange.

119
00:07:31,000 --> 00:07:34,000
Nu, for et stykke tid løkke, vi generelt ikke nødvendigvis

120
00:07:34,000 --> 00:07:36,000
vide, hvor mange gange vi ønsker, løkken skal køre.

121
00:07:36,000 --> 00:07:39,000
Men vi kender en form for betingelse, at vi ønsker det

122
00:07:39,000 --> 00:07:41,000
altid være sandt eller altid være falsk.

123
00:07:41,000 --> 00:07:44,000
For eksempel er under indstilles.

124
00:07:44,000 --> 00:07:46,000
Lad os sige det er en boolesk variabel.

125
00:07:46,000 --> 00:07:48,000
Selvom det er sandt, vi ønsker koden til at vurdere,

126
00:07:48,000 --> 00:07:52,000
så en lille smule mere strækbar, lidt mere generel end en for-løkke,

127
00:07:52,000 --> 00:07:55,000
men nogen for-løkke kan også omdannes til en while-løkke.

128
00:07:55,000 --> 00:08:00,000
Endelig gøre, mens løkker, som kan være den vanskeligste at forstå med det samme,

129
00:08:00,000 --> 00:08:04,000
bruges ofte, når vi ønsker at evaluere kode først

130
00:08:04,000 --> 00:08:06,000
før første gang vi kontrollere tilstanden.

131
00:08:06,000 --> 00:08:09,000
En almindelig anvendelse tilfældet for en do while løkke

132
00:08:09,000 --> 00:08:12,000
er, når du ønsker at få bruger-input, og du ved, at du vil spørge brugeren

133
00:08:12,000 --> 00:08:15,000
for input mindst én gang, men hvis de ikke give dig en god indgang med det samme

134
00:08:15,000 --> 00:08:18,000
du ønsker at holde beder dem indtil de giver dig den gode input.

135
00:08:18,000 --> 00:08:21,000
Det er den mest almindelige brug af en do while løkke,

136
00:08:21,000 --> 00:08:23,000
og lad os se på den faktiske struktur i disse sløjfer.

137
00:08:23,000 --> 00:08:27,000
De har typisk altid en tendens til at følge disse mønstre.

138
00:08:27,000 --> 00:08:30,000
>> På for-løkken inde du har 3 komponenter:

139
00:08:30,000 --> 00:08:35,000
initialisering, typisk noget lignende int i = 0 hvor i er tælleren,

140
00:08:35,000 --> 00:08:40,000
tilstand, hvor vi ønsker at sige køre denne for-løkke, så længe denne betingelse stadig holder,

141
00:08:40,000 --> 00:08:44,000
ligesom jeg <10, og så endelig, opdatering, som er, hvordan vi tilvækst

142
00:08:44,000 --> 00:08:47,000
tællervariablen ved hvert punkt i sløjfen.

143
00:08:47,000 --> 00:08:50,000
En fælles ting at se der er bare i + +,

144
00:08:50,000 --> 00:08:52,000
hvilket betyder tilvækst i med 1 hver gang.

145
00:08:52,000 --> 00:08:55,000
Du kan også gøre noget lignende i + = 2,

146
00:08:55,000 --> 00:08:58,000
hvilket betyder tilsættes 2 til i hver gang du går gennem løkken.

147
00:08:58,000 --> 00:09:03,000
Og så gør det bare henviser til enhver kode, der rent faktisk kører som en del af sløjfen.

148
00:09:03,000 --> 00:09:09,000
Og for en while-løkke, denne gang vi faktisk har initialiseringen uden for løkken,

149
00:09:09,000 --> 00:09:12,000
så for eksempel, lad os sige, vi forsøger at gøre det samme type løkke, som jeg lige har beskrevet.

150
00:09:12,000 --> 00:09:16,000
Vi ville sige int i = 0 før løkken begynder.

151
00:09:16,000 --> 00:09:20,000
Så kunne vi sige, mens jeg <10 gør dette,

152
00:09:20,000 --> 00:09:22,000
så den samme kodeblok som før,

153
00:09:22,000 --> 00:09:26,000
og denne gang opdateringen del af koden, for eksempel i + +,

154
00:09:26,000 --> 00:09:29,000
faktisk går inde i sløjfen.

155
00:09:29,000 --> 00:09:33,000
Og endelig, for en gør stykke tid, det ligner while-løkken,

156
00:09:33,000 --> 00:09:36,000
men vi skal huske, at koden vil evaluere en gang

157
00:09:36,000 --> 00:09:40,000
før tilstanden er valgt, så det gør meget mere mening

158
00:09:40,000 --> 00:09:44,000
hvis man ser på det i rækkefølge fra top til bund.

159
00:09:44,000 --> 00:09:49,000
I en do while løkke koden vurderer, før du selv se på imens tilstand,

160
00:09:49,000 --> 00:09:55,000
hvorimod en while-løkke, tjekker det første.

161
00:09:55,000 --> 00:09:59,000
Erklæringer og variabler.

162
00:09:59,000 --> 00:10:04,000
Når vi ønsker at skabe en ny variabel vi først ønsker at initialisere det.

163
00:10:04,000 --> 00:10:07,000
>> For eksempel initialiserer int bar den variable bar,

164
00:10:07,000 --> 00:10:10,000
men det gør ikke give det en værdi, så hvad er bar værdi nu?

165
00:10:10,000 --> 00:10:12,000
Vi ved det ikke.

166
00:10:12,000 --> 00:10:14,000
Det kunne være en garbage værdi, der tidligere er lagret i hukommelsen der,

167
00:10:14,000 --> 00:10:16,000
og vi ønsker ikke at bruge denne variabel

168
00:10:16,000 --> 00:10:19,000
indtil vi faktisk give det en værdi,

169
00:10:19,000 --> 00:10:21,000
så vi erklære den her.

170
00:10:21,000 --> 00:10:24,000
Så vi initialisere det til at være 42 nedenfor.

171
00:10:24,000 --> 00:10:28,000
Nu, selvfølgelig, ved vi det kan gøres på én linje, bar int = 42.

172
00:10:28,000 --> 00:10:30,000
Men bare for at være klar til flere trin, der foregår,

173
00:10:30,000 --> 00:10:34,000
erklæringen og initialisering sker separat her.

174
00:10:34,000 --> 00:10:38,000
Det sker på et trin, og den næste, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
denne erklæring, at intervaller Baz, så i slutningen af ​​denne kodeblok

176
00:10:44,000 --> 00:10:48,000
hvis vi skulle til at udskrive værdien af ​​baz ville det være 44

177
00:10:48,000 --> 00:10:52,000
fordi vi erklære og initialisere det at være 1> bar,

178
00:10:52,000 --> 00:10:58,000
og så må vi øg det en gang mere med + +.

179
00:10:58,000 --> 00:11:02,000
Vi gik over denne smukke kort, men det er godt at have en generel

180
00:11:02,000 --> 00:11:04,000
forståelse af, hvad tråde og begivenheder er.

181
00:11:04,000 --> 00:11:06,000
Vi hovedsagelig gjorde det i Scratch,

182
00:11:06,000 --> 00:11:09,000
så du kan tænke på tråde som flere sekvenser af kode

183
00:11:09,000 --> 00:11:11,000
kører samtidig.

184
00:11:11,000 --> 00:11:14,000
I virkeligheden er det sandsynligvis ikke kører på samme tid,

185
00:11:14,000 --> 00:11:17,000
men slags abstrakt vi kan tænke på det på den måde.

186
00:11:17,000 --> 00:11:20,000
>> I Scratch, for eksempel havde vi de mange sprites.

187
00:11:20,000 --> 00:11:22,000
Det kunne udføre anden kode på samme tid.

188
00:11:22,000 --> 00:11:26,000
Man kunne til fods, mens den anden siger noget

189
00:11:26,000 --> 00:11:29,000
i en anden del af skærmen.

190
00:11:29,000 --> 00:11:34,000
Events er en anden måde at udskille den logik

191
00:11:34,000 --> 00:11:37,000
mellem de forskellige elementer i din kode,

192
00:11:37,000 --> 00:11:40,000
og i Scratch var vi i stand til at simulere hændelser ved hjælp af Broadcast,

193
00:11:40,000 --> 00:11:43,000
og det er faktisk, når jeg modtager, ikke når jeg hører,

194
00:11:43,000 --> 00:11:47,000
men det væsentlige er det en måde at overføre information

195
00:11:47,000 --> 00:11:49,000
fra en sprite til en anden.

196
00:11:49,000 --> 00:11:52,000
For eksempel kan du ønsker at sende game over,

197
00:11:52,000 --> 00:11:56,000
og når en anden sprite modtager game over,

198
00:11:56,000 --> 00:11:58,000
den reagerer på en bestemt måde.

199
00:11:58,000 --> 00:12:03,000
Det er en vigtig model at forstå for programmering.

200
00:12:03,000 --> 00:12:07,000
Bare for at gå over den grundlæggende uge 0, hvad vi har været igennem indtil nu,

201
00:12:07,000 --> 00:12:10,000
lad os se på dette enkle C-program.

202
00:12:10,000 --> 00:12:14,000
Teksten kan være en smule mindre herfra, men jeg vil gå over det virkelig hurtig.

203
00:12:14,000 --> 00:12:20,000
Vi herunder 2 header-filer i toppen, cs50.h og stdio.h.

204
00:12:20,000 --> 00:12:23,000
Vi derefter definere en konstant kaldet grænse til at være 100.

205
00:12:23,000 --> 00:12:26,000
Vi derefter implementere vores vigtigste funktion.

206
00:12:26,000 --> 00:12:29,000
Da vi ikke bruger kommandolinjeargumenter her vi skal lægge ugyldig

207
00:12:29,000 --> 00:12:32,000
som argumenterne for main.

208
00:12:32,000 --> 00:12:38,000
Vi ser int over main. Det er returtypen, og derfor returnere 0 i bunden.

209
00:12:38,000 --> 00:12:41,000
Og vi bruger CS50 biblioteksfunktion få int

210
00:12:41,000 --> 00:12:45,000
at bede brugeren om input, og vi gemme det i denne variabel x,

211
00:12:45,000 --> 00:12:51,000
så vi erklærer x ovenfor, og vi initialisere den med x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Vi derefter kontrollere, om brugeren har givet os gode input.

213
00:12:53,000 --> 00:12:59,000
Hvis det er ≥ LIMIT vi ønsker at returnere en fejlkode på 1 og udskrive en fejlmeddelelse.

214
00:12:59,000 --> 00:13:02,000
Og endelig, hvis brugeren har givet os gode input

215
00:13:02,000 --> 00:13:08,000
vi kommer til at kvadratur nummer og udskrive dette resultat.

216
00:13:08,000 --> 00:13:11,000
Blot for at sørge for, at de alle hit hjem

217
00:13:11,000 --> 00:13:17,000
du kan se etiketterne på de forskellige dele af koden her.

218
00:13:17,000 --> 00:13:19,000
Jeg nævnte konstante, header filer.

219
00:13:19,000 --> 00:13:21,000
Åh, int x. Sørg for at huske, at er en lokal variabel.

220
00:13:21,000 --> 00:13:24,000
Det står i kontrast det fra en global variabel, som vi taler om

221
00:13:24,000 --> 00:13:27,000
lidt senere i gennemgangen session,

222
00:13:27,000 --> 00:13:30,000
og vi kræver biblioteksfunktionen printf,

223
00:13:30,000 --> 00:13:34,000
så hvis vi ikke havde medtaget den stdio.h header fil

224
00:13:34,000 --> 00:13:37,000
ville vi ikke være i stand til at ringe printf.

225
00:13:37,000 --> 00:13:42,000
Og jeg tror, ​​den pil, der blev afbrudt her peger på% d,

226
00:13:42,000 --> 00:13:45,000
der er en formatering streng i printf.

227
00:13:45,000 --> 00:13:52,000
Det siger udskrive denne variabel som et tal,% d.

228
00:13:52,000 --> 00:13:58,000
Og det er det for uge 0.

229
00:13:58,000 --> 00:14:06,000
Nu Lucas vil fortsætte.

230
00:14:06,000 --> 00:14:08,000
Hej med jer. Mit navn er Lucas.

231
00:14:08,000 --> 00:14:10,000
Jeg er en sophomore i det bedste hus på campus, Mather,

232
00:14:10,000 --> 00:14:14,000
og jeg har tænkt mig at snakke lidt om uge 1 og 2,1.

233
00:14:14,000 --> 00:14:16,000
[Uge 1 og 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Da Lexi sagde, da vi begyndte at oversætte din kode fra Scratch til C

235
00:14:19,000 --> 00:14:23,000
en af ​​de ting, som vi har bemærket er, at du kan ikke bare

236
00:14:23,000 --> 00:14:26,000
skrive din kode og køre det ved hjælp af et grønt flag længere.

237
00:14:26,000 --> 00:14:30,000
Faktisk, er du nødt til at bruge nogle skridt til at gøre din C program

238
00:14:30,000 --> 00:14:33,000
blive en eksekverbar fil.

239
00:14:33,000 --> 00:14:36,000
Dybest set, hvad du gør, når du skriver et program, er, at

240
00:14:36,000 --> 00:14:40,000
du oversætte din idé til et sprog, som en compiler kan forstå,

241
00:14:40,000 --> 00:14:44,000
så når du skriver et program i C

242
00:14:44,000 --> 00:14:47,000
hvad du gør, er rent faktisk at skrive noget, som din compiler vil forstå,

243
00:14:47,000 --> 00:14:50,000
og derefter compiler vil oversætte denne kode

244
00:14:50,000 --> 00:14:53,000
ind i noget, som din computer vil forstå.

245
00:14:53,000 --> 00:14:55,000
>> Og de ting er, din computer er faktisk meget dum.

246
00:14:55,000 --> 00:14:57,000
Computeren kan kun forstå 0'er og 1'ere,

247
00:14:57,000 --> 00:15:01,000
så faktisk i de første computere folk normalt programmeret

248
00:15:01,000 --> 00:15:04,000
hjælp 0'er og 1-taller, men ikke længere, gudskelov.

249
00:15:04,000 --> 00:15:07,000
Vi behøver ikke at huske sekvenserne for 0'er og 1'ere

250
00:15:07,000 --> 00:15:10,000
for en for-løkke eller i et stykke løkke og så videre.

251
00:15:10,000 --> 00:15:13,000
Det er derfor, vi har en compiler.

252
00:15:13,000 --> 00:15:17,000
Hvad en compiler gør, er det dybest set oversætter C-kode,

253
00:15:17,000 --> 00:15:21,000
i vores tilfælde, at et sprog, som computeren vil forstå

254
00:15:21,000 --> 00:15:25,000
som er genstand kode, og den compiler, som vi benytter

255
00:15:25,000 --> 00:15:30,000
kaldes klang, så det er faktisk symbolet for klang.

256
00:15:30,000 --> 00:15:33,000
Når du har dit program, du skal gøre 2 ting.

257
00:15:33,000 --> 00:15:37,000
Først skal du nødt til at kompilere dit program, og så er du kommer til at køre dit program.

258
00:15:37,000 --> 00:15:41,000
For at kompilere dit program du har en masse muligheder for at gøre det.

259
00:15:41,000 --> 00:15:44,000
Den første er at gøre Klang program.c

260
00:15:44,000 --> 00:15:47,000
i hvilket program er navnet på dit program.

261
00:15:47,000 --> 00:15:51,000
I dette tilfælde kan du se de er bare at sige "Hey, kompilere mit program."

262
00:15:51,000 --> 00:15:56,000
Du siger ikke "Jeg ønsker dette navn til mit program" eller noget.

263
00:15:56,000 --> 00:15:58,000
>> Den anden mulighed er at give et navn til dit program.

264
00:15:58,000 --> 00:16:02,000
Du kan sige klang-o, og derefter det navn, du vil have

265
00:16:02,000 --> 00:16:06,000
den eksekverbare fil, der skal navngives som og derefter program.c.

266
00:16:06,000 --> 00:16:11,000
Og du kan også gøre lave program, og se hvordan i de første 2 tilfælde

267
00:16:11,000 --> 00:16:15,000
Jeg sætter. C, og i den tredje jeg har kun programmer?

268
00:16:15,000 --> 00:16:18,000
Ja, du faktisk bør ikke lægge. C. når du bruger lave.

269
00:16:18,000 --> 00:16:22,000
Ellers compileren faktisk kommer til at råbe på dig.

270
00:16:22,000 --> 00:16:24,000
Og også, jeg ved ikke, hvis du fyre huske,

271
00:16:24,000 --> 00:16:29,000
men mange gange har vi også brugt-lcs50 eller-lm.

272
00:16:29,000 --> 00:16:31,000
Det kaldes sammenkædning.

273
00:16:31,000 --> 00:16:35,000
Det bare fortæller compileren, at du vil bruge disse biblioteker lige der,

274
00:16:35,000 --> 00:16:39,000
så hvis du ønsker at bruge cs50.h du faktisk nødt til at skrive

275
00:16:39,000 --> 00:16:43,000
klang program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Hvis du ikke gør det, er det compileren ikke kommer til at kende

277
00:16:45,000 --> 00:16:50,000
at du bruger disse funktioner i cs50.h.

278
00:16:50,000 --> 00:16:52,000
Og når du vil køre dit program har du 2 muligheder.

279
00:16:52,000 --> 00:16:57,000
Hvis du gjorde klang program.c du ikke give et navn til dit program.

280
00:16:57,000 --> 00:17:01,000
Du er nødt til at køre det med. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out er et standard navn, der klang giver dit program, hvis du ikke give den et navn.

282
00:17:06,000 --> 00:17:11,000
Ellers du vil gøre. / Program hvis du gav et navn til dit program,

283
00:17:11,000 --> 00:17:15,000
og også hvis du lavede program det navn, et program kommer til at få

284
00:17:15,000 --> 00:17:23,000
allerede vil være programmeret samme navn som den C-filen.

285
00:17:23,000 --> 00:17:26,000
Så vi talte om datatyper og data.

286
00:17:26,000 --> 00:17:31,000
>> Dybest set datatyper er det samme som små bokse, de bruger

287
00:17:31,000 --> 00:17:35,000
til at gemme værdier, så datatyperne er faktisk ligesom pokemons.

288
00:17:35,000 --> 00:17:39,000
De kommer i alle størrelser og typer.

289
00:17:39,000 --> 00:17:43,000
Jeg ved ikke, om denne analogi giver mening.

290
00:17:43,000 --> 00:17:46,000
Datastørrelsen faktisk afhænger af maskinens arkitektur.

291
00:17:46,000 --> 00:17:49,000
Alle de data størrelser, jeg har tænkt mig at vise her

292
00:17:49,000 --> 00:17:53,000
faktisk til en 32-bit maskine, hvilket er tilfældet i vort apparat,

293
00:17:53,000 --> 00:17:56,000
men hvis du rent faktisk er kodning din Mac eller Windows også

294
00:17:56,000 --> 00:17:59,000
sandsynligvis du vil have en 64-bit maskine,

295
00:17:59,000 --> 00:18:03,000
så husk, at de data, størrelser, jeg har tænkt mig at vise her

296
00:18:03,000 --> 00:18:06,000
er for 32-bit maskine.

297
00:18:06,000 --> 00:18:08,000
Den første, vi så, var en int,

298
00:18:08,000 --> 00:18:10,000
som er temmelig ligetil.

299
00:18:10,000 --> 00:18:13,000
Du bruger int til at gemme et heltal.

300
00:18:13,000 --> 00:18:16,000
Vi så også karakter, char.

301
00:18:16,000 --> 00:18:20,000
Hvis du ønsker at bruge et brev eller en lille symbol du sandsynligvis vil bruge en char.

302
00:18:20,000 --> 00:18:26,000
En char har 1 byte, hvilket betyder, 8 bit, som Lexi sagde.

303
00:18:26,000 --> 00:18:31,000
Dybest set har vi en ASCII tabel, der har 256

304
00:18:31,000 --> 00:18:34,000
mulige kombinationer af 0'er og 1-taller,

305
00:18:34,000 --> 00:18:37,000
og så når du skriver en char det kommer til at oversætte

306
00:18:37,000 --> 00:18:44,000
det tegn, som inputs dig et nummer, som du har i ASCII-tabellen, ligesom Lexi sagde.

307
00:18:44,000 --> 00:18:48,000
Vi har også svømmeren, som vi bruger til at gemme decimaltal.

308
00:18:48,000 --> 00:18:53,000
Hvis du ønsker at vælge 3,14, for eksempel, er du nødt til at bruge en flyder

309
00:18:53,000 --> 00:18:55,000
eller en dobbelt, der har mere præcision.

310
00:18:55,000 --> 00:18:57,000
En flyder har 4 bytes.

311
00:18:57,000 --> 00:19:01,000
En dobbelt har 8 bytes, så den eneste forskel er den præcision.

312
00:19:01,000 --> 00:19:04,000
Vi har også en lang som anvendes til heltal,

313
00:19:04,000 --> 00:19:09,000
og du kan se for en 32-bit maskine en int og en lang har samme størrelse,

314
00:19:09,000 --> 00:19:13,000
så det ikke rigtig mening at bruge en længe i en 32-bit maskine.

315
00:19:13,000 --> 00:19:17,000
>> Men hvis du bruger en Mac og 64-bit maskine, faktisk en lang har str. 8,

316
00:19:17,000 --> 00:19:19,000
så det virkelig afhænger af arkitekturen.

317
00:19:19,000 --> 00:19:22,000
For den 32-bit maskine giver det ikke mening at bruge en lang virkelig.

318
00:19:22,000 --> 00:19:25,000
Og derefter en lang lang, på den anden side har 8 byte,

319
00:19:25,000 --> 00:19:30,000
så det er meget godt, hvis du vil have en længere heltal.

320
00:19:30,000 --> 00:19:34,000
Og endelig har vi streng, som faktisk er en char *,

321
00:19:34,000 --> 00:19:37,000
der er en pointer til en char.

322
00:19:37,000 --> 00:19:40,000
Det er meget nemt at tro, at størrelsen af ​​strengen vil være ligesom

323
00:19:40,000 --> 00:19:42,000
det antal tegn, som du har der,

324
00:19:42,000 --> 00:19:45,000
men faktisk char * selv

325
00:19:45,000 --> 00:19:49,000
har størrelsen på en markør til en char, som er 4 bytes.

326
00:19:49,000 --> 00:19:52,000
Størrelsen af ​​en char * er 4 bytes.

327
00:19:52,000 --> 00:19:56,000
Det betyder ikke noget, hvis du har en lille ord eller et bogstav eller noget.

328
00:19:56,000 --> 00:19:58,000
Det kommer til at være 4 byte.

329
00:19:58,000 --> 00:20:01,000
Vi har også lært lidt om støbning,

330
00:20:01,000 --> 00:20:04,000
så du kan se, hvis du har for eksempel et program, der siger

331
00:20:04,000 --> 00:20:08,000
int x = 3 og derefter printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
tror du fyre ved, hvad det kommer til at udskrive på skærmen?

333
00:20:12,000 --> 00:20:14,000
>> Nogen? >> [Studerende] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, ja.

335
00:20:16,000 --> 00:20:20,000
Når du gør 3/2 det kommer til at få 1,5,

336
00:20:20,000 --> 00:20:24,000
men da vi bruger et heltal det kommer til at ignorere den decimal del,

337
00:20:24,000 --> 00:20:26,000
og du kommer til at have 1.

338
00:20:26,000 --> 00:20:29,000
Hvis du ikke ønsker at det skal ske, hvad du kan gøre, for eksempel,

339
00:20:29,000 --> 00:20:33,000
er erklære en float y = x.

340
00:20:33,000 --> 00:20:40,000
Så x, der plejede at være 3 nu vil være 3,000 i y.

341
00:20:40,000 --> 00:20:44,000
Og så kan du udskrive y / 2.

342
00:20:44,000 --> 00:20:50,000
Faktisk burde jeg have en 2. derovre.

343
00:20:50,000 --> 00:20:55,000
Det kommer til at gøre 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
og du kommer til at få 1,5.

345
00:20:58,000 --> 00:21:06,000
Og vi har denne .2 f blot at bede om 2 decimaler enheder i decimal del.

346
00:21:06,000 --> 00:21:12,000
Hvis du har .3 f det kommer til at have faktisk 1,500.

347
00:21:12,000 --> 00:21:16,000
Hvis det er 2 går det at være 1,50.

348
00:21:16,000 --> 00:21:18,000
Vi har også denne sag her.

349
00:21:18,000 --> 00:21:22,000
Hvis du gør float x = 3,14 og derefter du printf x

350
00:21:22,000 --> 00:21:24,000
du kommer til at få 3,14.

351
00:21:24,000 --> 00:21:29,000
Og hvis du gør x = int af x,

352
00:21:29,000 --> 00:21:34,000
hvilket betyder behandle x som en int, og du udskriver x nu

353
00:21:34,000 --> 00:21:36,000
du bliver nødt til 3,00.

354
00:21:36,000 --> 00:21:38,000
Giver det mening?

355
00:21:38,000 --> 00:21:41,000
Fordi du først er behandling af x som et heltal, så du ignorerer decimalerne,

356
00:21:41,000 --> 00:21:45,000
og derefter du udskriver x.

357
00:21:45,000 --> 00:21:47,000
Og endelig kan du også gøre dette,

358
00:21:47,000 --> 00:21:52,000
int x = 65, og så skal du erklære en char c = x,

359
00:21:52,000 --> 00:21:56,000
og derefter, hvis du udskriver c du faktisk vil få

360
00:21:56,000 --> 00:21:59,000
A, så dybest set, hvad du laver her

361
00:21:59,000 --> 00:22:02,000
er oversætte heltal i karakter,

362
00:22:02,000 --> 00:22:05,000
ligesom ASCII tabel gør.

363
00:22:05,000 --> 00:22:08,000
Vi talte også om matematik operatører.

364
00:22:08,000 --> 00:22:14,000
De fleste af dem er temmelig ligetil, så +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
og også talte vi om mod, som er resten af ​​en division af 2 numre.

366
00:22:20,000 --> 00:22:23,000
Hvis du har 10% 3, for eksempel,

367
00:22:23,000 --> 00:22:27,000
det betyder dividere 10 med 3, og hvad er resten?

368
00:22:27,000 --> 00:22:30,000
Det kommer til at være 1, så det er faktisk meget nyttigt for en masse af programmerne.

369
00:22:30,000 --> 00:22:38,000
For Vigenère og Cæsar Jeg er ret sikker på, at alle jer fyre brugt mod.

370
00:22:38,000 --> 00:22:43,000
Om matematik operatører, være meget forsigtig, når man kombinerer * og /.

371
00:22:43,000 --> 00:22:48,000
>> For eksempel, (3/2), hvis du gør * 2 hvad vil du få?

372
00:22:48,000 --> 00:22:50,000
[Studerende] 2.

373
00:22:50,000 --> 00:22:54,000
Ja, 2, fordi 3/2 vil være 1,5,

374
00:22:54,000 --> 00:22:57,000
men da du laver operationer mellem 2 heltal

375
00:22:57,000 --> 00:22:59,000
du faktisk bare at overveje 1,

376
00:22:59,000 --> 00:23:03,000
og derefter 1 * 2 kommer til at være 2, så vær meget forsigtige

377
00:23:03,000 --> 00:23:07,000
når du laver aritmetik med heltal, fordi

378
00:23:07,000 --> 00:23:12,000
du kan få det 2 = 3, i dette tilfælde.

379
00:23:12,000 --> 00:23:14,000
Og også være meget forsigtige med forrang.

380
00:23:14,000 --> 00:23:21,000
Du skal normalt bruge parenteser for at være sikker på, at du ved, hvad du laver.

381
00:23:21,000 --> 00:23:27,000
Nogle nyttige genveje, selvfølgelig, er en jeg + + eller i + = 1

382
00:23:27,000 --> 00:23:30,000
eller ved hjælp af + =.

383
00:23:30,000 --> 00:23:34,000
Det er det samme som at gøre i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Du kan også gøre i - eller i - = 1,

385
00:23:39,000 --> 00:23:42,000
hvilket er det samme som i = i -1,

386
00:23:42,000 --> 00:23:46,000
Noget du fyre bruger en masse i for-løkker, i det mindste.

387
00:23:46,000 --> 00:23:52,000
Også for *, hvis du bruger * = og hvis du gør, for eksempel,

388
00:23:52,000 --> 00:23:57,000
i * = 2 er det samme som at sige, i = i * 2,

389
00:23:57,000 --> 00:23:59,000
og det samme for division.

390
00:23:59,000 --> 00:24:08,000
Hvis du gør i / = 2 det er det samme som i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Nu om funktioner.

392
00:24:10,000 --> 00:24:13,000
Du fyre lærte, at funktioner er en meget god strategi at spare kode

393
00:24:13,000 --> 00:24:16,000
mens du programmerer, så hvis du ønsker at udføre den samme opgave

394
00:24:16,000 --> 00:24:20,000
i kode igen og igen, sandsynligvis du ønsker at bruge en funktion

395
00:24:20,000 --> 00:24:25,000
bare så du ikke behøver at kopiere og indsætte koden igen og igen.

396
00:24:25,000 --> 00:24:28,000
Faktisk main er en funktion, og når jeg vise dig formatet for en funktion

397
00:24:28,000 --> 00:24:32,000
du vil se, at det er temmelig indlysende.

398
00:24:32,000 --> 00:24:35,000
Vi bruger også funktioner fra nogle biblioteker,

399
00:24:35,000 --> 00:24:39,000
for eksempel printf, GetIn, som er fra CS50 bibliotek,

400
00:24:39,000 --> 00:24:43,000
og andre funktioner som toupper.

401
00:24:43,000 --> 00:24:46,000
Alle disse funktioner er faktisk gennemføres i andre biblioteker,

402
00:24:46,000 --> 00:24:49,000
og når du lægger dem tether filer i starten af ​​dit program

403
00:24:49,000 --> 00:24:53,000
du siger kan du give mig koden til disse funktioner

404
00:24:53,000 --> 00:24:57,000
så jeg ikke behøver at gennemføre dem selv?

405
00:24:57,000 --> 00:25:00,000
Og du kan også skrive dine egne funktioner, så når du starter programmering

406
00:25:00,000 --> 00:25:04,000
du indse, at bibliotekerne ikke har alle de funktioner, du har brug for.

407
00:25:04,000 --> 00:25:10,000
For sidste Pset, for eksempel skrev vi tegne, scramble, og opslag,

408
00:25:10,000 --> 00:25:13,000
og det er meget, meget vigtigt at være i stand til at skrive funktioner

409
00:25:13,000 --> 00:25:17,000
fordi de er nyttige, og vi bruger dem hele tiden i programmeringen,

410
00:25:17,000 --> 00:25:19,000
og det sparer en masse kode.

411
00:25:19,000 --> 00:25:21,000
Formatet for en funktion er denne ene.

412
00:25:21,000 --> 00:25:24,000
Vi har returtype i begyndelsen. Hvad er afkastet type?

413
00:25:24,000 --> 00:25:27,000
Det er bare når din funktion kommer til at vende tilbage.

414
00:25:27,000 --> 00:25:29,000
Hvis du har en funktion, for eksempel fakultet,

415
00:25:29,000 --> 00:25:31,000
, der vil beregne en faktor af et helt tal,

416
00:25:31,000 --> 00:25:34,000
sandsynligvis det kommer til at returnere et heltal også.

417
00:25:34,000 --> 00:25:37,000
Derefter returtypen bliver int.

418
00:25:37,000 --> 00:25:41,000
Printf faktisk har en returtype void

419
00:25:41,000 --> 00:25:43,000
fordi du ikke vender tilbage noget.

420
00:25:43,000 --> 00:25:45,000
Du er bare udskriver ting til skærmen

421
00:25:45,000 --> 00:25:48,000
og afslutning af funktionen bagefter.

422
00:25:48,000 --> 00:25:51,000
Så har du navnet på den funktion, som du kan vælge.

423
00:25:51,000 --> 00:25:55,000
Du skal være lidt fornuftig, ligesom ikke vælger et navn som xyz

424
00:25:55,000 --> 00:25:58,000
eller lignende x2f.

425
00:25:58,000 --> 00:26:02,000
Prøv at gøre op et navn, der giver mening.

426
00:26:02,000 --> 00:26:04,000
>> For eksempel, hvis det er factorial sige factorial.

427
00:26:04,000 --> 00:26:08,000
Hvis det er en funktion, der vil trække noget, name it tegne.

428
00:26:08,000 --> 00:26:11,000
Og så har vi de parametre, der også kaldes argumenter,

429
00:26:11,000 --> 00:26:14,000
der er ligesom de ressourcer, din funktion skal

430
00:26:14,000 --> 00:26:17,000
fra din kode til at udføre sin opgave.

431
00:26:17,000 --> 00:26:20,000
Hvis du ønsker at beregne fakultet af et tal

432
00:26:20,000 --> 00:26:23,000
sandsynligvis du nødt til at have et nummer til at beregne en faktorielt.

433
00:26:23,000 --> 00:26:27,000
Et af de argumenter, som du kommer til at have, er selve nummeret.

434
00:26:27,000 --> 00:26:31,000
Og så det kommer til at gøre noget og returnere værdien ved udgangen

435
00:26:31,000 --> 00:26:35,000
medmindre det er en void funktion.

436
00:26:35,000 --> 00:26:37,000
Lad os se et eksempel.

437
00:26:37,000 --> 00:26:40,000
Hvis jeg ønsker at skrive en funktion, der adderer alle tallene i et array af heltal,

438
00:26:40,000 --> 00:26:43,000
Først og fremmest er returtypen vil være int

439
00:26:43,000 --> 00:26:46,000
fordi jeg har et array af heltal.

440
00:26:46,000 --> 00:26:51,000
Og så jeg har tænkt mig at have den funktion navn som sumArray,

441
00:26:51,000 --> 00:26:54,000
og så det kommer til at tage array selv, int nums,

442
00:26:54,000 --> 00:26:58,000
og derefter længden af ​​array, så jeg ved, hvor mange tal, jeg er nødt til at opsummere.

443
00:26:58,000 --> 00:27:02,000
Så jeg er nødt til at initialisere en variabel kaldet sum, for eksempel til 0,

444
00:27:02,000 --> 00:27:08,000
og hver gang jeg ser et element i arrayet jeg skulle tilføje det til sum, så jeg gjorde en for-løkke.

445
00:27:08,000 --> 00:27:15,000
Ligesom Lexi sagde, du gør int i = 0, i <længde og i + +.

446
00:27:15,000 --> 00:27:20,000
Og for hvert element i arrayet jeg gjorde sum + = nums [i],

447
00:27:20,000 --> 00:27:24,000
og så vendte jeg tilbage til sum, så det er meget simpelt, og det sparer en masse kode

448
00:27:24,000 --> 00:27:28,000
hvis du bruger denne funktion en masse gange.

449
00:27:28,000 --> 00:27:32,000
Så vi tog et kig på betingelser.

450
00:27:32,000 --> 00:27:38,000
Vi har, hvis ellers, og ellers hvis.

451
00:27:38,000 --> 00:27:42,000
Lad os se hvad er forskellen mellem dem.

452
00:27:42,000 --> 00:27:45,000
Tag et kig på disse 2 koder. Hvad er forskellen mellem dem?

453
00:27:45,000 --> 00:27:49,000
Den første har grundlæggende for de koder, vil have dig til at fortælle

454
00:27:49,000 --> 00:27:51,000
om et tal er +, -, eller 0.

455
00:27:51,000 --> 00:27:55,000
Den første siger, at hvis det er> 0 så er det positivt.

456
00:27:55,000 --> 00:28:00,000
Hvis det er = til 0 så er det 0, og hvis det er <0 så er det negativt.

457
00:28:00,000 --> 00:28:04,000
>> Og den anden gør, hvis ellers hvis, ellers.

458
00:28:04,000 --> 00:28:07,000
Forskellen mellem de to er, at dette rent faktisk vil

459
00:28:07,000 --> 00:28:13,000
kontrollere, om> 0, <0 eller = 0 tre gange,

460
00:28:13,000 --> 00:28:17,000
så hvis du har tallet 2, for eksempel, går det at komme her og sige

461
00:28:17,000 --> 00:28:21,000
if (x> 0), og det kommer til at sige ja, så jeg udskriver positive.

462
00:28:21,000 --> 00:28:25,000
Men selv om jeg ved, at det er> 0 og det kommer ikke til at være 0 eller <0

463
00:28:25,000 --> 00:28:29,000
Jeg vil stadig gøre, er det 0, er det <0,

464
00:28:29,000 --> 00:28:33,000
så jeg faktisk går inde i hvis'er, at jeg ikke behøver at

465
00:28:33,000 --> 00:28:38,000
fordi jeg allerede ved, at det ikke kommer til at tilfredsstille nogen af ​​disse betingelser.

466
00:28:38,000 --> 00:28:41,000
Jeg kan bruge den, hvis ellers hvis ellers erklæring.

467
00:28:41,000 --> 00:28:45,000
Det dybest set siger, at hvis x = 0 Jeg udskriver det positive.

468
00:28:45,000 --> 00:28:48,000
Hvis det ikke er, vil jeg også teste dette.

469
00:28:48,000 --> 00:28:51,000
Hvis det er 2 ikke jeg har tænkt mig at gøre dette.

470
00:28:51,000 --> 00:28:54,000
Dybest set, hvis jeg havde x = 2 ville du sige

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ja, så udskrive dette.

472
00:28:57,000 --> 00:29:00,000
Nu, hvor jeg ved, at det er> 0 og at det opfyldte det første, hvis

473
00:29:00,000 --> 00:29:02,000
Jeg er ikke engang kommer til at køre denne kode.

474
00:29:02,000 --> 00:29:09,000
Koden kører hurtigere, faktisk, 3 gange hurtigere, hvis du bruger denne.

475
00:29:09,000 --> 00:29:11,000
Vi har også lært om og og eller.

476
00:29:11,000 --> 00:29:15,000
Jeg har ikke tænkt mig at gå igennem dette, fordi Lexi allerede talt om dem.

477
00:29:15,000 --> 00:29:17,000
Det er bare de && og | | operatør.

478
00:29:17,000 --> 00:29:21,000
>> Det eneste, jeg vil sige, er at være forsigtig, når du har 3 betingelser.

479
00:29:21,000 --> 00:29:24,000
Brug parenteser, fordi det er meget forvirrende, når du har en tilstand

480
00:29:24,000 --> 00:29:27,000
og en anden eller andet.

481
00:29:27,000 --> 00:29:30,000
Brug parenteser bare for at være sikker på, at dine betingelser giver mening

482
00:29:30,000 --> 00:29:34,000
for i så fald, for eksempel, kan man forestille sig, at

483
00:29:34,000 --> 00:29:38,000
det kunne være den første tilstand og den ene eller den anden

484
00:29:38,000 --> 00:29:41,000
eller de 2 forhold kombineret i et og

485
00:29:41,000 --> 00:29:45,000
eller den tredje, så bare være forsigtig.

486
00:29:45,000 --> 00:29:48,000
Og endelig har vi talt om switche.

487
00:29:48,000 --> 00:29:53,000
En switch er meget nyttigt, når du har en variabel.

488
00:29:53,000 --> 00:29:55,000
Lad os sige, at du har en variabel som n

489
00:29:55,000 --> 00:29:59,000
der kan være 0, 1, eller 2, og hvert af disse tilfælde

490
00:29:59,000 --> 00:30:01,000
du kommer til at udføre en opgave.

491
00:30:01,000 --> 00:30:04,000
Man kan sige skifte variabel, og det tyder på, at

492
00:30:04,000 --> 00:30:08,000
værdien så er ligesom værdi1 jeg har tænkt mig at gøre dette,

493
00:30:08,000 --> 00:30:12,000
og så vil jeg gå i stykker, hvilket betyder, at jeg har ikke tænkt mig at se på nogen af ​​de andre sager

494
00:30:12,000 --> 00:30:15,000
fordi vi allerede overbevist om, at sagen

495
00:30:15,000 --> 00:30:20,000
og derefter værdi2 og så videre, og jeg kan også have en standard switch.

496
00:30:20,000 --> 00:30:24,000
Det betyder, hvis den ikke opfylder nogen af ​​de sager, jeg har haft

497
00:30:24,000 --> 00:30:29,000
at jeg har tænkt mig at gøre noget andet, men det er valgfrit.

498
00:30:29,000 --> 00:30:36,000
Det er alt for mig. Lad os nu få Tommy.

499
00:30:36,000 --> 00:30:41,000
Okay, dette vil være Uge 3-ish.

500
00:30:41,000 --> 00:30:45,000
Disse er nogle af de emner vi vil være der dækker, krypto, anvendelsesområde, arrays, et cetera.

501
00:30:45,000 --> 00:30:49,000
Bare en hurtig bemærkning om krypto. Vi kommer ikke til at hamre dette hjem.

502
00:30:49,000 --> 00:30:52,000
>> Vi gjorde det i Pset 2, men for quizzen skal du kende forskel

503
00:30:52,000 --> 00:30:54,000
mellem Cæsar cipher og Vigenère cipher,

504
00:30:54,000 --> 00:30:57,000
hvordan begge disse ciphers arbejde, og hvad det vil sige at kryptere

505
00:30:57,000 --> 00:30:59,000
og dekryptere tekst ved hjælp af disse 2 ciphers.

506
00:30:59,000 --> 00:31:03,000
Husk, at Cæsar cipher simpelthen roterer hvert tegn med samme beløb,

507
00:31:03,000 --> 00:31:06,000
og sørg for du mod på antallet af bogstaver i alfabetet.

508
00:31:06,000 --> 00:31:09,000
Og Vigenère cipher, på den anden side, roterer hvert tegn

509
00:31:09,000 --> 00:31:12,000
med et andet beløb, end så hellere sige

510
00:31:12,000 --> 00:31:15,000
Hver karakter drejes af 3 Vigenère vil rotere hvert tegn

511
00:31:15,000 --> 00:31:17,000
med et andet beløb afhængig af nogle søgeord

512
00:31:17,000 --> 00:31:20,000
hvor hvert bogstav i søgeordet repræsenterer nogle forskellige beløb

513
00:31:20,000 --> 00:31:26,000
at rotere den klare tekst.

514
00:31:26,000 --> 00:31:28,000
Lad os først tale om variabel rækkevidde.

515
00:31:28,000 --> 00:31:30,000
Der findes 2 forskellige typer af variabler.

516
00:31:30,000 --> 00:31:33,000
Vi har lokale variable, og de vil blive defineret

517
00:31:33,000 --> 00:31:36,000
uden for hoved-eller uden for enhver funktion eller blok,

518
00:31:36,000 --> 00:31:39,000
og disse vil være tilgængelige overalt i dit program.

519
00:31:39,000 --> 00:31:41,000
Hvis du har en funktion, og i denne funktion er en while-løkke

520
00:31:41,000 --> 00:31:44,000
den store globale variabel er tilgængelig overalt.

521
00:31:44,000 --> 00:31:48,000
En lokal variabel på den anden side er virkefelt til det sted, hvor det er defineret.

522
00:31:48,000 --> 00:31:53,000
>> Hvis du har en funktion her, for eksempel, har vi denne funktion g,

523
00:31:53,000 --> 00:31:56,000
og inde i g er der en variabel her benævnt y,

524
00:31:56,000 --> 00:31:58,000
og det betyder, at dette er en lokal variabel.

525
00:31:58,000 --> 00:32:00,000
Selvom denne variabel kaldes y

526
00:32:00,000 --> 00:32:03,000
og denne variabel kaldes y disse 2 funktioner

527
00:32:03,000 --> 00:32:06,000
har ingen idé om, hvad hinandens lokale variabler er.

528
00:32:06,000 --> 00:32:10,000
På den anden side har vi heroppe siger int x = 5,

529
00:32:10,000 --> 00:32:12,000
og det er uden for enhver funktion.

530
00:32:12,000 --> 00:32:16,000
Det er uden for main, så dette er en global variabel.

531
00:32:16,000 --> 00:32:20,000
Det betyder, at indersiden af ​​disse 2 funktioner, når jeg siger x - eller x + +

532
00:32:20,000 --> 00:32:26,000
Jeg adgang til samme x, hvorved denne y og dette y er forskellige variable.

533
00:32:26,000 --> 00:32:30,000
Det er forskellen mellem en global variabel og en lokal variabel.

534
00:32:30,000 --> 00:32:33,000
For så vidt angår design angår, nogle gange er det nok en bedre idé

535
00:32:33,000 --> 00:32:37,000
at holde variabler lokal, når du overhovedet kan

536
00:32:37,000 --> 00:32:39,000
da have en masse globale variabler kan få virkelig forvirrende.

537
00:32:39,000 --> 00:32:42,000
Hvis du har en masse funktioner, alt modificere det samme

538
00:32:42,000 --> 00:32:45,000
du måske glemmer, hvad hvis denne funktion ved et uheld ændrer denne globale,

539
00:32:45,000 --> 00:32:47,000
og denne anden funktion ikke vide om det,

540
00:32:47,000 --> 00:32:50,000
og det får temmelig forvirrende, da du får mere kode.

541
00:32:50,000 --> 00:32:53,000
Holde variabler lokal, når du overhovedet kan

542
00:32:53,000 --> 00:32:56,000
er bare godt design.

543
00:32:56,000 --> 00:33:00,000
Arrays, husk på, er simpelthen lister over elementer af samme type.

544
00:33:00,000 --> 00:33:04,000
Inde i CI kan ikke have en liste som 1, 2,0, hej.

545
00:33:04,000 --> 00:33:06,000
Vi kan bare ikke gøre det.

546
00:33:06,000 --> 00:33:11,000
>> Når vi erklærer en datatabel i C alle de elementer være af samme type.

547
00:33:11,000 --> 00:33:14,000
Her har jeg en vifte af 3 heltal.

548
00:33:14,000 --> 00:33:18,000
Her har jeg længden af ​​array, men hvis jeg bare erklære den i denne syntaks

549
00:33:18,000 --> 00:33:21,000
hvor jeg specificere, hvad alle de elementer er jeg ikke teknisk brug for denne 3.

550
00:33:21,000 --> 00:33:25,000
Compileren er smart nok til at regne ud hvor stor array skal være.

551
00:33:25,000 --> 00:33:28,000
Nu når jeg ønsker at hente eller angive værdien af ​​et array

552
00:33:28,000 --> 00:33:30,000
dette er den syntaks at gøre det.

553
00:33:30,000 --> 00:33:33,000
Det vil faktisk ændre det andet element i array, fordi huske,

554
00:33:33,000 --> 00:33:36,000
Nummereringen starter ved 0, ikke ved 1.

555
00:33:36,000 --> 00:33:42,000
Hvis jeg ønsker at læse denne værdi jeg kan sige noget lignende int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Eller hvis jeg ønsker at indstille denne værdi, ligesom jeg gør her,

557
00:33:44,000 --> 00:33:47,000
Jeg kan sige array [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Den tid adgang til elementer ved deres indeks

559
00:33:50,000 --> 00:33:52,000
eller deres position eller når de er i sættet,

560
00:33:52,000 --> 00:33:57,000
og denne registrering starter ved 0.

561
00:33:57,000 --> 00:34:00,000
Vi kan også have arrays af arrays,

562
00:34:00,000 --> 00:34:03,000
og dette kaldes en multi-dimensional array.

563
00:34:03,000 --> 00:34:05,000
Når vi har en multi-dimensional matrix

564
00:34:05,000 --> 00:34:07,000
det betyder, at vi kan få noget lignende rækker og kolonner,

565
00:34:07,000 --> 00:34:11,000
og dette er blot én måde at visualisere denne eller tænker over det.

566
00:34:11,000 --> 00:34:14,000
Når jeg har en multi-dimensional array, der betyder, at jeg har tænkt mig at begynde at brug

567
00:34:14,000 --> 00:34:17,000
mere end 1 indeks, fordi hvis jeg har et gitter

568
00:34:17,000 --> 00:34:19,000
bare sige, hvad rækken du er i ikke giver os et tal.

569
00:34:19,000 --> 00:34:22,000
Det er virkelig bare vil give os en liste over numre.

570
00:34:22,000 --> 00:34:25,000
Lad os sige, at jeg har dette array her.

571
00:34:25,000 --> 00:34:30,000
Jeg har et array kaldet gitter, og jeg siger det er 2 rækker og 3 kolonner,

572
00:34:30,000 --> 00:34:32,000
og så dette er en måde at visualisere det.

573
00:34:32,000 --> 00:34:37,000
Når jeg siger jeg ønsker at få elementet på [1] [2]

574
00:34:37,000 --> 00:34:41,000
det betyder, at fordi disse er rækkerne først og derefter kolonner

575
00:34:41,000 --> 00:34:44,000
Jeg har tænkt mig at springe til række 1, da jeg sagde 1.

576
00:34:44,000 --> 00:34:49,000
>> Så jeg har tænkt mig at komme herover til kolonne 2, og jeg har tænkt mig at få værdien 6.

577
00:34:49,000 --> 00:34:51,000
Give mening?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensionelle arrays, husk, er teknisk set bare en vifte af arrays.

579
00:34:55,000 --> 00:34:57,000
Vi kan have arrays af rækker af arrays.

580
00:34:57,000 --> 00:35:00,000
Vi kan holde ud, men virkelig en måde at tænke på

581
00:35:00,000 --> 00:35:03,000
hvordan dette bliver lagt ud, og hvad der sker, er at visualisere det

582
00:35:03,000 --> 00:35:09,000
i et gitter som denne.

583
00:35:09,000 --> 00:35:12,000
Når vi passerer arrays til funktioner, kommer de til at opføre sig

584
00:35:12,000 --> 00:35:16,000
en lille smule anderledes, end når vi passerer regelmæssigt variabler til funktioner

585
00:35:16,000 --> 00:35:18,000
ligesom passerer en int eller en float.

586
00:35:18,000 --> 00:35:21,000
Når vi passerer i en int eller char eller nogen af ​​de andre datatyper

587
00:35:21,000 --> 00:35:24,000
vi tog bare et kig på, hvis funktionen ændrer

588
00:35:24,000 --> 00:35:28,000
værdien af ​​denne variabel, at forandring ikke kommer til at udbrede op

589
00:35:28,000 --> 00:35:32,000
til den kaldende funktion.

590
00:35:32,000 --> 00:35:35,000
Med et array, på den anden side vil der ske.

591
00:35:35,000 --> 00:35:39,000
Hvis jeg passere i et array til en funktion, og denne funktion ændrer nogle af de elementer,

592
00:35:39,000 --> 00:35:43,000
når jeg kommer tilbage til den funktion, som kaldte det

593
00:35:43,000 --> 00:35:47,000
mit array vil nu være anderledes, og det ordforråd for at

594
00:35:47,000 --> 00:35:50,000
er arrays sendes som reference, som vi vil se senere.

595
00:35:50,000 --> 00:35:53,000
Dette hænger sammen med, hvordan pointers arbejde, hvor disse grundlæggende datatyper

596
00:35:53,000 --> 00:35:55,000
På den anden side, gik der som værdi.

597
00:35:55,000 --> 00:35:59,000
>> Vi kan tænke på det som at tage en kopi af nogle variable og derefter passerer i kopien.

598
00:35:59,000 --> 00:36:01,000
Det er ligegyldigt, hvad vi gør med denne variabel.

599
00:36:01,000 --> 00:36:06,000
Den kaldende funktion vil ikke være klar over, at det blev ændret.

600
00:36:06,000 --> 00:36:10,000
Arrays er bare en lille smule anderledes i denne henseende.

601
00:36:10,000 --> 00:36:13,000
For eksempel, som vi netop har set vigtigste er simpelthen en funktion

602
00:36:13,000 --> 00:36:15,000
der kan tage i 2 argumenter.

603
00:36:15,000 --> 00:36:20,000
Det første argument til den vigtigste funktion er argc, eller antallet af argumenter,

604
00:36:20,000 --> 00:36:23,000
og det andet argument kaldes argv,

605
00:36:23,000 --> 00:36:27,000
og det er de faktiske værdier af disse argumenter.

606
00:36:27,000 --> 00:36:30,000
Lad os sige, at jeg har et program kaldet this.c,

607
00:36:30,000 --> 00:36:34,000
og jeg siger at gøre dette, og jeg har tænkt mig at køre dette på kommandolinjen.

608
00:36:34,000 --> 00:36:38,000
Nu til at passere i nogle argumenter til mit program kaldet dette,

609
00:36:38,000 --> 00:36:42,000
Jeg kunne sige noget lignende. / Dette er cs 50.

610
00:36:42,000 --> 00:36:45,000
Det er, hvad vi forestille David til at gøre hver dag på terminalen.

611
00:36:45,000 --> 00:36:48,000
Men nu er den vigtigste funktion inde i dette program

612
00:36:48,000 --> 00:36:52,000
har disse værdier, så argc er 4.

613
00:36:52,000 --> 00:36:56,000
Det kan være lidt forvirrende, fordi vi virkelig er kun passerer i, er cs 50.

614
00:36:56,000 --> 00:36:58,000
Det er kun 3.

615
00:36:58,000 --> 00:37:02,000
Men husk, at den første del af argv eller det første argument

616
00:37:02,000 --> 00:37:05,000
er navnet på selve funktionen.

617
00:37:05,000 --> 00:37:07,190
Så det betyder, at vi har 4 ting her,

618
00:37:07,190 --> 00:37:10,530
og det første element vil være. / dette.

619
00:37:10,530 --> 00:37:12,970
Og det vil være repræsenteret som en streng.

620
00:37:12,970 --> 00:37:18,590
Så de resterende elementer er, hvad vi skrev i efter navnet på programmet.

621
00:37:18,590 --> 00:37:22,720
Så lige som en sidebemærkning, da vi sandsynligvis oplevede i Pset 2,

622
00:37:22,720 --> 00:37:28,780
Husk, at strengen 50 er ≠ heltallet 50.

623
00:37:28,780 --> 00:37:32,520
Så vi kan ikke sige noget lignende, "int x = argv 3. '

624
00:37:32,520 --> 00:37:36,470
>> Det er bare ikke kommer til at give mening, fordi dette er en streng, og dette er et heltal.

625
00:37:36,470 --> 00:37:38,510
Så hvis du ønsker at konvertere mellem de 2, husk, vi kommer til at

626
00:37:38,510 --> 00:37:40,810
har denne magiske funktion kaldet atoi.

627
00:37:40,810 --> 00:37:46,270
Det tager en streng og returnerer heltal repræsenteret indersiden af ​​denne streng.

628
00:37:46,270 --> 00:37:48,360
Så det er en nem fejl at gøre på quizzen,

629
00:37:48,360 --> 00:37:51,590
bare tænker, at dette automatisk vil være den korrekte type.

630
00:37:51,590 --> 00:37:53,860
Men bare vide, at de altid vil være strenge

631
00:37:53,860 --> 00:38:00,920
selv om strengen kun indeholder et heltal eller et tegn eller en flyder.

632
00:38:00,920 --> 00:38:03,380
Så lad os nu tale om køretid.

633
00:38:03,380 --> 00:38:06,700
Når vi har alle disse algoritmer, der gør alle disse skøre ting,

634
00:38:06,700 --> 00:38:11,580
bliver det virkelig nyttigt at stille spørgsmålet: "Hvor længe skal de tage?"

635
00:38:11,580 --> 00:38:15,500
Vi erklærer herved, med noget, der hedder asymptotisk notation.

636
00:38:15,500 --> 00:38:18,430
Så det betyder, at - ja, lad os sige, at vi giver vores algoritme

637
00:38:18,430 --> 00:38:20,840
nogle virkelig, virkelig, virkelig store indgang.

638
00:38:20,840 --> 00:38:23,840
Vi ønsker at stille spørgsmålet: "Hvor længe kommer det til at tage?

639
00:38:23,840 --> 00:38:26,370
Hvor mange skridt vil det tage vores algoritme til at køre

640
00:38:26,370 --> 00:38:29,980
som en funktion af størrelsen af ​​input? "

641
00:38:29,980 --> 00:38:33,080
Så den første måde vi kan beskrive køre tid er med stor O.

642
00:38:33,080 --> 00:38:35,380
Og det er vores worst-case køretid.

643
00:38:35,380 --> 00:38:38,590
Så hvis vi ønsker at sortere et array, og vi giver vores algoritme et array

644
00:38:38,590 --> 00:38:41,000
det er i faldende rækkefølge, når det skal være i stigende orden,

645
00:38:41,000 --> 00:38:43,130
der kommer til at være det værst tænkelige.

646
00:38:43,130 --> 00:38:49,800
Dette er vores øvre grænse på den maksimale længde af tid vores algoritme vil tage.

647
00:38:49,800 --> 00:38:54,740
På den anden side er denne Ω vil beskrive best case driftstid.

648
00:38:54,740 --> 00:38:58,210
Så hvis vi giver en allerede sorteret array til en sortering algoritme,

649
00:38:58,210 --> 00:39:00,940
hvor lang tid vil det tage at sortere det?

650
00:39:00,940 --> 00:39:06,610
Og dette, så beskriver en nedre grænse på køretid.

651
00:39:06,610 --> 00:39:10,980
Så her er blot nogle ord, der beskriver nogle fælles køretider.

652
00:39:10,980 --> 00:39:13,120
Disse er i stigende rækkefølge.

653
00:39:13,120 --> 00:39:16,060
Den hurtigste køretid vi har kaldes konstant.

654
00:39:16,060 --> 00:39:19,800
>> Det betyder, uanset hvor mange elementer, vi giver vores algoritme,

655
00:39:19,800 --> 00:39:22,280
uanset hvor stor vores array er, sortering det

656
00:39:22,280 --> 00:39:26,510
eller gør, hvad vi gør til array vil altid tage den samme mængde tid.

657
00:39:26,510 --> 00:39:30,270
Så vi kan repræsentere, at blot med en 1, som er en konstant.

658
00:39:30,270 --> 00:39:32,410
Vi så også på logaritmisk driftstid.

659
00:39:32,410 --> 00:39:34,800
Så noget lignende binær søgning er logaritmisk,

660
00:39:34,800 --> 00:39:37,140
hvor vi skære problem i halvdelen hver gang

661
00:39:37,140 --> 00:39:40,970
og så tingene bare komme højere derfra.

662
00:39:40,970 --> 00:39:43,580
Og hvis du nogensinde skriver en O i nogen faktoriel algoritme,

663
00:39:43,580 --> 00:39:47,850
du skulle vel ikke betragte dette som din dag job.

664
00:39:47,850 --> 00:39:53,910
Når vi sammenligner kører gange er det vigtigt at huske på disse ting.

665
00:39:53,910 --> 00:39:57,760
Så hvis jeg har en algoritme, der er O (n), og en anden

666
00:39:57,760 --> 00:40:03,590
har en algoritme af O (2n) disse faktisk er asymptotisk ækvivalente.

667
00:40:03,590 --> 00:40:06,590
Så hvis vi forestiller os n være et stort antal lignende eleventy mia:

668
00:40:06,590 --> 00:40:13,090
så når vi sammenligner eleventy milliarder til noget som eleventy mia + 3,

669
00:40:13,090 --> 00:40:17,640
pludselig, at tre ikke rigtig gøre en stor forskel længere.

670
00:40:17,640 --> 00:40:20,980
Det er derfor, vi vil begynde at overveje disse ting at være ækvivalente.

671
00:40:20,980 --> 00:40:24,220
Så ting som disse konstanter her, er der 2 x denne, eller tilføje en 3,

672
00:40:24,220 --> 00:40:27,180
det er blot konstanter, og disse vil falde op.

673
00:40:27,180 --> 00:40:32,480
Så det er derfor alle 3 af disse køre tider er det samme som at sige, at de er O (n).

674
00:40:32,480 --> 00:40:37,490
Tilsvarende, hvis vi har 2 andre kørselstider, lad os sige O (n ³ + 2n ²), kan vi tilføje

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, og så har vi en anden driftstid, der er lige O (n ³).

676
00:40:42,070 --> 00:40:46,290
Igen er dette det samme fordi disse - disse er ikke de samme.

677
00:40:46,290 --> 00:40:49,840
Det er de samme ting, undskyld. Så disse er de samme, fordi

678
00:40:49,840 --> 00:40:53,090
Dette n ³ vil dominere dette 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Hvad er ikke det samme ting er, hvis vi har kørt tider som O (n ³) og O (n ²)

680
00:40:59,130 --> 00:41:02,820
fordi denne n ³ er meget større end dette n ².

681
00:41:02,820 --> 00:41:05,470
Så hvis vi har eksponenter, pludseligt dette begynder at betyde noget,

682
00:41:05,470 --> 00:41:08,280
men når vi er bare beskæftiger sig med faktorer, som vi er heroppe,

683
00:41:08,280 --> 00:41:12,810
så det kommer ikke til at noget, fordi de bare kommer til at falde ud.

684
00:41:12,810 --> 00:41:16,760
Lad os tage et kig på nogle af de algoritmer, vi har set hidtil

685
00:41:16,760 --> 00:41:19,260
og tale om deres køretid.

686
00:41:19,260 --> 00:41:23,850
Den første måde at se efter et nummer i en liste, som vi så, var lineær søgning.

687
00:41:23,850 --> 00:41:26,950
Og gennemførelsen af ​​lineær søgning er super ligetil.

688
00:41:26,950 --> 00:41:30,490
Vi har bare en liste, og vi vil se på hver enkelt element i listen

689
00:41:30,490 --> 00:41:34,260
indtil vi finder det nummer, vi leder efter.

690
00:41:34,260 --> 00:41:38,370
Så det vil sige, at i værste tilfælde er dette O (n).

691
00:41:38,370 --> 00:41:40,860
Og værste fald her kunne være, hvis elementet er

692
00:41:40,860 --> 00:41:45,710
det sidste element, og derefter ved lineær søgning, vi er nødt til at se på hvert enkelt element

693
00:41:45,710 --> 00:41:50,180
indtil vi kommer til den sidste, for at vide, at det var faktisk på listen.

694
00:41:50,180 --> 00:41:52,910
Vi kan ikke bare give op halvvejs og sige: "Det er nok ikke der."

695
00:41:52,910 --> 00:41:55,980
Med lineær søgning, vi er nødt til at se på det hele.

696
00:41:55,980 --> 00:41:59,090
The best case efterløbstid på den anden side er konstant

697
00:41:59,090 --> 00:42:04,200
fordi der i bedste fald det element, vi leder efter, er blot den første i listen.

698
00:42:04,200 --> 00:42:08,930
Så det kommer til at tage os præcis 1 trin, uanset hvor stor listen er

699
00:42:08,930 --> 00:42:12,140
hvis vi leder efter det første element hver gang.

700
00:42:12,140 --> 00:42:15,390
>> Så når du søger, husk, kræver det ikke, at vores liste være sorteret.

701
00:42:15,390 --> 00:42:19,430
Fordi vi simpelthen kommer til at se ud over hvert enkelt element, og det er faktisk ligegyldigt

702
00:42:19,430 --> 00:42:23,560
hvilken rækkefølge disse elementer er i.

703
00:42:23,560 --> 00:42:28,110
En mere intelligent søgealgoritme er noget binær søgning.

704
00:42:28,110 --> 00:42:31,500
Husk, at gennemførelsen af ​​binær søgning er, når du kommer til at

705
00:42:31,500 --> 00:42:34,320
holde ser på midten af ​​listen.

706
00:42:34,320 --> 00:42:38,000
Og fordi vi kigger på midten, kræver vi, at listen er sorteret

707
00:42:38,000 --> 00:42:40,580
eller andet, som vi ikke ved, hvor midten er, og vi er nødt til at kigge over

708
00:42:40,580 --> 00:42:44,480
hele listen for at finde den, og derefter på det tidspunkt vi bare spilder tiden.

709
00:42:44,480 --> 00:42:48,480
Så hvis vi har en sorteret liste, og vi finder i midten, vil vi sammenligne den midterste

710
00:42:48,480 --> 00:42:51,590
til elementet, vi leder efter.

711
00:42:51,590 --> 00:42:54,640
Hvis det er for højt, så kan vi glemme den højre halvdel

712
00:42:54,640 --> 00:42:57,810
fordi vi ved, at hvis vores element er allerede for høj

713
00:42:57,810 --> 00:43:01,080
og alt til højre for dette element er endnu højere,

714
00:43:01,080 --> 00:43:02,760
så vi behøver ikke at kigge der længere.

715
00:43:02,760 --> 00:43:05,430
Hvor på den anden side, hvis vores element er for lav,

716
00:43:05,430 --> 00:43:08,700
vi kender alt til venstre for denne bestanddel er også for lavt,

717
00:43:08,700 --> 00:43:11,390
så det ikke rigtig mening at kigge der, enten.

718
00:43:11,390 --> 00:43:15,760
Denne måde, med hvert skridt og hver gang vi ser på midten af ​​listen,

719
00:43:15,760 --> 00:43:19,060
vi kommer til at skære vores problem i halvdelen, fordi vi pludselig kender

720
00:43:19,060 --> 00:43:23,040
en hel masse tal, der ikke kan være den, vi leder efter.

721
00:43:23,040 --> 00:43:26,950
>> I pseudokode dette ville se noget som dette,

722
00:43:26,950 --> 00:43:30,990
og fordi vi skærer listen i halvdelen hver eneste gang,

723
00:43:30,990 --> 00:43:34,920
vores worst-case køretid springer fra lineær til logaritmisk.

724
00:43:34,920 --> 00:43:39,260
Så pludselig har vi log-in skridt for at finde et element på en liste.

725
00:43:39,260 --> 00:43:42,460
Den bedste case kørende tid, er dog stadig konstant

726
00:43:42,460 --> 00:43:45,180
fordi nu, lad os bare sige, at det element, vi leder efter, er

727
00:43:45,180 --> 00:43:48,380
altid nøjagtigt midt i den oprindelige liste.

728
00:43:48,380 --> 00:43:52,080
Så vi kan dyrke vores liste så stor som vi ønsker, men hvis element, vi leder efter, er på midten,

729
00:43:52,080 --> 00:43:54,910
så er det kun kommer til at tage os 1 trin.

730
00:43:54,910 --> 00:44:00,920
Så det er derfor vi er O (log n) og Ω (1) eller konstant.

731
00:44:00,920 --> 00:44:04,510
Lad os faktisk køre binær søgning på denne liste.

732
00:44:04,510 --> 00:44:08,020
Så lad os sige, at vi leder efter elementet 164.

733
00:44:08,020 --> 00:44:11,650
Den første ting, vi skal gøre, er at finde midtpunktet af denne liste.

734
00:44:11,650 --> 00:44:15,060
Det er bare sådan, at midtpunktet kommer til at falde i mellem disse 2 numre,

735
00:44:15,060 --> 00:44:18,960
så lad os bare vilkårligt sige, hver gang midtpunktet falder mellem 2 numre,

736
00:44:18,960 --> 00:44:21,150
lad os bare runde op.

737
00:44:21,150 --> 00:44:24,330
Vi skal bare sikre, at vi gør dette hvert skridt på vejen.

738
00:44:24,330 --> 00:44:29,040
Så vi kommer til at runde op, og vi vil sige, at 161 er midt i vores liste.

739
00:44:29,040 --> 00:44:34,640
Så 161 <164, og hvert element til venstre for 161

740
00:44:34,640 --> 00:44:39,120
er også <164, så vi ved, at det ikke kommer til at hjælpe os på alle

741
00:44:39,120 --> 00:44:42,690
at begynde at kigge herover, fordi elementet, vi leder efter kan ikke være der.

742
00:44:42,690 --> 00:44:47,060
Så hvad vi kan gøre, er at vi kan bare glemme alt om det hele venstre halvdel af listen,

743
00:44:47,060 --> 00:44:51,700
og nu kun tage stilling til fra højre side af 161 og fremefter.

744
00:44:51,700 --> 00:44:54,050
>> Så igen, det er midtpunktet, lad os bare runde op.

745
00:44:54,050 --> 00:44:56,260
Nu 175 er for stor.

746
00:44:56,260 --> 00:44:59,180
Så vi ved, det kommer ikke til at hjælpe os med at kigge her eller her,

747
00:44:59,180 --> 00:45:06,610
så vi kan bare smide det væk, og til sidst vil vi ramt 164.

748
00:45:06,610 --> 00:45:10,560
Eventuelle spørgsmål om binær søgning?

749
00:45:10,560 --> 00:45:14,180
Lad os komme videre fra at søge gennem en allerede sorteret liste

750
00:45:14,180 --> 00:45:17,660
til rent faktisk at tage en liste over numre i vilkårlig rækkefølge

751
00:45:17,660 --> 00:45:20,960
og gøre denne liste i stigende orden.

752
00:45:20,960 --> 00:45:24,060
Den første algoritme vi kiggede på blev kaldt boble slags.

753
00:45:24,060 --> 00:45:27,300
Og det ville være nemmere for de algoritmer vi så.

754
00:45:27,300 --> 00:45:32,970
Bubble slags siger, at når nogen 2 elementer inde listen er ud af sted,

755
00:45:32,970 --> 00:45:36,500
betyder at der er et højere antal til venstre for et lavere antal,

756
00:45:36,500 --> 00:45:40,190
så vi kommer til at bytte dem, fordi det betyder, at listen vil blive

757
00:45:40,190 --> 00:45:42,860
"Mere sorteres" end det var før.

758
00:45:42,860 --> 00:45:45,180
Og vi vil bare fortsætte denne proces igen og igen og igen

759
00:45:45,180 --> 00:45:52,100
indtil sidst elementerne slags boble til deres korrekte placering, og vi har en sorteret liste.

760
00:45:52,100 --> 00:45:57,230
>> Den kører tidspunktet for denne bliver O (n ²). Hvorfor?

761
00:45:57,230 --> 00:46:00,370
Jo, fordi i værste fald, vi kommer til at tage ethvert element, og

762
00:46:00,370 --> 00:46:04,570
vi kommer til at ende med at sammenligne den med alle andre elementer i listen.

763
00:46:04,570 --> 00:46:08,030
Men i bedste fald har vi en allerede sorteret liste, boble sortere s

764
00:46:08,030 --> 00:46:12,230
bare kommer til at gå igennem en gang, siger "Nope. jeg ikke gøre nogen swaps, så jeg er færdig."

765
00:46:12,230 --> 00:46:17,410
Så vi har en bedste-case køretid for Ω (n).

766
00:46:17,410 --> 00:46:20,680
Lad os køre boble sortere på en liste.

767
00:46:20,680 --> 00:46:23,560
Eller først, lad os bare se på nogle pseudokode virkelig hurtigt.

768
00:46:23,560 --> 00:46:28,160
Vi ønsker at sige, at vi ønsker at holde styr på, i hver iteration af løkken,

769
00:46:28,160 --> 00:46:32,190
holde styr på, hvorvidt vi skiftede nogen elementer.

770
00:46:32,190 --> 00:46:37,610
Så grunden til det er, vi kommer til at stoppe, når vi ikke har byttet nogen elementer.

771
00:46:37,610 --> 00:46:41,980
Så i starten af ​​vores løkke har vi ikke byttet noget, så vi vil sige, det er falsk.

772
00:46:41,980 --> 00:46:47,170
Nu er vi kommer til at gå gennem listen og sammenligne element i til element i + 1

773
00:46:47,170 --> 00:46:50,310
og hvis det er tilfældet, at der er et større tal til venstre for et mindre antal,

774
00:46:50,310 --> 00:46:52,310
så er vi bare kommer til at bytte dem.

775
00:46:52,310 --> 00:46:54,490
>> Og så vil vi huske, at vi byttes et element.

776
00:46:54,490 --> 00:46:58,900
Det betyder, at vi er nødt til at gå gennem listen mindst 1 gang

777
00:46:58,900 --> 00:47:02,160
fordi den tilstand, hvor vi stoppede er, når hele listen er allerede sorteret,

778
00:47:02,160 --> 00:47:04,890
hvilket betyder at vi ikke har foretaget swaps.

779
00:47:04,890 --> 00:47:09,960
Så det er derfor vores tilstand hernede er "idet nogle dele er blevet byttet."

780
00:47:09,960 --> 00:47:13,720
Så lad os nu bare se på dette kører på en liste.

781
00:47:13,720 --> 00:47:16,640
Jeg har listen 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble sort kommer til at starte helt til venstre, og det kommer til at sammenligne

783
00:47:19,850 --> 00:47:24,700
de i-elementer, så 0 til i + 1, som er element 1.

784
00:47:24,700 --> 00:47:29,020
Det kommer til at sige, godt 5> 0, men lige nu 5 er til venstre,

785
00:47:29,020 --> 00:47:32,500
så jeg er nødt til at bytte om på 5 og 0.

786
00:47:32,500 --> 00:47:35,470
Når jeg bytte dem, pludselig får jeg denne anden liste.

787
00:47:35,470 --> 00:47:38,260
Nu 5> 1, så vil vi bytte dem.

788
00:47:38,260 --> 00:47:42,160
5 er ikke> 6, så vi behøver ikke at gøre noget her.

789
00:47:42,160 --> 00:47:46,690
Men 6> 4, så vi er nødt til at bytte.

790
00:47:46,690 --> 00:47:49,740
Igen, vi er nødt til at løbe igennem hele listen til sidst opdage

791
00:47:49,740 --> 00:47:52,330
at disse er ude af drift, vi bytte dem,

792
00:47:52,330 --> 00:47:57,120
og på dette punkt er vi nødt til at køre gennem listen 1 gang

793
00:47:57,120 --> 00:48:05,390
for at sikre, at alt er i sin kendelse, og på dette punkt boble slags er færdig.

794
00:48:05,390 --> 00:48:10,720
En anden algoritme til at tage nogle elementer og sortering er selection art.

795
00:48:10,720 --> 00:48:15,740
Ideen bag udvælgelsen art er, at vi kommer til at opbygge en sorteret del af listen

796
00:48:15,740 --> 00:48:18,150
1 element ad gangen.

797
00:48:18,150 --> 00:48:23,170
>> Og den måde, vi kommer til at gøre det på er ved at opbygge den venstre del af listen.

798
00:48:23,170 --> 00:48:27,510
Og dybest set, hver - på hvert trin, vi kommer til at tage det mindste element vi har tilbage

799
00:48:27,510 --> 00:48:32,310
som ikke er blevet sorteret endnu, og vi vil flytte den ind i den sorterede segment.

800
00:48:32,310 --> 00:48:35,850
Det betyder, at vi er nødt til hele tiden at finde den mindste usorteret element

801
00:48:35,850 --> 00:48:40,720
og derefter tage det mindste element og bytte den med det

802
00:48:40,720 --> 00:48:45,090
venstre-mest element, der ikke er sorteret.

803
00:48:45,090 --> 00:48:50,890
Den kører tidspunktet for denne bliver O (n ²), fordi i værste fald

804
00:48:50,890 --> 00:48:55,070
Vi er nødt til at sammenligne hver enkelt element til hvert andet element.

805
00:48:55,070 --> 00:48:59,250
Fordi vi siger, at hvis vi starter på venstre halvdel af listen, har vi brug

806
00:48:59,250 --> 00:49:02,970
at gå gennem hele højre segment for at finde det mindste element.

807
00:49:02,970 --> 00:49:05,430
Og så igen, vi er nødt til at gå over hele højre segment og

808
00:49:05,430 --> 00:49:08,210
holde gå over det igen og igen og igen.

809
00:49:08,210 --> 00:49:11,350
Det kommer til at være n ². Vi skal bruge en for-løkke inde i en anden for-løkke

810
00:49:11,350 --> 00:49:13,350
hvilket tyder n ².

811
00:49:13,350 --> 00:49:16,530
I bedste fald tanken, lad os sige, at vi giver det en allerede sorteret liste;

812
00:49:16,530 --> 00:49:19,270
vi faktisk ikke gøre det bedre end n ².

813
00:49:19,270 --> 00:49:21,730
Fordi udvælgelse sort har ingen mulighed for at vide, at

814
00:49:21,730 --> 00:49:25,540
det mindste element er bare den, jeg tilfældigvis er på udkig på.

815
00:49:25,540 --> 00:49:28,970
Det er stadig nødt til at sørge for, at dette faktisk er et minimum.

816
00:49:28,970 --> 00:49:31,670
>> Og den eneste måde at sikre, at det er den mindste, ved hjælp af denne algoritme,

817
00:49:31,670 --> 00:49:34,640
er at se på hver enkelt element igen.

818
00:49:34,640 --> 00:49:38,420
Så virkelig, hvis du giver det - hvis du giver valg Arranger en allerede sorteret liste,

819
00:49:38,420 --> 00:49:42,720
det kommer ikke til at gøre noget bedre end at give det en liste, der ikke er sorteret endnu.

820
00:49:42,720 --> 00:49:46,320
Af den måde, at hvis det sker for at være tilfældet noget er O (noget)

821
00:49:46,320 --> 00:49:50,640
og omega for noget, kan vi bare sige mere kortfattet, at det er θ af noget.

822
00:49:50,640 --> 00:49:52,760
Så hvis du kan se, at komme op hvor som helst, det er hvad det betyder bare.

823
00:49:52,760 --> 00:49:57,580
>> Hvis noget er theta n ², er det både store O (n ²) og Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Så bedst tilfælde og værste tilfælde betyder det ikke gøre en forskel,

825
00:49:59,790 --> 00:50:04,400
algoritmen vil gøre det samme hver gang.

826
00:50:04,400 --> 00:50:06,610
Så dette er hvad pseudokoden for udvælgelse slags kan se ud.

827
00:50:06,610 --> 00:50:10,630
Vi dybest set kommer til at sige, at jeg ønsker at gentage over listen

828
00:50:10,630 --> 00:50:15,180
fra venstre mod højre, og ved hver iteration af løkken, vil jeg flytte

829
00:50:15,180 --> 00:50:19,780
den mindste element i denne sorterede del af listen.

830
00:50:19,780 --> 00:50:23,260
Og når jeg flytter noget der, jeg aldrig skal se på dette element igen.

831
00:50:23,260 --> 00:50:28,600
Fordi så snart jeg bytte et element i den venstre del af listen, er det sorteres

832
00:50:28,600 --> 00:50:32,600
fordi vi gør alt i stigende rækkefølge ved hjælp af mindstesatser.

833
00:50:32,600 --> 00:50:38,740
Så vi sagde, okay, vi er i position i, og vi er nødt til at se på alle de elementer,

834
00:50:38,740 --> 00:50:42,260
til højre for i for at finde den minimale.

835
00:50:42,260 --> 00:50:46,150
Så det betyder, at vi ønsker at se fra i + 1 til slutningen af ​​listen.

836
00:50:46,150 --> 00:50:51,610
Og nu, hvis det element, vi i øjeblikket kigger på, er mindre end vores minimum hidtil,

837
00:50:51,610 --> 00:50:54,190
der, husk, vi starter minimum ud til bare være

838
00:50:54,190 --> 00:50:57,020
uanset element vi i øjeblikket på, jeg vil antage, at er det mindste.

839
00:50:57,020 --> 00:51:00,270
Hvis jeg finder et element, der er mindre end det, så jeg har tænkt mig at sige, okay,

840
00:51:00,270 --> 00:51:02,700
godt, jeg har fundet en ny minimum.

841
00:51:02,700 --> 00:51:06,080
Jeg har tænkt mig at huske, hvor det minimum var.

842
00:51:06,080 --> 00:51:09,560
>> Så nu, når jeg har været igennem denne ret usorteret segment,

843
00:51:09,560 --> 00:51:16,690
Jeg kan sige, jeg har tænkt mig at skifte den mindste element med det element, der er i position i.

844
00:51:16,690 --> 00:51:21,100
Det kommer til at opbygge min liste, min sorteret del af listen fra venstre mod højre,

845
00:51:21,100 --> 00:51:25,190
og vi ikke nogensinde nødt til at se på et element igen, når det er i denne del.

846
00:51:25,190 --> 00:51:27,930
Når vi har byttet det.

847
00:51:27,930 --> 00:51:30,260
Så lad os køre udvælgelse slags på denne liste.

848
00:51:30,260 --> 00:51:38,220
Den blå element her vil være i, og den røde element vil være den mindste element.

849
00:51:38,220 --> 00:51:41,570
Så jeg starter helt i venstre side af listen, så på 5.

850
00:51:41,570 --> 00:51:44,610
Nu skal vi finde den mindste usorteret element.

851
00:51:44,610 --> 00:51:49,480
Så vi siger 0 <5, så 0 er min nye minimum.

852
00:51:49,480 --> 00:51:53,820
>> Men jeg kan ikke stoppe der, for selv om vi kan genkende, at 0 er den mindste,

853
00:51:53,820 --> 00:51:59,390
vi er nødt til at køre gennem hver andet element på listen for at sikre.

854
00:51:59,390 --> 00:52:01,760
Så 1 er større, 6 er større, 4 er større.

855
00:52:01,760 --> 00:52:05,850
Det betyder, at når man ser på alle disse elementer, har jeg bestemt 0 er den mindste.

856
00:52:05,850 --> 00:52:09,800
Så jeg har tænkt mig at bytte den 5 og 0.

857
00:52:09,800 --> 00:52:15,480
Når jeg bytte det, jeg kommer til at få en ny liste, og jeg ved, at jeg aldrig skal se på, at 0 igen

858
00:52:15,480 --> 00:52:19,380
fordi når jeg har byttet det, jeg har sorteret det, og vi er færdige.

859
00:52:19,380 --> 00:52:22,730
Nu er det bare sådan, at den blå element er igen 5,

860
00:52:22,730 --> 00:52:26,030
og vi er nødt til at se på 1, 6 og 4 for at fastslå, at 1

861
00:52:26,030 --> 00:52:31,520
er den mindste minimum element, så vi vil bytte 1 og 5.

862
00:52:31,520 --> 00:52:36,890
Igen, vi er nødt til at se på - sammenligne 5 til 6 og 4,

863
00:52:36,890 --> 00:52:39,830
og vi vil bytte 4 og 5, og endelig sammenligne

864
00:52:39,830 --> 00:52:45,740
disse 2 numre og bytte dem, indtil vi får vores sorteret liste.

865
00:52:45,740 --> 00:52:49,730
Eventuelle spørgsmål om udvælgelse slags?

866
00:52:49,730 --> 00:52:56,420
Okay. Lad os gå til den sidste emne her, og det er rekursion.

867
00:52:56,420 --> 00:52:59,810
>> Rekursion, husk, er det virkelig meta ting, hvor en funktion

868
00:52:59,810 --> 00:53:02,740
gentagne gange kalder sig.

869
00:53:02,740 --> 00:53:05,620
Så på et tidspunkt, mens vores fuction gentagne gange kalder sig selv

870
00:53:05,620 --> 00:53:10,100
skal der være et tidspunkt, hvor vi stoppe med at kalde os selv.

871
00:53:10,100 --> 00:53:13,670
For hvis vi ikke gør det, så er vi bare vil fortsætte med at gøre dette for evigt,

872
00:53:13,670 --> 00:53:16,660
og vores program er bare ikke kommer til at afslutte.

873
00:53:16,660 --> 00:53:19,200
Vi kalder denne tilstand basisscenariet.

874
00:53:19,200 --> 00:53:22,570
Og base case siger, snarere end at kalde en funktion igen,

875
00:53:22,570 --> 00:53:25,330
Jeg skal bare til at returnere en vis værdi.

876
00:53:25,330 --> 00:53:28,080
Så når vi har returneret en værdi, har vi standset kalde os selv,

877
00:53:28,080 --> 00:53:32,550
og resten af ​​de opkald, vi har lavet indtil videre kan også vende tilbage.

878
00:53:32,550 --> 00:53:36,050
Det modsatte af den oprindelige sag er den rekursive tilfældet.

879
00:53:36,050 --> 00:53:39,050
Og det er, når vi ønsker at foretage et andet opkald til den funktion, at vi er i øjeblikket i.

880
00:53:39,050 --> 00:53:44,690
Og vi sandsynligvis, men ikke altid, ønsker at bruge forskellige argumenter.

881
00:53:44,690 --> 00:53:48,940
>> Så hvis vi har en funktion kaldet f, og f har lige ringet tager 1 argument,

882
00:53:48,940 --> 00:53:52,010
og vi bare holde kalde f (1), f (1), f (1), og det bare så sker det, at

883
00:53:52,010 --> 00:53:56,510
argumentet 1 falder i rekursive tilfælde, er vi stadig aldrig vil stoppe.

884
00:53:56,510 --> 00:54:01,620
Selvom vi har en base sag, skal vi sørge for at i sidste ende vil vi ramme den basisscenariet.

885
00:54:01,620 --> 00:54:04,250
Vi har ikke bare holde opholder sig i denne rekursive tilfælde.

886
00:54:04,250 --> 00:54:09,870
Generelt, når vi kalder os selv, er vi nok nødt til en anden argumentation hver gang.

887
00:54:09,870 --> 00:54:12,700
Her er en virkelig enkel rekursiv funktion.

888
00:54:12,700 --> 00:54:15,090
Så dette vil beregne fakultet af et tal.

889
00:54:15,090 --> 00:54:17,790
Op øverst her vi har vores base case.

890
00:54:17,790 --> 00:54:22,330
I tilfælde af at n ≤ 1, vi vil ikke kalde fakultet igen.

891
00:54:22,330 --> 00:54:26,490
Vi kommer til at stoppe, vi bare vil vende tilbage en vis værdi.

892
00:54:26,490 --> 00:54:30,170
Hvis dette ikke er sandt, så er vi kommer til at ramme vores rekursiv sag.

893
00:54:30,170 --> 00:54:33,550
Bemærk her, at vi ikke bare kalde factorial (n), fordi det ikke ville være meget nyttigt.

894
00:54:33,550 --> 00:54:36,810
Vi vil kalde fakultet af noget andet.

895
00:54:36,810 --> 00:54:40,850
>> Og så du kan se, i sidste ende, hvis vi passerer en fakultetværdi (5) eller noget,

896
00:54:40,850 --> 00:54:45,900
vi vil kalde factorial (4) og så videre, og til sidst vil vi ramme denne basisscenariet.

897
00:54:45,900 --> 00:54:51,730
Så det ser godt ud. Lad os se hvad der sker, når vi rent faktisk køre dette.

898
00:54:51,730 --> 00:54:57,840
Dette er stakken, og lad os sige, at main vil kalde denne funktion med et argument (4).

899
00:54:57,840 --> 00:55:02,200
Så en gang faktoriel ser og = 4, vil fakultet kalde sig selv.

900
00:55:02,200 --> 00:55:05,010
Nu, pludselig har vi fakultet (3).

901
00:55:05,010 --> 00:55:10,780
Så disse funktioner vil holde vokse, indtil sidst vi ramt vores base case.

902
00:55:10,780 --> 00:55:17,830
På dette tidspunkt er returværdien af ​​dette afkast (nx returværdien af ​​dette),

903
00:55:17,830 --> 00:55:21,290
returværdien af ​​dette er nx returværdien af ​​dette.

904
00:55:21,290 --> 00:55:23,290
Til sidst skal vi ramt nogle tal.

905
00:55:23,290 --> 00:55:26,560
Øverst her siger vi tilbage 1.

906
00:55:26,560 --> 00:55:30,650
Det betyder, at når vi vender tilbage, at tal, kan vi pop dette fra stakken.

907
00:55:30,650 --> 00:55:36,570
Så denne factorial (1) udføres.

908
00:55:36,570 --> 00:55:41,190
Når 1 vender tilbage, denne faktorielle (1) afkast, denne tilbagevenden til 1.

909
00:55:41,190 --> 00:55:46,910
Returværdien af ​​dette, husk, var nx returværdien af ​​dette.

910
00:55:46,910 --> 00:55:50,720
Så pludselig, denne fyr ved, at jeg vil vende tilbage 2.

911
00:55:50,720 --> 00:55:55,910
>> Så husk, returnere værdien af ​​dette er bare NX returværdien heroppe.

912
00:55:55,910 --> 00:56:01,160
Så nu kan vi sige 3 x 2, og til sidst, her kan vi sige

913
00:56:01,160 --> 00:56:04,010
dette er bare at være 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Og når denne vender tilbage, vi får ned til et enkelt heltal inde i main.

915
00:56:09,570 --> 00:56:15,460
Eventuelle spørgsmål om rekursion?

916
00:56:15,460 --> 00:56:17,090
Ok. Så der er mere tid til spørgsmål til sidst,

917
00:56:17,090 --> 00:56:23,360
men nu Joseph vil dække de resterende emner.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Okay. Så nu, at vi har talt om rekursioner,

919
00:56:25,590 --> 00:56:27,840
lad os snakke lidt om hvad fusionere slags er.

920
00:56:27,840 --> 00:56:31,740
Flet slags er dybest set en anden måde at sortere en liste over numre.

921
00:56:31,740 --> 00:56:36,430
Og hvordan det virker er, med fletningen slags du har en liste, og hvad vi gør, er

922
00:56:36,430 --> 00:56:39,120
vi siger, lad os splitte dette i 2 halvdele.

923
00:56:39,120 --> 00:56:42,750
Vi vil først løbe fusionere slags igen på den venstre halvdel,

924
00:56:42,750 --> 00:56:45,040
så vil vi køre fusionere art på den højre halvdel,

925
00:56:45,040 --> 00:56:50,240
og det giver os nu 2 halvdele, der er sorteret, og nu vil vi kombinere disse halvdele sammen.

926
00:56:50,240 --> 00:56:55,010
Det er lidt svært at se uden et eksempel, så vi vil gå gennem beslutningsforslag, og se hvad der sker.

927
00:56:55,010 --> 00:56:59,590
Så du starte med denne liste, split vi det i 2 halvdele.

928
00:56:59,590 --> 00:57:02,300
Vi kører fusionere sortere på den venstre halvdel først.

929
00:57:02,300 --> 00:57:06,660
Så det er den venstre halvdel, og nu skal vi køre dem gennem denne liste igen

930
00:57:06,660 --> 00:57:09,800
der bliver gået ind i fletningen slags, og så ser vi, igen,

931
00:57:09,800 --> 00:57:13,270
på venstre side af denne liste, og vi kører fusionere slags på det.

932
00:57:13,270 --> 00:57:15,880
Nu får vi ned til en liste med 2 numre,

933
00:57:15,880 --> 00:57:19,010
og nu den venstre halvdel er kun 1 element lang, og vi kan ikke

934
00:57:19,010 --> 00:57:23,380
opdele en liste, der er kun 1 element i halve, så siger vi bare, når vi har 50,

935
00:57:23,380 --> 00:57:26,400
der er kun 1 element, er det allerede sorteret.

936
00:57:26,400 --> 00:57:29,860
>> Når vi er færdig med det, kan vi se, at vi kan

937
00:57:29,860 --> 00:57:32,230
gå videre til den højre halvdel af denne liste,

938
00:57:32,230 --> 00:57:36,480
og 3 er også sorteres, og så nu, at begge halvdele af denne liste er sorteret

939
00:57:36,480 --> 00:57:39,080
vi kan slutte disse tal sammen igen.

940
00:57:39,080 --> 00:57:45,320
Så ser vi på 50 og 3, 3 er mindre end 50, så det går i først og derefter 50 kommer ind

941
00:57:45,320 --> 00:57:49,340
Nu er der gjort, vi gå tilbage op til denne liste og sortere det er højre halvdel.

942
00:57:49,340 --> 00:57:52,440
42 er det eget nummer, så det er allerede sorteret.

943
00:57:52,440 --> 00:57:57,850
Så nu er vi sammenligne disse 2 og 3 er mindre end 42, så der bliver sat ind først,

944
00:57:57,850 --> 00:58:02,340
nu 42 bliver sat i, og 50 bliver sat i.

945
00:58:02,340 --> 00:58:07,220
Nu, det er sorteret, vi går hele vejen tilbage til toppen, 1337 og 15.

946
00:58:07,220 --> 00:58:14,560
Nå, vi nu ser på den venstre halvdel af denne liste, 1337 er i sig selv så det er sorteret og samme med 15.

947
00:58:14,560 --> 00:58:19,020
Så nu er vi kombinerer disse 2 numre for at sortere den oprindelige liste, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
så det går i først, så 1337 går i.

949
00:58:23,060 --> 00:58:26,640
Og nu vi sorteret begge halvdele af den oprindelige liste op øverst.

950
00:58:26,640 --> 00:58:30,440
Og alt, hvad vi skal gøre, er at kombinere disse.

951
00:58:30,440 --> 00:58:36,890
Vi ser på de første 2 numre af denne liste, 3 <15, så det går i den slags arrayet først.

952
00:58:36,890 --> 00:58:44,460
15 <42, så det går ind nu, 42 <1337, der går ind

953
00:58:44,460 --> 00:58:51,010
50 <1337, så det går i. Og bemærke, at vi tog bare 2 numre ud af denne liste.

954
00:58:51,010 --> 00:58:53,640
Så vi er ikke bare skiftevis mellem de 2 lister.

955
00:58:53,640 --> 00:58:56,050
Vi leder bare efter i starten, og vi tager elementet

956
00:58:56,050 --> 00:59:00,270
der er mindre og derefter sætte det ind i vores array.

957
00:59:00,270 --> 00:59:04,080
Nu har vi samlet alle de halvdele og vi er færdige.

958
00:59:04,080 --> 00:59:07,780
>> Eventuelle spørgsmål om fusionere slags? Ja?

959
00:59:07,780 --> 00:59:14,190
[Student] Hvis det er opsplitning i forskellige grupper, hvorfor de ikke bare dele det engang

960
00:59:14,190 --> 00:59:19,970
og du har 3 og 2 i en gruppe? [Resten af ​​spørgsmål uforståelig]

961
00:59:19,970 --> 00:59:24,940
Årsagen - så spørgsmålet er, hvorfor kan vi ikke bare flette dem på det første skridt efter at vi har dem?

962
00:59:24,940 --> 00:59:29,530
Grunden til at vi kan gøre dette, skal du starte på venstre de fleste elementer på begge sider,

963
00:59:29,530 --> 00:59:33,040
og derefter tage den mindste og sætte det i, er, at vi ved, at disse

964
00:59:33,040 --> 00:59:35,290
enkelte lister er i sorteret ordrer.

965
00:59:35,290 --> 00:59:37,290
Så hvis jeg ser på venstre de fleste elementer af begge halvdele,

966
00:59:37,290 --> 00:59:40,490
Jeg ved, at de kommer til at være de mindste dele af disse lister.

967
00:59:40,490 --> 00:59:43,930
Så jeg kan sætte dem i det mindste element pletter af denne store liste.

968
00:59:43,930 --> 00:59:47,810
På den anden side, hvis jeg ser på de 2 lister i det andet niveau derovre

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 og 15, er de ikke sorteret.

970
00:59:51,640 --> 00:59:55,770
Så hvis jeg ser på 50 og 1337, vil jeg sætte 50 ind i min liste først.

971
00:59:55,770 --> 01:00:00,130
Men det betyder ikke rigtig mening, fordi 3 er det mindste element ud af alle disse.

972
01:00:00,130 --> 01:00:04,390
Så den eneste grund, vi kan gøre dette kombinere trin er fordi vores lister allerede er sorteret.

973
01:00:04,390 --> 01:00:07,010
Det er derfor vi er nødt til at komme ned hele vejen til bunden

974
01:00:07,010 --> 01:00:09,800
fordi når vi har bare et enkelt tal, du ved, at et enkelt tal

975
01:00:09,800 --> 01:00:14,120
i sig selv allerede er sorteret liste.

976
01:00:14,120 --> 01:00:19,360
>> Eventuelle spørgsmål? Nej?

977
01:00:19,360 --> 01:00:24,260
Kompleksitet? Nå, kan du se, at der på hvert trin er der ende numre,

978
01:00:24,260 --> 01:00:27,590
og vi kan opdele en liste i halvdelen log n gange,

979
01:00:27,590 --> 01:00:31,700
hvilket er hvor vi får denne n x log n kompleksitet.

980
01:00:31,700 --> 01:00:34,940
Og du vil se det bedste fald for fletningen slags er n log n, og det bare så sker

981
01:00:34,940 --> 01:00:39,340
at den værst tænkelige, eller Ω derovre, er også n log n.

982
01:00:39,340 --> 01:00:42,480
Noget at holde sig for øje.

983
01:00:42,480 --> 01:00:45,750
Bevæger sig på, os gå videre til nogle super basic fil I / O. lade

984
01:00:45,750 --> 01:00:48,830
Hvis du har kigget på Scramble, vil du bemærke at vi havde en slags system,

985
01:00:48,830 --> 01:00:51,270
hvor man kunne skrive til en logfil, hvis du læser igennem koden.

986
01:00:51,270 --> 01:00:53,730
Lad os se, hvordan du kan gøre det.

987
01:00:53,730 --> 01:00:57,450
Nuvel, vi har fprintf, som du kan tænke på som bare printf,

988
01:00:57,450 --> 01:01:01,720
men blot at udskrive til en fil i stedet, og dermed f i begyndelsen.

989
01:01:01,720 --> 01:01:07,570
Denne form for kode op her, hvad det gør, er, som du måske har set i Scramble,

990
01:01:07,570 --> 01:01:12,310
det går igennem din 2-dimensionelle række udprintning rækkevis hvad tallene er.

991
01:01:12,310 --> 01:01:17,850
I dette tilfælde udskriver printf ud til din terminal eller det, vi kalder standard output af afsnittet.

992
01:01:17,850 --> 01:01:22,170
>> Og nu, i dette tilfælde, er alt hvad vi har at gøre erstatte printf med fprintf,

993
01:01:22,170 --> 01:01:26,770
fortælle, hvad fil, du vil udskrive til, og i dette tilfælde er det bare udskriver det til filen

994
01:01:26,770 --> 01:01:32,230
i stedet for at printe det ud til din terminal.

995
01:01:32,230 --> 01:01:36,500
Nå, så det rejser spørgsmålet: Hvor får vi denne form for fil fra, ikke?

996
01:01:36,500 --> 01:01:39,840
Vi passerede logge på denne fprintf fuction men vi havde ingen idé om, hvor det kom fra.

997
01:01:39,840 --> 01:01:43,980
Nå, tidligt i koden, hvad vi havde, var dette stykke kode herovre,

998
01:01:43,980 --> 01:01:48,340
som dybest set siger, at åbne filen kalder log.txt.

999
01:01:48,340 --> 01:01:53,220
Hvad vi gør efter det er vi nødt til at sørge for, at filen rent faktisk er åbnet med succes.

1000
01:01:53,220 --> 01:01:57,070
Så det kan mislykkes af flere årsager, og du ikke har nok plads på din computer, for eksempel.

1001
01:01:57,070 --> 01:01:59,790
Så det er altid vigtigt, før du gør alle operationer med filen

1002
01:01:59,790 --> 01:02:03,300
at vi kontrollere, om den pågældende fil blev åbnet med succes.

1003
01:02:03,300 --> 01:02:09,330
Så hvad at A, der er et argument for fopen, godt, vi kan åbne en fil på mange måder.

1004
01:02:09,330 --> 01:02:13,510
Hvad vi kan gøre er, kan vi give det w, hvilket betyder tilsidesætte filen, hvis det kommer ud allerede,

1005
01:02:13,510 --> 01:02:18,070
Vi kan passere en a, som de føjes til slutningen af ​​filen i stedet for tvingende det,

1006
01:02:18,070 --> 01:02:22,730
eller vi kan specificere r, hvilket betyder, lad os åbne filen som skrivebeskyttet.

1007
01:02:22,730 --> 01:02:24,890
Så hvis programmet forsøger at foretage ændringer i filen,

1008
01:02:24,890 --> 01:02:30,140
råber ad dem og ikke lade dem gøre det.

1009
01:02:30,140 --> 01:02:33,320
Endelig, når vi er færdig med filen, færdig med at gøre operationer på det,

1010
01:02:33,320 --> 01:02:35,860
vi nødt til at sikre, at vi lukker filen.

1011
01:02:35,860 --> 01:02:38,830
Og så i slutningen af ​​dit program, kan du komme til at passere dem igen

1012
01:02:38,830 --> 01:02:42,120
denne fil, du har åbnet, og bare lukke den.

1013
01:02:42,120 --> 01:02:44,650
Så det er noget vigtigt, at du er nødt til at sikre, at du gør.

1014
01:02:44,650 --> 01:02:47,180
Så husk du kan åbne en fil, så kan du skrive til filen,

1015
01:02:47,180 --> 01:02:51,270
udfører operationer i filen, men så er du nødt til at afslutte sagen i slutningen.

1016
01:02:51,270 --> 01:02:53,270
>> Eventuelle spørgsmål vedrørende grundlæggende filbaseret I / O? Ja?

1017
01:02:53,270 --> 01:02:58,050
[Student spørgsmål, uforståelig]

1018
01:02:58,050 --> 01:03:02,480
Lige her. Spørgsmålet er så, hvor denne Log.txt vist?

1019
01:03:02,480 --> 01:03:07,890
Tja, hvis du bare give det log.txt, det skaber det i samme mappe som den eksekverbare.

1020
01:03:07,890 --> 01:03:10,500
Så hvis Du er - >> [Student spørgsmål, uforståelig]

1021
01:03:10,500 --> 01:03:18,830
Ja. I den samme mappe, eller i den samme mappe. Som du kalder det

1022
01:03:18,830 --> 01:03:21,400
Nu hukommelse, stack, og bunke.

1023
01:03:21,400 --> 01:03:23,400
Så hvordan er hukommelse fastlagt i computeren?

1024
01:03:23,400 --> 01:03:26,270
Nå, kan du forestille dig hukommelse som en slags af denne blok her.

1025
01:03:26,270 --> 01:03:30,260
Og i hukommelsen har vi hvad der kaldes den bunke fast derovre, og den stak, der er dernede.

1026
01:03:30,260 --> 01:03:34,480
Og heap vokser nedad og stablen vokser opad.

1027
01:03:34,480 --> 01:03:38,620
Så som Tommy nævnte - oh, ja, og vi har disse andre 4 segmenter, som jeg vil komme til i en anden -

1028
01:03:38,620 --> 01:03:42,890
Som Tommy sagde tidligere, du ved, hvordan hans funktioner kalder sig og kalder hinanden?

1029
01:03:42,890 --> 01:03:44,930
De opbygger denne form for stakramme.

1030
01:03:44,930 --> 01:03:47,360
Tja, hvis de vigtigste opkald foo, bliver Foo sat på stakken.

1031
01:03:47,360 --> 01:03:52,430
Foo kalder bar, bar få os sætte på stakken, og der bliver lagt på stakken efter.

1032
01:03:52,430 --> 01:03:57,040
Og da de vender tilbage, de hver få taget fra stakken.

1033
01:03:57,040 --> 01:04:00,140
Hvad har hver af disse steder og hukommelse holde?

1034
01:04:00,140 --> 01:04:03,110
Godt, toppen, som er tekstsegment, indeholder selve programmet.

1035
01:04:03,110 --> 01:04:06,390
Så maskinkode, der er der, når du kompilere dit program.

1036
01:04:06,390 --> 01:04:08,520
Dernæst enhver startværdi globale variable.

1037
01:04:08,520 --> 01:04:12,660
>> Så du har globale variabler i dit program, og du siger ligesom, a = 5,

1038
01:04:12,660 --> 01:04:15,260
der bliver lagt i dette segment, og lige under det,

1039
01:04:15,260 --> 01:04:18,990
du har initialiserede globale data, som er lige int a,

1040
01:04:18,990 --> 01:04:20,990
men du behøver ikke sige det er lig med noget.

1041
01:04:20,990 --> 01:04:23,870
Indse disse er globale variabler, så de er uden for main.

1042
01:04:23,870 --> 01:04:28,560
Så det betyder nogen globale variabler, der angives, men er ikke initialiseret.

1043
01:04:28,560 --> 01:04:32,310
Så hvad der er i bunke? Memory fordeles efter malloc, som vi vil komme til i en lille smule.

1044
01:04:32,310 --> 01:04:35,990
Og endelig, med stakken du har nogen lokale variable

1045
01:04:35,990 --> 01:04:39,950
og alle funktioner man kunne kalde i nogen af ​​deres parametre.

1046
01:04:39,950 --> 01:04:43,720
Den sidste ting, behøver du ikke virkelig nødt til at vide, hvad de miljøvariabler gør,

1047
01:04:43,720 --> 01:04:46,700
men hver gang du kører programmet, der er forbundet noget, som

1048
01:04:46,700 --> 01:04:49,550
Dette er brugernavnet på den person, der kørte programmet.

1049
01:04:49,550 --> 01:04:51,550
Og det kommer til at blive slags i bunden.

1050
01:04:51,550 --> 01:04:54,540
I form af hukommelsesadresser, som er hexadecimale værdier,

1051
01:04:54,540 --> 01:04:58,170
værdierne ved det øverste begyndelse ved 0, og de går hele vejen ned til bunden.

1052
01:04:58,170 --> 01:05:00,440
I dette tilfælde, hvis du er på 32-bit system

1053
01:05:00,440 --> 01:05:05,390
adressen i bunden bliver 0x, efterfulgt af AF, fordi det er 32 bits,

1054
01:05:05,390 --> 01:05:10,890
som er otte bytes, og i dette tilfælde 8 byte svarer til 8 hexadecimale cifre.

1055
01:05:10,890 --> 01:05:20,110
Så hernede du vil have, ligesom, 0xffffff, og deroppe du vil have 0.

1056
01:05:20,110 --> 01:05:23,660
Så hvad er henvisninger? Nogle af jer har måske ikke dækket dette i afsnittet før.

1057
01:05:23,660 --> 01:05:26,660
men vi gik over det i forelæsning, så en pointer er blot en datatype

1058
01:05:26,660 --> 01:05:34,030
som lagrer i stedet for en form for værdi som 50, lagrer adressen på en lokation i hukommelsen.

1059
01:05:34,030 --> 01:05:36,020
Ligesom det minde [uforståelig].

1060
01:05:36,020 --> 01:05:41,120
Så i dette tilfælde, hvad vi har, er, at vi har en pegepind til et heltal eller en int *,

1061
01:05:41,120 --> 01:05:46,210
og den indeholder det hexadecimale adresse 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Så hvad vi har, er, nu, denne pointer peger på en placering i hukommelsen,

1063
01:05:50,880 --> 01:05:56,020
og det er bare en, værdien 50 er på denne hukommelsesplads.

1064
01:05:56,020 --> 01:06:01,810
På nogle 32-bit systemer, på alle 32-bit systemer pointers tage op 32 bits eller 4 bytes.

1065
01:06:01,810 --> 01:06:06,020
Men, for eksempel på en 64-bit-system, er henvisninger 64 bit.

1066
01:06:06,020 --> 01:06:08,040
Så det er noget, du ønsker at holde sig for øje.

1067
01:06:08,040 --> 01:06:12,310
Så på en ende-bit system er en pointer ende bit lang.

1068
01:06:12,310 --> 01:06:17,320
Pointers er slags svært at fordøje uden ekstra ting,

1069
01:06:17,320 --> 01:06:20,300
så lad os gå igennem et eksempel på dynamisk allokering af hukommelse.

1070
01:06:20,300 --> 01:06:25,130
Hvad dynamisk allokering af hukommelse gør for dig, eller hvad vi kalder malloc,

1071
01:06:25,130 --> 01:06:29,280
det kan du tildele en form for data uden for sættet.

1072
01:06:29,280 --> 01:06:31,830
Så disse data er slags mere permanent i hele programmet.

1073
01:06:31,830 --> 01:06:36,430
Fordi som du ved, hvis du erklærer x inde i en funktion, og at funktionen returnerer

1074
01:06:36,430 --> 01:06:40,910
du ikke længere har adgang til de data, der blev gemt i x.

1075
01:06:40,910 --> 01:06:44,420
Hvad pointers lad os gøre, er de Lad os gemme hukommelse eller lagre værdier

1076
01:06:44,420 --> 01:06:46,840
i et andet segment af hukommelse, nemlig heap.

1077
01:06:46,840 --> 01:06:49,340
Nu når vi igen ud af funktion, så længe vi har en pointer

1078
01:06:49,340 --> 01:06:54,960
til den pågældende placering i hukommelsen, hvad vi kan gøre så er vi bare kan se på de værdier der.

1079
01:06:54,960 --> 01:06:58,020
Lad os se på et eksempel: Dette er vores hukommelse layout igen.

1080
01:06:58,020 --> 01:07:00,050
Og vi har denne funktion, vigtigste.

1081
01:07:00,050 --> 01:07:06,870
Hvad det gør, er - okay, så simpelt, ikke -? Int x = 5, det er bare en variabel på stakken i main.

1082
01:07:06,870 --> 01:07:12,450
>> På den anden side, vi nu erklære en pointer, der kalder funktionen giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
Og så nu går vi ind i denne funktion, og vi skaber en ny stak ramme for det.

1084
01:07:16,800 --> 01:07:20,440
Men i denne stakramme, erklærer vi int * temp,

1085
01:07:20,440 --> 01:07:23,210
som i mallocs 3 heltal for os.

1086
01:07:23,210 --> 01:07:25,880
Så størrelse int vil give os hvor mange bytes denne int er,

1087
01:07:25,880 --> 01:07:29,620
og malloc giver os, at mange bytes af plads på heapen.

1088
01:07:29,620 --> 01:07:32,890
Så i dette tilfælde har vi skabt plads til 3 heltal,

1089
01:07:32,890 --> 01:07:36,830
og den bunke er vejen derop, hvilket er grunden til jeg har tegnet det højere op.

1090
01:07:36,830 --> 01:07:42,900
Når vi er færdige, kommer vi tilbage op her, behøver du kun 3 int'er returneret,

1091
01:07:42,900 --> 01:07:47,000
og det returnerer adressen, i dette tilfælde over, hvor denne hukommelse er.

1092
01:07:47,000 --> 01:07:51,250
Og vi sætter pointer = switch, og op der har vi bare en anden pointer.

1093
01:07:51,250 --> 01:07:54,550
Men hvad der returnerer funktionen er stablet her og forsvinder.

1094
01:07:54,550 --> 01:07:59,250
Så temp forsvinder, men vi stadig bevare adressen på hvor

1095
01:07:59,250 --> 01:08:01,850
disse 3 heltal er inde i elnettet.

1096
01:08:01,850 --> 01:08:06,180
Så i dette sæt er markørerne scoped lokalt til den stablede rammen,

1097
01:08:06,180 --> 01:08:09,860
men hukommelsen, de henviser til, er i dyngen.

1098
01:08:09,860 --> 01:08:12,190
>> Giver det mening?

1099
01:08:12,190 --> 01:08:14,960
[Student] Kunne du gentage det? >> [Joseph] Ja.

1100
01:08:14,960 --> 01:08:20,270
Så hvis jeg går tilbage bare en lille smule, kan du se at temp tildelt

1101
01:08:20,270 --> 01:08:23,500
noget hukommelse på heapen deroppe.

1102
01:08:23,500 --> 01:08:28,680
Så når denne funktion, giveMeThreeInts afkast, er denne stak her kommer til at forsvinde.

1103
01:08:28,680 --> 01:08:35,819
Og med det som helst af de variabler, i dette tilfælde den pointer, der blev tildelt i stablet ramme.

1104
01:08:35,819 --> 01:08:39,649
Det kommer til at forsvinde, men da vi vendte temp

1105
01:08:39,649 --> 01:08:46,330
og vi sætter pointer = temp, pointer er nu kommer til at pege samme hukommelse placering som temp var.

1106
01:08:46,330 --> 01:08:50,370
Så nu, selvom vi mister temp, at lokale pointer,

1107
01:08:50,370 --> 01:08:59,109
vi stadig bevare lageradressen af, hvad det var der peger på indersiden af ​​det variable pointer.

1108
01:08:59,109 --> 01:09:03,740
Spørgsmål? Det kan være lidt af en forvirrende emne, hvis du ikke har gået over det i pkt.

1109
01:09:03,740 --> 01:09:09,240
Vi kan, vil din TF helt sikkert gå over det, og vi kan selvfølgelig besvare spørgsmål

1110
01:09:09,240 --> 01:09:11,500
ved slutningen af ​​undersøgelsen session for dette.

1111
01:09:11,500 --> 01:09:14,220
Men det er en slags et komplekst emne, og jeg har flere eksempler på, at der kommer til at dukke op

1112
01:09:14,220 --> 01:09:18,790
som vil bidrage til at afklare, hvad pegepinde egentlig er.

1113
01:09:18,790 --> 01:09:22,500
>> I dette tilfælde er henvisninger svarer til arrays,

1114
01:09:22,500 --> 01:09:25,229
så jeg kan bare bruge denne pegepind som det samme som en int array.

1115
01:09:25,229 --> 01:09:29,840
Så jeg indeksering i 0, og ændre det første heltal til 1,

1116
01:09:29,840 --> 01:09:39,689
ændre den anden heltal til 2, og 3. heltal til 3.

1117
01:09:39,689 --> 01:09:44,210
Så mere om pegepinde. Nå, huske Binky.

1118
01:09:44,210 --> 01:09:48,319
I dette tilfælde har vi tildelt en pegepind, eller vi erklæret en pegepind,

1119
01:09:48,319 --> 01:09:52,760
men i første omgang, da jeg netop erklæret en pegepind, er det ikke peger på et vilkårligt sted i hukommelsen.

1120
01:09:52,760 --> 01:09:54,930
Det er bare skrald værdier indeni det.

1121
01:09:54,930 --> 01:09:56,470
Så jeg har ingen idé om, hvor denne pointer peger på.

1122
01:09:56,470 --> 01:10:01,630
Det har en adresse, som bare fyldt med 0 s og 1 s, hvor det oprindeligt blev anmeldt.

1123
01:10:01,630 --> 01:10:04,810
Jeg kan ikke gøre noget med dette, indtil jeg kalder malloc på det

1124
01:10:04,810 --> 01:10:08,390
og så det giver mig lidt plads på heapen, hvor jeg kan sætte værdier inde.

1125
01:10:08,390 --> 01:10:11,980
Så igen, jeg ved ikke, hvad der er inde i denne hukommelse.

1126
01:10:11,980 --> 01:10:16,780
Så det første jeg skal gøre er at kontrollere, om systemet havde nok hukommelse

1127
01:10:16,780 --> 01:10:20,850
at give mig tilbage 1 heltal i første omgang, hvilket er grunden til jeg gør dette tjek.

1128
01:10:20,850 --> 01:10:25,020
Hvis pointer er null, det betyder, at det ikke har nok plads eller en anden fejl opstod,

1129
01:10:25,020 --> 01:10:26,320
så jeg skulle afslutte ud af mit program.

1130
01:10:26,320 --> 01:10:29,400
 Men hvis det lykkedes, nu kan jeg bruge denne pegepind

1131
01:10:29,400 --> 01:10:35,020
og hvad * pointer gør, er det følger hvor adressen er

1132
01:10:35,020 --> 01:10:38,480
hvor denne værdi er, og det sætter det lig med 1.

1133
01:10:38,480 --> 01:10:41,850
Så over her, vi tjekker, om at hukommelsen eksisterede.

1134
01:10:41,850 --> 01:10:45,380
>> Når du ved det eksisterer, kan du sætte ind i det

1135
01:10:45,380 --> 01:10:50,460
hvilken værdi, du ønsker at sætte ind i det, i dette tilfælde 1.

1136
01:10:50,460 --> 01:10:53,060
Når vi er færdig med det, skal du frigøre denne pegepind

1137
01:10:53,060 --> 01:10:57,160
fordi vi har brug for at komme tilbage til det system, som hukommelse, som du bad om i første omgang.

1138
01:10:57,160 --> 01:10:59,690
Fordi computeren ikke vide, hvornår vi er færdige med det.

1139
01:10:59,690 --> 01:11:02,510
I dette tilfælde er vi eksplicit at fortælle det, okay, vi er færdige med denne hukommelse.

1140
01:11:02,510 --> 01:11:10,780
Hvis en anden proces har brug for det, et andet program har behov for det, er du velkommen til at gå videre og tage den.

1141
01:11:10,780 --> 01:11:15,110
Hvad kan vi også gøre, er at vi bare kan få adressen på lokale variable på tv'et.

1142
01:11:15,110 --> 01:11:19,080
Så int x er inde i stablet ramme main.

1143
01:11:19,080 --> 01:11:23,060
Og når vi bruger dette tegnet, denne og operatør, hvad det gør, er

1144
01:11:23,060 --> 01:11:27,310
det tager x, og x er blot nogle data i hukommelse, men den har en adresse.

1145
01:11:27,310 --> 01:11:33,790
Det er placeret et eller andet sted. Så ved at ringe & x, hvad dette gør, er at det giver os adressen på x.

1146
01:11:33,790 --> 01:11:38,430
Ved at gøre dette, gør vi pointer pege på hvor x er i hukommelsen.

1147
01:11:38,430 --> 01:11:41,710
Nu skal vi bare gøre noget lignende * x, vi kommer til at få 5 tilbage.

1148
01:11:41,710 --> 01:11:43,820
Stjernen hedder dereferere det.

1149
01:11:43,820 --> 01:11:46,640
Du følger den adresse, og du får værdien af ​​det gemt der.

1150
01:11:51,000 --> 01:11:53,310
>> Eventuelle spørgsmål? Ja?

1151
01:11:53,310 --> 01:11:56,500
[Student] Hvis du ikke gør det 3-spidse ting, betyder det stadig kompilere?

1152
01:11:56,500 --> 01:11:59,490
Ja. Hvis du ikke gør det 3-pointer ting, er det stadig kommer til at kompilere,

1153
01:11:59,490 --> 01:12:02,720
men jeg vil vise dig, hvad der sker i en anden, og uden at gøre det,

1154
01:12:02,720 --> 01:12:04,860
det er hvad vi kalder en hukommelsesfejl. Du er ikke giver systemet

1155
01:12:04,860 --> 01:12:07,850
bakke sin hukommelse, så efter et stykke tid at programmet kommer til at akkumulere

1156
01:12:07,850 --> 01:12:10,940
hukommelse, det er ikke bruger, og intet andet kan bruge det.

1157
01:12:10,940 --> 01:12:15,750
Hvis du nogensinde har set Firefox med 1,5 millioner kilobyte på din computer,

1158
01:12:15,750 --> 01:12:17,840
i opgaven manager, er det, hvad der foregår.

1159
01:12:17,840 --> 01:12:20,760
Du har en hukommelsesfejl i programmet, at de ikke er håndtering.

1160
01:12:23,080 --> 01:12:26,240
Så hvordan gør pointer aritmetiske arbejde?

1161
01:12:26,240 --> 01:12:29,480
Nå, pointer Regnestykket er lidt ligesom indeksering i et array.

1162
01:12:29,480 --> 01:12:36,370
I dette tilfælde har jeg en pegepind, og hvad jeg gør, er jeg gøre pointer peger på det første element

1163
01:12:36,370 --> 01:12:42,100
af denne række af 3 heltal, som jeg har tildelt.

1164
01:12:42,100 --> 01:12:46,670
Så nu hvad jeg gør, stjerne pointer bare ændrer det første element i listen.

1165
01:12:46,670 --> 01:12:49,140
Stjerne pointer +1 point herovre.

1166
01:12:49,140 --> 01:12:53,140
Så pointer er herovre, pointer +1 er herovre, pointer +2 er herovre.

1167
01:12:53,140 --> 01:12:56,610
>> Så bare tilsætte 1 er det samme som at bevæge sig langs denne array.

1168
01:12:56,610 --> 01:12:59,880
Hvad vi gør, er, når vi gør pointer +1 Du får adressen herover,

1169
01:12:59,880 --> 01:13:04,180
og for at få værdien herind, satte man en stjerne i fra hele udtrykket

1170
01:13:04,180 --> 01:13:05,990
at dereference det.

1171
01:13:05,990 --> 01:13:09,940
Så i dette tilfælde, jeg sætte den første plads i dette array til 1,

1172
01:13:09,940 --> 01:13:13,970
anden placering til 2, og tredje placering til 3.

1173
01:13:13,970 --> 01:13:18,180
Så hvad jeg laver herovre er jeg udskriver vores pointer +1,

1174
01:13:18,180 --> 01:13:19,970
der bare giver mig 2.

1175
01:13:19,970 --> 01:13:23,650
Nu er jeg forøgelse pointer, så markøren er lig pointer +1,

1176
01:13:23,650 --> 01:13:26,780
der bevæger det fremad.

1177
01:13:26,780 --> 01:13:30,810
Og så nu, hvis jeg udskrive pointer +1, pointer +1 er nu 3,

1178
01:13:30,810 --> 01:13:33,990
som i dette tilfælde udskrives 3.

1179
01:13:33,990 --> 01:13:36,560
Og for at frigøre noget, den pointer, jeg giver det

1180
01:13:36,560 --> 01:13:40,540
skal pege i begyndelsen af ​​det array, som jeg fik tilbage fra malloc.

1181
01:13:40,540 --> 01:13:43,430
Så i dette tilfælde, hvis jeg skulle kalde 3 lige her, ville dette ikke være rigtigt,

1182
01:13:43,430 --> 01:13:45,070
fordi det er i midten af ​​array.

1183
01:13:45,070 --> 01:13:48,820
Jeg er nødt til at fratrække at komme til den oprindelige placering

1184
01:13:48,820 --> 01:13:50,420
den oprindelige første stedet, før jeg kan frigøre det.

1185
01:13:56,300 --> 01:13:58,450
Så her er en mere involveret eksempel.

1186
01:13:58,450 --> 01:14:03,360
I dette tilfælde er vi afsætte 7 tegn i en karakter array.

1187
01:14:03,360 --> 01:14:06,480
>> Og i dette tilfælde, hvad vi laver, er vi looping over den første 6 af dem,

1188
01:14:06,480 --> 01:14:09,900
og vi indstille dem til Z.

1189
01:14:09,900 --> 01:14:13,350
Så for int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Så pointer + jeg vil bare give os, i dette tilfælde,

1191
01:14:16,220 --> 01:14:20,860
pointer, pointer 1, pointer to, pointer 3, og så videre og så videre i sløjfen.

1192
01:14:20,860 --> 01:14:24,040
Hvad det kommer til at gøre, er det får denne adresse, dereferences det for at få den værdi,

1193
01:14:24,040 --> 01:14:27,440
og ændringer, som værdi til en Z.

1194
01:14:27,440 --> 01:14:30,350
Så i slutningen huske dette er en streng, right?

1195
01:14:30,350 --> 01:14:33,560
Alle strengene er nødt til at ende med nul afslutning karakter.

1196
01:14:33,560 --> 01:14:38,620
Så, hvad jeg gør, er i pegepinden 6 Jeg sætter null terminator karakter i.

1197
01:14:38,620 --> 01:14:43,980
Og nu hvad jeg dybest set laver herovre er ved at implementere printf efter en streng, ikke?

1198
01:14:43,980 --> 01:14:46,190
>> Så, når printf nu, når det er nået til enden af ​​en snor?

1199
01:14:46,190 --> 01:14:48,230
Når den rammer nul afslutning karakter.

1200
01:14:48,230 --> 01:14:52,030
Så i dette tilfælde. Mine oprindelige pointer peger på starten af ​​dette array

1201
01:14:52,030 --> 01:14:56,410
Jeg udskriver det første tegn ud. Jeg flytter den hen over en.

1202
01:14:56,410 --> 01:14:58,420
Jeg udskrive denne karakter ud. Jeg flytte den over.

1203
01:14:58,420 --> 01:15:02,180
Og jeg holde gøre dette indtil jeg når til slutningen.

1204
01:15:02,180 --> 01:15:07,750
Og nu enden * pointer vil dereference dette og få nul afslutning karakter tilbage.

1205
01:15:07,750 --> 01:15:11,780
Og så min while-løkke kører kun, når denne værdi ikke er den nul afslutning karakter.

1206
01:15:11,780 --> 01:15:13,770
Så, nu jeg afslutte ud af denne løkke.

1207
01:15:18,780 --> 01:15:21,180
Og så hvis jeg trækker 6 fra denne pointer,

1208
01:15:21,180 --> 01:15:22,860
Jeg går helt tilbage til begyndelsen.

1209
01:15:22,860 --> 01:15:27,880
Husk, jeg gør det, fordi jeg er nødt til at gå til starten for at frigøre det.

1210
01:15:27,880 --> 01:15:30,270
>> Så jeg ved, det var en masse. Er der nogen spørgsmål?

1211
01:15:30,270 --> 01:15:31,870
Please, ja?

1212
01:15:31,870 --> 01:15:36,610
[Student spørgsmål uforståelig]

1213
01:15:36,610 --> 01:15:38,190
Kan du sige det højere? Undskyld.

1214
01:15:38,190 --> 01:15:44,140
[Student] Den sidste slide lige før du befriet markøren,

1215
01:15:44,140 --> 01:15:47,300
hvor var du faktisk at ændre værdien af ​​markøren?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Så lige her. >> [Student] Åh, okay.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Så jeg har en pegepind minus minus, højre,

1218
01:15:51,890 --> 01:15:54,140
som bevæger ting tilbage en, og så skal jeg befri det,

1219
01:15:54,140 --> 01:15:57,000
fordi denne pointer skal understreges til begyndelsen af ​​array.

1220
01:15:57,000 --> 01:16:00,420
[Student] Men det ville ikke være nødvendig havde du stoppet efter denne linje.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Så hvis jeg havde stoppet efter dette, ville det blive betragtet som en hukommelsesfejl,

1222
01:16:03,130 --> 01:16:04,810
fordi jeg ikke køre den gratis.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [uforståelig] efter de første tre linjer, hvor du havde pointer +1 [uforståelig].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Så, hvad er det spørgsmål der?

1225
01:16:13,140 --> 01:16:14,780
Undskyld. Nej, nej. Gå, gå, tak.

1226
01:16:14,780 --> 01:16:16,870
[Student] Så er du ikke ændre værdien af ​​pegepinde.

1227
01:16:16,870 --> 01:16:19,130
Du ville ikke have haft at gøre pointer minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ja, præcis.

1229
01:16:19,730 --> 01:16:21,890
Så når jeg gør pointer +1 og pointer +2,

1230
01:16:21,890 --> 01:16:24,410
Jeg laver ikke pointer lig pointer +1.

1231
01:16:24,410 --> 01:16:27,260
Således, markøren blot forbliver peger i begyndelsen af ​​grupperingen.

1232
01:16:27,260 --> 01:16:31,460
Det er kun, når jeg gør plus plus at det sætter værdi tilbage inde i markøren,

1233
01:16:31,460 --> 01:16:33,550
at det faktisk bevæger denne sammen.

1234
01:16:36,860 --> 01:16:37,780
Ok.

1235
01:16:40,550 --> 01:16:42,030
Flere spørgsmål?

1236
01:16:44,680 --> 01:16:47,790
>> Igen, hvis det er en slags overvældende, vil dette blive dækket i session.

1237
01:16:47,790 --> 01:16:50,710
Spørg din undervisning fyr om det, og vi kan besvare spørgsmål i slutningen.

1238
01:16:53,510 --> 01:16:56,600
Og normalt er vi ikke kan lide at gøre det minus ting.

1239
01:16:56,600 --> 01:16:59,760
Dette har at kræve mig at holde styr på, hvor meget jeg har forskudt i array.

1240
01:16:59,760 --> 01:17:04,520
Så generelt er det bare at forklare, hvordan pointer aritmetiske værker.

1241
01:17:04,520 --> 01:17:07,970
Men hvad vi normalt gerne gøre, er at vi gerne skabe en kopi af markøren,

1242
01:17:07,970 --> 01:17:11,640
og så vil vi bruge den kopi, når vi bevæger os rundt i strengen.

1243
01:17:11,640 --> 01:17:14,660
Så i disse tilfælde du bruge kopien til at udskrive hele strengen,

1244
01:17:14,660 --> 01:17:19,040
men vi behøver ikke at gøre som pointer minus 6 eller holde styr på, hvor meget vi flyttede i dette,

1245
01:17:19,040 --> 01:17:22,700
bare fordi vi ved, at vores oprindelige punkt stadig bliver peget på i starten af ​​listen

1246
01:17:22,700 --> 01:17:25,340
og alt, hvad vi ændrede var denne kopi.

1247
01:17:25,340 --> 01:17:28,250
Så generelt ændre kopier af din oprindelige pointer.

1248
01:17:28,250 --> 01:17:32,350
Forsøg ikke at sortere i lignende - lad være at ændre originale kopier.

1249
01:17:32,350 --> 01:17:35,290
Forsøger at ændre kun kopier af din original.

1250
01:17:41,540 --> 01:17:44,870
Så du bemærker, når vi passerer strengen i printf

1251
01:17:44,870 --> 01:17:48,990
du behøver ikke at sætte en stjerne foran det ligesom vi gjorde med alle de andre dereferences, right?

1252
01:17:48,990 --> 01:17:54,180
Så hvis du udskrive hele strengen% s forventer er en adresse,

1253
01:17:54,180 --> 01:17:57,610
og i dette tilfælde en pegepind eller i dette tilfælde som en række tegn.

1254
01:17:57,610 --> 01:18:00,330
>> Tegn, char * s, og arrays er de samme ting.

1255
01:18:00,330 --> 01:18:03,690
Pointer er til tegn, og tegndatatabeller er det samme.

1256
01:18:03,690 --> 01:18:05,720
Og så er alt, hvad vi skal gøre passere i pointer.

1257
01:18:05,720 --> 01:18:08,150
Vi behøver ikke at passere ind som * pegepind eller sådan noget.

1258
01:18:13,110 --> 01:18:14,930
Så, arrays og pointers er de samme ting.

1259
01:18:14,930 --> 01:18:19,160
Når du laver noget lignende x [y] herovre for et array,

1260
01:18:19,160 --> 01:18:21,960
hvad det gør under kølerhjelmen er det siger, okay, det er et tegn array,

1261
01:18:21,960 --> 01:18:23,690
så det er en pointer.

1262
01:18:23,690 --> 01:18:26,510
Og så x er de samme ting,

1263
01:18:26,510 --> 01:18:28,650
og så hvad det gør, er det tilføjer y til x,

1264
01:18:28,650 --> 01:18:31,820
hvilket er det samme som at bevæge sig fremad i hukommelsen så meget.

1265
01:18:31,820 --> 01:18:34,930
Og nu x + y giver os en slags adresse,

1266
01:18:34,930 --> 01:18:37,570
og vi dereference adresse eller følg pilen

1267
01:18:37,570 --> 01:18:41,640
hvor denne placering i hukommelsen er, og vi får værdi ud af denne placering i hukommelsen.

1268
01:18:41,640 --> 01:18:43,720
Så, så disse to er nøjagtig det samme.

1269
01:18:43,720 --> 01:18:45,840
Det er bare en syntaktisk sukker.

1270
01:18:45,840 --> 01:18:48,090
De gør det samme. De er bare forskellige syntactics for hinanden.

1271
01:18:51,500 --> 01:18:57,590
>> Så hvad kan gå galt med pointers? Ligesom en masse. Okay. Så dårlige ting.

1272
01:18:57,590 --> 01:19:02,410
Nogle dårlige ting, du kan gøre, er ikke at kontrollere, om din malloc kaldet returnerer null, right?

1273
01:19:02,410 --> 01:19:06,560
I dette tilfælde, jeg beder systemet til at give mig - hvad er det nummer?

1274
01:19:06,560 --> 01:19:11,200
Ligesom 2000000000 gange 4, fordi størrelsen af ​​et helt tal er fire bytes.

1275
01:19:11,200 --> 01:19:13,810
Jeg beder det om som 8 milliard bytes.

1276
01:19:13,810 --> 01:19:17,270
Selvfølgelig min computer ikke vil være i stand til at give mig så meget hukommelse tilbage.

1277
01:19:17,270 --> 01:19:20,960
Og vi ikke kontrollere, om dette er null, så når vi forsøger at dereference det derovre -

1278
01:19:20,960 --> 01:19:24,270
Følg pilen til, hvor det kommer til at - vi ikke har den hukommelse.

1279
01:19:24,270 --> 01:19:27,150
Det er, hvad vi kalder dereferere en null-pointer.

1280
01:19:27,150 --> 01:19:29,710
Og det væsentlige får dig til at segfault.

1281
01:19:29,710 --> 01:19:31,790
Dette er en af ​​de måder, du kan segfault.

1282
01:19:34,090 --> 01:19:38,090
Andre dårlige ting du kan gøre - oh well.

1283
01:19:38,090 --> 01:19:40,650
Det var dereferere en null-pointer. Okay.

1284
01:19:40,650 --> 01:19:45,160
Andre dårlige ting - godt, at fastsætte, at du bare sætte en check i der

1285
01:19:45,160 --> 01:19:46,980
som kontrollerer, om markøren er null

1286
01:19:46,980 --> 01:19:51,000
og afslutte ud af programmet, hvis det sker, at malloc returnerer en null-pointer.

1287
01:19:55,110 --> 01:19:59,850
Det er den xkcd tegneserie. Folk forstår det nu. Sorter af.

1288
01:20:06,120 --> 01:20:09,350
>> Så hukommelse. Og jeg gik over dette.

1289
01:20:09,350 --> 01:20:12,000
Vi kalder malloc i en løkke, men hver gang vi kalder malloc

1290
01:20:12,000 --> 01:20:14,370
vi at miste overblikket over, hvor denne pegepind peger på,

1291
01:20:14,370 --> 01:20:15,750
fordi vi clobbering det.

1292
01:20:15,750 --> 01:20:18,410
Så det første opkald til malloc giver mig hukommelse herovre.

1293
01:20:18,410 --> 01:20:19,990
Min pointer henvisninger til dette.

1294
01:20:19,990 --> 01:20:23,020
Nu mener jeg ikke frigøre det, så nu kalder jeg malloc igen.

1295
01:20:23,020 --> 01:20:26,070
Nu peger herovre. Nu er min hukommelse peger herovre.

1296
01:20:26,070 --> 01:20:27,640
Pege herovre. Pege herovre.

1297
01:20:27,640 --> 01:20:31,820
Men jeg har mistet overblikket over adresserne på hele hukommelsen herovre at jeg tildelt.

1298
01:20:31,820 --> 01:20:35,100
Og så nu jeg har ikke nogen henvisning til dem længere.

1299
01:20:35,100 --> 01:20:37,230
Så kan jeg ikke befri dem uden for dette loop.

1300
01:20:37,230 --> 01:20:39,390
Og så for at løse noget som dette,

1301
01:20:39,390 --> 01:20:42,250
hvis du glemmer at frigøre hukommelse og du får denne hukommelsesfejl,

1302
01:20:42,250 --> 01:20:45,810
Du er nødt til at frigøre hukommelse inde i denne løkke, når du er færdig med det.

1303
01:20:45,810 --> 01:20:51,400
Nå, det er hvad der sker. Jeg kender masser af du hader dette.

1304
01:20:51,400 --> 01:20:55,270
Men nu - yay! Du får ligesom 44.000 kilobyte.

1305
01:20:55,270 --> 01:20:57,110
Så, man befri den for enden af ​​løkken,

1306
01:20:57,110 --> 01:20:59,770
og det kommer til at bare frigøre hukommelse hver gang.

1307
01:20:59,770 --> 01:21:03,620
Væsentlige, er dit program ikke har en hukommelsesfejl længere.

1308
01:21:03,620 --> 01:21:08,150
>> Og nu noget andet, du kan gøre, er at frigøre noget hukommelse, som du har bedt om to gange.

1309
01:21:08,150 --> 01:21:11,060
I dette tilfælde, du malloc noget du ændre dens værdi.

1310
01:21:11,060 --> 01:21:13,140
Du frigøre det én gang, fordi du sagde, du var færdig med den.

1311
01:21:13,140 --> 01:21:14,940
Men derefter vi befriede det igen.

1312
01:21:14,940 --> 01:21:16,730
Det er noget, der er temmelig dårlig.

1313
01:21:16,730 --> 01:21:18,820
Det er ikke til at begynde segfault,

1314
01:21:18,820 --> 01:21:23,350
men efter et stykke tid, hvad det betyder er dobbelt frigør dette korrumperer din bunke struktur,

1315
01:21:23,350 --> 01:21:27,200
og du vil lære lidt mere om dette, hvis du vælger at tage en klasse som CS61.

1316
01:21:27,200 --> 01:21:30,000
Men det væsentlige efter et stykke tid din computer kommer til at blive forvirret

1317
01:21:30,000 --> 01:21:33,010
om, hvad hukommelsespladser er hvor og hvor den er gemt -

1318
01:21:33,010 --> 01:21:34,800
hvor data lagres i hukommelsen.

1319
01:21:34,800 --> 01:21:38,080
Og så frigør en pointer to gange er en dårlig ting, som du ikke ønsker at gøre.

1320
01:21:38,080 --> 01:21:41,600
>> Andre ting der kan gå galt er ikke bruger sizeof.

1321
01:21:41,600 --> 01:21:44,460
Så i dette tilfælde skal du allokere 8 byte,

1322
01:21:44,460 --> 01:21:46,700
og det er det samme som to heltal, right?

1323
01:21:46,700 --> 01:21:49,580
Så det er helt sikkert, men er det?

1324
01:21:49,580 --> 01:21:52,160
Nå, som Lucas talte om på forskellige arkitekturer,

1325
01:21:52,160 --> 01:21:54,220
heltal er af forskellig varighed.

1326
01:21:54,220 --> 01:21:57,970
Så på apparatet, som du bruger, er hele tal omkring 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
men på et andet system de kunne være 8 bytes, eller de kan være 16 byte.

1328
01:22:02,370 --> 01:22:05,680
Så hvis jeg bare bruge dette nummer herovre,

1329
01:22:05,680 --> 01:22:07,310
dette program kan arbejde på apparatet,

1330
01:22:07,310 --> 01:22:10,360
men det kommer ikke til at allokere nok hukommelse på et andet system.

1331
01:22:10,360 --> 01:22:14,020
I dette tilfælde er det, hvad den sizeof operatør bruges til.

1332
01:22:14,020 --> 01:22:16,880
Når vi kalder sizeof (int), hvad det gør, er

1333
01:22:16,880 --> 01:22:21,910
 det giver os størrelsen af ​​et heltal på systemet, at programmet kører.

1334
01:22:21,910 --> 01:22:25,490
Så i dette tilfælde vil sizeof (int) returnerer 4 på noget som apparatet,

1335
01:22:25,490 --> 01:22:29,980
og nu denne vilje 4 * 2, hvilket er 8,

1336
01:22:29,980 --> 01:22:32,330
som er lige den mængde plads er nødvendig for to heltal.

1337
01:22:32,330 --> 01:22:36,710
På et andet system, hvis en int er ligesom 16 byte eller 8 bytes

1338
01:22:36,710 --> 01:22:39,380
det bare at gå tilbage nok bytes til at gemme dette beløb.

1339
01:22:41,830 --> 01:22:45,310
>> Og endelig, struct.

1340
01:22:45,310 --> 01:22:48,340
Så hvis du ønsker at gemme en sudoku bord i hukommelsen, hvordan kunne vi gøre det?

1341
01:22:48,340 --> 01:22:51,570
Du tror måske, ligesom en variabel for det første,

1342
01:22:51,570 --> 01:22:53,820
en variabel til den anden ting, en variabel for den tredje ting,

1343
01:22:53,820 --> 01:22:56,420
en variabel for fjerde ting - dårlig, ikke?

1344
01:22:56,420 --> 01:23:00,750
Så en forbedring du kan gøre på toppen af ​​dette er at lave en 9 x 9 array.

1345
01:23:00,750 --> 01:23:04,480
Det er fint, men hvad nu hvis du ønsker at knytte andre ting med sudoku bestyrelse

1346
01:23:04,480 --> 01:23:06,490
lide, hvad det er vanskeligt at bestyrelsen er,

1347
01:23:06,490 --> 01:23:11,740
eller for eksempel? hvad din score er, eller hvor meget tid det har taget dig at løse dette board

1348
01:23:11,740 --> 01:23:14,970
Nå, hvad du kan gøre, er du kan oprette en struct.

1349
01:23:14,970 --> 01:23:18,910
Hvad jeg dybest set siger, er jeg definere denne struktur herovre,

1350
01:23:18,910 --> 01:23:23,230
og jeg definerer en sudoku bestyrelse, som består af en bestyrelse, der er 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Og hvad det har den har henvisninger til navnet på niveau.

1352
01:23:26,650 --> 01:23:30,730
Det har også x og y, som er koordinaterne for, hvor jeg er lige nu.

1353
01:23:30,730 --> 01:23:35,980
Det har også tid [uforståeligt], og det har det samlede antal træk, jeg har indlæst hidtil.

1354
01:23:35,980 --> 01:23:40,010
Og så i dette tilfælde, kan jeg gruppere en hel masse data ind i kun én struktur

1355
01:23:40,010 --> 01:23:42,790
stedet for at have det som at flyve rundt i ligesom forskellige variabler

1356
01:23:42,790 --> 01:23:44,540
at jeg ikke kan virkelig holde styr på.

1357
01:23:44,540 --> 01:23:49,720
Og det lader os har bare nice syntaks for slags referere forskellige ting inde i denne struct.

1358
01:23:49,720 --> 01:23:53,430
Jeg kan bare gøre board.board, og jeg får sudoku bord tilbage.

1359
01:23:53,430 --> 01:23:56,320
Board.level, jeg får hvor hårdt det er.

1360
01:23:56,320 --> 01:24:00,540
Board.x og board.y give mig koordinaterne for, hvor jeg kan være i bestyrelsen.

1361
01:24:00,540 --> 01:24:04,730
Og så jeg adgang til det, vi kalder felter i struct.

1362
01:24:04,730 --> 01:24:08,840
Dette definerer sudokuBoard, som er en type, som jeg har.

1363
01:24:08,840 --> 01:24:14,800
Og nu er vi her. Jeg har en variabel kaldet "board" af typen sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Og så nu kan jeg få adgang til alle de felter, der udgør denne struktur herovre.

1365
01:24:20,830 --> 01:24:22,450
>> Eventuelle spørgsmål om struct? Ja?

1366
01:24:22,450 --> 01:24:25,890
[Student] For int x, y, du erklærede både på én linje? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Så kunne du bare gøre det med dem alle?

1368
01:24:27,400 --> 01:24:31,200
Ligesom i x, y komma gange, at den samlede?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ja, det kan du helt sikkert gøre det, men grunden til at jeg satte x og y på samme linje -

1370
01:24:34,460 --> 01:24:36,330
og spørgsmålet er, hvorfor kan vi bare gøre det på samme linie?

1371
01:24:36,330 --> 01:24:38,600
Hvorfor gør vi ikke bare sætte alle disse på samme linje er

1372
01:24:38,600 --> 01:24:42,090
x og y er relateret til hinanden,

1373
01:24:42,090 --> 01:24:44,780
og dette er bare stilistisk mere korrekt, i en vis forstand,

1374
01:24:44,780 --> 01:24:46,600
fordi det er gruppering to ting på samme linje

1375
01:24:46,600 --> 01:24:49,340
at lignende slags vedrører samme ting.

1376
01:24:49,340 --> 01:24:51,440
Og jeg har lige dele disse fra hinanden. Det er bare en stil ting.

1377
01:24:51,440 --> 01:24:53,720
Det funktionelt gør ingen forskel overhovedet.

1378
01:24:58,150 --> 01:24:59,270
Eventuelle andre spørgsmål om struct?

1379
01:25:03,030 --> 01:25:06,620
Du kan definere en Pokedex med en struct.

1380
01:25:06,620 --> 01:25:11,720
En Pokémon har et nummer og det har et brev, en ejer, en type.

1381
01:25:11,720 --> 01:25:16,990
Og så hvis du har en bred vifte af Pokémon, kan du gøre op en Pokedex, right?

1382
01:25:16,990 --> 01:25:20,810
Okay, cool. Så spørgsmål om struct. Det er relateret til struct.

1383
01:25:20,810 --> 01:25:25,270
>> Endelig GDB. Hvad betyder GDB lade dig gøre? Det kan du debug din program.

1384
01:25:25,270 --> 01:25:27,650
Og hvis du ikke har brugt GDB, ville jeg anbefalet at se den korte

1385
01:25:27,650 --> 01:25:31,250
og bare gå over, hvad GDB er, hvordan du arbejder med det, hvordan du kan bruge det,

1386
01:25:31,250 --> 01:25:32,900
og teste det på et program.

1387
01:25:32,900 --> 01:25:37,400
Og hvad så GDB lader dig gøre, er det lader pause [uforståelig] op dit program

1388
01:25:37,400 --> 01:25:38,920
og en praktisk linie.

1389
01:25:38,920 --> 01:25:42,600
For eksempel, vil jeg holde pause udførelse på ligesom linje 3 i mit program,

1390
01:25:42,600 --> 01:25:46,010
og mens jeg er på linie 3 Jeg kan udskrive alle de værdier, der er der.

1391
01:25:46,010 --> 01:25:49,710
Og så det, vi kalder ligesom pause i en linje

1392
01:25:49,710 --> 01:25:52,350
er vi kalde dette at sætte et breakpoint på denne linje

1393
01:25:52,350 --> 01:25:55,920
og så kan vi udskrive variabler på tilstanden af ​​programmet på det tidspunkt.

1394
01:25:55,920 --> 01:25:58,990
>> Vi kan så derfra gå gennem programmet linje for linje.

1395
01:25:58,990 --> 01:26:03,200
Og så kan vi se på tilstanden af ​​stablen på det tidspunkt.

1396
01:26:03,200 --> 01:26:08,600
Og så for at bruge GDB, hvad vi gør, er vi kalder Klang på C-fil,

1397
01:26:08,600 --> 01:26:11,290
men vi er nødt til at passere det-ggdb flag.

1398
01:26:11,290 --> 01:26:15,850
Og når vi er færdige med at vi bare køre gdb på den resulterende output fil.

1399
01:26:15,850 --> 01:26:18,810
Og så får du nogle lignende masse tekst som denne,

1400
01:26:18,810 --> 01:26:21,990
men virkelig alt hvad du skal gøre er at skrive i kommandoer i begyndelsen.

1401
01:26:21,990 --> 01:26:24,250
Break main sætter et breakpoint på main.

1402
01:26:24,250 --> 01:26:28,470
Liste 400 opregner de linjer kode omkring linie 400.

1403
01:26:28,470 --> 01:26:31,410
Og så i dette tilfælde kan du bare kigge dig omkring og sige, åh,

1404
01:26:31,410 --> 01:26:34,360
Jeg ønsker at indstille et breakpoint på linje 397, som er denne linje,

1405
01:26:34,360 --> 01:26:37,170
og derefter dit program kører ind i det trin og det kommer til at bryde.

1406
01:26:37,170 --> 01:26:41,120
Det kommer til pause der, og du kan printe ud, for eksempel værdien af ​​lav eller høj.

1407
01:26:41,120 --> 01:26:46,410
Og så er der en masse kommandoer, du har brug for at vide,

1408
01:26:46,410 --> 01:26:48,660
og dette diasshow vil gå op på hjemmesiden,

1409
01:26:48,660 --> 01:26:54,000
så hvis du blot ønsker at referere disse eller lignende lægge dem på din snyde ark, velkommen.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Det var Quiz anmeldelse 0, og vi vil holde sig i nærheden, hvis du har spørgsmål.

1411
01:27:00,650 --> 01:27:03,850
Ok.

1412
01:27:03,850 --> 01:27:09,030
>>  [Bifald]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]