1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [§ 4] [mindre komfortable]

2
00:00:02,000 --> 00:00:04,000
[Nate Hardison] [Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Dette er CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Greit, velkommen tilbake til del.

5
00:00:10,000 --> 00:00:13,000
I denne ukens avsnitt skal vi gjøre et par ting.

6
00:00:13,000 --> 00:00:17,000
Vi skal først oppsummering Problem Set 2,

7
00:00:17,000 --> 00:00:20,000
som er Caesar og Vigenère oppgavesettet.

8
00:00:20,000 --> 00:00:23,000
Og så skal vi dykke inn Quiz 0 anmeldelse

9
00:00:23,000 --> 00:00:26,000
og tilbringe litt tid recapping hva vi har snakket om

10
00:00:26,000 --> 00:00:30,000
i hver av forelesningene så langt, og vi vil også gjøre noen problemer

11
00:00:30,000 --> 00:00:32,000
fra fjorårets spørrekonkurranser.

12
00:00:32,000 --> 00:00:36,000
På den måten dere har en god måte å forberede for det.

13
00:00:36,000 --> 00:00:40,000
>> Hvis du vil starte, har jeg startet opp et par gode løsninger

14
00:00:40,000 --> 00:00:45,000
for den forrige oppgavesettet, Set Oppgave 2, inn i dette rommet.

15
00:00:45,000 --> 00:00:48,000
Hvis dere alle treffer denne linken,

16
00:00:48,000 --> 00:00:53,000
og hvis du klikker mitt navn og klikk på min første revisjon

17
00:00:53,000 --> 00:00:56,000
vil du se caesar.c, som er akkurat det jeg ser på.

18
00:00:56,000 --> 00:01:00,000
La oss snakke om dette virkelig raskt.

19
00:01:00,000 --> 00:01:02,000
Dette er bare et eksempel løsning.

20
00:01:02,000 --> 00:01:05,000
Dette er ikke nødvendigvis den perfekte løsningen.

21
00:01:05,000 --> 00:01:08,000
Det er mange forskjellige måter å skrive dette,

22
00:01:08,000 --> 00:01:10,000
men det er et par ting som jeg ønsket å markere

23
00:01:10,000 --> 00:01:13,000
som jeg så da jeg var gradering, vanlige feil som jeg tror

24
00:01:13,000 --> 00:01:18,000
denne løsningen gjør en svært god jobb med håndtering.

25
00:01:18,000 --> 00:01:22,000
>> Den første er å ha en slags header kommentar på toppen.

26
00:01:22,000 --> 00:01:25,000
På linjene 1 til 7 ser du detaljene,

27
00:01:25,000 --> 00:01:28,000
hva dette programmet gjør.

28
00:01:28,000 --> 00:01:32,000
En god standard praksis når du skriver C-kode

29
00:01:32,000 --> 00:01:35,000
uansett om programmet er i en enkelt fil eller

30
00:01:35,000 --> 00:01:38,000
enten det er fordelt over flere filer er å ha noen form for

31
00:01:38,000 --> 00:01:40,000
orientere kommentar på toppen.

32
00:01:40,000 --> 00:01:43,000
Dette er også for folk som går ut og skrive kode i den virkelige verden.

33
00:01:43,000 --> 00:01:47,000
Det er der de vil sette informasjon om opphavsrett.

34
00:01:47,000 --> 00:01:50,000
Nedenfor er # omfatter.

35
00:01:50,000 --> 00:01:55,000
På linje 16 er det denne # define, som vi vil komme tilbake til i en smule.

36
00:01:55,000 --> 00:01:59,000
Og deretter en gang funksjonen starter, når viktigste starter,

37
00:01:59,000 --> 00:02:03,000
fordi dette programmet er alle inneholdt i en enkelt funksjon

38
00:02:03,000 --> 00:02:09,000
den aller første som skjer, og dette er veldig idiomatisk og typisk for et C-program

39
00:02:09,000 --> 00:02:14,000
som tar i kommandolinjeargumenter-er at det umiddelbart sjekker

40
00:02:14,000 --> 00:02:18,000
>> for argumentet teller, argc.

41
00:02:18,000 --> 00:02:24,000
Akkurat her ser vi at dette programmet er ventet to argumenter nøyaktig.

42
00:02:24,000 --> 00:02:27,000
Husk at det er det første argumentet som er spesiell en

43
00:02:27,000 --> 00:02:29,000
det er alltid navnet på programmet som blir kjørt,

44
00:02:29,000 --> 00:02:31,000
navnet på den kjørbare filen.

45
00:02:31,000 --> 00:02:36,000
Og så hva dette gjør er det hindrer brukeren i å kjøre programmet

46
00:02:36,000 --> 00:02:42,000
med flere eller færre argumenter.

47
00:02:42,000 --> 00:02:44,000
Grunnen til at vi ønsker å se etter denne gang er fordi

48
00:02:44,000 --> 00:02:52,000
Vi kan faktisk ikke tilgang til denne argv rekke her pålitelig

49
00:02:52,000 --> 00:02:55,000
før vi har sjekket for å se hvor stort det er.

50
00:02:55,000 --> 00:02:58,000
>> En av de vanligste feilene jeg så var folk ville umiddelbart gå i

51
00:02:58,000 --> 00:03:01,000
og grip argv [1].

52
00:03:01,000 --> 00:03:06,000
De hadde ta nøkkelen argument ut av tabellen og gjøre en til jeg se på det,

53
00:03:06,000 --> 00:03:11,000
og deretter de ville gjøre testen for argc samt neste test,

54
00:03:11,000 --> 00:03:16,000
hvorvidt det første argumentet var faktisk et heltall på samme tid,

55
00:03:16,000 --> 00:03:20,000
og det ikke fungerer fordi i tilfelle at det ikke er noen argumenter som følger

56
00:03:20,000 --> 00:03:26,000
du skal flytte et argument som ikke er der eller forsøker å hente en som ikke er der.

57
00:03:26,000 --> 00:03:29,000
>> Den andre store ting som du bør legge merke til er at

58
00:03:29,000 --> 00:03:32,000
du alltid ønsker å skrive ut en slags nyttig feilmelding

59
00:03:32,000 --> 00:03:34,000
for brukeren å orientere dem.

60
00:03:34,000 --> 00:03:37,000
Jeg er sikker på at du har alle kjøre programmer der plutselig det krasjer,

61
00:03:37,000 --> 00:03:41,000
og du får dette latterlig lite dialog som dukker opp og sier

62
00:03:41,000 --> 00:03:44,000
noe forferdelig kryptisk og kanskje gir deg en feilkode eller noe sånt

63
00:03:44,000 --> 00:03:47,000
som gir ingen mening.

64
00:03:47,000 --> 00:03:50,000
Det er der du virkelig ønsker å gi noe nyttig

65
00:03:50,000 --> 00:03:54,000
og målrettet for brukeren, slik at når de kjører den de går "Å," ansikt håndflaten.

66
00:03:54,000 --> 00:03:58,000
"Jeg vet nøyaktig hva de skal gjøre. Jeg vet hvordan å fikse dette."

67
00:03:58,000 --> 00:04:01,000
>> Hvis du ikke skriver ut en melding, så du ender opp med faktisk

68
00:04:01,000 --> 00:04:04,000
la brukeren til å gå undersøke kildekoden

69
00:04:04,000 --> 00:04:07,000
å finne ut hva som gikk galt.

70
00:04:07,000 --> 00:04:11,000
Det er også noen ganger at du kommer til å bruke forskjellige feilkoder.

71
00:04:11,000 --> 00:04:14,000
Her har vi bare brukt en for å si det var en feil,

72
00:04:14,000 --> 00:04:16,000
Det oppstod en feil, det var en feil.

73
00:04:16,000 --> 00:04:20,000
Større programmer, ofte programmer som kalles av andre programmer,

74
00:04:20,000 --> 00:04:25,000
vil returnere en slags spesielle feilkoder i ulike scenarier

75
00:04:25,000 --> 00:04:28,000
programmatisk kommunisere hva du ellers ville

76
00:04:28,000 --> 00:04:32,000
bare bruke en fin engelsk melding for.

77
00:04:32,000 --> 00:04:35,000
Cool.

78
00:04:35,000 --> 00:04:37,000
Ettersom vi arbeider ned, kan du se at vi trekker nøkkelen ut.

79
00:04:37,000 --> 00:04:40,000
Vi tester for å se om nøkkelen passer.

80
00:04:40,000 --> 00:04:42,000
Vi får en melding fra brukeren.

81
00:04:42,000 --> 00:04:46,000
Grunnen til at vi gjør det i denne gjøre mens loop-og dette er noe som vi vil dekke

82
00:04:46,000 --> 00:04:50,000
i en liten bit-men det viser seg at hvis du skriver kontroll D

83
00:04:50,000 --> 00:04:54,000
når du får den GetString ledetekst på terminalen

84
00:04:54,000 --> 00:04:59,000
hva som faktisk gjør er det sender et spesialtegn

85
00:04:59,000 --> 00:05:01,000
til programmet.

86
00:05:01,000 --> 00:05:05,000
Det kalles ELF eller slutten av filen karakter.

87
00:05:05,000 --> 00:05:08,000
Og i så fall, vil vårt budskap streng være null,

88
00:05:08,000 --> 00:05:14,000
så dette var ikke noe vi sjekket for i problemet satt seg.

89
00:05:14,000 --> 00:05:17,000
>> Men som vi går på, nå som vi har begynt å snakke om pekere

90
00:05:17,000 --> 00:05:21,000
og dynamisk minne allokering på haugen,

91
00:05:21,000 --> 00:05:25,000
sjekker for null når du har en funksjon som kanskje

92
00:05:25,000 --> 00:05:30,000
returnere null som verdi er noe som du ønsker å komme i vane å gjøre.

93
00:05:30,000 --> 00:05:33,000
Dette er her først og fremst for illustrasjon.

94
00:05:33,000 --> 00:05:36,000
Men når du ser GetString i fremtiden,

95
00:05:36,000 --> 00:05:41,000
så fra oppgavesettet 4 på, vil du ønsker å holde dette i bakhodet.

96
00:05:41,000 --> 00:05:44,000
Igjen, dette er ikke et problem for Problem sett 3 enten siden vi ikke hadde dekket det ennå.

97
00:05:44,000 --> 00:05:53,000
Til slutt får vi til denne delen hvor vi kommer til det viktigste kryptering loop,

98
00:05:53,000 --> 00:05:57,000
og det er et par ting som skjer her.

99
00:05:57,000 --> 00:06:02,000
Først iterere vi over hele meldingen strengen selv.

100
00:06:02,000 --> 00:06:07,000
Her har vi holdt strlen samtale i tilstanden,

101
00:06:07,000 --> 00:06:12,000
der en rekke av dere har påpekt er ikke en fin måte å gå.

102
00:06:12,000 --> 00:06:15,000
Det viser seg i dette tilfellet er det heller ikke stor,

103
00:06:15,000 --> 00:06:20,000
delvis fordi vi endrer innholdet i selve meldingen

104
00:06:20,000 --> 00:06:27,000
inne for loop, slik at hvis vi har en melding som er 10 tegn lang,

105
00:06:27,000 --> 00:06:32,000
første gang vi starter som for loop strlen vil returnere hva?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> Men hvis vi deretter endre meldingen, sier vi endre sin femte karakter,

108
00:06:40,000 --> 00:06:46,000
og vi kaster i en \ 0 karakter i femte posisjon,

109
00:06:46,000 --> 00:06:49,000
på en påfølgende iterasjon strlen (melding) vil ikke returnere hva den gjorde

110
00:06:49,000 --> 00:06:52,000
den aller første gangen vi iterated,

111
00:06:52,000 --> 00:06:56,000
men det vil i stedet gå tilbake 5 fordi vi kastet i at null terminator,

112
00:06:56,000 --> 00:06:59,000
og strengens lengde er definert

113
00:06:59,000 --> 00:07:03,000
av stillingen at \ 0.

114
00:07:03,000 --> 00:07:09,000
I dette tilfellet, er dette en fin måte å gå fordi vi endre det på plass.

115
00:07:09,000 --> 00:07:13,000
Men du merker at dette er faktisk overraskende enkelt å kryptere

116
00:07:13,000 --> 00:07:16,000
hvis du kan få regnestykket riktig.

117
00:07:16,000 --> 00:07:19,000
Alt som kreves er å sjekke hvorvidt brevet som du ser på

118
00:07:19,000 --> 00:07:21,000
er store eller små bokstaver.

119
00:07:21,000 --> 00:07:24,000
>> Grunnen til at vi bare nødt til å se etter det, og vi trenger ikke å se etter

120
00:07:24,000 --> 00:07:27,000
det er alfa saken er fordi

121
00:07:27,000 --> 00:07:30,000
Hvis et tegn er store eller om det er små

122
00:07:30,000 --> 00:07:33,000
så er det definitivt en bokstav,

123
00:07:33,000 --> 00:07:38,000
fordi vi ikke har store og små sifre.

124
00:07:38,000 --> 00:07:41,000
Den andre tingen vi gjør, og dette er litt kinkig-

125
00:07:41,000 --> 00:07:45,000
er vi har endret standard Caesar cipher formel

126
00:07:45,000 --> 00:07:49,000
at vi ga i oppgavesettet spesifikasjonen.

127
00:07:49,000 --> 00:07:52,000
Hva er annerledes her er at vi trekkes

128
00:07:52,000 --> 00:07:58,000
i store saken hovedstaden A, og så la vi til hovedstaden A

129
00:07:58,000 --> 00:08:02,000
tilbake på slutten.

130
00:08:02,000 --> 00:08:05,000
>> Jeg vet at noen av dere gjort dette i koden.

131
00:08:05,000 --> 00:08:09,000
Visste noen av dere gjør dette i innleveringer?

132
00:08:09,000 --> 00:08:13,000
Du gjorde dette. Kan du forklare hva dette betyr, Sahb?

133
00:08:13,000 --> 00:08:18,000
Ved å trekke den ut, fordi du gjorde en mod rett etter det,

134
00:08:18,000 --> 00:08:21,000
du må ta den ut, slik at måten du får [hoste] posisjon.

135
00:08:21,000 --> 00:08:25,000
Og så ved å legge det tilbake senere flyttet deg over den du ønsket.

136
00:08:25,000 --> 00:08:27,000
Ja, akkurat.

137
00:08:27,000 --> 00:08:32,000
Hva Sahb sa var at når vi ønsker å legge til

138
00:08:32,000 --> 00:08:36,000
vårt budskap og vår nøkkel sammen

139
00:08:36,000 --> 00:08:42,000
og deretter mod at mod at ved NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
hvis vi ikke skalere vårt budskap i riktig 0-25 utvalg først,

141
00:08:50,000 --> 00:08:54,000
så vi kan ende opp med å få en veldig merkelig nummer

142
00:08:54,000 --> 00:08:59,000
fordi de verdier som vi ser på når vi ser på meldingen [i],

143
00:08:59,000 --> 00:09:03,000
når vi ser på den i. karakter av vår vanlig tekstmelding,

144
00:09:03,000 --> 00:09:08,000
er en verdi et sted i dette 65-122 rekkevidde

145
00:09:08,000 --> 00:09:13,000
basert på de verdier for ASCII store A gjennom små z.

146
00:09:13,000 --> 00:09:18,000
Og så når vi mod det med 26 eller NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
siden det var vår # define øverst til høyre opp her,

148
00:09:23,000 --> 00:09:28,000
som kommer til å gi oss en verdi som er i 0-25 rekkevidde,

149
00:09:28,000 --> 00:09:30,000
og vi trenger en måte å deretter skalere det tilbake opp

150
00:09:30,000 --> 00:09:32,000
og få det inn i riktig ASCII-området.

151
00:09:32,000 --> 00:09:36,000
Den enkleste måten å gjøre det på er å bare skalere alt ned

152
00:09:36,000 --> 00:09:39,000
inn 0-25 rekkevidde til å begynne med,

153
00:09:39,000 --> 00:09:43,000
og deretter skifte alt tilbake opp på slutten.

154
00:09:43,000 --> 00:09:46,000
>> En annen vanlig feil som jeg så folk kjører inn er at

155
00:09:46,000 --> 00:09:50,000
hvis du ikke faktisk gjør dette skalering med en gang

156
00:09:50,000 --> 00:09:53,000
og du legger og tast sammen, og du legger dem, sier,

157
00:09:53,000 --> 00:09:58,000
inn i en char variabel, problemet med det

158
00:09:58,000 --> 00:10:01,000
er siden meldingen [i] er et relativt stort antall til å begynne med-

159
00:10:01,000 --> 00:10:05,000
husk det er minst 65 hvis det er en stor bokstav-

160
00:10:05,000 --> 00:10:09,000
hvis du har en stor nøkkel, si, noe som 100,

161
00:10:09,000 --> 00:10:13,000
og du legger dem to sammen til en signert røye du kommer til å få en overflow.

162
00:10:13,000 --> 00:10:17,000
Du kommer til å få en verdi som er større enn 127,

163
00:10:17,000 --> 00:10:22,000
som er den største verdien som en char variabel kan holde.

164
00:10:22,000 --> 00:10:26,000
Igjen, det er derfor du ønsker å gjøre den slags ting til å begynne med.

165
00:10:26,000 --> 00:10:29,000
Noen mennesker fikk rundt så fall ved å gjøre en if else og testing

166
00:10:29,000 --> 00:10:33,000
for å se om det ville overflyt før du gjør det,

167
00:10:33,000 --> 00:10:36,000
men på denne måten får rundt det.

168
00:10:36,000 --> 00:10:40,000
Og så i denne løsningen skrives vi ut hele strengen helt på slutten.

169
00:10:40,000 --> 00:10:45,000
Andra skrives ut et tegn om gangen. Begge er kjempebra.

170
00:10:45,000 --> 00:10:51,000
På dette punktet, gjør dere har noen spørsmål, noen kommentarer om dette?

171
00:10:51,000 --> 00:10:56,000
Ting du liker, ting du ikke liker?

172
00:10:56,000 --> 00:10:58,000
>> Jeg hadde et spørsmål.

173
00:10:58,000 --> 00:11:01,000
Kanskje jeg savnet det under din forklaring, men hvordan fungerer dette programmet

174
00:11:01,000 --> 00:11:07,000
hoppe mellomrommene for tilkobling nøkkelen til lengden av teksten?

175
00:11:07,000 --> 00:11:10,000
Dette er bare Caesar cipher. >> Å, unnskyld, ja.

176
00:11:10,000 --> 00:11:13,000
Ja, vi får se det.

177
00:11:13,000 --> 00:11:16,000
I Caesar cipher fikk vi rundt det fordi

178
00:11:16,000 --> 00:11:18,000
vi bare venda tegn.

179
00:11:18,000 --> 00:11:27,000
Vi bare rotert dem hvis de var store eller små bokstaver.

180
00:11:27,000 --> 00:11:32,000
Dere følelsen ganske godt om dette?

181
00:11:32,000 --> 00:11:34,000
Føl deg fri til å kopiere dette hjemme, ta den,

182
00:11:34,000 --> 00:11:37,000
sammenligne det med hva dere skrev.

183
00:11:37,000 --> 00:11:42,000
Definitivt gjerne sende spørsmål om det også.

184
00:11:42,000 --> 00:11:46,000
Og igjen, innser at målet her med problemet ditt setter

185
00:11:46,000 --> 00:11:50,000
er ikke å få dere til å skrive kode som er perfekt for dine oppgavesett.

186
00:11:50,000 --> 00:11:57,000
Det er en lærerik opplevelse. Ja.

187
00:11:57,000 --> 00:12:01,000
>> Tilbake til gjøre mens loop, hvis det tilsvarer null,

188
00:12:01,000 --> 00:12:06,000
så null betyr bare ingenting, de bare trykk enter?

189
00:12:06,000 --> 00:12:12,000
Null er en spesiell pekeren verdi,

190
00:12:12,000 --> 00:12:17,000
og vi bruker null når vi ønsker å si

191
00:12:17,000 --> 00:12:23,000
Vi har en peker variabel som peker til ingenting.

192
00:12:23,000 --> 00:12:28,000
Og så typisk det betyr at denne variabelen, denne meldingen variabel

193
00:12:28,000 --> 00:12:35,000
er tom, og her, fordi vi bruker CS50 spesiell streng type,

194
00:12:35,000 --> 00:12:37,000
hva er den CS50 streng type?

195
00:12:37,000 --> 00:12:42,000
Har du sett hva det er når David trukket tilbake hette i forelesningen?

196
00:12:42,000 --> 00:12:44,000
Det er en funky-det er en peker, ikke sant?

197
00:12:44,000 --> 00:12:48,000
Ok, ja. >> Det er en char *.

198
00:12:48,000 --> 00:12:52,000
Og så egentlig vi kunne erstatte dette

199
00:12:52,000 --> 00:12:56,000
her med char * melding,

200
00:12:56,000 --> 00:13:04,000
og så GetString funksjon, hvis det ikke får hell en streng fra brukeren,

201
00:13:04,000 --> 00:13:08,000
det kan ikke analysere en streng, og det ene tilfellet der det ikke kan analysere en streng

202
00:13:08,000 --> 00:13:11,000
er hvis brukeren skriver slutten av filen karakter, kontroll D,

203
00:13:11,000 --> 00:13:17,000
som ikke er noe du vanligvis gjør, men hvis det skjer

204
00:13:17,000 --> 00:13:20,000
deretter funksjonen vil returnere denne nullverdi som en måte å si

205
00:13:20,000 --> 00:13:23,000
"Hei, jeg fikk ikke en streng."

206
00:13:23,000 --> 00:13:27,000
Hva ville skje hvis vi ikke setter melding = null,

207
00:13:27,000 --> 00:13:30,000
som er noe som vi ikke har gjort ennå?

208
00:13:30,000 --> 00:13:32,000
Hvorfor skulle det være et problem her?

209
00:13:32,000 --> 00:13:38,000
Fordi jeg vet at vi snakket litt i foredrag om minnelekkasjer.

210
00:13:38,000 --> 00:13:42,000
Ja, la oss gjøre det, og la oss se hva som skjer.

211
00:13:42,000 --> 00:13:44,000
>> Basil spørsmålet var hva som skjer hvis vi ikke egentlig har

212
00:13:44,000 --> 00:13:48,000
denne meldingen = null test?

213
00:13:48,000 --> 00:13:51,000
La oss rulle opp til toppen.

214
00:13:51,000 --> 00:13:53,000
Dere kan kommentere dette.

215
00:13:53,000 --> 00:13:55,000
Egentlig vil jeg lagre den i en revisjon.

216
00:13:55,000 --> 00:13:58,000
Dette vil være Revisjon 3.

217
00:13:58,000 --> 00:14:02,000
Hva du må gjøre for å kjøre dette programmet er at du må trykke på denne tannhjulikonet her oppe,

218
00:14:02,000 --> 00:14:04,000
og du må legge til et argument til det.

219
00:14:04,000 --> 00:14:10,000
Du må gi den sentralt argument siden vi ønsker å passere i en kommandolinje argument.

220
00:14:10,000 --> 00:14:13,000
Her jeg kommer til å gi det nummer tre. Jeg liker 3.

221
00:14:13,000 --> 00:14:19,000
Nå zoome ut igjen, kjører programmet.

222
00:14:19,000 --> 00:14:24,000
Det kjører, kompilering, bygge.

223
00:14:24,000 --> 00:14:27,000
Here we go. Det venter på å bli spurt.

224
00:14:27,000 --> 00:14:33,000
Hvis jeg skriver inn noe sånt som hello-hvor ble det gå?

225
00:14:33,000 --> 00:14:38,000
Oh, tok mitt program for lang tid å kjøre. Jeg var jawing for lenge.

226
00:14:38,000 --> 00:14:40,000
Her går.

227
00:14:40,000 --> 00:14:43,000
Nå jeg skriver i hallo.

228
00:14:43,000 --> 00:14:46,000
Vi ser at det krypterer riktig.

229
00:14:46,000 --> 00:14:52,000
Nå hva skjer hvis vi gjør rask GetString å returnere null?

230
00:14:52,000 --> 00:14:57,000
Husk, jeg sa at vi gjorde det ved å trykke kontroll D samtidig.

231
00:14:57,000 --> 00:14:59,000
Jeg skal bla opp her. Vi vil kjøre den på nytt.

232
00:14:59,000 --> 00:15:01,000
Building. Der går.

233
00:15:01,000 --> 00:15:04,000
Nå når jeg treffer kontroll D

234
00:15:04,000 --> 00:15:12,000
Jeg fikk denne linjen som sier opt/sandbox50/bin/run.sh, Segmentation fault.

235
00:15:12,000 --> 00:15:15,000
Har dere sett det før?

236
00:15:15,000 --> 00:15:17,000
>> [Student] Hvorfor er det ingen >> Beklager?

237
00:15:17,000 --> 00:15:20,000
[Student] Hvorfor er det ingen kjerne dump i dette tilfellet?

238
00:15:20,000 --> 00:15:26,000
Kjernen dump er-spørsmålet er hvorfor er det ingen kjerne dump her?

239
00:15:26,000 --> 00:15:29,000
Spørsmålet er at det kan være, men kjernen dump er en fil

240
00:15:29,000 --> 00:15:31,000
som blir lagret på harddisken.

241
00:15:31,000 --> 00:15:34,000
I dette tilfellet har vi deaktivert kjerne dumper

242
00:15:34,000 --> 00:15:37,000
på flukt serveren slik at vi ikke har folk SEG forkastninger

243
00:15:37,000 --> 00:15:40,000
og bygge opp tonnevis av kjernen dumper.

244
00:15:40,000 --> 00:15:46,000
Men du kan få en.

245
00:15:46,000 --> 00:15:48,000
Kjerne dumper er den slags ting som du ofte kan deaktivere,

246
00:15:48,000 --> 00:15:52,000
og noen ganger du gjør.

247
00:15:52,000 --> 00:15:55,000
Segmentering skyld, for å svare på spørsmålet ditt, Basil,

248
00:15:55,000 --> 00:16:00,000
sier at vi prøvde å få tilgang til en peker

249
00:16:00,000 --> 00:16:05,000
som ikke ble satt til å peke på noe.

250
00:16:05,000 --> 00:16:09,000
Husk Binky i videoen når Binky forsøker å

251
00:16:09,000 --> 00:16:12,000
gå tilgang til en peker som ikke er peker til noe?

252
00:16:12,000 --> 00:16:16,000
I dette tilfellet antar jeg teknisk pekeren peker til noe.

253
00:16:16,000 --> 00:16:20,000
Den peker til null, som er teknisk 0,

254
00:16:20,000 --> 00:16:25,000
men som er definert til å være i et segment som ikke er tilgjengelig

255
00:16:25,000 --> 00:16:28,000
ved programmet, slik at du får en segmentering feil

256
00:16:28,000 --> 00:16:31,000
fordi du ikke tilgang minne som er i en gyldig segment

257
00:16:31,000 --> 00:16:38,000
som heap linjestykke eller stakksegmentet eller data segmentet.

258
00:16:38,000 --> 00:16:40,000
Cool.

259
00:16:40,000 --> 00:16:48,000
Eventuelle flere spørsmål om Caesar?

260
00:16:48,000 --> 00:16:51,000
>> La oss gå videre. La oss se på revisjon 2 veldig raskt.

261
00:16:51,000 --> 00:17:00,000
Det er Vigenère.

262
00:17:00,000 --> 00:17:04,000
Her i Vigenère

263
00:17:04,000 --> 00:17:06,000
vi vil gå gjennom dette ganske raskt fordi, igjen,

264
00:17:06,000 --> 00:17:10,000
Vigenère og Caesar er ganske lik.

265
00:17:10,000 --> 00:17:12,000
Header kommentar er før,

266
00:17:12,000 --> 00:17:17,000
# Define er før å unngå å bruke disse magiske tallene.

267
00:17:17,000 --> 00:17:21,000
Det fine er si at vi ønsket å flytte til

268
00:17:21,000 --> 00:17:23,000
et annet alfabet eller noe sånt.

269
00:17:23,000 --> 00:17:26,000
Snarere enn å måtte gå manuelt endre alle de 26-tallet i koden

270
00:17:26,000 --> 00:17:30,000
vi kan endre dette til 27 eller slippe den ned

271
00:17:30,000 --> 00:17:34,000
hvis vi bruker forskjellige alfabeter, ulike språk.

272
00:17:34,000 --> 00:17:38,000
Igjen har vi denne kontrollen av argumentet teller,

273
00:17:38,000 --> 00:17:42,000
og virkelig du kan nesten ta dette som en mal.

274
00:17:42,000 --> 00:17:46,000
Ganske mye hvert program du skriver bør ha-

275
00:17:46,000 --> 00:17:50,000
hvis det tar kommandolinjeargumenter-noen sekvens av linjer

276
00:17:50,000 --> 00:17:55,000
som lyder slik helt i begynnelsen.

277
00:17:55,000 --> 00:17:59,000
Det er en av de første mental helse testene du ønsker å gjøre.

278
00:17:59,000 --> 00:18:03,000
>> Her er hva vi gjorde var vi sørget for at

279
00:18:03,000 --> 00:18:06,000
søkeordet var gyldig, og det var den andre sjekken som vi gjorde.

280
00:18:06,000 --> 00:18:11,000
Legg merke igjen at vi skilte dette fra argc og 2.

281
00:18:11,000 --> 00:18:14,000
Vær oppmerksom på at i dette tilfellet en ting som vi måtte gjøre var stedet

282
00:18:14,000 --> 00:18:18,000
for å bruke en til I ønsket vi å validere hele strengen,

283
00:18:18,000 --> 00:18:21,000
og for å gjøre det du faktisk må gå tegn for tegn

284
00:18:21,000 --> 00:18:23,000
over strengen.

285
00:18:23,000 --> 00:18:29,000
Det er ingen god måte å kalle noe på det

286
00:18:29,000 --> 00:18:31,000
fordi selv, for eksempel, en til i. kommer tilbake 0

287
00:18:31,000 --> 00:18:37,000
hvis det ikke kan analysere et heltall, slik at ikke engang fungerer.

288
00:18:37,000 --> 00:18:42,000
Igjen, hyggelig melding som forteller brukeren nøyaktig hva som skjedde.

289
00:18:42,000 --> 00:18:45,000
Så her igjen, vi også håndtere saken der

290
00:18:45,000 --> 00:18:50,000
brukeren skriver i en kontroll D tilfeldig karakter.

291
00:18:50,000 --> 00:18:54,000
>> Og så Charlotte hadde et spørsmål tidligere om hvordan vi klarer å hoppe over områder

292
00:18:54,000 --> 00:18:57,000
i vårt bånd her.

293
00:18:57,000 --> 00:19:00,000
Dette var slags ligner på hva vi gjorde med Myspace program

294
00:19:00,000 --> 00:19:04,000
som vi gjorde i avsnitt, og måten dette arbeidet

295
00:19:04,000 --> 00:19:08,000
er at vi spores antall bokstaver som vi hadde sett.

296
00:19:08,000 --> 00:19:13,000
Så vi gikk over meldingen streng, som vi gikk over tegn for tegn,

297
00:19:13,000 --> 00:19:16,000
vi spores indeksen som en del av vår for loop, og deretter vi også spores

298
00:19:16,000 --> 00:19:21,000
antall bokstaver, slik at ikke-spesialtegn, ikke-sifre, ikke-mellomrommet

299
00:19:21,000 --> 00:19:27,000
at vi hadde sett i egen variabel.

300
00:19:27,000 --> 00:19:33,000
Og så denne løsningen endrer nøkkelen

301
00:19:33,000 --> 00:19:41,000
å få en virkelig nøkkel heltall, og det gjør det på sparket,

302
00:19:41,000 --> 00:19:47,000
rett før det går så å kryptere selve meldingen karakter.

303
00:19:47,000 --> 00:19:50,000
Det er noen løsninger som var perfekt stor for

304
00:19:50,000 --> 00:19:58,000
som ville endre nøkkelen opp ved testing for nøkkelen gyldighet.

305
00:19:58,000 --> 00:20:01,000
I tillegg til å sørge for at karakter og søkeordet

306
00:20:01,000 --> 00:20:05,000
ble en bokstav det også viste at til et heltall

307
00:20:05,000 --> 00:20:13,000
i 0-25 rekkevidde for deretter hoppe å gjøre det senere i dette for loop.

308
00:20:13,000 --> 00:20:18,000
Igjen, ser du her dette er virkelig nøyaktig samme kode

309
00:20:18,000 --> 00:20:22,000
som vi brukte i Caesar på dette punktet.

310
00:20:22,000 --> 00:20:25,000
Du gjør akkurat det samme, slik at den virkelige kunsten er å finne ut

311
00:20:25,000 --> 00:20:30,000
hvordan du slår inn søkeordet i et heltall.

312
00:20:30,000 --> 00:20:35,000
>> En ting som vi gjorde her som er litt tett

313
00:20:35,000 --> 00:20:39,000
er vi gjentok denne setningen, jeg antar du kan kalle det,

314
00:20:39,000 --> 00:20:45,000
3 separate ganger på 58 linjer, 59, og 61.

315
00:20:45,000 --> 00:20:52,000
Kan noen forklare hva denne setningen betyr?

316
00:20:52,000 --> 00:20:55,000
Det er tilgang til en karakter, som du sa.

317
00:20:55,000 --> 00:20:59,000
Ja, det er [uhørbart] et tegn i søkeordet,

318
00:20:59,000 --> 00:21:04,000
og så er det antall bokstaver sett fordi du bare beveger seg langs

319
00:21:04,000 --> 00:21:06,000
søkeordet når du har sett brevet,

320
00:21:06,000 --> 00:21:10,000
så det kommer til å effektivt hoppe mellomrom og sånt.

321
00:21:10,000 --> 00:21:12,000
Ja, akkurat.

322
00:21:12,000 --> 00:21:16,000
Og når du har sett søkeordet blank du bare mod så du flytter tilbake rundt.

323
00:21:16,000 --> 00:21:18,000
Akkurat. Det er en perfekt forklaring.

324
00:21:18,000 --> 00:21:23,000
Hva Kevin sa er at vi ønsker å indeksere inn søkeordet.

325
00:21:23,000 --> 00:21:28,000
Vi ønsker å få num_letters_seen karakter, om du vil,

326
00:21:28,000 --> 00:21:32,000
men hvis num_letters_seen overstiger lengden på søkeordet,

327
00:21:32,000 --> 00:21:37,000
måten vi kommer tilbake i riktig område er vi bruker mod operatør

328
00:21:37,000 --> 00:21:40,000
å effektivt vikle rundt.

329
00:21:40,000 --> 00:21:43,000
For eksempel, som i korte, er vår nøkkelord bacon,

330
00:21:43,000 --> 00:21:46,000
og det er 5 bokstaver.

331
00:21:46,000 --> 00:21:50,000
Men vi har sett 6 bokstaver i vår ren tekst på dette punktet

332
00:21:50,000 --> 00:21:52,000
og kryptert 6.

333
00:21:52,000 --> 00:21:57,000
Vi vil ende opp tilgang til num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
som er 6, mod lengden søkeordet, 5,

335
00:22:00,000 --> 00:22:04,000
og så vi får en, og så hva vi vil gjøre er at vi vil

336
00:22:04,000 --> 00:22:14,000
tilgang til første tegnet på innsiden av søkeordet vår på det tidspunktet.

337
00:22:14,000 --> 00:22:21,000
>> Greit, noen spørsmål om Vigenère

338
00:22:21,000 --> 00:22:26,000
før vi går videre?

339
00:22:26,000 --> 00:22:31,000
Dere følelsen ganske godt om dette?

340
00:22:31,000 --> 00:22:35,000
Cool, flott.

341
00:22:35,000 --> 00:22:38,000
Jeg vil være sikker på at dere får sjansen til å se kode

342
00:22:38,000 --> 00:22:48,000
at vi synes ser bra ut og har sjansen til å lære av det.

343
00:22:48,000 --> 00:22:53,000
Dette kommer til å bli det siste vi skal bruke mellomrom for tiden,

344
00:22:53,000 --> 00:22:59,000
og vi kommer til å overgangen nå, og jeg kommer til å gå til cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
slik at vi kan gjøre en liten bit av quiz gjennomgang.

346
00:23:06,000 --> 00:23:10,000
Den beste måten jeg tror å begynne å gjøre quiz anmeldelsen

347
00:23:10,000 --> 00:23:15,000
er å komme til denne Forelesninger siden, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
og under hver av uken overskrifter, så hvis jeg ser her i uke 0,

349
00:23:20,000 --> 00:23:27,000
Jeg ser at vi har en liste over emner som vi dekket i uke 0.

350
00:23:27,000 --> 00:23:31,000
>> Hvis noen av disse emnene virke uvant for deg

351
00:23:31,000 --> 00:23:34,000
vil du definitivt ønsker å gå tilbake og skure forelesningsnotater og muligens

352
00:23:34,000 --> 00:23:39,000
selv skumme gjennom forelesninger, se dem igjen hvis du vil

353
00:23:39,000 --> 00:23:44,000
å få en følelse for hva som skjer med hvert av disse emnene.

354
00:23:44,000 --> 00:23:49,000
Jeg vil si i tillegg i år en av de kule ressursene vi har fått

355
00:23:49,000 --> 00:23:55,000
er disse shorts som vi har laget, og hvis du ser på uke 0,

356
00:23:55,000 --> 00:24:00,000
Vi har ikke alle av temaene, men vi har ganske mange av dem,

357
00:24:00,000 --> 00:24:03,000
noen av de vanskeligere seg, så ser disse shorts igjen

358
00:24:03,000 --> 00:24:08,000
er en god måte å få deg opp til hastighet.

359
00:24:08,000 --> 00:24:15,000
Spesielt, jeg kommer til å sette i en plugg for 3 på bunnen, siden jeg gjorde de.

360
00:24:15,000 --> 00:24:20,000
Men hvis du sliter med binære, biter, hex, den slags ting,

361
00:24:20,000 --> 00:24:22,000
binær er et flott sted å starte.

362
00:24:22,000 --> 00:24:25,000
ASCII er en annen som er godt å se også.

363
00:24:25,000 --> 00:24:31,000
Du kan selv se meg på 1,5 x hastighet hvis jeg går for tregt for deg.

364
00:24:31,000 --> 00:24:35,000
Siden det er gjennomgang, gjerne gjøre det.

365
00:24:35,000 --> 00:24:40,000
>> Bare for å starte veldig raskt, vi kommer til å gå gjennom et par av disse quiz problemer

366
00:24:40,000 --> 00:24:44,000
bare for å raskt churn gjennom disse.

367
00:24:44,000 --> 00:24:50,000
For eksempel, la oss se på problemet 16 som jeg har rett her oppe på brettet.

368
00:24:50,000 --> 00:24:54,000
Vi har fått denne følgende beregning i binær,

369
00:24:54,000 --> 00:24:56,000
og vi ønsker å vise noe arbeid.

370
00:24:56,000 --> 00:24:59,000
Ok, jeg kommer til å gi dette en sjanse.

371
00:24:59,000 --> 00:25:01,000
Dere bør følge med papir,

372
00:25:01,000 --> 00:25:04,000
og vi vil gjøre dette veldig raskt.

373
00:25:04,000 --> 00:25:06,000
Vi ønsker å utføre følgende beregning i binær.

374
00:25:06,000 --> 00:25:16,000
Jeg har 00110010.

375
00:25:16,000 --> 00:25:27,000
Og jeg kommer til å legge til det 00110010.

376
00:25:27,000 --> 00:25:30,000
For matematikk genier følgende sammen hjemme,

377
00:25:30,000 --> 00:25:35,000
Dette er effektivt multiplisere med 2.

378
00:25:35,000 --> 00:25:37,000
La oss starte.

379
00:25:37,000 --> 00:25:39,000
Vi kommer til å følge samme tillegg algoritme som vi gjør

380
00:25:39,000 --> 00:25:43,000
når vi legger desimaltall sammen.

381
00:25:43,000 --> 00:25:46,000
Egentlig den eneste forskjellen her er at vi sløyfe tilbake rundt

382
00:25:46,000 --> 00:25:51,000
når vi har 1 + 1 i stedet for når vi kommer til 10 år.

383
00:25:51,000 --> 00:25:53,000
>> Hvis vi starter fra høyre, veldig raskt, er det det første sifferet?

384
00:25:53,000 --> 00:25:55,000
[Student] 0. >> [Nate H.] 0.

385
00:25:55,000 --> 00:25:58,000
Stor, det andre sifferet?

386
00:25:58,000 --> 00:26:00,000
[Student] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate H.] Er det en 1? 1 + 1 er?

