1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Avsnitt 4] [mindre bekväm]

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

3
00:00:04,000 --> 00:00:07,000
[Detta är CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Okej, välkommen tillbaka till avsnitt.

5
00:00:10,000 --> 00:00:13,000
I denna veckas avsnitt ska vi göra ett par saker.

6
00:00:13,000 --> 00:00:17,000
Vi kommer till det första återblick problembild 2,

7
00:00:17,000 --> 00:00:20,000
vilket är Caesar och Vigenère problembild.

8
00:00:20,000 --> 00:00:23,000
Och sedan ska vi dyka in Quiz 0 omdöme

9
00:00:23,000 --> 00:00:26,000
och spendera lite tid regummering vad vi har pratat om

10
00:00:26,000 --> 00:00:30,000
i varje föreläsningarna hittills, och vi kommer också att göra några problem

11
00:00:30,000 --> 00:00:32,000
från föregående års frågesporter.

12
00:00:32,000 --> 00:00:36,000
På så sätt ni har ett bra sätt att förbereda sig för detta.

13
00:00:36,000 --> 00:00:40,000
>> Till att börja, jag startat upp ett par bra lösningar

14
00:00:40,000 --> 00:00:45,000
för föregående problemet inställd, ställ Problem 2, i detta utrymme.

15
00:00:45,000 --> 00:00:48,000
Om ni träffa alla här länken,

16
00:00:48,000 --> 00:00:53,000
och om du klickar på mitt namn och klicka på min första översyn

17
00:00:53,000 --> 00:00:56,000
ser du caesar.c, vilket är exakt vad jag tittar på.

18
00:00:56,000 --> 00:01:00,000
Låt oss tala om det här verkligen snabbt.

19
00:01:00,000 --> 00:01:02,000
Detta är bara en provlösning.

20
00:01:02,000 --> 00:01:05,000
Detta är inte nödvändigtvis den perfekta lösningen.

21
00:01:05,000 --> 00:01:08,000
Det finns många olika sätt att skriva detta,

22
00:01:08,000 --> 00:01:10,000
men det finns några saker som jag ville lyfta fram

23
00:01:10,000 --> 00:01:13,000
som jag såg när jag klassificering, vanliga misstag som jag tror

24
00:01:13,000 --> 00:01:18,000
denna lösning gör ett mycket bra jobb med hantering.

25
00:01:18,000 --> 00:01:22,000
>> Den första är att ha någon form av header kommentar längst upp.

26
00:01:22,000 --> 00:01:25,000
På linjerna 1 till 7 du ser detaljer,

27
00:01:25,000 --> 00:01:28,000
exakt vad detta program gör.

28
00:01:28,000 --> 00:01:32,000
En god praxis när du skriver C-kod

29
00:01:32,000 --> 00:01:35,000
oavsett om ditt program finns i en enda fil eller

30
00:01:35,000 --> 00:01:38,000
oavsett om det är delad över flera filer är att ha någon form av

31
00:01:38,000 --> 00:01:40,000
orientera kommentaren överst.

32
00:01:40,000 --> 00:01:43,000
Det är också för människor som går ut och skriva kod i den verkliga världen.

33
00:01:43,000 --> 00:01:47,000
Det är där de sätter copyrightinformation.

34
00:01:47,000 --> 00:01:50,000
Nedan är # omfattar.

35
00:01:50,000 --> 00:01:55,000
På rad 16 finns det # define, som vi ska återkomma till i bara lite.

36
00:01:55,000 --> 00:01:59,000
Och sedan när funktionen startar när stora starter,

37
00:01:59,000 --> 00:02:03,000
eftersom detta program har alla i en enda funktion

38
00:02:03,000 --> 00:02:09,000
den allra första som händer, och detta är mycket idiomatisk och typiskt för ett C-program

39
00:02:09,000 --> 00:02:14,000
som tar i kommandoraden argument, är att det omedelbart kontrollerar

40
00:02:14,000 --> 00:02:18,000
>> för argumentet räkna, argc.

41
00:02:18,000 --> 00:02:24,000
Just här ser vi att detta program väntar 2 argument exakt.

42
00:02:24,000 --> 00:02:27,000
Kom ihåg att det är det första argumentet som är det speciella en

43
00:02:27,000 --> 00:02:29,000
det är alltid namnet på det program som är körs,

44
00:02:29,000 --> 00:02:31,000
Namnet på den körbara filen.

45
00:02:31,000 --> 00:02:36,000
Och så vad detta innebär är det förhindrar användaren från att köra programmet

46
00:02:36,000 --> 00:02:42,000
med fler eller färre argument.

47
00:02:42,000 --> 00:02:44,000
Anledningen till att vi vill kontrollera detta direkt beror

48
00:02:44,000 --> 00:02:52,000
Vi kan faktiskt inte komma åt denna argv array här tillförlitligt

49
00:02:52,000 --> 00:02:55,000
tills vi har kontrollerat att se hur stort det är.

50
00:02:55,000 --> 00:02:58,000
>> En av de vanligaste felen jag såg var människor omedelbart skulle gå i

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

52
00:03:01,000 --> 00:03:06,000
De skulle ta nyckeln argumentet ur matrisen och gör en till jag kolla på det,

53
00:03:06,000 --> 00:03:11,000
och då de skulle göra testet för argc samt nästa test,

54
00:03:11,000 --> 00:03:16,000
huruvida eller inte den första argumentet verkligen var ett heltal på samma gång,

55
00:03:16,000 --> 00:03:20,000
och det inte fungerar eftersom det i fall att det inte finns några medföljande argument

56
00:03:20,000 --> 00:03:26,000
du kommer att ta tag ett argument som inte finns eller försöker ta en som inte finns.

57
00:03:26,000 --> 00:03:29,000
>> Den andra stora sak som du kommer att märka är att

58
00:03:29,000 --> 00:03:32,000
du alltid vill skriva ut någon form av hjälp felmeddelande

59
00:03:32,000 --> 00:03:34,000
till användaren att orientera dem.

60
00:03:34,000 --> 00:03:37,000
Jag är säker på att du har alla köra program där plötsligt kraschar,

61
00:03:37,000 --> 00:03:41,000
och du får denna löjliga lilla dialogrutan som dyker upp och säger

62
00:03:41,000 --> 00:03:44,000
något fruktansvärt kryptiska och kanske ger dig en felkod eller något liknande

63
00:03:44,000 --> 00:03:47,000
som är meningslöst.

64
00:03:47,000 --> 00:03:50,000
Det är där du verkligen vill ge något till hjälp

65
00:03:50,000 --> 00:03:54,000
och riktade till användaren så att när de kör det de går "Åh," ansikte palm.

66
00:03:54,000 --> 00:03:58,000
"Jag vet precis vad jag ska göra. Jag vet hur man fixar det här."

67
00:03:58,000 --> 00:04:01,000
>> Om du inte skriver ut ett meddelande, då du hamna faktiskt

68
00:04:01,000 --> 00:04:04,000
lämnar användaren att gå undersöka din källkod

69
00:04:04,000 --> 00:04:07,000
att räkna ut vad som gick fel.

70
00:04:07,000 --> 00:04:11,000
Det finns också några gånger som du använder olika felkoder.

71
00:04:11,000 --> 00:04:14,000
Här har vi använt bara en för att säga att det var ett misstag,

72
00:04:14,000 --> 00:04:16,000
Det uppstod ett fel, det var ett fel.

73
00:04:16,000 --> 00:04:20,000
Större program, ofta program som anropas av andra program,

74
00:04:20,000 --> 00:04:25,000
kommer tillbaka någon form av särskilda felkoder i olika scenarier

75
00:04:25,000 --> 00:04:28,000
att programmässigt kommunicera vad du annars skulle

76
00:04:28,000 --> 00:04:32,000
bara använda en trevlig engelsk meddelande för.

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

78
00:04:35,000 --> 00:04:37,000
Eftersom vi arbetar ner, kan du se att vi drar nyckeln ut.

79
00:04:37,000 --> 00:04:40,000
Vi testar för att se om nyckeln passar.

80
00:04:40,000 --> 00:04:42,000
Vi får ett meddelande från användaren.

81
00:04:42,000 --> 00:04:46,000
Anledningen till att vi gör det i den här göra medan loop-och detta är något som vi kommer att täcka

82
00:04:46,000 --> 00:04:50,000
i lite-men det visar sig att om du skriver kontroll D

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

84
00:04:54,000 --> 00:04:59,000
vad det faktiskt gör det skickar en speciell karaktär

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

86
00:05:01,000 --> 00:05:05,000
Det kallas ELF eller slutet av filen karaktär.

87
00:05:05,000 --> 00:05:08,000
Och i så fall kommer vårt budskap sträng vara null,

88
00:05:08,000 --> 00:05:14,000
så detta var inte något vi kontrollerat i problemet satt.

89
00:05:14,000 --> 00:05:17,000
>> Men när vi går vidare, nu när vi har börjat prata om pekare

90
00:05:17,000 --> 00:05:21,000
och dynamisk minnesallokering på högen,

91
00:05:21,000 --> 00:05:25,000
kontroll av null när du har en funktion som skulle kunna

92
00:05:25,000 --> 00:05:30,000
returnera null som ett värde är något som du kommer att vilja få en vana att göra.

93
00:05:30,000 --> 00:05:33,000
Detta är här främst för illustration.

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

95
00:05:36,000 --> 00:05:41,000
så från problembild 4 på, men du vill ha detta i åtanke.

96
00:05:41,000 --> 00:05:44,000
Återigen, detta är inte en fråga för problembild 3 antingen eftersom vi inte hade täckt det ännu.

97
00:05:44,000 --> 00:05:53,000
Slutligen får vi till denna del där vi får den huvudsakliga kryptering slingan,

98
00:05:53,000 --> 00:05:57,000
och det finns ett par saker som pågår här.

99
00:05:57,000 --> 00:06:02,000
Först iterera vi över hela meddelandet strängen själv.

100
00:06:02,000 --> 00:06:07,000
Här har vi hållit strlen samtalet i tillståndet,

101
00:06:07,000 --> 00:06:12,000
som flera av er har påpekat är inte ett bra sätt att gå.

102
00:06:12,000 --> 00:06:15,000
Det visar sig i det här fallet är det inte heller bra,

103
00:06:15,000 --> 00:06:20,000
dels för att vi ändrar innehållet i själva meddelandet

104
00:06:20,000 --> 00:06:27,000
innanför for-slingan, så om vi har ett budskap som är 10 tecken långa,

105
00:06:27,000 --> 00:06:32,000
första gången vi startar att för slingan strlen kommer tillbaka vad?

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

107
00:06:35,000 --> 00:06:40,000
>> Men om vi sedan ändra budskap, säger vi ändra sitt 5:e karaktär,

108
00:06:40,000 --> 00:06:46,000
och vi slänger i en \ 0 tecken i den 5: e positionen,

109
00:06:46,000 --> 00:06:49,000
på en senare upprepning strlen (meddelande) inte kommer att återvända vad det gjorde

110
00:06:49,000 --> 00:06:52,000
första gången vi upprepade,

111
00:06:52,000 --> 00:06:56,000
men det kommer i stället tillbaka 5 eftersom vi kastade i den null terminator,

112
00:06:56,000 --> 00:06:59,000
och strängens längd definieras

113
00:06:59,000 --> 00:07:03,000
av läget för att \ 0.

114
00:07:03,000 --> 00:07:09,000
I det här fallet, är detta ett bra sätt att gå eftersom vi ändrar den på plats.

115
00:07:09,000 --> 00:07:13,000
Men du märker att detta är faktiskt förvånansvärt enkelt att kryptera

116
00:07:13,000 --> 00:07:16,000
om du kan få matten korrekt.

117
00:07:16,000 --> 00:07:19,000
Allt som krävs är att kontrollera huruvida det brev som du tittar på

118
00:07:19,000 --> 00:07:21,000
är versaler eller gemener.

119
00:07:21,000 --> 00:07:24,000
>> Anledningen till att vi bara behöver kontrollera det och vi behöver inte kontrollera

120
00:07:24,000 --> 00:07:27,000
det är alfa fallet beror

121
00:07:27,000 --> 00:07:30,000
Om ett tecken är versaler eller om det är gemener

122
00:07:30,000 --> 00:07:33,000
då är det definitivt en bokstav,

123
00:07:33,000 --> 00:07:38,000
eftersom vi inte har stora och små siffror.

124
00:07:38,000 --> 00:07:41,000
Den andra saken som vi gör-och det är lite knepigt,

125
00:07:41,000 --> 00:07:45,000
är att vi har ändrat standard Caesar chiffer formel

126
00:07:45,000 --> 00:07:49,000
att vi gav i problemet inställda specifikationen.

127
00:07:49,000 --> 00:07:52,000
Vad är annorlunda här är att vi subtraheras

128
00:07:52,000 --> 00:07:58,000
i versaler fall kapital A, och sedan vi lagt kapital A

129
00:07:58,000 --> 00:08:02,000
tillbaka i slutet.

130
00:08:02,000 --> 00:08:05,000
>> Jag känner några av er har gjort detta i din kod.

131
00:08:05,000 --> 00:08:09,000
Har någon av er gör detta i era synpunkter?

132
00:08:09,000 --> 00:08:13,000
Du gjorde det här. Kan du förklara vad detta innebär, Sahb?

133
00:08:13,000 --> 00:08:18,000
Genom att subtrahera det, eftersom du gjorde en mod direkt efter det,

134
00:08:18,000 --> 00:08:21,000
du måste ta ut, så på det sättet får du [hosta] läge.

135
00:08:21,000 --> 00:08:25,000
Och sedan genom att lägga tillbaka senare du skiftat över den du ville ha.

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

137
00:08:27,000 --> 00:08:32,000
Vad Sahb sade var att när vi vill lägga

138
00:08:32,000 --> 00:08:36,000
vårt budskap och vår nyckel tillsammans

139
00:08:36,000 --> 00:08:42,000
och sedan mod att mod att genom NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
om vi inte skala vårt budskap i rätt 0 till 25 intervall först,

141
00:08:50,000 --> 00:08:54,000
då kan vi i slutändan får en riktigt konstig nummer

142
00:08:54,000 --> 00:08:59,000
eftersom de värderingar som vi tittar på när vi tittar på meddelande [i],

143
00:08:59,000 --> 00:09:03,000
när vi tittar på den i: te karaktär vår vanlig textmeddelande,

144
00:09:03,000 --> 00:09:08,000
är ett värde någonstans i detta 65 till 122 intervall

145
00:09:08,000 --> 00:09:13,000
baserat på ASCII-värden för versaler A genom gemener z..

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

147
00:09:18,000 --> 00:09:23,000
eftersom det var vår # define längst upp till höger här uppe,

148
00:09:23,000 --> 00:09:28,000
det kommer att ge oss ett värde som är i 0 till 25 intervall,

149
00:09:28,000 --> 00:09:30,000
och vi behöver ett sätt att sedan skala som backup

150
00:09:30,000 --> 00:09:32,000
och få den i rätt ASCII området.

151
00:09:32,000 --> 00:09:36,000
Det enklaste sättet att göra det är att bara skala ned allt

152
00:09:36,000 --> 00:09:39,000
i 0 till 25 intervall till att börja med,

153
00:09:39,000 --> 00:09:43,000
och sedan flytta tillbaka allt i slutet.

154
00:09:43,000 --> 00:09:46,000
>> Ett annat vanligt fel som jag såg människor stöter är att

155
00:09:46,000 --> 00:09:50,000
om du inte verkligen göra detta skalning direkt

156
00:09:50,000 --> 00:09:53,000
och du lägger och skriv tillsammans och du lägger till dem, säg,

157
00:09:53,000 --> 00:09:58,000
till en röding variabel problemet med att

158
00:09:58,000 --> 00:10:01,000
är sedan meddelande [i] är en relativt stort antal att börja med,

159
00:10:01,000 --> 00:10:05,000
kom ihåg det är minst 65, om det är en versal tecken-

160
00:10:05,000 --> 00:10:09,000
om du har en stor nyckel, säg, något som 100,

161
00:10:09,000 --> 00:10:13,000
och du lägger dem 2 ihop till en undertecknad röding du kommer att få ett överflöd.

162
00:10:13,000 --> 00:10:17,000
Du kommer att få ett värde som är större än 127,

163
00:10:17,000 --> 00:10:22,000
vilket är det största värdet som en CHAR-variabel kan hålla.

164
00:10:22,000 --> 00:10:26,000
Återigen, det är därför du skulle vilja göra sånt till att börja med.

165
00:10:26,000 --> 00:10:29,000
Vissa människor fick runt det fallet genom att göra en om annat och testa

166
00:10:29,000 --> 00:10:33,000
för att se om det skulle svämma över innan du gör det,

167
00:10:33,000 --> 00:10:36,000
men detta sätt får runt det.

168
00:10:36,000 --> 00:10:40,000
Och sedan i denna lösning vi skrivs ut hela strängen i slutet.

169
00:10:40,000 --> 00:10:45,000
Andra människor skrivs ut ett tecken i taget. Båda är fantastisk.

170
00:10:45,000 --> 00:10:51,000
Vid denna punkt, gör ni har några frågor, några kommentarer om detta?

171
00:10:51,000 --> 00:10:56,000
Saker du gillar, saker du inte gillar?

172
00:10:56,000 --> 00:10:58,000
>> Jag hade en fråga.

173
00:10:58,000 --> 00:11:01,000
Jag kanske missade det under din förklaring, men hur går det här programmet

174
00:11:01,000 --> 00:11:07,000
hoppa över utrymmena för anslutning av nyckeln till textens längd?

175
00:11:07,000 --> 00:11:10,000
Detta är bara Caesar chiffer. >> Förlåt, ja.

176
00:11:10,000 --> 00:11:13,000
Ja, vi ser det.

177
00:11:13,000 --> 00:11:16,000
I Caesar chiffer vi fick runt att eftersom

178
00:11:16,000 --> 00:11:18,000
Vi vände bara tecken.

179
00:11:18,000 --> 00:11:27,000
Vi roterade bara dem om de var stora eller små bokstäver.

180
00:11:27,000 --> 00:11:32,000
Ni känner ganska bra om det här?

181
00:11:32,000 --> 00:11:34,000
Kopiera gärna detta hem, ta det,

182
00:11:34,000 --> 00:11:37,000
jämför det med vad ni skrev.

183
00:11:37,000 --> 00:11:42,000
Definitivt gärna skicka frågor om det också.

184
00:11:42,000 --> 00:11:46,000
Och återigen, inser att målet här med ditt problem sätter

185
00:11:46,000 --> 00:11:50,000
är inte att få er att skriva perfekt kod för ditt problem uppsättningar.

186
00:11:50,000 --> 00:11:57,000
Det är en lärorik erfarenhet. Ja.

187
00:11:57,000 --> 00:12:01,000
>> Tillbaka till DO WHILE loop, om det är lika med noll,

188
00:12:01,000 --> 00:12:06,000
så null betyder bara någonting, slog de bara in?

189
00:12:06,000 --> 00:12:12,000
Null är en speciell pekare värde,

190
00:12:12,000 --> 00:12:17,000
och vi använder noll när vi vill säga

191
00:12:17,000 --> 00:12:23,000
Vi har en pekare variabel som pekar på ingenting.

192
00:12:23,000 --> 00:12:28,000
Och så typiskt att det innebär att denna variabel, detta meddelande variabel

193
00:12:28,000 --> 00:12:35,000
är tom, och här, eftersom vi använder CS50 speciell sträng typ,

194
00:12:35,000 --> 00:12:37,000
vad är det CS50 sträng typ?

195
00:12:37,000 --> 00:12:42,000
Har du sett vad det är när David drog tillbaka huven i föreläsningen?

196
00:12:42,000 --> 00:12:44,000
Det är en funky, det är en pekare, eller hur?

197
00:12:44,000 --> 00:12:48,000
Okej, ja. >> Det är en char *.

198
00:12:48,000 --> 00:12:52,000
Och så verkligen att vi kunde ersätta denna

199
00:12:52,000 --> 00:12:56,000
här med char * meddelande

200
00:12:56,000 --> 00:13:04,000
och så GetString funktionen, om det inte lyckas få en sträng från användaren,

201
00:13:04,000 --> 00:13:08,000
det kan inte tolka en sträng, och ett fall där det inte kan tolka en sträng

202
00:13:08,000 --> 00:13:11,000
är om användaren skriver änden av fil karaktär, kontroll D,

203
00:13:11,000 --> 00:13:17,000
vilket inte är något man normalt gör, men om det händer

204
00:13:17,000 --> 00:13:20,000
då funktionen returnerar denna nollvärde som ett sätt att säga

205
00:13:20,000 --> 00:13:23,000
"Hej, jag fick inte en sträng".

206
00:13:23,000 --> 00:13:27,000
Vad skulle hända om vi inte sätter meddelande = null,

207
00:13:27,000 --> 00:13:30,000
vilket är något som vi inte har gjort ännu?

208
00:13:30,000 --> 00:13:32,000
Varför skulle det vara ett problem här?

209
00:13:32,000 --> 00:13:38,000
Eftersom jag vet att vi pratade lite i föreläsning om minnesläckor.

210
00:13:38,000 --> 00:13:42,000
Ja, låt oss göra det, och låt oss se vad som händer.

211
00:13:42,000 --> 00:13:44,000
>> Basil fråga var vad som händer om vi inte faktiskt har

212
00:13:44,000 --> 00:13:48,000
detta meddelande = null test?

213
00:13:48,000 --> 00:13:51,000
Låt oss bläddra upp till toppen.

214
00:13:51,000 --> 00:13:53,000
Ni kan kommentera detta.

215
00:13:53,000 --> 00:13:55,000
Egentligen, jag sparar det i en revision.

216
00:13:55,000 --> 00:13:58,000
Detta kommer att vara Revision 3.

217
00:13:58,000 --> 00:14:02,000
Vad du måste göra för att köra det här programmet är att du måste klicka på denna kugghjulsikonen här uppe,

218
00:14:02,000 --> 00:14:04,000
och du måste lägga till ett argument till det.

219
00:14:04,000 --> 00:14:10,000
Du måste ge den nyckeln argument eftersom vi vill gå på en kommandorad argument.

220
00:14:10,000 --> 00:14:13,000
Här kommer jag att ge den siffran 3. Jag gillar 3.

221
00:14:13,000 --> 00:14:19,000
Nu zoomar ut igen, kör programmet.

222
00:14:19,000 --> 00:14:24,000
Den körs, sammanställa, bygga.

223
00:14:24,000 --> 00:14:27,000
Nu kör vi. Det väntar på att bli tillfrågad.

224
00:14:27,000 --> 00:14:33,000
Om jag skriver in något i stil med Hello-där gick det?

225
00:14:33,000 --> 00:14:38,000
Åh, tog mitt program för lång tid att köra. Jag jawing för länge.

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

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

228
00:14:43,000 --> 00:14:46,000
Vi ser att det krypterar korrekt.

229
00:14:46,000 --> 00:14:52,000
Nu vad händer om vi gör snabb GetString att returnera null?

230
00:14:52,000 --> 00:14:57,000
Kom ihåg, jag sa att vi gjorde det genom att trycka på kontrollen D samtidigt.

231
00:14:57,000 --> 00:14:59,000
Jag bläddrar upp här. Vi kör det igen.

232
00:14:59,000 --> 00:15:01,000
Byggnad. Där det går.

233
00:15:01,000 --> 00:15:04,000
Nu när jag slog kontroll D

234
00:15:04,000 --> 00:15:12,000
Jag fick denna linje som säger opt/sandbox50/bin/run.sh, segmenteringsfel.

235
00:15:12,000 --> 00:15:15,000
Har ni sett det förut?

236
00:15:15,000 --> 00:15:17,000
>> [Student] Varför finns det ingen->> Ursäkta?

237
00:15:17,000 --> 00:15:20,000
[Student] Varför finns det ingen core dump i detta fall?

238
00:15:20,000 --> 00:15:26,000
Kärnan dump är-frågan är varför finns det ingen core dump här?

239
00:15:26,000 --> 00:15:29,000
Frågan är att det kan finnas, men kärnan dumpa är en fil

240
00:15:29,000 --> 00:15:31,000
som får lagras på hårddisken.

241
00:15:31,000 --> 00:15:34,000
I det här fallet har vi inaktiverat minnesdumpar

242
00:15:34,000 --> 00:15:37,000
på flykt servern så att vi inte har människor seg förkastningar

243
00:15:37,000 --> 00:15:40,000
och bygga upp massor av centrala soptippar.

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

245
00:15:46,000 --> 00:15:48,000
Minnesdumpar är det slags saker som du kan ofta inaktivera,

246
00:15:48,000 --> 00:15:52,000
och ibland gör.

247
00:15:52,000 --> 00:15:55,000
Den segmenteringsfel, att svara på din fråga, basilika,

248
00:15:55,000 --> 00:16:00,000
säger att vi försökte få tillgång till en pekare

249
00:16:00,000 --> 00:16:05,000
som inte var inställd att peka på något.

250
00:16:05,000 --> 00:16:09,000
Tänk Binky i videon när Binky försöker

251
00:16:09,000 --> 00:16:12,000
gå åt en pekare som inte är att peka på något?

252
00:16:12,000 --> 00:16:16,000
I det här fallet antar jag tekniskt pekaren pekar på något.

253
00:16:16,000 --> 00:16:20,000
Det pekar på null, vilket är tekniskt 0,

254
00:16:20,000 --> 00:16:25,000
men som är definierad att vara i ett segment som inte är tillgänglig

255
00:16:25,000 --> 00:16:28,000
av ditt program, så att du får ett segmenteringsfel

256
00:16:28,000 --> 00:16:31,000
eftersom du inte tillgång till minne som är i en giltig segment

257
00:16:31,000 --> 00:16:38,000
som heap segmentet eller stapeln segmentet eller datasegmentet.

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

259
00:16:40,000 --> 00:16:48,000
Några fler frågor om Caesar?

260
00:16:48,000 --> 00:16:51,000
>> Låt oss gå vidare. Låt oss titta på Revision 2 riktigt snabbt.

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

262
00:17:00,000 --> 00:17:04,000
Här i Vigenère

263
00:17:04,000 --> 00:17:06,000
Vi kommer att gå igenom detta en ganska snabbt eftersom, återigen,

264
00:17:06,000 --> 00:17:10,000
Vigenère och Caesar är ganska lika.

265
00:17:10,000 --> 00:17:12,000
Header kommentar är innan,

266
00:17:12,000 --> 00:17:17,000
# Define är före att undvika att använda dessa magiska nummer.

267
00:17:17,000 --> 00:17:21,000
Det fina är att säga att vi ville flytta till

268
00:17:21,000 --> 00:17:23,000
ett annat alfabet eller något liknande.

269
00:17:23,000 --> 00:17:26,000
Hellre än att behöva gå manuellt ändra alla 26-talet i koden

270
00:17:26,000 --> 00:17:30,000
Vi kan ändra det till 27 eller släppa ner

271
00:17:30,000 --> 00:17:34,000
om vi använde olika alfabet, olika språk.

272
00:17:34,000 --> 00:17:38,000
Återigen, vi har denna kontroll av argumentet räkna,

273
00:17:38,000 --> 00:17:42,000
och verkligen kan du nästan ta detta som en mall.

274
00:17:42,000 --> 00:17:46,000
Ganska mycket alla program du skriver ska ha,

275
00:17:46,000 --> 00:17:50,000
om det tar kommandoradsargument-vissa sekvens av linjer

276
00:17:50,000 --> 00:17:55,000
som lyder så här i början.

277
00:17:55,000 --> 00:17:59,000
Det är en av de första sanity tester du vill göra.

278
00:17:59,000 --> 00:18:03,000
>> Här är vad vi gjorde var att vi såg till att

279
00:18:03,000 --> 00:18:06,000
nyckelordet var giltig, och det var den andra kontrollen som vi gjorde.

280
00:18:06,000 --> 00:18:11,000
Notera igen att vi separerade det från argc och 2.

281
00:18:11,000 --> 00:18:14,000
Notera att i detta fall en sak som vi hade att göra var istället

282
00:18:14,000 --> 00:18:18,000
att använda en till jag vi ville att validera hela strängen,

283
00:18:18,000 --> 00:18:21,000
och för att göra det du faktiskt måste gå tecken för tecken

284
00:18:21,000 --> 00:18:23,000
över strängen.

285
00:18:23,000 --> 00:18:29,000
Det finns inget bra sätt att kalla något på det

286
00:18:29,000 --> 00:18:31,000
eftersom även, till exempel, en till jag återkommer 0

287
00:18:31,000 --> 00:18:37,000
om det inte kan tolka ett heltal, så att inte ens fungerar.

288
00:18:37,000 --> 00:18:42,000
Återigen, trevlig meddelande om att användaren exakt vad som hände.

289
00:18:42,000 --> 00:18:45,000
Då här, igen, hanterar vi även fallet när

290
00:18:45,000 --> 00:18:50,000
användaren skriver i en kontroll D slumpmässig karaktär.

291
00:18:50,000 --> 00:18:54,000
>> Och sedan Charlotte hade en fråga tidigare om hur vi lyckas hoppa utrymmen

292
00:18:54,000 --> 00:18:57,000
i vår sträng här.

293
00:18:57,000 --> 00:19:00,000
Detta var typ av liknar vad vi gjorde med Myspace programmet

294
00:19:00,000 --> 00:19:04,000
som vi gjorde i snitt och hur detta fungerat

295
00:19:04,000 --> 00:19:08,000
är att vi spårade antalet bokstäver som vi hade sett.

296
00:19:08,000 --> 00:19:13,000
När vi gick över meddelandet strängen, som vi gick över tecken för tecken,

297
00:19:13,000 --> 00:19:16,000
Vi spårade index som en del av vår for-slinga, och sedan vi också spåras

298
00:19:16,000 --> 00:19:21,000
antalet bokstäver, så icke-specialtecken, icke-siffror, icke-vita rymden

299
00:19:21,000 --> 00:19:27,000
att vi hade sett i separat variabel.

300
00:19:27,000 --> 00:19:33,000
Och därefter denna lösning ändrar nyckeln

301
00:19:33,000 --> 00:19:41,000
att få en verklig nyckel heltal, och det gör att i farten,

302
00:19:41,000 --> 00:19:47,000
precis innan det går då att kryptera själva meddelandet karaktär.

303
00:19:47,000 --> 00:19:50,000
Det finns några lösningar som var helt bra också

304
00:19:50,000 --> 00:19:58,000
som skulle ändra uppåt när man testar för nyckeln giltighet.

305
00:19:58,000 --> 00:20:01,000
Förutom att se till att karaktär och sökordet

306
00:20:01,000 --> 00:20:05,000
var en bokstav visade det sig också att till ett heltal

307
00:20:05,000 --> 00:20:13,000
i 0 till 25 intervall för att sedan hoppa behöva göra det senare i detta for-slinga.

308
00:20:13,000 --> 00:20:18,000
Återigen ser du här detta är verkligen exakt samma kod

309
00:20:18,000 --> 00:20:22,000
som vi använde i Caesar vid denna punkt.

310
00:20:22,000 --> 00:20:25,000
Du gör exakt samma sak, så det verkliga tricket är att räkna ut

311
00:20:25,000 --> 00:20:30,000
hur du aktiverar sökordet till ett heltal.

312
00:20:30,000 --> 00:20:35,000
>> En sak som vi gjorde här som är lite tät

313
00:20:35,000 --> 00:20:39,000
är vi upprepade denna fras, antar jag att du kan kalla det,

314
00:20:39,000 --> 00:20:45,000
3 separata gånger på ledningarna 58, 59, och 61.

315
00:20:45,000 --> 00:20:52,000
Kan någon förklara vad exakt denna fras gör?

316
00:20:52,000 --> 00:20:55,000
Det öppna en karaktär, som du sa.

317
00:20:55,000 --> 00:20:59,000
Ja, det är [ohörbart] ett tecken i sökordet,

318
00:20:59,000 --> 00:21:04,000
och så det är många sett bokstäver eftersom du bara rör sig längs

319
00:21:04,000 --> 00:21:06,000
nyckelordet när du har sett brevet,

320
00:21:06,000 --> 00:21:10,000
så det kommer att effektivt hoppa utrymmen och sånt.

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

322
00:21:12,000 --> 00:21:16,000
Och sedan när du har sett sökordet tomt du bara mod så du flyttar tillbaka runt.

323
00:21:16,000 --> 00:21:18,000
Exakt. Det är en perfekt förklaring.

324
00:21:18,000 --> 00:21:23,000
Vad Kevin sa att vi vill indexera i sökordet.

325
00:21:23,000 --> 00:21:28,000
Vi vill få num_letters_seen karaktär, om du vill,

326
00:21:28,000 --> 00:21:32,000
men om num_letters_seen överskrider längden på sökordet,

327
00:21:32,000 --> 00:21:37,000
hur vi får tillbaka i rätt område är vi använder mod operatören

328
00:21:37,000 --> 00:21:40,000
att effektivt linda runt.

329
00:21:40,000 --> 00:21:43,000
Till exempel, som i korthet är vår sökord bacon,

330
00:21:43,000 --> 00:21:46,000
och det är 5 bokstäver långa.

331
00:21:46,000 --> 00:21:50,000
Men vi har sett 6 bokstäver i vår klartext på denna punkt

332
00:21:50,000 --> 00:21:52,000
och krypterade 6.

333
00:21:52,000 --> 00:21:57,000
Vi kommer att hamna tillgång till num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
vilket är 6, mod längden av nyckelordet, 5,

335
00:22:00,000 --> 00:22:04,000
så vi får 1, och så vad vi ska göra är att vi ska

336
00:22:04,000 --> 00:22:14,000
tillgång till första tecknet på insidan av vår sökord på den punkten.

337
00:22:14,000 --> 00:22:21,000
>> Okej, alla frågor om Vigenère

338
00:22:21,000 --> 00:22:26,000
innan vi går vidare?

339
00:22:26,000 --> 00:22:31,000
Ni känner ganska bra om det här?

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

341
00:22:35,000 --> 00:22:38,000
Jag vill vara säker på att ni får chansen att se kod

342
00:22:38,000 --> 00:22:48,000
som vi tror ser bra ut och har chansen att lära av det.

343
00:22:48,000 --> 00:22:53,000
Detta kommer att bli det sista vi kommer att använda utrymmen för närvarande,

344
00:22:53,000 --> 00:22:59,000
och vi kommer att övergången nu, och jag ska gå till cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
så att vi kan göra lite frågesport översyn.

346
00:23:06,000 --> 00:23:10,000
Det bästa sättet tror jag att börja göra frågesport recension

347
00:23:10,000 --> 00:23:15,000
är att komma till denna Föreläsningar sidan, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
och under varje vecka rubriker, så om jag ser här vid vecka 0,

349
00:23:20,000 --> 00:23:27,000
Jag ser att vi har en lista över ämnen som vi täckt i vecka 0.

350
00:23:27,000 --> 00:23:31,000
>> Om någon av dessa frågor verkar obekant för dig

351
00:23:31,000 --> 00:23:34,000
du definitivt vill gå tillbaka och skura föreläsningsanteckningar och eventuellt

352
00:23:34,000 --> 00:23:39,000
även skumma igenom föreläsningar, titta på dem igen om du vill

353
00:23:39,000 --> 00:23:44,000
att få en känsla för vad som händer med vart och ett av ämnena.

354
00:23:44,000 --> 00:23:49,000
Jag kommer att säga ytterligare i år en av de coola resurser vi har fått

355
00:23:49,000 --> 00:23:55,000
är dessa shorts som vi har skapat, och om man tittar på vecka 0,

356
00:23:55,000 --> 00:24:00,000
vi har inte alla de ämnen som behandlas, men vi har en hel del av dem,

357
00:24:00,000 --> 00:24:03,000
några av de knepigaste sådana, så titta på dessa shorts igen

358
00:24:03,000 --> 00:24:08,000
är ett bra sätt att få dig upp till hastigheten.

359
00:24:08,000 --> 00:24:15,000
I synnerhet kommer jag att sätta i en plugg för 3 på botten, eftersom jag gjorde dem.

360
00:24:15,000 --> 00:24:20,000
Men om du kämpar med binära, bitar, hex, den sortens saker,

361
00:24:20,000 --> 00:24:22,000
binär är ett bra ställe att börja.

362
00:24:22,000 --> 00:24:25,000
ASCII är en annan som är bra att visa också.

363
00:24:25,000 --> 00:24:31,000
Du kan även titta på mig på 1.5x hastighet om jag går för långsamt för dig.

364
00:24:31,000 --> 00:24:35,000
Eftersom det är recension, gärna göra det.

365
00:24:35,000 --> 00:24:40,000
>> Bara att börja riktigt snabbt, kommer vi att gå igenom ett par av dessa frågesport problem

366
00:24:40,000 --> 00:24:44,000
bara för att snabbt pressa igenom dessa.

367
00:24:44,000 --> 00:24:50,000
Till exempel, låt oss titta på problemet 16 att jag har rätt här uppe på bordet.

368
00:24:50,000 --> 00:24:54,000
Vi har denna följande beräkning i binär,

369
00:24:54,000 --> 00:24:56,000
och vi vill visa något arbete.

370
00:24:56,000 --> 00:24:59,000
Okej, jag ska ge detta en chans.

371
00:24:59,000 --> 00:25:01,000
Ni borde följa med papper,

372
00:25:01,000 --> 00:25:04,000
och vi ska göra det riktigt snabbt.

373
00:25:04,000 --> 00:25:06,000
Vi vill utföra följande beräkning i binär.

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

375
00:25:16,000 --> 00:25:27,000
Och jag kommer att lägga till den 00.110.010.

376
00:25:27,000 --> 00:25:30,000
För matte genier följer med hemma,

377
00:25:30,000 --> 00:25:35,000
Detta är i praktiken multipliceras med 2.

378
00:25:35,000 --> 00:25:37,000
Låt oss börja.

379
00:25:37,000 --> 00:25:39,000
Vi kommer att följa samma tillägg algoritm som vi gör

380
00:25:39,000 --> 00:25:43,000
när vi lägger decimaltal tillsammans.

381
00:25:43,000 --> 00:25:46,000
Verkligen den enda skillnaden här är att vi slinga tillbaka runt

382
00:25:46,000 --> 00:25:51,000
när vi har 1 + 1 istället för när vi kommer till 10.

383
00:25:51,000 --> 00:25:53,000
>> Om vi ​​börjar från höger, riktigt snabbt, är det den första siffran?

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

385
00:25:55,000 --> 00:25:58,000
Stora, den andra siffran?

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

387
00:26:00,000 --> 00:26:02,000
[Nate H] Är det en 1? 1 + 1 är?

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

389
00:26:04,000 --> 00:26:08,000
[Nate H] Exakt, så vad är den siffra som jag skriver rakt nedanför 2 ettor lagts ihop?

390
00:26:08,000 --> 00:26:11,000
[Student] 1, 0 eller 0 och sedan bära 1.

391
00:26:11,000 --> 00:26:15,000
[Nate H] 0 och bär en 1, exakt.

392
00:26:15,000 --> 00:26:18,000
Nästa upp, basilika, du upp.

393
00:26:18,000 --> 00:26:20,000
Vad är 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, och vad ska jag göra?

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

398
00:26:32,000 --> 00:26:34,000
[Nate H] Och vad ska jag göra? Och då jag bär 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] Och gör jag något här?

