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

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
>> Okay, velkommen tilbage til afsnittet.

5
00:00:10,000 --> 00:00:13,000
I denne uges afsnit vil vi gøre et par ting.

6
00:00:13,000 --> 00:00:17,000
Vi skal til første opsummere Problem Set 2,

7
00:00:17,000 --> 00:00:20,000
som er Cæsar og Vigenère problem sæt.

8
00:00:20,000 --> 00:00:23,000
Og så vil vi dykke ned i Quiz 0 anmeldelse

9
00:00:23,000 --> 00:00:26,000
og tilbringe en lille smule tid slidbanepålægning hvad vi har talt om

10
00:00:26,000 --> 00:00:30,000
i hvert af de foredrag hidtil, og vi vil også gøre et par problemer

11
00:00:30,000 --> 00:00:32,000
fra sidste års quizzer.

12
00:00:32,000 --> 00:00:36,000
På den måde du fyre har en god måde at forberede sig til det.

13
00:00:36,000 --> 00:00:40,000
>> For at starte, jeg har startet op et par gode løsninger

14
00:00:40,000 --> 00:00:45,000
for det foregående problem sæt, Set Problem 2, ind i dette rum.

15
00:00:45,000 --> 00:00:48,000
Hvis du fyre alle ramt dette link,

16
00:00:48,000 --> 00:00:53,000
og hvis du klikker på mit navn, og klik på min første revision

17
00:00:53,000 --> 00:00:56,000
vil du se caesar.c, hvilket er præcis, hvad jeg ser på.

18
00:00:56,000 --> 00:01:00,000
Lad os tale om det virkelig hurtigt.

19
00:01:00,000 --> 00:01:02,000
Dette er blot en prøveopløsning.

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

21
00:01:05,000 --> 00:01:08,000
Der er mange forskellige måder at skrive dette,

22
00:01:08,000 --> 00:01:10,000
men der er et par ting, jeg ønskede at fremhæve

23
00:01:10,000 --> 00:01:13,000
, som jeg så, da jeg var klassificering, almindelige fejl, som jeg tror

24
00:01:13,000 --> 00:01:18,000
denne løsning gør et godt stykke arbejde med håndtering.

25
00:01:18,000 --> 00:01:22,000
>> Den første er at have en form for header kommentarer på toppen.

26
00:01:22,000 --> 00:01:25,000
På linje 1 til 7 du se detaljerne,

27
00:01:25,000 --> 00:01:28,000
hvad dette program gø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
uanset om dit program er indeholdt i en enkelt fil eller

30
00:01:35,000 --> 00:01:38,000
uanset om det er delt over flere filer, er at have en form for

31
00:01:38,000 --> 00:01:40,000
orientering kommentarer på toppen.

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

33
00:01:43,000 --> 00:01:47,000
Det er her, de vil lægge oplysninger om ophavsret.

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

35
00:01:50,000 --> 00:01:55,000
På linie 16 er der denne # define, som vi vil vende tilbage til i bare en smule.

36
00:01:55,000 --> 00:01:59,000
Og derefter en gang funktionen starter, når de vigtigste starter,

37
00:01:59,000 --> 00:02:03,000
fordi dette program er blevet alle indeholdt i en enkelt funktion

38
00:02:03,000 --> 00:02:09,000
den allerførste ting, der sker, og det er meget idiomatisk og typisk for et C-program

39
00:02:09,000 --> 00:02:14,000
der tager i kommandolinjeflag-er, at den straks tjekker

40
00:02:14,000 --> 00:02:18,000
>> for argumentet tæller,. argc

41
00:02:18,000 --> 00:02:24,000
Lige her ser vi, at dette program forventer 2 argumenter nøjagtigt.

42
00:02:24,000 --> 00:02:27,000
Husk der er det første argument, der er den særlige en

43
00:02:27,000 --> 00:02:29,000
det er altid navnet på det program, der bliver kørt,

44
00:02:29,000 --> 00:02:31,000
navnet på den eksekverbare fil.

45
00:02:31,000 --> 00:02:36,000
Og så hvad det gør, er det forhindrer brugeren i at kø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
Årsagen til at vi ønsker at tjekke for denne ret væk er fordi

48
00:02:44,000 --> 00:02:52,000
Vi kan faktisk ikke få adgang til denne argv opstilling lige her pålideligt

49
00:02:52,000 --> 00:02:55,000
indtil vi har tjekket for at se, hvor stor den er.

50
00:02:55,000 --> 00:02:58,000
>> En af de almindelige fejl jeg så var folk ville straks gå i

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

52
00:03:01,000 --> 00:03:06,000
De havde fat i nøglen argument ud af arrayet og har den en for jeg kontrollere det,

53
00:03:06,000 --> 00:03:11,000
og så de ville gøre testen for argc samt den næste test,

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

55
00:03:16,000 --> 00:03:20,000
og det ikke virker, fordi der i det tilfælde, at der ikke er nogen leverede argumenter

56
00:03:20,000 --> 00:03:26,000
du skal snuppe et argument, der ikke er der, eller forsøger at få fat i en, der ikke er der.

57
00:03:26,000 --> 00:03:29,000
>> Den anden store ting, du bør bemærke, er, at

58
00:03:29,000 --> 00:03:32,000
du altid ønsker at udskrive en slags nyttige fejlmeddelelse

59
00:03:32,000 --> 00:03:34,000
for brugeren at orientere dem.

60
00:03:34,000 --> 00:03:37,000
Jeg er sikker på du har alle run programmer, hvor alle af en pludselig det går ned,

61
00:03:37,000 --> 00:03:41,000
og du får denne latterlige lille dialogboks, der popper op og siger

62
00:03:41,000 --> 00:03:44,000
noget forfærdeligt kryptisk og måske giver dig en fejlkode eller noget i den retning

63
00:03:44,000 --> 00:03:47,000
Det giver ingen mening.

64
00:03:47,000 --> 00:03:50,000
Det er her, du virkelig ønsker at give noget nyttigt

65
00:03:50,000 --> 00:03:54,000
og målrettet til brugeren, så når de kører det de går "Oh," ansigt håndflade.

66
00:03:54,000 --> 00:03:58,000
"Jeg ved præcis, hvad de skal gøre. Jeg ved, hvordan man kan løse dette."

67
00:03:58,000 --> 00:04:01,000
>> Hvis du ikke udskrive en besked, så du ender faktisk

68
00:04:01,000 --> 00:04:04,000
forlader brugeren til at gå undersøge din kildekode

69
00:04:04,000 --> 00:04:07,000
at finde ud af hvad der gik galt.

70
00:04:07,000 --> 00:04:11,000
Der er også nogle gange, at du skal bruge forskellige fejlkoder.

71
00:04:11,000 --> 00:04:14,000
Her har vi bare brugt en til at sige, at der var en fejl,

72
00:04:14,000 --> 00:04:16,000
der opstod en fejl, der opstod en fejl.

73
00:04:16,000 --> 00:04:20,000
Større programmer, ofte programmer, der kaldes af andre programmer,

74
00:04:20,000 --> 00:04:25,000
vil returnere en slags specielle fejlkoder i forskellige scenarier

75
00:04:25,000 --> 00:04:28,000
til programmering kommunikere hvad du ellers ville

76
00:04:28,000 --> 00:04:32,000
bare bruge en dejlig engelsk besked til.

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

78
00:04:35,000 --> 00:04:37,000
Når vi arbejder ned, kan du se, at vi trækker nøglen ud.

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

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

81
00:04:42,000 --> 00:04:46,000
Grunden til at vi gør det i dette do while løkke-og det er noget, vi vil dække

82
00:04:46,000 --> 00:04:50,000
i en lille smule-men det viser sig, at hvis du skriver kontrol D

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

84
00:04:54,000 --> 00:04:59,000
hvad det egentlig gør, er det sender et specialtegn

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

86
00:05:01,000 --> 00:05:05,000
Det hedder ELF eller slutningen af ​​filen karakter.

87
00:05:05,000 --> 00:05:08,000
Og i så fald, vil vores budskab strengen være null,

88
00:05:08,000 --> 00:05:14,000
så dette var ikke noget, vi kontrolleres for i opgaven sat sig.

89
00:05:14,000 --> 00:05:17,000
>> Men da vi går videre, nu hvor vi er begyndt at tale om pointers

90
00:05:17,000 --> 00:05:21,000
og dynamisk allokering af hukommelse på heapen,

91
00:05:21,000 --> 00:05:25,000
kontrol af null, når du har en funktion, der kunne

92
00:05:25,000 --> 00:05:30,000
returnere null som en værdi er noget, du ønsker at få for vane at gøre.

93
00:05:30,000 --> 00:05:33,000
Det er her primært til illustration.

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

95
00:05:36,000 --> 00:05:41,000
så fra Problem Set 4 om, vil du ønsker at holde dette i tankerne.

96
00:05:41,000 --> 00:05:44,000
Igen, dette er ikke et problem for Problem Set 3 enten fordi vi ikke havde dækket det endnu.

97
00:05:44,000 --> 00:05:53,000
Endelig vil vi komme til denne del, hvor vi komme til den vigtigste krypterings loop,

98
00:05:53,000 --> 00:05:57,000
og der er et par ting der foregår her.

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

100
00:06:02,000 --> 00:06:07,000
Her har vi holdt strlen opkald i den stand,

101
00:06:07,000 --> 00:06:12,000
som nogle af Dem har påpeget, er ikke en god vej at gå.

102
00:06:12,000 --> 00:06:15,000
Det viser sig i dette tilfælde er det heller ikke stor,

103
00:06:15,000 --> 00:06:20,000
dels fordi vi ændre indholdet af selve meddelelsen

104
00:06:20,000 --> 00:06:27,000
inde i for-løkken, så hvis vi har et budskab, der er 10 tegn lang,

105
00:06:27,000 --> 00:06:32,000
første gang vi starter at for-løkke strlen vil vende tilbage hvad?

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

107
00:06:35,000 --> 00:06:40,000
>> Men hvis vi så ændre budskab, siger vi ændre sin 5 karakter,

108
00:06:40,000 --> 00:06:46,000
og vi smider i et \ 0 tegn i 5. position,

109
00:06:46,000 --> 00:06:49,000
på en efterfølgende iteration strlen (message) returnerer ikke hvad den gjorde

110
00:06:49,000 --> 00:06:52,000
den allerførste gang, vi gentog,

111
00:06:52,000 --> 00:06:56,000
men det vil i stedet returnere 5, fordi vi kastede i det null terminator,

112
00:06:56,000 --> 00:06:59,000
og strengens længde er defineret

113
00:06:59,000 --> 00:07:03,000
ved placeringen af ​​det \ 0.

114
00:07:03,000 --> 00:07:09,000
I dette tilfælde er det en fantastisk måde at gå, fordi vi ændre det på plads.

115
00:07:09,000 --> 00:07:13,000
Men du opdager, at dette er faktisk overraskende nemt at kryptere

116
00:07:13,000 --> 00:07:16,000
hvis du kan få det math korrekte.

117
00:07:16,000 --> 00:07:19,000
Det eneste, der kræves, er at kontrollere, om det brev, som du kigger på

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

119
00:07:21,000 --> 00:07:24,000
>> Grunden til at vi kun nødt til at tjekke for det, og vi behøver ikke at tjekke for

120
00:07:24,000 --> 00:07:27,000
det er alpha tilfældet er,

121
00:07:27,000 --> 00:07:30,000
hvis en karakter er store eller hvis det er små

122
00:07:30,000 --> 00:07:33,000
så er det absolut et bogstav,

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

124
00:07:38,000 --> 00:07:41,000
Den anden ting, vi gør-og det er lidt tricky,

125
00:07:41,000 --> 00:07:45,000
er vi har ændret standard Cæsar cipher formel

126
00:07:45,000 --> 00:07:49,000
at vi gav i problemet indstillede specifikation.

127
00:07:49,000 --> 00:07:52,000
Hvad er anderledes her er, at vi fratrækkes

128
00:07:52,000 --> 00:07:58,000
i det store sag kapital A, og så har vi tilføjet kapital A

129
00:07:58,000 --> 00:08:02,000
tilbage i slutningen.

130
00:08:02,000 --> 00:08:05,000
>> Jeg kender et par af jer har gjort dette i din kode.

131
00:08:05,000 --> 00:08:09,000
Har nogen af ​​jer gøre dette i dit indlæg?

132
00:08:09,000 --> 00:08:13,000
Du gjorde det. Kan du forklare, hvad dette betyder, Sahb?

133
00:08:13,000 --> 00:08:18,000
Ved at trække det ud, fordi du gjorde en mod lige efter det,