388
00:26:02,000 --> 00:26:04,000
[Student] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Akkurat, så hva er siffer som jeg skriver rett under 2 de legges sammen?

390
00:26:08,000 --> 00:26:11,000
[Student] 1, 0 eller 0 og deretter bære en.

391
00:26:11,000 --> 00:26:15,000
[Nate H.] 0 og bære en 1, akkurat.

392
00:26:15,000 --> 00:26:18,000
Neste opp, Basil, nå er du.

393
00:26:18,000 --> 00:26:20,000
Hva er den tredje? >> [Basil] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate H.] 1, perfekt. Kevin?

395
00:26:23,000 --> 00:26:27,000
[Kevin] 0. >> [Nate H.] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate H.] Ja, og hva gjør jeg?

397
00:26:30,000 --> 00:26:32,000
[Student] The 1.

398
00:26:32,000 --> 00:26:34,000
[Nate H.] Og hva gjør jeg? Og da jeg bære en.

399
00:26:34,000 --> 00:26:36,000
Perfekt, Sahb? >> [Sahb] Nå har du en.

400
00:26:36,000 --> 00:26:40,000
[Nate H.] Og gjør jeg noe her?

401
00:26:40,000 --> 00:26:43,000
[Sahb] Så for den neste du har en fordi du gjennomført over 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Flott, så her kan vi fullføre den.