401
00:26:40,000 --> 00:26:43,000
[Sahb] Sedan för nästa har du 1 för att du som överförts 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H] Bra, så här kan vi avsluta det.

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

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

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

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

407
00:27:01,000 --> 00:27:07,000
10 är en missvisande eftersom för mig 10 innebär att antalet 10,

408
00:27:07,000 --> 00:27:12,000
och det är sarkasm hur vi representerar det när vi skriver det.

409
00:27:12,000 --> 00:27:20,000
Vi representerar siffran 2 med 1, 0, och antalet 10 är något annorlunda.

410
00:27:20,000 --> 00:27:23,000
>> Vad är typ av trevligt om binär är att det verkligen inte finns så många

411
00:27:23,000 --> 00:27:25,000
fall måste du lära dig.

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

413
00:27:30,000 --> 00:27:34,000
1 + 1 är 0, och sedan bära en 1,

414
00:27:34,000 --> 00:27:37,000
och sedan kan du se här på den tredje kolumnen från höger

415
00:27:37,000 --> 00:27:40,000
vi hade detta 1, 1 och 1.

416
00:27:40,000 --> 00:27:43,000
Och 1 + 1 + 1 är en 1,

417
00:27:43,000 --> 00:27:45,000
och du bär en annan 1.

418
00:27:45,000 --> 00:27:48,000
När du gör binär addition, ganska enkelt.