134
00:08:18,000 --> 00:08:21,000
du nødt til at tage det ud, så på den måde får du [hoste] position.

135
00:08:21,000 --> 00:08:25,000
Og så ved at tilføje det igen senere du skiftet over den, du ønskede.

136
00:08:25,000 --> 00:08:27,000
Ja, præcis.

137
00:08:27,000 --> 00:08:32,000
Hvad Sahb sagde, var, at når vi ønsker at tilføje

138
00:08:32,000 --> 00:08:36,000
vores budskab og vores nøgle sammen

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

140
00:08:42,000 --> 00:08:50,000
hvis vi ikke skalere vores budskab i den passende 0 til 25 rækkevidde først,

141
00:08:50,000 --> 00:08:54,000
så vi kan ende med at få en virkelig underlig nummer

142
00:08:54,000 --> 00:08:59,000
fordi de værdier, vi kigger på når vi ser på besked [i],

143
00:08:59,000 --> 00:09:03,000
når vi ser på den i'te karakter af vores almindelig SMS-besked,

144
00:09:03,000 --> 00:09:08,000
er en værdi et eller andet sted i dette 65-122 interval

145
00:09:08,000 --> 00:09:13,000
baseret på de ASCII værdier for store bogstaver A gennem små z.

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

147
00:09:18,000 --> 00:09:23,000
da det var vores # define øverst til højre op her,

148
00:09:23,000 --> 00:09:28,000
der kommer til at give os en værdi, der er i 0 til 25 rækkevidde,

149
00:09:28,000 --> 00:09:30,000
og vi har brug for en måde at derefter skalere den tilbage op

150
00:09:30,000 --> 00:09:32,000
og få det i den relevante ASCII rækkevidde.

151
00:09:32,000 --> 00:09:36,000
Den nemmeste måde at gøre det er at bare skalere alting ned

152
00:09:36,000 --> 00:09:39,000
i 0-25 interval til at begynde med,

153
00:09:39,000 --> 00:09:43,000
og derefter flytte alt tilbage op i slutningen.

154
00:09:43,000 --> 00:09:46,000
>> En anden almindelig fejl, at jeg så folk løber ind i, er, at

155
00:09:46,000 --> 00:09:50,000
hvis du ikke rent faktisk gør dette skalering med det samme

156
00:09:50,000 --> 00:09:53,000
og du tilføjer besked og tast sammen, og du tilføjer dem, siger,

157
00:09:53,000 --> 00:09:58,000
i en char variabel, problem med at

158
00:09:58,000 --> 00:10:01,000
er da budskab [i] er et relativt stort antal til at begynde med,

159
00:10:01,000 --> 00:10:05,000
husk det er mindst 65, hvis det er et stort bogstav-

160
00:10:05,000 --> 00:10:09,000
hvis du har en stor nøgle, siger, noget i retning af 100,

161
00:10:09,000 --> 00:10:13,000
og du tilføje dem 2 sammen ind i en underskrevet char du kommer til at få et overløb.

162
00:10:13,000 --> 00:10:17,000
Du kommer til at få en værdi, der er større end 127,

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

164
00:10:22,000 --> 00:10:26,000
Igen, det er derfor du gerne vil gøre den slags ting til at begynde med.

165
00:10:26,000 --> 00:10:29,000
Nogle mennesker fik omkring denne sag ved at gøre en hvis ellers og afprøvning

166
00:10:29,000 --> 00:10:33,000
at se, om det ville overflow før du gør det,

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

168
00:10:36,000 --> 00:10:40,000
Og så i denne opløsning vi udskrevet hele strengen til allersidst.

169
00:10:40,000 --> 00:10:45,000
Andre mennesker udskrives et tegn ad gangen. Begge er awesome.

170
00:10:45,000 --> 00:10:51,000
På dette tidspunkt, har du fyre har spørgsmål, bemærkninger om dette?

171
00:10:51,000 --> 00:10:56,000
Ting du gerne, ting du ikke kan lide?

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

173
00:10:58,000 --> 00:11:01,000
Måske jeg savnede det under din forklaring, men hvordan fungerer dette program

174
00:11:01,000 --> 00:11:07,000
springe rum til tilslutning af nøglen til længden af ​​teksten?

175
00:11:07,000 --> 00:11:10,000
Dette er blot Cæsar cipher. >> Åh, undskyld, ja.

176
00:11:10,000 --> 00:11:13,000
Ja, det vil vi se, at.

177
00:11:13,000 --> 00:11:16,000
I Caesar cipher vi fik omkring, at fordi

178
00:11:16,000 --> 00:11:18,000
vi kun vendt tegn.

179
00:11:18,000 --> 00:11:27,000
Vi kun drejet dem, hvis de var store eller små bogstaver.

180
00:11:27,000 --> 00:11:32,000
Du fyre følelse temmelig godt om dette?

181
00:11:32,000 --> 00:11:34,000
Du er velkommen til at kopiere dette hjem, tage det,

182
00:11:34,000 --> 00:11:37,000
sammenligne det med hvad du fyre skrev.

183
00:11:37,000 --> 00:11:42,000
Absolut velkommen til at sende spørgsmål om det også.

184
00:11:42,000 --> 00:11:46,000
Og igen, indse, at målet her med dit problem sætter

185
00:11:46,000 --> 00:11:50,000
er ikke at få jer til at skrive perfekt kode til dit problem sæt.

186
00:11:50,000 --> 00:11:57,000
Det er en lærerig oplevelse. Yeah.

187
00:11:57,000 --> 00:12:01,000
>> Tilbage til do while-løkken, hvis det er lig nul,

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

189
00:12:06,000 --> 00:12:12,000
Null er en særlig pointerværdi,

190
00:12:12,000 --> 00:12:17,000
og vi bruger null, når vi ønsker at sige

191
00:12:17,000 --> 00:12:23,000
vi har en pointer variabel, der peger på noget.

192
00:12:23,000 --> 00:12:28,000
Og så typisk betyder det, at denne variabel, denne besked variabel

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

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

195
00:12:37,000 --> 00:12:42,000
Har du set, hvad det er, når David trukket tilbage hætten i foredraget?

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

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

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

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

200
00:12:56,000 --> 00:13:04,000
og så GetString funktion, hvis det ikke lykkes at en snor fra brugeren,

201
00:13:04,000 --> 00:13:08,000
det kan ikke parse en streng, og det ene tilfælde, hvor det ikke kan parse en streng

202
00:13:08,000 --> 00:13:11,000
er, hvis brugeren skriver i slutningen af ​​filen karakter, kontrol D,

203
00:13:11,000 --> 00:13:17,000
der er ikke noget man typisk gør, men hvis det sker

204
00:13:17,000 --> 00:13:20,000
så funktionen vil returnere dette null værdi som en måde at sige

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

206
00:13:23,000 --> 00:13:27,000
Hvad ville der ske, hvis vi ikke sætter besked = null,

207
00:13:27,000 --> 00:13:30,000
hvilket er noget, vi ikke har gjort endnu?

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

209
00:13:32,000 --> 00:13:38,000
Fordi jeg ved, at vi snakkede lidt i foredrag om memory leaks.

210
00:13:38,000 --> 00:13:42,000
Ja, lad os gøre det, og lad os se hvad der sker.

211
00:13:42,000 --> 00:13:44,000
>> Basil spørgsmål var, hvad der sker, hvis vi faktisk ikke har

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

213
00:13:48,000 --> 00:13:51,000
Lad os rulle op til toppen.

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

215
00:13:53,000 --> 00:13:55,000
Faktisk vil jeg gemme det i en revision.

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

217
00:13:58,000 --> 00:14:02,000
Hvad du nødt til at gøre for at køre dette program er du nødt til at klikke på dette gear ikon op her,

218
00:14:02,000 --> 00:14:04,000
og du bliver nødt til at tilføje et argument til det.

219
00:14:04,000 --> 00:14:10,000
Du bliver nødt til at give det afgørende argument, da vi ønsker at passere i en kommandolinje argument.

220
00:14:10,000 --> 00:14:13,000
Her vil jeg har tænkt mig at give det et nummer 3. Jeg kan godt lide 3.

221
00:14:13,000 --> 00:14:19,000
Nu zoomer ud igen, kører programmet.

222
00:14:19,000 --> 00:14:24,000
Det kører, kompilering, bygning.

223
00:14:24,000 --> 00:14:27,000
Her går vi. Det venter på at blive spurgt.

224
00:14:27,000 --> 00:14:33,000
Hvis jeg skriver i noget lignende hello-hvor gik det?

225
00:14:33,000 --> 00:14:38,000
Åh, mit program tog for lang tid at køre. Jeg var jawing for længe.

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

227
00:14:40,000 --> 00:14:43,000
Nu skriver jeg i hej.

228
00:14:43,000 --> 00:14:46,000
Vi ser, at den krypterer korrekt.

229
00:14:46,000 --> 00:14:52,000
Nu, hvad der sker, hvis vi ikke gør hurtig GetString at returnere null?

230
00:14:52,000 --> 00:14:57,000
Husk, jeg sagde, at vi gjorde det ved at trykke på kontrol D på samme tid.

231
00:14:57,000 --> 00:14:59,000
Jeg rulle op her. Vi vil køre det igen.

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

233
00:15:01,000 --> 00:15:04,000
Nu når jeg ramte kontrol D

234
00:15:04,000 --> 00:15:12,000
Jeg fik denne linje, der siger opt/sandbox50/bin/run.sh, Segmentation fault.

235
00:15:12,000 --> 00:15:15,000
Har du fyre set det før?

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

237
00:15:17,000 --> 00:15:20,000
[Student] Hvorfor er der ingen kerne-dump i dette tilfælde?

238
00:15:20,000 --> 00:15:26,000
Kernen dump er-spørgsmålet er, hvorfor er der ingen kerne-dump her?

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

240
00:15:29,000 --> 00:15:31,000
der bliver gemt på harddisken.

241
00:15:31,000 --> 00:15:34,000
I dette tilfælde har vi deaktiveret kerne lossepladser

242
00:15:34,000 --> 00:15:37,000
på flugt serveren, så vi ikke har folk seg fejlagtigt

243
00:15:37,000 --> 00:15:40,000
og opbygge tonsvis af centrale lossepladser.

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

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

246
00:15:48,000 --> 00:15:52,000
og nogle gange du gør.

247
00:15:52,000 --> 00:15:55,000
Den segmentering fejl, at besvare dit spørgsmål, Basil,

248
00:15:55,000 --> 00:16:00,000
siger, at vi har forsøgt at få adgang til en pegepind

249
00:16:00,000 --> 00:16:05,000
der var ikke sat til at pege på noget som helst.

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

251
00:16:09,000 --> 00:16:12,000
gå adgang til en pointer, der er ikke peger på noget?

252
00:16:12,000 --> 00:16:16,000
I dette tilfælde vil jeg gætte teknisk markøren peger på noget.

253
00:16:16,000 --> 00:16:20,000
Det peger på null, der er teknisk 0,

254
00:16:20,000 --> 00:16:25,000
men der er defineret til at være i et segment, som ikke er tilgængelige

255
00:16:25,000 --> 00:16:28,000
af dit program, så du får en segmenteringsfejl

256
00:16:28,000 --> 00:16:31,000
fordi du ikke får adgang til hukommelse, der er i en gyldig segment

257
00:16:31,000 --> 00:16:38,000
som dyngen segment eller stakken segment eller datasegment.

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

259
00:16:40,000 --> 00:16:48,000
Har du flere spørgsmål om Caesar?

260
00:16:48,000 --> 00:16:51,000
>> Lad os komme videre. Lad os se på Revision 2 virkelig hurtigt.

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
vil vi gå gennem denne ene temmelig hurtigt, fordi, igen,

264
00:17:06,000 --> 00:17:10,000
Vigenère og Cæsar er temmelig ens.

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 at undgå at bruge disse magiske tal.

267
00:17:17,000 --> 00:17:21,000
Det gode er at sige vi ønskede at flytte til

268
00:17:21,000 --> 00:17:23,000
et andet alfabet eller noget lignende.

269
00:17:23,000 --> 00:17:26,000
Snarere end at skulle gå manuelt ændre alle 26 er i koden

270
00:17:26,000 --> 00:17:30,000
vi kunne ændre dette til 27 eller drop det ned

271
00:17:30,000 --> 00:17:34,000
hvis vi bruger forskellige alfabeter, forskellige sprog.

272
00:17:34,000 --> 00:17:38,000
Igen har vi denne kontrol af argumentet tæller,

273
00:17:38,000 --> 00:17:42,000
og virkelig du kan næsten tage dette som en skabelon.