403
00:26:49,000 --> 00:26:51,000
Cool.

404
00:26:51,000 --> 00:26:54,000
[Student] Har 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, som du sa, er 10, eller 1, 0, heller.

407
00:27:01,000 --> 00:27:07,000
10 er en misvisende benevnelse fordi for meg 10 betyr tallet 10,

408
00:27:07,000 --> 00:27:12,000
og det er innfall av hvordan vi representerer det når vi skriver det.

409
00:27:12,000 --> 00:27:20,000
Vi representerer tallet 2 med 1, 0, og nummer 10 er noe forskjellig.

410
00:27:20,000 --> 00:27:23,000
>> Hva er slags fint om binære er at det egentlig ikke er så mange

411
00:27:23,000 --> 00:27:25,000
tilfeller du trenger å lære.

412
00:27:25,000 --> 00:27:30,000
Det finnes 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 er 0, og deretter bære en 1,

414
00:27:34,000 --> 00:27:37,000
og så kan du se her på den tredje kolonnen fra høyre

415
00:27:37,000 --> 00:27:40,000
Vi hadde denne 1, 1 og 1.

416
00:27:40,000 --> 00:27:43,000
Og 1 + 1 + 1 er en 1,

417
00:27:43,000 --> 00:27:45,000
og du bære en annen en.