419
00:27:48,000 --> 00:27:51,000
Jag skulle göra ett par fler av dessa vårt förstånd kontrollera er

420
00:27:51,000 --> 00:27:54,000
innan du går in för det här är

421
00:27:54,000 --> 00:28:00,000
förmodligen något som vi får se på testet.

422
00:28:00,000 --> 00:28:03,000
Nu ska vi göra det här nästa också.

423
00:28:03,000 --> 00:28:06,000
Låt oss göra problemet 17.

424
00:28:06,000 --> 00:28:12,000
Vi kommer att omvandla följande binära tal till decimal.

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

426
00:28:28,000 --> 00:28:33,000
Tänk på det binära videon som jag gjorde

427
00:28:33,000 --> 00:28:36,000
Jag gick igenom ett par exempel, och jag visade hur

428
00:28:36,000 --> 00:28:41,000
allt fungerar när du gör det i decimalform.

429
00:28:41,000 --> 00:28:45,000
När du arbetar i decimal representation jag tror att vi är

430
00:28:45,000 --> 00:28:48,000
vid denna punkt i våra liv så flytande i det som

431
00:28:48,000 --> 00:28:53,000
Det är ganska lätt att släta över mekaniken i hur det faktiskt fungerar.

432
00:28:53,000 --> 00:28:59,000
>> Men för att göra en snabb resumé, om jag har numret 137