274
00:17:42,000 --> 00:17:46,000
Stort set alle program, du skriver bør have-

275
00:17:46,000 --> 00:17:50,000
hvis det tager kommandolinjeargumenter-nogle sekvens af linjer

276
00:17:50,000 --> 00:17:55,000
, der lyder sådan her i begyndelsen.

277
00:17:55,000 --> 00:17:59,000
Det er en af ​​de første tilregnelighed test, du vil gøre.

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

279
00:18:03,000 --> 00:18:06,000
søgeordet var gyldig, og det var den anden kontrol, som vi gjorde.

280
00:18:06,000 --> 00:18:11,000
Bemærk igen, at vi adskilt denne fra argc og 2.

281
00:18:11,000 --> 00:18:14,000
Bemærk, at i dette tilfælde én ting, vi skulle gøre, var i stedet

282
00:18:14,000 --> 00:18:18,000
for at bruge en til jeg vi ønskede at validere hele strengen,

283
00:18:18,000 --> 00:18:21,000
og for at gøre, at du rent faktisk nødt til at gå tegn for tegn

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

285
00:18:23,000 --> 00:18:29,000
Der er ingen god måde at kalde noget om det

286
00:18:29,000 --> 00:18:31,000
fordi selv, for eksempel A til I returnerer 0

287
00:18:31,000 --> 00:18:37,000
hvis det ikke kan parse et heltal, så der ikke engang virker.

288
00:18:37,000 --> 00:18:42,000
Igen, nice meddelelse til brugeren præcis hvad der skete.

289
00:18:42,000 --> 00:18:45,000
Så her, igen, vi også håndtere de tilfælde, hvor

290
00:18:45,000 --> 00:18:50,000
brugeren skriver i en kontrolgruppe D tilfældig karakter.

291
00:18:50,000 --> 00:18:54,000
>> Og så Charlotte havde et spørgsmål tidligere om, hvordan vi formår at springe rum

292
00:18:54,000 --> 00:18:57,000
i vores streng her.

293
00:18:57,000 --> 00:19:00,000
Det var slags svarer til, hvad vi gjorde med Myspace program

294
00:19:00,000 --> 00:19:04,000
at vi gjorde i snit, og den måde det fungerede

295
00:19:04,000 --> 00:19:08,000
er, at vi sporede antallet af bogstaver, som vi havde set.

296
00:19:08,000 --> 00:19:13,000
Da vi gik over den besked streng, da vi gik over tegn for tegn,

297
00:19:13,000 --> 00:19:16,000
Vi sporede indekset som del af vores for-løkke, og så har vi også spores

298
00:19:16,000 --> 00:19:21,000
antallet af bogstaver, så ikke-specialtegn, ikke-tal, ikke-blanktegn

299
00:19:21,000 --> 00:19:27,000
at vi havde set i den separat variabel.

300
00:19:27,000 --> 00:19:33,000
Og så denne løsning ændrer nøglen

301
00:19:33,000 --> 00:19:41,000
at få en nøgle tal, og det gør, at der på den flue,

302
00:19:41,000 --> 00:19:47,000
lige før det går så til at kryptere selve budskabet karakter.

303
00:19:47,000 --> 00:19:50,000
Der er nogle løsninger, der var helt store også

304
00:19:50,000 --> 00:19:58,000
der ville ændre nøglen op ved test for knappens gyldighed.

305
00:19:58,000 --> 00:20:01,000
Ud over at sørge for, at tegnet og søgeordet

306
00:20:01,000 --> 00:20:05,000
blev et bogstav det også slået det ind i et heltal

307
00:20:05,000 --> 00:20:13,000
i 0 til 25 sortimentet derefter springe skulle gøre det senere i denne for-løkke.

308
00:20:13,000 --> 00:20:18,000
Igen, du ser her er det virkelig den nøjagtig samme kode

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

310
00:20:22,000 --> 00:20:25,000
Du gør præcis de samme ting, så det virkelige trick er at finde ud

311
00:20:25,000 --> 00:20:30,000
hvordan man kan slå søgeordet i et heltal.

312
00:20:30,000 --> 00:20:35,000
>> En ting, som vi gjorde her, er en lille tæt

313
00:20:35,000 --> 00:20:39,000
er vi gentaget denne sætning, jeg gætte, du kan kalde det,

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

315
00:20:45,000 --> 00:20:52,000
Kan nogen forklare, hvad der præcist denne sætning betyder?

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

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

318
00:20:59,000 --> 00:21:04,000
og så det er antallet af sete bogstaver, fordi du kun bevæger sig langs

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

320
00:21:06,000 --> 00:21:10,000
så der kommer til at effektivt at springe rum og den slags.

321
00:21:10,000 --> 00:21:12,000
Ja, præcis.

322
00:21:12,000 --> 00:21:16,000
Og så når du har set søgeordet blank du bare mod, så du flytter tilbage omkring.

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

324
00:21:18,000 --> 00:21:23,000
Hvad Kevin sige er, at vi ønsker at indekset i søgeordet.

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

326
00:21:28,000 --> 00:21:32,000
men hvis num_letters_seen overskrider længden af ​​søgeordet,

327
00:21:32,000 --> 00:21:37,000
den måde, vi kommer tilbage til det passende område er vi bruge mod operatøren

328
00:21:37,000 --> 00:21:40,000
til effektivt at ombryde omkring.

329
00:21:40,000 --> 00:21:43,000
For eksempel, som på kort vores søgeord er bacon,

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

331
00:21:46,000 --> 00:21:50,000
Men vi har set 6 bogstaver i vores klartekst på dette punkt

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

333
00:21:52,000 --> 00:21:57,000
Vi vil ende med at få adgang til num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
som er 6, mod længden af ​​nøgleord, 5,

335
00:22:00,000 --> 00:22:04,000
og så vil vi få 1, og så hvad vi vil gøre, er at vi får

336
00:22:04,000 --> 00:22:14,000
åbne det første tegn indersiden af ​​vores nøgleord ved dette punkt.

337
00:22:14,000 --> 00:22:21,000
>> Okay, eventuelle spørgsmå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
Du fyre følelse temmelig godt om dette?

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

341
00:22:35,000 --> 00:22:38,000
Jeg vil være sikker på, at du fyre får chancen for at se koden

342
00:22:38,000 --> 00:22:48,000
at vi synes ser godt og har chancen for at lære af det.

343
00:22:48,000 --> 00:22:53,000
Dette vil være det sidste, vi kommer til at bruge mellemrum for tiden,

344
00:22:53,000 --> 00:22:59,000
og vi vil overgangen nu, og jeg har tænkt mig at gå til cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
så vi kan gøre en lille smule af quiz gennemgang.

346
00:23:06,000 --> 00:23:10,000
Den bedste måde jeg tror at begynde at gøre quiz anmeldelse

347
00:23:10,000 --> 00:23:15,000
er at komme til denne Forelæsninger side, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
og under hver af de uger overskrifter, så hvis jeg ser her i uge 0,

349
00:23:20,000 --> 00:23:27,000
Jeg kan se, at vi har en liste over emner, som vi dækket i uge 0.

350
00:23:27,000 --> 00:23:31,000
>> Hvis nogen af ​​disse emner synes ukendte for dig

351
00:23:31,000 --> 00:23:34,000
du vil helt sikkert ønsker at gå tilbage og gennemsøge forelæsningsnoter og eventuelt

352
00:23:34,000 --> 00:23:39,000
selv skimme gennem foredrag, se dem igen, hvis du ønsker

353
00:23:39,000 --> 00:23:44,000
at få en fornemmelse for, hvad der sker med hver enkelt af disse emner.

354
00:23:44,000 --> 00:23:49,000
Jeg vil sige yderligere i år en af ​​de seje ressourcer, vi har fået

355
00:23:49,000 --> 00:23:55,000
er disse shorts, som vi har oprettet, og hvis man ser på uge 0,

356
00:23:55,000 --> 00:24:00,000
vi har ikke alle, der er omfattet af de emner, men vi har fået en hel del af dem,

357
00:24:00,000 --> 00:24:03,000
nogle af de mere vanskelige dem, så ser disse shorts igen

358
00:24:03,000 --> 00:24:08,000
er en god måde at få dig op i fart.

359
00:24:08,000 --> 00:24:15,000
I særdeleshed vil jeg sætte i en plug til 3 på bunden, da jeg gjorde dem.

360
00:24:15,000 --> 00:24:20,000
Men hvis du kæmper med binær, bits, hex, den slags ting,

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

362
00:24:22,000 --> 00:24:25,000
ASCII er en anden en, der er god til at se også.

363
00:24:25,000 --> 00:24:31,000
Du kan endda se mig på 1,5 x hastighed, hvis jeg går for langsomt for dig.

364
00:24:31,000 --> 00:24:35,000
Da det er gennemgang, er du velkommen til at gøre det.

365
00:24:35,000 --> 00:24:40,000
>> Blot for at starte virkelig hurtigt, vi kommer til at gå igennem et par af disse quiz problemer

366
00:24:40,000 --> 00:24:44,000
lige hurtigt churn gennem disse.

367
00:24:44,000 --> 00:24:50,000
For eksempel, lad os se på problemet 16, at jeg har lige her oppe på tavlen.

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

369
00:24:54,000 --> 00:24:56,000
og vi ønsker at vise noget arbejde.

370
00:24:56,000 --> 00:24:59,000
Okay, jeg vil give denne et skud.

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

372
00:25:01,000 --> 00:25:04,000
og vi vil gøre det virkelig hurtigt.

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

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

375
00:25:16,000 --> 00:25:27,000
Og jeg har tænkt mig at tilføje til det 00.110.010.

376
00:25:27,000 --> 00:25:30,000
For matematiske genier efter sammen derhjemme,

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

378
00:25:35,000 --> 00:25:37,000
Lad os starte.

379
00:25:37,000 --> 00:25:39,000
Vi kommer til at følge samme tilsætning algoritme, at vi gør

380
00:25:39,000 --> 00:25:43,000
når vi tilføjer decimaltal sammen.

381
00:25:43,000 --> 00:25:46,000
Virkelig den eneste forskel her er, at vi løkke tilbage omkring

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

383
00:25:51,000 --> 00:25:53,000
>> Hvis vi starter fra højre, virkelig hurtigt, hvad er det første ciffer?

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

385
00:25:55,000 --> 00:25:58,000
Store, det andet ciffer?

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?

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

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Præcis, så hvad er det ciffer, jeg skriver lige under de 2 dem lægges sammen?

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

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

392
00:26:15,000 --> 00:26:18,000
Næste en op, Basil, du er oppe.

393
00:26:18,000 --> 00:26:20,000
Hvad 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 hvad gø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 hvad skal jeg gøre? Og så kan jeg bære den 1.

399
00:26:34,000 --> 00:26:36,000
Perfekt, Sahb? >> [Sahb] Nu har du 1.

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

401
00:26:40,000 --> 00:26:43,000
[Sahb] Så for det næste du har 1, fordi du gennemførte over 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Godt, så her kan vi afslutte det op.

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 sagde, er 10 eller 1, 0, snarere.

407
00:27:01,000 --> 00:27:07,000
10 er en misvisende, fordi for mig 10 betyder tallet 10,

408
00:27:07,000 --> 00:27:12,000
og det er den ejendommelighed, hvordan vi repræsenterer det, når vi skriver det.

409
00:27:12,000 --> 00:27:20,000
Vi repræsenterer tallet 2 med 1, 0, og antallet 10 er en smule anderledes.

410
00:27:20,000 --> 00:27:23,000
>> Hvad er lidt rart, om binære er, at der virkelig er ikke så mange

411
00:27:23,000 --> 00:27:25,000
sager, du har brug for at lære.

412
00:27:25,000 --> 00:27:30,000
Der er 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 er 0, og så foretage et 1,

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

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

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

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

418
00:27:45,000 --> 00:27:48,000
Når du laver binær desuden ret simpelt.

419
00:27:48,000 --> 00:27:51,000
Jeg ville gøre et par mere af disse til tilregnelighed kontrollere jer selv

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

421
00:27:54,000 --> 00:28:00,000
sandsynligvis noget, som vi vil se på quizzen.

422
00:28:00,000 --> 00:28:03,000
Lad os nu gøre det næste en så godt.

423
00:28:03,000 --> 00:28:06,000
Lad os gøre problem 17.

424
00:28:06,000 --> 00:28:12,000
Vi kommer til at konvertere følgende binære tal til decimal.

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 gik gennem et par eksempler, og jeg viste, hvordan

428
00:28:36,000 --> 00:28:41,000
alt fungerer, når du laver det i decimal.

429
00:28:41,000 --> 00:28:45,000
Når du arbejder i decimal repræsentation jeg tror, ​​vi er