418
00:27:45,000 --> 00:27:48,000
Når du gjør binære tillegg, ganske enkelt.

419
00:27:48,000 --> 00:27:51,000
Jeg vil gjøre et par mer av disse forstanden sjekk dere

420
00:27:51,000 --> 00:27:54,000
før du går i, fordi dette er

421
00:27:54,000 --> 00:28:00,000
sannsynligvis noe vi får se på quiz.

422
00:28:00,000 --> 00:28:03,000
Nå la oss gjøre dette neste også.

423
00:28:03,000 --> 00:28:06,000
La oss gjøre problem 17.

424
00:28:06,000 --> 00:28:12,000
Vi kommer til å konvertere følgende binære tall til desimal.

425
00:28:12,000 --> 00:28:28,000
Jeg har 10100111001.

426
00:28:28,000 --> 00:28:33,000
Husk i det binære video som jeg gjorde

427
00:28:33,000 --> 00:28:36,000
Jeg gikk gjennom et par eksempler, og jeg viste hvordan

428
00:28:36,000 --> 00:28:41,000
alt fungerer når du gjør det i desimal.

429
00:28:41,000 --> 00:28:45,000
Når du arbeider i desimalfremstilling Jeg tror vi

430
00:28:45,000 --> 00:28:48,000
på dette punktet i våre liv så flytende i det som

431
00:28:48,000 --> 00:28:53,000
det er ganske lett å glatte over mekanikken i hvordan det faktisk fungerer.

432
00:28:53,000 --> 00:28:59,000
>> Men for å gjøre en rask oppsummering, hvis jeg har nummer 137

433
00:28:59,000 --> 00:29:06,000
Dette betyr-og virkelig igjen, dette er i desimalfremstilling-

434
00:29:06,000 --> 00:29:19,000
tallet 137 i desimal betyr at jeg har 1 x 100 + 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
Dette er alle bor på skjermen.

436
00:29:22,000 --> 00:29:29,000
Og så hvis du ser på disse tallene her,

437
00:29:29,000 --> 00:29:34,000
100, 10 og 1, ser du at de er faktisk alle krefter 10.

438
00:29:34,000 --> 00:29:43,000
Jeg har 10 ², 10 ¹, og 10 til null.

439
00:29:43,000 --> 00:29:48,000
Vi har en lignende slags ting i binær,

440
00:29:48,000 --> 00:29:55,000
bortsett fra at vår base, som vi kaller det, er 2 i stedet for 10 år.

441
00:29:55,000 --> 00:29:58,000
Disse 10s som jeg skrev ned her nederst,

442
00:29:58,000 --> 00:30:02,000
denne 10 ², 10 ¹, 10 til null, 10 er vår base,

443
00:30:02,000 --> 00:30:08,000
og eksponent, 0 1,, eller 2,

444
00:30:08,000 --> 00:30:14,000
er underforstått av posisjonen sifferet i antall at vi skriver.

445
00:30:14,000 --> 00:30:21,000
1, hvis vi ser på det, er dette en i andre posisjon.

446
00:30:21,000 --> 00:30:27,000
Den 3 er i første posisjon, og 7 er i den 0th stilling.

447
00:30:27,000 --> 00:30:35,000
Det er slik vi får de ulike eksponentene nedenfor for våre baser.

448
00:30:35,000 --> 00:30:40,000
>> Etter alt dette we'll-faktisk, vet du hva?

449
00:30:40,000 --> 00:30:43,000
Vi vil gjøre-der gjorde min angre knapp gå?

450
00:30:43,000 --> 00:30:45,000
Der går.

451
00:30:45,000 --> 00:30:47,000
Jeg elsker denne angre ting.

452
00:30:47,000 --> 00:30:51,000
Etter dette tror jeg for meg minst

453
00:30:51,000 --> 00:30:54,000
den enkleste måten å begynne å konvertere et binært tall

454
00:30:54,000 --> 00:30:57,000
eller et heksadesimalt tall der basen er 16

455
00:30:57,000 --> 00:31:02,000
og ikke 10 eller 2 er å gå videre og skrive ut

456
00:31:02,000 --> 00:31:09,000
baser og eksponenter for alle tallene i mitt binært tall på toppen.

457
00:31:09,000 --> 00:31:14,000
Hvis vi begynner fra venstre til høyre igjen,

458
00:31:14,000 --> 00:31:17,000
som er slags counterintuitive,

459
00:31:17,000 --> 00:31:23,000
Jeg kommer til å endre tilbake til svart her, har vi to til 0. posisjon,

460
00:31:23,000 --> 00:31:27,000
og da har vi to ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
og deretter 2 til 3, 2 til 4, 2 til 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, og 10.

463
00:31:39,000 --> 00:31:41,000
Disse tallene jeg har skrevet ut er alle eksponenter.

464
00:31:41,000 --> 00:31:48,000
Jeg bare skrev baser her i de første 3 bare for plass.

465
00:31:48,000 --> 00:31:50,000
>> På dette punktet kommer jeg til å gå videre, og jeg faktisk kommer til å slette

466
00:31:50,000 --> 00:31:53,000
ting som vi gjorde i desimal, hvis det er greit.

467
00:31:53,000 --> 00:31:57,000
Dere har alle fått det.

468
00:31:57,000 --> 00:32:05,000
De av dere ser på nettet er jeg sikker på vil være i stand til å spole tilbake meg hvis du vil.

469
00:32:05,000 --> 00:32:07,000
Bytte tilbake til pennen.

470
00:32:07,000 --> 00:32:12,000
Nå, hva vi kan gjøre-hvis dere ikke er helt opp til hastigheten på kreftene dine på 2,

471
00:32:12,000 --> 00:32:15,000
det er helt kult.

472
00:32:15,000 --> 00:32:18,000
Det skjer. Jeg forstår.

473
00:32:18,000 --> 00:32:23,000
Jeg hadde en gang en jobb intervju der jeg ble fortalt jeg burde vite alle krefter 2

474
00:32:23,000 --> 00:32:26,000
opp gjennom 2 til den 30..

475
00:32:26,000 --> 00:32:29,000
Det var ikke en jobb jeg fikk.

476
00:32:29,000 --> 00:32:32,000
Uansett, kan dere gå videre og gjøre regnestykket her,

477
00:32:32,000 --> 00:32:35,000
men med binære ikke det gjør virkelig fornuftig,

478
00:32:35,000 --> 00:32:38,000
og heller ikke det fornuftig med desimal eller heksadesimal heller,

479
00:32:38,000 --> 00:32:43,000
å gjøre regnestykket ut hvor du har nuller.

480
00:32:43,000 --> 00:32:49,000
Du kan se jeg har 0 her, en 0 her, 0 her, 0 her, 0 her, 0 her.

481
00:32:49,000 --> 00:32:52,000
Hvorfor kan det ikke være fornuftig å gjøre selve regnestykket

482
00:32:52,000 --> 00:32:56,000
å beregne den aktuelle strøm av 2 for den posisjonen?

483
00:32:56,000 --> 00:32:59,000
Akkurat som Charlotte sa, vil det være 0.

484
00:32:59,000 --> 00:33:05,000
Kan like godt spare deg selv tid hvis beregning krefter 2 er ikke din sterke side.

485
00:33:05,000 --> 00:33:10,000
I dette tilfellet trenger vi bare å beregne det for 2 til 0 som er-?

486
00:33:10,000 --> 00:33:12,000
[Student] 1.

487
00:33:12,000 --> 00:33:14,000
[Nate H.] 1, 2 til 3, som er-?

488
00:33:14,000 --> 00:33:16,000
[Student] 8. >> [Nate H.] 8.

489
00:33:16,000 --> 00:33:18,000
2 til 4?

490
00:33:18,000 --> 00:33:21,000
[Student] 2. Jeg beklager, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H.] 2 til 4 er 16, akkurat.

492
00:33:26,000 --> 00:33:28,000
2 til 5, Kevin? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate H.] 32, 2 til 8?

494
00:33:32,000 --> 00:33:38,000
[Student] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate H.] Perfect.

496
00:33:41,000 --> 00:33:43,000
Og 2 til 10?

497
00:33:43,000 --> 00:33:45,000
[Student] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate H.] Yeah, 1024.

499
00:33:49,000 --> 00:33:57,000
>> Når vi har fått disse tallene kan vi oppsummere dem alle opp.

500
00:33:57,000 --> 00:34:01,000
Og det er her det er veldig viktig å gjøre et par ting.

501
00:34:01,000 --> 00:34:07,000
En er å gå sakte og kontrollere arbeidet.

502
00:34:07,000 --> 00:34:10,000
Du kan fortelle at det er en 1 på slutten av dette antallet,

503
00:34:10,000 --> 00:34:15,000
så jeg skal definitivt få et oddetall som følge min,

504
00:34:15,000 --> 00:34:18,000
fordi alle de andre som kommer til å bli enda tall

505
00:34:18,000 --> 00:34:21,000
gitt at det er et binært tall.

506
00:34:21,000 --> 00:34:24,000
Den andre tingen å gjøre er hvis du kommer til dette punktet på testen

507
00:34:24,000 --> 00:34:27,000
og du har skrevet det ut så langt

508
00:34:27,000 --> 00:34:30,000
og du kjører ut av tiden

509
00:34:30,000 --> 00:34:33,000
se på antall poeng at dette problemet er verdt.

510
00:34:33,000 --> 00:34:40,000
Dette problemet, som du kan se-hvis jeg vende tilbake til min laptop veldig raskt-

511
00:34:40,000 --> 00:34:44,000
dette problemet er verdt 2 poeng, så dette er ikke den slags tillegg

512
00:34:44,000 --> 00:34:47,000
du bør gå gjennom hvis du virkelig presset for tiden.

513
00:34:47,000 --> 00:34:52,000
Men vi vil bytte tilbake til iPad, og vi vil gå gjennom det veldig raskt.

514
00:34:52,000 --> 00:34:54,000
>> Jeg liker å gjøre de små tallene første

515
00:34:54,000 --> 00:34:56,000
fordi jeg finner det lettere.

516
00:34:56,000 --> 00:35:00,000
Jeg liker 32 og 8 fordi de går sammen ganske lett, og får vi 50.

517
00:35:00,000 --> 00:35:03,000
16 og en får 17.

518
00:35:03,000 --> 00:35:05,000
Det får vi 57,

519
00:35:05,000 --> 00:35:14,000
og da kan vi gjøre resten av denne, slik at vi kan gjøre 57, 156.

520
00:35:14,000 --> 00:35:16,000
Kom igjen.

521
00:35:16,000 --> 00:35:19,000
Mann, vel, la oss se.

522
00:35:19,000 --> 00:35:27,000
Vi hadde 57, 256, og 1024.

523
00:35:27,000 --> 00:35:31,000
På dette punktet, vil jeg heller bare gå gjennom.

524
00:35:31,000 --> 00:35:35,000
Jeg har ingen anelse. Jeg trenger helt klart å lese meg opp på dette.

525
00:35:35,000 --> 00:35:40,000
7, 6 og 4, får du 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
Så får vi 3, og så får vi en.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
Easter egg, noen?

530
00:35:55,000 --> 00:35:59,000
Noen kjenner dette nummeret?

531
00:35:59,000 --> 00:36:02,000
Chris gjenkjenner nummeret. Hva betyr det, Chris?

532
00:36:02,000 --> 00:36:04,000
[Chris] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, så hvis du ser på dette, ser det ut som leet.

534
00:36:11,000 --> 00:36:15,000
Hacker ting. Se opp for den slags ting på midterm eller quiz, heller.

535
00:36:15,000 --> 00:36:19,000
Hvis du ser den slags ting, og du lurer på "Huh,"

536
00:36:19,000 --> 00:36:22,000
som kan faktisk bety noe.

537
00:36:22,000 --> 00:36:24,000
Jeg vet ikke. David liker å sette det i.

538
00:36:24,000 --> 00:36:26,000
Det er en god måte å forstanden sjekke det.

539
00:36:26,000 --> 00:36:30,000
Som greit, jeg kan se hva som skjer.

540
00:36:30,000 --> 00:36:34,000
>> Det er Week 0/uke en ting.

541
00:36:34,000 --> 00:36:39,000
Hvis vi går tilbake til våre bærbare nå,

542
00:36:39,000 --> 00:36:46,000
zoome ut, og et par andre ting.

543
00:36:46,000 --> 00:36:50,000
Det er ASCII, som vi har gjort mye med problemet sett.

544
00:36:50,000 --> 00:36:55,000
Denne oppfatningen av kapital A. Hva er det egentlig?

545
00:36:55,000 --> 00:36:57,000
Å vite det er Desimalheltallet.

546
00:36:57,000 --> 00:37:00,000
65 er hva det er kartlagt til i ASCII-tabellen,

547
00:37:00,000 --> 00:37:03,000
og det er derfor hvordan datamaskinen skriver det,

548
00:37:03,000 --> 00:37:06,000
og det er hvordan vi har fått unna med faktisk skriver

549
00:37:06,000 --> 00:37:09,000
tegnet kapital A og tegnet små bokstaver a

550
00:37:09,000 --> 00:37:14,000
i noen av disse løsningene og øvingsoppgaver som du har gjort.

551
00:37:14,000 --> 00:37:16,000
Et par andre ting.

552
00:37:16,000 --> 00:37:25,000
Vi har uttalelser, boolske uttrykk, betingelser, løkker, variabler og tråder.

553
00:37:25,000 --> 00:37:29,000
>> De alle synes å være fornuftig for det meste?

554
00:37:29,000 --> 00:37:35,000
Noe av dette terminologi er litt funky til tider.

555
00:37:35,000 --> 00:37:46,000
Jeg liker å tenke på en uttalelse som for det meste noe som ender med et semikolon.