433
00:28:59,000 --> 00:29:06,000
Detta betyder, och verkligen igen, detta är i decimal representation,

434
00:29:06,000 --> 00:29:19,000
numret 137 i decimalform innebär att jag har 1 x 100 + 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
Detta är allt som vistas på skärmen.

436
00:29:22,000 --> 00:29:29,000
Och sedan om man tittar på dessa siffror här,

437
00:29:29,000 --> 00:29:34,000
100, 10 och 1, ser du att de är faktiskt alla befogenheter 10.

438
00:29:34,000 --> 00:29:43,000
Jag har 10 ^, 10 ^, och 10 till noll.

439
00:29:43,000 --> 00:29:48,000
Vi har en liknande saker i binär,

440
00:29:48,000 --> 00:29:55,000
förutom att vår bas, som vi kallar det, är 2 istället för 10.

441
00:29:55,000 --> 00:29:58,000
Dessa 10s som jag skrev här nere på botten,

442
00:29:58,000 --> 00:30:02,000
detta 10 m², 10 ¹, 10 till noll, 10 är vår bas,

443
00:30:02,000 --> 00:30:08,000
och exponenten, 0, 1, eller 2,

444
00:30:08,000 --> 00:30:14,000
antyds av läget för siffran i antalet som vi skriver.

445
00:30:14,000 --> 00:30:21,000
1, om vi ser på det, är detta 1 i 2: a plats.

446
00:30:21,000 --> 00:30:27,000
Den 3 är i den 1: a positionen, och 7 är i 0:e läge.

447
00:30:27,000 --> 00:30:35,000
Det är så vi får olika exponenter nedan för våra baser.

448
00:30:35,000 --> 00:30:40,000
>> Efter allt detta we'll-faktiskt, vet du vad?

449
00:30:40,000 --> 00:30:43,000
Vi gör-vart tog min ångra knapp vägen?

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

451
00:30:45,000 --> 00:30:47,000
Jag älskar det här ångra sak.

452
00:30:47,000 --> 00:30:51,000
Efter detta tror jag för mig åtminstone

453
00:30:51,000 --> 00:30:54,000
Det enklaste sättet att börja konvertera ett binärt tal

454
00:30:54,000 --> 00:30:57,000
eller ett hexadecimalt tal där basen är 16

455
00:30:57,000 --> 00:31:02,000
och inte 10 eller 2 är att gå vidare och skriva ut

456
00:31:02,000 --> 00:31:09,000
grunderna och exponenter för alla nummer i min binärt tal i toppen.

457
00:31:09,000 --> 00:31:14,000
Om vi ​​börjar från vänster till höger igen,

458
00:31:14,000 --> 00:31:17,000
som är typ av bakvända,

459
00:31:17,000 --> 00:31:23,000
Jag kommer att ändra tillbaka till svart här, har vi 2 till 0. Läget,

460
00:31:23,000 --> 00:31:27,000
och sedan har vi 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
och sedan 2 till 3, 2 till 4, 2 till 5, 6,

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

463
00:31:39,000 --> 00:31:41,000
Dessa siffror har jag skrivit ut är alla exponenter.

464
00:31:41,000 --> 00:31:48,000
Jag skrev bara baserna här i första 3 bara för rymden.

465
00:31:48,000 --> 00:31:50,000
>> På denna punkt kommer jag att gå vidare och jag faktiskt kommer att radera

466
00:31:50,000 --> 00:31:53,000
de saker som vi gjorde i decimal, om det är okej.

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

468
00:31:57,000 --> 00:32:05,000
De av er tittar på nätet är jag säker på kommer att kunna spola tillbaka mig om du vill.

469
00:32:05,000 --> 00:32:07,000
Växla tillbaka till pennan.

470
00:32:07,000 --> 00:32:12,000
Nu, vad vi kan göra, om ni inte är helt upp till hastigheten på dina befogenheter 2,

471
00:32:12,000 --> 00:32:15,000
Det är helt cool.

472
00:32:15,000 --> 00:32:18,000
Det händer. Jag förstår.

473
00:32:18,000 --> 00:32:23,000
Jag hade en gång en anställningsintervju där jag fick höra att jag borde känna till alla befogenheter 2

474
00:32:23,000 --> 00:32:26,000
upp genom 2 till den 30.

475
00:32:26,000 --> 00:32:29,000
Det var inte ett jobb jag fick.

476
00:32:29,000 --> 00:32:32,000
Hur som helst, kan ni gå vidare och göra matten här,

477
00:32:32,000 --> 00:32:35,000
men med binär det inte verkligen göra mening,

478
00:32:35,000 --> 00:32:38,000
och inte heller det vettigt med decimal eller hexadecimal heller,

479
00:32:38,000 --> 00:32:43,000
att göra matten reda på var du har nollor.

480
00:32:43,000 --> 00:32:49,000
Du kan se har jag 0 här, en 0 här, 0 här, 0 här, 0 här, 0 här.

481
00:32:49,000 --> 00:32:52,000
Varför kan det inte meningsfullt att göra själva matten

482
00:32:52,000 --> 00:32:56,000
att beräkna lämplig effekt av 2 för den positionen?

483
00:32:56,000 --> 00:32:59,000
Exakt, precis Charlotte sa blir det 0.

484
00:32:59,000 --> 00:33:05,000
Kan lika gärna spara själv tid om beräkning befogenheter 2 inte är din starka sida.

485
00:33:05,000 --> 00:33:10,000
I det här fallet behöver vi bara beräkna det för 2 till 0, som är-?

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

487
00:33:12,000 --> 00:33:14,000
[Nate H] 1, 2 till 3 som är-?

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

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

490
00:33:18,000 --> 00:33:21,000
[Student] 2. Jag är ledsen, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H] 2 ​​till 4 är 16, exakt.

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

493
00:33:28,000 --> 00:33:32,000
[Nate H] 32, 2 till 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] Perfekt.

496
00:33:41,000 --> 00:33:43,000
Och 2 till 10?

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

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

499
00:33:49,000 --> 00:33:57,000
>> När vi har fått dessa siffror kan vi summera dem alla.

500
00:33:57,000 --> 00:34:01,000
Och det är där det är verkligen viktigt att göra ett par saker.

501
00:34:01,000 --> 00:34:07,000
En är att gå sakta och kontrollera ditt arbete.

502
00:34:07,000 --> 00:34:10,000
Du kan säga att det finns en 1 i slutet av detta nummer,

503
00:34:10,000 --> 00:34:15,000
så jag borde definitivt få ett udda antal som min resultat,

504
00:34:15,000 --> 00:34:18,000
eftersom alla de andra kommer att bli ännu tal

505
00:34:18,000 --> 00:34:21,000
tanke på att det är ett binärt tal.

506
00:34:21,000 --> 00:34:24,000
Den andra sak att göra är om du kommer till denna punkt på prov

507
00:34:24,000 --> 00:34:27,000
och du har skrivit ut så här långt

508
00:34:27,000 --> 00:34:30,000
och du ont om tid

509
00:34:30,000 --> 00:34:33,000
titta på antalet poäng att detta problem är värt.

510
00:34:33,000 --> 00:34:40,000
Detta problem, som ni kan se, om jag vänder tillbaka till min laptop verkligen snabbt,

511
00:34:40,000 --> 00:34:44,000
detta problem är värt 2 poäng, så det är inte den typ av tillägg

512
00:34:44,000 --> 00:34:47,000
du bör gå igenom om du verkligen ont om tid.

513
00:34:47,000 --> 00:34:52,000
Men vi ska växla tillbaka till iPad, och vi ska gå igenom det riktigt snabbt.

514
00:34:52,000 --> 00:34:54,000
>> Jag gillar att göra de små siffrorna 1.

515
00:34:54,000 --> 00:34:56,000
eftersom jag tycker att lättare.

516
00:34:56,000 --> 00:35:00,000
Jag gillar 32 och 8 eftersom de går ihop ganska enkelt, och vi får 50.

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

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

519
00:35:05,000 --> 00:35:14,000
och då kan vi göra resten av detta, så att vi kan göra 57, 156.

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

521
00:35:16,000 --> 00:35:19,000
Människan, ja, låt oss se.

522
00:35:19,000 --> 00:35:27,000
Vi hade 57, 256 och 1024.

523
00:35:27,000 --> 00:35:31,000
Vid denna punkt, skulle jag hellre bara gå igenom.

524
00:35:31,000 --> 00:35:35,000
Jag har ingen aning. Jag behöver helt klart läsa upp detta.

525
00:35:35,000 --> 00:35:40,000
7, 6 och 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
Då får vi 3, och sedan får vi 1.

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

529
00:35:52,000 --> 00:35:55,000
Påskägg, någon?

530
00:35:55,000 --> 00:35:59,000
Någon känner igen detta nummer?

531
00:35:59,000 --> 00:36:02,000
Chris känner igen numret. Vad 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å om du tittar på det här, det ser ut som Leet.

534
00:36:11,000 --> 00:36:15,000
Hacker grejer. Se upp för den typen av saker på halva tiden eller testet, snarare.

535
00:36:15,000 --> 00:36:19,000
Om du ser den typen av grejer och du undrar "Va,"

536
00:36:19,000 --> 00:36:22,000
som faktiskt kan betyda något.

537
00:36:22,000 --> 00:36:24,000
Jag vet inte. David gillar att sätta den i.

538
00:36:24,000 --> 00:36:26,000
Det är ett bra sätt att förnuft kontrollera det.

539
00:36:26,000 --> 00:36:30,000
Liksom okej, jag kan se vad som händer.

540
00:36:30,000 --> 00:36:34,000
>> Det är vecka 0/Week 1 grejer.

541
00:36:34,000 --> 00:36:39,000
Om vi ​​växlar tillbaka till våra bärbara nu,

542
00:36:39,000 --> 00:36:46,000
zooma ut, och ett par andra saker.

543
00:36:46,000 --> 00:36:50,000
Det finns ASCII, vilket vi har gjort en hel del med problemet uppsättningar.

544
00:36:50,000 --> 00:36:55,000
Detta begrepp av kapital A. Vad är det egentligen?

545
00:36:55,000 --> 00:36:57,000
Att veta att det är det decimala heltal.

546
00:36:57,000 --> 00:37:00,000
65 är vad det är mappat till i ASCII tabellen,

547
00:37:00,000 --> 00:37:03,000
och det är därför hur datorn skriver det,

548
00:37:03,000 --> 00:37:06,000
och det är hur vi har komma undan med faktiskt skriva

549
00:37:06,000 --> 00:37:09,000
tecknet kapital A och karaktären gemener en

550
00:37:09,000 --> 00:37:14,000
i några av dessa lösningar och sätter problem som du har gjort.

551
00:37:14,000 --> 00:37:16,000
Ett par andra saker.

552
00:37:16,000 --> 00:37:25,000
Vi har uttalanden, booleska uttryck, villkor, slingor, variabler och trådar.

553
00:37:25,000 --> 00:37:29,000
>> De alla verkar vettigt för det mesta?

554
00:37:29,000 --> 00:37:35,000
En del av denna terminologi är lite funky ibland.

555
00:37:35,000 --> 00:37:46,000
Jag tycker om att ett uttalande som för det mesta något som avslutas med ett semikolon.

556
00:37:46,000 --> 00:37:51,000
Uttalanden som x = 7, som sätter en variabel,

557
00:37:51,000 --> 00:37:54,000
förmodligen kallas x = 7.

558
00:37:54,000 --> 00:38:01,000
Förmodligen X är också en typ som kan lagra numret 7,

559
00:38:01,000 --> 00:38:05,000
så det är en int eller möjligen en flottör eller en kort eller en röding,

560
00:38:05,000 --> 00:38:07,000
något liknande.

561
00:38:07,000 --> 00:38:12,000
Ett booleskt uttryck använder dessa dubbel lika

562
00:38:12,000 --> 00:38:17,000
och bang är lika eller inte lika, mindre än, större än,

563
00:38:17,000 --> 00:38:22,000
mindre än eller lika med alla såna saker.