430
00:28:45,000 --> 00:28:48,000
på dette tidspunkt i vores liv, så flydende i det at

431
00:28:48,000 --> 00:28:53,000
det er ret nemt at tilsløre mekanik, hvordan det rent faktisk virker.

432
00:28:53,000 --> 00:28:59,000
>> Men for at gøre en hurtig opsummere, hvis jeg har det nummer 137

433
00:28:59,000 --> 00:29:06,000
det virkelig betyder-og igen, dette er i decimal repræsentation-

434
00:29:06,000 --> 00:29:19,000
nummeret 137 i decimal betyder, at jeg har 1 x 100 + 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
Dette er så opholder sig på skærmen.

436
00:29:22,000 --> 00:29:29,000
Og så hvis man ser på disse tal lige her,

437
00:29:29,000 --> 00:29:34,000
100, 10 og 1, kan du se, at de er faktisk alle potenser af 10.

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

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
bortset fra at vores base, som vi kalder det, er 2 i stedet for 10.

441
00:29:55,000 --> 00:29:58,000
Disse 10'erne, som jeg skrev ned her i bunden,

442
00:29:58,000 --> 00:30:02,000
denne 10 ², 10 ¹, 10 til nul, 10 er vores base,

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

444
00:30:08,000 --> 00:30:14,000
kan udledes af positionen af ​​det ciffer i det tal, vi skriver.

445
00:30:14,000 --> 00:30:21,000
1, hvis vi ser på det, denne 1 er i 2. position.

446
00:30:21,000 --> 00:30:27,000
The 3 er i 1. positionen, og 7 er i 0. Position.

447
00:30:27,000 --> 00:30:35,000
Det er, hvordan vi får de forskellige eksponenter nedenfor for vores baser.

448
00:30:35,000 --> 00:30:40,000
>> Efter alt dette we'll-faktisk, ved du hvad?

449
00:30:40,000 --> 00:30:43,000
Vi vil gøre, hvor har min fortryd knap hen?

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

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

452
00:30:47,000 --> 00:30:51,000
Efter denne jeg tror for mig i det mindste

453
00:30:51,000 --> 00:30:54,000
den nemmeste måde at begynde at konvertere et binært tal

454
00:30:54,000 --> 00:30:57,000
eller et hexadecimalt tal, hvor basen er 16

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

456
00:31:02,000 --> 00:31:09,000
grundlaget og eksponenter for alle numrene i mit binære tal øverst.

457
00:31:09,000 --> 00:31:14,000
Hvis vi starter fra venstre til højre igen,

458
00:31:14,000 --> 00:31:17,000
som er lidt ulogisk,

459
00:31:17,000 --> 00:31:23,000
Jeg skifter tilbage til sort her, vi har 2 til den 0:e position,

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

461
00:31:27,000 --> 00:31:33,000
og derefter 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 tal jeg har skrevet ud, er alle eksponenter.

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

465
00:31:48,000 --> 00:31:50,000
>> På dette punkt, jeg har tænkt mig at gå videre, og jeg faktisk kommer til at slette

466
00:31:50,000 --> 00:31:53,000
de ting, vi gjorde i decimal, hvis det er okay.

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

468
00:31:57,000 --> 00:32:05,000
De af jer, se online jeg er sikker på vil være i stand til at spole tilbage mig, hvis du har lyst.

469
00:32:05,000 --> 00:32:07,000
Skift tilbage til pennen.

470
00:32:07,000 --> 00:32:12,000
Nu, hvad vi kan gøre,-hvis du fyre ikke er helt op til hastighed på dine kræfter på 2,

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

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

473
00:32:18,000 --> 00:32:23,000
Jeg havde engang en jobsamtale, hvor jeg fik at vide, jeg skulle kende alle potenser af 2

474
00:32:23,000 --> 00:32:26,000
op gennem 2 til d.30.

475
00:32:26,000 --> 00:32:29,000
Det var ikke et job, jeg fik.

476
00:32:29,000 --> 00:32:32,000
Anyway, kan du fyre gå videre og gøre det math her,

477
00:32:32,000 --> 00:32:35,000
men med binær det ikke rigtig mening,

478
00:32:35,000 --> 00:32:38,000
og heller ikke mening med decimal eller hexadecimale enten,

479
00:32:38,000 --> 00:32:43,000
at gøre det math ud af, 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 mening at gøre det faktiske math

482
00:32:52,000 --> 00:32:56,000
til at beregne den relevante potens af 2 for denne holdning?

483
00:32:56,000 --> 00:32:59,000
Præcis ligesom Charlotte sagde, vil det være 0.

484
00:32:59,000 --> 00:33:05,000
Kan lige så godt spare dig tid, hvis beregningen potenser af 2 ikke er din stærke trop.

485
00:33:05,000 --> 00:33:10,000
I dette tilfælde behøver vi kun at beregne det for 2 til 0, hvilket 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 er ked af, 1.

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

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ået disse tal kan vi sammenfatte dem alle op.

500
00:33:57,000 --> 00:34:01,000
Og det er her, det er virkelig vigtigt at gøre et par ting.

501
00:34:01,000 --> 00:34:07,000
Den ene er at gå langsomt og tjek dit arbejde.

502
00:34:07,000 --> 00:34:10,000
Du kan fortælle, at der er en 1 i slutningen af ​​dette nummer,

503
00:34:10,000 --> 00:34:15,000
så jeg burde helt sikkert få et ulige antal som mit resultat,

504
00:34:15,000 --> 00:34:18,000
fordi alle de andre dem vil være lige numre

505
00:34:18,000 --> 00:34:21,000
da det er et binært tal.

506
00:34:21,000 --> 00:34:24,000
Den anden ting at gøre, er, hvis du kommer til dette punkt på prøve

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

508
00:34:27,000 --> 00:34:30,000
og du kører ud af tid

509
00:34:30,000 --> 00:34:33,000
se på det antal point, at dette problem er værd.

510
00:34:33,000 --> 00:34:40,000
Dette problem, som du kan se, hvis jeg vende tilbage til min laptop virkelig hurtigt-

511
00:34:40,000 --> 00:34:44,000
dette problem er værd 2 point, så dette er ikke den form for tilsætning

512
00:34:44,000 --> 00:34:47,000
du skal gå igennem, hvis du virkelig er presset på for tiden.

513
00:34:47,000 --> 00:34:52,000
Men vi vil skifte tilbage til iPad, og vi vil gå igennem det virkelig hurtigt.

514
00:34:52,000 --> 00:34:54,000
>> Jeg kan godt lide at gøre de små tal 1:e

515
00:34:54,000 --> 00:34:56,000
fordi jeg synes, at lettere.

516
00:34:56,000 --> 00:35:00,000
Jeg kan godt lide 32 og 8, fordi de går sammen temmelig let, og vi får 50.

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

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

519
00:35:05,000 --> 00:35:14,000
og så kan vi gøre resten af ​​dette, så vi kan gøre 57, 156.

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

521
00:35:16,000 --> 00:35:19,000
Mand, ja, lad os se.

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

523
00:35:27,000 --> 00:35:31,000
På dette tidspunkt ville jeg hellere bare gå igennem.

524
00:35:31,000 --> 00:35:35,000
Jeg har ingen anelse. Jeg har helt klart brug for at læse op 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
Derefter får vi 3, og så får vi 1.

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

529
00:35:52,000 --> 00:35:55,000
Påske æg, nogen?

530
00:35:55,000 --> 00:35:59,000
Nogen genkende dette nummer?

531
00:35:59,000 --> 00:36:02,000
Chris genkender nummeret. Hvad betyder 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å det, det ligner leet.

534
00:36:11,000 --> 00:36:15,000
Hacker stuff. Hold øje med den slags ting om midtvejsrevisionen eller quiz, snarere.

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

536
00:36:19,000 --> 00:36:22,000
, som rent faktisk betyder noget.

537
00:36:22,000 --> 00:36:24,000
Det ved jeg ikke. David kan godt lide at sætte det i.

538
00:36:24,000 --> 00:36:26,000
Det er en god måde at tilregnelighed kontrollere det.

539
00:36:26,000 --> 00:36:30,000
Ligesom okay, kan jeg se, hvad der foregår.

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

541
00:36:34,000 --> 00:36:39,000
Hvis vi skifter tilbage til vores bærbare nu,

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

543
00:36:46,000 --> 00:36:50,000
Der er ASCII, som vi har gjort en masse af med problemet sæt.

544
00:36:50,000 --> 00:36:55,000
Denne opfattelse af kapital A. Hvad er det egentlig?

545
00:36:55,000 --> 00:36:57,000
Vel vidende at det er den decimale heltal.

546
00:36:57,000 --> 00:37:00,000
65 er hvad det er kortlagt i ASCII-tabellen,

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

548
00:37:03,000 --> 00:37:06,000
og det er, hvordan vi har været at få væk med rent faktisk at skrive

549
00:37:06,000 --> 00:37:09,000
tegnet kapital A og karakteren små bogstaver en

550
00:37:09,000 --> 00:37:14,000
i nogle af disse løsninger og problematiske sæt, 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 udsagn, boolske udtryk, betingelser, løkker, variabler og tråde.

553
00:37:25,000 --> 00:37:29,000
>> De, der alle synes at give mening for det meste?

554
00:37:29,000 --> 00:37:35,000
Noget af denne terminologi er lidt funky til tider.

555
00:37:35,000 --> 00:37:46,000
Jeg kan godt lide at tænke på en erklæring, som for det meste noget, der slutter med et semikolon.

556
00:37:46,000 --> 00:37:51,000
Udtalelser såsom x = 7, som fastsætter en variabel,

557
00:37:51,000 --> 00:37:54,000
formentlig kaldet x = 7.

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

559
00:38:01,000 --> 00:38:05,000
så det er en int eller eventuelt en float eller en kort eller en char,

560
00:38:05,000 --> 00:38:07,000
noget lignende.

561
00:38:07,000 --> 00:38:12,000
En boolean udtryk bruger disse dobbelt lig

562
00:38:12,000 --> 00:38:17,000
og bang lig eller ikke lig med, mindre end, større end,

563
00:38:17,000 --> 00:38:22,000
mindre end eller lig med, al den slags ting.

564
00:38:22,000 --> 00:38:28,000
Forhold så er om Else udsagn.

565
00:38:28,000 --> 00:38:32,000
Jeg vil huske, at du ikke kan have en anden uden en tilsvarende hvis.

566
00:38:32,000 --> 00:38:37,000
Ligeledes kan du ikke have en andet, hvis uden en tilsvarende hvis.

567
00:38:37,000 --> 00:38:40,000
Loops, minde om de 3 slags løkker vi har hamring ind i dig

568
00:38:40,000 --> 00:38:43,000
for de sidste par afsnit og problemstillinger sæt.

569
00:38:43,000 --> 00:38:46,000
Der må mens når du får input fra brugeren,

570
00:38:46,000 --> 00:38:51,000
ved hjælp mens løkker, indtil en bestemt betingelse er sand,

571
00:38:51,000 --> 00:38:56,000
og derefter bruge dem, for sløjfer, hvis du skal

572
00:38:56,000 --> 00:39:01,000
vide, hvilken iteration af løkken, du er i øjeblikket på, er, hvordan jeg tænker over det.

573
00:39:01,000 --> 00:39:07,000
Eller hvis du laver en for hvert tegn i en streng jeg ønsker at gøre noget,

574
00:39:07,000 --> 00:39:15,000
for hvert element i et array jeg ønsker at gøre noget for dette element.

575
00:39:15,000 --> 00:39:18,000
>> Tråde og arrangementer.

576
00:39:18,000 --> 00:39:21,000
Disse har vi ikke dækket så eksplicit i C,

577
00:39:21,000 --> 00:39:23,000
men huske dette fra Scratch.

578
00:39:23,000 --> 00:39:26,000
Det er forestillingen om at have forskellige scripts.

579
00:39:26,000 --> 00:39:32,000
Dette er også denne forestilling om udsendelse af en begivenhed.

580
00:39:32,000 --> 00:39:37,000
Nogle mennesker har ikke brug udsendelse i deres projekter i første omgang,

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

582
00:39:40,000 --> 00:39:46,000
men disse er 2 forskellige måder at håndtere denne større problem kaldet concurrency,

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

584
00:39:49,000 --> 00:39:54,000
eller tilsyneladende udføre på samme tid?

585
00:39:54,000 --> 00:39:59,000
Forskellige opgaver kører, mens andre opgaver også kører.

586
00:39:59,000 --> 00:40:01,000
Dette er, hvordan dit operativsystem synes at virke.