556
00:37:46,000 --> 00:37:51,000
Utsagn som x = 7, som setter en variabel,

557
00:37:51,000 --> 00:37:54,000
antagelig kalt x = 7.

558
00:37:54,000 --> 00:38:01,000
Antagelig x er også en type som kan lagre nummeret 7,

559
00:38:01,000 --> 00:38:05,000
så det er en int eller muligens en flåte eller en kort eller en røye,

560
00:38:05,000 --> 00:38:07,000
noe sånt.

561
00:38:07,000 --> 00:38:12,000
En boolsk uttrykk bruker disse dobbeltsidige lik

562
00:38:12,000 --> 00:38:17,000
og bang lik eller ikke lik, mindre enn, større enn,

563
00:38:17,000 --> 00:38:22,000
mindre enn eller lik, alle den slags ting.

564
00:38:22,000 --> 00:38:28,000
Forholdene så er hvis annet uttalelser.

565
00:38:28,000 --> 00:38:32,000
Jeg ville huske at du ikke kan ha en annen uten en tilsvarende hvis.

566
00:38:32,000 --> 00:38:37,000
På samme måte kan du ikke ha en else if uten en tilsvarende hvis.

567
00:38:37,000 --> 00:38:40,000
Looper, husker de tre typer loops vi har hammering inn i deg

568
00:38:40,000 --> 00:38:43,000
for de siste par seksjoner og øvingsoppgaver.

569
00:38:43,000 --> 00:38:46,000
Bruke gjøre mens når du får brukerundersøkelser,

570
00:38:46,000 --> 00:38:51,000
bruke mens looper før en bestemt betingelse er sann,

571
00:38:51,000 --> 00:38:56,000
og deretter bruke dem for løkker hvis du trenger å

572
00:38:56,000 --> 00:39:01,000
vet hvilken iterasjon av loopen du befinner deg på er hvordan jeg tenker på det.

573
00:39:01,000 --> 00:39:07,000
Eller hvis du gjør en for hvert tegn i en streng jeg ønsker å gjøre noe,

574
00:39:07,000 --> 00:39:15,000
for hvert element i en matrise jeg ønsker å gjøre noe til dette elementet.

575
00:39:15,000 --> 00:39:18,000
>> Tråder og hendelser.

576
00:39:18,000 --> 00:39:21,000
Disse har vi ikke dekket så eksplisitt i C,

577
00:39:21,000 --> 00:39:23,000
men husk dette fra bunnen av.

578
00:39:23,000 --> 00:39:26,000
Dette er ideen om å ha forskjellige skript.

579
00:39:26,000 --> 00:39:32,000
Dette er også denne oppfatningen av kringkasting en hendelse.

580
00:39:32,000 --> 00:39:37,000
Noen mennesker ikke bruke kringkasting i sine prosjekter i utgangspunktet,

581
00:39:37,000 --> 00:39:40,000
som er helt kult,

582
00:39:40,000 --> 00:39:46,000
men disse er to forskjellige måter å håndtere dette større problem kalt samtidighet,

583
00:39:46,000 --> 00:39:49,000
som er hvordan får du programmer for å utføre

584
00:39:49,000 --> 00:39:54,000
eller tilsynelatende utføre samtidig?

585
00:39:54,000 --> 00:39:59,000
Forskjellige oppgaver som kjører mens andre oppgaver også kjører.

586
00:39:59,000 --> 00:40:01,000
Dette er hvordan operativsystemet ser ut til å fungere.

587
00:40:01,000 --> 00:40:04,000
Dette er grunnen til at selv om, for eksempel,

588
00:40:04,000 --> 00:40:10,000
Jeg har fått min nettleser som kjører, kan jeg også slå på Spotify og spiller en sang.

589
00:40:10,000 --> 00:40:14,000
Det er mer av en konseptuell ting å forstå.

590
00:40:14,000 --> 00:40:17,000
Jeg ville ta en titt på trådene korte

591
00:40:17,000 --> 00:40:21,000
Hvis du ønsker å lære mer om det.

592
00:40:21,000 --> 00:40:26,000
>> La oss se, tror jeg det kan ha vært

593
00:40:26,000 --> 00:40:31,000
et problem på dette i en av disse.

594
00:40:31,000 --> 00:40:35,000
Igjen, jeg tror tråder og hendelser ikke noe som vi vil dekke i C

595
00:40:35,000 --> 00:40:41,000
bare fordi det er betydelig vanskeligere enn i Scratch.

596
00:40:41,000 --> 00:40:44,000
Du bør ikke bekymre deg for det der, men definitivt forstå begrepene,

597
00:40:44,000 --> 00:40:47,000
forstå hva som skjer.

598
00:40:47,000 --> 00:40:52,000
Før vi går videre, noen spørsmål om Week 0 materiale?

599
00:40:52,000 --> 00:40:55,000
Alle følelsen ganske bra?

600
00:40:55,000 --> 00:41:03,000
Forstå variabler og hva en variabel er?

601
00:41:03,000 --> 00:41:08,000
>> Flytte på. Uke 1.

602
00:41:08,000 --> 00:41:12,000
Et par ting her som ikke var spesielt dekket

603
00:41:12,000 --> 00:41:21,000
i quiz gjennomgang nødvendigvis og også er mer konseptuelle ting å tenke på.

604
00:41:21,000 --> 00:41:30,000
Den første er dette oppfatningen av hva kildekode, kompilatorer og objekt kode er.

605
00:41:30,000 --> 00:41:32,000
Noen? Basilikum.

606
00:41:32,000 --> 00:41:37,000
Er objektkode-Jeg mener kildekoden er hva du putter i clang,

607
00:41:37,000 --> 00:41:42,000
og objektkode er hva clang legger ut slik at datamaskinen kan lese programmet.

608
00:41:42,000 --> 00:41:44,000
Akkurat.

609
00:41:44,000 --> 00:41:47,000
Kildekode er C-kode som du faktisk skriver opp.

610
00:41:47,000 --> 00:41:50,000
Objektkode er hva du får ut av klang.

611
00:41:50,000 --> 00:41:54,000
Det er 0'er og 1'ere i at binært format.

612
00:41:54,000 --> 00:41:59,000
Hva skjer da er når du har en haug med objekt-filer,

613
00:41:59,000 --> 00:42:04,000
si at du kompilere et prosjekt eller et program som bruker flere kildekodefiler,

614
00:42:04,000 --> 00:42:09,000
som etter konvensjonen får. c filtypen.

615
00:42:09,000 --> 00:42:13,000
Det er derfor vi har caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
Hvis du skriver Java-programmer du gir dem utvidelsen. Java.

617
00:42:18,000 --> 00:42:24,000
Python-programmer har filtypen. Py ofte.

618
00:42:24,000 --> 00:42:26,000
>> Når du har flere. C-filer, kompilere du dem.

619
00:42:26,000 --> 00:42:29,000
Clang spytter ut alt dette binære useriøs.

620
00:42:29,000 --> 00:42:33,000
Deretter fordi du bare vil ha 1 program

621
00:42:33,000 --> 00:42:37,000
du har linker lenken alle disse objekt filer sammen

622
00:42:37,000 --> 00:42:40,000
i en kjørbar fil.

623
00:42:40,000 --> 00:42:45,000
Dette er også hva som skjer når du bruker CS50 biblioteket, for eksempel.

624
00:42:45,000 --> 00:42:50,000
Den CS50 biblioteket er både det. H header-fil

625
00:42:50,000 --> 00:42:53,000
at du leser, at # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
Og da er det også en spesiell binær bibliotekfil

627
00:42:58,000 --> 00:43:02,000
som er blitt utarbeidet som er 0'er og 1'ere,

628
00:43:02,000 --> 00:43:08,000
og at-l flagget, så hvis vi går tilbake til våre Spaces, og vi ser veldig raskt

629
00:43:08,000 --> 00:43:11,000
på hva som skjer her når vi ser på vår clang kommando,

630
00:43:11,000 --> 00:43:15,000
hva vi har fått er at dette er vår kildekoden filen her.

631
00:43:15,000 --> 00:43:18,000
Dette er en haug med kompilatoren flagg.

632
00:43:18,000 --> 00:43:22,000
Og så helt til slutt, disse-l flagg koblingen i

633
00:43:22,000 --> 00:43:30,000
de faktiske binære filer for disse to bibliotekene, CS50 bibliotek og deretter regnestykket bibliotek.

634
00:43:30,000 --> 00:43:35,000
>> Forstå hver type filer "Formålet

635
00:43:35,000 --> 00:43:38,000
i innsamlingsprosessen er noe du ønsker å være i stand til å

636
00:43:38,000 --> 00:43:43,000
gi minst et høyt nivå oversikt.

637
00:43:43,000 --> 00:43:46,000
Kildekode kommer inn Object koden kommer ut.

638
00:43:46,000 --> 00:43:53,000
Objekt kodefiler knytte sammen, og du får en vakker, kjørbar fil.

639
00:43:53,000 --> 00:43:55,000
Cool.

640
00:43:55,000 --> 00:43:58,000
Det er også her du kan få feil på flere punkter

641
00:43:58,000 --> 00:44:00,000
i innsamlingsprosessen.

642
00:44:00,000 --> 00:44:04,000
Det er der, for eksempel, hvis du tar ut denne tilknytningen flagg,

643
00:44:04,000 --> 00:44:10,000
den CS50 flagg, og du utelater det i Spaces, eller når du kjører koden,

644
00:44:10,000 --> 00:44:13,000
Dette er hvor du vil få en feilmelding i å knytte fase,

645
00:44:13,000 --> 00:44:18,000
og linker vil si: "Hei, kalte deg en funksjon GetString

646
00:44:18,000 --> 00:44:20,000
som er i CS50 bibliotek. "

647
00:44:20,000 --> 00:44:25,000
"Du fortalte meg at det var i CS50 biblioteket, og jeg kan ikke finne koden for det."

648
00:44:25,000 --> 00:44:28,000
Det er der du må koble den inn, og som er atskilt

649
00:44:28,000 --> 00:44:33,000
fra en kompilator feil fordi kompilatoren ser på syntaks og den slags ting.

650
00:44:33,000 --> 00:44:38,000
Det er godt å vite hva som skjer når.

651
00:44:38,000 --> 00:44:42,000
>> Andre ting å vite om.

652
00:44:42,000 --> 00:44:49,000
Jeg vil si at du definitivt ønsker å ta en titt på den korte på typecasting gjort av Jordan

653
00:44:49,000 --> 00:44:55,000
å forstå hva ints er under panseret,

654
00:44:55,000 --> 00:44:58,000
hva chars er under panseret.

655
00:44:58,000 --> 00:45:02,000
Når vi snakker om ASCII, og vi faktisk ser på ASCII-tabellen,

656
00:45:02,000 --> 00:45:07,000
hva som gjør er å gi oss en under panseret utseende

657
00:45:07,000 --> 00:45:13,000
på hvordan datamaskinen faktisk representerer kapital A og tallet 7

658
00:45:13,000 --> 00:45:17,000
og et komma og et spørsmålstegn.

659
00:45:17,000 --> 00:45:20,000
Datamaskinen har også spesielle måter å representere

660
00:45:20,000 --> 00:45:23,000
tallet 7 som et heltall.

661
00:45:23,000 --> 00:45:27,000
Den har en spesiell måte å representere nummer 7 som et flyttall,

662
00:45:27,000 --> 00:45:29,000
og de er svært forskjellige.

663
00:45:29,000 --> 00:45:32,000
Typecasting er hvordan du fortelle datamaskinen "Hei, jeg vil at du skal konvertere

664
00:45:32,000 --> 00:45:37,000
fra en representasjon til en annen representasjon. "

665
00:45:37,000 --> 00:45:40,000
Hvorfor ikke vi ta en titt på det.

666
00:45:40,000 --> 00:45:44,000
>> Jeg vil også ta en titt på den korte på biblioteker og kort på kompilatorer.

667
00:45:44,000 --> 00:45:47,000
De snakker om prosessen med samling,

668
00:45:47,000 --> 00:45:53,000
hva et bibliotek er, og gå over noen av disse spørsmålene som du kan få spurt.

669
00:45:53,000 --> 00:45:55,000
Spørsmål om Week 1-materiale?

670
00:45:55,000 --> 00:46:03,000
Er det noen emner her inne som synes skremmende du ønsker å dekke?

671
00:46:03,000 --> 00:46:07,000
Jeg prøver å blåse gjennom det meste av disse tidligere emner, slik at vi kan få til

672
00:46:07,000 --> 00:46:13,000
pekere og gjøre en liten bit av rekursjon.

673
00:46:13,000 --> 00:46:15,000
Tanker?

674
00:46:15,000 --> 00:46:19,000
Noe å dekke?

675
00:46:19,000 --> 00:46:21,000
Tid for litt sjokolade kanskje?

676
00:46:21,000 --> 00:46:23,000
Dere jobber gjennom den.

677
00:46:23,000 --> 00:46:26,000
Jeg kommer til å holde sipping på min kaffe.

678
00:46:26,000 --> 00:46:31,000
Uke 2.

679
00:46:31,000 --> 00:46:34,000
God samtale, god samtale.

680
00:46:34,000 --> 00:46:38,000
I uke 2 snakket vi litt mer om funksjoner.

681
00:46:38,000 --> 00:46:43,000
>> I de første oppgavesett vi ikke egentlig skrive noen funksjoner i det hele tatt

682
00:46:43,000 --> 00:46:45,000
annet enn hvilken funksjon?

683
00:46:45,000 --> 00:46:47,000
[Student] Main. >> Main, akkurat.

684
00:46:47,000 --> 00:46:51,000
Og så har vi sett de forskjellige kostymer som viktigste slites.

685
00:46:51,000 --> 00:46:54,000
Det er en der det tar ingen argumenter,

686
00:46:54,000 --> 00:46:58,000
og vi bare si tomrom i mellom parentesene,

687
00:46:58,000 --> 00:47:01,000
og så er det den andre der vi ønsker å ta kommandolinjeargumenter,

688
00:47:01,000 --> 00:47:08,000
og som vi så, det er der du har int argc og streng argv rekke

689
00:47:08,000 --> 00:47:13,000
eller nå som vi faktisk har utsatt streng til å være den char * at det er

690
00:47:13,000 --> 00:47:20,000
vi kommer til å begynne å skrive det som char * argv og deretter parentes.