564
00:38:22,000 --> 00:38:28,000
Förutsättningarna är då om else uttalanden.

565
00:38:28,000 --> 00:38:32,000
Jag skulle komma ihåg att du inte kan ha en annan utan motsvarande om.

566
00:38:32,000 --> 00:38:37,000
På samma sätt kan du inte ett annat om utan motsvarande om.

567
00:38:37,000 --> 00:38:40,000
Loopar, minns 3 sorters loopar vi har hammering in dig

568
00:38:40,000 --> 00:38:43,000
för de senaste avsnitten och sätter problem.

569
00:38:43,000 --> 00:38:46,000
Använda gör medan när du får indata,

570
00:38:46,000 --> 00:38:51,000
användning medan slingor tills ett visst villkor är sant,

571
00:38:51,000 --> 00:38:56,000
och sedan använda dem för loopar om du behöver

572
00:38:56,000 --> 00:39:01,000
veta vilken iteration av slingan närvarande är du på är hur jag tänker på det.

573
00:39:01,000 --> 00:39:07,000
Eller om du gör en för varje tecken i en sträng jag vill göra något,

574
00:39:07,000 --> 00:39:15,000
för varje element i en array jag vill göra något för att det elementet.

575
00:39:15,000 --> 00:39:18,000
>> Trådar och evenemang.

576
00:39:18,000 --> 00:39:21,000
Dessa vi har inte täckt så uttryckligen i C,

577
00:39:21,000 --> 00:39:23,000
men kom ihåg detta från grunden.

578
00:39:23,000 --> 00:39:26,000
Detta är begreppet har olika skript.

579
00:39:26,000 --> 00:39:32,000
Detta är också denna uppfattning att sända ett evenemang.

580
00:39:32,000 --> 00:39:37,000
Vissa människor använde inte sändningar i sina projekt från början,

581
00:39:37,000 --> 00:39:40,000
vilket är helt cool,

582
00:39:40,000 --> 00:39:46,000
men dessa är 2 olika sätt att hantera denna större fråga kallas samtidighet,

583
00:39:46,000 --> 00:39:49,000
vilket är hur får man program för att utföra

584
00:39:49,000 --> 00:39:54,000
eller till synes exekvera samtidigt?

585
00:39:54,000 --> 00:39:59,000
Olika uppgifter körs medan andra uppgifter också igång.

586
00:39:59,000 --> 00:40:01,000
Detta är hur operativsystemet verkar fungera.

587
00:40:01,000 --> 00:40:04,000
Det är därför även, till exempel,

588
00:40:04,000 --> 00:40:10,000
Jag har min webbläsare igång kan jag vända också på Spotify och spela upp en låt.

589
00:40:10,000 --> 00:40:14,000
Det är mer av en konceptuell sak att förstå.

590
00:40:14,000 --> 00:40:17,000
Jag skulle ta en titt på gängorna korta

591
00:40:17,000 --> 00:40:21,000
Om du vill veta mer om det.

592
00:40:21,000 --> 00:40:26,000
>> Låt oss se, tror jag att det kan ha varit

593
00:40:26,000 --> 00:40:31,000
ett problem på detta i en av dessa.

594
00:40:31,000 --> 00:40:35,000
Återigen, jag tror trådar och händelser är inte något som vi kommer att täcka i C

595
00:40:35,000 --> 00:40:41,000
bara för att det är betydligt svårare än i Scratch.

596
00:40:41,000 --> 00:40:44,000
Du ska inte bry dig om det där, men definitivt förstå begreppen,

597
00:40:44,000 --> 00:40:47,000
förstå vad som händer.

598
00:40:47,000 --> 00:40:52,000
Innan vi går vidare, några frågor om vecka 0 material?

599
00:40:52,000 --> 00:40:55,000
Alla mår ganska bra?

600
00:40:55,000 --> 00:41:03,000
Förstå variabler och vad en variabel är?

601
00:41:03,000 --> 00:41:08,000
>> Går vidare. Vecka 1.

602
00:41:08,000 --> 00:41:12,000
Ett par saker här som inte var särskilt omfattas

603
00:41:12,000 --> 00:41:21,000
i frågesporten översyn nödvändighet och också är mer konceptuella saker att tänka på.

604
00:41:21,000 --> 00:41:30,000
Den första är denna föreställning om vad källkoden, kompilatorer och objektkod är.

605
00:41:30,000 --> 00:41:32,000
Någon? Basilika.

606
00:41:32,000 --> 00:41:37,000
Är objektkod-jag menar källkod är vad du lägger i klang,

607
00:41:37,000 --> 00:41:42,000
och objektkod är vad klang lägger ut så att datorn kan läsa programmet.

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

609
00:41:44,000 --> 00:41:47,000
Källkod är C-kod som du faktiskt skriva upp.

610
00:41:47,000 --> 00:41:50,000
Objektkod är vad du får ut av klang.

611
00:41:50,000 --> 00:41:54,000
Det är 0 och 1 i den binärt format.

612
00:41:54,000 --> 00:41:59,000
Vad som händer är när du har en massa objektfiler,

613
00:41:59,000 --> 00:42:04,000
säga att du sammanställa ett projekt eller ett program som använder flera källkodsfiler,

614
00:42:04,000 --> 00:42:09,000
som konventionellt ges. c. filändelsen.

615
00:42:09,000 --> 00:42:13,000
Det är därför vi har caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
Om du skriver Java-program du ger dem en förlängning. Java.

617
00:42:18,000 --> 00:42:24,000
Python-program har filtillägget. Py ofta.

618
00:42:24,000 --> 00:42:26,000
>> När du har flera. C-filer, kompilera du dem.

619
00:42:26,000 --> 00:42:29,000
Klang spottar ut allt detta binära skräp.

620
00:42:29,000 --> 00:42:33,000
Sedan för att du vill endast 1 program

621
00:42:33,000 --> 00:42:37,000
har du länken länken alla dessa objektfiler tillsammans

622
00:42:37,000 --> 00:42:40,000
i 1 körbar fil.

623
00:42:40,000 --> 00:42:45,000
Detta är också vad som händer när du använder CS50 biblioteket, till exempel.

624
00:42:45,000 --> 00:42:50,000
Den CS50 bibliotek är både att. H. huvudfil

625
00:42:50,000 --> 00:42:53,000
att du läser, det # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
Och då är det också en speciell binär biblioteksfil

627
00:42:58,000 --> 00:43:02,000
som har varit sammanställts som är 0 och 1,

628
00:43:02,000 --> 00:43:08,000
och att-Jag flaggan, så om vi går tillbaka till våra utrymmen och vi ser verkligen snabbt

629
00:43:08,000 --> 00:43:11,000
på vad som händer här när vi ser på vår klang kommando,

630
00:43:11,000 --> 00:43:15,000
vad vi har är att detta är vår källkod fil här.

631
00:43:15,000 --> 00:43:18,000
Dessa är ett gäng kompilator flaggor.

632
00:43:18,000 --> 00:43:22,000
Och sedan i slutet, dessa-l flaggor länken i

633
00:43:22,000 --> 00:43:30,000
de faktiska binära filer för dessa 2 bibliotek, CS50 bibliotek och sedan matematik bibliotek.

634
00:43:30,000 --> 00:43:35,000
>> Förstå varje typ av filer "syftet

635
00:43:35,000 --> 00:43:38,000
i sammanställningen processen är något du vill kunna

636
00:43:38,000 --> 00:43:43,000
ger åtminstone en hög nivå översikt över.

637
00:43:43,000 --> 00:43:46,000
Källkod kommer in Objektkod kommer ut.

638
00:43:46,000 --> 00:43:53,000
Objekt kodfiler knyta ihop, och du får en vacker, körbar fil.

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

640
00:43:55,000 --> 00:43:58,000
Det är också där du kan få fel på flera punkter

641
00:43:58,000 --> 00:44:00,000
i sammanställningen processen.

642
00:44:00,000 --> 00:44:04,000
Det är där, till exempel, om du tar det här länka flagga,

643
00:44:04,000 --> 00:44:10,000
den CS50 flaggan och du utelämnar det i utrymmen eller när du kör din kod,

644
00:44:10,000 --> 00:44:13,000
det är där du får ett fel i länkningen fasen,

645
00:44:13,000 --> 00:44:18,000
och länken kommer att säga, "Hej, kallat er en funktion GetString

646
00:44:18,000 --> 00:44:20,000
det är i CS50 biblioteket. "

647
00:44:20,000 --> 00:44:25,000
"Du sa att det var i CS50 biblioteket och jag kan inte hitta koden för det."

648
00:44:25,000 --> 00:44:28,000
Det är där du måste länka det, och det är separata

649
00:44:28,000 --> 00:44:33,000
från ett kompileringsfel eftersom kompilatorn tittar på syntax och sånt.

650
00:44:33,000 --> 00:44:38,000
Det är bra att veta vad som händer när.

651
00:44:38,000 --> 00:44:42,000
>> Andra saker att känna till.

652
00:44:42,000 --> 00:44:49,000
Jag skulle säga att du absolut vill ta en titt på den korta på typecasting görs av Jordanien

653
00:44:49,000 --> 00:44:55,000
att förstå vad ints är under huven,

654
00:44:55,000 --> 00:44:58,000
vilka tecken är under huven.

655
00:44:58,000 --> 00:45:02,000
När vi talar om ASCII och vi faktiskt tittar på ASCII tabellen,

656
00:45:02,000 --> 00:45:07,000
vad det gör är att ge oss en under huven ser

657
00:45:07,000 --> 00:45:13,000
på hur datorn faktiskt representerar kapitalet A och siffran 7

658
00:45:13,000 --> 00:45:17,000
och ett kommatecken och ett frågetecken.

659
00:45:17,000 --> 00:45:20,000
Datorn har också speciella sätt att representera

660
00:45:20,000 --> 00:45:23,000
numret 7 som ett heltal.

661
00:45:23,000 --> 00:45:27,000
Den har ett speciellt sätt att representera nummer 7 som ett flyttal,

662
00:45:27,000 --> 00:45:29,000
och de är mycket olika.

663
00:45:29,000 --> 00:45:32,000
Typecasting är hur du säger datorn "Hej, jag vill att du ska konvertera

664
00:45:32,000 --> 00:45:37,000
från en representation till en annan representation. "

665
00:45:37,000 --> 00:45:40,000
Varför inte vi ta en titt på det.

666
00:45:40,000 --> 00:45:44,000
>> Jag vill också ta en titt på den korta på biblioteken och den korta på kompilatorer.

667
00:45:44,000 --> 00:45:47,000
De talar om processen för sammanställning,

668
00:45:47,000 --> 00:45:53,000
vad ett bibliotek är och gå igenom några av dessa frågor som du kan få frågade.

669
00:45:53,000 --> 00:45:55,000
Frågor om Vecka 1-material?

670
00:45:55,000 --> 00:46:03,000
Finns det några ämnen i här som verkar skrämmande du vill täcka?

671
00:46:03,000 --> 00:46:07,000
Jag försöker blåsa igenom de flesta av dessa tidigare frågor så att vi kan få till

672
00:46:07,000 --> 00:46:13,000
pekare och göra lite av rekursion.

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

674
00:46:15,000 --> 00:46:19,000
Allt för att täcka?

675
00:46:19,000 --> 00:46:21,000
Dags för lite choklad kanske?

676
00:46:21,000 --> 00:46:23,000
Ni arbetar genom den.

677
00:46:23,000 --> 00:46:26,000
Jag kommer att fortsätta smuttar på mitt kaffe.

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

679
00:46:31,000 --> 00:46:34,000
Bra samtal, bra samtal.

680
00:46:34,000 --> 00:46:38,000
I vecka 2 pratade vi lite mer om funktioner.

681
00:46:38,000 --> 00:46:43,000
>> Under de första problemet set vi inte riktigt skriva några funktioner alls

682
00:46:43,000 --> 00:46:45,000
annat än vilken funktion?

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

684
00:46:47,000 --> 00:46:51,000
Och så har vi sett de olika kostymer som främsta bär.

685
00:46:51,000 --> 00:46:54,000
Där är en som tar inga argument,

686
00:46:54,000 --> 00:46:58,000
och vi säger bara tomrum mellan parenteserna,

687
00:46:58,000 --> 00:47:01,000
och sedan finns det andra där vi vill ta kommandoradsargument,

688
00:47:01,000 --> 00:47:08,000
och som vi såg, det är där du har int argc och sträng argv array

689
00:47:08,000 --> 00:47:13,000
eller nu när vi har faktiskt utsatt sträng att vara den char * att det är

690
00:47:13,000 --> 00:47:20,000
vi kommer att börja skriva det som char * argv och konsoler.

691
00:47:20,000 --> 00:47:22,000
I problembild 3, såg ni ett gäng funktioner,

692
00:47:22,000 --> 00:47:27,000
och du genomfört ett gäng funktioner, rita, titta upp, scramble.

693
00:47:27,000 --> 00:47:31,000
Prototyperna var alla skrivna där för dig.

694
00:47:31,000 --> 00:47:33,000
>> Vad jag ville prata om här med funktioner riktigt snabbt

695
00:47:33,000 --> 00:47:38,000
är att det finns 3 delar till dem när du skriver en funktion.

696
00:47:38,000 --> 00:47:43,000
Du måste ange en returtyp för funktionen.

697
00:47:43,000 --> 00:47:46,000
Du måste ange ett namn för funktionen och då måste man ange

698
00:47:46,000 --> 00:47:51,000
argumentlistan eller parameterlistan.

699
00:47:51,000 --> 00:47:57,000
Till exempel, om jag skulle skriva en funktion för att summera ett gäng heltal