587
00:40:01,000 --> 00:40:04,000
Det er derfor, selv om, for eksempel,

588
00:40:04,000 --> 00:40:10,000
Jeg har fået min browser kører, kan jeg også tænde Spotify og spille en sang.

589
00:40:10,000 --> 00:40:14,000
Det er mere en begrebsmæssig ting at forstå.

590
00:40:14,000 --> 00:40:17,000
Jeg ville tage et kig på trådene korte

591
00:40:17,000 --> 00:40:21,000
Hvis du gerne vil vide mere om det.

592
00:40:21,000 --> 00:40:26,000
>> Lad os se, jeg tror, ​​at der kunne have været

593
00:40:26,000 --> 00:40:31,000
et problem på denne i en af ​​disse.

594
00:40:31,000 --> 00:40:35,000
Igen, jeg tror tråde og begivenheder er ikke noget, vi vil dække i C

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

596
00:40:41,000 --> 00:40:44,000
Du bør ikke bekymre dig om det der, men absolut forstå de begreber,

597
00:40:44,000 --> 00:40:47,000
forstå, hvad der foregår.

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

599
00:40:52,000 --> 00:40:55,000
Alle følelse temmelig god?

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

601
00:41:03,000 --> 00:41:08,000
>> Flytning af. Uge 1.

602
00:41:08,000 --> 00:41:12,000
Et par ting her, som ikke var særligt dækkede

603
00:41:12,000 --> 00:41:21,000
i quizzen gennemgang nødvendigvis og også er mere konceptuelle ting at tænke på.

604
00:41:21,000 --> 00:41:30,000
Den første er denne opfattelse af, hvad kildekode, compilere og objekt kode er.

605
00:41:30,000 --> 00:41:32,000
Nogen? Basil.

606
00:41:32,000 --> 00:41:37,000
Er objekt code-jeg mener kildekode er hvad du putter i Klang,

607
00:41:37,000 --> 00:41:42,000
og objekt kode er, hvad klang lægger ud, så din computer kan læse programmet.

608
00:41:42,000 --> 00:41:44,000
Præcis.

609
00:41:44,000 --> 00:41:47,000
Kildekode er den C-kode, som du faktisk skrive op.

610
00:41:47,000 --> 00:41:50,000
Objektkode er hvad du får ud af klang.

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

612
00:41:54,000 --> 00:41:59,000
Så hvad der sker, er, når du har en masse objekt filer,

613
00:41:59,000 --> 00:42:04,000
siger du kompilerer et projekt eller et program, der bruger flere kildekodefiler,

614
00:42:04,000 --> 00:42:09,000
som efter sædvane får. c. filtypenavnet.

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 giver dem forlængelsen. Java.

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

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

619
00:42:26,000 --> 00:42:29,000
Klang spytter alt dette binære junk.

620
00:42:29,000 --> 00:42:33,000
Så fordi du kun ønsker 1 program

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

622
00:42:37,000 --> 00:42:40,000
i 1 eksekverbar fil.

623
00:42:40,000 --> 00:42:45,000
Dette er også, hvad der sker, når du bruger CS50 bibliotek, for eksempel.

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

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

626
00:42:53,000 --> 00:42:58,000
Og så er det også en særlig binær biblioteksfil

627
00:42:58,000 --> 00:43:02,000
der er blevet udarbejdet som er 0'er og 1'ere,

628
00:43:02,000 --> 00:43:08,000
og at-l flag, så hvis vi går tilbage til vores rum, og vi ser virkelig hurtigt

629
00:43:08,000 --> 00:43:11,000
på, hvad der foregår her, når vi ser på vores klang kommando,

630
00:43:11,000 --> 00:43:15,000
hvad vi har, er det er vores kildekode fil lige her.

631
00:43:15,000 --> 00:43:18,000
Det er en flok kompiler-flag.

632
00:43:18,000 --> 00:43:22,000
Og så til allersidst, i disse-l-flag link

633
00:43:22,000 --> 00:43:30,000
de faktiske binære filer til disse 2 biblioteker, det CS50 bibliotek og derefter math bibliotek.

634
00:43:30,000 --> 00:43:35,000
>> Forståelse hver type filer 'formål

635
00:43:35,000 --> 00:43:38,000
i udarbejdelsen proces er noget, du ønsker at være i stand til at

636
00:43:38,000 --> 00:43:43,000
opnåelse af i det mindste et højt niveau oversigt over.

637
00:43:43,000 --> 00:43:46,000
Kildekode kommer ind Objektkode kommer ud.

638
00:43:46,000 --> 00:43:53,000
Objekt kode filer sammenkæde, og du får en smuk, eksekverbar 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å fejl på flere punkter

641
00:43:58,000 --> 00:44:00,000
i processen til kompilering.

642
00:44:00,000 --> 00:44:04,000
Det er her, for eksempel, hvis du tager ud denne sammenkædning flag,

643
00:44:04,000 --> 00:44:10,000
det CS50 flag, og du udelader det i Spaces, eller når du kører din kode,

644
00:44:10,000 --> 00:44:13,000
det er her du får en fejl i sammenkædningen fase,

645
00:44:13,000 --> 00:44:18,000
og linkeren vil sige: "Hey, du kaldte en funktion GetString

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

647
00:44:20,000 --> 00:44:25,000
"Du fortalte mig det var i CS50 biblioteket, og jeg kan ikke finde koden til det."

648
00:44:25,000 --> 00:44:28,000
Det er, hvor du er nødt til at forbinde det med, og det er særskilt

649
00:44:28,000 --> 00:44:33,000
fra en compiler fejl, fordi compileren ser på syntaks og den slags ting.

650
00:44:33,000 --> 00:44:38,000
Det er godt at vide, hvad der sker hvornår.

651
00:44:38,000 --> 00:44:42,000
>> Andre ting at vide om.

652
00:44:42,000 --> 00:44:49,000
Jeg vil sige, du helt sikkert ønsker at tage et kig på den kort på typecasting udført af Jordan

653
00:44:49,000 --> 00:44:55,000
at forstå, hvad int'er er under kølerhjelmen,

654
00:44:55,000 --> 00:44:58,000
hvilke tegn er under kølerhjelmen.

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

656
00:45:02,000 --> 00:45:07,000
hvad der gør, er at give os en under kølerhjelmen udseende

657
00:45:07,000 --> 00:45:13,000
på, hvordan computeren faktisk repræsenterer kapitalen A og tallet 7

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

659
00:45:17,000 --> 00:45:20,000
Computeren har også særlige måder at repræsentere

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

661
00:45:23,000 --> 00:45:27,000
Den har en særlig måde at repræsentere tallet 7 som et decimaltal,

662
00:45:27,000 --> 00:45:29,000
og dem er meget forskellige.

663
00:45:29,000 --> 00:45:32,000
Typecasting er, hvordan du fortælle computeren "Hey, jeg vil have dig til at konvertere

664
00:45:32,000 --> 00:45:37,000
fra én repræsentation til en anden repræsentation. "

665
00:45:37,000 --> 00:45:40,000
Hvorfor vi ikke tage et kig på det.

666
00:45:40,000 --> 00:45:44,000
>> Jeg vil også tage et kig på den korte på biblioteker og den korte på compilers.

667
00:45:44,000 --> 00:45:47,000
Dem snak om processen med udarbejdelse,

668
00:45:47,000 --> 00:45:53,000
hvad et bibliotek er, og gå over nogle af disse spørgsmål, som du kan få spurgt.

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

670
00:45:55,000 --> 00:46:03,000
Er der nogen emner herinde, der synes skræmmende som du gerne vil dække?

671
00:46:03,000 --> 00:46:07,000
Jeg forsøger at blæse gennem det meste af disse tidligere emner, så vi kan komme til

672
00:46:07,000 --> 00:46:13,000
pointere og gøre en lille smule af rekursion.

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

674
00:46:15,000 --> 00:46:19,000
Noget at dække?

675
00:46:19,000 --> 00:46:21,000
Tid til lidt chokolade måske?

676
00:46:21,000 --> 00:46:23,000
Du fyre arbejder igennem det.

677
00:46:23,000 --> 00:46:26,000
Jeg har tænkt mig at holde sipping på min kaffe.

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

679
00:46:31,000 --> 00:46:34,000
Godt opkald, god opkald.

680
00:46:34,000 --> 00:46:38,000
I uge 2 snakkede vi lidt mere om funktioner.

681
00:46:38,000 --> 00:46:43,000
>> I de første par problematiske sæt vi ikke virkelig skrive nogen funktioner på alle

682
00:46:43,000 --> 00:46:45,000
andet end hvilken funktion?

683
00:46:45,000 --> 00:46:47,000
[Student] Main. >> Main, præcis.

684
00:46:47,000 --> 00:46:51,000
Og så har vi set de forskellige kostumer, der main slidt.

685
00:46:51,000 --> 00:46:54,000
Der er den, hvor det tager ingen argumenter,

686
00:46:54,000 --> 00:46:58,000
og vi bare sige tomrum i mellem parenteserne,

687
00:46:58,000 --> 00:47:01,000
og så er der den anden, hvor vi ønsker at tage kommandolinjeargumenter,

688
00:47:01,000 --> 00:47:08,000
og da vi så, det er hvor du har int argc og streng argv arrayet

689
00:47:08,000 --> 00:47:13,000
eller nu, at vi faktisk har udsat streng at være den char *, at det er

690
00:47:13,000 --> 00:47:20,000
vi vil begynde at skrive det som char * argv og derefter parentes.

691
00:47:20,000 --> 00:47:22,000
I Problem Set 3, så gutter en flok af funktioner,

692
00:47:22,000 --> 00:47:27,000
og du implementeret en masse funktioner, tegne, se op, kapløbet.

693
00:47:27,000 --> 00:47:31,000
Prototyperne blev alle skrevet der for dig.

694
00:47:31,000 --> 00:47:33,000
>> Hvad jeg ønskede at tale om her med funktioner virkelig hurtigt

695
00:47:33,000 --> 00:47:38,000
er, at der er 3 dele til dem, når du skriver en funktion.

696
00:47:38,000 --> 00:47:43,000
Du skal angive returtype for funktionen.

697
00:47:43,000 --> 00:47:46,000
Du skal angive et navn for den funktion, og så er du nødt til at specificere

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

699
00:47:51,000 --> 00:47:57,000
For eksempel, hvis jeg skulle skrive en funktion til at opsummere en flok af heltal

700
00:47:57,000 --> 00:48:03,000
og derefter vende tilbage til mig det beløb, hvad der ville være mit returtype

701
00:48:03,000 --> 00:48:06,000
hvis jeg ønskede at opsummere heltal og derefter returnere summen?

702
00:48:06,000 --> 00:48:12,000
Derefter navnet på funktionen.

703
00:48:12,000 --> 00:48:27,000
Hvis jeg gå videre og skrive i grøn, denne del er returtype.

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

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

706
00:48:40,000 --> 00:48:46,000
er der, hvor jeg giver de argumenter,

707
00:48:46,000 --> 00:48:56,000
ofte forkortet som args, undertiden kaldet params for parametre.

708
00:48:56,000 --> 00:49:00,000
Og hvis du har en, du bare angive én.

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

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

711
00:49:13,000 --> 00:49:18,000
[Kevin] Du er nødt til at give type og derefter navnet.

712
00:49:18,000 --> 00:49:21,000
Og derefter navnet, og navnet er det navn, du vil bruge

713
00:49:21,000 --> 00:49:25,000
at henvise til dette argument i sum-funktionen,

714
00:49:25,000 --> 00:49:27,000
inden den funktion, du i øjeblikket er ved at skrive.

715
00:49:27,000 --> 00:49:32,000
>> Du behøver ikke at for eksempel, hvis jeg har tænkt mig at opsummere,

716
00:49:32,000 --> 00:49:41,000
sige, et array af heltal-vi do int array,

717
00:49:41,000 --> 00:49:46,000
og jeg vil give mig selv nogle krøllede parenteser der-

718
00:49:46,000 --> 00:49:51,000
så når jeg passerer et array til summen funktion

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

720
00:49:55,000 --> 00:49:59,000
Men det array, jeg passerer i behøver ikke at have navnet arr..

721
00:49:59,000 --> 00:50:07,000
Arr. vil være, hvordan jeg henvise til dette argument i kroppen af ​​funktionen.

722
00:50:07,000 --> 00:50:10,000
Den anden ting, vi er nødt til at tage hensyn til,

723
00:50:10,000 --> 00:50:14,000
og det er lidt anderledes end funktioner, men jeg tror, ​​det er en vigtig pointe,

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

725
00:50:20,000 --> 00:50:29,000
hvordan kan jeg vide, hvor mange elementer er i denne array?