691
00:47:20,000 --> 00:47:22,000
I Problem Set 3, så dere en haug av funksjoner,

692
00:47:22,000 --> 00:47:27,000
og du implementert en haug av funksjoner, tegne, se opp, krafse.

693
00:47:27,000 --> 00:47:31,000
Prototypene ble alle skrevet der for deg.

694
00:47:31,000 --> 00:47:33,000
>> Det jeg ønsket å snakke om her med funksjoner veldig raskt

695
00:47:33,000 --> 00:47:38,000
er at det er 3 deler til dem når du skriver en funksjon.

696
00:47:38,000 --> 00:47:43,000
Du må angi avkastning type funksjonen.

697
00:47:43,000 --> 00:47:46,000
Du må angi et navn for funksjonen, og deretter må du angi

698
00:47:46,000 --> 00:47:51,000
argumentlisten eller parameterlisten.

699
00:47:51,000 --> 00:47:57,000
For eksempel, hvis jeg skulle skrive en funksjon for å oppsummere en haug av heltall

700
00:47:57,000 --> 00:48:03,000
og deretter gå tilbake til meg summen hva som ville være min retur-type

701
00:48:03,000 --> 00:48:06,000
hvis jeg ønsket å summere heltall og deretter returnere summen?

702
00:48:06,000 --> 00:48:12,000
Deretter navnet på funksjonen.

703
00:48:12,000 --> 00:48:27,000
Hvis jeg går videre og skrive i grønt, er denne delen returtypen.

704
00:48:27,000 --> 00:48:34,000
Denne delen er navnet.

705
00:48:34,000 --> 00:48:40,000
Og deretter i parentes

706
00:48:40,000 --> 00:48:46,000
er der jeg gi argumenter,

707
00:48:46,000 --> 00:48:56,000
ofte forkortet til args, noen ganger kalt params for parametere.

708
00:48:56,000 --> 00:49:00,000
Og hvis du har en, du bare angi ett.

709
00:49:00,000 --> 00:49:06,000
Hvis du har flere du skille hver enkelt med komma.

710
00:49:06,000 --> 00:49:13,000
Og for hvert argument gi deg det 2 ting som er-Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] Du må gi typen og så navnet.

712
00:49:18,000 --> 00:49:21,000
Og så navnet, og navnet er navnet som du kommer til å bruke

713
00:49:21,000 --> 00:49:25,000
å henvise til at argumentet innenfor summen funksjonen,

714
00:49:25,000 --> 00:49:27,000
i funksjonen som du nå skriver.

715
00:49:27,000 --> 00:49:32,000
>> Du trenger ikke å, for eksempel, hvis jeg kommer til å oppsummere,

716
00:49:32,000 --> 00:49:41,000
si, en rekke heltall-vi gjør int array,

717
00:49:41,000 --> 00:49:46,000
og jeg skal gi meg selv noen klammeparentes der-

718
00:49:46,000 --> 00:49:51,000
så når jeg passerer en matrise til summen funksjon

719
00:49:51,000 --> 00:49:55,000
Jeg passerer det i første posisjon av argumentet listen.

720
00:49:55,000 --> 00:49:59,000
Men tabellen som jeg passerer i ikke å ha navnet arr.

721
00:49:59,000 --> 00:50:07,000
Arr kommer til å være hvordan jeg refererer til som argument i kroppen av funksjonen.

722
00:50:07,000 --> 00:50:10,000
Den andre tingen som vi må ta hensyn til,

723
00:50:10,000 --> 00:50:14,000
og dette er litt forskjellig fra funksjoner, men jeg tror det er et viktig poeng,

724
00:50:14,000 --> 00:50:20,000
er at i C når jeg skriver en funksjon som dette

725
00:50:20,000 --> 00:50:29,000
hvordan vet jeg hvor mange elementer er i denne tabellen?

726
00:50:29,000 --> 00:50:31,000
Dette er noe av et lurespørsmål.

727
00:50:31,000 --> 00:50:35,000
Vi snakket om dette litt i forrige ukes delen.

728
00:50:35,000 --> 00:50:40,000
Hvordan vet jeg hvor mange elementer inne en rekke i C?

729
00:50:40,000 --> 00:50:44,000
Er det en måte?

730
00:50:44,000 --> 00:50:49,000
>> Det viser seg at det er ingen måte å vite.

731
00:50:49,000 --> 00:50:52,000
Du må passere det separat.

732
00:50:52,000 --> 00:50:55,000
Det er et triks som du kan gjøre

733
00:50:55,000 --> 00:51:00,000
hvis du er i samme funksjon som matrisen har blitt erklært,

734
00:51:00,000 --> 00:51:04,000
og du arbeider med en stabel array.

735
00:51:04,000 --> 00:51:06,000
Men det fungerer bare hvis du er i samme funksjon.

736
00:51:06,000 --> 00:51:09,000
Når du passerer en matrise til en annen funksjon, eller hvis du har erklært en rekke

737
00:51:09,000 --> 00:51:12,000
og du setter denne matrisen på haugen, har du brukt malloc

738
00:51:12,000 --> 00:51:15,000
 og den slags ting, er alle spill av.

739
00:51:15,000 --> 00:51:18,000
Da har du faktisk nødt til å passere rundt

740
00:51:18,000 --> 00:51:21,000
en spesiell argument eller en annen parameter

741
00:51:21,000 --> 00:51:23,000
forteller deg hvor stor matrise er.

742
00:51:23,000 --> 00:51:28,000
I dette tilfellet ønsker jeg å bruke komma-Jeg beklager, det kommer ut av skjermen her-

743
00:51:28,000 --> 00:51:32,000
og jeg vil passere i et annet argument

744
00:51:32,000 --> 00:51:40,000
 og kaller det int len ​​for lengden.

745
00:51:40,000 --> 00:51:44,000
>> En ting som kan komme opp på quiz

746
00:51:44,000 --> 00:51:49,000
ber deg om å skrive eller gjennomføre en bestemt funksjon som heter noe.

747
00:51:49,000 --> 00:51:54,000
Hvis vi ikke gi deg prototypen, så dette hele greia her,

748
00:51:54,000 --> 00:51:58,000
hele denne rotet kalles funksjonen erklæringen eller funksjonen prototype,

749
00:51:58,000 --> 00:52:01,000
dette er en av de første tingene som du ønsker å spikre ned hvis det ikke er gitt

750
00:52:01,000 --> 00:52:03,000
til deg med en gang på quiz.

751
00:52:03,000 --> 00:52:06,000
Den andre triks jeg har lært er at

752
00:52:06,000 --> 00:52:11,000
sier vi gjør gir deg en prototype for en funksjon, og vi sier: "Hei, har du til å skrive det."

753
00:52:11,000 --> 00:52:16,000
Inne i klammeparentes som du har på quiz

754
00:52:16,000 --> 00:52:20,000
Hvis du oppdager at det er en avkastning type og merke deg at avkastningen typen

755
00:52:20,000 --> 00:52:25,000
er noe annet enn tomrom, noe som betyr at funksjonen ikke returnerer noe,

756
00:52:25,000 --> 00:52:28,000
så en ting du definitivt ønsker å gjøre er å skrive

757
00:52:28,000 --> 00:52:33,000
en slags retur uttalelse på slutten av funksjonen.

758
00:52:33,000 --> 00:52:40,000
Retur, og i dette tilfellet, vil vi sette inn en tom fordi vi ønsker å fylle inn de tomme.

759
00:52:40,000 --> 00:52:44,000
Men dette får du tenke på riktig måte om hvordan jeg kommer til å nærme seg dette problemet?

760
00:52:44,000 --> 00:52:49,000
Og det minner deg om du er nødt til å returnere en verdi

761
00:52:49,000 --> 00:52:51,000
til den som ringer til funksjonen.

762
00:52:51,000 --> 00:52:54,000
>> Ja. >> [Student] Gjelder stil når vi skriver kode på quiz?

763
00:52:54,000 --> 00:52:58,000
Som innrykk og den slags ting? >> [Student] Yeah.

764
00:52:58,000 --> 00:53:00,000
Nei, ikke så mye.

765
00:53:00,000 --> 00:53:09,000
Jeg tror mye av-dette er noe vi vil avklare på quiz på dagen av,

766
00:53:09,000 --> 00:53:15,000
men typisk bekymre omfatter # og den slags ting, er det slags utenfor.

767
00:53:15,000 --> 00:53:17,000
[Student] Trenger du å kommentere en håndskrevet koden?

768
00:53:17,000 --> 00:53:19,000
Trenger du å kommentere en håndskrevet koden?

769
00:53:19,000 --> 00:53:24,000
Kommenterer alltid bra hvis du er bekymret for delvis kreditt

770
00:53:24,000 --> 00:53:29,000
eller du ønsker å kommunisere din hensikt til grader.

771
00:53:29,000 --> 00:53:33,000
Men jeg, igjen, vil avklare om quiz seg selv og på quiz dagen,

772
00:53:33,000 --> 00:53:39,000
men jeg tror ikke at du vil bli bedt om å skrive kommentarer, nei.

773
00:53:39,000 --> 00:53:42,000
Vanligvis ikke, men det er definitivt den slags ting der

774
00:53:42,000 --> 00:53:45,000
du kan kommunisere din intensjon, som "Hei, dette er hvor jeg skal med det."

775
00:53:45,000 --> 00:53:49,000
Og noen ganger som kan hjelpe med delvis kreditt.

776
00:53:49,000 --> 00:53:51,000
Cool.

777
00:53:51,000 --> 00:53:53,000
>> Basilikum.

778
00:53:53,000 --> 00:53:56,000
[Basil] Hva er forskjellen mellom å erklære, sier int lang

779
00:53:56,000 --> 00:54:03,000
i argumentene eller parametere versus erklære en variabel i funksjonen?

780
00:54:03,000 --> 00:54:05,000
Wow, gikk kaffe ned i luftrøret.

781
00:54:05,000 --> 00:54:07,000
[Basil] Like hvilke ting vi ønsker å sette i argumenter.

782
00:54:07,000 --> 00:54:09,000
Ja, det er et stort spørsmål.

783
00:54:09,000 --> 00:54:11,000
Hvordan velger du hvilke ting du ønsker å sette i argumentene

784
00:54:11,000 --> 00:54:17,000
i motsetning til hva du bør gjøre innsiden av funksjon?

785
00:54:17,000 --> 00:54:24,000
I dette tilfellet har vi inkludert begge disse som argumenter

786
00:54:24,000 --> 00:54:29,000
fordi de er noe som den som kommer til å bruke summen funksjonen

787
00:54:29,000 --> 00:54:32,000
må spesifisere disse tingene.

788
00:54:32,000 --> 00:54:35,000
>> Summen funksjonen, som vi snakket om, har ingen måte å vite

789
00:54:35,000 --> 00:54:40,000
hvor stor matrise er det blir fra sin ringer eller den som bruker summen funksjonen.

790
00:54:40,000 --> 00:54:44,000
Det har ingen måte å vite hvor stor denne matrisen er.

791
00:54:44,000 --> 00:54:48,000
Grunnen til at vi passerer i denne lengden her som et argument

792
00:54:48,000 --> 00:54:51,000
er fordi det er noe som vi i utgangspunktet forteller innringeren av funksjonen,

793
00:54:51,000 --> 00:54:55,000
den som kommer til å bruke summen funksjon "Hei, ikke bare du må gi oss en rekke

794
00:54:55,000 --> 00:54:59,000
av ints, du må også fortelle oss hvor stor tabellen som du har gitt oss er. "

795
00:54:59,000 --> 00:55:03,000
[Basil] De vil begge være kommandolinjeargumenter?

796
00:55:03,000 --> 00:55:06,000
Nei, dette er faktisk argumenter som du ville passere til funksjonen.

797
00:55:06,000 --> 00:55:10,000
>> La meg gjøre en ny side her.

798
00:55:10,000 --> 00:55:13,000
[Basil] Som navnet skulle passere-

799
00:55:13,000 --> 00:55:24,000
[Nate H.] Hvis jeg har int main (void),

800
00:55:24,000 --> 00:55:27,000
og jeg kommer til å sette i min return 0 her nede på bunnen,

801
00:55:27,000 --> 00:55:31,000
og si jeg vil kalle summen funksjonen.

802
00:55:31,000 --> 00:55:42,000
Jeg ønsker å si int x = sum ();

803
00:55:42,000 --> 00:55:46,000
Å bruke summen funksjon jeg har til å passere både i matrisen som jeg ønsker å oppsummere

804
00:55:46,000 --> 00:55:51,000
og lengden av tabellen, så dette er hvor

805
00:55:51,000 --> 00:55:54,000
antar jeg hadde en rekke ints,

806
00:55:54,000 --> 00:56:12,000
si at jeg hadde int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
type bruk som hacket seg syntaks akkurat der,

808
00:56:16,000 --> 00:56:21,000
så hva jeg ville gjøre er i sum jeg ønsker å passere i

809
00:56:21,000 --> 00:56:27,000
både numbaz og 3

810
00:56:27,000 --> 00:56:30,000
å fortelle summen funksjonen "Ok, her er tabellen jeg vil at du skal summere."

811
00:56:30,000 --> 00:56:34,000
"Her er størrelsen."

812
00:56:34,000 --> 00:56:39,000
Gjør det fornuftig? Svarer at spørsmålet ditt?

813
00:56:39,000 --> 00:56:42,000
>> På mange måter gjør det parallelt hva vi gjør med hoved

814
00:56:42,000 --> 00:56:44,000
når vi har kommandolinjeargumentene.

815
00:56:44,000 --> 00:56:47,000
Et program som Caesar cipher, for eksempel, trengte det

816
00:56:47,000 --> 00:56:53,000
kommandolinjeargumenter ikke ville være i stand til å gjøre noe.

817
00:56:53,000 --> 00:56:57,000
Det ville ikke vet hvordan å kryptere hvis du ikke fortelle den hva nøkkel for å bruke

818
00:56:57,000 --> 00:57:03,000
eller hvis du ikke fortelle den hva strengen du ønsket å kryptere.

819
00:57:03,000 --> 00:57:08,000
Ber om innspill, dette er hvor vi har to ulike mekanismer

820
00:57:08,000 --> 00:57:14,000
for å ta innspill fra brukeren, for å ta informasjon i fra brukeren.

821
00:57:14,000 --> 00:57:19,000
For Problem Set 1 vi så dette GetInt, GetString, GetFloat måte