700
00:47:57,000 --> 00:48:03,000
och sedan tillbaka till mig den summa vad som skulle vara min återkomst typ

701
00:48:03,000 --> 00:48:06,000
om jag ville summera heltal och sedan tillbaka summan?

702
00:48:06,000 --> 00:48:12,000
Sedan namnet på funktionen.

703
00:48:12,000 --> 00:48:27,000
Om jag går vidare och skriver i grönt, är denna del av returtyp.

704
00:48:27,000 --> 00:48:34,000
Denna del är namnet.

705
00:48:34,000 --> 00:48:40,000
Och sedan mellan parentes

706
00:48:40,000 --> 00:48:46,000
är där jag ger argumenten,

707
00:48:46,000 --> 00:48:56,000
ofta förkortat args, ibland kallade params för parametrar.

708
00:48:56,000 --> 00:49:00,000
Och om du har en, anger du bara en.

709
00:49:00,000 --> 00:49:06,000
Om du har flera du dela var och en med ett kommatecken.

710
00:49:06,000 --> 00:49:13,000
Och för varje argument du ger den 2 saker som är-Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] Du måste ge den typ och sedan namnet.

712
00:49:18,000 --> 00:49:21,000
Och sedan namnet och namnet är det namn som du kommer att använda

713
00:49:21,000 --> 00:49:25,000
att hänvisa till det argumentet inom ramen för summan funktion,

714
00:49:25,000 --> 00:49:27,000
inom den funktion som du för närvarande skriver.

715
00:49:27,000 --> 00:49:32,000
>> Du behöver inte, till exempel om jag ska sammanfatta,

716
00:49:32,000 --> 00:49:41,000
säga, en rad av heltal-Vi gör int array,

717
00:49:41,000 --> 00:49:46,000
och jag ska ge mig några klammerparenteser där-

718
00:49:46,000 --> 00:49:51,000
sedan när jag passerar en array till funktionen SUMMA

719
00:49:51,000 --> 00:49:55,000
Jag låta det gå i den första positionen av argumentet listan.

720
00:49:55,000 --> 00:49:59,000
Men array som jag passerar på inte behöver ha namnet arr.

721
00:49:59,000 --> 00:50:07,000
Arr kommer att vara hur jag hänvisar till det argumentet i själva funktionen.

722
00:50:07,000 --> 00:50:10,000
Den andra saken som vi måste ta hänsyn till,

723
00:50:10,000 --> 00:50:14,000
och detta är något annorlunda funktioner, men jag tycker det är en viktig punkt,

724
00:50:14,000 --> 00:50:20,000
är att i C när jag skriver en funktion som denna

725
00:50:20,000 --> 00:50:29,000
hur vet jag hur många element är i denna array?

726
00:50:29,000 --> 00:50:31,000
Detta är något av en kuggfråga.

727
00:50:31,000 --> 00:50:35,000
Vi pratade om detta lite i förra veckans avsnitt.

728
00:50:35,000 --> 00:50:40,000
Hur vet jag hur många element inuti en array i C?

729
00:50:40,000 --> 00:50:44,000
Finns det något sätt?

730
00:50:44,000 --> 00:50:49,000
>> Det visar sig att det finns inget sätt att veta.

731
00:50:49,000 --> 00:50:52,000
Du måste låta det gå i separat.

732
00:50:52,000 --> 00:50:55,000
Det finns ett trick som du kan göra

733
00:50:55,000 --> 00:51:00,000
om du är i samma funktion som arrayen har förklarats,

734
00:51:00,000 --> 00:51:04,000
och du arbetar med en stack array.

735
00:51:04,000 --> 00:51:06,000
Men det fungerar bara om du är i samma funktion.

736
00:51:06,000 --> 00:51:09,000
När du passerar en rad till en annan funktion eller om du har deklarerat en matris

737
00:51:09,000 --> 00:51:12,000
och du sätter den arrayen på högen, har du använt malloc

738
00:51:12,000 --> 00:51:15,000
 och sånt, så alla satsningar är avstängd.

739
00:51:15,000 --> 00:51:18,000
Då har du faktiskt gå runt

740
00:51:18,000 --> 00:51:21,000
en speciell argument eller annan parameter

741
00:51:21,000 --> 00:51:23,000
berätta hur stor gruppen är.

742
00:51:23,000 --> 00:51:28,000
I det här fallet skulle jag vilja använda en komma-Jag är ledsen, det kommer upp på skärmen här-

743
00:51:28,000 --> 00:51:32,000
och jag skulle passera i ett annat argument

744
00:51:32,000 --> 00:51:40,000
 och kallar det int len ​​för längden.

745
00:51:40,000 --> 00:51:44,000
>> En sak som kan komma upp på frågesport

746
00:51:44,000 --> 00:51:49,000
ber dig att skriva eller genomföra en viss funktion som heter något.

747
00:51:49,000 --> 00:51:54,000
Om vi ​​inte ger dig prototypen, så hela den här saken här,

748
00:51:54,000 --> 00:51:58,000
hela den här röran kallas funktionen deklarationen eller funktionen prototyp,

749
00:51:58,000 --> 00:52:01,000
Detta är en av de första saker som du kommer att vilja spika ner om den inte har gett

750
00:52:01,000 --> 00:52:03,000
till dig direkt på testet.

751
00:52:03,000 --> 00:52:06,000
Den andra knep som jag har lärt mig är att

752
00:52:06,000 --> 00:52:11,000
säger att vi gör ger dig en prototyp för en funktion, och vi säger: "Hej, har du att skriva det."

753
00:52:11,000 --> 00:52:16,000
Inuti klammerparenteser som du har på testet

754
00:52:16,000 --> 00:52:20,000
om du märker att det finns en returtyp och du märker att avkastningen typen

755
00:52:20,000 --> 00:52:25,000
är något annat än tomrum, vilket innebär att funktionen inte returnera någonting,

756
00:52:25,000 --> 00:52:28,000
då en sak som du definitivt vill göra är att skriva

757
00:52:28,000 --> 00:52:33,000
någon form av return i slutet av funktionen.

758
00:52:33,000 --> 00:52:40,000
Avkastning, och i detta fall kommer vi sätta en tom eftersom vi vill fylla i de tomma.

759
00:52:40,000 --> 00:52:44,000
Men detta får dig att tänka på rätt sätt om hur ska jag närma sig detta problem?

760
00:52:44,000 --> 00:52:49,000
Och det påminner dig att du kommer att få tillbaka ett värde

761
00:52:49,000 --> 00:52:51,000
till anroparen av funktionen.

762
00:52:51,000 --> 00:52:54,000
>> Ja. >> [Student] Har stil gälla när vi skriver kod på testet?

763
00:52:54,000 --> 00:52:58,000
Såsom indrag och sånt? >> [Student] Ja.

764
00:52:58,000 --> 00:53:00,000
Nej, inte så mycket.

765
00:53:00,000 --> 00:53:09,000
Jag tror att många av-detta är något vi kommer att klargöra om testet på dagen för,

766
00:53:09,000 --> 00:53:15,000
men typiskt oroa omfattar # och sånt, det är typ av utanför.

767
00:53:15,000 --> 00:53:17,000
[Student] Behöver du kommentera din handskrivna kod?

768
00:53:17,000 --> 00:53:19,000
Behöver du kommentera din handskrivna kod?

769
00:53:19,000 --> 00:53:24,000
Kommentarer är alltid bra om du är orolig för partiell kredit

770
00:53:24,000 --> 00:53:29,000
eller om du vill kommunicera din avsikt att grader.

771
00:53:29,000 --> 00:53:33,000
Men jag, återigen, att klargöra om testet själv och den frågesport dag,

772
00:53:33,000 --> 00:53:39,000
men jag tror inte att du kommer att krävas för att skriva kommentarer, nej.

773
00:53:39,000 --> 00:53:42,000
Vanligtvis inte, men det är definitivt den typ av sak där

774
00:53:42,000 --> 00:53:45,000
Du kan kommunicera din avsikt, som "Hej, det är här jag ska med det."

775
00:53:45,000 --> 00:53:49,000
Och ibland som kan hjälpa till med partiell kredit.

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

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

778
00:53:53,000 --> 00:53:56,000
[Basil] Vad är skillnaden mellan att förklara, säger, int Lang

779
00:53:56,000 --> 00:54:03,000
i argument eller parametrar kontra förklara en variabel i funktionen?

780
00:54:03,000 --> 00:54:05,000
Wow, gick kaffe ner luftstrupen.

781
00:54:05,000 --> 00:54:07,000
[Basil] Som vilka saker vi vill sätta i argument.

782
00:54:07,000 --> 00:54:09,000
Ja, det är en bra fråga.

783
00:54:09,000 --> 00:54:11,000
Hur väljer du vilka saker du vill sätta i argumenten

784
00:54:11,000 --> 00:54:17,000
kontra vad saker du bör göra inne i funktion?

785
00:54:17,000 --> 00:54:24,000
I detta fall har vi inkluderat båda dessa som argument

786
00:54:24,000 --> 00:54:29,000
eftersom de är något som den som ska använda funktionen SUMMA

787
00:54:29,000 --> 00:54:32,000
måste ange dessa saker.

788
00:54:32,000 --> 00:54:35,000
>> Summan funktionen som vi talade om, har ingen möjlighet att veta

789
00:54:35,000 --> 00:54:40,000
hur stor gruppen är den får från sin uppringaren eller den som använder funktionen SUMMA.

790
00:54:40,000 --> 00:54:44,000
Den har ingen möjlighet att veta hur stor den gruppen är.

791
00:54:44,000 --> 00:54:48,000
Anledningen till att vi passerar i denna längd här som ett argument

792
00:54:48,000 --> 00:54:51,000
är för att det är något som vi i grund och botten säger till den som ringer av funktionen,

793
00:54:51,000 --> 00:54:55,000
vem ska använda funktionen SUMMA, "Hej, inte bara att du måste ge oss en rad

794
00:54:55,000 --> 00:54:59,000
av Ints, måste du också berätta hur stor den array som du har gett oss är. "

795
00:54:59,000 --> 00:55:03,000
[Basil] De kommer båda att vara kommandoradsargument?

796
00:55:03,000 --> 00:55:06,000
Nej, det är faktiskt argument som du skulle passera till funktionen.

797
00:55:06,000 --> 00:55:10,000
>> Låt mig göra en ny sida här.

798
00:55:10,000 --> 00:55:13,000
[Basil] Som namnet skulle passera-

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

800
00:55:24,000 --> 00:55:27,000
och jag kommer att sätta i min återkomst 0 här nere på botten,

801
00:55:27,000 --> 00:55:31,000
och säger att jag vill ringa summan funktionen.

802
00:55:31,000 --> 00:55:42,000
Jag vill säga int x = summa ();

803
00:55:42,000 --> 00:55:46,000
För att använda funktionen SUMMA jag måste passera både den array som jag vill sammanfatta

804
00:55:46,000 --> 00:55:51,000
och längden av uppsättningen, så det är där

805
00:55:51,000 --> 00:55:54,000
förutsatt att jag hade en rad Ints,

806
00:55:54,000 --> 00:56:12,000
säga att jag hade int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
typ av användning som hackat upp syntax där,

808
00:56:16,000 --> 00:56:21,000
vad jag skulle göra i summa jag skulle vilja gå i

809
00:56:21,000 --> 00:56:27,000
både numbaz och antalet 3

810
00:56:27,000 --> 00:56:30,000
att berätta summan funktionen "Okej, här matrisen jag vill att du ska summera."

811
00:56:30,000 --> 00:56:34,000
"Här är dess storlek."

812
00:56:34,000 --> 00:56:39,000
Verkar det vettigt? Besvarar det din fråga?

813
00:56:39,000 --> 00:56:42,000
>> På många sätt den gör parallella vad vi gör med största

814
00:56:42,000 --> 00:56:44,000
när vi har kommandoradsargumenten.

815
00:56:44,000 --> 00:56:47,000
Ett program som Caesar chiffer, till exempel, behövs det

816
00:56:47,000 --> 00:56:53,000
kommandoradsargument skulle inte kunna göra någonting.

817
00:56:53,000 --> 00:56:57,000
Det skulle inte vet hur man krypterar om du inte tala om vad för att använda

818
00:56:57,000 --> 00:57:03,000
eller om du inte tala om vad sträng du vill kryptera.

819
00:57:03,000 --> 00:57:08,000
Uppmaning för inmatning, det är där vi har 2 olika mekanismer

820
00:57:08,000 --> 00:57:14,000
för att ta in in från användaren, för att ta information från användaren.

821
00:57:14,000 --> 00:57:19,000
För problembild 1 såg vi denna getInt, GetString, getFloat sätt

822
00:57:19,000 --> 00:57:26,000
att förmå för inmatning, och det kallas med standard in strömmen.

823
00:57:26,000 --> 00:57:28,000
Det är något annorlunda.

824
00:57:28,000 --> 00:57:31,000
Det är något som du kan göra på en gång i stället för

825
00:57:31,000 --> 00:57:35,000
När du startar programmet, när du startar programmet körs.

826
00:57:35,000 --> 00:57:41,000
De kommandoradsargument alla anges när du startar programmet igång.

827
00:57:41,000 --> 00:57:47,000
Vi har blanda två av dem.

828
00:57:47,000 --> 00:57:52,000
När vi använder argument till en funktion, det är mycket som kommandoradsargument till huvud.

829
00:57:52,000 --> 00:57:56,000
Det är när du anropar funktionen måste du berätta det

830
00:57:56,000 --> 00:58:05,000
exakt vad den behöver för att utföra sina uppgifter.