726
00:50:29,000 --> 00:50:31,000
Det er noget af et trick spørgsmål.

727
00:50:31,000 --> 00:50:35,000
Vi talte om dette en lille smule i sidste uges afsnit.

728
00:50:35,000 --> 00:50:40,000
Hvordan kan jeg vide, hvor mange elementer inde et array i C?

729
00:50:40,000 --> 00:50:44,000
Er der en måde?

730
00:50:44,000 --> 00:50:49,000
>> Det viser sig, at der er ingen måde at vide.

731
00:50:49,000 --> 00:50:52,000
Du er nødt til at lade det separat.

732
00:50:52,000 --> 00:50:55,000
Der er et trick, du kan gøre

733
00:50:55,000 --> 00:51:00,000
hvis du er i samme funktion, hvor arrayet er erklæret,

734
00:51:00,000 --> 00:51:04,000
og du arbejder med en stak array.

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

736
00:51:06,000 --> 00:51:09,000
Når du har bestået et array til en anden funktion, eller hvis du har erklæret et array

737
00:51:09,000 --> 00:51:12,000
og du lægger det datatabel på heapen, har du brugt malloc

738
00:51:12,000 --> 00:51:15,000
 og den slags ting, så er alt håb ude.

739
00:51:15,000 --> 00:51:18,000
Så er du faktisk nødt til at passere rundt

740
00:51:18,000 --> 00:51:21,000
en særlig argument eller en anden parameter

741
00:51:21,000 --> 00:51:23,000
fortæller dig hvor stor array er.

742
00:51:23,000 --> 00:51:28,000
I dette tilfælde ville jeg ønsker at bruge et komma-Undskyld, går det væk fra skærmen her-

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

744
00:51:32,000 --> 00:51:40,000
 og kalder det int len ​​for længden.

745
00:51:40,000 --> 00:51:44,000
>> En ting, der kan komme op på quizzen

746
00:51:44,000 --> 00:51:49,000
beder dig om at skrive eller opfylde en særlig funktion kaldet noget.

747
00:51:49,000 --> 00:51:54,000
Hvis vi ikke giver dig prototypen, så det hele her,

748
00:51:54,000 --> 00:51:58,000
hele denne rod kaldes funktionen angivelse eller funktion prototype,

749
00:51:58,000 --> 00:52:01,000
dette er en af ​​de første ting, du ønsker at søm ned, hvis det ikke er givet

750
00:52:01,000 --> 00:52:03,000
til dig med det samme på quizzen.

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

752
00:52:06,000 --> 00:52:11,000
siger, at vi giver dig en prototype for en funktion, og vi siger, "Hey, har du fået at skrive det."

753
00:52:11,000 --> 00:52:16,000
Inde i de krøllede parenteser, du har på quizzen

754
00:52:16,000 --> 00:52:20,000
hvis du bemærker, at der er en returtype og du bemærker, at returtypen

755
00:52:20,000 --> 00:52:25,000
er noget andet end hulrum, hvilket betyder, at funktionen ikke returnerer noget,

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

757
00:52:28,000 --> 00:52:33,000
en slags tilbagevenden erklæring i slutningen af ​​funktionen.

758
00:52:33,000 --> 00:52:40,000
Return, og i dette tilfælde, vil vi sætte en blank, fordi vi ønsker at udfylde det tomme.

759
00:52:40,000 --> 00:52:44,000
Men det får du tænker på den rigtige måde, hvordan skal jeg gribe dette problem?

760
00:52:44,000 --> 00:52:49,000
Og det minder dig du er nødt til at returnere en værdi

761
00:52:49,000 --> 00:52:51,000
til den opkaldende af funktionen.

762
00:52:51,000 --> 00:52:54,000
>> Ja. >> [Student] Er stil gælder, når vi skriver kode på quizzen?

763
00:52:54,000 --> 00:52:58,000
Såsom indrykning og den slags ting? >> [Student] Yeah.

764
00:52:58,000 --> 00:53:00,000
Nej, ikke så meget.

765
00:53:00,000 --> 00:53:09,000
Jeg tror en masse af-dette er noget, vi vil tydeliggøre på quizzen på dagen for,

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

767
00:53:15,000 --> 00:53:17,000
[Student] Har du brug for at kommentere din håndskrevne kode?

768
00:53:17,000 --> 00:53:19,000
Har du brug for at kommentere din håndskrevne kode?

769
00:53:19,000 --> 00:53:24,000
Kommentering er altid godt, hvis du er bekymret for delvis kredit

770
00:53:24,000 --> 00:53:29,000
eller du ønsker at kommunikere din hensigt til grader.

771
00:53:29,000 --> 00:53:33,000
Men jeg, igen, vil afklare om quizzen selv og i quiz dag,

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

773
00:53:39,000 --> 00:53:42,000
Typisk ikke, men det er helt sikkert den slags ting, hvor

774
00:53:42,000 --> 00:53:45,000
du kan kommunikere din hensigt, som "Hey, det er her jeg har tænkt mig med det."

775
00:53:45,000 --> 00:53:49,000
Og nogle gange, der kan hjælpe med delvis kredit.

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

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

778
00:53:53,000 --> 00:53:56,000
[Basil] Hvad er forskellen mellem at erklære, siger, int lang

779
00:53:56,000 --> 00:54:03,000
i de argumenter eller parametre kontra erklære en variabel i funktionen?

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

781
00:54:05,000 --> 00:54:07,000
[Basil] Ligesom der ting, vi ønsker at sætte i argumenter.

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

783
00:54:09,000 --> 00:54:11,000
Hvordan vælger du hvilke ting du ønsker at sætte i de argumenter

784
00:54:11,000 --> 00:54:17,000
forhold til, hvad ting du skal gøre inde i funktionen?

785
00:54:17,000 --> 00:54:24,000
I dette tilfælde har vi inkluderet begge disse som argumenter

786
00:54:24,000 --> 00:54:29,000
fordi de er noget, som den, der kommer til at bruge funktionen SUM

787
00:54:29,000 --> 00:54:32,000
nødt til at præcisere disse ting.

788
00:54:32,000 --> 00:54:35,000
>> Funktionen SUM, ligesom vi talte om, har ingen mulighed for at vide

789
00:54:35,000 --> 00:54:40,000
hvor stort array er den går fra sin opkalds eller hvem der bruger funktionen SUM.

790
00:54:40,000 --> 00:54:44,000
Det har ingen mulighed for at vide hvor stor den opstilling er.

791
00:54:44,000 --> 00:54:48,000
Grunden til at vi passerer i denne længde lige her som et argument

792
00:54:48,000 --> 00:54:51,000
er, fordi det er noget, som vi dybest set er at fortælle den, der ringer af funktionen,

793
00:54:51,000 --> 00:54:55,000
uanset hvem der kommer til at bruge den sum funktion, "Hey, ikke kun du nødt til at give os et array

794
00:54:55,000 --> 00:54:59,000
af int'er du også nødt til at fortælle os, hvor stort array, du har givet os, 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
Nej, disse er faktiske argumenter, som du ville passere til funktionen.

797
00:55:06,000 --> 00:55:10,000
>> Lad mig gøre en ny side her.

798
00:55:10,000 --> 00:55:13,000
[Basil] Ligesom navn ville 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 har tænkt mig at sætte i min tilbagevenden 0 herned i bunden,

801
00:55:27,000 --> 00:55:31,000
og sige, at jeg vil kalde funktionen SUM.

802
00:55:31,000 --> 00:55:42,000
Jeg vil gerne sige int x = sum ();

803
00:55:42,000 --> 00:55:46,000
Hvis du vil bruge funktionen SUM jeg nødt til at passere i både array, som jeg ønsker at opsummere

804
00:55:46,000 --> 00:55:51,000
og længden af ​​array'et, så det er her

805
00:55:51,000 --> 00:55:54,000
hvis jeg havde en matrix af int'er,

806
00:55:54,000 --> 00:56:12,000
siger jeg havde int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
form for brug, der hacket op syntaks lige der,

808
00:56:16,000 --> 00:56:21,000
så hvad jeg ville gøre, er i sum, jeg ønsker at passere i

809
00:56:21,000 --> 00:56:27,000
både numbaz og tallet 3

810
00:56:27,000 --> 00:56:30,000
at fortælle sum funktionen "Okay, her er array jeg vil have dig til at opsummere."

811
00:56:30,000 --> 00:56:34,000
"Her er dens størrelse."

812
00:56:34,000 --> 00:56:39,000
Giver det mening? Besvarer det dit spørgsmål?

813
00:56:39,000 --> 00:56:42,000
>> På mange måder det gør parallel, hvad vi gør med de vigtigste

814
00:56:42,000 --> 00:56:44,000
når vi har de kommandolinjeargumenter.

815
00:56:44,000 --> 00:56:47,000
Et program som Cæsar cipher, for eksempel, er nødvendig at

816
00:56:47,000 --> 00:56:53,000
kommandolinjeargumenter ville ikke være i stand til at gøre noget.

817
00:56:53,000 --> 00:56:57,000
Det ville ikke vide, hvordan man kryptere hvis du ikke fortælle, hvad nøglen til at bruge

818
00:56:57,000 --> 00:57:03,000
eller hvis du ikke fortælle, hvad streng du ønskede at kryptere.

819
00:57:03,000 --> 00:57:08,000
Tilskyndelse for input, det er her vi har 2 forskellige mekanismer

820
00:57:08,000 --> 00:57:14,000
for at tage input fra brugeren, for at tage information fra brugeren.

821
00:57:14,000 --> 00:57:19,000
For Problem Set 1 vi så dette GetInt, GetString, GetFloat måde

822
00:57:19,000 --> 00:57:26,000
af forespørgsel om input, og det hedder med standard input stream.

823
00:57:26,000 --> 00:57:28,000
Det er lidt anderledes.

824
00:57:28,000 --> 00:57:31,000
Det er noget, du kan gøre på én gang i modsætning til

825
00:57:31,000 --> 00:57:35,000
når du starter programmet, når du starter programmet kører.

826
00:57:35,000 --> 00:57:41,000
De kommandolinjeargumenter alle er specificeret, når du starter programmet kører.

827
00:57:41,000 --> 00:57:47,000
Vi har blande de to af dem.

828
00:57:47,000 --> 00:57:52,000
Når vi bruger argumenter til en funktion, det er meget ligesom kommandolinjeargumenter til main.

829
00:57:52,000 --> 00:57:56,000
Det er, når du påberåbe den funktion, du har brug for at fortælle det

830
00:57:56,000 --> 00:58:05,000
hvad den behøver for at kunne udføre sine opgaver.

831
00:58:05,000 --> 00:58:08,000
En anden god ting at se på-og jeg vil lade dig se på det i din fritid,

832
00:58:08,000 --> 00:58:11,000
og det blev dækket i quizzen, var denne opfattelse af anvendelsesområdet

833
00:58:11,000 --> 00:58:15,000
og lokale variable versus globale variable.

834
00:58:15,000 --> 00:58:18,000
Gør opmærksom på det.

835
00:58:18,000 --> 00:58:23,000
>> Nu, hvor vi får på denne anden ting,

836
00:58:23,000 --> 00:58:27,000
i uge 3 vi begyndte at snakke om søgning og sortering.

837
00:58:27,000 --> 00:58:32,000
Søgning og sortering, i det mindste i CS50,

838
00:58:32,000 --> 00:58:39,000
er i høj grad en introduktion til nogle af de mere teoretiske dele af datalogi.

839
00:58:39,000 --> 00:58:42,000
Problemet med søgning, 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 finder du et bestemt antal i en vifte af milliarder af heltal?

842
00:58:52,000 --> 00:58:55,000
Hvordan finder du et bestemt navn i en telefonbog

843
00:58:55,000 --> 00:58:59,000
der er gemt på din bærbare computer?

844
00:58:59,000 --> 00:59:04,000
Og så introducerer vi denne idé om asymptotiske driftstid

845
00:59:04,000 --> 00:59:11,000
til virkelig at kvantificere hvor længe, ​​hvor hårdt disse problem er,

846
00:59:11,000 --> 00:59:14,000
hvor lang tid de tager at løse.

847
00:59:14,000 --> 00:59:20,000
I, tror jeg, 2011 er quiz der er et problem, som jeg tror fortjener

848
00:59:20,000 --> 00:59:27,000
dækker meget hurtigt, hvilket er den her, problem 12.

849
00:59:27,000 --> 00:59:32,000
O nej, det er Omega.

850
00:59:32,000 --> 00:59:41,000
>> Her taler vi om den hurtigst mulige køretid

851
00:59:41,000 --> 00:59:46,000
for en bestemt algoritme, og derefter den langsomste mulige driftstid.