822
00:57:19,000 --> 00:57:26,000
for å be om innspill, og det kalles å bruke standard input stream.

823
00:57:26,000 --> 00:57:28,000
Det er litt annerledes.

824
00:57:28,000 --> 00:57:31,000
Det er noe som du kan gjøre på en gang, i motsetning til

825
00:57:31,000 --> 00:57:35,000
når du åpner programmet, når du starter programmet kjører.

826
00:57:35,000 --> 00:57:41,000
Kommandolinjeargumentene alle spesifiseres når du starter programmet kjører.

827
00:57:41,000 --> 00:57:47,000
Vi har vært å blande to av dem.

828
00:57:47,000 --> 00:57:52,000
Når vi bruker argumenter til en funksjon, er det mye som kommandolinjeargumenter til hovedsiden.

829
00:57:52,000 --> 00:57:56,000
Det er når du starter funksjonen må du fortelle det

830
00:57:56,000 --> 00:58:05,000
hva den trenger for å kunne utføre sine oppgaver.

831
00:58:05,000 --> 00:58:08,000
En annen god ting å se på, og jeg skal fortelle deg se på det i fritiden,

832
00:58:08,000 --> 00:58:11,000
og det ble dekket i quiz-var denne oppfatningen av omfanget

833
00:58:11,000 --> 00:58:15,000
og lokale variabler versus globale variabler.

834
00:58:15,000 --> 00:58:18,000
Gjør oppmerksom på det.

835
00:58:18,000 --> 00:58:23,000
>> Nå som vi får på denne andre ting,

836
00:58:23,000 --> 00:58:27,000
i uke 3 begynte vi å snakke om søking og sortering.

837
00:58:27,000 --> 00:58:32,000
Søking og sortering, i hvert fall i CS50,

838
00:58:32,000 --> 00:58:39,000
er veldig mye en introduksjon til noen av de mer teoretiske delene av informatikk.

839
00:58:39,000 --> 00:58:42,000
Problemet med søking, problemet med sortering

840
00:58:42,000 --> 00:58:46,000
er store, kanoniske problemer.

841
00:58:46,000 --> 00:58:52,000
Hvordan finner du et bestemt nummer i en rekke av milliarder av heltall?

842
00:58:52,000 --> 00:58:55,000
Hvordan finner du et bestemt navn i en telefonkatalog

843
00:58:55,000 --> 00:58:59,000
som er lagret på den bærbare datamaskinen?

844
00:58:59,000 --> 00:59:04,000
Og så vi introdusere denne oppfatningen av asymptotiske kjøre ganger

845
00:59:04,000 --> 00:59:11,000
å virkelig tallfeste hvor lenge, hvor hardt disse problem er,

846
00:59:11,000 --> 00:59:14,000
hvor lenge de tar for å løse.

847
00:59:14,000 --> 00:59:20,000
I, tror jeg, 2011s quiz det er et problem som jeg tror meritter

848
00:59:20,000 --> 00:59:27,000
dekker svært raskt, som er denne, problemet 12.

849
00:59:27,000 --> 00:59:32,000
O nei, det er Omega.

850
00:59:32,000 --> 00:59:41,000
>> Her snakker vi om raskest mulig kjøretid

851
00:59:41,000 --> 00:59:46,000
for en bestemt algoritme og deretter den tregeste mulig kjøretid.

852
00:59:46,000 --> 00:59:52,000
Dette Omega og O er egentlig bare snarveier.

853
00:59:52,000 --> 00:59:55,000
De er notasjonskonvensjonene snarveier for å si

854
00:59:55,000 --> 00:59:59,000
hvor fort på best mulig tilfelle vil vår algoritme kjøre,

855
00:59:59,000 --> 01:00:06,000
og hvor treg i verst tenkelige tilfelle vil vår algoritme kjøre?

856
01:00:06,000 --> 01:00:10,000
La oss gjøre et par av disse, og disse ble også dekket

857
01:00:10,000 --> 01:00:13,000
på kort på asymptotisk notasjon, som jeg anbefaler.

858
01:00:13,000 --> 01:00:17,000
Jackson gjorde en veldig god jobb.

859
01:00:17,000 --> 01:00:23,000
Med binær søk, snakker vi om binære søk som en algoritme,

860
01:00:23,000 --> 01:00:28,000
og vi vanligvis snakker om det i form av sin store O.

861
01:00:28,000 --> 01:00:30,000
Hva er den store O?

862
01:00:30,000 --> 01:00:34,000
Hva er den tregeste mulig kjøretid av binære søk?

863
01:00:34,000 --> 01:00:36,000
[Student] N ²?

864
01:00:36,000 --> 01:00:41,000
Close, antar jeg ligner på det.

865
01:00:41,000 --> 01:00:43,000
Det er mye raskere enn det.

866
01:00:43,000 --> 01:00:45,000
[Student] Binary? >> Ja, binær søk.

867
01:00:45,000 --> 01:00:47,000
[Student] Det er log n.

868
01:00:47,000 --> 01:00:49,000
Logg n, så hva gjør logge n mener?

869
01:00:49,000 --> 01:00:51,000
Det halverer det hver iterasjon.

870
01:00:51,000 --> 01:00:56,000
Nøyaktig, så i den tregeste mulig tilfelle,

871
01:00:56,000 --> 01:01:00,000
si hvis du har en sortert rekke

872
01:01:00,000 --> 01:01:08,000
av en million heltall og antall du leter etter

873
01:01:08,000 --> 01:01:14,000
er enten den aller første element i matrisen eller den aller siste element i matrisen.

874
01:01:14,000 --> 01:01:18,000
Husk fungerer det binære søk algoritme ved å se på midten element,

875
01:01:18,000 --> 01:01:21,000
se om det er kampen som du leter etter.

876
01:01:21,000 --> 01:01:23,000
Hvis det er, så flott, du fant den.

877
01:01:23,000 --> 01:01:27,000
>> På best mulig tilfelle, hvor fort gjør binære søk kjøre?

878
01:01:27,000 --> 01:01:29,000
[Studenter] 1.

879
01:01:29,000 --> 01:01:32,000
1, er det konstant tid, stor O av en. Ja.

880
01:01:32,000 --> 01:01:36,000
[Student] Jeg har et spørsmål. Når du sier logge av n, mener du med hensyn til base 2, ikke sant?

881
01:01:36,000 --> 01:01:40,000
Ja, slik at den andre tingen.

882
01:01:40,000 --> 01:01:44,000
Vi sier log n, og jeg antar da jeg var på high school

883
01:01:44,000 --> 01:01:48,000
Jeg har alltid antatt at loggen var base 10.

884
01:01:48,000 --> 01:01:57,000
Ja, så ja, kan du logge base 2 typisk er det vi bruker.

885
01:01:57,000 --> 01:02:02,000
Igjen, gå tilbake til binære søk, hvis du søker for enten

886
01:02:02,000 --> 01:02:05,000
elementet på slutten eller elementet helt i begynnelsen,

887
01:02:05,000 --> 01:02:08,000
fordi du starter i midten og deretter kaste

888
01:02:08,000 --> 01:02:13,000
hvilken en halv oppfyller ikke kriteriene du leter etter,

889
01:02:13,000 --> 01:02:15,000
og du går videre til neste halvår og neste halvår og neste halve.

890
01:02:15,000 --> 01:02:19,000
Hvis jeg søker etter den største element i millioner heltall matrise

891
01:02:19,000 --> 01:02:25,000
Jeg kommer til å halvere det på de fleste log på 1 million ganger

892
01:02:25,000 --> 01:02:28,000
før jeg endelig teste og se at elementet jeg leter etter

893
01:02:28,000 --> 01:02:33,000
er i den største eller i den høyeste indeks av tabellen,

894
01:02:33,000 --> 01:02:38,000
og som vil ta logg av n, logg av 1 million ganger.

895
01:02:38,000 --> 01:02:40,000
>> Bubble slag.

896
01:02:40,000 --> 01:02:43,000
Husker dere gjøre boblen slags algoritme?

897
01:02:43,000 --> 01:02:47,000
Kevin, kan du gi meg en rask oppsummering av hva som skjedde i boblen slags algoritme?

898
01:02:47,000 --> 01:02:50,000
[Kevin] I utgangspunktet går gjennom alt på listen.

899
01:02:50,000 --> 01:02:52,000
Det ser på de to første.

900
01:02:52,000 --> 01:02:55,000
Hvis den første er større enn den andre en Den bytter dem.

901
01:02:55,000 --> 01:02:58,000
Deretter sammenlignes andre og tredje, samme, bytteavtaler,

902
01:02:58,000 --> 01:03:00,000
tredje og fjerde, hele veien ned.

903
01:03:00,000 --> 01:03:03,000
Større tall vil følge opp til slutt.

904
01:03:03,000 --> 01:03:07,000
Og etter imidlertid mange looper du er ferdig.

905
01:03:07,000 --> 01:03:11,000
Nøyaktig, så hva Kevin sa at vi vil se større tall

906
01:03:11,000 --> 01:03:15,000
boble opp til slutten av tabellen.

907
01:03:15,000 --> 01:03:19,000
For eksempel, gjør du noe imot vandre oss gjennom dette eksemplet hvis dette er vår array?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Du tar 2 og 3.

909
01:03:21,000 --> 01:03:23,000
3 er større enn 2, slik at du bytte dem.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Høyre, så vi bytte disse, og så får vi 2, 3, 6, 4 og 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] Så du sammenligne 3 og 6.

912
01:03:31,000 --> 01:03:33,000
3 er mindre enn 6, så du lar dem,

913
01:03:33,000 --> 01:03:37,000
og 6 og 4, vil du bytte dem fordi 4 er mindre enn seks.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] Høyre, så jeg får 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] og 9 er større enn 6, så du forlater den.

916
01:03:46,000 --> 01:03:48,000
Og du vil gå tilbake gjennom det igjen.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H.] Er jeg ferdig på dette punktet? >> [Kevin] Nei

918
01:03:50,000 --> 01:03:52,000
Og hvorfor er jeg ikke ferdig på dette punktet?

919
01:03:52,000 --> 01:03:54,000
Fordi det ser ut som min tabellen er sortert. Jeg ser på det.

920
01:03:54,000 --> 01:03:57,000
[Kevin] Gå gjennom det igjen og sørge for at det ikke er flere bytteavtaler

921
01:03:57,000 --> 01:04:00,000
før du kan fullt ut slutte.

922
01:04:00,000 --> 01:04:04,000
Nøyaktig, så du må holde det gående gjennom og sørge for at det ikke er noen swapper

923
01:04:04,000 --> 01:04:06,000
at du kan gjøre på dette punktet.

924
01:04:06,000 --> 01:04:08,000
Det var egentlig bare flaks, som du sa, at vi endte opp med

925
01:04:08,000 --> 01:04:12,000
bare måtte gjøre en går gjennom og vi er sortert.

926
01:04:12,000 --> 01:04:16,000
Men for å gjøre dette i det generelle tilfellet vil vi faktisk nødt til å gjøre dette om og om igjen.

927
01:04:16,000 --> 01:04:20,000
Og faktisk, dette var et eksempel på en best mulig tilfelle,

928
01:04:20,000 --> 01:04:24,000
som vi så i problemet.

929
01:04:24,000 --> 01:04:28,000
Vi så at best mulig saken ble n..

930
01:04:28,000 --> 01:04:32,000
Vi gikk gjennom matrisen en gang.

931
01:04:32,000 --> 01:04:35,000
Hva er det verste mulig tilfelle for denne algoritmen?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
Og hva sånn ut? Hva ville en rekke ser sånn ville ta n ² tid?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [hørbar] sortert.

935
01:04:43,000 --> 01:04:51,000
Akkurat, så hvis jeg hadde matrisen 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
først ni ville boble hele veien opp.

937
01:04:54,000 --> 01:04:59,000
Etter en iterasjon ville vi ha 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Deretter 7 ville boble opp, 6, 5, 2, 7, 9, og så videre og så videre.

939
01:05:07,000 --> 01:05:13,000
>> Vi måtte gå gjennom hele matrisen n ganger,

940
01:05:13,000 --> 01:05:16,000
og du kan faktisk få litt mer presis enn dette

941
01:05:16,000 --> 01:05:23,000
fordi når vi har flyttet 9 hele veien opp til sin siste mulige posisjon

942
01:05:23,000 --> 01:05:26,000
Vi vet at vi aldri trenger å sammenligne mot dette elementet på nytt.

943
01:05:26,000 --> 01:05:29,000
Når vi begynner å boblende de 7 opp

944
01:05:29,000 --> 01:05:35,000
Vi vet at vi kan stoppe når 7 er rett før 9

945
01:05:35,000 --> 01:05:37,000
siden vi allerede har sammenlignet 9 til det.

946
01:05:37,000 --> 01:05:46,000
Hvis du gjør dette på en smart måte er det ikke virkelig, jeg antar at mye tid.

947
01:05:46,000 --> 01:05:49,000
Du kommer ikke til å sammenligne alle mulige [hørbar] kombinasjoner

948
01:05:49,000 --> 01:05:55,000
hver eneste gang du går gjennom hver iterasjon.

949
01:05:55,000 --> 01:05:59,000
Men likevel, når vi snakker om dette øvre grense vi si at

950
01:05:59,000 --> 01:06:04,000
du ser på n ² sammenligninger hele veien gjennom.

951
01:06:04,000 --> 01:06:12,000
>> La oss gå tilbake, og siden vi begynner å bli litt kort på tid

952
01:06:12,000 --> 01:06:15,000
Jeg vil si at du bør definitivt gå gjennom resten av denne tabellen,

953
01:06:15,000 --> 01:06:17,000
fylle det ut.

954
01:06:17,000 --> 01:06:20,000
Tenk på eksempler. Tenk på konkrete eksempler.

955
01:06:20,000 --> 01:06:22,000
Det er veldig praktisk og nyttig å gjøre.

956
01:06:22,000 --> 01:06:25,000
Trekke den ut.

957
01:06:25,000 --> 01:06:28,000
Dette er den type tabell som når du går gjennom i informatikk

958
01:06:28,000 --> 01:06:32,000
du burde virkelig begynne å kjenne disse utenat.

959
01:06:32,000 --> 01:06:34,000
Dette er den typen spørsmål du får i intervjuer.

960
01:06:34,000 --> 01:06:36,000
Dette er slags ting som er bra å vite,