831
00:58:05,000 --> 00:58:08,000
En annan bra sak att titta på, och jag ska låta dig titta på det på fritiden,

832
00:58:08,000 --> 00:58:11,000
och det var täckt i frågesporten-var denna föreställning om omfattningen

833
00:58:11,000 --> 00:58:15,000
och lokala variabler kontra globala variabler.

834
00:58:15,000 --> 00:58:18,000
Vill uppmärksamma det.

835
00:58:18,000 --> 00:58:23,000
>> Nu när vi får in på denna andra grejer,

836
00:58:23,000 --> 00:58:27,000
i vecka 3 började vi prata om sökning och sortering.

837
00:58:27,000 --> 00:58:32,000
Sökning och sortering, åtminstone i CS50,

838
00:58:32,000 --> 00:58:39,000
är mycket en introduktion till några av de mer teoretiska delarna av datavetenskap.

839
00:58:39,000 --> 00:58:42,000
Problemet med sökning, problemet med sortering

840
00:58:42,000 --> 00:58:46,000
är stora, kanoniska problem.

841
00:58:46,000 --> 00:58:52,000
Hur hittar man ett visst antal i en rad miljarder heltal?

842
00:58:52,000 --> 00:58:55,000
Hur hittar man ett visst namn i en telefonbok

843
00:58:55,000 --> 00:58:59,000
som lagras på din bärbara dator?

844
00:58:59,000 --> 00:59:04,000
Och så presenterar vi den här begreppet asymptotiska körtider

845
00:59:04,000 --> 00:59:11,000
att verkligen mäta hur länge, hur hårt dessa problem är,

846
00:59:11,000 --> 00:59:14,000
hur lång tid de tar att lösa.

847
00:59:14,000 --> 00:59:20,000
I, tror jag, 2011 s frågesport det finns ett problem som jag tycker förtjänar

848
00:59:20,000 --> 00:59:27,000
täcker mycket snabbt, vilket är en, problemet 12.

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

850
00:59:32,000 --> 00:59:41,000
>> Här pratar vi om snabbast möjliga körtid

851
00:59:41,000 --> 00:59:46,000
för en viss algoritm och sedan den långsammaste möjliga körtid.

852
00:59:46,000 --> 00:59:52,000
Detta Omega och O är egentligen bara genvägar.

853
00:59:52,000 --> 00:59:55,000
De är notationer genvägar för att säga

854
00:59:55,000 --> 00:59:59,000
hur snabbt på bästa möjliga fallet kommer vår algoritm springa,

855
00:59:59,000 --> 01:00:06,000
och hur långsamt i värsta möjliga fall kommer vår algoritm körs?

856
01:00:06,000 --> 01:00:10,000
Låt oss göra ett par av dessa, och dessa också omfattas

857
01:00:10,000 --> 01:00:13,000
på kort på asymptotisk notation, som jag rekommenderar.

858
01:00:13,000 --> 01:00:17,000
Jackson gjorde ett riktigt bra jobb.

859
01:00:17,000 --> 01:00:23,000
Med binär sökning, talar vi om binärsökning som en algoritm,

860
01:00:23,000 --> 01:00:28,000
och vi brukar tala om det i termer av dess stora O.

861
01:00:28,000 --> 01:00:30,000
Vad är den stora O?

862
01:00:30,000 --> 01:00:34,000
Vad är den långsammaste möjliga drifttid för binär sökning?

863
01:00:34,000 --> 01:00:36,000
[Student] N ^?

864
01:00:36,000 --> 01:00:41,000
Nära, jag antar liknar.

865
01:00:41,000 --> 01:00:43,000
Det är mycket snabbare än så.

866
01:00:43,000 --> 01:00:45,000
[Student] Binary? >> Ja, binär sökning.

867
01:00:45,000 --> 01:00:47,000
[Student] Det är log n.

868
01:00:47,000 --> 01:00:49,000
Log n, så vad gör log n menar?

869
01:00:49,000 --> 01:00:51,000
Det halverar det varje iteration.

870
01:00:51,000 --> 01:00:56,000
Exakt, så i den långsammaste möjliga fallet,

871
01:00:56,000 --> 01:01:00,000
säga om du har en sorterad array

872
01:01:00,000 --> 01:01:08,000
miljon heltal och antalet du söker

873
01:01:08,000 --> 01:01:14,000
är antingen den första elementet i matrisen eller den sista elementet i gruppen.

874
01:01:14,000 --> 01:01:18,000
Kom ihåg, fungerar den binära sökalgoritmen genom att titta på den mellersta elementet,

875
01:01:18,000 --> 01:01:21,000
se om det är matchen som du letar efter.

876
01:01:21,000 --> 01:01:23,000
Om det är så stor, du hittade det.

877
01:01:23,000 --> 01:01:27,000
>> På bästa möjliga fallet, hur snabbt rinner binär sökning?

878
01:01:27,000 --> 01:01:29,000
[Studenter] 1.

879
01:01:29,000 --> 01:01:32,000
1, är det konstant tid, stora O i 1. Ja.

880
01:01:32,000 --> 01:01:36,000
[Student] Jag har en fråga. När du säger loggar n, menar du när det gäller bas 2, eller hur?

881
01:01:36,000 --> 01:01:40,000
Ja, det är så att den andra saken.

882
01:01:40,000 --> 01:01:44,000
Vi säger log n, och jag antar att när jag var i gymnasiet

883
01:01:44,000 --> 01:01:48,000
Jag antog alltid att stocken var basen 10.

884
01:01:48,000 --> 01:01:57,000
Ja, så ja, logga bas 2 normalt är vad vi använder.

885
01:01:57,000 --> 01:02:02,000
Återigen, gå tillbaka till binär sökning, om du söker efter något

886
01:02:02,000 --> 01:02:05,000
elementet i slutet eller elementet i början,

887
01:02:05,000 --> 01:02:08,000
eftersom du startar i mitten och sedan kassera

888
01:02:08,000 --> 01:02:13,000
beroende halv uppfyller inte de kriterier som du letar efter,

889
01:02:13,000 --> 01:02:15,000
och du går vidare till nästa halv och nästa halv och nästa halv.

890
01:02:15,000 --> 01:02:19,000
Om jag söker efter den största elementet i miljon heltalsmatris

891
01:02:19,000 --> 01:02:25,000
Jag ska halvera den som mest logg på 1 miljon gånger

892
01:02:25,000 --> 01:02:28,000
innan jag testar slutligen och se att elementet jag söker

893
01:02:28,000 --> 01:02:33,000
är i den största eller i den högsta indexet i matrisen,

894
01:02:33,000 --> 01:02:38,000
och som kommer att ta logg av n, logga på 1 miljon gånger.

895
01:02:38,000 --> 01:02:40,000
>> Bubbla sortera.

896
01:02:40,000 --> 01:02:43,000
Minns ni algoritmen bubblan slag?

897
01:02:43,000 --> 01:02:47,000
Kevin, kan du ge mig en snabb resumé av vad som hände i bubblan Sortera algoritmen?

898
01:02:47,000 --> 01:02:50,000
[Kevin] I grunden går igenom allt i listan.

899
01:02:50,000 --> 01:02:52,000
Det ser på de två första.

900
01:02:52,000 --> 01:02:55,000
Om den första är större än den andra den swappar dem.

901
01:02:55,000 --> 01:02:58,000
Sedan jämförs andra och tredje, samma sak, swappar,

902
01:02:58,000 --> 01:03:00,000
tredje och fjärde, hela vägen ner.

903
01:03:00,000 --> 01:03:03,000
Större siffror kommer att följa upp till slutet.

904
01:03:03,000 --> 01:03:07,000
Och efter hur många loopar du är klar.

905
01:03:07,000 --> 01:03:11,000
Exakt, så vad Kevin sa att vi ska titta större antal

906
01:03:11,000 --> 01:03:15,000
bubbla upp till slutet av arrayen.

907
01:03:15,000 --> 01:03:19,000
Till exempel har något emot dig gå oss genom det här exemplet, om detta är vår matris?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Du tar 2 och 3.

909
01:03:21,000 --> 01:03:23,000
3 är större än 2, så att du byta dem.

910
01:03:23,000 --> 01:03:29,000
[Nate H] Rätt, så vi byter dessa, och så får vi 2, 3, 6, 4, och 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] Sedan jämföra 3 och 6.

912
01:03:31,000 --> 01:03:33,000
3 är mindre än 6, så att du lämnar dem,

913
01:03:33,000 --> 01:03:37,000
och 6 och 4, skulle du byta dem eftersom 4 är mindre än 6.

914
01:03:37,000 --> 01:03:42,000
[Nate H] Rätt, så jag får 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] och 9 är större än 6, så att du lämnar den.

916
01:03:46,000 --> 01:03:48,000
Och du skulle gå tillbaka genom det igen.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H] Är jag gjort i detta läge? >> [Kevin] Nej

918
01:03:50,000 --> 01:03:52,000
Och varför är jag inte gjort på denna punkt?

919
01:03:52,000 --> 01:03:54,000
Eftersom det ser ut som min grupp sorteras. Jag tittar på det.

920
01:03:54,000 --> 01:03:57,000
[Kevin] Gå igenom den igen och se till att det inte finns fler swappar

921
01:03:57,000 --> 01:04:00,000
innan du kan helt sluta.

922
01:04:00,000 --> 01:04:04,000
Exakt, så du måste hålla gå igenom och se till att det inte finns några swappar

923
01:04:04,000 --> 01:04:06,000
att du kan göra på denna punkt.

924
01:04:06,000 --> 01:04:08,000
Det var egentligen bara tur, som du sa, att vi hamnade

925
01:04:08,000 --> 01:04:12,000
bara behöva göra 1 passerar genom och vi är sorterade.

926
01:04:12,000 --> 01:04:16,000
Men för att göra detta i det allmänna fallet kommer vi faktiskt måste göra detta om och om igen.

927
01:04:16,000 --> 01:04:20,000
Och i själva verket var detta ett exempel på bästa möjliga fallet,

928
01:04:20,000 --> 01:04:24,000
som vi såg i problemet.

929
01:04:24,000 --> 01:04:28,000
Vi såg att det bästa möjliga fallet n.

930
01:04:28,000 --> 01:04:32,000
Vi gick igenom arrayen 1 gång.

931
01:04:32,000 --> 01:04:35,000
Vad är det värsta möjliga fallet för denna algoritm?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ^.

933
01:04:37,000 --> 01:04:41,000
Och vad tycker det utseendet? Vad skulle en array ser ut som skulle ta n ^ tid?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [ohörbart] sorteras.

935
01:04:43,000 --> 01:04:51,000
Exakt, så om jag hade matrisen 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
först 9 skulle bubbla hela vägen upp.

937
01:04:54,000 --> 01:04:59,000
Efter 1 iteration skulle vi ha 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Sedan 7 skulle bubbla upp, 6, 5, 2, 7, 9, och så vidare och så vidare.

939
01:05:07,000 --> 01:05:13,000
>> Vi skulle behöva gå igenom hela matrisen n gånger,

940
01:05:13,000 --> 01:05:16,000
och du kan faktiskt få något mer exakt än detta

941
01:05:16,000 --> 01:05:23,000
eftersom när vi har flyttat 9 hela vägen upp till sitt sista möjliga läge

942
01:05:23,000 --> 01:05:26,000
Vi vet att vi aldrig behöver jämföra mot det elementet igen.

943
01:05:26,000 --> 01:05:29,000
När vi börjar bubblar 7 upp

944
01:05:29,000 --> 01:05:35,000
Vi vet att vi kan stoppa när 7 är rätt innan 9

945
01:05:35,000 --> 01:05:37,000
eftersom vi redan jämförde 9 till det.

946
01:05:37,000 --> 01:05:46,000
Om du gör detta på ett smart sätt är det inte riktigt, antar jag, så mycket tid.

947
01:05:46,000 --> 01:05:49,000
Du kommer inte att jämföra alla möjliga [ohörbara] kombinationer

948
01:05:49,000 --> 01:05:55,000
varje gång du går igenom varje iteration.

949
01:05:55,000 --> 01:05:59,000
Men ändå, när vi talar om denna övre gräns säger vi att

950
01:05:59,000 --> 01:06:04,000
du tittar på N ^ jämförelser hela vägen igenom.

951
01:06:04,000 --> 01:06:12,000
>> Låt oss gå tillbaka, och eftersom vi börjar få lite ont om tid

952
01:06:12,000 --> 01:06:15,000
Jag skulle säga att du definitivt bör gå igenom resten av denna tabell,

953
01:06:15,000 --> 01:06:17,000
fylla ut allt.

954
01:06:17,000 --> 01:06:20,000
Tänk exempel. Tänk på konkreta exempel.

955
01:06:20,000 --> 01:06:22,000
Det är verkligen praktiskt och bra att göra.

956
01:06:22,000 --> 01:06:25,000
Dra ut.

957
01:06:25,000 --> 01:06:28,000
Detta är den typ av tabell som när du går igenom i datavetenskap

958
01:06:28,000 --> 01:06:32,000
du borde verkligen börja känna dem utantill.

959
01:06:32,000 --> 01:06:34,000
Det är den typ av frågor som du får i intervjuer.

960
01:06:34,000 --> 01:06:36,000
Det är massa saker som är bra att veta,

961
01:06:36,000 --> 01:06:41,000
och tänka på de kant fallen verkligen räkna ut hur att tänka på

962
01:06:41,000 --> 01:06:45,000
att veta att för Bubble sortera den sämsta matrisen

963
01:06:45,000 --> 01:06:52,000
att sortera med det är en som är i omvänd ordning.

964
01:06:52,000 --> 01:06:58,000
>> Pekare. Låt oss tala lite om pekare.