852
00:59:46,000 --> 00:59:52,000
Denne Omega og O er virkelig bare genveje.

853
00:59:52,000 --> 00:59:55,000
De er notational genveje for at sige

854
00:59:55,000 --> 00:59:59,000
hvor hurtigt i den bedst mulige tilfælde vil vores algoritme køre,

855
00:59:59,000 --> 01:00:06,000
og hvor langsomme i den værst tænkelige tilfælde vil vores algoritme køre?

856
01:00:06,000 --> 01:00:10,000
Lad os gøre et par af disse, og disse blev også dækket

857
01:00:10,000 --> 01:00:13,000
på kort på asymptotisk notation, som jeg stærkt anbefale.

858
01:00:13,000 --> 01:00:17,000
Jackson gjorde et virkelig godt stykke arbejde.

859
01:00:17,000 --> 01:00:23,000
Med binær søgning, taler vi om binær søgning som værende en algoritme,

860
01:00:23,000 --> 01:00:28,000
og vi normalt taler om det på grund af sin store O.

861
01:00:28,000 --> 01:00:30,000
Hvad er den store O?

862
01:00:30,000 --> 01:00:34,000
Hvad er den langsomste mulige driftstid af binær søgning?

863
01:00:34,000 --> 01:00:36,000
[Student] N ²?

864
01:00:36,000 --> 01:00:41,000
Close, jeg gætte svarende til den.

865
01:00:41,000 --> 01:00:43,000
Det er meget hurtigere end det.

866
01:00:43,000 --> 01:00:45,000
[Student] Binary? >> Ja, binær søgning.

867
01:00:45,000 --> 01:00:47,000
[Student] Det er log n.

868
01:00:47,000 --> 01:00:49,000
Log n, så hvad betyder log n betyde?

869
01:00:49,000 --> 01:00:51,000
Det halverer det hver iteration.

870
01:00:51,000 --> 01:00:56,000
Præcis, så i den langsomste mulige tilfælde,

871
01:00:56,000 --> 01:01:00,000
sige, hvis du har en sorteret opstilling

872
01:01:00,000 --> 01:01:08,000
af en million heltal og det nummer, du leder efter

873
01:01:08,000 --> 01:01:14,000
er enten det første element i arrayet eller den sidste element i grupperingen.

874
01:01:14,000 --> 01:01:18,000
Husk, at binære søgealgoritme virker ved at kigge på den midterste del,

875
01:01:18,000 --> 01:01:21,000
se, om det er den kamp, ​​som du leder efter.

876
01:01:21,000 --> 01:01:23,000
Hvis det er, så stor, du fandt den.

877
01:01:23,000 --> 01:01:27,000
>> I det bedst mulige tilfælde har hvor hurtigt binær søgning løb?

878
01:01:27,000 --> 01:01:29,000
[Studerende] 1.

879
01:01:29,000 --> 01:01:32,000
1, er det konstant tid, big O i 1. Yeah.

880
01:01:32,000 --> 01:01:36,000
[Student] Jeg har et spørgsmål. Når du siger logger af n, du mener med hensyn til basen 2, right?

881
01:01:36,000 --> 01:01:40,000
Ja, så det er den anden ting.

882
01:01:40,000 --> 01:01:44,000
Vi siger log n, og jeg gætte, da jeg var i high school

883
01:01:44,000 --> 01:01:48,000
Jeg har altid antaget, at log var basis 10.

884
01:01:48,000 --> 01:01:57,000
Ja, så ja, log base 2 typisk er, hvad vi bruger.

885
01:01:57,000 --> 01:02:02,000
Igen, går tilbage til binær søgning, hvis du søger efter enten

886
01:02:02,000 --> 01:02:05,000
elementet til allersidst eller elementet i begyndelsen,

887
01:02:05,000 --> 01:02:08,000
fordi du starter i midten og derefter du kassere

888
01:02:08,000 --> 01:02:13,000
uanset hvilken halv opfylder ikke de kriterier, du leder efter,

889
01:02:13,000 --> 01:02:15,000
og du gå til den næste halvdel og den næste halve og den næste halvdel.

890
01:02:15,000 --> 01:02:19,000
Hvis jeg søger efter det største element i million integer array

891
01:02:19,000 --> 01:02:25,000
Jeg har tænkt mig at halvere det højst log på 1 million gange

892
01:02:25,000 --> 01:02:28,000
før jeg endelig teste og se, at elementet jeg leder efter

893
01:02:28,000 --> 01:02:33,000
er i den største eller i det højeste indeks af arrayet,

894
01:02:33,000 --> 01:02:38,000
og det vil tage log af n, skal du logge på 1 million gange.

895
01:02:38,000 --> 01:02:40,000
>> Bubble slags.

896
01:02:40,000 --> 01:02:43,000
Kan du fyre huske den boble slags algoritme?

897
01:02:43,000 --> 01:02:47,000
Kevin, kan du give mig en hurtig resumé af, hvad der skete i den boble slags algoritme?

898
01:02:47,000 --> 01:02:50,000
[Kevin] Dybest set det går igennem 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 det første er større end den anden det swaps dem.

901
01:02:55,000 --> 01:02:58,000
Derefter sammenlignes andet og tredje, samme ting, swaps,

902
01:02:58,000 --> 01:03:00,000
tredje og fjerde, hele vejen ned.

903
01:03:00,000 --> 01:03:03,000
Større tal vil følge op til slutningen.

904
01:03:03,000 --> 01:03:07,000
Og efter uanset hvor mange sløjfer du er færdig.

905
01:03:07,000 --> 01:03:11,000
Præcis, så hvad Kevin sagde, er, at vi vil se større tal

906
01:03:11,000 --> 01:03:15,000
boble op til udgangen af ​​arrayet.

907
01:03:15,000 --> 01:03:19,000
For eksempel, har du noget imod walking os gennem dette eksempel, hvis dette er vores array?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Du tager 2 og 3.

909
01:03:21,000 --> 01:03:23,000
3 er større end 2, så du bytte dem.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Højre, så vi bytte dem, og så vi får 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 end 6, så du forlader dem,

913
01:03:33,000 --> 01:03:37,000
og 6 og 4, ville du bytte dem fordi 4 er mindre end 6.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] Right, så jeg får 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] Og 9 er større end 6, så du forlader den.

916
01:03:46,000 --> 01:03:48,000
Og du vil gå tilbage igennem det igen.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H.] Er jeg gjort på dette punkt? >> [Kevin] Nej.

918
01:03:50,000 --> 01:03:52,000
Og hvorfor er jeg ikke gjort på dette punkt?

919
01:03:52,000 --> 01:03:54,000
Fordi det ligner min opstilling er sorteret. Jeg kigger på det.

920
01:03:54,000 --> 01:03:57,000
[Kevin] Gå igennem det igen og sørg for, at der ikke er flere swaps

921
01:03:57,000 --> 01:04:00,000
før du fuldt ud kan stoppe.

922
01:04:00,000 --> 01:04:04,000
Præcis, så du skal holde går igennem, og sørg for, at der ikke er nogen swaps

923
01:04:04,000 --> 01:04:06,000
at du kan gøre på dette punkt.

924
01:04:06,000 --> 01:04:08,000
Det var virkelig bare heldig, som du sagde, at vi endte med

925
01:04:08,000 --> 01:04:12,000
kun at skulle lave 1 passerer gennem og vi er sorteret.

926
01:04:12,000 --> 01:04:16,000
Men for at gøre dette i det generelle tilfælde vil vi faktisk nødt til at gøre det igen og igen.

927
01:04:16,000 --> 01:04:20,000
Og i virkeligheden var dette et eksempel på den bedst mulige sag,

928
01:04:20,000 --> 01:04:24,000
ligesom vi så i problemet.

929
01:04:24,000 --> 01:04:28,000
Vi så, at den bedst mulige sag var N.

930
01:04:28,000 --> 01:04:32,000
Vi gik gennem opstillingen 1 gang.

931
01:04:32,000 --> 01:04:35,000
Hvad er det værst tænkelige tilfælde for denne algoritme?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
Og hvad ligner det? Hvad ville et array ligne det ville tage n ² tid?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [uhørlig] sorteres.

935
01:04:43,000 --> 01:04:51,000
Præcis, så hvis jeg havde arrayet 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
først 9 ville boble hele vejen op.

937
01:04:54,000 --> 01:04:59,000
Efter 1 iteration ville vi have 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Derefter 7 vil boble op, 6, 5, 2, 7, 9, og så videre og så videre.

939
01:05:07,000 --> 01:05:13,000
>> Vi er nødt til at gå gennem hele arrayet n gange,

940
01:05:13,000 --> 01:05:16,000
og du kan faktisk få en anelse mere præcis end dette

941
01:05:16,000 --> 01:05:23,000
fordi når vi har flyttet den 9 hele vejen op i sin sidste mulige position

942
01:05:23,000 --> 01:05:26,000
Vi ved, at vi aldrig behøver at sammenligne med dette element igen.

943
01:05:26,000 --> 01:05:29,000
Når vi begynder gennembobling af 7 op

944
01:05:29,000 --> 01:05:35,000
Vi ved, at vi kan stoppe når 7 er lige før 9

945
01:05:35,000 --> 01:05:37,000
da vi allerede har sammenlignet den 9 til den.

946
01:05:37,000 --> 01:05:46,000
Hvis du gør dette på en smart måde, det er ikke rigtig, tror jeg, at meget tid.

947
01:05:46,000 --> 01:05:49,000
Du kommer ikke til at sammenligne alle de mulige [uhørlige] kombinationer

948
01:05:49,000 --> 01:05:55,000
hver eneste gang du går igennem hver iteration.

949
01:05:55,000 --> 01:05:59,000
Men alligevel, når vi taler om denne øvre grænse vi siger, at

950
01:05:59,000 --> 01:06:04,000
du kigger på n ² sammenligninger hele vejen igennem.

951
01:06:04,000 --> 01:06:12,000
>> Lad os gå tilbage, og da vi er begyndt at få lidt kort til tiden

952
01:06:12,000 --> 01:06:15,000
Jeg vil sige, bør du helt sikkert gå gennem resten af ​​denne tabel,

953
01:06:15,000 --> 01:06:17,000
udfylde det hele ud.

954
01:06:17,000 --> 01:06:20,000
Tænk på eksempler. Tænk på konkrete eksempler.

955
01:06:20,000 --> 01:06:22,000
Det er virkelig praktisk og nyttigt at gøre.

956
01:06:22,000 --> 01:06:25,000
Trække den ud.

957
01:06:25,000 --> 01:06:28,000
Det er den slags tabel, som du går igennem i datalogi

958
01:06:28,000 --> 01:06:32,000
du bør virkelig begynde at kende disse udenad.

959
01:06:32,000 --> 01:06:34,000
Det er den slags spørgsmål, du får i interviews.

960
01:06:34,000 --> 01:06:36,000
Det er slags ting, der er godt at vide,

961
01:06:36,000 --> 01:06:41,000
og tænke over disse kanter sager, virkelig finde ud af at tænke

962
01:06:41,000 --> 01:06:45,000
vel vidende, at for boble sortere den værst mulige opstilling

963
01:06:45,000 --> 01:06:52,000
at sortere med det er en, der er i omvendt rækkefølge.

964
01:06:52,000 --> 01:06:58,000
>> Pointers. Lad os snakke lidt om pointers.

965
01:06:58,000 --> 01:07:03,000
I de sidste par minutter, vi har her

966
01:07:03,000 --> 01:07:11,000
Jeg ved, det er noget sammen med fil I / O, som er temmelig ny.

967
01:07:11,000 --> 01:07:19,000
Når vi taler om pegepinde årsagen til at vi ønsker at tale om pointers

968
01:07:19,000 --> 01:07:24,000
er fordi, en, når vi arbejder i C

969
01:07:24,000 --> 01:07:33,000
Vi er virkelig på et forholdsvis lavt niveau sammenlignet med de fleste moderne programmeringssprog.

970
01:07:33,000 --> 01:07:38,000
Vi er faktisk i stand til at manipulere de variable i hukommelsen,

971
01:07:38,000 --> 01:07:43,000
regne ud, hvor de er faktisk beliggende inden for vores RAM.

972
01:07:43,000 --> 01:07:46,000
Når du har gået på at tage operativsystemer klasser, du vil se

973
01:07:46,000 --> 01:07:48,000
, at det er, igen, sådan en abstraktion.

974
01:07:48,000 --> 01:07:50,000
Det er faktisk ikke tilfældet.

975
01:07:50,000 --> 01:07:52,000
Vi har virtuel hukommelse, der gemmer disse oplysninger fra os.

