1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Omtale] [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
>> Hei, alle sammen.

5
00:00:10,000 --> 00:00:15,000
Velkommen til gjennomgangen økt for 0 Quiz, som finner sted på onsdag.

6
00:00:15,000 --> 00:00:19,000
Hva vi skal gjøre i kveld, jeg med 3 andre TFS,

7
00:00:19,000 --> 00:00:24,000
og sammen skal vi gå gjennom en gjennomgang av hva vi har gjort i løpet så langt.

8
00:00:24,000 --> 00:00:27,000
Det kommer ikke til å være 100% omfattende, men det bør gi deg en bedre idé

9
00:00:27,000 --> 00:00:31,000
av hva du allerede har ned og hva du fortsatt trenger å studere før onsdag.

10
00:00:31,000 --> 00:00:34,000
Og gjerne heve hånden med spørsmål som vi skal sammen,

11
00:00:34,000 --> 00:00:38,000
men husk at vi vil også ha en liten bit av tid på slutten-

12
00:00:38,000 --> 00:00:41,000
hvis vi får gjennom med et par minutter til overs til å gjøre generelle spørsmål,

13
00:00:41,000 --> 00:00:47,000
så hold det i tankene, så vi kommer til å starte i begynnelsen med uke 0.

14
00:00:47,000 --> 00:00:50,000
>> [Quiz 0 anmeldelse!] [Part 0] [Lexi Ross] Men før vi gjør det la oss snakke om

15
00:00:50,000 --> 00:00:53,000
logistikken av quizen.

16
00:00:53,000 --> 00:00:55,000
>> [Logistikk] [Quiz foregår onsdag 10/10 i stedet for forelesning]

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

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

19
00:01:00,000 --> 00:01:03,000
som også er tilgjengelig fra CS50.net-det er en link til det-

20
00:01:03,000 --> 00:01:06,000
Du kan se informasjon om hvor du skal dra på grunnlag av

21
00:01:06,000 --> 00:01:10,000
etternavnet ditt eller skolen tilknytning samt

22
00:01:10,000 --> 00:01:14,000
det forteller om nøyaktig hva quiz vil dekke og hvilke typer spørsmål som du kommer til å få.

23
00:01:14,000 --> 00:01:19,000
Husk at du også har en sjanse til å gjennomgå for quiz i seksjonen,

24
00:01:19,000 --> 00:01:21,000
slik at TFS skal gå over noen praksis problemer,

25
00:01:21,000 --> 00:01:29,000
og det er en annen god sjanse til å se hvor du fortsatt trenger å studere opp for quiz.

26
00:01:29,000 --> 00:01:32,000
La oss begynne med begynnelsen med Bits 'n' Bytes.

27
00:01:32,000 --> 00:01:35,000
Husk litt er bare en 0 eller 1,

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

29
00:01:38,000 --> 00:01:42,000
La oss se på denne samlingen av biter her.

30
00:01:42,000 --> 00:01:44,000
Vi burde være i stand til å finne ut hvor mange biter det er.

31
00:01:44,000 --> 00:01:48,000
Der vi teller det er bare 8 av dem, åtte 0 eller 1 stk.

32
00:01:48,000 --> 00:01:51,000
Og siden det er 8 bits, det er en byte,

33
00:01:51,000 --> 00:01:53,000
og la oss konvertere den til heksadesimal.

34
00:01:53,000 --> 00:01:58,000
Heksadesimal er base 16, og det er ganske enkelt å konvertere

35
00:01:58,000 --> 00:02:01,000
et tall i binær, som er hva som er, til en rekke i heksadesimal.

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

37
00:02:04,000 --> 00:02:07,000
og vi konvertere dem til riktig heksadesimale siffer.

38
00:02:07,000 --> 00:02:11,000
Vi starter med lengst til høyre gruppe 4, så 0011.

39
00:02:11,000 --> 00:02:16,000
Det kommer til å bli en 1 og en 2, så sammen som gjør tre.

40
00:02:16,000 --> 00:02:19,000
Og så la oss se på den andre blokken av fire.

41
00:02:19,000 --> 00:02:24,000
1101. Det kommer til å bli en 1, en 4, og en 8.

42
00:02:24,000 --> 00:02:28,000
Sammen som kommer til å være 13, noe som gjør D.

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

44
00:02:32,000 --> 00:02:36,000
Vi går fra 0 til F, så etter 9, 10 tilsvarer en,

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

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

47
00:02:44,000 --> 00:02:49,000
så å konvertere den til desimal alt vi gjør er vi faktisk

48
00:02:49,000 --> 00:02:52,000
behandle hver posisjon som en effekt på 2.

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

50
00:02:58,000 --> 00:03:03,000
og det er litt vanskelig å beregne i hodet ditt, men hvis vi går til neste lysbilde

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

52
00:03:05,000 --> 00:03:09,000
>> I hovedsak skal vi over fra helt tilbake til venstre,

53
00:03:09,000 --> 00:03:14,000
og vi multiplisere hvert siffer ved tilsvarende effekt på 2.

54
00:03:14,000 --> 00:03:19,000
Og husk, for heksadesimal betegne vi disse tallene med 0x i begynnelsen

55
00:03:19,000 --> 00:03:23,000
så vi ikke forveksles med et desimaltall.

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

57
00:03:29,000 --> 00:03:35,000
og hva vi bruker ASCII for å kartlegge fra tegn til numeriske verdier.

58
00:03:35,000 --> 00:03:39,000
Husk i kryptografi pset vi gjorde utstrakt bruk av ASCII-tabellen

59
00:03:39,000 --> 00:03:43,000
for å bruke ulike metoder for kryptografi,

60
00:03:43,000 --> 00:03:47,000
Caesar og Vigenère siffer, for å konvertere forskjellige bokstaver

61
00:03:47,000 --> 00:03:52,000
i en streng i henhold til nøkkel gitt av brukeren.

62
00:03:52,000 --> 00:03:56,000
La oss se på en liten bit av ASCII matematikk.

63
00:03:56,000 --> 00:04:02,000
Ser på "P" + 1, i karakter form som ville 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 hvordan akkurat ville vi konvertere mellom disse to formene?

66
00:04:10,000 --> 00:04:13,000
Det er faktisk ikke så vanskelig.

67
00:04:13,000 --> 00:04:16,000
For å få 5 vi trekker '0 '

68
00:04:16,000 --> 00:04:20,000
fordi det er 5 steder mellom '0 'og '5.'

69
00:04:20,000 --> 00:04:23,000
For å gå den andre veien vi bare legge til 0,

70
00:04:23,000 --> 00:04:25,000
så det er liksom som vanlig aritmetikk.

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

72
00:04:29,000 --> 00:04:37,000
og tilsvarer dermed en verdi i ASCII-tabellen.

73
00:04:37,000 --> 00:04:40,000
Flytte inn mer generelle informatikk emner.

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

75
00:04:43,000 --> 00:04:45,000
å gjennomføre algoritmer.

76
00:04:45,000 --> 00:04:48,000
Noen eksempler på algoritmer er noe veldig enkelt som

77
00:04:48,000 --> 00:04:51,000
sjekke om et tall er partall eller oddetall.

78
00:04:51,000 --> 00:04:54,000
For at vi husker mod tallet med 2 og sjekk om resultatet er 0.

79
00:04:54,000 --> 00:04:57,000
I så fall er det enda. Hvis ikke, er det merkelig.

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

81
00:04:59,000 --> 00:05:02,000
>> En liten bit av en mer involvert man er binært søk,

82
00:05:02,000 --> 00:05:05,000
som vi vil gå over senere i anmeldelsen økten.

83
00:05:05,000 --> 00:05:09,000
Og programmering er betegnelsen vi bruker for å ta en algoritme

84
00:05:09,000 --> 00:05:15,000
og konvertere den til kode på datamaskinen kan lese.

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

86
00:05:20,000 --> 00:05:22,000
som er hva vi gjorde i uke 0.

87
00:05:22,000 --> 00:05:25,000
Selv om vi ikke egentlig skriver ut koden er det en måte å implementere

88
00:05:25,000 --> 00:05:29,000
denne algoritmen, som skriver tallene 1-10,

89
00:05:29,000 --> 00:05:32,000
og her gjør vi det samme i C programmeringsspråk.

90
00:05:32,000 --> 00:05:41,000
Dette er funksjonelt likeverdig, bare skrevet på forskjellige språk eller syntaks.

91
00:05:41,000 --> 00:05:44,000
Vi har lært om boolske uttrykk,

92
00:05:44,000 --> 00:05:48,000
og en boolean er en verdi som er enten sant eller usant,

93
00:05:48,000 --> 00:05:51,000
og her ofte boolske uttrykk

94
00:05:51,000 --> 00:05:55,000
gå inn på vilkårene, så hvis (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
vel, vi allerede satt x = 5, slik at tilstanden kommer til å vurdere å true.

96
00:06:00,000 --> 00:06:03,000
Og hvis det er sant, er det koden under forutsetning

97
00:06:03,000 --> 00:06:08,000
kommer til å bli vurdert av datamaskinen, er at strengen skal skrives ut

98
00:06:08,000 --> 00:06:12,000
til standard ut, og begrepet tilstand

99
00:06:12,000 --> 00:06:16,000
refererer til det som er i parentes hvis setningen.

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

101
00:06:20,000 --> 00:06:26,000
Husk det er && og | | når vi prøver å kombinere to eller flere forhold,

102
00:06:26,000 --> 00:06:30,000
== Ikke = for å sjekke om to ting er like.

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

104
00:06:36,000 --> 00:06:41,000
≤, ≥ og deretter den endelige to er selvforklarende.

105
00:06:41,000 --> 00:06:45,000
En generell gjennomgang av boolsk logikk her.

106
00:06:45,000 --> 00:06:48,000
Og boolske uttrykk er også viktig i sløyfer,

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

108
00:06:50,000 --> 00:06:56,000
Vi har lært om tre typer sløyfer så langt i CS50, for, while, og gjøre mens.

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

110
00:06:59,000 --> 00:07:02,000
Vi kan faktisk bruke hvilken som helst type løkke generelt

111
00:07:02,000 --> 00:07:06,000
er det visse typer av formål eller felles mønstre

112
00:07:06,000 --> 00:07:09,000
i programmering som spesifikt kaller for en av disse loopene

113
00:07:09,000 --> 00:07:13,000
som gjør den til den mest effektive eller elegant å kode det på den måten.

114
00:07:13,000 --> 00:07:18,000
La oss gå over hva hver av disse løkker tendens til å bli brukt for oftest.

115
00:07:18,000 --> 00:07:21,000
>> I en for løkke generelt vi allerede vet hvor mange ganger vi ønsker å veksle.

116
00:07:21,000 --> 00:07:24,000
Det er hva vi legger i den tilstanden.

117
00:07:24,000 --> 00:07:28,000
For, i = 0, I <10, for eksempel.

118
00:07:28,000 --> 00:07:31,000
Vi vet allerede at vi ønsker å gjøre noe 10 ganger.

119
00:07:31,000 --> 00:07:34,000
Nå, for en stund løkke, generelt vi ikke nødvendigvis

120
00:07:34,000 --> 00:07:36,000
vet hvor mange ganger vi vil at loopen skal kjøres.

121
00:07:36,000 --> 00:07:39,000
Men vi vet en slags tilstand som vi vil ha det til

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

123
00:07:41,000 --> 00:07:44,000
For eksempel, er mens angitt.

124
00:07:44,000 --> 00:07:46,000
La oss si at det er en boolsk variabel.

125
00:07:46,000 --> 00:07:48,000
Mens det er sant vi ønsker koden for å evaluere,

126
00:07:48,000 --> 00:07:52,000
så litt mer utvidbar, litt mer generell enn en for loop,

127
00:07:52,000 --> 00:07:55,000
men noen for loop kan også bli konvertert til en stund loop.

128
00:07:55,000 --> 00:08:00,000
Endelig gjør mens sløyfer, som kan være den vanskeligste å forstå med en gang,

129
00:08:00,000 --> 00:08:04,000
brukes ofte når vi ønsker å evaluere koden først

130
00:08:04,000 --> 00:08:06,000
før den første gangen sjekker vi tilstanden.

131
00:08:06,000 --> 00:08:09,000
En vanlig bruk tilfelle for en gjøre mens sløyfe

132
00:08:09,000 --> 00:08:12,000
er når du ønsker å få brukerens input, og du vet at du vil be brukeren

133
00:08:12,000 --> 00:08:15,000
for innspill minst en gang, men hvis de ikke gi deg gode innspill med en gang

134
00:08:15,000 --> 00:08:18,000
du ønsker å fortsette å spørre dem før de gir deg gode innspill.

135
00:08:18,000 --> 00:08:21,000
Det er den mest vanlige bruken av en gjøre mens loop,

136
00:08:21,000 --> 00:08:23,000
og la oss se på selve strukturen av disse loopene.

137
00:08:23,000 --> 00:08:27,000
De vanligvis pleier alltid å følge disse mønstrene.

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

139
00:08:30,000 --> 00:08:35,000
initialisering, typisk noe som int i = 0 hvor jeg er telleren,

140
00:08:35,000 --> 00:08:40,000
tilstand, der vi ønsker å si kjøre dette for loop så lenge denne tilstanden gjelder fremdeles,

141
00:08:40,000 --> 00:08:44,000
som jeg <10, og så til slutt, oppdatering, som er hvordan vi øke

142
00:08:44,000 --> 00:08:47,000
tellervariabelen ved hvert punkt i sløyfen.

143
00:08:47,000 --> 00:08:50,000
En vanlig ting å se det er bare i + +,

144
00:08:50,000 --> 00:08:52,000
som betyr inkrementere jeg med 1 hver gang.

145
00:08:52,000 --> 00:08:55,000
Du kan også gjøre noe sånt i + = 2,

146
00:08:55,000 --> 00:08:58,000
som betyr legge 2 til jeg hver gang du går gjennom løkken.

147
00:08:58,000 --> 00:09:03,000
Og så gjør dette refererer bare til noen kode som faktisk kjører som en del av loopen.

148
00:09:03,000 --> 00:09:09,000
Og for en stund loop, denne gangen vi faktisk har initialisering utenfor løkken,

149
00:09:09,000 --> 00:09:12,000
så for eksempel, la oss si at vi prøver å gjøre samme type løkke som jeg nettopp beskrev.

150
00:09:12,000 --> 00:09:16,000
Vi vil si int i = 0 før løkken begynner.

151
00:09:16,000 --> 00:09:20,000
Da kunne vi si mens jeg <10 gjør dette,

152
00:09:20,000 --> 00:09:22,000
så samme blokk med kode som før,

153
00:09:22,000 --> 00:09:26,000
og denne gangen oppdateringen del av koden, for eksempel, i + +,

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

155
00:09:29,000 --> 00:09:33,000
Og til slutt, for en gjøre mens, det ligner mens loop,

156
00:09:33,000 --> 00:09:36,000
men vi må huske at koden vil vurdere en gang

157
00:09:36,000 --> 00:09:40,000
før tilstanden er sjekket, så det gjør mye mer fornuftig

158
00:09:40,000 --> 00:09:44,000
hvis du ser på det i rekkefølge fra topp til bunn.

159
00:09:44,000 --> 00:09:49,000
I en gjøre mens sløyfe koden evaluerer før du selv se på mens condition,

160
00:09:49,000 --> 00:09:55,000
mens en stund loop, sjekker den først.

161
00:09:55,000 --> 00:09:59,000
Uttalelser og variabler.

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

163
00:10:04,000 --> 00:10:07,000
>> For eksempel, initialiseres int bar variabelen bar,

164
00:10:07,000 --> 00:10:10,000
men det gir ikke det en verdi, så hva er bar verdi nå?

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

166
00:10:12,000 --> 00:10:14,000
Det kan være noen søppel verdi som tidligere var lagret i minnet der,

167
00:10:14,000 --> 00:10:16,000
og vi ønsker ikke å bruke den variabelen

168
00:10:16,000 --> 00:10:19,000
før vi faktisk gi den en verdi,

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

170
00:10:21,000 --> 00:10:24,000
Deretter vi initialisere det å være 42 under.

171
00:10:24,000 --> 00:10:28,000
Nå, selvfølgelig, vet vi at dette kan gjøres på én linje, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Men bare for å være fjerne flere trinn som skjer,

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

174
00:10:34,000 --> 00:10:38,000
Det skjer på ett trinn, og den neste, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
denne uttalelsen nedenfor, som øker baz, så på slutten av denne koden blokken

176
00:10:44,000 --> 00:10:48,000
hvis vi skulle skrive verdien av baz det ville være 44

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

178
00:10:52,000 --> 00:10:58,000
og da vi øke det enda en gang med + +.

179
00:10:58,000 --> 00:11:02,000
Vi gikk over denne ganske kort, men det er godt å ha en generell

180
00:11:02,000 --> 00:11:04,000
forståelse av hva tråder og hendelser er.

181
00:11:04,000 --> 00:11:06,000
Vi hovedsakelig gjorde dette i Scratch,

182
00:11:06,000 --> 00:11:09,000
slik at du kan tenke på tråder som flere sekvenser av kode

183
00:11:09,000 --> 00:11:11,000
kjører på samme tid.

184
00:11:11,000 --> 00:11:14,000
I virkeligheten, er det sannsynligvis ikke kjører på samme tid,

185
00:11:14,000 --> 00:11:17,000
men slags abstrakt vi kan tenke på det på den måten.

186
00:11:17,000 --> 00:11:20,000
>> I Scratch, for eksempel, hadde vi flere sprites.

187
00:11:20,000 --> 00:11:22,000
Det kan være å utføre annen kode samtidig.

188
00:11:22,000 --> 00:11:26,000
Man kunne være gange mens den andre er å si noe

189
00:11:26,000 --> 00:11:29,000
i en annen del av skjermen.

190
00:11:29,000 --> 00:11:34,000
Arrangementer er en annen måte for å skille ut logikken

191
00:11:34,000 --> 00:11:37,000
mellom ulike elementer av koden din,

192
00:11:37,000 --> 00:11:40,000
og i Scratch kunne vi simulere hendelser ved hjelp av Broadcast,

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

194
00:11:43,000 --> 00:11:47,000
men i hovedsak er det en måte å overføre informasjon

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

196
00:11:49,000 --> 00:11:52,000
For eksempel kan det være lurt å overføre game over,

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

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

199
00:11:58,000 --> 00:12:03,000
Det er en viktig modell for å forstå for programmering.

200
00:12:03,000 --> 00:12:07,000
Bare for å gå over den grunnleggende uke 0, hva vi har gått over så langt,

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

202
00:12:10,000 --> 00:12:14,000
Teksten kan være litt lite herfra, men jeg skal gå over det virkelig rask.

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

204
00:12:20,000 --> 00:12:23,000
Vi så definere en konstant kalt grense for å være 100.

205
00:12:23,000 --> 00:12:26,000
Vi så implementere vår viktigste funksjon.

206
00:12:26,000 --> 00:12:29,000
Siden vi ikke bruker kommandolinjeargumenter her vi må sette ugyldig

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

208
00:12:32,000 --> 00:12:38,000
Vi ser int over main. Det er returtypen, derav returnere 0 nederst.

209
00:12:38,000 --> 00:12:41,000
Og vi bruker CS50 biblioteket funksjon får int

210
00:12:41,000 --> 00:12:45,000
å spørre brukeren om inndata, og vi lagre den i denne variabelen x,

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

212
00:12:51,000 --> 00:12:53,000
>> Vi så sjekk for å se om brukeren ga oss gode innspill.

213
00:12:53,000 --> 00:12:59,000
Hvis det er ≥ LIMIT vi ønsker å returnere en feilkode på en og skrive ut en feilmelding.

214
00:12:59,000 --> 00:13:02,000
Og til slutt, hvis brukeren har gitt oss gode innspill

215
00:13:02,000 --> 00:13:08,000
vi kommer til torget nummeret og skrive ut resultatet.

216
00:13:08,000 --> 00:13:11,000
Bare for å være sikker på at de alle hit hjem

217
00:13:11,000 --> 00:13:17,000
du kan se etikettene på ulike deler av koden her.

218
00:13:17,000 --> 00:13:19,000
Jeg nevnte konstant, header filer.

219
00:13:19,000 --> 00:13:21,000
Oh, int x. Sørg for å huske det er en lokal variabel.

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

221
00:13:24,000 --> 00:13:27,000
litt senere i anmeldelsen økten,

222
00:13:27,000 --> 00:13:30,000
og vi ringer bibliotek funksjon printf,

223
00:13:30,000 --> 00:13:34,000
så hvis vi ikke hadde tatt den stdio.h topptekstfilen

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

225
00:13:37,000 --> 00:13:42,000
Og jeg tror pilen som fikk kuttet av her peker til% d,

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

227
00:13:45,000 --> 00:13:52,000
Det sier skrive ut denne variabelen som et tall,% d.

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

229
00:13:58,000 --> 00:14:06,000
Nå Lucas kommer til å fortsette.

230
00:14:06,000 --> 00:14:08,000
Hei, folkens. Mitt navn er Lucas.

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

232
00:14:10,000 --> 00:14:14,000
og jeg kommer til å snakke litt om uke 1 og 2,1.

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

234
00:14:16,000 --> 00:14:19,000
Som Lexi sa, da vi startet å oversette koden fra Scratch til C

235
00:14:19,000 --> 00:14:23,000
en av de tingene som vi la merke er at du kan ikke bare

236
00:14:23,000 --> 00:14:26,000
skrive kode og kjøre den med et grønt flagg lenger.

237
00:14:26,000 --> 00:14:30,000
Egentlig må du bruke noen skritt for å gjøre din C-program

238
00:14:30,000 --> 00:14:33,000
bli en kjørbar fil.

239
00:14:33,000 --> 00:14:36,000
I utgangspunktet hva du gjør når du skriver et program er at

240
00:14:36,000 --> 00:14:40,000
du oversette din idé til et språk som en kompilator 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
hva du gjør er faktisk å skrive noe som kompilatoren kommer til å forstå,

243
00:14:47,000 --> 00:14:50,000
og deretter kompilatoren skal oversette denne koden

244
00:14:50,000 --> 00:14:53,000
til noe som datamaskinen forstår.

245
00:14:53,000 --> 00:14:55,000
>> Og ting er, er datamaskinen faktisk veldig dumt.

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

247
00:14:57,000 --> 00:15:01,000
så faktisk i de første datamaskinene folk vanligvis programmert

248
00:15:01,000 --> 00:15:04,000
hjelp 0'er og 1'ere, men ikke lenger, takk Gud.

249
00:15:04,000 --> 00:15:07,000
Vi trenger ikke å memorere sekvenser for 0'er og 1'ere

250
00:15:07,000 --> 00:15:10,000
for en for sløyfe eller en stund løkke og så videre.

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

252
00:15:13,000 --> 00:15:17,000
Hva en kompilator gjør er det i utgangspunktet oversetter C-kode,

253
00:15:17,000 --> 00:15:21,000
i vårt tilfelle, til et språk som datamaskinen vil forstå,

254
00:15:21,000 --> 00:15:25,000
som er gjenstand koden, og kompilatoren at vi bruker

255
00:15:25,000 --> 00:15:30,000
kalles clang, så dette er faktisk symbolet for clang.

256
00:15:30,000 --> 00:15:33,000
Når du har programmet, må du gjøre to ting.

257
00:15:33,000 --> 00:15:37,000
Først må du kompilere programmet, og du kommer til å kjøre programmet.

258
00:15:37,000 --> 00:15:41,000
Å kompilere programmet du har en rekke alternativer for å gjøre det.

259
00:15:41,000 --> 00:15:44,000
Den første er å gjøre clang program.c

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

261
00:15:47,000 --> 00:15:51,000
I dette tilfellet kan du se de bare si "Hei, kompilere programmet mitt."

262
00:15:51,000 --> 00:15:56,000
Du sier ikke "Jeg vil dette navnet for mitt program" eller noe.

263
00:15:56,000 --> 00:15:58,000
>> Det andre alternativet er å gi et navn til programmet.

264
00:15:58,000 --> 00:16:02,000
Du kan si clang-o og deretter navnet du vil

265
00:16:02,000 --> 00:16:06,000
den kjørbare filen til å bli navngitt som og deretter program.c.

266
00:16:06,000 --> 00:16:11,000
Og du kan også gjør programmet, og se hvordan de første to tilfellene

267
00:16:11,000 --> 00:16:15,000
Jeg satt. C, og i den tredje bare jeg har programmer?

268
00:16:15,000 --> 00:16:18,000
Ja, du faktisk ikke bør sette. C når du bruker gjør.

269
00:16:18,000 --> 00:16:22,000
Ellers kompilatoren er faktisk kommer til å kjefte på deg.

270
00:16:22,000 --> 00:16:24,000
Og også, jeg vet ikke om dere husker,

271
00:16:24,000 --> 00:16:29,000
men mange ganger vi også brukt-lcs50 eller-lm.

272
00:16:29,000 --> 00:16:31,000
Som kalles linking.

273
00:16:31,000 --> 00:16:35,000
Det forteller bare kompilatoren som du vil bruke disse bibliotekene der,

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

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

276
00:16:43,000 --> 00:16:45,000
Hvis du ikke gjør det, er kompilatoren ikke kommer til å vite

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

278
00:16:50,000 --> 00:16:52,000
Og når du ønsker å kjøre programmet du har 2 alternativer.

279
00:16:52,000 --> 00:16:57,000
Hvis du gjorde clang program.c du ikke gi et navn til programmet.

280
00:16:57,000 --> 00:17:01,000
Du må kjøre den bruker. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out er en standard navn som klang gir programmet hvis du ikke gi den et navn.

282
00:17:06,000 --> 00:17:11,000
Ellers kommer du til å gjøre. / Program hvis du ga et navn til programmet,

283
00:17:11,000 --> 00:17:15,000
og også hvis du gjorde programmet navnet at et program skal få

284
00:17:15,000 --> 00:17:23,000
er allerede kommer til å bli programmert samme navn som c-fil.

285
00:17:23,000 --> 00:17:26,000
Da vi snakket om datatyper og data.

286
00:17:26,000 --> 00:17:31,000
>> I utgangspunktet datatyper er det samme som små bokser de bruker

287
00:17:31,000 --> 00:17:35,000
å lagre verdier, så datatyper er faktisk akkurat som 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 vet ikke om det analogi er fornuftig.

290
00:17:43,000 --> 00:17:46,000
Datastørrelsen avhenger faktisk på maskinen arkitektur.

291
00:17:46,000 --> 00:17:49,000
Alle data størrelser som jeg kommer til å vise her

292
00:17:49,000 --> 00:17:53,000
er faktisk for et 32-bits maskin, som er tilfellet med apparatet vårt

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

294
00:17:56,000 --> 00:17:59,000
du sannsynligvis kommer til å ha en 64-bits maskin,

295
00:17:59,000 --> 00:18:03,000
så husk at dataene størrelser som jeg kommer til å vise her

296
00:18:03,000 --> 00:18:06,000
er for 32-bits maskin.

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

298
00:18:08,000 --> 00:18:10,000
som er ganske grei.

299
00:18:10,000 --> 00:18:13,000
Du bruker int til å lagre et heltall.

300
00:18:13,000 --> 00:18:16,000
Vi så også tegnet, røye.

301
00:18:16,000 --> 00:18:20,000
Hvis du ønsker å bruke en bokstav eller et lite symbol du sannsynligvis kommer til å bruke en røye.

302
00:18:20,000 --> 00:18:26,000
En røye har 1 byte, noe som betyr 8 bits, som Lexi sa.

303
00:18:26,000 --> 00:18:31,000
I utgangspunktet har vi en ASCII-tabellen som har 256

304
00:18:31,000 --> 00:18:34,000
mulige kombinasjoner av 0'er og 1'ere,

305
00:18:34,000 --> 00:18:37,000
og når du skriver en røye det kommer til å oversette

306
00:18:37,000 --> 00:18:44,000
tegnet som innganger du et nummer som du har i ASCII-tabellen, som Lexi sa.

307
00:18:44,000 --> 00:18:48,000
Vi har også flyte, som vi bruker til å lagre desimaltall.

308
00:18:48,000 --> 00:18:53,000
Hvis du ønsker å velge 3.14, for eksempel, du kommer til å bruke en flåte

309
00:18:53,000 --> 00:18:55,000
eller en dobbel som har mer presisjon.

310
00:18:55,000 --> 00:18:57,000
En flottør har 4 bytes.

311
00:18:57,000 --> 00:19:01,000
En dobbel har 8 byte, så den eneste forskjellen er presisjonen.

312
00:19:01,000 --> 00:19:04,000
Vi har også en lang som brukes for heltall,

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

314
00:19:09,000 --> 00:19:13,000
så det gjør ikke egentlig fornuftig å bruke en lang i en 32-bits maskin.

315
00:19:13,000 --> 00:19:17,000
>> Men hvis du bruker en Mac og 64-bits maskin, faktisk en lang har størrelse 8,

316
00:19:17,000 --> 00:19:19,000
så det er egentlig avhengig av arkitektur.

317
00:19:19,000 --> 00:19:22,000
For 32-bits maskin det ikke fornuftig å bruke en lang egentlig.

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

319
00:19:25,000 --> 00:19:30,000
så det er veldig bra hvis du vil ha en lengre heltall.

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

321
00:19:34,000 --> 00:19:37,000
som er en peker til en char.

322
00:19:37,000 --> 00:19:40,000
Det er veldig lett å tenke at størrelsen på strengen skal være like

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

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

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

326
00:19:49,000 --> 00:19:52,000
Størrelsen på en char * er 4 byte.

327
00:19:52,000 --> 00:19:56,000
Det spiller ingen rolle om du har et lite ord eller en bokstav eller noe.

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

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

330
00:20:01,000 --> 00:20:04,000
slik som du kan se, hvis du har, for eksempel, et program som sier

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

332
00:20:08,000 --> 00:20:12,000
vet dere hva det kommer til å skrive ut på skjermen?

333
00:20:12,000 --> 00:20:14,000
>> Noen? >> [Studenter] 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 gjør 3/2 det kommer til å få 1,5,

336
00:20:20,000 --> 00:20:24,000
men siden vi bruker et heltall det kommer til å ignorere desimaldel,

337
00:20:24,000 --> 00:20:26,000
og du kommer til å ha en.

338
00:20:26,000 --> 00:20:29,000
Hvis du ikke vil at det skal skje hva du kan gjøre, for eksempel,

339
00:20:29,000 --> 00:20:33,000
er erklærer en flåte y = x.

340
00:20:33,000 --> 00:20:40,000
Så x som pleide å være 3 er nå kommer til å være 3.000 i y.

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

342
00:20:44,000 --> 00:20:50,000
Egentlig bør jeg ha en 2. der borte.

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

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

345
00:20:58,000 --> 00:21:06,000
Og vi har denne .2 f bare for å be om 2 desimaler enheter i desimaldelen.

346
00:21:06,000 --> 00:21:12,000
Hvis du har 0,3 f det kommer til å ha faktisk 1.500.

347
00:21:12,000 --> 00:21:16,000
Hvis det er to det kommer til å være 1,50.

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

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

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

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

352
00:21:29,000 --> 00:21:34,000
noe som betyr behandle x som en int, og du skriver ut x nå

353
00:21:34,000 --> 00:21:36,000
du kommer til å ha 3,00.

354
00:21:36,000 --> 00:21:38,000
Gjør det fornuftig?

355
00:21:38,000 --> 00:21:41,000
Fordi du først å behandle x som et heltall, slik at du ignorerer desimaldelen,

356
00:21:41,000 --> 00:21:45,000
og da er du skriver x.

357
00:21:45,000 --> 00:21:47,000
Og til slutt, kan du også gjøre dette,

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

359
00:21:52,000 --> 00:21:56,000
og hvis du skriver ut c du faktisk kommer til å få

360
00:21:56,000 --> 00:21:59,000
A, så i utgangspunktet hva du gjør her

361
00:21:59,000 --> 00:22:02,000
er å oversette heltall inn i karakteren,

362
00:22:02,000 --> 00:22:05,000
akkurat som ASCII tabellen.

363
00:22:05,000 --> 00:22:08,000
Vi snakket også om baneoperatører.

364
00:22:08,000 --> 00:22:14,000
De fleste av dem er ganske grei, så +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
og også vi snakket om mod, som er resten av en divisjon av to tall.

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 betyr dele 10 med 3, og hva er resten?

368
00:22:27,000 --> 00:22:30,000
Det kommer til å være 1, så det er faktisk veldig nyttig for mange av programmene.

369
00:22:30,000 --> 00:22:38,000
For Vigenère og Caesar er jeg ganske sikker på at alle dere brukte mod.

370
00:22:38,000 --> 00:22:43,000
Om baneoperatører, være svært forsiktig med å kombinere * og /.

371
00:22:43,000 --> 00:22:48,000
>> For eksempel, hvis du gjør (3/2) * 2 hva har du tenkt å bli?

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

373
00:22:50,000 --> 00:22:54,000
Ja, 2, fordi tre halvdel kommer til å være 1,5,

374
00:22:54,000 --> 00:22:57,000
men siden du gjør operasjoner mellom to heltall

375
00:22:57,000 --> 00:22:59,000
du faktisk bare kommer til å vurdere en,

376
00:22:59,000 --> 00:23:03,000
og deretter 1 * 2 kommer til å bli to, så vær veldig forsiktig

377
00:23:03,000 --> 00:23:07,000
når du gjør regning med heltall fordi

378
00:23:07,000 --> 00:23:12,000
du kan få den 2 = 3, i så fall.

379
00:23:12,000 --> 00:23:14,000
Og også være svært forsiktig med forrang.

380
00:23:14,000 --> 00:23:21,000
Du bør vanligvis bruke parenteser for å være sikker på at du vet hva du gjør.

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

382
00:23:27,000 --> 00:23:30,000
eller bruke + =.

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

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

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

386
00:23:42,000 --> 00:23:46,000
noe dere bruker mye i for looper, minst.

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

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

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

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

391
00:24:08,000 --> 00:24:10,000
>> Nå om funksjoner.

392
00:24:10,000 --> 00:24:13,000
Dere lærte at funksjonene er en veldig god strategi for å spare kode

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

394
00:24:16,000 --> 00:24:20,000
i koden igjen og igjen, sannsynligvis du vil bruke en funksjon

395
00:24:20,000 --> 00:24:25,000
bare så du ikke trenger å kopiere og lime inn koden igjen og igjen.

396
00:24:25,000 --> 00:24:28,000
Egentlig er det viktigste en funksjon, og når jeg vise deg formatet av en funksjon

397
00:24:28,000 --> 00:24:32,000
du kommer til å se at det er ganske åpenbart.

398
00:24:32,000 --> 00:24:35,000
Vi bruker også funksjoner fra enkelte bibliotekene,

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

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

401
00:24:43,000 --> 00:24:46,000
Alle disse funksjonene faktisk blir gjennomført i andre bibliotek,

402
00:24:46,000 --> 00:24:49,000
og når du setter dem tjore filer i begynnelsen av programmet

403
00:24:49,000 --> 00:24:53,000
du sier kan du gi meg koden for disse funksjonene

404
00:24:53,000 --> 00:24:57,000
så jeg ikke trenger å implementere dem selv?

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

406
00:25:00,000 --> 00:25:04,000
du skjønner at bibliotekene ikke har alle funksjonene du trenger.

407
00:25:04,000 --> 00:25:10,000
For den siste pset, for eksempel, skrev vi tegne, krafse, og oppslag,

408
00:25:10,000 --> 00:25:13,000
og det er veldig, veldig viktig å være i stand til å skrive funksjoner

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

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

411
00:25:19,000 --> 00:25:21,000
Formatet på en funksjon er dette en.

412
00:25:21,000 --> 00:25:24,000
Vi har returtype i begynnelsen. Hva er avkastningen type?

413
00:25:24,000 --> 00:25:27,000
Det er bare når funksjonen kommer til å returnere.

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

415
00:25:29,000 --> 00:25:31,000
som kommer til å beregne en fakultet av et heltall,

416
00:25:31,000 --> 00:25:34,000
sannsynligvis det kommer til å returnere et heltall også.

417
00:25:34,000 --> 00:25:37,000
Da returtypen kommer til å være int.

418
00:25:37,000 --> 00:25:41,000
Printf har faktisk en retur-type ugyldig

419
00:25:41,000 --> 00:25:43,000
fordi du ikke er tilbake noe.

420
00:25:43,000 --> 00:25:45,000
Du er bare skriver ting på skjermen

421
00:25:45,000 --> 00:25:48,000
og avslutte funksjonen etterpå.

422
00:25:48,000 --> 00:25:51,000
Da har du navnet på funksjonen som du kan velge.

423
00:25:51,000 --> 00:25:55,000
Du bør være litt fornuftig, som ikke velger et navn som xyz

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

425
00:25:58,000 --> 00:26:02,000
Prøv å gjøre opp et navn som gir mening.

426
00:26:02,000 --> 00:26:04,000
>> For eksempel, hvis det er faktoriell, sier fakultet.

427
00:26:04,000 --> 00:26:08,000
Hvis det er en funksjon som kommer til å tegne noe, name it tegne.

428
00:26:08,000 --> 00:26:11,000
Og så har vi de parametrene, som også kalles argumenter,

429
00:26:11,000 --> 00:26:14,000
som er som de ressurser som din funksjon trenger

430
00:26:14,000 --> 00:26:17,000
fra koden din for å utføre sin oppgave.

431
00:26:17,000 --> 00:26:20,000
Hvis du ønsker å beregne fakultet til et tall

432
00:26:20,000 --> 00:26:23,000
sannsynligvis må du ha et nummer for å beregne en fakultet.

433
00:26:23,000 --> 00:26:27,000
Et av argumentene som du kommer til å ha er selve nummeret.

434
00:26:27,000 --> 00:26:31,000
Og så det kommer til å gjøre noe og returnere verdien på slutten

435
00:26:31,000 --> 00:26:35,000
med mindre det er et tomrom funksjon.

436
00:26:35,000 --> 00:26:37,000
La oss se et eksempel.

437
00:26:37,000 --> 00:26:40,000
Hvis jeg ønsker å skrive en funksjon som summerer alle tallene i en matrise av heltall,

438
00:26:40,000 --> 00:26:43,000
først av alt, er returtypen skal være int

439
00:26:43,000 --> 00:26:46,000
fordi jeg har en rekke heltall.

440
00:26:46,000 --> 00:26:51,000
Og så skal jeg ha funksjonen navn som sumArray,

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

442
00:26:54,000 --> 00:26:58,000
og deretter lengden av tabellen, så jeg vet hvor mange tall jeg må oppsummere.

443
00:26:58,000 --> 00:27:02,000
Da må jeg initialisere en variabel kalt sum, for eksempel, til 0,

444
00:27:02,000 --> 00:27:08,000
og hver gang jeg ser et element i matrisen jeg bør legge det til summen, så jeg gjorde en for-løkke.

445
00:27:08,000 --> 00:27:15,000
Akkurat som Lexi sa, du int i = 0, i <lengde og i + +.

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

447
00:27:20,000 --> 00:27:24,000
og da jeg kom tilbake summen, så det er veldig enkelt, og det sparer mye kode

448
00:27:24,000 --> 00:27:28,000
hvis du bruker denne funksjonen en rekke ganger.

449
00:27:28,000 --> 00:27:32,000
Så tok vi en titt på forholdene.

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

451
00:27:38,000 --> 00:27:42,000
La oss se hva som er forskjellen mellom disse.

452
00:27:42,000 --> 00:27:45,000
Ta en titt på disse to kodene. Hva er forskjellen mellom dem?

453
00:27:45,000 --> 00:27:49,000
Den første har-i utgangspunktet kodene du ønsker å fortelle

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

455
00:27:51,000 --> 00:27:55,000
Den første sier at hvis det er> 0, så det er 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 andre gjør if, else if, else.

458
00:28:04,000 --> 00:28:07,000
Forskjellen mellom de to er at dette faktisk kommer til å

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

460
00:28:13,000 --> 00:28:17,000
så hvis du har nummer 2, for eksempel, kommer det til å komme hit og si

461
00:28:17,000 --> 00:28:21,000
if (x> 0), og det kommer til å si ja, så jeg skriver ut positivt.

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

463
00:28:25,000 --> 00:28:29,000
Jeg er fortsatt kommer til å gjøre er det 0, er det <0,

464
00:28:29,000 --> 00:28:33,000
så jeg faktisk kommer inne i IFS at jeg ikke måtte

465
00:28:33,000 --> 00:28:38,000
fordi jeg vet allerede at det ikke kommer til å tilfredsstille noen av disse forholdene.

466
00:28:38,000 --> 00:28:41,000
Jeg kan bruke if, else if, else statement.

467
00:28:41,000 --> 00:28:45,000
Det sier i utgangspunktet hvis x = 0 Jeg skriver det positive.

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

469
00:28:48,000 --> 00:28:51,000
Hvis det er to ikke jeg kommer til å gjøre dette.

470
00:28:51,000 --> 00:28:54,000
I utgangspunktet hvis jeg hadde x = 2 du ville si

471
00:28:54,000 --> 00:28:57,000
if (x> 0), ja, så skrive ut denne.

472
00:28:57,000 --> 00:29:00,000
Nå som jeg vet at det er> 0 og at det tilfredsstilte først hvis

473
00:29:00,000 --> 00:29:02,000
Jeg er ikke engang kommer til å kjøre denne koden.

474
00:29:02,000 --> 00:29:09,000
Koden kjøres fortere, faktisk, tre ganger raskere hvis du bruker dette.

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 kommer ikke til å gå gjennom dette fordi Lexi allerede snakket om dem.

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

478
00:29:17,000 --> 00:29:21,000
>> Det eneste jeg vil si er å være forsiktig når du har 3 tilstander.

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

480
00:29:24,000 --> 00:29:27,000
og en annen eller et annet,.

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

482
00:29:30,000 --> 00:29:34,000
fordi i så fall, for eksempel, kan du forestille deg at

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

484
00:29:38,000 --> 00:29:41,000
eller de 2 forholdene kombinert i en og

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

486
00:29:45,000 --> 00:29:48,000
Og til slutt, vi snakket om brytere.

487
00:29:48,000 --> 00:29:53,000
En bryter er svært nyttig når du har en variabel.

488
00:29:53,000 --> 00:29:55,000
La oss si at du har en variabel som n

489
00:29:55,000 --> 00:29:59,000
som kan være 0, 1, eller 2, og for hver av disse tilfellene

490
00:29:59,000 --> 00:30:01,000
du kommer til å utføre en oppgave.

491
00:30:01,000 --> 00:30:04,000
Du kan si slå variabelen, og det indikerer at

492
00:30:04,000 --> 00:30:08,000
verdien er da like verdi1 jeg kommer til å gjøre dette,

493
00:30:08,000 --> 00:30:12,000
og da jeg bryte, noe som betyr jeg ikke kommer til å se på noen av de andre sakene

494
00:30:12,000 --> 00:30:15,000
fordi vi allerede fornøyd med at saken

495
00:30:15,000 --> 00:30:20,000
og deretter verdi2 og så videre, og jeg kan også ha en standard bryter.

496
00:30:20,000 --> 00:30:24,000
Det betyr at hvis det ikke tilfredsstiller noen av de sakene som jeg hadde

497
00:30:24,000 --> 00:30:29,000
at jeg kommer til å gjøre noe annet, men det er valgfritt.

498
00:30:29,000 --> 00:30:36,000
Det er alt for meg. Nå la oss ha Tommy.

499
00:30:36,000 --> 00:30:41,000
Greit, dette kommer til å bli Uke 3-ish.

500
00:30:41,000 --> 00:30:45,000
Dette er noen av temaene som vil bli dekket, krypto, omfang, arrays, et cetera.

501
00:30:45,000 --> 00:30:49,000
Bare en rask ord på krypto. Vi kommer ikke til å hamre dette hjemme.

502
00:30:49,000 --> 00:30:52,000
>> Vi gjorde dette i pset 2, men for quiz sørg for at du vet forskjellen

503
00:30:52,000 --> 00:30:54,000
mellom Caesar cipher og Vigenère chiffer,

504
00:30:54,000 --> 00:30:57,000
hvordan begge disse ciphers arbeid og hva det er som å kryptere

505
00:30:57,000 --> 00:30:59,000
og dekryptere tekst ved hjelp av disse to chifre.

506
00:30:59,000 --> 00:31:03,000
Husk, roterer Caesar cipher bare hvert tegn med samme beløp,

507
00:31:03,000 --> 00:31:06,000
gjør at du mod med antall bokstaver i alfabetet.

508
00:31:06,000 --> 00:31:09,000
Og Vigenère chiffer, derimot, roterer hvert tegn

509
00:31:09,000 --> 00:31:12,000
av et annet beløp, så i stedet for å si

510
00:31:12,000 --> 00:31:15,000
Hver karakter roteres ved 3 Vigenère vil rotere hver karakter

511
00:31:15,000 --> 00:31:17,000
av et annet beløp avhengig noen søkeord

512
00:31:17,000 --> 00:31:20,000
hvor hver bokstav i søkeordet representerer noen annet beløp

513
00:31:20,000 --> 00:31:26,000
å rotere klartekst ved.

514
00:31:26,000 --> 00:31:28,000
La oss først snakke om variabel omfang.

515
00:31:28,000 --> 00:31:30,000
Det er 2 forskjellige typer variabler.

516
00:31:30,000 --> 00:31:33,000
Vi har lokale variabler, og disse kommer til å bli definert

517
00:31:33,000 --> 00:31:36,000
utenfor viktigste eller utenfor enhver funksjon eller blokk,

518
00:31:36,000 --> 00:31:39,000
og disse vil være tilgjengelig hvor som helst i programmet.

519
00:31:39,000 --> 00:31:41,000
Hvis du har en funksjon og at funksjonen er en stund loop

520
00:31:41,000 --> 00:31:44,000
den store globale variabelen er tilgjengelig overalt.

521
00:31:44,000 --> 00:31:48,000
En lokal variabel, på den annen side, er scoped til stedet hvor det er definert.

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

523
00:31:53,000 --> 00:31:56,000
og innsiden av g det er en variabel her kalt y,

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

525
00:31:58,000 --> 00:32:00,000
Selv om denne variabelen kalles y

526
00:32:00,000 --> 00:32:03,000
og denne variabelen kalles y disse to funksjonene

527
00:32:03,000 --> 00:32:06,000
aner ikke hva hverandres lokale variabler er.

528
00:32:06,000 --> 00:32:10,000
På den annen side, opp her vi si int x = 5,

529
00:32:10,000 --> 00:32:12,000
og dette er utenfor enhver funksjon.

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

531
00:32:16,000 --> 00:32:20,000
Det betyr at innsiden av disse to funksjonene når jeg sier x - eller x + +

532
00:32:20,000 --> 00:32:26,000
Jeg tilgang til samme x der dette y og dette y er forskjellige variabler.

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

534
00:32:30,000 --> 00:32:33,000
Så langt som design er bekymret, noen ganger er det sannsynligvis en bedre idé

535
00:32:33,000 --> 00:32:37,000
å holde variabler lokale når du muligens kan

536
00:32:37,000 --> 00:32:39,000
siden har en haug av globale variable kan bli veldig forvirrende.

537
00:32:39,000 --> 00:32:42,000
Hvis du har en haug med funksjoner all endre samme

538
00:32:42,000 --> 00:32:45,000
du kan glemme hva hvis denne funksjonen ved et uhell endrer denne globale,

539
00:32:45,000 --> 00:32:47,000
og denne andre funksjonen ikke vet om det,

540
00:32:47,000 --> 00:32:50,000
og det får ganske forvirrende som du får mer kode.

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

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

543
00:32:56,000 --> 00:33:00,000
Matriser, husk, er bare lister over elementer av samme type.

544
00:33:00,000 --> 00:33:04,000
Innsiden av CI kan ikke ha en liste som 1, 2,0, hallo.

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

546
00:33:06,000 --> 00:33:11,000
>> Når vi erklærer en matrise i C alle elementene må være av samme type.

547
00:33:11,000 --> 00:33:14,000
Her har jeg en rekke 3 heltall.

548
00:33:14,000 --> 00:33:18,000
Her har jeg lengden på tabellen, men hvis jeg bare erklære det i denne syntaksen

549
00:33:18,000 --> 00:33:21,000
hvor jeg spesifisere hva alle elementene er jeg ikke teknisk trenger dette 3.

550
00:33:21,000 --> 00:33:25,000
Kompilatoren er smart nok til å finne ut hvor stor matrise skal være.

551
00:33:25,000 --> 00:33:28,000
Nå når jeg ønsker å få eller sette verdien av en matrise

552
00:33:28,000 --> 00:33:30,000
Dette er syntaksen som skal gjøre det.

553
00:33:30,000 --> 00:33:33,000
Dette vil faktisk endre andre element i matrisen fordi, huske,

554
00:33:33,000 --> 00:33:36,000
nummerering starter på 0, ikke i en.

555
00:33:36,000 --> 00:33:42,000
Hvis jeg ønsker å lese denne verdien jeg kan si noe sånt som int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Eller hvis jeg ønsker å sette denne verdien, som jeg gjør her,

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

558
00:33:47,000 --> 00:33:50,000
Den tiden tilgang elementer ved deres indeks

559
00:33:50,000 --> 00:33:52,000
eller deres posisjon eller hvor de er i matrisen,

560
00:33:52,000 --> 00:33:57,000
og at oppføringen starter på 0.

561
00:33:57,000 --> 00:34:00,000
Vi kan også ha matriser med arrays,

562
00:34:00,000 --> 00:34:03,000
og dette kalles en multi-dimensjonal array.

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

564
00:34:05,000 --> 00:34:07,000
det betyr at vi kan ha noe som rader og kolonner,

565
00:34:07,000 --> 00:34:11,000
og dette er bare en måte å visualisere dette eller tenke på det.

566
00:34:11,000 --> 00:34:14,000
Når jeg har en multi-dimensjonal array som betyr at jeg kommer til å starte trenger

567
00:34:14,000 --> 00:34:17,000
mer enn 1 indeksen fordi om jeg har et rutenett

568
00:34:17,000 --> 00:34:19,000
bare si hva raden du er i ikke gir oss et tall.

569
00:34:19,000 --> 00:34:22,000
Det er egentlig bare kommer til å gi oss en liste med tall.

570
00:34:22,000 --> 00:34:25,000
La oss si at jeg denne tabellen her.

571
00:34:25,000 --> 00:34:30,000
Jeg har en array kalt rutenett, og jeg sier det er to rader og tre kolonner,

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

573
00:34:32,000 --> 00:34:37,000
Når jeg sier jeg vil få elementet på [1] [2]

574
00:34:37,000 --> 00:34:41,000
det betyr at fordi disse er rader først og deretter kolonner

575
00:34:41,000 --> 00:34:44,000
Jeg kommer til å hoppe til rad 1 siden jeg sa en.

576
00:34:44,000 --> 00:34:49,000
>> Så jeg kommer til å komme over her til kolonne 2, og jeg kommer til å få verdien 6.

577
00:34:49,000 --> 00:34:51,000
Fornuftig?

578
00:34:51,000 --> 00:34:55,000
Multi-dimensjonale arrays, husk, er teknisk bare en rekke arrays.

579
00:34:55,000 --> 00:34:57,000
Vi kan ha matriser av matriser av arrays.

580
00:34:57,000 --> 00:35:00,000
Vi kan holde det gående, men egentlig en måte å tenke på

581
00:35:00,000 --> 00:35:03,000
hvordan dette blir lagt ut og hva som skjer, er å visualisere det

582
00:35:03,000 --> 00:35:09,000
i et rutenett som dette.

583
00:35:09,000 --> 00:35:12,000
Når vi passerer arrays til funksjoner, de kommer til å oppføre seg

584
00:35:12,000 --> 00:35:16,000
litt annerledes enn når vi passerer regelmessig variabler til funksjoner

585
00:35:16,000 --> 00:35:18,000
som passerer en int eller en flåte.

586
00:35:18,000 --> 00:35:21,000
Når vi passerer i en int eller røye eller noen av disse andre datatyper

587
00:35:21,000 --> 00:35:24,000
vi bare tok en titt på om funksjonen modifiserer

588
00:35:24,000 --> 00:35:28,000
verdien av variabelen at endringen ikke kommer til å forplante seg opp

589
00:35:28,000 --> 00:35:32,000
til å kalle funksjonen.

590
00:35:32,000 --> 00:35:35,000
Med en matrise, på den annen side, vil det skje.

591
00:35:35,000 --> 00:35:39,000
Hvis jeg passerer i en matrise til noen funksjon, og at funksjonen endrer noen av elementene,

592
00:35:39,000 --> 00:35:43,000
når jeg kommer tilbake til den funksjonen som kalte det

593
00:35:43,000 --> 00:35:47,000
min matrise er nå kommer til å være annerledes, og ordforrådet for at

594
00:35:47,000 --> 00:35:50,000
er arrays er vedtatt av referanse, som vi skal se senere.

595
00:35:50,000 --> 00:35:53,000
Dette er relatert til hvordan pekere arbeid, der disse grunnleggende datatyper

596
00:35:53,000 --> 00:35:55,000
på den annen side er vedtatt av verdi.

597
00:35:55,000 --> 00:35:59,000
>> Vi kan tenke på det som å lage en kopi av noen variable og deretter passerer i kopien.

598
00:35:59,000 --> 00:36:01,000
Det spiller ingen rolle hva vi gjør med den variabelen.

599
00:36:01,000 --> 00:36:06,000
Den ringer funksjonen vil ikke være klar over at den ble endret.

600
00:36:06,000 --> 00:36:10,000
Arrays er bare litt annerledes i den forbindelse.

601
00:36:10,000 --> 00:36:13,000
For eksempel, som vi nettopp så, er det viktigste bare en funksjon

602
00:36:13,000 --> 00:36:15,000
som kan ta i 2 argumenter.

603
00:36:15,000 --> 00:36:20,000
Det første argumentet til den viktigste funksjonen er argc, eller antall argumenter,

604
00:36:20,000 --> 00:36:23,000
og det andre argumentet kalles argv,

605
00:36:23,000 --> 00:36:27,000
og de er de faktiske verdiene av disse argumentene.

606
00:36:27,000 --> 00:36:30,000
La oss si jeg har et program som heter this.c,

607
00:36:30,000 --> 00:36:34,000
og jeg sier at dette, og jeg kommer til å kjøre dette på kommandolinjen.

608
00:36:34,000 --> 00:36:38,000
Nå for å passere i noen argumenter mitt program kalt dette,

609
00:36:38,000 --> 00:36:42,000
Jeg kan si noe sånt som. / Dette er cs 50.

610
00:36:42,000 --> 00:36:45,000
Dette er hva vi forestille David å gjøre hver dag på terminalen.

611
00:36:45,000 --> 00:36:48,000
Men nå den viktigste funksjonen innsiden av det programmet

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

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

614
00:36:56,000 --> 00:36:58,000
Det er bare tre.

615
00:36:58,000 --> 00:37:02,000
Men husk at det første elementet i argv eller det første argumentet

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

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

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

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

620
00:37:12,970 --> 00:37:18,590
Da de gjenværende elementene er hva vi skrev i etter navnet på programmet.

621
00:37:18,590 --> 00:37:22,720
Så akkurat som en side, som vi trolig så 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 si noe sånt som "int x = argv 3.

624
00:37:32,520 --> 00:37:36,470
>> Det er bare ikke til å være fornuftig, fordi dette er en streng, og dette er et heltall.

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

626
00:37:38,510 --> 00:37:40,810
har denne magisk funksjon kalt atoi.

627
00:37:40,810 --> 00:37:46,270
Som tar en streng og returnerer heltall representert innsiden av strengen.

628
00:37:46,270 --> 00:37:48,360
Så det er en enkel feil å gjøre på quiz,

629
00:37:48,360 --> 00:37:51,590
bare tenker at dette vil automatisk være riktig type.

630
00:37:51,590 --> 00:37:53,860
Men bare vet at disse vil alltid være strenger

631
00:37:53,860 --> 00:38:00,920
selv om strengen inneholder bare et heltall eller et tegn eller en flåte.

632
00:38:00,920 --> 00:38:03,380
Så nå la oss snakke om kjøretid.

633
00:38:03,380 --> 00:38:06,700
Når vi har alle disse algoritmene som gjør alle disse sprø tingene,

634
00:38:06,700 --> 00:38:11,580
det blir veldig nyttig å stille spørsmålet: "Hvor lang tid tar de?"

635
00:38:11,580 --> 00:38:15,500
Vi representerer det med noe som kalles asymptotisk notasjon.

636
00:38:15,500 --> 00:38:18,430
Så dette betyr at - vel, la oss si at vi gir vår algoritme

637
00:38:18,430 --> 00:38:20,840
noen virkelig, virkelig, virkelig stor inngang.

638
00:38:20,840 --> 00:38:23,840
Vi ønsker å stille spørsmålet: "Hvor lenge går det å ta?

639
00:38:23,840 --> 00:38:26,370
Hvor mange skritt vil det ta vår algoritme for å kjøre

640
00:38:26,370 --> 00:38:29,980
som en funksjon av størrelsen på input? "

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

642
00:38:33,080 --> 00:38:35,380
Og dette er vår verste fall kjører tid.

643
00:38:35,380 --> 00:38:38,590
Så hvis vi ønsker å sortere en tabell, og vi gir vår algoritme en rekke

644
00:38:38,590 --> 00:38:41,000
som er i synkende rekkefølge når det skal være i stigende rekkefølge,

645
00:38:41,000 --> 00:38:43,130
som kommer til å være den verste tilfelle.

646
00:38:43,130 --> 00:38:49,800
Dette er vår øvre grense i den maksimale lengden av vår tid algoritme vil ta.

647
00:38:49,800 --> 00:38:54,740
På den annen side er denne Ω skal beskrive beste tilfelle kjøretid.

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

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

650
00:39:00,940 --> 00:39:06,610
Og dette, da, beskriver en nedre grense på kjøretid.

651
00:39:06,610 --> 00:39:10,980
Så her er bare noen ord som beskriver noen vanlige kjører ganger.

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

653
00:39:13,120 --> 00:39:16,060
Den raskeste kjøretid vi har kalles konstant.

654
00:39:16,060 --> 00:39:19,800
>> Det betyr at uansett hvor mange elementer vi gi våre algoritme,

655
00:39:19,800 --> 00:39:22,280
uansett hvor stor vår rekke er, sortere det

656
00:39:22,280 --> 00:39:26,510
eller gjør hva vi gjør til matrisen vil alltid ta like lang tid.

657
00:39:26,510 --> 00:39:30,270
Så vi kan representere at bare med en 1, som er en konstant.

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

659
00:39:32,410 --> 00:39:34,800
Så noe som binære søk er logaritmisk,

660
00:39:34,800 --> 00:39:37,140
der vi kuttet problemet i halvparten hver gang

661
00:39:37,140 --> 00:39:40,970
og deretter ting bare få høyere derfra.

662
00:39:40,970 --> 00:39:43,580
Og hvis du noen gang å skrive en O av noen faktoriell algoritme,

663
00:39:43,580 --> 00:39:47,850
du sannsynligvis ikke bør vurdere dette som dagen din jobb.

664
00:39:47,850 --> 00:39:53,910
Når vi sammenligner kjøretider er det viktig å huske på disse tingene.

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

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

667
00:40:03,590 --> 00:40:06,590
Så hvis vi forestille n å være et stort antall som eleventy milliarder:

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

669
00:40:13,090 --> 00:40:17,640
plutselig at tre ikke gjør virkelig en stor forskjell lenger.

670
00:40:17,640 --> 00:40:20,980
Det er derfor vi kommer til å starte vurderer disse tingene for å være likeverdige.

671
00:40:20,980 --> 00:40:24,220
Så ting som disse konstantene her, det er 2 x dette, eller legge til en 3,

672
00:40:24,220 --> 00:40:27,180
disse er bare konstanter, og disse kommer til å slippe opp.

673
00:40:27,180 --> 00:40:32,480
Så det er derfor alle 3 av disse kjøre ganger er de samme som sier de er O (n).

674
00:40:32,480 --> 00:40:37,490
Tilsvarende, hvis vi har 2 andre kjøre ganger, la oss si O (n ³ + 2n ²), kan vi legge

675
00:40:37,490 --> 00:40:42,070
+ N, + 7, og så har vi en annen kjøring det er bare O (n ³).

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

677
00:40:46,290 --> 00:40:49,840
Dette er de samme tingene, beklager. Så disse er de samme, fordi

678
00:40:49,840 --> 00:40:53,090
dette n ³ kommer til å dominere denne 2n ².

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

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

681
00:41:02,820 --> 00:41:05,470
Så hvis vi har eksponenter, plutselig dette begynner å rolle,

682
00:41:05,470 --> 00:41:08,280
men når vi bare håndtere faktorer som vi er her oppe,

683
00:41:08,280 --> 00:41:12,810
så det kommer ikke til å gjøre noe, fordi de bare kommer til å droppe ut.

684
00:41:12,810 --> 00:41:16,760
La oss ta en titt på noen av de algoritmene vi har sett så langt

685
00:41:16,760 --> 00:41:19,260
og snakke om sin kjøring.

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

687
00:41:23,850 --> 00:41:26,950
Og gjennomføring av lineær søk er super enkelt.

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

689
00:41:30,490 --> 00:41:34,260
før vi finner nummeret vi leter etter.

690
00:41:34,260 --> 00:41:38,370
Så det betyr at i verste fall, denne O (n).

691
00:41:38,370 --> 00:41:40,860
Og verste tilfelle her kan være hvis elementet er

692
00:41:40,860 --> 00:41:45,710
det siste elementet, deretter bruke lineær søk vi må se på hvert enkelt element

693
00:41:45,710 --> 00:41:50,180
før vi kommer til den siste for å vite at det var faktisk på listen.

694
00:41:50,180 --> 00:41:52,910
Vi kan ikke bare gi opp halvveis og si: "Det er nok ikke der."

695
00:41:52,910 --> 00:41:55,980
Med lineær søk må vi se på hele greia.

696
00:41:55,980 --> 00:41:59,090
Best-case gangtid, på den annen side, er konstant

697
00:41:59,090 --> 00:42:04,200
fordi det i beste fall elementet vi leter etter er bare den første i listen.

698
00:42:04,200 --> 00:42:08,930
Så det kommer til å ta oss nøyaktig ett trinn, uansett hvor stor den listen er

699
00:42:08,930 --> 00:42:12,140
hvis vi leter etter det første elementet hver gang.

700
00:42:12,140 --> 00:42:15,390
>> Så når du søker, husk, krever det ikke at vår liste skal sorteres.

701
00:42:15,390 --> 00:42:19,430
Fordi vi bare kommer til å se over hver eneste element, og det spiller ingen rolle

702
00:42:19,430 --> 00:42:23,560
hvilken rekkefølge disse elementene er i.

703
00:42:23,560 --> 00:42:28,110
En mer intelligent søk algoritmen er noe som binære søk.

704
00:42:28,110 --> 00:42:31,500
Husk at gjennomføringen av binære søk når du skal

705
00:42:31,500 --> 00:42:34,320
holde utkikk på midten av listen.

706
00:42:34,320 --> 00:42:38,000
Og fordi vi ser på midten, krever vi at listen er sortert

707
00:42:38,000 --> 00:42:40,580
eller annet vi ikke vet hvor midten er, og vi må se over

708
00:42:40,580 --> 00:42:44,480
hele listen for å finne den, og deretter på det punktet er vi bare kaster bort tiden.

709
00:42:44,480 --> 00:42:48,480
Så hvis vi har en sortert liste, og vi finner midten, vi kommer til å sammenligne midten

710
00:42:48,480 --> 00:42:51,590
til elementet vi leter etter.

711
00:42:51,590 --> 00:42:54,640
Hvis det er for høyt, så kan vi glemme den høyre halvdelen

712
00:42:54,640 --> 00:42:57,810
fordi vi vet at om vårt element er allerede for høy

713
00:42:57,810 --> 00:43:01,080
og alt til høyre for dette elementet er enda høyere,

714
00:43:01,080 --> 00:43:02,760
så vi trenger ikke å se det lenger.

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

716
00:43:05,430 --> 00:43:08,700
vi vet alt til venstre for at elementet er også for lav,

717
00:43:08,700 --> 00:43:11,390
så det gjør ikke egentlig fornuftig å se det, heller.

718
00:43:11,390 --> 00:43:15,760
Denne måten, med hvert skritt og hver gang vi ser på midtpunktet av listen,

719
00:43:15,760 --> 00:43:19,060
vi kommer til å kutte vårt problem i halvparten fordi vi plutselig vite

720
00:43:19,060 --> 00:43:23,040
en hel haug med tall som ikke kan være den vi leter etter.

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

722
00:43:26,950 --> 00:43:30,990
og fordi vi kutte listen i halvparten hver eneste gang,

723
00:43:30,990 --> 00:43:34,920
våre worst-case kjøretidsberegninger hopper fra lineær til logaritmisk.

724
00:43:34,920 --> 00:43:39,260
Så plutselig har vi log-in skritt for å finne et element i en liste.

725
00:43:39,260 --> 00:43:42,460
Den beste fall kjører tid, men er fortsatt konstant

726
00:43:42,460 --> 00:43:45,180
fordi nå, la oss bare si at elementet vi leter etter er

727
00:43:45,180 --> 00:43:48,380
alltid den nøyaktige midten av den opprinnelige listen.

728
00:43:48,380 --> 00:43:52,080
Så vi kan øke vår liste så stor som vi ønsker, men hvis elementet vi leter etter er på midten,

729
00:43:52,080 --> 00:43:54,910
så er det bare kommer til å ta oss en trinn.

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
La oss faktisk kjøre binært søk på denne listen.

732
00:44:04,510 --> 00:44:08,020
Så la oss si at vi leter etter elementet 164.

733
00:44:08,020 --> 00:44:11,650
Det første vi skal gjøre er å finne midtpunktet av denne listen.

734
00:44:11,650 --> 00:44:15,060
Det bare så skjer at midtpunktet kommer til å falle i mellom disse to tallene,

735
00:44:15,060 --> 00:44:18,960
så la oss bare vilkårlig si, hver gang midtpunktet faller mellom to tall,

736
00:44:18,960 --> 00:44:21,150
la oss bare runde opp.

737
00:44:21,150 --> 00:44:24,330
Vi trenger bare å sørge for at vi gjør dette hvert steg på veien.

738
00:44:24,330 --> 00:44:29,040
Så vi kommer til å runde opp, og vi kommer til å si at 161 er midt i vår 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 vet at det ikke kommer til å hjelpe oss i det hele tatt

741
00:44:39,120 --> 00:44:42,690
å begynne å se over her fordi elementet vi leter etter kan ikke være der.

742
00:44:42,690 --> 00:44:47,060
Så hva vi kan gjøre er at vi kan bare glemme at hele venstre halvdel av listen,

743
00:44:47,060 --> 00:44:51,700
og nå bare vurdere fra høyre side av 161 framover.

744
00:44:51,700 --> 00:44:54,050
>> Så igjen, dette er midtpunktet, la oss bare runde opp.

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

746
00:44:56,260 --> 00:44:59,180
Så vi vet at det ikke kommer til å hjelpe oss ser her eller her,

747
00:44:59,180 --> 00:45:06,610
så vi kan bare kaste det bort, og til slutt vil vi treffer 164.

748
00:45:06,610 --> 00:45:10,560
Eventuelle spørsmål om binære søk?

749
00:45:10,560 --> 00:45:14,180
La oss gå videre fra å søke gjennom et allerede sortert liste

750
00:45:14,180 --> 00:45:17,660
å faktisk ta en liste med tall i hvilken som helst rekkefølge

751
00:45:17,660 --> 00:45:20,960
og gjør den listen i stigende rekkefølge.

752
00:45:20,960 --> 00:45:24,060
Den første algoritmen vi så på ble kalt boble slag.

753
00:45:24,060 --> 00:45:27,300
Og dette ville være enklere av algoritmer vi så.

754
00:45:27,300 --> 00:45:32,970
Boble slags sier at når noen 2 elementer inne i listen er malplassert,

755
00:45:32,970 --> 00:45:36,500
betyr at det er et høyere tall til venstre for et lavere antall,

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

757
00:45:40,190 --> 00:45:42,860
"Mer sortert" enn det var før.

758
00:45:42,860 --> 00:45:45,180
Og vi bare kommer til å fortsette denne prosessen igjen og igjen og igjen

759
00:45:45,180 --> 00:45:52,100
før slutt elementene slags boble til riktig sted og vi har en sortert liste.

760
00:45:52,100 --> 00:45:57,230
>> Kjøretiden for denne kommer til å være O (n ²). Hvorfor?

761
00:45:57,230 --> 00:46:00,370
Vel, fordi i verste fall, vi kommer til å ta hvert element, og

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

763
00:46:04,570 --> 00:46:08,030
Men i beste fall har vi en allerede sortert liste, boble sortere er

764
00:46:08,030 --> 00:46:12,230
bare kommer til å gå gjennom en gang, sier "Nope. jeg ikke gjøre noen bytter, så jeg er ferdig."

765
00:46:12,230 --> 00:46:17,410
Så vi har et best-case kjøretid på Ω (n).

766
00:46:17,410 --> 00:46:20,680
La oss kjøre boble sortere på en liste.

767
00:46:20,680 --> 00:46:23,560
Eller først, la oss bare se på noen pseudokode veldig raskt.

768
00:46:23,560 --> 00:46:28,160
Vi ønsker å si at vi ønsker å holde styr på, i alle iterasjon av loopen,

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

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

771
00:46:37,610 --> 00:46:41,980
Så ved starten av løkken vår har vi ikke byttet noe, så vi får si det er falsk.

772
00:46:41,980 --> 00:46:47,170
Nå skal vi gå gjennom listen og sammenligne element i å element i + 1

773
00:46:47,170 --> 00:46:50,310
og hvis det er slik at det er et større antall til venstre for et mindre tall,

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

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

776
00:46:54,490 --> 00:46:58,900
Det betyr at vi trenger å gå gjennom listen minst 1 gang

777
00:46:58,900 --> 00:47:02,160
fordi tilstanden der vi stoppet er når hele listen er allerede sortert,

778
00:47:02,160 --> 00:47:04,890
som betyr at vi ikke har gjort noen bytter.

779
00:47:04,890 --> 00:47:09,960
Så det er derfor vår tilstand her nede er "mens noen elementer har blitt byttet.

780
00:47:09,960 --> 00:47:13,720
Så nå la oss bare se på dette som kjø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 sortere skal starte helt på venstre, og det kommer til å sammenligne

783
00:47:19,850 --> 00:47:24,700
The I elementene, så 0 til i + 1, som er elementet 1.

784
00:47:24,700 --> 00:47:29,020
Det kommer til å si, vel 5> 0, men akkurat nå 5 er til venstre,

785
00:47:29,020 --> 00:47:32,500
så jeg trenger å bytte 5 og 0.

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

787
00:47:35,470 --> 00:47:38,260
Nå 5> 1, så vi kommer til å bytte dem.

788
00:47:38,260 --> 00:47:42,160
5 er ikke> 6, så vi trenger ikke å gjøre noe her.

789
00:47:42,160 --> 00:47:46,690
Men 6> 4, så vi trenger å bytte.

790
00:47:46,690 --> 00:47:49,740
Igjen må vi kjøre gjennom hele listen til slutt oppdage

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

792
00:47:52,330 --> 00:47:57,120
og på dette punktet må vi kjøre gjennom listen en gang til

793
00:47:57,120 --> 00:48:05,390
å sørge for at alt er i orden sin, og på dette punktet boble slags er ferdig.

794
00:48:05,390 --> 00:48:10,720
En annen algoritme for å ta noen elementer og sortere dem er valg slag.

795
00:48:10,720 --> 00:48:15,740
Ideen bak utvalget typen er at vi kommer til å bygge opp en sortert del av listen

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

797
00:48:18,150 --> 00:48:23,170
>> Og måten vi skal gjøre det på er ved å bygge opp den venstre delen av listen.

798
00:48:23,170 --> 00:48:27,510
Og i utgangspunktet, hver - på hvert trinn, vi kommer til å ta den minste elementet vi har igjen

799
00:48:27,510 --> 00:48:32,310
som ikke har blitt sortert ennå, og vi kommer til å flytte den inn i det sortert segmentet.

800
00:48:32,310 --> 00:48:35,850
Det betyr at vi må kontinuerlig finne minimum usortert element

801
00:48:35,850 --> 00:48:40,720
og deretter ta det minimum element og bytte det med hva

802
00:48:40,720 --> 00:48:45,090
venstre-mest element som ikke er sortert.

803
00:48:45,090 --> 00:48:50,890
Den kjører tid dette kommer til å være O (n ²) fordi i verste fall

804
00:48:50,890 --> 00:48:55,070
vi trenger å sammenligne hver enkelt element til alle andre element.

805
00:48:55,070 --> 00:48:59,250
Fordi vi sier at hvis vi starter på venstre halvdel av listen, må vi

806
00:48:59,250 --> 00:49:02,970
å gå gjennom hele høyre segment å finne det minste elementet.

807
00:49:02,970 --> 00:49:05,430
Og så, igjen, må vi gå over hele høyre segment og

808
00:49:05,430 --> 00:49:08,210
holde gå over at over og over og over igjen.

809
00:49:08,210 --> 00:49:11,350
Det kommer til å være n ². Vi kommer til å trenge en for løkke inne i en annen for loop

810
00:49:11,350 --> 00:49:13,350
noe som antyder n ².

811
00:49:13,350 --> 00:49:16,530
I beste fall tanken, la oss si at vi gir den en allerede sortert liste;

812
00:49:16,530 --> 00:49:19,270
vi faktisk ikke gjøre noe bedre enn n ².

813
00:49:19,270 --> 00:49:21,730
Fordi utvalget slags har ingen måte å vite at

814
00:49:21,730 --> 00:49:25,540
minimum element er bare den jeg tilfeldigvis være å se på.

815
00:49:25,540 --> 00:49:28,970
Det må likevel sørge for at dette faktisk er et minimum.

816
00:49:28,970 --> 00:49:31,670
>> Og den eneste måten å sørge for at det er minimum, ved hjelp av denne algoritmen,

817
00:49:31,670 --> 00:49:34,640
er å se på hvert enkelt element på nytt.

818
00:49:34,640 --> 00:49:38,420
Så egentlig, hvis du gir den - hvis du gir utvalget sortere en allerede sortert liste,

819
00:49:38,420 --> 00:49:42,720
det er ikke til å gjøre noe bedre enn å gi det en liste som ikke er sortert ennå.

820
00:49:42,720 --> 00:49:46,320
Forresten, hvis det skjer for å være tilfelle at noe er O (noe)

821
00:49:46,320 --> 00:49:50,640
og omega for noe, kan vi bare si mer konsist at det er θ av noe.

822
00:49:50,640 --> 00:49:52,760
Så hvis du ser at kommer opp hvor som helst, det er hva det betyr bare.

823
00:49:52,760 --> 00:49:57,580
>> Hvis noe er theta av n ², er det både store O (n ²) og Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Så best case og worst case, betyr det ikke gjøre en forskjell,

825
00:49:59,790 --> 00:50:04,400
algoritmen kommer til å gjøre det samme hver gang.

826
00:50:04,400 --> 00:50:06,610
Så dette er hva pseudokode for valg slags kunne se ut.

827
00:50:06,610 --> 00:50:10,630
Vi er i utgangspunktet tenkt å si at jeg ønsker å iterere over listen

828
00:50:10,630 --> 00:50:15,180
fra venstre til høyre, og på hver iterasjon av loopen, jeg kommer til å flytte

829
00:50:15,180 --> 00:50:19,780
minimum elementet inn dette sortert del av listen.

830
00:50:19,780 --> 00:50:23,260
Og når jeg flytter noe der, jeg trenger aldri å se på dette elementet på nytt.

831
00:50:23,260 --> 00:50:28,600
Fordi så snart jeg bytte et element i den venstre delen av listen, er det sortert

832
00:50:28,600 --> 00:50:32,600
fordi vi gjør alt i stigende rekkefølge ved hjelp av minimumskrav.

833
00:50:32,600 --> 00:50:38,740
Så vi sa, ok, vi i posisjon i, og vi trenger å se på alle elementene

834
00:50:38,740 --> 00:50:42,260
til høyre for i i for å finne den minste.

835
00:50:42,260 --> 00:50:46,150
Så det betyr at vi ønsker å se fra i + 1 til slutten av listen.

836
00:50:46,150 --> 00:50:51,610
Og nå, hvis elementet som vi for tiden ser på er mindre enn minimum vår så langt,

837
00:50:51,610 --> 00:50:54,190
som, husk, vi starter minimum av å bare være

838
00:50:54,190 --> 00:50:57,020
uansett element vi er nå på, jeg vil anta det er minimum.

839
00:50:57,020 --> 00:51:00,270
Hvis jeg finner et element som er mindre enn det, så jeg kommer til å si, ok,

840
00:51:00,270 --> 00:51:02,700
vel, jeg har funnet en ny minimum.

841
00:51:02,700 --> 00:51:06,080
Jeg kommer til å huske hvor det minimum var.

842
00:51:06,080 --> 00:51:09,560
>> Så nå, når jeg har gått gjennom det høyre usortert segment,

843
00:51:09,560 --> 00:51:16,690
Jeg kan si jeg kommer til å bytte den minste element med elementet som er i posisjon i.

844
00:51:16,690 --> 00:51:21,100
Det kommer til å bygge opp min liste, min sortert del av listen fra venstre til høyre,

845
00:51:21,100 --> 00:51:25,190
og vi ikke trenger å se på et element på nytt når den er i den delen.

846
00:51:25,190 --> 00:51:27,930
Når vi har byttet den.

847
00:51:27,930 --> 00:51:30,260
Så la oss kjøre utvalg sortere på denne listen.

848
00:51:30,260 --> 00:51:38,220
Den blå element her kommer til å bli i, og den røde element kommer til å være det minste elementet.

849
00:51:38,220 --> 00:51:41,570
Så jeg begynner helt til venstre på listen, så på 5.

850
00:51:41,570 --> 00:51:44,610
Nå må vi finne minimum usortert element.

851
00:51:44,610 --> 00:51:49,480
Så vi sier 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 gjenkjenne at 0 er den minste,

853
00:51:53,820 --> 00:51:59,390
vi trenger å kjøre gjennom alle andre element i listen for å være sikker.

854
00:51:59,390 --> 00:52:01,760
Så en er større, er 6 større, er 4 større.

855
00:52:01,760 --> 00:52:05,850
Det betyr at etter å se på alle disse elementene, har jeg bestemt 0 er den minste.

856
00:52:05,850 --> 00:52:09,800
Så jeg kommer til å bytte 5 og 0.

857
00:52:09,800 --> 00:52:15,480
Når jeg bytte det, kommer jeg til å få en ny liste, og jeg vet at jeg aldri trenger å se på at 0 igjen

858
00:52:15,480 --> 00:52:19,380
fordi når jeg har byttet den, har jeg sortert det og vi er ferdige.

859
00:52:19,380 --> 00:52:22,730
Nå er det bare så skjer at den blå element er igjen 5,

860
00:52:22,730 --> 00:52:26,030
og vi trenger å se på 1, 6 og 4 for å fastslå at en

861
00:52:26,030 --> 00:52:31,520
er den minste minimum element, slik at vi vil bytte 1 og 5.

862
00:52:31,520 --> 00:52:36,890
Igjen må vi se på - sammenligne 5 til 6 og 4,

863
00:52:36,890 --> 00:52:39,830
og vi kommer til å bytte 4 og 5, og til slutt, sammenligne

864
00:52:39,830 --> 00:52:45,740
de to tallene og bytte dem inntil vi får vår sortert liste.

865
00:52:45,740 --> 00:52:49,730
Eventuelle spørsmål om valg sort?

866
00:52:49,730 --> 00:52:56,420
Okay. La oss flytte til det siste temaet her, og det er rekursjon.

867
00:52:56,420 --> 00:52:59,810
>> Rekursjon, husk, dette er virkelig meta ting der en funksjon

868
00:52:59,810 --> 00:53:02,740
gjentatte ganger kaller seg.

869
00:53:02,740 --> 00:53:05,620
Så på et tidspunkt, mens vår fuction er gjentatte ganger kaller seg,

870
00:53:05,620 --> 00:53:10,100
det må være et tidspunkt der vi slutte å kalle oss selv.

871
00:53:10,100 --> 00:53:13,670
Fordi hvis vi ikke gjør det, så vi bare kommer til å fortsette å gjøre dette for alltid,

872
00:53:13,670 --> 00:53:16,660
og vårt program er bare ikke til å si opp.

873
00:53:16,660 --> 00:53:19,200
Vi kaller denne tilstanden base case.

874
00:53:19,200 --> 00:53:22,570
Og basen saken sier, snarere enn å ringe en funksjon igjen,

875
00:53:22,570 --> 00:53:25,330
Jeg bare kommer til å returnere noen verdi.

876
00:53:25,330 --> 00:53:28,080
Så når vi har kommet tilbake en verdi, har vi sluttet å ringe oss,

877
00:53:28,080 --> 00:53:32,550
og resten av samtalene vi har gjort så langt kan også returnere.

878
00:53:32,550 --> 00:53:36,050
Det motsatte av basen saken er den rekursive tilfelle.

879
00:53:36,050 --> 00:53:39,050
Og dette er når vi ønsker å foreta et nytt anrop til funksjonen som vi er nå i.

880
00:53:39,050 --> 00:53:44,690
Og vi sannsynligvis, men ikke alltid, vil bruke forskjellige argumenter.

881
00:53:44,690 --> 00:53:48,940
>> Så hvis vi har en funksjon som heter f, og f bare kalt ta en argument,

882
00:53:48,940 --> 00:53:52,010
og vi bare holde ringer f (1), f (1), f (1), og det bare så skjer at

883
00:53:52,010 --> 00:53:56,510
argumentet en faller i rekursiv tilfelle, vi likevel aldri kommer til å stoppe.

884
00:53:56,510 --> 00:54:01,620
Selv om vi har en base case, må vi sørge for at vi til slutt kommer til å treffe base case.

885
00:54:01,620 --> 00:54:04,250
Vi har ikke bare holde bor i dette rekursive tilfellet.

886
00:54:04,250 --> 00:54:09,870
Vanligvis, når vi kaller oss, vi sannsynligvis kommer til å ha en annen argument hver gang.

887
00:54:09,870 --> 00:54:12,700
Her er en veldig enkel rekursiv funksjon.

888
00:54:12,700 --> 00:54:15,090
Så dette vil beregne fakultet til et tall.

889
00:54:15,090 --> 00:54:17,790
Opp toppen her vi har vår base case.

890
00:54:17,790 --> 00:54:22,330
I tilfelle at n ≤ 1, vi kommer ikke til å ringe fakultet igjen.

891
00:54:22,330 --> 00:54:26,490
Vi kommer til å stoppe, vi bare kommer til å returnere noen verdi.

892
00:54:26,490 --> 00:54:30,170
Hvis dette ikke er sant, så vi kommer til å treffe våre rekursiv tilfelle.

893
00:54:30,170 --> 00:54:33,550
Legg merke til her at vi ikke bare kalle fakultet (n), fordi det ikke ville være svært nyttig.

894
00:54:33,550 --> 00:54:36,810
Vi kommer til å kalle fakultet av noe annet.

895
00:54:36,810 --> 00:54:40,850
>> Og så kan du se, til slutt hvis vi passerer en faktorielt (5) eller noe,

896
00:54:40,850 --> 00:54:45,900
vi kommer til å kalle fakultet (4) og så videre, og til slutt skal vi treffe denne base case.

897
00:54:45,900 --> 00:54:51,730
Så dette ser bra ut. La oss se hva som skjer når vi faktisk kjøre dette.

898
00:54:51,730 --> 00:54:57,840
Dette er bunken, og la oss si at main kommer til å kalle denne funksjonen med et argument (4).

899
00:54:57,840 --> 00:55:02,200
Så når fakultet ser og = 4, vil fakultet kalle seg.

900
00:55:02,200 --> 00:55:05,010
Nå, plutselig, har vi fakultet (3).

901
00:55:05,010 --> 00:55:10,780
Så disse funksjonene skal vokse inntil vi til slutt traff vår base case.

902
00:55:10,780 --> 00:55:17,830
På dette punktet, er returverdien av dette avkastningen (nx returverdien av dette),

903
00:55:17,830 --> 00:55:21,290
returverdien av dette er nx returverdien av dette.

904
00:55:21,290 --> 00:55:23,290
Til slutt må vi treffe noen tall.

905
00:55:23,290 --> 00:55:26,560
På toppen her, sier vi tilbake en.

906
00:55:26,560 --> 00:55:30,650
Det betyr at når vi kommer tilbake det nummeret, kan vi pop dette av stabelen.

907
00:55:30,650 --> 00:55:36,570
Så dette fakultet (1) er gjort.

908
00:55:36,570 --> 00:55:41,190
Når en er tilbake, denne faktorielle (1) returer, denne avkastningen til en.

909
00:55:41,190 --> 00:55:46,910
Returverdien av dette, husk, var nx returverdien av dette.

910
00:55:46,910 --> 00:55:50,720
Så plutselig, vet denne fyren som jeg ønsker å gå tilbake to.

911
00:55:50,720 --> 00:55:55,910
>> Så husk, tilbake verdien av dette er bare nx returverdien opp her.

912
00:55:55,910 --> 00:56:01,160
Så nå kan vi si 3 x 2, og til slutt, her kan vi si

913
00:56:01,160 --> 00:56:04,010
dette er bare kommer til å være 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Og når dette kommer tilbake, får vi ned til en enkelt heltall innsiden av main.

915
00:56:09,570 --> 00:56:15,460
Eventuelle spørsmål om rekursjon?

916
00:56:15,460 --> 00:56:17,090
OK. Så det er mer tid til spørsmål på slutten,

917
00:56:17,090 --> 00:56:23,360
men nå Joseph vil dekke de resterende emnene.

918
00:56:23,360 --> 00:56:25,590
>> [Joseph Ong] Greit. Så nå som vi har snakket om rekursjoner,

919
00:56:25,590 --> 00:56:27,840
la oss snakke litt om hva fusjonere slags er.

920
00:56:27,840 --> 00:56:31,740
Flette sort er i utgangspunktet en annen måte å sortere en liste med tall.

921
00:56:31,740 --> 00:56:36,430
Og hvordan det fungerer er, med fletting typen du har en liste, og det vi gjør er

922
00:56:36,430 --> 00:56:39,120
vi sier, la oss dele dette inn i to halvdeler.

923
00:56:39,120 --> 00:56:42,750
Vi vil først kjøre flette sortere igjen på venstre halvdel,

924
00:56:42,750 --> 00:56:45,040
så får vi kjøre flette slag på høyre halvdel,

925
00:56:45,040 --> 00:56:50,240
og det gir oss nå 2 halvdeler som er sortert, og nå skal vi kombinere disse halvdelene sammen.

926
00:56:50,240 --> 00:56:55,010
Det er litt vanskelig å se uten et eksempel, så vi vil gå gjennom bevegelser og se hva som skjer.

927
00:56:55,010 --> 00:56:59,590
Så du begynner med denne listen, vi delt det inn i to halvdeler.

928
00:56:59,590 --> 00:57:02,300
Vi kjører flette slag på venstre halvdel først.

929
00:57:02,300 --> 00:57:06,660
Så det er den venstre halvdelen, og nå har vi kjørt dem gjennom denne listen igjen

930
00:57:06,660 --> 00:57:09,800
som blir ført inn fusjonere sortere, og vi ser igjen,

931
00:57:09,800 --> 00:57:13,270
på venstre side av denne listen og kjøre vi flette sorter på den.

932
00:57:13,270 --> 00:57:15,880
Nå får vi ned til en liste over 2 tall,

933
00:57:15,880 --> 00:57:19,010
og nå den venstre halvdelen er bare 1 element lang, og vi kan ikke

934
00:57:19,010 --> 00:57:23,380
dele en liste som er bare 1 element i halv, så vi bare si, når vi har 50,

935
00:57:23,380 --> 00:57:26,400
som er bare 1 element, er det allerede sortert.

936
00:57:26,400 --> 00:57:29,860
>> Når vi er ferdige med det, kan vi se at vi kan

937
00:57:29,860 --> 00:57:32,230
gå videre til høyre halvdel av denne listen,

938
00:57:32,230 --> 00:57:36,480
og 3 er også sortert, og så nå at begge halvdelene av denne listen er sortert

939
00:57:36,480 --> 00:57:39,080
Vi kan delta i disse tallene sammen.

940
00:57:39,080 --> 00:57:45,320
Så vi ser på 50 og 3, 3 er mindre enn 50, så det går i første og deretter 50 kommer inn

941
00:57:45,320 --> 00:57:49,340
Nå er det gjort, vi går tilbake til den listen og sortere det er høyre halvdel.

942
00:57:49,340 --> 00:57:52,440
42 er det egne tall, så det er allerede sortert.

943
00:57:52,440 --> 00:57:57,850
Så nå er vi sammenligne disse 2 og 3 er mindre enn 42, så det blir satt inn først,

944
00:57:57,850 --> 00:58:02,340
nå 42 blir satt inn, og 50 blir satt i.

945
00:58:02,340 --> 00:58:07,220
Nå, det er sortert, går vi helt tilbake til toppen, 1337 og 15.

946
00:58:07,220 --> 00:58:14,560
Vel, vi nå ser på den venstre halvdelen av denne listen, 1337 er i seg selv så det er sortert og samme med 15.

947
00:58:14,560 --> 00:58:19,020
Så nå har vi kombinere disse to tallene å sortere det opprinnelige listen, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
så det går i først, deretter 1337 går i.

949
00:58:23,060 --> 00:58:26,640
Og nå har vi sortert begge halvdelene av den opprinnelige listen opp toppen.

950
00:58:26,640 --> 00:58:30,440
Og alt vi trenger å gjøre er å kombinere disse.

951
00:58:30,440 --> 00:58:36,890
Vi ser på de 2 første numrene til denne listen, 3 <15, så det går inn i slags matrise først.

952
00:58:36,890 --> 00:58:44,460
15 <42, så det går i. Nå, 42 <1337, som går i.

953
00:58:44,460 --> 00:58:51,010
50 <1337, så det går i. Og legg merke til at vi bare tok 2 tall ut av denne listen.

954
00:58:51,010 --> 00:58:53,640
Slik at vi ikke bare vekslende mellom de 2 listene.

955
00:58:53,640 --> 00:58:56,050
Vi ser bare i begynnelsen, og vi tar elementet

956
00:58:56,050 --> 00:59:00,270
det er mindre og deretter sette det inn matrise vår.

957
00:59:00,270 --> 00:59:04,080
Nå har vi slått sammen alle halvdeler og vi er ferdige.

958
00:59:04,080 --> 00:59:07,780
>> Eventuelle spørsmål om utskriftsfletting sort? Ja?

959
00:59:07,780 --> 00:59:14,190
[Student] Hvis det er splitting i ulike grupper, hvorfor ikke de bare dele det en gang

960
00:59:14,190 --> 00:59:19,970
og du har 3 og 2 i en gruppe? [Resten av spørsmålet uforståelig]

961
00:59:19,970 --> 00:59:24,940
Grunnen - så spørsmålet er, hvorfor kan vi ikke bare slå dem på det første skrittet etter at vi har dem?

962
00:59:24,940 --> 00:59:29,530
Grunnen til at vi kan gjøre dette, starter på venstre de fleste elementer på begge sider,

963
00:59:29,530 --> 00:59:33,040
og deretter ta den mindre og sette det inn, er at vi vet at disse

964
00:59:33,040 --> 00:59:35,290
enkelte listene er i sortert bestillinger.

965
00:59:35,290 --> 00:59:37,290
Så hvis jeg ser på lengst til venstre elementer av begge omganger,

966
00:59:37,290 --> 00:59:40,490
Jeg vet at de kommer til å være de minste elementene i disse listene.

967
00:59:40,490 --> 00:59:43,930
Så jeg kan sette dem inn i de minste element flekker av denne store listen.

968
00:59:43,930 --> 00:59:47,810
På den annen side, hvis jeg ser på de to listene i det andre nivået der borte,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 og 15, er de som ikke sorteres.

970
00:59:51,640 --> 00:59:55,770
Så hvis jeg ser på 50 og 1337, kommer jeg til å sette 50 inn liste min første.

971
00:59:55,770 --> 01:00:00,130
Men det gjør ikke egentlig fornuftig, fordi 3 er det minste elementet ut av alle disse.

972
01:00:00,130 --> 01:00:04,390
Så den eneste grunnen til at vi kan gjøre dette kombinere trinnet er fordi våre lister er allerede sortert.

973
01:00:04,390 --> 01:00:07,010
Som er grunnen til at vi må få ned hele veien til bunnen

974
01:00:07,010 --> 01:00:09,800
fordi når vi har bare et enkelt tall, vet du at et enkelt tall

975
01:00:09,800 --> 01:00:14,120
i seg selv er allerede en sortert liste.

976
01:00:14,120 --> 01:00:19,360
>> Eventuelle spørsmål? Nei?

977
01:00:19,360 --> 01:00:24,260
Kompleksitet? Vel, kan du se at på hvert trinn er det slutt tall,

978
01:00:24,260 --> 01:00:27,590
og vi kan dele en liste i halvparten log n ganger,

979
01:00:27,590 --> 01:00:31,700
som er der vi får dette n x log n kompleksitet.

980
01:00:31,700 --> 01:00:34,940
Og du vil se den beste saken for flettingen sort er n log n, og det bare så skjer

981
01:00:34,940 --> 01:00:39,340
at verste fall, eller Ω der borte, er også n log n.

982
01:00:39,340 --> 01:00:42,480
Noe å huske på.

983
01:00:42,480 --> 01:00:45,750
Flytte på, la oss gå videre til noen super grunnleggende fil I / O.

984
01:00:45,750 --> 01:00:48,830
Hvis du har sett på Scramble, vil du legge merke vi hadde noen form for system

985
01:00:48,830 --> 01:00:51,270
hvor du kan skrive til en loggfil hvis du leser gjennom koden.

986
01:00:51,270 --> 01:00:53,730
La oss se hvordan du kan gjøre det.

987
01:00:53,730 --> 01:00:57,450
Vel, vi har fprintf, som du kan tenke på som bare printf,

988
01:00:57,450 --> 01:01:01,720
men bare skrive til en fil i stedet, og dermed f i begynnelsen.

989
01:01:01,720 --> 01:01:07,570
Denne typen kode her oppe, hva den gjør er, som du kanskje har sett i Scramble,

990
01:01:07,570 --> 01:01:12,310
det går gjennom to-dimensjonal array utskrift ut rad for rad hva tallene er.

991
01:01:12,310 --> 01:01:17,850
I dette tilfellet, skriver printf ut til terminalen eller hva vi kaller standard utgang av delen.

992
01:01:17,850 --> 01:01:22,170
>> Og nå, i dette tilfellet, er alt vi trenger å gjøre bytte printf med fprintf,

993
01:01:22,170 --> 01:01:26,770
fortelle den hva filen du vil skrive ut på, og i dette tilfellet bare det skrives det ut til at filen

994
01:01:26,770 --> 01:01:32,230
stedet for å skrive den ut til terminalen.

995
01:01:32,230 --> 01:01:36,500
Vel, da ber spørsmålet: Hvor får vi denne typen fil fra, ikke sant?

996
01:01:36,500 --> 01:01:39,840
Vi passerte logge på denne fprintf fuction men vi hadde ingen anelse om hvor det kom fra.

997
01:01:39,840 --> 01:01:43,980
Vel, tidlig i koden, hva vi hadde var denne del av koden over her,

998
01:01:43,980 --> 01:01:48,340
som sier i utgangspunktet at åpne filen kaller log.txt.

999
01:01:48,340 --> 01:01:53,220
Hva vi gjør etter det er vi nødt til å sørge for at filen faktisk åpnet vellykket.

1000
01:01:53,220 --> 01:01:57,070
Så det kan mislykkes av flere grunner, du har ikke nok plass på datamaskinen, for eksempel.

1001
01:01:57,070 --> 01:01:59,790
Så det er alltid viktig før du gjør noen operasjoner med filen

1002
01:01:59,790 --> 01:02:03,300
at vi sjekker om filen ble åpnet vellykket.

1003
01:02:03,300 --> 01:02:09,330
Så hva det en, er at et argument til fopen, vel, kan vi åpne en fil på mange måter.

1004
01:02:09,330 --> 01:02:13,510
Hva vi kan gjøre er, kan vi gi det w, noe som betyr overstyre filen hvis det kommer allerede,

1005
01:02:13,510 --> 01:02:18,070
Vi kan passere en a, som de føyer til slutten av filen i stedet tilsidesette den,

1006
01:02:18,070 --> 01:02:22,730
eller vi kan spesifisere r, noe som betyr, la oss åpne filen som skrivebeskyttet.

1007
01:02:22,730 --> 01:02:24,890
Så hvis programmet forsøker å gjøre noen endringer i filen,

1008
01:02:24,890 --> 01:02:30,140
kjefte på dem og ikke la dem gjøre det.

1009
01:02:30,140 --> 01:02:33,320
Til slutt, når vi er ferdig med filen, gjort gjør operasjoner på det,

1010
01:02:33,320 --> 01:02:35,860
Vi må sørge for at vi lukke filen.

1011
01:02:35,860 --> 01:02:38,830
Og så på slutten av programmet, skal du passere dem igjen

1012
01:02:38,830 --> 01:02:42,120
denne filen som du åpnet, og bare lukke den.

1013
01:02:42,120 --> 01:02:44,650
Så dette er noe viktig som du må sørge for at du gjør.

1014
01:02:44,650 --> 01:02:47,180
Så husk at du kan åpne en fil, så kan du skrive til filen,

1015
01:02:47,180 --> 01:02:51,270
gjøre operasjoner i filen, men da må du lukke filen på slutten.

1016
01:02:51,270 --> 01:02:53,270
>> Eventuelle spørsmål om grunnleggende fil I / O? Ja?

1017
01:02:53,270 --> 01:02:58,050
[Student spørsmål, uforståelig]

1018
01:02:58,050 --> 01:03:02,480
Akkurat her. Spørsmålet er, der gjør dette Log.txt vises?

1019
01:03:02,480 --> 01:03:07,890
Vel, hvis du bare gi den log.txt, skaper det den i samme katalog som den kjørbare.

1020
01:03:07,890 --> 01:03:10,500
Så hvis du har kommet - >> [Student spørsmål, uforståelig]

1021
01:03:10,500 --> 01:03:18,830
Ja. I samme mappe, eller i samme katalog, som du kaller det.

1022
01:03:18,830 --> 01:03:21,400
Nå minne, stack, og heap.

1023
01:03:21,400 --> 01:03:23,400
Så hvordan er minne lagt ut i datamaskinen?

1024
01:03:23,400 --> 01:03:26,270
Vel, du kan forestille minne som liksom denne blokken her.

1025
01:03:26,270 --> 01:03:30,260
Og i minnet har vi det som kalles haug fast der, og stakken som er der nede.

1026
01:03:30,260 --> 01:03:34,480
Og haugen vokser nedover og stakken vokser oppover.

1027
01:03:34,480 --> 01:03:38,620
Så som Tommy nevnt - oh, vel, og vi har disse andre 4 segmenter som jeg vil komme til i et sekund -

1028
01:03:38,620 --> 01:03:42,890
Som Tommy sa tidligere, vet du hvordan hans funksjoner selv ringe og ringe hverandre?

1029
01:03:42,890 --> 01:03:44,930
De bygger opp denne typen stabelen ramme.

1030
01:03:44,930 --> 01:03:47,360
Vel, hvis viktigste samtaler foo, blir foo satt på stakken.

1031
01:03:47,360 --> 01:03:52,430
Foo kaller bar, bar få oss sette på stakken, og som blir satt på bunken etter.

1032
01:03:52,430 --> 01:03:57,040
Og som de kommer tilbake, de hver får tatt av stabelen.

1033
01:03:57,040 --> 01:04:00,140
Hva holder hver av disse stedene og minne gjøre?

1034
01:04:00,140 --> 01:04:03,110
Vel, inneholder toppen, som er den tekstsegment, selve programmet.

1035
01:04:03,110 --> 01:04:06,390
Så maskinkode, som er der når du kompilere programmet.

1036
01:04:06,390 --> 01:04:08,520
Neste, noen initialisert globale variabler.

1037
01:04:08,520 --> 01:04:12,660
>> Så du har globale variabler i programmet, og si at du liker, a = 5,

1038
01:04:12,660 --> 01:04:15,260
som blir satt i det segmentet, og rett under det,

1039
01:04:15,260 --> 01:04:18,990
du har noen uinitialiserte globale data, som er int bare en,

1040
01:04:18,990 --> 01:04:20,990
men du ikke si det er lik noe.

1041
01:04:20,990 --> 01:04:23,870
Innse disse er globale variabler, så de er utenfor viktigste.

1042
01:04:23,870 --> 01:04:28,560
Så dette betyr noen globale variabler som deklareres, men er ikke initialisert.

1043
01:04:28,560 --> 01:04:32,310
Så hva er i haugen? Minnebruken bruker malloc, som vi vil komme til i en liten bit.

1044
01:04:32,310 --> 01:04:35,990
Og til slutt, med bunken har du noen lokale variabler

1045
01:04:35,990 --> 01:04:39,950
og eventuelle funksjoner du kan ringe inn noen av sine parametere.

1046
01:04:39,950 --> 01:04:43,720
Det siste, trenger du egentlig ikke trenger å vite hva miljøvariabler gjøre,

1047
01:04:43,720 --> 01:04:46,700
men når du kjører programmet, det er noe forbundet, som

1048
01:04:46,700 --> 01:04:49,550
Dette er brukernavnet til personen som kjørte programmet.

1049
01:04:49,550 --> 01:04:51,550
Og det kommer til å være slags nederst.

1050
01:04:51,550 --> 01:04:54,540
I form av minneadresser, som er heksadesimalverdier,

1051
01:04:54,540 --> 01:04:58,170
verdiene øverst start på 0, og de går hele veien ned til bunnen.

1052
01:04:58,170 --> 01:05:00,440
I dette tilfellet, hvis du er på 32-bit system,

1053
01:05:00,440 --> 01:05:05,390
adressen nederst kommer til å være 0x, etterfulgt av af, fordi det er 32 biter,

1054
01:05:05,390 --> 01:05:10,890
som er 8 byte, og i dette tilfellet 8 byte tilsvarer åtte heksadesimale sifre.

1055
01:05:10,890 --> 01:05:20,110
Så her nede du kommer til å ha, liker, 0xffffff, og der oppe du kommer til å ha 0.

1056
01:05:20,110 --> 01:05:23,660
Så hva er pekere? Noen av dere har kanskje ikke dekket dette i avsnittet før.

1057
01:05:23,660 --> 01:05:26,660
men vi gikk over den i foredraget, så en peker er bare en datatype

1058
01:05:26,660 --> 01:05:34,030
hvilke butikker, i stedet for noen slags verdi som 50 lagrer den adressen til noen sted i minnet.

1059
01:05:34,030 --> 01:05:36,020
Sånn minne [uforståelig].

1060
01:05:36,020 --> 01:05:41,120
Så i dette tilfellet, hva vi har er, har vi en peker til et heltall eller en int *,

1061
01:05:41,120 --> 01:05:46,210
og den inneholder denne heksadesimale adressen 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Så det vi har er nå, dette peker på noen sted i minnet,

1063
01:05:50,880 --> 01:05:56,020
og det er bare en, er verdien 50 på denne minneplassen.

1064
01:05:56,020 --> 01:06:01,810
På noen 32-bits systemer, på alle 32-bits systemer, pekere ta opp 32 biter eller 4 byte.

1065
01:06:01,810 --> 01:06:06,020
Men, for eksempel på en 64-bits system, pekere er 64 bits.

1066
01:06:06,020 --> 01:06:08,040
Så det er noe du ønsker å huske på.

1067
01:06:08,040 --> 01:06:12,310
Så på en slutt-bit system, er en peker kantskjær lang.

1068
01:06:12,310 --> 01:06:17,320
Pekere er slags vanskelig å fordøye uten ekstra ting,

1069
01:06:17,320 --> 01:06:20,300
så la oss gå gjennom et eksempel på dynamisk minne allokering.

1070
01:06:20,300 --> 01:06:25,130
Hva dynamisk minne allokering gjør for deg, eller hva vi kaller malloc,

1071
01:06:25,130 --> 01:06:29,280
den lar deg fordele noen form for data utenfor settet.

1072
01:06:29,280 --> 01:06:31,830
Så disse opplysninger er slags mer permanent for varigheten av programmet.

1073
01:06:31,830 --> 01:06:36,430
Fordi som du vet, hvis du deklarerer x innsiden av en funksjon, og at funksjonen returnerer,

1074
01:06:36,430 --> 01:06:40,910
du ikke lenger har tilgang til dataene som ble lagret i x.

1075
01:06:40,910 --> 01:06:44,420
Hva pekere la oss gjøre er de la oss lagre minne eller lagre verdier

1076
01:06:44,420 --> 01:06:46,840
i en annen del av minnet, nemlig haugen.

1077
01:06:46,840 --> 01:06:49,340
Nå når vi går tilbake ut av funksjon, så lenge vi har en peker

1078
01:06:49,340 --> 01:06:54,960
til det stedet i minnet, så hva vi kan gjøre er at vi kan bare se på verdiene der.

1079
01:06:54,960 --> 01:06:58,020
La oss se på et eksempel: Dette er vår hukommelse layout igjen.

1080
01:06:58,020 --> 01:07:00,050
Og vi har denne funksjonen, main.

1081
01:07:00,050 --> 01:07:06,870
Hva den gjør er - okay, så enkelt, ikke sant? - Int x = 5, det er bare en variabel på stabelen i hovedvinduet.

1082
01:07:06,870 --> 01:07:12,450
>> På den annen side, nå er vi erklærer en peker som kaller funksjonen giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
Og så nå går vi inn i denne funksjonen, og vi oppretter en ny bunke ramme for det.

1084
01:07:16,800 --> 01:07:20,440
Men i denne bunken ramme, erklærer vi int * temp,

1085
01:07:20,440 --> 01:07:23,210
som i mallocs 3 heltall for oss.

1086
01:07:23,210 --> 01:07:25,880
Så størrelsen på int vil gi oss hvor mange byte denne int er,

1087
01:07:25,880 --> 01:07:29,620
og malloc gir oss at mange byte av plass på haugen.

1088
01:07:29,620 --> 01:07:32,890
Så i dette tilfellet, har vi skapt nok plass til tre heltall,

1089
01:07:32,890 --> 01:07:36,830
og haugen er veien opp dit, og det er derfor jeg har trukket den høyere opp.

1090
01:07:36,830 --> 01:07:42,900
Når vi er ferdig, vi kommer tilbake hit, trenger du bare tre ints tilbake,

1091
01:07:42,900 --> 01:07:47,000
og den returnerer adressen, i dette tilfellet over hvor at minnet er.

1092
01:07:47,000 --> 01:07:51,250
Og vi setter pekeren = bryteren, og der oppe har vi bare en annen pekeren.

1093
01:07:51,250 --> 01:07:54,550
Men hva som fungerer avkastning er stablet her og forsvinner.

1094
01:07:54,550 --> 01:07:59,250
Så temp forsvinner, men vi fortsatt opprettholde adressen der

1095
01:07:59,250 --> 01:08:01,850
de tre heltall er inne i strømnettet.

1096
01:08:01,850 --> 01:08:06,180
Så i dette settet, pekere er scoped lokalt for stablet ramme,

1097
01:08:06,180 --> 01:08:09,860
men minnet som de henviser er i haugen.

1098
01:08:09,860 --> 01:08:12,190
>> Gjør det fornuftig?

1099
01:08:12,190 --> 01:08:14,960
[Student] Kan du gjenta det? >> [Joseph] Ja.

1100
01:08:14,960 --> 01:08:20,270
Så hvis jeg går tilbake bare en liten bit, ser du at temp tildelt

1101
01:08:20,270 --> 01:08:23,500
noe minne på haugen der oppe.

1102
01:08:23,500 --> 01:08:28,680
Så når denne funksjonen, giveMeThreeInts avkastning, er denne bunken her kommer til å forsvinne.

1103
01:08:28,680 --> 01:08:35,819
Og med det noen av variablene, i dette tilfellet, denne pekeren som ble tildelt i stablet ramme.

1104
01:08:35,819 --> 01:08:39,649
Som kommer til å forsvinne, men siden vi returnerte temp

1105
01:08:39,649 --> 01:08:46,330
og vi setter pekeren = temp, peker nå går til å peke i samme minne plassering som temp var.

1106
01:08:46,330 --> 01:08:50,370
Så nå, selv om vi mister temp, at lokal pekeren,

1107
01:08:50,370 --> 01:08:59,109
vi fortsatt beholde minnet adressen på hva det var som peker til innsiden av den variabelen pekeren.

1108
01:08:59,109 --> 01:09:03,740
Spørsmål? Det kan være slag av en forvirrende emnet hvis du ikke har gått over det i snitt.

1109
01:09:03,740 --> 01:09:09,240
Vi kan, vil TF definitivt gå over det og selvfølgelig kan vi svare på spørsmål

1110
01:09:09,240 --> 01:09:11,500
ved slutten av gjennomgangen sesjon for dette.

1111
01:09:11,500 --> 01:09:14,220
Men dette er liksom et komplekst tema, og jeg har flere eksempler som kommer til å dukke opp

1112
01:09:14,220 --> 01:09:18,790
som vil bidra til å avklare hva pekere faktisk er.

1113
01:09:18,790 --> 01:09:22,500
>> I dette tilfellet, pekere er tilsvarer matriser,

1114
01:09:22,500 --> 01:09:25,229
så jeg kan bare bruke denne pekeren som det samme som en int array.

1115
01:09:25,229 --> 01:09:29,840
Så jeg indeksering inn 0, og endre den første heltall til 1,

1116
01:09:29,840 --> 01:09:39,689
endre andre heltall til 2, og den tredje heltall til 3.

1117
01:09:39,689 --> 01:09:44,210
Så mer på pekere. Vel, husker Binky.

1118
01:09:44,210 --> 01:09:48,319
I dette tilfellet har vi tildelt en peker, eller vi erklært en peker,

1119
01:09:48,319 --> 01:09:52,760
men i utgangspunktet, når jeg nettopp erklært en peker, det er ikke peker til hvor som helst i minnet.

1120
01:09:52,760 --> 01:09:54,930
Det er bare søppel tall inne i den.

1121
01:09:54,930 --> 01:09:56,470
Så jeg har ingen anelse om hvor denne pekeren peker til.

1122
01:09:56,470 --> 01:10:01,630
Den har en adresse som er bare fylt med 0 og 1-ere der den opprinnelig ble erklært.

1123
01:10:01,630 --> 01:10:04,810
Jeg kan ikke gjøre noe med dette før jeg kaller malloc på det

1124
01:10:04,810 --> 01:10:08,390
og da det gir meg en liten plass på haugen hvor jeg kan sette verdier inne.

1125
01:10:08,390 --> 01:10:11,980
Så igjen, jeg vet ikke hva som er på innsiden av dette minnet.

1126
01:10:11,980 --> 01:10:16,780
Så det første jeg må gjøre er å sjekke om systemet hadde nok minne

1127
01:10:16,780 --> 01:10:20,850
å gi meg tilbake en heltall i første omgang, og det er derfor jeg gjør dette sjekk.

1128
01:10:20,850 --> 01:10:25,020
Hvis pekeren er null, betyr det at det ikke har nok plass eller annen feil har oppstått,

1129
01:10:25,020 --> 01:10:26,320
så jeg skal gå ut av programmet mitt.

1130
01:10:26,320 --> 01:10:29,400
 Men hvis det lyktes, nå kan jeg bruke den peker

1131
01:10:29,400 --> 01:10:35,020
og hva * pekeren gjør er det følger hvor adressen er

1132
01:10:35,020 --> 01:10:38,480
hvor denne verdien er, og det setter den lik en.

1133
01:10:38,480 --> 01:10:41,850
Så over her, vi sjekker om det minnet eksisterte.

1134
01:10:41,850 --> 01:10:45,380
>> Når du vet det finnes, kan du sette inn i den

1135
01:10:45,380 --> 01:10:50,460
hvilken verdi du ønsker å legge i det, i dette tilfellet en.

1136
01:10:50,460 --> 01:10:53,060
Når vi er ferdig med det, må du frigjøre at pekeren

1137
01:10:53,060 --> 01:10:57,160
fordi vi trenger å komme tilbake til det systemet som minnet som du ba om i første omgang.

1138
01:10:57,160 --> 01:10:59,690
Fordi datamaskinen ikke vet når vi er ferdig med det.

1139
01:10:59,690 --> 01:11:02,510
I dette tilfellet er vi eksplisitt forteller det, ok, vi er ferdige med dette minnet.

1140
01:11:02,510 --> 01:11:10,780
Hvis en annen prosess trenger det, et annet program trenger det, gjerne gå videre og ta den.

1141
01:11:10,780 --> 01:11:15,110
Hva vi kan også gjøre er at vi kan bare få adressen lokale variabler på settet.

1142
01:11:15,110 --> 01:11:19,080
Så int x er innenfor stablet rammen av main.

1143
01:11:19,080 --> 01:11:23,060
Og når vi bruker denne ampersand, dette og operatør, hva den gjør er

1144
01:11:23,060 --> 01:11:27,310
det tar x, og x er bare noen data i minnet, men det har en adresse.

1145
01:11:27,310 --> 01:11:33,790
Det ligger et sted. Så ved å ringe & x, hva dette betyr er det gir oss adressen x.

1146
01:11:33,790 --> 01:11:38,430
Ved å gjøre dette, gjør vi pekeren peker til hvor x er i minnet.

1147
01:11:38,430 --> 01:11:41,710
Nå er vi bare gjøre noe sånt * x, vi kommer til å få 5 tilbake.

1148
01:11:41,710 --> 01:11:43,820
Stjernen kalles dereferencing det.

1149
01:11:43,820 --> 01:11:46,640
Du følger den adressen og du får verdien av det som er lagret der.

1150
01:11:51,000 --> 01:11:53,310
>> Eventuelle spørsmål? Ja?

1151
01:11:53,310 --> 01:11:56,500
[Student] Hvis du ikke gjør det 3-spiss ting, gjør det likevel kompilere?

1152
01:11:56,500 --> 01:11:59,490
Ja. Hvis du ikke gjør det 3-pekeren ting, er det fortsatt kommer til å kompilere,

1153
01:11:59,490 --> 01:12:02,720
men jeg skal vise deg hva som skjer i et sekund, og uten å gjøre det,

1154
01:12:02,720 --> 01:12:04,860
det er hva vi kaller en minnelekkasje. Du ikke gir systemet

1155
01:12:04,860 --> 01:12:07,850
tilbake sin hukommelse, så etter en stund programmet kommer til å akkumulere

1156
01:12:07,850 --> 01:12:10,940
minne som det ikke er bruk, og ingenting annet kan bruke den.

1157
01:12:10,940 --> 01:12:15,750
Hvis du noensinne har sett Firefox med 1,5 millioner kilobyte på datamaskinen,

1158
01:12:15,750 --> 01:12:17,840
i oppgaven manager, det er hva som skjer.

1159
01:12:17,840 --> 01:12:20,760
Du har en minnelekkasje i programmet at de ikke håndterer.

1160
01:12:23,080 --> 01:12:26,240
Så hvordan pekeren aritmetiske arbeid?

1161
01:12:26,240 --> 01:12:29,480
Vel, er pekeren aritmetiske liksom som indeksering inn i en matrise.

1162
01:12:29,480 --> 01:12:36,370
I dette tilfellet har jeg en peker, og hva jeg gjør er jeg gjør pekeren peker til det første elementet

1163
01:12:36,370 --> 01:12:42,100
av denne matrisen av 3 heltall som jeg har tildelt.

1164
01:12:42,100 --> 01:12:46,670
Så nå hva jeg gjør, endrer stjerne pekeren bare det første elementet i listen.

1165
01:12:46,670 --> 01:12:49,140
Stjerners pekeren en poeng over her.

1166
01:12:49,140 --> 01:12:53,140
Så pekeren er over her, er pekeren en over her, er pekeren to over her.

1167
01:12:53,140 --> 01:12:56,610
>> Så bare legge en er det samme som å flytte langs denne matrisen.

1168
01:12:56,610 --> 01:12:59,880
Hva vi gjør er, når vi gjør pekeren en du få adressen over her,

1169
01:12:59,880 --> 01:13:04,180
og for å få verdien her, legger du en stjerne i fra hele uttrykket

1170
01:13:04,180 --> 01:13:05,990
å dereferanse det.

1171
01:13:05,990 --> 01:13:09,940
Så, i dette tilfellet, jeg sette første beliggenhet i dette matrise til 1,

1172
01:13:09,940 --> 01:13:13,970
andre beliggenhet til 2, og tredje sted til 3.

1173
01:13:13,970 --> 01:13:18,180
Så hva jeg gjør over her er jeg skrive vår pekeren +1,

1174
01:13:18,180 --> 01:13:19,970
som gir meg to.

1175
01:13:19,970 --> 01:13:23,650
Nå er jeg inkrementering pekeren, så peker tilsvarer pekeren +1,

1176
01:13:23,650 --> 01:13:26,780
som beveger den frem.

1177
01:13:26,780 --> 01:13:30,810
Og så nå hvis jeg skriver ut pekeren +1, er pekeren en nå 3,

1178
01:13:30,810 --> 01:13:33,990
som i dette tilfelle skrives ut 3.

1179
01:13:33,990 --> 01:13:36,560
Og for å frigjøre noe, pekeren at jeg gir det

1180
01:13:36,560 --> 01:13:40,540
må peke på begynnelsen av tabellen som jeg kom tilbake fra malloc.

1181
01:13:40,540 --> 01:13:43,430
Så, i dette tilfellet, hvis jeg skulle ringe tre her, ville dette ikke være riktig,

1182
01:13:43,430 --> 01:13:45,070
fordi den er i midten av matrisen.

1183
01:13:45,070 --> 01:13:48,820
Jeg må trekke for å komme til den opprinnelige plasseringen

1184
01:13:48,820 --> 01:13:50,420
den innledende første sted før jeg kan få det løs.

1185
01:13:56,300 --> 01:13:58,450
Så, her er en mer involvert eksempel.

1186
01:13:58,450 --> 01:14:03,360
I dette tilfellet, vi fordele 7 tegn i et tegn array.

1187
01:14:03,360 --> 01:14:06,480
>> Og i dette tilfellet hva vi gjør er at vi looping over den første 6 av dem,

1188
01:14:06,480 --> 01:14:09,900
og vi setter 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å peker + jeg vil bare gi oss, i dette tilfellet,

1191
01:14:16,220 --> 01:14:20,860
pekeren, en pekeren, 2 pekeren, 3 pekeren, og så videre og så videre i loop.

1192
01:14:20,860 --> 01:14:24,040
Hva det kommer til å gjøre er det blir den adressen, dereferences det å få verdien,

1193
01:14:24,040 --> 01:14:27,440
og endringer som verdi til en Z.

1194
01:14:27,440 --> 01:14:30,350
Deretter på slutten huske dette er en streng, ikke sant?

1195
01:14:30,350 --> 01:14:33,560
Alle strenger må slutte med null avslutning karakter.

1196
01:14:33,560 --> 01:14:38,620
Så, det jeg gjør er i peker 6 la jeg null terminator tegnet i.

1197
01:14:38,620 --> 01:14:43,980
Og nå hva jeg egentlig gjør her borte gjennomfører printf for en streng, ikke sant?

1198
01:14:43,980 --> 01:14:46,190
>> Så, når printf nå når det har nådd slutten av en streng?

1199
01:14:46,190 --> 01:14:48,230
Når den treffer null avslutte tegn.

1200
01:14:48,230 --> 01:14:52,030
Så, i dette tilfellet, min opprinnelige peker til begynnelsen av denne tabellen.

1201
01:14:52,030 --> 01:14:56,410
Jeg skriver inn det første tegnet ut. Jeg flytter den over ett.

1202
01:14:56,410 --> 01:14:58,420
Jeg skriver det tegnet ut. Jeg flytter den over.

1203
01:14:58,420 --> 01:15:02,180
Og jeg holder på til jeg når slutten.

1204
01:15:02,180 --> 01:15:07,750
Og nå til slutt * pekeren vil dereference dette og få null avslutte tegn tilbake.

1205
01:15:07,750 --> 01:15:11,780
Og så min mens loop kjører bare når denne verdien ikke er null avslutte tegn.

1206
01:15:11,780 --> 01:15:13,770
Så nå er jeg gå ut av denne loopen.

1207
01:15:18,780 --> 01:15:21,180
Og så hvis jeg trekker 6 fra denne pekeren,

1208
01:15:21,180 --> 01:15:22,860
Jeg går tilbake helt til begynnelsen.

1209
01:15:22,860 --> 01:15:27,880
Husk, jeg gjør dette fordi jeg må gå til begynnelsen for å frigjøre den.

1210
01:15:27,880 --> 01:15:30,270
>> Så, jeg vet det var mye. Er det noen spørsmål?

1211
01:15:30,270 --> 01:15:31,870
Vær så snill, ja?

1212
01:15:31,870 --> 01:15:36,610
[Student spørsmålet uforståelig]

1213
01:15:36,610 --> 01:15:38,190
Kan du si at høyere? Unnskyld.

1214
01:15:38,190 --> 01:15:44,140
[Student] På det siste lysbildet rett før du frigjort pekeren,

1215
01:15:44,140 --> 01:15:47,300
hvor ble du faktisk endre verdien av pekeren?

1216
01:15:47,300 --> 01:15:50,370
[Joseph] Så akkurat her. >> [Student] Oh, okay.

1217
01:15:50,370 --> 01:15:51,890
[Joseph] Så har jeg en peker minus minus, høyre,

1218
01:15:51,890 --> 01:15:54,140
som flytter ting tilbake en, og da jeg frigjøre det,

1219
01:15:54,140 --> 01:15:57,000
fordi denne pekeren har å bli henvist til begynnelsen av tabellen.

1220
01:15:57,000 --> 01:16:00,420
[Student] Men det ville ikke være nødvendig hvis du hadde stoppet etter den linjen.

1221
01:16:00,420 --> 01:16:03,130
[Joseph] Så hvis jeg hadde stoppet etter dette, ville dette bli betraktet som en minnelekkasje,

1222
01:16:03,130 --> 01:16:04,810
fordi jeg ikke kjøre gratis.

1223
01:16:04,810 --> 01:16:11,290
[Student] I [uforståelig] etter de tre første linjene der du hadde markøren en [uforståelig].

1224
01:16:11,290 --> 01:16:13,140
[Joseph] Uh-huh. Så, hva er spørsmålet der?

1225
01:16:13,140 --> 01:16:14,780
Unnskyld. Nei, nei. Gå, gå, takk.

1226
01:16:14,780 --> 01:16:16,870
[Student] Så, er du ikke endre verdien av pekere.

1227
01:16:16,870 --> 01:16:19,130
Du ville ikke ha hatt å gjøre pekeren minus minus.

1228
01:16:19,130 --> 01:16:19,730
[Joseph] Ja, akkurat.

1229
01:16:19,730 --> 01:16:21,890
Så, når jeg gjør pekeren en og peker +2,

1230
01:16:21,890 --> 01:16:24,410
Jeg er ikke gjør pekeren lik pekeren +1.

1231
01:16:24,410 --> 01:16:27,260
Så pekeren bare forblir peker på begynnelsen av tabellen.

1232
01:16:27,260 --> 01:16:31,460
Det er bare når jeg gjør pluss pluss at det setter verdien tilbake inne pekeren,

1233
01:16:31,460 --> 01:16:33,550
at den beveger seg faktisk dette sammen.

1234
01:16:36,860 --> 01:16:37,780
OK.

1235
01:16:40,550 --> 01:16:42,030
Flere spørsmål?

1236
01:16:44,680 --> 01:16:47,790
>> Igjen, hvis dette er slags overveldende, vil dette bli dekket i økten.

1237
01:16:47,790 --> 01:16:50,710
Spør din undervisning stipendiat om det, og vi kan svare på spørsmål på slutten.

1238
01:16:53,510 --> 01:16:56,600
Og vanligvis vi ikke liker å gjøre dette minus ting.

1239
01:16:56,600 --> 01:16:59,760
Dette må kreve meg å holde styr på hvor mye jeg har forskjøvet i tabellen.

1240
01:16:59,760 --> 01:17:04,520
Så, generelt, er dette bare for å forklare hvordan pekeren aritmetiske fungerer.

1241
01:17:04,520 --> 01:17:07,970
Men hva vi vanligvis liker å gjøre er vi ønsker å lage en kopi av pekeren,

1242
01:17:07,970 --> 01:17:11,640
og så får vi bruke dette eksemplaret når vi flytter rundt i strengen.

1243
01:17:11,640 --> 01:17:14,660
Så, i disse tilfelle du bruker kopien til å skrive ut hele strengen,

1244
01:17:14,660 --> 01:17:19,040
men vi trenger ikke å gjøre som peker minus 6 eller holde styr på hvor mye vi flyttet i dette,

1245
01:17:19,040 --> 01:17:22,700
bare fordi vi vet at vår opprinnelige punktet er fortsatt pekt på begynnelsen av listen

1246
01:17:22,700 --> 01:17:25,340
og alt som vi endret var denne kopien.

1247
01:17:25,340 --> 01:17:28,250
Så generelt, endre kopier av den opprinnelige pekeren.

1248
01:17:28,250 --> 01:17:32,350
Ikke prøv å sortere av som - ikke endre originale kopier.

1249
01:17:32,350 --> 01:17:35,290
Prøver å endre bare kopier av originalen.

1250
01:17:41,540 --> 01:17:44,870
Så, du merker når vi passerer strengen til printf

1251
01:17:44,870 --> 01:17:48,990
du trenger ikke å sette en stjerne foran det som vi gjorde med alle de andre dereferences, ikke sant?

1252
01:17:48,990 --> 01:17:54,180
Så hvis du skriver ut hele strengen% s forventer er en adresse,

1253
01:17:54,180 --> 01:17:57,610
og i dette tilfellet en peker eller i dette tilfellet som en rekke tegn.

1254
01:17:57,610 --> 01:18:00,330
>> Tegn, char * s, og arrayer er det samme.

1255
01:18:00,330 --> 01:18:03,690
Pointer er å tegn, og tegn arrays er det samme.

1256
01:18:03,690 --> 01:18:05,720
Og så, er pass alt vi trenger å gjøre i pekeren.

1257
01:18:05,720 --> 01:18:08,150
Vi trenger ikke å passere i like * pekeren eller noe sånt.

1258
01:18:13,110 --> 01:18:14,930
Så, arrays og pekere er det samme.

1259
01:18:14,930 --> 01:18:19,160
Når du gjør noe sånt x [y] over her for en matrise,

1260
01:18:19,160 --> 01:18:21,960
hva det gjør under panseret er det å si, ok, det er et tegn array,

1261
01:18:21,960 --> 01:18:23,690
så det er en peker.

1262
01:18:23,690 --> 01:18:26,510
Og så x er det samme,

1263
01:18:26,510 --> 01:18:28,650
og så hva den gjør er det legger y til x,

1264
01:18:28,650 --> 01:18:31,820
som er det samme som å flytte frem i minnet så mye.

1265
01:18:31,820 --> 01:18:34,930
Og nå x + y gir oss en slags adresse,

1266
01:18:34,930 --> 01:18:37,570
og vi dereferanse adressen eller følg pilen

1267
01:18:37,570 --> 01:18:41,640
hvor den plasseringen i minnet er og vi får verdi ut av det sted i minnet.

1268
01:18:41,640 --> 01:18:43,720
Så, så disse to er akkurat 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 gjør det samme. De er bare forskjellige syntactics for hverandre.

1271
01:18:51,500 --> 01:18:57,590
>> Så, hva kan gå galt med pekere? Som, mye. Okay. Så dårlige ting.

1272
01:18:57,590 --> 01:19:02,410
Noen dårlige ting du kan gjøre er ikke å sjekke om din malloc kallet returnerer null, ikke sant?

1273
01:19:02,410 --> 01:19:06,560
I dette tilfellet, ber jeg om systemet for å gi meg - hva er det nummeret?

1274
01:19:06,560 --> 01:19:11,200
Som 2 milliarder ganger 4, fordi størrelsen av et heltall er 4 byte.

1275
01:19:11,200 --> 01:19:13,810
Jeg ber den for som 8 milliarder bytes.

1276
01:19:13,810 --> 01:19:17,270
Selvfølgelig min datamaskin ikke kommer til å være i stand til å gi meg så mye minne tilbake.

1277
01:19:17,270 --> 01:19:20,960
Og vi fikk ikke sjekke om dette er null, så når vi prøver å dereference det der -

1278
01:19:20,960 --> 01:19:24,270
følge pilen til hvor det kommer til å - vi har ikke det minnet.

1279
01:19:24,270 --> 01:19:27,150
Dette er hva vi kaller dereferencing en nullpeker.

1280
01:19:27,150 --> 01:19:29,710
Og dette fører i hovedsak å segfault.

1281
01:19:29,710 --> 01:19:31,790
Dette er en av måtene du kan segfault.

1282
01:19:34,090 --> 01:19:38,090
Andre dårlige ting du kan gjøre - nåvel.

1283
01:19:38,090 --> 01:19:40,650
Det var dereferencing en nullpeker. Okay.

1284
01:19:40,650 --> 01:19:45,160
Andre dårlige ting - vel, for å fikse at du bare sette en sjekk der

1285
01:19:45,160 --> 01:19:46,980
som sjekker om pekeren er null

1286
01:19:46,980 --> 01:19:51,000
og gå ut av programmet hvis det skjer at malloc returnerer en nullpeker.

1287
01:19:55,110 --> 01:19:59,850
Det er xkcd komisk. Folk forstår det nå. Liksom.

1288
01:20:06,120 --> 01:20:09,350
>> Så, minne. Og jeg gikk over dette.

1289
01:20:09,350 --> 01:20:12,000
Vi kaller malloc i en loop, men hver gang vi kaller malloc

1290
01:20:12,000 --> 01:20:14,370
vi mister oversikten over hvor denne pekeren peker til,

1291
01:20:14,370 --> 01:20:15,750
fordi vi clobbering det.

1292
01:20:15,750 --> 01:20:18,410
Så gir den første telefonsamtalen til malloc meg minne over her.

1293
01:20:18,410 --> 01:20:19,990
Min pekeren pekere til dette.

1294
01:20:19,990 --> 01:20:23,020
Nå, jeg vet ikke frigjøre det, så nå er jeg kaller malloc igjen.

1295
01:20:23,020 --> 01:20:26,070
Nå er det peker over her. Nå er min hukommelse peker over her.

1296
01:20:26,070 --> 01:20:27,640
Peker over her. Peker over her.

1297
01:20:27,640 --> 01:20:31,820
Men jeg har mistet oversikten over adressene til alle minnet over her at jeg tildelt.

1298
01:20:31,820 --> 01:20:35,100
Og så nå er jeg ikke har noen referanse til dem lenger.

1299
01:20:35,100 --> 01:20:37,230
Så, jeg kan ikke fri dem utenfor denne sløyfen.

1300
01:20:37,230 --> 01:20:39,390
Og så for å fikse noe som dette,

1301
01:20:39,390 --> 01:20:42,250
Hvis du glemmer å frigjøre minne, og du får denne minnelekkasje,

1302
01:20:42,250 --> 01:20:45,810
Du må frigjøre minne innsiden av denne sløyfen når du er ferdig med det.

1303
01:20:45,810 --> 01:20:51,400
Vel, dette er hva som skjer. Jeg vet hater mange av dere dette.

1304
01:20:51,400 --> 01:20:55,270
Men nå - yay! Du får som 44000 kilobyte.

1305
01:20:55,270 --> 01:20:57,110
Så frigjøre deg det på slutten av loopen,

1306
01:20:57,110 --> 01:20:59,770
og det kommer til å bare frigjøre minne hver gang.

1307
01:20:59,770 --> 01:21:03,620
Hovedsak, ikke programmet ikke har en minnelekkasje lenger.

1308
01:21:03,620 --> 01:21:08,150
>> Og nå noe annet du kan gjøre er å frigjøre minne som du har bedt om to ganger.

1309
01:21:08,150 --> 01:21:11,060
I dette tilfellet, du malloc noe, endrer du verdien.

1310
01:21:11,060 --> 01:21:13,140
Du frigjøre det en gang fordi du sa at du var ferdig med den.

1311
01:21:13,140 --> 01:21:14,940
Men da vi frigjort det igjen.

1312
01:21:14,940 --> 01:21:16,730
Dette er noe som er ganske ille.

1313
01:21:16,730 --> 01:21:18,820
Det kommer ikke til å begynne med segfault,

1314
01:21:18,820 --> 01:21:23,350
men etter en stund hva dette betyr er dobbelt frigjøre dette ødelegger din heap struktur,

1315
01:21:23,350 --> 01:21:27,200
og du vil lære litt mer om dette hvis du velger å ta en klasse som CS61.

1316
01:21:27,200 --> 01:21:30,000
Men i hovedsak etter en stund datamaskinen kommer til å bli forvirret

1317
01:21:30,000 --> 01:21:33,010
om hva minneplasser er der og hvor det er lagret -

1318
01:21:33,010 --> 01:21:34,800
hvor data er lagret i minnet.

1319
01:21:34,800 --> 01:21:38,080
Og så frigjør en peker er dobbelt en dårlig ting som du ikke ønsker å gjøre.

1320
01:21:38,080 --> 01:21:41,600
>> Andre ting som kan gå galt er å ikke bruke sizeof.

1321
01:21:41,600 --> 01:21:44,460
Så, i dette tilfellet malloc du 8 byte,

1322
01:21:44,460 --> 01:21:46,700
og det er det samme som to heltall, ikke sant?

1323
01:21:46,700 --> 01:21:49,580
Så, det er helt trygt, men er det?

1324
01:21:49,580 --> 01:21:52,160
Vel, som Lucas snakket om på ulike arkitekturer,

1325
01:21:52,160 --> 01:21:54,220
heltall er av forskjellige lengder.

1326
01:21:54,220 --> 01:21:57,970
Så, på apparatet du bruker, heltall er ca 4 bytes,

1327
01:21:57,970 --> 01:22:02,370
men på en annen system kan de være 8 byte, eller de kan være 16 bytes.

1328
01:22:02,370 --> 01:22:05,680
Så, hvis jeg bare bruke dette nummeret over her,

1329
01:22:05,680 --> 01:22:07,310
dette programmet kan fungere på apparatet,

1330
01:22:07,310 --> 01:22:10,360
men det er ikke til å allokere nok minne på noen andre system.

1331
01:22:10,360 --> 01:22:14,020
I dette tilfellet er dette hva sizeof operatør brukes til.

1332
01:22:14,020 --> 01:22:16,880
Når vi kaller sizeof (int), hva dette betyr er

1333
01:22:16,880 --> 01:22:21,910
 det gir oss størrelsen av et heltall på systemet at programmet kjøres.

1334
01:22:21,910 --> 01:22:25,490
Så, i dette tilfellet, vil sizeof (int) returnere 4 på noe sånt apparatet,

1335
01:22:25,490 --> 01:22:29,980
og nå dette vil 4 * 2, som er 8,

1336
01:22:29,980 --> 01:22:32,330
som er bare mengden plass nødvendig for to heltall.

1337
01:22:32,330 --> 01:22:36,710
På et annet system, hvis en int er som 16 byte eller 8 byte,

1338
01:22:36,710 --> 01:22:39,380
det er bare kommer til å returnere nok byte til å lagre dette beløpet.

1339
01:22:41,830 --> 01:22:45,310
>> Og til slutt, structs.

1340
01:22:45,310 --> 01:22:48,340
Så, hvis du ønsket å lagre en sudoku bord i minnet, kan hvordan vi gjør dette?

1341
01:22:48,340 --> 01:22:51,570
Du tenker kanskje som en variabel for det første,

1342
01:22:51,570 --> 01:22:53,820
en variabel for andre ting, en variabel for tredje tingen,

1343
01:22:53,820 --> 01:22:56,420
en variabel for fjerde ting - dårlig, ikke sant?

1344
01:22:56,420 --> 01:23:00,750
Så, er en forbedring du kan gjøre på toppen av dette for å gjøre en 9 x 9 matrise.

1345
01:23:00,750 --> 01:23:04,480
Det er fint, men hva om du ønsket å knytte andre ting med sudoku styret

1346
01:23:04,480 --> 01:23:06,490
liker det vanskeligheten av styret er,

1347
01:23:06,490 --> 01:23:11,740
eller, for eksempel, hva poengsummen din er, eller hvor mye tid det har tatt å løse dette brettet?

1348
01:23:11,740 --> 01:23:14,970
Vel, hva du kan gjøre er at du kan lage en struct.

1349
01:23:14,970 --> 01:23:18,910
Det jeg egentlig sier er jeg definere denne strukturen over her,

1350
01:23:18,910 --> 01:23:23,230
og jeg definere en sudoku styre som består av et styre som er 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Og hva det har det har pekere til navnet på nivået.

1352
01:23:26,650 --> 01:23:30,730
Det har også x og y, som er koordinatene for hvor jeg er akkurat nå.

1353
01:23:30,730 --> 01:23:35,980
Det har også tid brukt [uforståelig], og det har det totale antallet trekk jeg har lagt inn så langt.

1354
01:23:35,980 --> 01:23:40,010
Og så i dette tilfellet, kan jeg gruppere en hel haug med data til bare én struktur

1355
01:23:40,010 --> 01:23:42,790
i stedet for å ha det som flyr rundt i som ulike 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 dette lar oss har bare gode syntaks for slags henvisning forskjellige ting innsiden av denne struct.

1358
01:23:49,720 --> 01:23:53,430
Jeg kan bare gjøre board.board, og jeg får sudoku styret tilbake.

1359
01:23:53,430 --> 01:23:56,320
Board.level, får jeg hvor tøft det er.

1360
01:23:56,320 --> 01:24:00,540
Board.x og board.y gi meg koordinatene for hvor jeg kan være i styret.

1361
01:24:00,540 --> 01:24:04,730
Og så jeg tilgang hva vi kaller felt 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 nå er vi her. Jeg har en variabel kalt "bord" av typen sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Og så nå kan jeg få tilgang til alle feltene som utgjør denne strukturen over her.

1365
01:24:20,830 --> 01:24:22,450
>> Eventuelle spørsmål om structs? Ja?

1366
01:24:22,450 --> 01:24:25,890
[Student] For int x, y, erklærte dere begge på én linje? >> [Joseph] Uh-huh.

1367
01:24:25,890 --> 01:24:27,400
[Student] Så kan du bare gjøre det med dem alle?

1368
01:24:27,400 --> 01:24:31,200
Som i X, Y komma ganger at totalt?

1369
01:24:31,200 --> 01:24:34,460
[Joseph] Ja, du kan definitivt gjøre det, men grunnen til at jeg satte x og y på samme linje -

1370
01:24:34,460 --> 01:24:36,330
og spørsmålet er hvorfor kan vi bare gjøre dette på samme linje?

1371
01:24:36,330 --> 01:24:38,600
Hvorfor vi ikke bare sette alle disse på samme linje er

1372
01:24:38,600 --> 01:24:42,090
x og y er relatert til hverandre,

1373
01:24:42,090 --> 01:24:44,780
og dette er bare stilistisk mer korrekt, på en måte,

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
som liker slags forholde seg til det samme.

1376
01:24:49,340 --> 01:24:51,440
Og jeg bare dele disse fra hverandre. Det er bare en stil ting.

1377
01:24:51,440 --> 01:24:53,720
Det gjør funksjonelt ingen forskjell overhodet.

1378
01:24:58,150 --> 01:24:59,270
Andre spørsmål om structs?

1379
01:25:03,030 --> 01:25:06,620
Du kan definere en Pokédex med en struct.

1380
01:25:06,620 --> 01:25:11,720
En Pokémon har et nummer og det har en bokstav, en eier, en type.

1381
01:25:11,720 --> 01:25:16,990
Og så hvis du har en rekke Pokémon, kan du lage et Pokédex, ikke sant?

1382
01:25:16,990 --> 01:25:20,810
Ok, kult. Så, spørsmål om structs. De er knyttet til structs.

1383
01:25:20,810 --> 01:25:25,270
>> Til slutt, GDB. Hva lar GDB du gjøre? Den lar deg feilsøke programmet.

1384
01:25:25,270 --> 01:25:27,650
Og hvis du ikke har brukt GDB, ville jeg anbefalt å se den korte

1385
01:25:27,650 --> 01:25:31,250
og bare gå over hva GDB er, hvordan du arbeider med det, hvordan du kan bruke det,

1386
01:25:31,250 --> 01:25:32,900
og teste den på et program.

1387
01:25:32,900 --> 01:25:37,400
Og så hva GDB lar deg gjøre det lar pause [uforståelig] opp programmet

1388
01:25:37,400 --> 01:25:38,920
og en praktisk linje.

1389
01:25:38,920 --> 01:25:42,600
For eksempel, jeg ønsker å ta en pause kjøring på som linje 3 av mitt program,

1390
01:25:42,600 --> 01:25:46,010
og mens jeg er på linje 3 Jeg kan skrive ut alle verdiene som er der.

1391
01:25:46,010 --> 01:25:49,710
Og så hva vi kaller som pause i en linje

1392
01:25:49,710 --> 01:25:52,350
er kaller vi dette å sette et stoppunkt på den linjen

1393
01:25:52,350 --> 01:25:55,920
og så kan vi skrive ut variabler på tilstanden til programmet på den tiden.

1394
01:25:55,920 --> 01:25:58,990
>> Vi kan da derfra gå gjennom programmet linje for linje.

1395
01:25:58,990 --> 01:26:03,200
Og så kan vi se på tilstanden av stabelen på den tiden.

1396
01:26:03,200 --> 01:26:08,600
Og så for å bruke GDB, det vi gjør er vi kaller clang på C-filen,

1397
01:26:08,600 --> 01:26:11,290
men vi må passere den-ggdb flagget.

1398
01:26:11,290 --> 01:26:15,850
Og når vi er ferdige med det vi bare kjøre gdb på den resulterende filen.

1399
01:26:15,850 --> 01:26:18,810
Og så får du noen som massen av tekst som dette,

1400
01:26:18,810 --> 01:26:21,990
men egentlig alt du trenger å gjøre er å skrive inn kommandoer i begynnelsen.

1401
01:26:21,990 --> 01:26:24,250
Break viktigste setter et stoppunkt på main.

1402
01:26:24,250 --> 01:26:28,470
Liste 400 viser linjer med kode rundt linje 400.

1403
01:26:28,470 --> 01:26:31,410
Og så i dette tilfellet kan du bare se deg rundt og si, oh,

1404
01:26:31,410 --> 01:26:34,360
Jeg ønsker å sette et stoppunkt på linje 397, som er denne linjen,

1405
01:26:34,360 --> 01:26:37,170
og deretter programmet går inn i det trinnet og det kommer til å bryte.

1406
01:26:37,170 --> 01:26:41,120
Det kommer til å ta en pause der, og du kan skrive ut, for eksempel verdien av lav eller høy.

1407
01:26:41,120 --> 01:26:46,410
Og så er det en haug med kommandoene du trenger å vite,

1408
01:26:46,410 --> 01:26:48,660
og denne lysbildefremvisning vil gå opp på nettstedet,

1409
01:26:48,660 --> 01:26:54,000
så hvis du bare ønsker å referere disse eller liker sette dem på jukse ark, gjerne.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Det var Quiz omtale 0, og vi vil holde rundt hvis du har spørsmål.

1411
01:27:00,650 --> 01:27:03,850
OK.

1412
01:27:03,850 --> 01:27:09,030
>>  [Applaus]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]