965
01:06:58,000 --> 01:07:03,000
Under de sista minuterna som vi har här

966
01:07:03,000 --> 01:07:11,000
Jag vet att detta är något tillsammans med I / O-det är ganska nytt.

967
01:07:11,000 --> 01:07:19,000
När vi talar om pekare anledningen till att vi vill tala om pekare

968
01:07:19,000 --> 01:07:24,000
beror en, när vi arbetar i C

969
01:07:24,000 --> 01:07:33,000
Vi är verkligen på en relativt låg nivå jämfört med de flesta moderna programmeringsspråk.

970
01:07:33,000 --> 01:07:38,000
Vi är faktiskt kan manipulera variabler i minnet,

971
01:07:38,000 --> 01:07:43,000
räkna ut var de är faktiskt belägna inom vårt RAM.

972
01:07:43,000 --> 01:07:46,000
När du har gått på att ta klasser operativsystem du ser

973
01:07:46,000 --> 01:07:48,000
att det är, återigen, typ av en abstraktion.

974
01:07:48,000 --> 01:07:50,000
Det är faktiskt inte fallet.

975
01:07:50,000 --> 01:07:52,000
Vi har virtuellt minne som döljer dessa uppgifter från oss.

976
01:07:52,000 --> 01:07:58,000
>> Men nu kan du räkna med att när du har ett program,

977
01:07:58,000 --> 01:08:02,000
till exempel när du börjar köra din Caesar chiffer program-

978
01:08:02,000 --> 01:08:06,000
Jag växla tillbaka till min iPad verkligen snabbt,

979
01:08:06,000 --> 01:08:12,000
att i början ditt program, om du har, säg,

980
01:08:12,000 --> 01:08:15,000
4 gigabyte RAM-minne på din bärbara dator,

981
01:08:15,000 --> 01:08:21,000
du får avsatt denna bit, och vi kommer att kalla detta RAM.

982
01:08:21,000 --> 01:08:25,000
Och det börjar på en plats vi kommer att ringa 0,

983
01:08:25,000 --> 01:08:30,000
och det slutar på en plats som vi kallar 4 gigabyte.

984
01:08:30,000 --> 01:08:37,000
Jag kan verkligen inte skriva. Människan, är att hacka.

985
01:08:37,000 --> 01:08:40,000
När programmet körs

986
01:08:40,000 --> 01:08:44,000
operativsystemet skär upp RAM,

987
01:08:44,000 --> 01:08:51,000
och det anges olika segment för olika delar av ditt program att leva i.

988
01:08:51,000 --> 01:08:58,000
Här nere detta område är typ av en ingenmansland.

989
01:08:58,000 --> 01:09:02,000
När du går upp lite längre här

990
01:09:02,000 --> 01:09:05,000
du har faktiskt den plats där

991
01:09:05,000 --> 01:09:09,000
koden för ditt program liv.

992
01:09:09,000 --> 01:09:13,000
Att den faktiska binär kod, faktiskt att körbar fil får laddas in i minnet

993
01:09:13,000 --> 01:09:17,000
När du kör ett program, och den lever i kodsegmentet.

994
01:09:17,000 --> 01:09:22,000
Och som ditt program exekverar processorn ser på detta kodsegment

995
01:09:22,000 --> 01:09:24,000
att räkna ut vad som är nästa instruktion?

996
01:09:24,000 --> 01:09:27,000
Vad är nästa kodrad behöver jag köra?

997
01:09:27,000 --> 01:09:31,000
>> Det finns också en datasegment, och det är där de strängkonstanter

998
01:09:31,000 --> 01:09:34,000
får lagras som du har använt.

999
01:09:34,000 --> 01:09:42,000
Och sedan längre upp finns denna plats som kallas högen.

1000
01:09:42,000 --> 01:09:46,000
Vi åt minnet där med malloc,

1001
01:09:46,000 --> 01:09:49,000
och sedan mot den absoluta toppen av ditt program

1002
01:09:49,000 --> 01:09:52,000
Det finns stacken,

1003
01:09:52,000 --> 01:09:57,000
och det är där vi har spelat under större delen av början.

1004
01:09:57,000 --> 01:09:59,000
Detta är inte att skala eller något.

1005
01:09:59,000 --> 01:10:03,000
Mycket av detta är mycket maskin beroende,

1006
01:10:03,000 --> 01:10:10,000
operativsystemet beroende, men det är relativt hur saker och ting blir chunked upp.

1007
01:10:10,000 --> 01:10:17,000
När du kör ett program och du deklarerar en variabel som heter X-

1008
01:10:17,000 --> 01:10:27,000
Jag ska rita en annan låda nere, och det kommer att bli RAM också.

1009
01:10:27,000 --> 01:10:29,000
Och jag kommer att se ut.

1010
01:10:29,000 --> 01:10:34,000
Vi kommer dra taggiga linjer för att indikera detta är bara en liten del av RAM-minne

1011
01:10:34,000 --> 01:10:38,000
och inte alla av det som vi drar på toppen.

1012
01:10:38,000 --> 01:10:43,000
>> Om jag deklarerar en heltalsvariabel kallad x,

1013
01:10:43,000 --> 01:10:49,000
vad jag faktiskt får är en kartläggning

1014
01:10:49,000 --> 01:10:54,000
som lagras i symboltabellen i mitt program

1015
01:10:54,000 --> 01:11:00,000
som ansluter namnet X till denna region av minne som jag har ritat

1016
01:11:00,000 --> 01:11:03,000
här mellan de vertikala staplarna.

1017
01:11:03,000 --> 01:11:08,000
Om jag har en kodrad i mitt program som säger x = 7

1018
01:11:08,000 --> 01:11:15,000
processorn vet "Åh, okej, jag vet att x bor på denna plats i minnet."

1019
01:11:15,000 --> 01:11:25,000
"Jag ska gå vidare och skriva en 7 där."

1020
01:11:25,000 --> 01:11:28,000
Hur vet den vilken plats detta är i minne?

1021
01:11:28,000 --> 01:11:30,000
Tja, det är allt gjort vid kompileringen.

1022
01:11:30,000 --> 01:11:34,000
Kompilatorn tar hand om fördelningen där varje variabel kommer att gå

1023
01:11:34,000 --> 01:11:40,000
och skapa en speciell kartläggning eller snarare ansluta prickar

1024
01:11:40,000 --> 01:11:43,000
mellan en symbol och där det går, en variabel namn

1025
01:11:43,000 --> 01:11:46,000
och där det kommer att leva i minnet.

1026
01:11:46,000 --> 01:11:50,000
Men det visar sig att vi faktiskt kan komma åt den i våra program också.

1027
01:11:50,000 --> 01:11:55,000
Detta blir viktigt när vi börjar prata om några av de datastrukturer,

1028
01:11:55,000 --> 01:11:58,000
vilket är ett begrepp som vi kommer att införa senare.

1029
01:11:58,000 --> 01:12:09,000
>> Men nu, vad du kan veta är att jag kan skapa en pekare till denna plats, x.

1030
01:12:09,000 --> 01:12:12,000
Till exempel kan jag skapa en pekare variabel.

1031
01:12:12,000 --> 01:12:16,000
När vi skapar en pekare variabel använder vi stjärnan notation.

1032
01:12:16,000 --> 01:12:21,000
I det här fallet säger det jag ska skapa en pekare till en int.

1033
01:12:21,000 --> 01:12:24,000
Det är en typ precis som alla andra.

1034
01:12:24,000 --> 01:12:27,000
Vi ger det en variabel som y,

1035
01:12:27,000 --> 01:12:32,000
och då vi satt det lika med adressen till en adress.

1036
01:12:32,000 --> 01:12:38,000
I detta fall, kan vi ställa y peka till x

1037
01:12:38,000 --> 01:12:43,000
genom att ta adressen av x, som vi gör med denna et-tecken,

1038
01:12:43,000 --> 01:12:55,000
och sedan sätter vi y att peka på den.

1039
01:12:55,000 --> 01:12:59,000
Vad detta i huvudsak innebär är om vi ser på vår RAM

1040
01:12:59,000 --> 01:13:02,000
detta skapar en separat variabel.

1041
01:13:02,000 --> 01:13:04,000
Det kommer att kalla det y,

1042
01:13:04,000 --> 01:13:06,000
och när denna rad med kod körs

1043
01:13:06,000 --> 01:13:13,000
det faktiskt kommer att skapa en liten pekare som vi vanligtvis dra som en pil,

1044
01:13:13,000 --> 01:13:15,000
och det sätter y att peka på x.

1045
01:13:15,000 --> 01:13:17,000
Ja.

1046
01:13:17,000 --> 01:13:19,000
[Student] Om x är redan en pekare, skulle du göra just

1047
01:13:19,000 --> 01:13:22,000
int * y = x i stället för et-tecknet?

1048
01:13:22,000 --> 01:13:24,000
Ja.

1049
01:13:24,000 --> 01:13:27,000
Om x är redan en pekare, kan du ställa in 2 pekare lika med varandra,

1050
01:13:27,000 --> 01:13:30,000
i vilket fall Y inte skulle peka på x,

1051
01:13:30,000 --> 01:13:34,000
men det skulle peka på vad X pekar på.

1052
01:13:34,000 --> 01:13:37,000
Tyvärr kan vi för sent.

1053
01:13:37,000 --> 01:13:44,000
>> Vad jag vill säga i det här läget kan vi prata om det här offline

1054
01:13:44,000 --> 01:13:49,000
men jag skulle säga börja arbeta igenom problemet, # 14.

1055
01:13:49,000 --> 01:13:53,000
Du kan se det redan lite fyllas i för dig här.

1056
01:13:53,000 --> 01:13:57,000
Du kan se att när vi deklarerar 2 pekare, int * x och * y,

1057
01:13:57,000 --> 01:14:01,000
och konstaterar att peka * bredvid variabeln var något som gjordes förra året.

1058
01:14:01,000 --> 01:14:05,000
Det visar sig att detta liknar vad vi gör i år.

1059
01:14:05,000 --> 01:14:11,000
Det spelar ingen roll var du skriver * när du förklara pekaren.

1060
01:14:11,000 --> 01:14:17,000
Men vi har skrivit * bredvid den typ

1061
01:14:17,000 --> 01:14:24,000
eftersom det gör det mycket tydligt att du förklara en pekare variabel.

1062
01:14:24,000 --> 01:14:27,000
Du kan se att förklara de 2 pekarna ger oss 2 lådor.

1063
01:14:27,000 --> 01:14:31,000
Här när vi satt x lika med malloc

1064
01:14:31,000 --> 01:14:34,000
vad detta säger avsätter minne i högen.

1065
01:14:34,000 --> 01:14:41,000
Denna lilla ruta här, denna cirkel, ligger på högen.

1066
01:14:41,000 --> 01:14:43,000
X pekar på det.

1067
01:14:43,000 --> 01:14:46,000
Observera att y fortfarande inte pekar på något.

1068
01:14:46,000 --> 01:14:50,000
För att få minnes-för att lagra numret 42 till X

1069
01:14:50,000 --> 01:14:55,000
Vi skulle använda vad notation?

1070
01:14:55,000 --> 01:14:59,000
[Student] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Exakt, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
Det innebär att följa pilen och kasta 42 där.

1073
01:15:06,000 --> 01:15:09,000
Här där vi satt y och x har vi y pekar på x.

1074
01:15:09,000 --> 01:15:13,000
Återigen är så här precis vad Kevin sa där vi satt y lika med x.

1075
01:15:13,000 --> 01:15:15,000
Y inte pekar på x.

1076
01:15:15,000 --> 01:15:19,000
Snarare är det att peka på vad x pekar på också.

1077
01:15:19,000 --> 01:15:24,000
>> Och slutligen i denna sista ruta finns 2 möjliga saker som vi kan göra.

1078
01:15:24,000 --> 01:15:28,000
En är att vi kan säga * x = 13.

1079
01:15:28,000 --> 01:15:33,000
Den andra saken är att vi kan säga-Alex, vet du vad vi kan göra här?

1080
01:15:33,000 --> 01:15:37,000
Man kan säga * x = 13 eller-

1081
01:15:37,000 --> 01:15:41,000
[Student] Du kan säga int vad som helst.

1082
01:15:41,000 --> 01:15:45,000
[Nate H] Om detta skulle kallas en int variabel som vi kunde göra det.

1083
01:15:45,000 --> 01:15:49,000
Vi skulle också kunna säga * y = 13 eftersom de är båda pekar på samma plats,

1084
01:15:49,000 --> 01:15:51,000
så att vi kunde använda antingen variabel för att komma dit.

1085
01:15:51,000 --> 01:15:56,000
Ja. >> [Student] Hur skulle det se ut om vi bara säga int x är 13?

1086
01:15:56,000 --> 01:16:00,000
Det skulle vara att förklara en ny variabel som heter X, som inte skulle fungera.

1087
01:16:00,000 --> 01:16:04,000
Vi skulle ha en kollision eftersom vi förklarade x för att vara en pekare upp här.

1088
01:16:04,000 --> 01:16:10,000
[Student] Om vi ​​bara hade detta påstående i sig vad skulle det se ut i termer av cirkeln?

1089
01:16:10,000 --> 01:16:14,000
Om vi ​​hade x = 13 då vi skulle ha en låda, och snarare än att ha en pil

1090
01:16:14,000 --> 01:16:16,000
kommer ut ur lådan vi skulle dra det som bara en 13.

1091
01:16:16,000 --> 01:16:19,000
[Student] i rutan. Okej.

1092
01:16:19,000 --> 01:16:24,000
>> Tack för att titta, och lycka till på Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]