976
01:07:52,000 --> 01:07:58,000
>> Men for nu kan du antage, at når du har et program,

977
01:07:58,000 --> 01:08:02,000
for eksempel, der kører, når du starter din Cæsar cipher program-

978
01:08:02,000 --> 01:08:06,000
Jeg vil skifte tilbage til min iPad virkelig hurtigt-

979
01:08:06,000 --> 01:08:12,000
at der ved begyndelsen dit program, hvis du har, sige,

980
01:08:12,000 --> 01:08:15,000
4 GB RAM på din bærbare computer,

981
01:08:15,000 --> 01:08:21,000
du får afsat denne luns, og vi vil kalde denne RAM.

982
01:08:21,000 --> 01:08:25,000
Og det starter på et sted, vi vil kalde 0,

983
01:08:25,000 --> 01:08:30,000
og det ender på et sted, som vi vil kalde 4 gigabyte.

984
01:08:30,000 --> 01:08:37,000
Jeg kan virkelig ikke skrive. Mand, er, at hacket.

985
01:08:37,000 --> 01:08:40,000
Når dit program udfører

986
01:08:40,000 --> 01:08:44,000
operativsystemet skærer op RAM,

987
01:08:44,000 --> 01:08:51,000
og det angiver forskellige segmenter for forskellige dele af dit program til at leve i.

988
01:08:51,000 --> 01:08:58,000
Hernede dette område er lidt af en ingenmandsland.

989
01:08:58,000 --> 01:09:02,000
Når du går op lidt længere her

990
01:09:02,000 --> 01:09:05,000
du har fået faktisk det sted, hvor

991
01:09:05,000 --> 01:09:09,000
koden for dit program liv.

992
01:09:09,000 --> 01:09:13,000
Det faktiske binære kode, som eksekverbar fil faktisk bliver indlæst i hukommelsen

993
01:09:13,000 --> 01:09:17,000
når du kører et program, og den lever i kodesegmentet.

994
01:09:17,000 --> 01:09:22,000
Og som dit program udfører processoren ser på dette kodesegmentet

995
01:09:22,000 --> 01:09:24,000
at regne ud, hvad er det næste instruktion?

996
01:09:24,000 --> 01:09:27,000
Hvad er den næste linje kode jeg har brug for at udføre?

997
01:09:27,000 --> 01:09:31,000
>> Der er også en data segment, og det er her de strengkonstanter

998
01:09:31,000 --> 01:09:34,000
få gemt at du har brugt.

999
01:09:34,000 --> 01:09:42,000
Og så videre deroppe er dette sted kaldet den bunke.

1000
01:09:42,000 --> 01:09:46,000
Vi adgang hukommelse derinde ved hjælp af malloc,

1001
01:09:46,000 --> 01:09:49,000
og derefter mod selve toppen af ​​dit program

1002
01:09:49,000 --> 01:09:52,000
der er stakken,

1003
01:09:52,000 --> 01:09:57,000
og det er her vi har spillet i det meste af begyndelsen.

1004
01:09:57,000 --> 01:09:59,000
Dette er ikke i skala eller noget.

1005
01:09:59,000 --> 01:10:03,000
Meget af dette er meget maskine afhængig,

1006
01:10:03,000 --> 01:10:10,000
operativsystem afhængige, men det er relativt hvordan tingene bliver chunked op.

1007
01:10:10,000 --> 01:10:17,000
Når du kører et program, og du erklærer en variabel kaldet x-

1008
01:10:17,000 --> 01:10:27,000
Jeg har tænkt mig at tegne en anden kasse nede, og det vil være RAM så godt.

1009
01:10:27,000 --> 01:10:29,000
Og jeg har tænkt mig at se.

1010
01:10:29,000 --> 01:10:34,000
Vi vil tegne takkede linjer for at angive dette er blot en lille del af RAM

1011
01:10:34,000 --> 01:10:38,000
og ikke det hele som trækker vi øverst.

1012
01:10:38,000 --> 01:10:43,000
>> Hvis jeg erklærer en heltalsvariabel kaldet x,

1013
01:10:43,000 --> 01:10:49,000
så hvad jeg egentlig får, er en kortlægning

1014
01:10:49,000 --> 01:10:54,000
der er gemt i symbol tabellen i mit program

1015
01:10:54,000 --> 01:11:00,000
der forbinder navnet x til denne region af hukommelse, som jeg har tegnet

1016
01:11:00,000 --> 01:11:03,000
lige her mellem de lodrette bjælker.

1017
01:11:03,000 --> 01:11:08,000
Hvis jeg har en linje kode i mit program, der siger x = 7

1018
01:11:08,000 --> 01:11:15,000
processoren kender "Åh, okay, jeg ved, at x lever på dette sted i hukommelsen."

1019
01:11:15,000 --> 01:11:25,000
"Jeg har tænkt mig at gå videre og skrive en 7 der."

1020
01:11:25,000 --> 01:11:28,000
Hvordan virker det ved, hvad placering dette er i hukommelsen?

1021
01:11:28,000 --> 01:11:30,000
Nå, det hele foregår ved oversættelsen.

1022
01:11:30,000 --> 01:11:34,000
Compileren tager sig af fordelingen, hvor hver af de variable kommer til at gå

1023
01:11:34,000 --> 01:11:40,000
og skabe en særlig kortlægning eller snarere forbinde prikkerne

1024
01:11:40,000 --> 01:11:43,000
mellem et symbol og hvor den skal hen, en variabel navn

1025
01:11:43,000 --> 01:11:46,000
og hvor det kommer til at leve i hukommelsen.

1026
01:11:46,000 --> 01:11:50,000
Men det viser sig, at vi faktisk kan få adgang til det i vores programmer så godt.

1027
01:11:50,000 --> 01:11:55,000
Dette får betydning, når vi begynder at tale om nogle af de datastrukturer,

1028
01:11:55,000 --> 01:11:58,000
som er et koncept, som vi vil introducere senere.

1029
01:11:58,000 --> 01:12:09,000
>> Men for nu, er, hvad du kan vide, at jeg kan oprette en pegepind til denne placering, x.

1030
01:12:09,000 --> 01:12:12,000
For eksempel kan jeg oprette en pointer variabel.

1031
01:12:12,000 --> 01:12:16,000
Når vi opretter en pointer variabel bruger vi stjernen notation.

1032
01:12:16,000 --> 01:12:21,000
I dette tilfælde siger, at dette jeg har tænkt mig at oprette en pegepind til en int.

1033
01:12:21,000 --> 01:12:24,000
Det er en type, ligesom alle andre.

1034
01:12:24,000 --> 01:12:27,000
Vi giver det en variabel som y,

1035
01:12:27,000 --> 01:12:32,000
og så satte vi det lige til adressen, til en adresse.

1036
01:12:32,000 --> 01:12:38,000
I dette tilfælde kan vi sætte y til at pege på x

1037
01:12:38,000 --> 01:12:43,000
ved at tage adressen på x, som vi gør med denne tegnet,

1038
01:12:43,000 --> 01:12:55,000
og så satte vi y til at pege på den.

1039
01:12:55,000 --> 01:12:59,000
Hvad dette hovedsagelig gør, er, hvis vi ser på vores RAM

1040
01:12:59,000 --> 01:13:02,000
dette skaber en separat variabel.

1041
01:13:02,000 --> 01:13:04,000
Det kommer til at kalde det y,

1042
01:13:04,000 --> 01:13:06,000
og når denne linje kode henretter

1043
01:13:06,000 --> 01:13:13,000
det er faktisk kommer til at skabe en lille pointer, som vi typisk trække så en pil,

1044
01:13:13,000 --> 01:13:15,000
og det sætter y til at pege 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 pegepind, ville du bare gøre

1047
01:13:19,000 --> 01:13:22,000
int * y = x i stedet for at have 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 pointer, så du kan indstille 2 pointers svarende til hinanden,

1050
01:13:27,000 --> 01:13:30,000
i hvilket tilfælde y ville ikke pege på x,

1051
01:13:30,000 --> 01:13:34,000
men det ville pege på, hvad x peger på.

1052
01:13:34,000 --> 01:13:37,000
Vi kan desværre for sent.

1053
01:13:37,000 --> 01:13:44,000
>> Hvad jeg ville sige på nuværende tidspunkt, kan vi tale om det offline,

1054
01:13:44,000 --> 01:13:49,000
men jeg vil sige begynde at arbejde gennem dette problem, # 14.

1055
01:13:49,000 --> 01:13:53,000
Du kan se der er allerede en lille smule udfyldt for dig her.

1056
01:13:53,000 --> 01:13:57,000
Du kan se, at når vi erklærer 2 pointere, int * x og * y,

1057
01:13:57,000 --> 01:14:01,000
og bemærk, at pege * ved siden af ​​den variable var noget, der blev gjort sidste år.

1058
01:14:01,000 --> 01:14:05,000
Det viser sig, at dette svarer til, hvad vi gør i år.

1059
01:14:05,000 --> 01:14:11,000
Det betyder ikke noget, hvor du skriver *, når du erklære markøren.

1060
01:14:11,000 --> 01:14:17,000
Men vi har skrevet * ud for den type

1061
01:14:17,000 --> 01:14:24,000
fordi det gør det meget klart, at du erklære en pointer variabel.

1062
01:14:24,000 --> 01:14:27,000
Du kan se at erklære de 2 pointere giver os 2 æsker.

1063
01:14:27,000 --> 01:14:31,000
Her når vi sætter x lig med malloc

1064
01:14:31,000 --> 01:14:34,000
hvad dette siger er at afsætte hukommelse i bunke.

1065
01:14:34,000 --> 01:14:41,000
Denne lille boks lige her, denne cirkel, er placeret på den bunke.

1066
01:14:41,000 --> 01:14:43,000
X peger på den.

1067
01:14:43,000 --> 01:14:46,000
Bemærk, at y stadig ikke peger på noget.

1068
01:14:46,000 --> 01:14:50,000
For at få hukommelse til at gemme nummer 42 i x

1069
01:14:50,000 --> 01:14:55,000
vi ville bruge, hvad notation?

1070
01:14:55,000 --> 01:14:59,000
[Student] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Præcis, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
Det betyder, følg pilen, og smide 42 derinde.

1073
01:15:06,000 --> 01:15:09,000
Her hvor vi sætter y og x har vi y peger på x.

1074
01:15:09,000 --> 01:15:13,000
Igen, dette ligesom hvad Kevin sagde, hvor vi sat y lig x.

1075
01:15:13,000 --> 01:15:15,000
Y ikke er rettet til x.

1076
01:15:15,000 --> 01:15:19,000
Snarere er det at pege på, hvad x peger på så godt.

1077
01:15:19,000 --> 01:15:24,000
>> Og så til sidst i denne sidste kasse er der 2 mulige ting, vi kunne gøre.

1078
01:15:24,000 --> 01:15:28,000
Den ene er, at vi kunne sige * x = 13.

1079
01:15:28,000 --> 01:15:33,000
Den anden ting er, at vi kunne sige-Alex, ved du hvad vi kunne gøre her?

1080
01:15:33,000 --> 01:15:37,000
Man kan sige * x = 13 or-

1081
01:15:37,000 --> 01:15:41,000
[Student] Man kan sige int whatever.

1082
01:15:41,000 --> 01:15:45,000
[Nate H.] Hvis dette blev omtalt som en int variabel vi kunne gøre det.

1083
01:15:45,000 --> 01:15:49,000
Vi kunne også sige * y = 13, fordi de er begge peger på den samme plads,

1084
01:15:49,000 --> 01:15:51,000
så vi kunne bruge enten variabel til derhen.

1085
01:15:51,000 --> 01:15:56,000
Ja. >> [Student] Hvad ville det se ud, hvis vi bare sige int x er 13?

1086
01:15:56,000 --> 01:16:00,000
Det ville være at erklære en ny variabel kaldet x, som ikke ville virke.

1087
01:16:00,000 --> 01:16:04,000
Vi ville have en kollision, fordi vi erklæret x at være en pegepind op her.

1088
01:16:04,000 --> 01:16:10,000
[Student] Hvis vi bare havde denne udtalelse af sig selv, hvad ville det se ud i forhold til cirklen?

1089
01:16:10,000 --> 01:16:14,000
Hvis vi havde x = 13 så ville vi have en kasse, og snarere end at have en pil

1090
01:16:14,000 --> 01:16:16,000
kommer ud af boksen, vi ville trække det som bare en 13.

1091
01:16:16,000 --> 01:16:19,000
[Student] I kassen. Okay.

1092
01:16:19,000 --> 01:16:24,000
>> Tak for at se, og held og lykke på Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]