961
01:06:36,000 --> 01:06:41,000
og tenke på de edge tilfeller virkelig finne ut hvordan å tenke

962
01:06:41,000 --> 01:06:45,000
vel vitende om at for boble sortere verst tenkelige utvalg

963
01:06:45,000 --> 01:06:52,000
å sortere med det er en som er i motsatt rekkefølge.

964
01:06:52,000 --> 01:06:58,000
>> Pekere. La oss snakke litt om pekere.

965
01:06:58,000 --> 01:07:03,000
I de siste minuttene har vi her

966
01:07:03,000 --> 01:07:11,000
Jeg vet dette er noe sammen med fil I / O som er ganske ny.

967
01:07:11,000 --> 01:07:19,000
Når vi snakker om pekere grunnen til at vi ønsker å snakke om pekere

968
01:07:19,000 --> 01:07:24,000
er fordi, en, når vi jobber i C

969
01:07:24,000 --> 01:07:33,000
Vi er virkelig på et relativt lavt nivå sammenlignet med de fleste moderne programmeringsspråk.

970
01:07:33,000 --> 01:07:38,000
Vi er faktisk i stand til å manipulere variabler i minnet,

971
01:07:38,000 --> 01:07:43,000
finne ut hvor de er faktisk ligger innenfor RAM vår.

972
01:07:43,000 --> 01:07:46,000
Når du har gått på å ta operativsystem klasser du vil se

973
01:07:46,000 --> 01:07:48,000
at det er, igjen, slag av en abstraksjon.

974
01:07:48,000 --> 01:07:50,000
Det er faktisk ikke tilfelle.

975
01:07:50,000 --> 01:07:52,000
Vi har virtuelt minne som gjemmer disse detaljene fra oss.

976
01:07:52,000 --> 01:07:58,000
>> Men for nå kan du anta at når du har et program,

977
01:07:58,000 --> 01:08:02,000
for eksempel når du begynner å kjøre din Caesar cipher program-

978
01:08:02,000 --> 01:08:06,000
Jeg vil bytte tilbake til min iPad virkelig raskt-

979
01:08:06,000 --> 01:08:12,000
at helt i begynnelsen programmet ditt, hvis du har, sier

980
01:08:12,000 --> 01:08:15,000
4 gigabyte RAM på din bærbare PC,

981
01:08:15,000 --> 01:08:21,000
du får sette denne blings, og vi kaller dette RAM.

982
01:08:21,000 --> 01:08:25,000
Og den starter på et sted vi kommer til å ringe 0,

983
01:08:25,000 --> 01:08:30,000
og det ender på et sted som vi kaller 4 gigabyte.

984
01:08:30,000 --> 01:08:37,000
Jeg kan virkelig ikke skrive. Man, er at hacket.

985
01:08:37,000 --> 01:08:40,000
Når programmet utfører

986
01:08:40,000 --> 01:08:44,000
operativsystemet rister opp RAM,

987
01:08:44,000 --> 01:08:51,000
og det angir ulike segmenter for ulike deler av programmet til å leve i.

988
01:08:51,000 --> 01:08:58,000
Her nede dette området er slag av en ingenmannsland.

989
01:08:58,000 --> 01:09:02,000
Når du går opp litt lenger her

990
01:09:02,000 --> 01:09:05,000
du har faktisk det stedet hvor

991
01:09:05,000 --> 01:09:09,000
koden for programmet liv.

992
01:09:09,000 --> 01:09:13,000
At faktisk binær kode, som kjørbar fil faktisk blir lastet inn i minnet

993
01:09:13,000 --> 01:09:17,000
når du kjører et program, og den lever i kodesegmentet.

994
01:09:17,000 --> 01:09:22,000
Og som programmet utfører prosessoren ser på dette kodesegmentet

995
01:09:22,000 --> 01:09:24,000
å finne ut hva som er den neste instruksjonen?

996
01:09:24,000 --> 01:09:27,000
Hva er neste kodelinje jeg trenger å kjøre?

997
01:09:27,000 --> 01:09:31,000
>> Det er også en data-segmentet, og det er her de streng konstanter

998
01:09:31,000 --> 01:09:34,000
bli lagret som du har brukt.

999
01:09:34,000 --> 01:09:42,000
Og så lenger opp er det dette stedet kalt haugen.

1000
01:09:42,000 --> 01:09:46,000
Vi har tilgang til minnet i det ved hjelp av malloc,

1001
01:09:46,000 --> 01:09:49,000
og deretter mot toppen av programmet

1002
01:09:49,000 --> 01:09:52,000
det er stabelen,

1003
01:09:52,000 --> 01:09:57,000
og det er der vi har spilt for det meste av begynnelsen.

1004
01:09:57,000 --> 01:09:59,000
Dette er ikke i målestokk eller noe.

1005
01:09:59,000 --> 01:10:03,000
Mye av dette er svært maskinen avhengig,

1006
01:10:03,000 --> 01:10:10,000
operativsystemet avhengige, men dette er relativt hvordan ting blir chunked opp.

1007
01:10:10,000 --> 01:10:17,000
Når du kjører et program og erklærer deg en variabel kalt x-

1008
01:10:17,000 --> 01:10:27,000
Jeg kommer til å trekke en annen boks der nede, og dette kommer til å bli RAM også.

1009
01:10:27,000 --> 01:10:29,000
Og jeg kommer til å se.

1010
01:10:29,000 --> 01:10:34,000
Vi vil trekke takkete linjer for å indikere dette er bare en liten del av RAM

1011
01:10:34,000 --> 01:10:38,000
og ikke alle av det som vi trekke øverst.

1012
01:10:38,000 --> 01:10:43,000
>> Hvis jeg erklærer en heltallsvariabel kalt x,

1013
01:10:43,000 --> 01:10:49,000
så hva jeg egentlig får er en kartlegging

1014
01:10:49,000 --> 01:10:54,000
som er lagret i symboltabellen av mitt program

1015
01:10:54,000 --> 01:11:00,000
som forbinder navnet x til denne regionen av minnet som jeg har trukket

1016
01:11:00,000 --> 01:11:03,000
her mellom de vertikale stolpene.

1017
01:11:03,000 --> 01:11:08,000
Hvis jeg har en linje med kode i mitt program som sier x = 7

1018
01:11:08,000 --> 01:11:15,000
prosessoren vet "Oh, ok, jeg vet at x bor på dette stedet i minnet."

1019
01:11:15,000 --> 01:11:25,000
"Jeg kommer til å gå videre og skrive en 7 der."

1020
01:11:25,000 --> 01:11:28,000
Hvordan føles det vet hvilken plassering dette er i minnet?

1021
01:11:28,000 --> 01:11:30,000
Vel, det er alt gjort på kompilering.

1022
01:11:30,000 --> 01:11:34,000
Kompilatoren tar seg av tildeling hvor hver av variablene kommer til å gå

1023
01:11:34,000 --> 01:11:40,000
og å opprette en spesiell kartlegging eller snarere koble prikkene

1024
01:11:40,000 --> 01:11:43,000
mellom et symbol og hvor det kommer, en variabel navn

1025
01:11:43,000 --> 01:11:46,000
og hvor det kommer til å leve i minnet.

1026
01:11:46,000 --> 01:11:50,000
Men det viser seg at vi faktisk kan få tilgang til den i våre programmer også.

1027
01:11:50,000 --> 01:11:55,000
Dette blir viktig når vi begynner å snakke om noen av datastrukturer,

1028
01:11:55,000 --> 01:11:58,000
som er et konsept som vi kommer til å innføre senere.

1029
01:11:58,000 --> 01:12:09,000
>> Men for nå, hva du kan vite er at jeg kan lage en peker til denne plasseringen, x.

1030
01:12:09,000 --> 01:12:12,000
For eksempel kan jeg lage en peker variabel.

1031
01:12:12,000 --> 01:12:16,000
Når vi lage en peker variabel vi bruke stjernen notasjon.

1032
01:12:16,000 --> 01:12:21,000
I dette tilfellet, sier dette jeg kommer til å lage en peker til en int.

1033
01:12:21,000 --> 01:12:24,000
Det er en type akkurat som alle andre.

1034
01:12:24,000 --> 01:12:27,000
Vi gir den en variabel som y,

1035
01:12:27,000 --> 01:12:32,000
og da vi satt den lik adressen, til en adresse.

1036
01:12:32,000 --> 01:12:38,000
I dette tilfellet, kan vi sette y for å peke til x

1037
01:12:38,000 --> 01:12:43,000
ved å ta inn adressen x, som vi gjør med denne ampersand,

1038
01:12:43,000 --> 01:12:55,000
og da vi satt y å peke på den.

1039
01:12:55,000 --> 01:12:59,000
Hva dette egentlig betyr er hvis vi ser på RAM vår

1040
01:12:59,000 --> 01:13:02,000
Dette skaper en egen variabel.

1041
01:13:02,000 --> 01:13:04,000
Det kommer til å kalle det y,

1042
01:13:04,000 --> 01:13:06,000
og når denne linjen med kode utfører

1043
01:13:06,000 --> 01:13:13,000
det er faktisk kommer til å lage en liten peker som vi vanligvis trekker som en pil,

1044
01:13:13,000 --> 01:13:15,000
og det setter y å peke på x.

1045
01:13:15,000 --> 01:13:17,000
Ja.

1046
01:13:17,000 --> 01:13:19,000
[Student] Hvis x er allerede en peker, ville du bare gjøre

1047
01:13:19,000 --> 01:13:22,000
int * y = x stedet for å ha tegnet?

1048
01:13:22,000 --> 01:13:24,000
Ja.

1049
01:13:24,000 --> 01:13:27,000
Hvis x er allerede en peker, så kan du sette to pekere lik hverandre,

1050
01:13:27,000 --> 01:13:30,000
i så fall ikke y vil peke på x,

1051
01:13:30,000 --> 01:13:34,000
men det ville peke på hva x peker til.

1052
01:13:34,000 --> 01:13:37,000
Dessverre, vi er ute av tiden.

1053
01:13:37,000 --> 01:13:44,000
>> Hva jeg kan si på dette punktet, kan vi snakke om dette offline,

1054
01:13:44,000 --> 01:13:49,000
men jeg vil si begynne å jobbe gjennom dette problemet, # 14.

1055
01:13:49,000 --> 01:13:53,000
Du kan se det allerede litt fylt ut for deg her.

1056
01:13:53,000 --> 01:13:57,000
Du kan se at når vi erklærer 2 pekere, int * x og * y,

1057
01:13:57,000 --> 01:14:01,000
og merk at peker * ved siden av variabelen var noe som ble gjort i fjor.

1058
01:14:01,000 --> 01:14:05,000
Det viser seg at dette er likt det vi gjør i år.

1059
01:14:05,000 --> 01:14:11,000
Det spiller ingen rolle hvor du skriver * når du erklære pekeren.

1060
01:14:11,000 --> 01:14:17,000
Men vi har skrevet * ved siden av typen

1061
01:14:17,000 --> 01:14:24,000
fordi det gjør det veldig klart at du erklære en peker variabel.

1062
01:14:24,000 --> 01:14:27,000
Du kan se at erklære 2 pekere gir oss to esker.

1063
01:14:27,000 --> 01:14:31,000
Her når vi setter x lik malloc

1064
01:14:31,000 --> 01:14:34,000
hva dette sier er å sette minne i haugen.

1065
01:14:34,000 --> 01:14:41,000
Denne lille boksen her, denne sirkelen, ligger på haugen.

1066
01:14:41,000 --> 01:14:43,000
X er koblet til den.

1067
01:14:43,000 --> 01:14:46,000
Legg merke til at y er fortsatt ikke peker til noe.

1068
01:14:46,000 --> 01:14:50,000
For å få minne-for å lagre nummeret 42 i x

1069
01:14:50,000 --> 01:14:55,000
vi ville bruke det notasjon?

1070
01:14:55,000 --> 01:14:59,000
[Student] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Akkurat, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
Det betyr følge pilen og kaste 42 i det.

1073
01:15:06,000 --> 01:15:09,000
Her hvor vi setter y og x har vi y peker til x.

1074
01:15:09,000 --> 01:15:13,000
Igjen, dette er akkurat som det Kevin sa hvor vi setter y lik x.

1075
01:15:13,000 --> 01:15:15,000
Y er ikke peker til x.

1076
01:15:15,000 --> 01:15:19,000
Snarere er det å peke på hva x peker til også.

1077
01:15:19,000 --> 01:15:24,000
>> Og så til slutt i denne siste boksen er det to mulige ting som vi kunne gjøre.

1078
01:15:24,000 --> 01:15:28,000
Det ene er at vi kunne si * x = 13.

1079
01:15:28,000 --> 01:15:33,000
Den andre tingen er at vi kunne si-Alex, vet du hva vi kunne gjøre her?

1080
01:15:33,000 --> 01:15:37,000
Du kan si * x = 13 eller-

1081
01:15:37,000 --> 01:15:41,000
[Student] Du kan si int uansett.

1082
01:15:41,000 --> 01:15:45,000
[Nate H.] Hvis dette ble referert til som en int variabel vi kunne gjøre det.

1083
01:15:45,000 --> 01:15:49,000
Vi kan også si * y = 13 fordi de er begge peker til samme sted,

1084
01:15:49,000 --> 01:15:51,000
slik at vi kunne bruke enten variabel for å komme dit.

1085
01:15:51,000 --> 01:15:56,000
Ja. >> [Student] Hvordan ville det se ut som om vi bare si int x er 13?

1086
01:15:56,000 --> 01:16:00,000
Det ville være å erklære en ny variabel kalt x, som ikke ville fungere.

1087
01:16:00,000 --> 01:16:04,000
Vi ville ha en kollisjon fordi vi erklært x å være en peker opp her.

1088
01:16:04,000 --> 01:16:10,000
[Student] Hvis vi bare hadde den uttalelsen i seg selv hva ville det se ut i form av sirkelen?

1089
01:16:10,000 --> 01:16:14,000
Hvis vi hadde x = 13 da ville vi ha en boks, og heller enn å ha en pil

1090
01:16:14,000 --> 01:16:16,000
kommer ut av boksen vi ville tegne det som bare en 13.

1091
01:16:16,000 --> 01:16:19,000
[Student] I boksen. Okay.

1092
01:16:19,000 --> 01:16:24,000
>> Takk for at du ser på, og lykke til på Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]