1
00:00:00,000 --> 00:00:02,200
[Powered by Google Translate] [Uke 3]

2
00:00:02,200 --> 00:00:03,950
[David J. Malan - Harvard University]

3
00:00:03,950 --> 00:00:07,140
[Dette er CS50. - CS50.TV]

4
00:00:07,140 --> 00:00:10,720
La meg styre oss i retning av der vi slapp forrige gang,

5
00:00:10,720 --> 00:00:13,890
som var begynt å tenke litt mer enn om syntaks

6
00:00:13,890 --> 00:00:17,150
og prøver å tenke litt mindre om alle de bagateller

7
00:00:17,150 --> 00:00:20,630
som tar litt tid å venne seg til så langt i form av semikolon

8
00:00:20,630 --> 00:00:22,360
og parenteser og klammeparentes,

9
00:00:22,360 --> 00:00:25,630
å begynne å ta ting litt på et høyere konseptuelt nivå

10
00:00:25,630 --> 00:00:28,800
slik at de problemene vi nå begynne å løse i løpet av de neste ukene

11
00:00:28,800 --> 00:00:32,340
kommer til å innebære mye mer inn høyere nivå konseptuelle problemer

12
00:00:32,340 --> 00:00:36,310
og litt mindre i syntaktisk som du får dine føtter våt

13
00:00:36,310 --> 00:00:40,090
og hendene skitne med noen av syntaksen fra disse siste ukene.

14
00:00:40,090 --> 00:00:43,690
>> Så husker at forrige uke lanserte vi denne oppfatningen av en matrise.

15
00:00:43,690 --> 00:00:49,320
Og en matrise på engelsk kan beskrives som hva? >> [Uhørlig student respons]

16
00:00:49,320 --> 00:00:51,710
Beklager?

17
00:00:51,710 --> 00:00:54,810
En samling av? >> [Uhørlig student respons] >> Ok, bra.

18
00:00:54,810 --> 00:00:57,820
En samling av elementer. Så vi så arrays i Scratch.

19
00:00:57,820 --> 00:01:01,880
Hvis du tilfeldigvis bruke for pset 0 en av Scratch lister som du kan dra ting

20
00:01:01,880 --> 00:01:05,410
som appelsiner og bananer i, en opptelling av former,

21
00:01:05,410 --> 00:01:07,100
som er typen som hva en matrise er.

22
00:01:07,100 --> 00:01:10,980
Og deretter mer teknisk, i sammenheng med en faktisk datamaskin,

23
00:01:10,980 --> 00:01:14,730
en matrise er rett og slett en sammenhengende del av minnet.

24
00:01:14,730 --> 00:01:18,590
Med andre ord, har du en byte, og deretter en annen byte, og deretter en annen byte, og deretter en annen byte,

25
00:01:18,590 --> 00:01:21,330
og hvis du skulle trekke disse bytes i et bilde,

26
00:01:21,330 --> 00:01:24,510
de ville være rygg mot rygg til rygg mot rygg. Det er det vi mener med sammenhengende.

27
00:01:24,510 --> 00:01:26,690
>> Så det er byte nummer 1, deretter 2, deretter 3.

28
00:01:26,690 --> 00:01:29,680
Det betyr ikke opp her, her oppe, her oppe, her oppe.

29
00:01:29,680 --> 00:01:33,800
En matrise er en sammenhengende del av 0 eller flere byte.

30
00:01:33,800 --> 00:01:36,160
Så hva er de nyttige for?

31
00:01:36,160 --> 00:01:40,090
Husker vi hadde denne typen contrived eksempel på lagring folks quiz karakterer i et program

32
00:01:40,090 --> 00:01:42,580
å beregne din quiz gjennomsnittet for noen kurs,

33
00:01:42,580 --> 00:01:46,780
og huske at vi kunne begynne å skrive at programmet ved å erklære en variabel quiz1.

34
00:01:46,780 --> 00:01:49,550
Da kunne vi ha en annen variabel kalt quiz2.

35
00:01:49,550 --> 00:01:52,030
Men så hvis det var 3 quizer i denne klassen, quiz4.

36
00:01:52,030 --> 00:01:55,710
Eller hvis det var en ukentlig quiz, ville det være quiz5, quiz6, quiz7.

37
00:01:55,710 --> 00:01:58,520
Så du ville ha alle disse variablene erklært innsiden av hoved

38
00:01:58,520 --> 00:02:00,470
eller et annet sted i programmet,

39
00:02:00,470 --> 00:02:03,870
og problemet med denne tilnærmingen, lett skjønt det er å bare kopiere og lime inn,

40
00:02:03,870 --> 00:02:06,120
er det bare veldig fort blir uhåndterlig.

41
00:02:06,120 --> 00:02:09,360
Gud forby du faktisk har 30 spørrekonkurranser eller 50 spørrekonkurranser.

42
00:02:09,360 --> 00:02:12,080
Hvis det er som en high school stil daglig pop quiz,

43
00:02:12,080 --> 00:02:15,910
så du bare har en latterlig lang liste av variabler deklareres,

44
00:02:15,910 --> 00:02:17,780
og dette bare veldig fort kommer ut av kontroll.

45
00:02:17,780 --> 00:02:20,820
Det er stygt, er det vanskelig å vedlikeholde, er det så mye lettere å gjøre en skrivefeil

46
00:02:20,820 --> 00:02:23,910
hvis du får en rekke skrevet feil et sted i programmet.

47
00:02:23,910 --> 00:02:26,800
>> Så vi introduserte begrepet en matrise i stedet.

48
00:02:26,800 --> 00:02:30,760
Og huske at vi implementert dette programmet ved å gjøre litt noe sånt som dette.

49
00:02:30,760 --> 00:02:33,950
La meg gå inn i dagens Kilde 3 mandag katalog

50
00:02:33,950 --> 00:02:37,160
og åpne opp array, som vi så forrige gang.

51
00:02:37,160 --> 00:02:39,940
Og selv om det var et par nye C triks her,

52
00:02:39,940 --> 00:02:41,920
blant dem ideen om en konstant,

53
00:02:41,920 --> 00:02:47,140
husker at vi erklært flere flyter hovedsak ved hjelp av denne syntaksen:

54
00:02:47,140 --> 00:02:51,750
flyte, så navnet på variabelen, så vi brukte firkant parenteser virkelig for første gang,

55
00:02:51,750 --> 00:02:55,450
og hva vi gjorde innsiden av de firkantede bukseseler ble effektivt satt et tall.

56
00:02:55,450 --> 00:02:59,780
Men i stedet for å sette et tall, la jeg denne ord med store bokstaver, spørrekonkurranser.

57
00:02:59,780 --> 00:03:03,220
Og hva var motivasjonen for å sette en balanseført ord som spørrekonkurranser

58
00:03:03,220 --> 00:03:08,170
og deretter bruke linje 17 er trikset her for å faktisk gi den et nummer?

59
00:03:08,170 --> 00:03:11,240
Hva var motivasjonen der? Ja.

60
00:03:11,240 --> 00:03:13,360
>> [Uhørlig student respons] >> Nettopp.

61
00:03:13,360 --> 00:03:16,630
Hvis vi ønsker å endre denne verdien 2, vi trenger bare å endre den i en plass

62
00:03:16,630 --> 00:03:19,680
fordi vurdere - Jeg vet ikke engang huske hva dette programmet gjorde akkurat,

63
00:03:19,680 --> 00:03:22,040
men hvis du bare skumme det du ser spørrekonkurranser, quiz.

64
00:03:22,040 --> 00:03:24,720
Du ser spørrekonkurranser, ned her mer spørrekonkurranser.

65
00:03:24,720 --> 00:03:28,180
Så hvis vi ikke har dette konstant, denne bruken av skarp definere,

66
00:03:28,180 --> 00:03:33,320
vi ville ha skrevet to, deretter 2, deretter 2, deretter 2, som er fine. Det ville være like riktig.

67
00:03:33,320 --> 00:03:36,220
Men anta at neste år har vi tre quizer i CS50.

68
00:03:36,220 --> 00:03:39,190
Så jeg må gå og oppdatere koden, må jeg rekompilere det,

69
00:03:39,190 --> 00:03:43,820
men problemet er hvis jeg gjør noe dumt, som jeg overse en omtale av to

70
00:03:43,820 --> 00:03:46,750
og glemmer å plugge i tre, kan hele programmet veldig godt bryte.

71
00:03:46,750 --> 00:03:48,720
Så vi bare be om problemer.

72
00:03:48,720 --> 00:03:53,170
>> Så tanken om en konstant handler om factoring ut noen del av data,

73
00:03:53,170 --> 00:03:56,070
enten det er en streng eller en røye eller en flåte eller hva,

74
00:03:56,070 --> 00:04:00,070
og erklære det en plass, slik at du kan lettere endre det i fremtiden.

75
00:04:00,070 --> 00:04:03,660
Og det er også ærlig, litt lettere å lese fordi hvis du bare tenker på dette nå,

76
00:04:03,660 --> 00:04:07,840
det er spørrekonkurranser, eller vi kan selv endre navnet noe sånt som NUMBER_OF_QUIZZES

77
00:04:07,840 --> 00:04:09,430
eller noe mer eksplisitt.

78
00:04:09,430 --> 00:04:11,830
Koden blir bare litt mer opplagt på hva det gjør,

79
00:04:11,830 --> 00:04:15,780
og du lurer på litt mindre hva nummer 2 kan skje til å bety.

80
00:04:15,780 --> 00:04:18,920
Så den konstante hadde ingenting å gjøre fundamentalt med arrays.

81
00:04:18,920 --> 00:04:22,990
Matrisen ble introdusert i form av disse firkantede bukseseler.

82
00:04:22,990 --> 00:04:26,610
>> Så merke til at i tråd 23 spør vi bruker, "Hva var dine quiz score?"

83
00:04:26,610 --> 00:04:31,120
Så vi bare har denne sløyfen som tilsynelatende ber brukeren om sine karakterer. Hvordan?

84
00:04:31,120 --> 00:04:37,460
Det gjentar 0-2. Og jeg sier 2 fordi quizer i alle caps er nå 2.

85
00:04:37,460 --> 00:04:42,310
Så det gjentar fra 0 til 2 og deretter det skrives ut Quiz # noe av noe,

86
00:04:42,310 --> 00:04:45,830
og deretter den bruker GetFloat å få en verdi fra brukeren.

87
00:04:45,830 --> 00:04:49,050
Så merke dette er den eneste andre nye stykke syntaks fra sist onsdag.

88
00:04:49,050 --> 00:04:53,120
Hvis du ønsker å lagre noe på et bestemt sted i denne matrisen,

89
00:04:53,120 --> 00:04:55,460
du igjen bruke klammeparentesene.

90
00:04:55,460 --> 00:04:57,030
>> Så det er litt av dikotomi her.

91
00:04:57,030 --> 00:04:59,040
Den første gangen du bruker hakeparenteser

92
00:04:59,040 --> 00:05:02,250
du bruke den til å angi hvor stor du vil at tabellen skal være.

93
00:05:02,250 --> 00:05:06,580
Men dette neste sammenheng her hvor vi igjen ansette disse hakeparenteser

94
00:05:06,580 --> 00:05:10,540
betyr hvor i denne matrisen vil du sette noen verdi?

95
00:05:10,540 --> 00:05:13,650
Og skillet her kan utledes fra sammenheng.

96
00:05:13,650 --> 00:05:17,130
Legg merke her har vi en datatype, så har vi navnet på en variabel,

97
00:05:17,130 --> 00:05:20,770
så har vi våre firkant parenteser med en rekke inne, semikolon. Det var det.

98
00:05:20,770 --> 00:05:22,290
Så det er en erklæring.

99
00:05:22,290 --> 00:05:28,390
Det er akkurat som om vi hadde gjort noe sånt flyte Grade1, float Grade2;

100
00:05:28,390 --> 00:05:31,730
men igjen, dette svært raskt tilfaller inn altfor mye kopiere, lime,

101
00:05:31,730 --> 00:05:34,260
så i stedet vi bare forenklet det som sådan,

102
00:05:34,260 --> 00:05:38,800
som betyr heretter vi har en karakter som kan lagres på brakett 0,

103
00:05:38,800 --> 00:05:41,760
Vi har en annen karakter som kan lagres på trinn 1,

104
00:05:41,760 --> 00:05:46,890
men hva om jeg tabbe og, for eksempel, går min sløyfe så langt -

105
00:05:46,890 --> 00:05:48,740
for eksempel, gjør jeg dette mindre enn eller lik,

106
00:05:48,740 --> 00:05:50,620
som husker var kilden til en tidligere bug -

107
00:05:50,620 --> 00:05:55,590
som betyr effektivt at på noen tredje utilsiktet gjentakelse av denne sløyfen

108
00:05:55,590 --> 00:06:00,380
Jeg bruker brakett 2. Effektivt, hva kan skje her? Beklager?

109
00:06:00,380 --> 00:06:02,860
[Student] Det kommer til å bli erstattet. >> Er det kommer til å bli erstattet?

110
00:06:02,860 --> 00:06:04,520
Hva ville bli erstattet?

111
00:06:04,520 --> 00:06:10,890
Dette bokstavelig sier erstatte det er på stedet 2 med returverdien av GetFloat.

112
00:06:10,890 --> 00:06:13,690
Men problemet er hvor stor er rekken på dette punktet i historien?

113
00:06:13,690 --> 00:06:17,730
[Uhørlig student respons] >> Matrisen er fortsatt bare av størrelse 2

114
00:06:17,730 --> 00:06:22,730
fordi tabellen, som en variabel, ble erklært først, før vi brukte den,

115
00:06:22,730 --> 00:06:27,220
og vi angitt her på grunn av dette konstant at jeg har to karakterer som jeg kommer til å sette.

116
00:06:27,220 --> 00:06:29,930
>> Men husk, dataforskere begynne å telle fra 0.

117
00:06:29,930 --> 00:06:33,620
Så det første stedet i denne matrisen er brakett 0.

118
00:06:33,620 --> 00:06:40,210
Neste lokasjon er en. Denne saken er aldri så litt for langt til siden.

119
00:06:40,210 --> 00:06:42,870
Så med andre ord, hvis jeg faktisk hadde denne tabellen -

120
00:06:42,870 --> 00:06:46,790
og la meg se hvor godt dette cooperates her for oss -

121
00:06:46,790 --> 00:06:52,360
hvis jeg har en matrise som jeg har rett og slett tegnet som følger

122
00:06:52,360 --> 00:06:56,750
og jeg har avsatt plass for to elementer, kan jeg trekke dette som dette i minnet

123
00:06:56,750 --> 00:06:58,020
hvor denne store hvite lerretet er.

124
00:06:58,020 --> 00:07:00,920
Det er bare RAM jeg har i min datamaskin, en gig RAM, 2 gigabyte RAM, uansett,

125
00:07:00,920 --> 00:07:05,400
men disse to boksene som nå individuelt representerer en flåte, 32 biter.

126
00:07:05,400 --> 00:07:10,860
Så hvis jeg legger en rekke her som 1.0, så jeg satte et annet nummer her som 3,2

127
00:07:10,860 --> 00:07:15,280
men så gjør jeg to brakett, det er som å sette noe her.

128
00:07:15,280 --> 00:07:17,820
Og som bildet antyder, det er ingenting der.

129
00:07:17,820 --> 00:07:20,450
Det er liksom som ingenmannsland fordi jeg ikke har bedt om operativsystemet

130
00:07:20,450 --> 00:07:23,550
å gi meg denne tredje quiz.

131
00:07:23,550 --> 00:07:26,940
Hvis jeg hadde lyst at tredje quiz, jeg skulle ha hatt forethought

132
00:07:26,940 --> 00:07:31,700
å be operativsystemet for det ved å erklære quizer å være ikke 2

133
00:07:31,700 --> 00:07:34,210
men å i stedet utgjøre 3.

134
00:07:34,210 --> 00:07:39,000
>> Så med andre ord, ser det bildet som vi effektivt har for hånden som dette her.

135
00:07:39,000 --> 00:07:42,260
Dette er igjen ingenmannsland. Vi bedre ikke prøve å skrive verdier her.

136
00:07:42,260 --> 00:07:45,300
Men igjen, fordi dataforskere telle fra 0,

137
00:07:45,300 --> 00:07:49,520
når vi snakker om denne plasseringen i matrisen, er det ment å være plassering 0,

138
00:07:49,520 --> 00:07:53,890
dette er ment å være plassering 1, og dette betyr ikke engang eksisterer

139
00:07:53,890 --> 00:07:57,380
fordi vi bare bedt operativsystemet for to slike steder.

140
00:07:57,380 --> 00:08:00,130
Så de av dere med tidligere erfaring med programmering fra andre språk

141
00:08:00,130 --> 00:08:04,150
kanskje vet at dette er ikke alltid tilfelle med matriser eller ting som kalles vektorer.

142
00:08:04,150 --> 00:08:06,930
Snarere kan du bare fortsette å legge og legge og legge ting til matriser,

143
00:08:06,930 --> 00:08:10,720
som, ærlig, hadde vi den muligheten i spill og ennå vi synes å ha gitt det opp her

144
00:08:10,720 --> 00:08:15,160
fordi med C er du programmerer mye mer eksplisitt.

145
00:08:15,160 --> 00:08:17,980
Det er bare du og datamaskinen akkurat nå, og at datamaskinen er bare kommer til å gjøre

146
00:08:17,980 --> 00:08:19,530
hva du ber den om.

147
00:08:19,530 --> 00:08:24,270
Så hvis du bare fortelle det for å gi deg to flottører ved hjelp av linje 22 her,

148
00:08:24,270 --> 00:08:27,640
det er alt du kommer til å komme tilbake fra operativsystemet: plass til 2.

149
00:08:27,640 --> 00:08:34,049
>> Så i økende grad programmene skal tidvis være buggy med hensyn til arrays.

150
00:08:34,049 --> 00:08:37,520
Dette er bare en slags natur dyret der alle av oss er ufeilbarlige,

151
00:08:37,520 --> 00:08:42,490
og på et tidspunkt vil du høyst sannsynlig indeks utover grensen av arrayet.

152
00:08:42,490 --> 00:08:45,980
Og det er bare en fancy måte å si at du gikk inn brakett noe

153
00:08:45,980 --> 00:08:49,970
og noe var bare for stor til et tall. Du gikk utenfor grensene av arrayet.

154
00:08:49,970 --> 00:08:51,530
Men oppsiden er nå dette.

155
00:08:51,530 --> 00:08:54,990
Resten av dette programmet har egentlig ingenting fundamentalt å gjøre med arrays.

156
00:08:54,990 --> 00:08:58,180
Det handler bare om noen enkel aritmetikk for databehandling gjennomsnitt.

157
00:08:58,180 --> 00:09:03,200
Så vi har her i dette for loop her først en variabel kalt sum som vi initialisere til 0.

158
00:09:03,200 --> 00:09:09,020
Da vi iterate fra 0 til 2 igjen, og vi legger til at summering variabel

159
00:09:09,020 --> 00:09:12,620
-te klasse, så brakett 0, så braketten en.

160
00:09:12,620 --> 00:09:15,130
Og deretter som du ville gjort i grunnskolen til å beregne gjennomsnitt,

161
00:09:15,130 --> 00:09:19,420
vi bare ta denne summen, dele den med det totale antall tester,

162
00:09:19,420 --> 00:09:22,520
og deretter for godt mål vi kaller en funksjon her kalt runde.

163
00:09:22,520 --> 00:09:28,580
>> Nå, som en side, hva er greia med denne parenthetical int på linje 34?

164
00:09:28,580 --> 00:09:31,730
Det kan ha kommet opp allerede i snitt, har egentlig ikke snakket om det formelt her,

165
00:09:31,730 --> 00:09:35,210
men hva er dette int i parentesar sannsynligvis gjør? >> [Uhørlig student respons]

166
00:09:35,210 --> 00:09:38,500
Ja, dette refererer til støping eller typecasting,

167
00:09:38,500 --> 00:09:41,690
som betyr å ta en datatype og konvertere den til en annen.

168
00:09:41,690 --> 00:09:45,400
Du kan ikke gjøre dette med alle datatyper fordi noen ganger det ville være litt rart.

169
00:09:45,400 --> 00:09:49,640
Men i dette tilfellet, hvis returverdien runden er en flottør

170
00:09:49,640 --> 00:09:53,880
fordi, tross alt, jeg tar en dupp og dele det på et tall som 2,

171
00:09:53,880 --> 00:09:55,840
Jeg kommer til å få tilbake en flåte.

172
00:09:55,840 --> 00:10:00,760
Men grunnskolen folk ikke liker å vite at deres gjennomsnittlige var 93,4

173
00:10:00,760 --> 00:10:04,420
fordi de vil innse at de var aldri så nær at 95 avrunding punktet.

174
00:10:04,420 --> 00:10:09,540
>> Så vi ønsker å i stedet bruke int å runde alle til nærmeste int,

175
00:10:09,540 --> 00:10:12,730
som i dette tilfellet kommer til å være 94 med noe punkt etter den.

176
00:10:12,730 --> 00:10:14,530
Så det er bare en liten matematisk triks.

177
00:10:14,530 --> 00:10:17,570
Og vi vil komme tilbake til denne tanken for å kaste fordi det vil ha konsekvenser,

178
00:10:17,570 --> 00:10:21,640
Hvis du ikke har oppdaget allerede, for problemet sett 2.

179
00:10:21,640 --> 00:10:25,210
Så en matrise så kan du tenke på - det kommer til å gjøre meg smile hele dagen.

180
00:10:25,210 --> 00:10:27,830
Det ser ut som dette hvis du tegner et bilde av det,

181
00:10:27,830 --> 00:10:31,460
men nøkkelen er at størrelsen også er valgt av deg

182
00:10:31,460 --> 00:10:34,050
når du ber om det fra operativsystemet.

183
00:10:34,050 --> 00:10:39,460
Eventuelle spørsmål deretter på arrays? Ja.

184
00:10:39,460 --> 00:10:47,080
[Uhørlig student spørsmål]

185
00:10:47,080 --> 00:10:49,310
Ah, godt spørsmål.

186
00:10:49,310 --> 00:10:53,150
Spørsmålet er hva som skjer med null 0 i array? Det finnes ikke i denne sammenheng.

187
00:10:53,150 --> 00:10:57,430
Som bare finnes i sammenheng med strenger, som vi er i ferd med å komme til i løpet av et øyeblikk.

188
00:10:57,430 --> 00:11:02,300
Men for en matrise, som i dette tilfellet, er alt du får det du ber operativsystemet for.

189
00:11:02,300 --> 00:11:04,050
>> Og som en side, så dette være uklart,

190
00:11:04,050 --> 00:11:07,030
Jeg holder å si at du spør operativsystemet, spør operativsystemet.

191
00:11:07,030 --> 00:11:10,090
Et operativsystem, som du sikkert vet, er Mac OS, Windows, Linux.

192
00:11:10,090 --> 00:11:13,560
Når du ringer funksjoner som GetFloat

193
00:11:13,560 --> 00:11:19,280
eller du erklære variabler som karakterer,

194
00:11:19,280 --> 00:11:23,200
på slutten av dagen er du effektivt å spørre noen andre til å gi deg den minne

195
00:11:23,200 --> 00:11:25,940
fordi vi som håper programmerere

196
00:11:25,940 --> 00:11:28,800
har ingen anelse om hvordan å faktisk få fysisk tilgang til minnet.

197
00:11:28,800 --> 00:11:31,100
Men noen gjør: operativsystemet.

198
00:11:31,100 --> 00:11:36,630
Så i tillegg til å presentere oss med pen ikoner og menyer og mapper og lignende

199
00:11:36,630 --> 00:11:39,050
som du ser på ditt skrivebord, enten en Mac eller PC,

200
00:11:39,050 --> 00:11:42,240
operativsystemer også gjøre det lave nivået dagligdagse ting,

201
00:11:42,240 --> 00:11:44,680
den svært tekniske ting å forvalte gigabyte

202
00:11:44,680 --> 00:11:48,780
eller 2 gigabyte minne som du har, administrerende CPU som du har, og så videre.

203
00:11:48,780 --> 00:11:50,170
Så når du skriver kode,

204
00:11:50,170 --> 00:11:53,900
du virkelig trekke på operativsystemet i den forstand.

205
00:11:53,900 --> 00:11:55,720
Jeg kommer til å minimere det. OK.

206
00:11:55,720 --> 00:11:59,980
>> Andre spørsmål om arrays?

207
00:12:00,330 --> 00:12:02,520
Nei? Okay.

208
00:12:02,520 --> 00:12:06,680
Så overgangen naturlig fra arrays er faktisk et emne som er litt kjent.

209
00:12:06,680 --> 00:12:09,570
Og vi så aldri så kort på denne siste gangen også.

210
00:12:09,570 --> 00:12:12,500
Dette var en streng eksempel fra onsdag.

211
00:12:12,500 --> 00:12:15,060
Denne strengen eksempel var en ganske enkelt program,

212
00:12:15,060 --> 00:12:18,120
og jeg har faktisk forenklet det ved et par linjer for dagens formål.

213
00:12:18,120 --> 00:12:22,680
Alt den gjør i linje 19 er å få en streng fra brukeren, lagrer den i en variabel kalt s.

214
00:12:22,680 --> 00:12:28,670
Så i linje 22 og fremover er det tilsynelatende skriver at strengen en tegn per linje.

215
00:12:28,670 --> 00:12:30,730
Men hvordan er det å gjøre dette?

216
00:12:30,730 --> 00:12:33,350
Vi erklærer en variabel i, sette den lik 0,

217
00:12:33,350 --> 00:12:35,770
og dette blir gammel vane nå.

218
00:12:35,770 --> 00:12:39,270
Vi hadde ikke sett dette før onsdag, men du kan slags antyde fra sitt navn

219
00:12:39,270 --> 00:12:44,610
strlen returnerer akkurat hva når gitt s? Lengden av strengen.

220
00:12:44,610 --> 00:12:47,940
Så hvis jeg passerer det en streng, sitat-unquote DAVID,

221
00:12:47,940 --> 00:12:51,810
det er forhåpentligvis kommer til å returnere til meg nummer 5 på grunn av DAVID.

222
00:12:51,810 --> 00:12:55,600
Så det er dens formål i livet er å ta en streng, enten hardkodet av deg

223
00:12:55,600 --> 00:12:58,840
eller i dette tilfellet koblet som en variabel, som et argument,

224
00:12:58,840 --> 00:13:01,980
og det finner ut hva lengden på strengen er.

225
00:13:01,980 --> 00:13:06,470
>> Så her nå er vi låne noen notasjon fra forrige quiz eksempel.

226
00:13:06,470 --> 00:13:09,390
Dette har ingenting å gjøre med flottører, har ingenting å gjøre med spørrekonkurranser,

227
00:13:09,390 --> 00:13:13,100
men det viser seg at den lille hvite løgnen vi har vært å fortelle deg siden uke 1

228
00:13:13,100 --> 00:13:16,330
er at en streng egentlig ikke finnes i C.

229
00:13:16,330 --> 00:13:20,230
En streng på slutten av dagen er egentlig bare en matrise.

230
00:13:20,230 --> 00:13:25,140
Det er en rekke bytes, så byte, byte, byte, byte, som tilbakekallingen er bare 8 bits,

231
00:13:25,140 --> 00:13:28,130
så mengde minne, del av minnet, del av minnet, del av minnet.

232
00:13:28,130 --> 00:13:31,210
Og midlene som en streng er implementert

233
00:13:31,210 --> 00:13:33,070
er ved å sette det første tegnet her,

234
00:13:33,070 --> 00:13:37,470
så her, så her, så her, rygg mot rygg mot rygg i datamaskinens minne.

235
00:13:37,470 --> 00:13:42,160
Så hvis du ønsker å stave ut et ord som HELLO, ville du sette en karakter H,

236
00:13:42,160 --> 00:13:48,240
deretter E, deretter L deretter L, deretter O - 5 tegn i totalt - et sted i datamaskinens RAM.

237
00:13:48,240 --> 00:13:52,080
Men viktig detalj her er at de kommer til å være tilbake til rygg mot rygg til rygg,

238
00:13:52,080 --> 00:13:54,200
rett ved siden av hverandre.

239
00:13:54,200 --> 00:13:58,820
Når når jeg sier s [i], hva i engelsk er dette gi meg?

240
00:14:01,240 --> 00:14:04,550
Hva betyr s [i] representerer i dette tilfellet? Ja.

241
00:14:04,550 --> 00:14:07,800
>> [Student] Den ith tegnet i strengen. >> Nettopp. Den ed tegnet i strengen.

242
00:14:07,800 --> 00:14:12,260
Nå er jeg kommer til å starte på 0 pr min for loop her,

243
00:14:12,260 --> 00:14:14,850
men det er bra fordi alt begynner å telle fra 0.

244
00:14:14,850 --> 00:14:19,160
Så s [0] kommer til å representere bokstaven H i et ord som HELLO,

245
00:14:19,160 --> 00:14:24,530
s [1] kommer til å representere en bokstav som E i et ord som Hallo, og så videre.

246
00:14:24,530 --> 00:14:27,130
Og hva vi synes å være å gjøre på hver iterasjon av denne sløyfen

247
00:14:27,130 --> 00:14:32,780
midlertidig lagring av ed tegnet i en variabel kalt c, som er bare en røye,

248
00:14:32,780 --> 00:14:35,010
og så skal vi skrive ut c

249
00:14:35,010 --> 00:14:37,620
slik at ved slutten av dagen hva dette programmet gjør er følgende.

250
00:14:37,620 --> 00:14:42,900
Hvis jeg går inn i kilden katalogen og jeg gjør streng1 og jeg går videre og kjøre streng1,

251
00:14:42,900 --> 00:14:51,920
og da jeg skriver inn et ord som HELLO, Enter, er alt den gjør ut dette en tegn om gangen.

252
00:14:51,920 --> 00:14:54,010
>> Så det er en mulighet for videreutvikling her.

253
00:14:54,010 --> 00:14:58,150
Jeg er litt å gjøre mer arbeid, selv om det er mer tydelig kanskje på denne måten, enn nødvendig.

254
00:14:58,150 --> 00:15:03,270
Hvilken linje av koden her kan jeg nok kaste bort helt? Ja.

255
00:15:03,270 --> 00:15:08,290
Linje 24. I linje 24 jeg erklære en variabel c.

256
00:15:08,290 --> 00:15:14,320
Jeg lagre i. karakter er i det, men da jeg bruker c her.

257
00:15:14,320 --> 00:15:20,160
Så jeg bruker c, så jeg føler at jeg kan ikke bare kaste line 24 unna.

258
00:15:20,160 --> 00:15:23,850
[Uhørlig student kommentar] >> Nettopp.

259
00:15:23,850 --> 00:15:26,240
Så når det gjelder å snakke om design av programmer,

260
00:15:26,240 --> 00:15:30,740
merke til dette liten forenkling av koden, som er like lesbar,

261
00:15:30,740 --> 00:15:34,680
men innser at s er bare en variabel, er datatypen en matrise,

262
00:15:34,680 --> 00:15:38,610
så s [i] er bare kommer til å umiddelbart gå tilbake til deg i. tegnet i strengen.

263
00:15:38,610 --> 00:15:40,620
Og hvis du ønsker å skrive det ut, er det fint.

264
00:15:40,620 --> 00:15:43,680
Du må bare bruke% c fordi du ikke skriver ut en streng,

265
00:15:43,680 --> 00:15:48,520
du skriver et tegn i en streng, og dette også har effekten av å trykke den ith karakter.

266
00:15:48,520 --> 00:15:51,390
Og minnes den eneste forskjellen egentlig fra forrige uke med å bruke printf

267
00:15:51,390 --> 00:15:54,220
er at mens i ukene tidligere vi ville gjøre noe super enkelt

268
00:15:54,220 --> 00:15:58,510
som% s plassholderen deretter navnet på en streng her,

269
00:15:58,510 --> 00:16:01,190
nå er vi dykking i en litt dypere under panseret og sa

270
00:16:01,190 --> 00:16:06,090
ikke ut strengen, skrive ut enkelt tegn der.

271
00:16:06,090 --> 00:16:10,570
>> Så vi kan gjøre noe litt annerledes her fordi det er en annen - ikke bug

272
00:16:10,570 --> 00:16:14,090
fordi dette programmet er riktig, men jeg gjør noe dumt

273
00:16:14,090 --> 00:16:16,810
som jeg nevnte kort på onsdag.

274
00:16:16,810 --> 00:16:22,680
Men tenker tilbake, hvordan kunne dette programmet design bli forbedret ytterligere? Ja.

275
00:16:22,680 --> 00:16:28,280
[Uhørlig student respons] >> Å, bra.

276
00:16:28,280 --> 00:16:32,120
Så husker at vi innførte en ny variabel kalt n siste gang,

277
00:16:32,120 --> 00:16:34,850
som synes å være motstridende oss fordi mitt mål en andre siden

278
00:16:34,850 --> 00:16:37,380
var bare å kaste bort en variabel som unødvendig,

279
00:16:37,380 --> 00:16:40,700
men husker at på onsdag faktisk vi gjorde dette.

280
00:16:40,700 --> 00:16:46,170
Jeg har forandret for loop å faktisk ha et komma her, så n = strlen,

281
00:16:46,170 --> 00:16:52,120
og deretter over her gjorde jeg i <n, så jeg gjorde mine trinn.

282
00:16:52,120 --> 00:16:57,660
Hva er den grunnleggende gevinst som jeg oppnå ved å endre min initialisering til dette

283
00:16:57,660 --> 00:17:01,590
og min tilstand til dette nå? >> [Uhørlig student respons] >> Nettopp.

284
00:17:01,590 --> 00:17:06,170
Jeg er ikke tilbakekaller strlen igjen og igjen og igjen fordi husker hvordan for løkke fungerer.

285
00:17:06,170 --> 00:17:08,790
Selv om de begynner å bli mer komplisert utseende,

286
00:17:08,790 --> 00:17:12,480
husker at ting før det første semikolon er initialisering, som skjer en gang.

287
00:17:12,480 --> 00:17:14,359
Tilstanden, men er i midten,

288
00:17:14,359 --> 00:17:17,710
og dette blir sjekket hver gang du går gjennom løkken.

289
00:17:17,710 --> 00:17:22,420
>> Så det er litt dumt å spørre datamaskinen det samme spørsmålet igjen og igjen -

290
00:17:22,420 --> 00:17:25,920
Hva er lengden på HELLO? Hva er lengden på HELLO? Hva er lengden på HELLO? -

291
00:17:25,920 --> 00:17:29,740
fordi vi vil se i dag og på onsdag, er dette definitivt kommer til å ta tid,

292
00:17:29,740 --> 00:17:34,320
og det er ikke en veldig god bruk av tid fordi å finne ut lengden på en streng

293
00:17:34,320 --> 00:17:37,030
faktisk tar litt innsats.

294
00:17:37,030 --> 00:17:39,760
Det er ikke umiddelbar, som det er i enkelte språk.

295
00:17:39,760 --> 00:17:43,920
Så ved å endre dette til n, er prisen jeg betaler hva?

296
00:17:43,920 --> 00:17:45,640
Vi ser en avveining her.

297
00:17:45,640 --> 00:17:49,460
Jeg kan spare tid ved å ikke stille det samme jævla spørsmålet igjen og igjen,

298
00:17:49,460 --> 00:17:51,740
men det kommer til å koste meg noe, som er hva?

299
00:17:51,740 --> 00:17:55,050
>> [Student] Du mister en viss mengde minne. >> Nettopp. Det kommer til å koste meg minne.

300
00:17:55,050 --> 00:17:56,670
Så i dette tilfellet koster det meg hva?

301
00:17:56,670 --> 00:18:01,530
En annen 32 biter fordi n er bare en int, som underforstått av ordet int her.

302
00:18:01,530 --> 00:18:03,300
Men er det greit?

303
00:18:03,300 --> 00:18:05,800
Ærlig talt, det er nok greit fordi hvis du tenker på det,

304
00:18:05,800 --> 00:18:09,030
jo lenger strengen er, jo mer tid jeg kommer til å være å kaste bort

305
00:18:09,030 --> 00:18:11,920
fordi strlen kommer til å bli kalt igjen og igjen og igjen

306
00:18:11,920 --> 00:18:13,520
for hver iterasjon av sløyfen.

307
00:18:13,520 --> 00:18:18,070
Og i disse dager, har min Mac 2 gigabyte RAM, i disse dager 4 gigabyte RAM noen ganger.

308
00:18:18,070 --> 00:18:22,420
Jeg tror jeg kan ha råd til 4 av disse byte å faktisk fortgang.

309
00:18:22,420 --> 00:18:26,590
Men dette kommer til å bli en avveining og et tema virkelig i programmering og i informatikk

310
00:18:26,590 --> 00:18:28,320
av egentlig aldri å få noe gratis.

311
00:18:28,320 --> 00:18:32,880
Hvis du ønsker å forbedre noe her, må du betale for det i den andre hånden eller annen måte.

312
00:18:32,880 --> 00:18:35,880
Plass mot tid i dette tilfellet.

313
00:18:35,880 --> 00:18:40,700
>> Så dette var alt ledet opp mot noe kryptisk som dette,

314
00:18:40,700 --> 00:18:44,070
som, som du sikkert funnet ut av nå, sier egentlig?

315
00:18:44,070 --> 00:18:47,420
[Uhørlig student respons] >> Ja, så dette er, sørg for å drikke din Ovaltine,

316
00:18:47,420 --> 00:18:52,490
faktisk bruker en algoritme som heter ROT13, ROT 1-3,

317
00:18:52,490 --> 00:18:55,500
som betyr bare rotere alle bokstavene 13 plasser,

318
00:18:55,500 --> 00:18:58,720
som betyr å ta A og deretter legge 13 til den og gå prikk, prikk, prikk

319
00:18:58,720 --> 00:19:04,640
hele veien til det 13. brevet bort, gjør det samme for B og for C, og for D og så videre.

320
00:19:04,640 --> 00:19:10,850
Og så hvis vi faktisk konvertere dette her med en forskyvning av 13 plasser,

321
00:19:10,850 --> 00:19:14,580
vi vil komme tilbake til det lille Ralphie hadde, som var, sørg for å drikke din Ovaltine.

322
00:19:14,580 --> 00:19:18,160
Men nå for problem sett 2, i standardutgaven minst,

323
00:19:18,160 --> 00:19:21,680
du må slags gjør dette enciphering selv,

324
00:19:21,680 --> 00:19:25,990
og vi må liksom ta i input som dette og kryptere det eller dekryptere den.

325
00:19:25,990 --> 00:19:29,850
>> Så hvilke av disse grunnleggende slags fører oss til denne muligheten?

326
00:19:29,850 --> 00:19:32,650
La oss ta en titt på denne tredje eksempel her.

327
00:19:32,650 --> 00:19:38,430
Først av alt, det heter ASCII. Hva refererer ASCII tilbake til?

328
00:19:38,430 --> 00:19:40,460
American Standard Code for Information Interchange,

329
00:19:40,460 --> 00:19:43,850
som er en veldig lang vei å si hva? Hva er ASCII?

330
00:19:43,850 --> 00:19:47,890
[Uhørlig student respons] >> Hva er det? >> [Student] Et tegn kart. >> Et tegn kart.

331
00:19:47,890 --> 00:19:51,390
Det bare kartlegger tall til bokstaver fordi verden har standardisert

332
00:19:51,390 --> 00:19:55,380
hva tallene vil representere hva bokstavene slik at alle av oss kan bruke datamaskiner

333
00:19:55,380 --> 00:19:59,340
og våre programmer alle er like kompatible når det kommer til å skrive ut ting på skjermen.

334
00:19:59,340 --> 00:20:04,680
Så husker at 65 skjer til å representere A, skjer 97 til å representere små bokstaver en.

335
00:20:04,680 --> 00:20:08,510
Og så dette enkle programmet her ASCII tar nytte av det faktum -

336
00:20:08,510 --> 00:20:12,770
at verden vet at kapitalen A er 65 - og det er bare å skrive ut kartleggingen.

337
00:20:12,770 --> 00:20:16,320
>> Så før vi dykke inn denne koden, la meg i stedet åpne opp en terminal vindu.

338
00:20:16,320 --> 00:20:21,550
La meg gå videre og gjøre ASCII, og så la oss bare kjøre denne ting bare for å ødelegge utgang.

339
00:20:21,550 --> 00:20:25,960
Og det gjør nettopp dette: en virkelig stor diagram som bare forteller meg alle de forskjellige koder

340
00:20:25,960 --> 00:20:27,950
for alle de ulike bokstavene.

341
00:20:27,950 --> 00:20:32,100
Så en super enkelt program, men jeg har ikke for hardt kode de 52 linjer med:

342
00:20:32,100 --> 00:20:34,860
26 store, 26 små bokstaver.

343
00:20:34,860 --> 00:20:37,790
I stedet gjorde jeg dette programmatisk med et par sløyfer.

344
00:20:37,790 --> 00:20:39,720
Legg merke til hva jeg gjorde her.

345
00:20:39,720 --> 00:20:44,790
Jeg iterated fra jeg er 65 på opp til 65 + 26 fordi jeg ønsket å skrive ut 26 bokstaver

346
00:20:44,790 --> 00:20:49,860
i det engelske alfabetet, i + + på hver iterasjon, og nå merker dette på nytt.

347
00:20:49,860 --> 00:20:52,540
Det er gjentakelse av vår venn typecasting

348
00:20:52,540 --> 00:20:54,620
der du konverterer en datatype til en annen

349
00:20:54,620 --> 00:20:57,480
fordi det ønsker jeg å gjøre i dette programmet?

350
00:20:57,480 --> 00:21:02,650
Jeg ønsker å telle numerisk fordi det er hvordan jeg vokste opp telling - 65, 66, 67, og så videre -

351
00:21:02,650 --> 00:21:04,420
men jeg ønsker ikke å skrive ut bare tallene.

352
00:21:04,420 --> 00:21:08,030
Jeg ønsker å skrive brevet etterfulgt av nummeret.

353
00:21:08,030 --> 00:21:18,640
Jeg ønsker å skrive ut A: nummer, B: nummer, men jeg kan gjøre dette med de samme variabel.

354
00:21:18,640 --> 00:21:21,630
Så jeg skrive ut% c som plassholder for et tegn,

355
00:21:21,630 --> 00:21:25,080
% D som plassholder for et siffer eller nummer.

356
00:21:25,080 --> 00:21:27,750
Så hva plugge jeg i for de to plassholdere?

357
00:21:27,750 --> 00:21:33,960
Jeg først koble tegnet tilsvarende i, og da jeg skrive ut i seg selv.

358
00:21:33,960 --> 00:21:36,400
>> Så merker dette også fungerer.

359
00:21:36,400 --> 00:21:39,320
Akkurat som jeg kan kaste fra en flåte til en int

360
00:21:39,320 --> 00:21:41,750
for å gå fra et reelt tall til et heltall,

361
00:21:41,750 --> 00:21:46,100
her kan jeg gå fra en int til en røye, som er litt rart -

362
00:21:46,100 --> 00:21:48,680
ikke helt kartlegge på den virkelige verden - men i datamaskiner

363
00:21:48,680 --> 00:21:51,140
en røye er bare et tall under panseret,

364
00:21:51,140 --> 00:21:53,590
så vi blir aldri så eksplisitt her til datamaskinen, sa

365
00:21:53,590 --> 00:21:58,920
printf, skrive ut ikke jeg som 65, skrive den ut som sin numerisk tilsvarende.

366
00:21:58,920 --> 00:22:02,110
Og det viser seg at jeg teknisk sett ikke engang trenger dette.

367
00:22:02,110 --> 00:22:05,020
Hva jeg gjorde for et øyeblikk siden er eksplisitt avstøpning

368
00:22:05,020 --> 00:22:08,760
ved å angi hva datatype jeg ønsker å gå fra og til.

369
00:22:08,760 --> 00:22:11,840
Men merker at jeg allerede har denne plassholder% c

370
00:22:11,840 --> 00:22:14,930
og denne andre% c plassholder her.

371
00:22:14,930 --> 00:22:18,880
Selv om dette ikke er int, innser datamaskinen som en røye,

372
00:22:18,880 --> 00:22:21,080
det er bare en int under panseret.

373
00:22:21,080 --> 00:22:25,100
>> Så hvis jeg faktisk rekompilere denne og kjør ASCII-programmet,

374
00:22:25,100 --> 00:22:31,210
merker det fortsatt bare fungerer fordi datamaskinen innser at det er denne korrespondansen.

375
00:22:31,210 --> 00:22:34,870
Nå er det mer viktig å gjøre det eksplisitte casting i verden av flyter til ints

376
00:22:34,870 --> 00:22:37,460
fordi det du faktisk gjør en kalkulert avgjørelse:

377
00:22:37,460 --> 00:22:40,140
kaste bort alt etter desimaltegnet.

378
00:22:40,140 --> 00:22:44,990
Her er det virkelig ingenting å kaste bort fordi et tegn er bare et tall,

379
00:22:44,990 --> 00:22:48,220
og en streng er bare en rekke tegn.

380
00:22:48,220 --> 00:22:52,530
Så når det gjelder tid til å implementere noen kryptering eller dekryptering,

381
00:22:52,530 --> 00:22:56,770
hvordan er det at vi faktisk kan oversette noe sånt som dette tullet til,

382
00:22:56,770 --> 00:22:58,670
Sørg for å drikke din Ovaltine?

383
00:22:58,670 --> 00:23:02,700
Hva om vi vet akkurat nå - la oss ta som forutsetning - at nøkkelen,

384
00:23:02,700 --> 00:23:08,010
nummeret som vi roterer alle disse brevene ved, er nummer 13?

385
00:23:08,010 --> 00:23:11,800
Så vi gikk fra bokstaven B hele veien til O ved starten av setningen,

386
00:23:11,800 --> 00:23:14,710
Sørg for å drikke din Ovaltine, fordi hvis jeg gjør B

387
00:23:14,710 --> 00:23:19,600
og da går C, D, E, F, G, H, I, J, K, L, M, N, O,

388
00:23:19,600 --> 00:23:23,760
det er derfor kryptering av bokstaven B blir O

389
00:23:23,760 --> 00:23:26,570
fordi jeg nettopp har lagt 13 til det.

390
00:23:26,570 --> 00:23:33,460
>> Så hvis jeg ønsker å dekryptere dette, jeg egentlig har å ta O og deretter trekke 13 fra det.

391
00:23:33,460 --> 00:23:36,880
Eller, ærlig, fordi det er 26 bokstaver i alfabetet, er dette fantastisk symmetrisk,

392
00:23:36,880 --> 00:23:41,260
Vi kan også bare legge 13 og vi vil komme tilbake til bokstaven B.

393
00:23:41,260 --> 00:23:44,290
Men hvordan går du om å implementere noe slikt i Caesar

394
00:23:44,290 --> 00:23:46,600
eller egentlig manipulere strenger generelt?

395
00:23:46,600 --> 00:23:51,380
Hvis bokstaven B er hvilket nummer?

396
00:23:51,380 --> 00:23:55,290
Hva er bokstaven B? Så det er 66, ikke sant?

397
00:23:55,290 --> 00:23:59,220
Så hvis bokstaven A er 65 og bokstaven B er 66,

398
00:23:59,220 --> 00:24:03,940
så 66, er alt jeg har å gjøre er å legge 13 til det, og dette gir meg 79.

399
00:24:03,940 --> 00:24:09,150
Og hvis vi går til vår lille jukse ark, 79 faktisk kart på O.

400
00:24:09,150 --> 00:24:11,290
>> Men det er litt av et hjørne tilfelle her.

401
00:24:11,290 --> 00:24:15,170
Hva er for eksempel bokstaven Z?

402
00:24:15,170 --> 00:24:20,180
Hvis vi gjør 66 + 25 for å få hele veien til slutten av alfabetet, er vi på 91.

403
00:24:20,180 --> 00:24:24,520
91 + 13 gir meg 104, og gjett hva?

404
00:24:24,520 --> 00:24:29,200
104 ikke lik ikke en stor bokstav.

405
00:24:29,200 --> 00:24:31,610
La oss gå tilbake til en liten jukselapp her.

406
00:24:31,610 --> 00:24:38,070
Hvis jeg kjøre dette programmet i apparatet, legg merke til at 104, hvis jeg går tilbake til terminalen vinduet,

407
00:24:38,070 --> 00:24:41,800
104 er tilsynelatende små timer.

408
00:24:41,800 --> 00:24:46,400
Så vi trenger noen viktige triks her for å sørge for at når vi begynner på Z

409
00:24:46,400 --> 00:24:50,260
og vi legger 13 til det vi ønsker ikke å bare holde bygge videre til større og større tall.

410
00:24:50,260 --> 00:24:52,600
Hva vet vi egentlig ønsker å gjøre?

411
00:24:52,600 --> 00:24:54,570
Du ønsker å vikle rundt.

412
00:24:54,570 --> 00:25:00,250
>> Så det viser seg, som du har sett sannsynligvis i avsnittet nå eller i oppgavesettet spec selv

413
00:25:00,250 --> 00:25:05,730
innsett at det er denne andre operatør i C som også er et prosenttegn,

414
00:25:05,730 --> 00:25:11,020
men mens vi har brukt% her for å angi en plassholder,

415
00:25:11,020 --> 00:25:15,420
vet at, spesielt for oppgavesettet 2, det er også noe som dette:

416
00:25:15,420 --> 00:25:18,990
int x = y% z.

417
00:25:18,990 --> 00:25:22,770
La meg bare presentere dette som en svært generisk form av denne.

418
00:25:22,770 --> 00:25:25,580
Prosent betyr det i et programmeringsspråk? >> [Student] Modulo.

419
00:25:25,580 --> 00:25:28,790
Modulo, som er en fancy måte å si resten.

420
00:25:28,790 --> 00:25:31,620
Selv om det er en liten forskjell med definisjonen der,

421
00:25:31,620 --> 00:25:37,210
dette betyr dele y ved z, men ikke returnere resultatet av denne avdelingen;

422
00:25:37,210 --> 00:25:39,650
stedet, tilbake resten.

423
00:25:39,650 --> 00:25:47,390
>> Så hvis y er faktisk 3 og z er faktisk 2, 3 delt på 2 er en med en rest på 1,

424
00:25:47,390 --> 00:25:51,550
så hva gjør x faktisk like i dette scenariet? 1.

425
00:25:51,550 --> 00:25:54,540
Dette er en så enkel, lavt nivå idé.

426
00:25:54,540 --> 00:25:56,480
Det tar litt tid å få tankene surret rundt det

427
00:25:56,480 --> 00:25:58,740
fordi det er trolig vært en stund siden du hadde å bry seg om rester

428
00:25:58,740 --> 00:26:01,160
og faktisk bruke dem til noe meningsfylt,

429
00:26:01,160 --> 00:26:05,290
men i dette tilfellet det enkle faktum at du kan gå fra et stort antall som 3

430
00:26:05,290 --> 00:26:08,920
til et relativt lite antall som 2 og deretter vikle rundt effektivt

431
00:26:08,920 --> 00:26:14,160
ved å bruke resten til en mindre verdi som en kommer til å være en uvurderlig triks

432
00:26:14,160 --> 00:26:17,690
at vi kan bruke både for noe sånt som Caesar og denne andre ting Vigenere

433
00:26:17,690 --> 00:26:22,240
i problemet sett 2, men dette kommer til å være et tilbakevendende triks gjennom semesteret.

434
00:26:22,240 --> 00:26:24,880
Denne enkle, enkel idé om bare å ta resten generelt

435
00:26:24,880 --> 00:26:26,530
kommer til å tillate oss å vikle rundt.

436
00:26:26,530 --> 00:26:31,140
Og som vi begynner å spille mer med matriser, som vi begynner å spille mer med minne seg selv,

437
00:26:31,140 --> 00:26:35,800
dette kommer til å bli mer og mer av en kraftig knep.

438
00:26:35,800 --> 00:26:43,420
>> Så noen spørsmål så på ASCII eller representasjon av strenger som arrays?

439
00:26:43,420 --> 00:26:47,430
Og vi vil ta det opp 1 hakk videre. Ja.

440
00:26:47,430 --> 00:26:52,350
[Uhørlig student spørsmål] >> Godt spørsmål.

441
00:26:52,350 --> 00:26:55,370
Hva betyr det når en variabel har en stjerne foran den?

442
00:26:55,370 --> 00:26:57,720
La meg utsette å svare at i enhver detalj,

443
00:26:57,720 --> 00:27:00,100
men som refererer til et emne som kalles en peker.

444
00:27:00,100 --> 00:27:03,440
Pekere har å gjøre med minne, og vi er faktisk i dag

445
00:27:03,440 --> 00:27:06,330
ta det første skrittet mot den diskusjonen,

446
00:27:06,330 --> 00:27:08,600
men for nå, la meg late at stjernen ikke eksisterer

447
00:27:08,600 --> 00:27:15,380
og vi vil fortsette å kalle strenger strenger i stedet for å bruke char *,

448
00:27:15,380 --> 00:27:19,530
som du sikkert har sett før, og jeg skal sette på skjermen i løpet av et øyeblikk som en teaser.

449
00:27:19,530 --> 00:27:23,010
Så vi vil komme tilbake til det i måten nærmere enn mange av dere vil sannsynligvis liker.

450
00:27:23,010 --> 00:27:25,760
Til slutt, ikke i dag. Ja.

451
00:27:25,760 --> 00:27:42,810
>> [Uhørlig student spørsmål]

452
00:27:42,810 --> 00:27:47,080
I hvilken sammenheng har du å gi tegn for et tegn? >> [Student] Yeah.

453
00:27:47,080 --> 00:27:52,130
Så som standard, når du ikke sette en +, er bare positive tall til grunn.

454
00:27:52,130 --> 00:27:55,390
Så hvis bare skrive nummer 1, er det en positiv en.

455
00:27:55,390 --> 00:27:57,710
Hvis du faktisk ønsker å spesifisere negasjonen av en verdi,

456
00:27:57,710 --> 00:28:01,060
you have to do -1 på tastaturet.

457
00:28:01,060 --> 00:28:20,440
Men dette er trolig ikke spørsmålet ditt. >> [Uhørlig student respons]

458
00:28:20,440 --> 00:28:22,200
>> Godt spørsmål. Okay.

459
00:28:22,200 --> 00:28:24,970
Så dette har å gjøre, jeg samle, med en slags insekt du kjørte inn i

460
00:28:24,970 --> 00:28:27,640
fordi du var å konvertere et heltall til et tegn,

461
00:28:27,640 --> 00:28:29,780
men noe negativitet ble involvert,

462
00:28:29,780 --> 00:28:32,380
og så tegnet bare kom ut munged annen måte.

463
00:28:32,380 --> 00:28:36,710
Så for nå, la meg forenkle litt før vi kommer tilbake til denne typen emnet.

464
00:28:36,710 --> 00:28:39,570
For nå, tenke på ting på denne måten - og dette er en overforenkling.

465
00:28:39,570 --> 00:28:43,500
Men i en verden av et heltall, har du hvor mange biter til din disposisjon?

466
00:28:43,500 --> 00:28:45,190
Du har 32 biter.

467
00:28:45,190 --> 00:28:49,030
Og så langt har vi snakket om det totale antall heltall kan derfor representere

468
00:28:49,030 --> 00:28:52,430
er rundt 4 milliarder kroner fordi du har 32 bits,

469
00:28:52,430 --> 00:28:55,100
så det er 2 til 32, så det er omtrent 4 milliarder.

470
00:28:55,100 --> 00:28:58,810
Men vi så en uke eller to siden at du ikke egentlig har en rekke tall

471
00:28:58,810 --> 00:29:01,240
fra 0 på opptil 4 milliarder kroner.

472
00:29:01,240 --> 00:29:06,340
Utvalget går i stedet fra ca negative 2 milliarder til positiv 2 milliarder.

473
00:29:06,340 --> 00:29:10,990
Men dette ber deretter spørsmålet, hvordan du representerer begrepet negative 2000000000

474
00:29:10,990 --> 00:29:13,260
enn si negative 1?

475
00:29:13,260 --> 00:29:17,960
For nå kan vi forenkle og bare si at vi kommer til å bruke lengst til venstre bit

476
00:29:17,960 --> 00:29:22,380
av disse 32 bits, og hvis det er en 1 er det et negativt tall,

477
00:29:22,380 --> 00:29:25,090
og hvis det er en 0 er det et positivt tall.

478
00:29:25,090 --> 00:29:28,570
Problemet med at forenklet representasjon av negative tall

479
00:29:28,570 --> 00:29:33,700
er at hvis du var bevisst å være flink og prøver å konvertere fra et tegn til et tall

480
00:29:33,700 --> 00:29:37,190
eller vice versa, er det ingen slike ting som en negativ karakter.

481
00:29:37,190 --> 00:29:42,550
I en verden av ASCII, som bare bruker 8 bits, alle 8 av dem biter saken,

482
00:29:42,550 --> 00:29:46,810
og lengst til venstre bit har ingenting å gjøre med negativitet.

483
00:29:46,810 --> 00:29:49,670
Og bare for å være klar, når jeg sier lengst til venstre biter,

484
00:29:49,670 --> 00:29:54,610
husker at da vi gjorde vår bit-relaterte eksempler i den første uken

485
00:29:54,610 --> 00:30:02,570
husker at vi trakk ting som 1001101, noe som dette.

486
00:30:02,570 --> 00:30:07,210
Når jeg sier lengst til venstre litt, jeg bare bokstavelig talt bety en som du skriver hele veien over til venstre.

487
00:30:07,210 --> 00:30:11,910
Så i en verden av tegn er det ingen forestilling av negativitet,

488
00:30:11,910 --> 00:30:16,360
slik at venstre bit faktisk har noe å gjøre med ASCII, ingenting å gjøre med negativitet.

489
00:30:16,360 --> 00:30:19,390
>> Så det høres ut som - og ut av sammenheng er det vanskelig å svare nøyaktig -

490
00:30:19,390 --> 00:30:25,840
men noe ble koden forvirrende at venstre bit som representerer en negativ verdi

491
00:30:25,840 --> 00:30:29,160
når det egentlig var en del av tegnet i spørsmålet.

492
00:30:29,160 --> 00:30:32,250
Og igjen, jeg oversimplifying fordi datamaskiner faktisk gjøre noe litt mer avansert

493
00:30:32,250 --> 00:30:37,080
enn bare å endre det venstre litt til en 1 for et minustegn versus en 0.

494
00:30:37,080 --> 00:30:41,270
De i stedet, hvis du er nysgjerrig på å Google, bruker noe typisk kalt 2-komplement,

495
00:30:41,270 --> 00:30:43,830
som er litt mer sofistikert av en tilnærming

496
00:30:43,830 --> 00:30:45,490
men ideen er slutt den samme.

497
00:30:45,490 --> 00:30:50,530
>> Så kort sagt, det hadde å gjøre med det faktum at du var masserer et nummer til en karakter

498
00:30:50,530 --> 00:30:53,750
eller vice versa, men koden var ikke bevisst på det faktum

499
00:30:53,750 --> 00:30:56,510
at en av de bitene hadde betydning i den numeriske verden.

500
00:30:56,510 --> 00:30:59,940
Det er ikke tilfelle i tegnet verden.

501
00:30:59,940 --> 00:31:04,270
Men det høres ut som du fast, og da Moot nå. Andre spørsmål.

502
00:31:06,030 --> 00:31:07,110
Okay.

503
00:31:07,110 --> 00:31:11,560
Så så langt har alle de programmene vi har skrevet tatt innspill kanskje fra brukeren

504
00:31:11,560 --> 00:31:14,330
i form av funksjoner som GetInt, GetString,

505
00:31:14,330 --> 00:31:16,990
eller hvis du har lest videre i ulike bøker eller online referanser,

506
00:31:16,990 --> 00:31:21,390
dere selv kan ha brukt funksjoner som scanf som, ærlig, bruker vi i CS50 biblioteket.

507
00:31:21,390 --> 00:31:25,370
Men i en uke eller to, vil vi faktisk vise deg hvordan CS50 biblioteket er implementert

508
00:31:25,370 --> 00:31:27,890
slik at vi kan ta de trening hjul av helt.

509
00:31:27,890 --> 00:31:31,340
>> Men det viser seg at det er en annen måte å få innspill fra en bruker.

510
00:31:31,340 --> 00:31:34,670
Faktisk har vi selv vært med kommandolinjeargumenter

511
00:31:34,670 --> 00:31:36,500
for et par uker nå.

512
00:31:36,500 --> 00:31:41,150
Hver gang vi har kjørt Clang eller vi har kjørt gjøre,

513
00:31:41,150 --> 00:31:45,050
Vi har ikke bare skrevet clang, Enter, vi har ikke skrevet gjøre, Enter.

514
00:31:45,050 --> 00:31:49,340
Hva har vi vanligvis skrevet etter ordet clang på vår terminal vinduer spørsmål?

515
00:31:51,110 --> 00:31:52,900
[Student] Filnavnet. >> Filnavnet, ikke sant?

516
00:31:52,900 --> 00:31:57,560
Hallo.c eller mario.c eller hva den aktuelle filen heter.

517
00:31:57,560 --> 00:32:01,910
Og i den forstand hva du har virkelig gjort er at du har påvirket oppførselen til Clang

518
00:32:01,910 --> 00:32:05,750
fordi absolutt folk som skrev Clang hadde ingen anelse om at litt gammel du

519
00:32:05,750 --> 00:32:08,890
hadde tenkt å skrive et program som heter mario.c år senere.

520
00:32:08,890 --> 00:32:13,150
Så du måtte liksom påvirke atferden til det programmet,

521
00:32:13,150 --> 00:32:18,140
og at programmet Clang måtte være skrevet på en slik måte at den kan ta imot data fra du

522
00:32:18,140 --> 00:32:23,480
ved tilsetting av ord på spørsmål før brukeren treff Enter.

523
00:32:23,480 --> 00:32:27,860
>> Så det viser seg at for noen tid har vi vært erklære nesten alle av våre programmer

524
00:32:27,860 --> 00:32:32,840
å starte som dette - int main (void) - og så har vi gått foran

525
00:32:32,840 --> 00:32:35,110
og begynte å skrive vår kode.

526
00:32:35,110 --> 00:32:37,910
Og vi kan ha noen skarpe omfatter øverst filen,

527
00:32:37,910 --> 00:32:40,660
men nesten alle av våre programmer så langt har begynt med dette

528
00:32:40,660 --> 00:32:44,200
selv om du kanskje har sett i snitt, i bøker, referanser

529
00:32:44,200 --> 00:32:46,570
at dette ikke faktisk må være ugyldig.

530
00:32:46,570 --> 00:32:55,820
En annen legitim form for at dette skal ta er int argc og streng argv [].

531
00:32:55,820 --> 00:32:57,500
Så nå hva er dette antyder?

532
00:32:57,500 --> 00:33:01,320
Det viser seg at argc, som er en menneskelig konvensjonen - du kan kalle dette foo,

533
00:33:01,320 --> 00:33:03,710
men det ville bare være mye mindre klart for leserne -

534
00:33:03,710 --> 00:33:09,330
argc er bare et argument til funksjonen kalles viktigste som representerer hva?

535
00:33:09,330 --> 00:33:12,450
Hva står argc for for de som er kjent?

536
00:33:12,450 --> 00:33:14,980
>> [Uhørlig student respons] >> Ja, antall argumenter eller argument teller.

537
00:33:14,980 --> 00:33:16,510
Det er så enkelt som det.

538
00:33:16,510 --> 00:33:19,160
Hvor mange argumenter ble sendt til dette programmet?

539
00:33:19,160 --> 00:33:20,630
Hva betyr det?

540
00:33:20,630 --> 00:33:27,090
Hvis på kommandolinjen jeg har kjørt noe sånt som dette - clang mario.c--

541
00:33:27,090 --> 00:33:35,440
argc når jeg treffer Enter kommer til å ta på en verdi av, noe forvirrende, 2.

542
00:33:35,440 --> 00:33:40,150
Så det viser seg at argc er argument teller,

543
00:33:40,150 --> 00:33:46,280
men for historiske årsaker, er navnet på selve programmet inkludert i som teller.

544
00:33:46,280 --> 00:33:51,950
Så argc er 2 når jeg skrev clang mario.c.

545
00:33:51,950 --> 00:33:54,290
Hva inneholder argv?

546
00:33:54,290 --> 00:33:57,020
Først av alt, ser argv som en streng, men ikke helt

547
00:33:57,020 --> 00:33:59,310
fordi som sist onsdag og alle de mer i dag,

548
00:33:59,310 --> 00:34:02,890
disse hakeparenteser betegne hva? Det er en matrise.

549
00:34:02,890 --> 00:34:07,110
Det er ingen tall i rekken, og det bør være fornuftig intuitivt

550
00:34:07,110 --> 00:34:10,790
fordi folk som skrev clang år siden sikkert hadde ingen anelse

551
00:34:10,790 --> 00:34:16,300
hvor mange ord folk som oss ville skrive på spørsmål før du trykker på Enter.

552
00:34:16,300 --> 00:34:22,280
>> Så i dette tilfellet her har de erklært funksjonen main som tar en rekke argumenter,

553
00:34:22,280 --> 00:34:24,590
0 eller flere argumenter.

554
00:34:24,590 --> 00:34:26,460
De vet ikke på forhånd hvor mange det er,

555
00:34:26,460 --> 00:34:29,690
så det er bevisst noe nummer på innsiden av disse hakeparenteser.

556
00:34:29,690 --> 00:34:32,750
Men det faktum at de klammer er der forteller datamaskinen,

557
00:34:32,750 --> 00:34:34,639
forventer en matrise.

558
00:34:34,639 --> 00:34:37,489
Argv er bare stenografi notasjon for argument vektor.

559
00:34:37,489 --> 00:34:39,889
En vektor er en fancy måte å si array,

560
00:34:39,889 --> 00:34:42,980
og matrise er en fancy måte å si en liste eller samling.

561
00:34:42,980 --> 00:34:47,360
Så dette betyr bare at hvis du skriver viktigste som dette

562
00:34:47,360 --> 00:34:51,100
i stedet for som hvordan vi har gjort det for de siste par ukene,

563
00:34:51,100 --> 00:34:54,699
programmet har nå muligheten til å akseptere kommandolinjeargumenter

564
00:34:54,699 --> 00:34:58,520
slik at ingen lenger har du å skrive mario og trykk Enter,

565
00:34:58,520 --> 00:35:01,610
skriver inn et tall for hvor mange blokker høyt du vil at pyramiden skal være,

566
00:35:01,610 --> 00:35:03,100
trykk Enter igjen.

567
00:35:03,100 --> 00:35:07,720
Vi trenger ikke engang å bruke GetString lenger eller GetInt eller GetFloat for den saks skyld.

568
00:35:07,720 --> 00:35:12,370
Vi kan bare forvente at brukeren skriver disse ordene på prompten

569
00:35:12,370 --> 00:35:16,850
akkurat som forfatterne av Clang besluttet det ville være en virkelig irriterende program

570
00:35:16,850 --> 00:35:20,550
om å kompilere koden du først skrev klang, trykk Enter,

571
00:35:20,550 --> 00:35:24,090
da vi sa til brukeren, vennligst skriv inn navnet på filen du ønsker å kompilere,

572
00:35:24,090 --> 00:35:26,920
så vi skriver i mario.c og trykk Enter.

573
00:35:26,920 --> 00:35:29,850
Men det er akkurat det vi har gjort til våre brukere de siste par ukene.

574
00:35:29,850 --> 00:35:33,550
Vi bruker GetString og vi vente til programmet kjører for å be dem om innspill.

575
00:35:33,550 --> 00:35:36,710
Som ikke lenger trenger å være tilfelle.

576
00:35:36,710 --> 00:35:41,160
>> Så i dette eksempelet her, vi har nå streng argv,

577
00:35:41,160 --> 00:35:43,390
og dette er også en overforenkling,

578
00:35:43,390 --> 00:35:45,610
trening hjul som vil ganske snart komme.

579
00:35:45,610 --> 00:35:50,860
Dette er mer riktig måte å skrive denne alternative deklarering av hoved

580
00:35:50,860 --> 00:35:54,740
fordi det viser seg at det vi holder ringer streng faktisk har en stjerne,

581
00:35:54,740 --> 00:35:58,440
en stjerne i sin faktiske definisjonen, men dette bare ser komplisert ut,

582
00:35:58,440 --> 00:36:02,600
det er forvirrende i begynnelsen, så vi forenkle ved å bare lage et synonym slags

583
00:36:02,600 --> 00:36:09,340
i CS50 bibliotek som kartlegger char * til dette mer brukervennlig ord streng.

584
00:36:09,340 --> 00:36:13,180
>> Så la oss faktisk prøve dette da. La meg gå videre og åpne opp gedit her.

585
00:36:13,180 --> 00:36:17,010
La meg gå videre og åpne argv av en.

586
00:36:17,010 --> 00:36:21,620
Dette programmet tilsynelatende skriver argumentene, men i engelsk vilkår,

587
00:36:21,620 --> 00:36:26,290
ved å se på denne koden, hva dette gjør mer spesifikt?

588
00:36:26,290 --> 00:36:35,910
Hvis jeg skriver i kommandoen a.out foo bar, blir det trykt i min svart og hvitt vindu?

589
00:36:35,910 --> 00:36:41,260
A.out foo bar, Enter.

590
00:36:43,120 --> 00:36:48,300
Gå fremover. Ja. >> [Uhørlig student respons]

591
00:36:48,300 --> 00:36:52,730
Bra. Så a.out, ny linje, foo, ny linje, bar, ny linje.

592
00:36:52,730 --> 00:36:54,980
Hvorfor er dette? Vi kan absolutt bekrefte på bare et øyeblikk.

593
00:36:54,980 --> 00:36:56,940
Dette er en slags lun linje med kode.

594
00:36:56,940 --> 00:36:59,560
 Det skrives bare en ny linje bare for å gjøre ting penere på skjermen.

595
00:36:59,560 --> 00:37:03,730
Dette er en sløyfe som er iterating fra 0 på opptil argc,

596
00:37:03,730 --> 00:37:07,210
og dette er inkrementering på hver iterasjon + +.

597
00:37:07,210 --> 00:37:12,270
Så dette er nå si ut en streng, som underforstått av denne% s.

598
00:37:12,270 --> 00:37:16,460
Argv [i] er ganske mye den samme ideen fra forrige eksempel.

599
00:37:16,460 --> 00:37:19,580
Vi pleide å kalle den variable s, nå det heter, vilkårlig, argv.

600
00:37:19,580 --> 00:37:24,270
Dette betyr ut i. argument som ble skrevet på kommandolinjen,

601
00:37:24,270 --> 00:37:28,690
og deretter etter alt dette er gjort, bare for godt mål ut en ny linje.

602
00:37:28,690 --> 00:37:31,600
>> Så la oss se dette. La meg åpne opp terminal-vinduet.

603
00:37:31,600 --> 00:37:37,470
La meg kompilere argv på 1, og nå la meg kjøre argv på 1, Enter. Hmm. Okay.

604
00:37:37,470 --> 00:37:40,850
La oss kjøre foo bar. Interessant. Baz.

605
00:37:40,850 --> 00:37:42,640
Og hvis du noen gang har lurt på hvorfor jeg skriver dette,

606
00:37:42,640 --> 00:37:45,010
dette er bare også en dum datamaskin science konvensjonen.

607
00:37:45,010 --> 00:37:48,050
Verden trenger ofte bare verbale plassholdere for ord.

608
00:37:48,050 --> 00:37:50,090
Så hvis du ønsker å snakke om noen generiske streng,

609
00:37:50,090 --> 00:37:53,250
dataforskere bare en tendens til å si Foo når de trenger et tilfeldig ord,

610
00:37:53,250 --> 00:37:55,530
så de sier bar hvis de trenger en andre tilfeldig ord,

611
00:37:55,530 --> 00:37:59,100
så de sier baz hvis de trenger en tredje ordet, så de sier qux hvis de trenger en fjerde ordet,

612
00:37:59,100 --> 00:38:01,520
og så er det en stor religiøs debatt på nettet om hva som kommer etter qux,

613
00:38:01,520 --> 00:38:04,940
slik at du kan google det å finne ut hva den andre vilkårlig ord bør være.

614
00:38:04,940 --> 00:38:07,480
Men disse har ingen mening overhodet,

615
00:38:07,480 --> 00:38:10,100
om foo bar, hvis du Google det, som ikke har mening,

616
00:38:10,100 --> 00:38:12,780
som er en del av den etymology her.

617
00:38:12,780 --> 00:38:17,550
>> Så alt dette gjør så skriver en av disse strengene per linje.

618
00:38:17,550 --> 00:38:19,900
Så hvis jeg i stedet, men ønsket å få en litt mer avansert,

619
00:38:19,900 --> 00:38:22,550
anta at jeg ikke ønsker å skrive ut hver streng per linje;

620
00:38:22,550 --> 00:38:26,220
Jeg ønsket å skrive ut hver karakter fra hver streng per linje.

621
00:38:26,220 --> 00:38:28,550
Hvordan kunne jeg i stedet gjøre det?

622
00:38:28,550 --> 00:38:33,720
Hva trenger jeg å endre om dette programmet hvis jeg ønsker å skrive ut ikke hvert ord

623
00:38:33,720 --> 00:38:37,290
men jeg ønsker å skrive ut hvert ord bokstav for bokstav for bokstav,

624
00:38:37,290 --> 00:38:40,590
så det neste ordet bokstav for bokstav for bokstav?

625
00:38:40,590 --> 00:38:43,650
Hvordan kombinerer vi gjør disse ideene så langt? Ja.

626
00:38:43,650 --> 00:38:47,390
[Student]% c. >> Greit. Så vi et sted trenger en% c.

627
00:38:47,390 --> 00:38:50,680
Bra, fordi jeg ikke vil skrive ut hele strenger, jeg ønsker å skrive ut tegn. Hva annet?

628
00:38:50,680 --> 00:38:54,290
>> [Uhørlig student respons] >> Interessant.

629
00:38:54,290 --> 00:38:56,860
Så vi trenger en slags ny dimensjon her nå

630
00:38:56,860 --> 00:39:02,300
fordi tenke på argv som en matrise, men det er en rekke strenger.

631
00:39:02,300 --> 00:39:07,170
Men som av, liker, 15 minutter siden, hva er en streng? Det er en rekke tegn.

632
00:39:07,170 --> 00:39:12,320
Så egentlig er argv en rekke en rekke tegn,

633
00:39:12,320 --> 00:39:14,870
en rekke matriser av tegn.

634
00:39:14,870 --> 00:39:19,170
Så det viser seg at vi kan bruke bare mer hakeparentes merknader. Så la oss gjøre dette.

635
00:39:19,170 --> 00:39:23,650
I toppen av denne sløyfen på linje 19, kommer jeg til å veksle fra jeg opp til argc,

636
00:39:23,650 --> 00:39:25,760
men da jeg kommer til å gjøre dette:

637
00:39:25,760 --> 00:39:27,580
for - ikke jeg kan bruke jeg nå.

638
00:39:27,580 --> 00:39:30,300
Jeg trenger en annen variabel fordi jeg ønsker å iterere over ordene

639
00:39:30,300 --> 00:39:32,640
men da også over bokstavene i ordene

640
00:39:32,640 --> 00:39:37,280
så jeg slags har en vertikal akse og en horisontal akse, liksom konseptuelt.

641
00:39:37,280 --> 00:39:43,930
Så int j får 0, så jeg ønsker å gjøre j så lenge j er mindre enn - og jeg vil rydde opp i en bit.

642
00:39:43,930 --> 00:39:48,410
Hvordan iterere jeg over bokstavene i en streng? Vi gjorde dette for et øyeblikk siden.

643
00:39:48,410 --> 00:39:54,670
Strlen av argv [i]. Bra.

644
00:39:54,670 --> 00:39:57,860
Og igjen, jeg gjør litt ineffektivitet her ved ikke å skape n eller hva,

645
00:39:57,860 --> 00:39:59,610
men vi vil komme tilbake til det.

646
00:39:59,610 --> 00:40:03,270
>> Så nå j + +. Nå må jeg rykke nærmere her.

647
00:40:03,270 --> 00:40:06,950
Hva gjør jeg nå ønsker å skrive ut på hver iterasjon?

648
00:40:06,950 --> 00:40:09,720
[Uhørlig student respons] >> Så [i] vil gi meg ordet.

649
00:40:09,720 --> 00:40:12,910
[I] [j], liksom som en matrise.

650
00:40:12,910 --> 00:40:14,810
De av dere med matte-y bakgrunn,

651
00:40:14,810 --> 00:40:19,340
Vi er liksom indeksering enda dypere inn i denne matrisen eller denne rekke matriser,

652
00:40:19,340 --> 00:40:21,380
Dette 2-dimensjonale struktur.

653
00:40:21,380 --> 00:40:25,070
Så la oss nå se hva som skjer her. La meg åpne opp min større terminal-vinduet.

654
00:40:25,070 --> 00:40:28,170
La meg kjøre gjøre av argv av en.

655
00:40:28,170 --> 00:40:33,090
Og jeg har skrudd opp her, som er en god leksjon fordi jeg også glemte å gjøre dette.

656
00:40:33,090 --> 00:40:37,150
Implisitt erklære C biblioteket funksjon 'strlen' med type 'usignert -

657
00:40:37,150 --> 00:40:40,360
Jeg vet ikke engang hva resten av det betyr, men jeg har sett dette før,

658
00:40:40,360 --> 00:40:42,000
implisitt sier.

659
00:40:42,000 --> 00:40:45,540
Når vi ser denne feilen, hva dette vanligvis bety?

660
00:40:45,540 --> 00:40:48,520
>> [Uhørlig student respons] >> Jeg glemte et bibliotek opp toppen. Men vent litt.

661
00:40:48,520 --> 00:40:51,690
Vanligvis har jeg skrudd opp fordi jeg glemte CS50 biblioteket, men det er det.

662
00:40:51,690 --> 00:40:54,480
Vanligvis har jeg skrudd opp fordi jeg har glemt standard I / O.

663
00:40:54,480 --> 00:40:57,960
Og ærlig talt, jeg vet ikke engang trenger dette. Vi bruker ikke GetString dag.

664
00:40:57,960 --> 00:40:59,900
Så hva er det jeg mangler?

665
00:40:59,900 --> 00:41:04,860
Det er et annet bibliotek som nå må vi bruke noen ganger kalt string.h,

666
00:41:04,860 --> 00:41:08,980
og dette er bare enda en bibliotek som har flere funksjoner som ikke er i standard I / O.

667
00:41:08,980 --> 00:41:11,640
>> Så la oss gå tilbake til min store terminal vinduet.

668
00:41:11,640 --> 00:41:16,670
Okay. Nå, for faen, jeg tror jeg var galt. Jeg var bruker CS50 biblioteket.

669
00:41:16,670 --> 00:41:18,460
Så vi kan fikse dette på en av to måter.

670
00:41:18,460 --> 00:41:21,510
Vi kan ta trening hjul av akkurat nå og bare gjøre dette,

671
00:41:21,510 --> 00:41:26,600
eller la oss slags holde at forenkling bare for nå, lime dette tilbake i,

672
00:41:26,600 --> 00:41:30,180
løse det problemet, og nå går tilbake til terminalen vinduet.

673
00:41:30,180 --> 00:41:33,080
Så for å være klar, i CS50 biblioteket ikke bare fungerer,

674
00:41:33,080 --> 00:41:36,920
det er også nøkkelordet strengen, som er grunnen til at feilen skjedde.

675
00:41:36,920 --> 00:41:43,010
>> Så her går vi. Jeg fikset begge bibliotek problemer. Enter. Bra.

676
00:41:43,010 --> 00:41:49,250
Argv av 1, foo bar, Enter. Utmerket.

677
00:41:49,250 --> 00:41:52,830
Så nå har vi hver bokstav i hvert ord skrives en per linje,

678
00:41:52,830 --> 00:41:55,290
som ikke gjør for en meget interessant program,

679
00:41:55,290 --> 00:41:59,350
men varsel nå har vi evnen til ikke bare gjentar over ord

680
00:41:59,350 --> 00:42:04,090
men også over enkelte bokstaver i ord, som lyder svært kjent

681
00:42:04,090 --> 00:42:10,330
til selv de enkleste programmene som scrambling bokstaver i en streng som dette.

682
00:42:10,330 --> 00:42:12,410
La oss gå videre og ta vår 5-minutters pause her.

683
00:42:12,410 --> 00:42:14,410
Og når vi kommer tilbake, vil vi begynne å snakke om effektivitet

684
00:42:14,410 --> 00:42:17,670
som vi kan gjøre disse tingene bedre.

685
00:42:19,370 --> 00:42:21,900
>> OK. Vi er tilbake.

686
00:42:21,900 --> 00:42:26,970
Takket være en av våre TFS som spiller mye bananagrams,

687
00:42:26,970 --> 00:42:30,000
vi faktisk har en hel haug med tegn med oss ​​her i dag

688
00:42:30,000 --> 00:42:32,520
fysisk inkarnert med disse små plast stykker,

689
00:42:32,520 --> 00:42:36,910
og la meg foreslå at denne blank hvit skifer her representerer RAM i datamaskinen min -

690
00:42:36,910 --> 00:42:39,790
laptop, desktop, uansett - og det ser ut som mye av det

691
00:42:39,790 --> 00:42:44,090
fordi hvis vi begynner hakke opp dette RAM i små byte-størrelse stykker,

692
00:42:44,090 --> 00:42:48,970
la oss vilkårlig si at noe som størrelse og at uklare representerer -

693
00:42:48,970 --> 00:42:52,430
der vi går, og la oss zoome ut litt her -

694
00:42:52,430 --> 00:42:56,120
la oss si noe som størrelse representerer en enkelt byte.

695
00:42:56,120 --> 00:43:00,400
Så vi kan faktisk passe en hel haug med byte eller tegn innsiden av dette minnet,

696
00:43:00,400 --> 00:43:02,860
som foreslått av den relative størrelsen her.

697
00:43:02,860 --> 00:43:06,780
>> Så antar nå at målet er å allokere minne for en streng.

698
00:43:06,780 --> 00:43:08,680
Hvordan virker dette faktisk fungerer?

699
00:43:08,680 --> 00:43:11,380
I programmene vi har skrevet, har vi vanligvis brukt GetString,

700
00:43:11,380 --> 00:43:16,300
men nå, tydelig, det er denne andre kanalen via hvor vi kan få brukerens input i argv

701
00:43:16,300 --> 00:43:18,190
via kommandolinjeargumenter.

702
00:43:18,190 --> 00:43:20,580
Men hva som egentlig skjer under panseret?

703
00:43:20,580 --> 00:43:24,920
Det viser seg hvis vi kaller - la oss bla tilbake til GetString - funksjonen GetString

704
00:43:24,920 --> 00:43:28,190
i CS50 biblioteket, blir brukeren bedt om en streng,

705
00:43:28,190 --> 00:43:30,780
brukeren skriver i noen ord - la oss kalle det HELLO.

706
00:43:30,780 --> 00:43:35,410
Og vi har sagt i de siste par ukene at avkastningen verdien av GetString

707
00:43:35,410 --> 00:43:37,750
er faktisk en streng, som ordet HELLO.

708
00:43:37,750 --> 00:43:39,660
>> Men hva er GetString egentlig gjør?

709
00:43:39,660 --> 00:43:45,230
Mens brukeren skriver i HELLO, Enter, blir GetString finne ut,

710
00:43:45,230 --> 00:43:47,930
okay, hvor mange tegn er dette? Dette er H-E-L-L-O.

711
00:43:47,930 --> 00:43:52,500
Så det må fordele, må den be operativsystemet - Linux i dette tilfellet -

712
00:43:52,500 --> 00:43:55,410
i minst 5 byte for å lagre HELLO.

713
00:43:55,410 --> 00:43:59,570
Og hva det deretter fortsetter å gjøre når det kommer tilbake de 5 bytes fra operativsystemet

714
00:43:59,570 --> 00:44:04,120
er å legge ut HELLO rygg mot rygg til rygg mot rygg.

715
00:44:04,120 --> 00:44:11,070
Og så hva som egentlig returnert fra GetString er en del av data som ser ut som dette.

716
00:44:11,070 --> 00:44:16,850
Men dette er litt unøyaktig fordi det viser seg at det ikke er så enkelt

717
00:44:16,850 --> 00:44:20,310
som bare lagring HELLO i datamaskinens minne

718
00:44:20,310 --> 00:44:24,140
fordi anta at mitt program som jeg skriver i C så kaller GetString igjen,

719
00:44:24,140 --> 00:44:28,210
og det neste ordet brukeren skriver i er BYE, BYE.

720
00:44:28,210 --> 00:44:31,300
Vel, jeg må passe på at ordet BYE sted i minnet.

721
00:44:31,300 --> 00:44:33,790
Jeg kan ikke clobber HELLO.

722
00:44:33,790 --> 00:44:37,320
For eksempel, jeg ønsker ikke at datamaskinen skal bare begynne overskriving som dette

723
00:44:37,320 --> 00:44:41,400
den opprinnelige ordet fordi jeg kan fortsatt bruke ordet HELLO i en variabel

724
00:44:41,400 --> 00:44:43,070
et annet sted i programmet mitt.

725
00:44:43,070 --> 00:44:45,900
>> Så B-Y-E har å ende opp et annet sted i minnet.

726
00:44:45,900 --> 00:44:50,460
Men konvensjonen er typisk at neste strengen du tildele

727
00:44:50,460 --> 00:44:54,940
sannsynligvis, men ikke alltid, kommer til å ende opp på neste tilgjengelige minneområde.

728
00:44:54,940 --> 00:44:57,370
Og hvis jeg ikke har bedt operativsystemet for noe minne

729
00:44:57,370 --> 00:45:01,380
siden sist gang jeg ringte GetString, oddsen er ordet BYE

730
00:45:01,380 --> 00:45:05,790
kommer til å ende opp rett etter ordet HELLO i minnet.

731
00:45:05,790 --> 00:45:10,550
Men på dette punktet kan du kanskje se hvor et potensielt problem oppstår.

732
00:45:10,550 --> 00:45:13,310
Fordi de neste mengder minne, de neste byte som var bare gratis -

733
00:45:13,310 --> 00:45:18,230
ren hvit skifer - i datamaskinens minne var rett ved siden HELLO,

734
00:45:18,230 --> 00:45:23,670
det føles som den første strengen jeg ba om kan plutselig nå endre

735
00:45:23,670 --> 00:45:26,410
fordi jeg har egentlig endret det til HELLOBYE

736
00:45:26,410 --> 00:45:31,310
i stedet for en eller annen måte demarcing starten av BYE og slutten av HELLO.

737
00:45:31,310 --> 00:45:33,920
>> Så det viser seg at det som egentlig skjer under panseret,

738
00:45:33,920 --> 00:45:37,570
som du kanskje har observert i online referanser eller § eller bøker

739
00:45:37,570 --> 00:45:41,780
eller ikke i det hele tatt bare ennå, er at det faktisk er en bevisst avgrensning

740
00:45:41,780 --> 00:45:45,890
mellom ord i datamaskinens minne.

741
00:45:45,890 --> 00:45:52,480
Og faktisk, i dette tilfellet her, snarere enn bare sette BYE rett ved siden HELLO,

742
00:45:52,480 --> 00:45:58,610
stedet, settes datamaskinen en spesiell karakter, den spesielle null karakter, så å si,

743
00:45:58,610 --> 00:46:03,050
som er representert med en markør med backslash 0.

744
00:46:03,050 --> 00:46:06,700
Så lang historie kort, husker at tegnene er representert i ASCII.

745
00:46:06,700 --> 00:46:09,680
ASCII er bare en mapping mellom tall og bokstaver,

746
00:46:09,680 --> 00:46:13,870
og de fleste av disse brevene begynner omtrent 65 for kapital A,

747
00:46:13,870 --> 00:46:19,780
men det viser seg at du kan sikkert representere tallet 0 som et heltall eller binær,

748
00:46:19,780 --> 00:46:22,690
og det viser seg at verden bestemt for lenge, lenge siden, "Vet du hva?"

749
00:46:22,690 --> 00:46:27,550
"La oss reserve nummer 0 som ikke representerer noen tegn på tastaturet -

750
00:46:27,550 --> 00:46:30,810
"Ingen brev, ingen tall, ingen tegnsetting. 0 er spesiell."

751
00:46:30,810 --> 00:46:35,830
"Det kommer til å bli den spesielle null karakter, og vi kommer til å skrive det som \ 0".

752
00:46:35,830 --> 00:46:41,170
Forskjellen er hvis vi bare skrev 0, 0 er et tegn.

753
00:46:41,170 --> 00:46:45,700
Husker at det ASCII-koder for 0, for en, for 2, for 3

754
00:46:45,700 --> 00:46:50,570
fordi tegnet 0, er forskjellig fra tallet 0.

755
00:46:50,570 --> 00:46:54,270
Og du kan se at hvis du ser tilbake fra uke 1 når vi først snakket om ASCII,

756
00:46:54,270 --> 00:46:59,130
0 og 1 og 2 og 3 hele veien opp til 9 hadde sine egne ASCII-koder.

757
00:46:59,130 --> 00:47:02,300
De er ikke tilfeldigvis 0 til 9. De er svært forskjellige.

758
00:47:02,300 --> 00:47:08,770
Så 0 betyr bare "jeg er spesiell", og de \ 0 betyr, bokstavelig talt, "Jeg er ikke den 0 karakter."

759
00:47:08,770 --> 00:47:11,360
"Jeg er denne spesielle verdi, null karakter."

760
00:47:11,360 --> 00:47:16,930
Så jeg faktisk trenger en annen av disse siden jeg ikke kan gjøre den samme feilen to ganger.

761
00:47:16,930 --> 00:47:21,550
>> Så etter ordet BYE vi også kommer til å trenge en av disse nulltegn.

762
00:47:21,550 --> 00:47:27,090
La meg ta min penn her og la meg raskt trekke et \ 0

763
00:47:27,090 --> 00:47:30,480
slik at etter at jeg har bedt operativsystemet for to strenger

764
00:47:30,480 --> 00:47:33,270
via GetString etterfulgt av et annet kall til GetString,

765
00:47:33,270 --> 00:47:35,640
dette er hva som faktisk er i minnet.

766
00:47:35,640 --> 00:47:39,900
Så når jeg kommer tilbake en streng, jeg virkelig får tilbake at,

767
00:47:39,900 --> 00:47:43,450
og når jeg får den neste strengen, jeg virkelig å få tilbake det.

768
00:47:43,450 --> 00:47:47,910
Så dette ber spørsmålet, strlen, først av alt, hva skal det tilbake?

769
00:47:47,910 --> 00:47:54,650
Når jeg ringer strlen på strengen s og s var ordet HELLO at brukeren har skrevet inn,

770
00:47:54,650 --> 00:47:57,800
hva gjorde vi selvsagt si lengden på HELLO var for noen minutter siden?

771
00:47:57,800 --> 00:48:01,290
Det var 5, ikke sant? H-E-L-L-O. Og det er faktisk hvordan strlen fungerer.

772
00:48:01,290 --> 00:48:05,670
Den returnerer hva et normalt menneske ville forvente lengden på en streng å være.

773
00:48:05,670 --> 00:48:11,030
Men i virkeligheten, hvor stor er rekke tegn som er lagring hallo?

774
00:48:11,030 --> 00:48:12,770
Det er faktisk seks.

775
00:48:12,770 --> 00:48:15,740
Så strlen nevner ikke det faktum for deg.

776
00:48:15,740 --> 00:48:20,300
Men under panseret datamaskinen faktisk bruker 6 bytes til å lagre en 5-brev ord,

777
00:48:20,300 --> 00:48:22,380
og dette gjelder uansett hvor lenge ordet er.

778
00:48:22,380 --> 00:48:26,470
Det er alltid kommer til å være en spesiell null terminerende tegnet på slutten av strengen

779
00:48:26,470 --> 00:48:28,800
å demarc sin totale lengde.

780
00:48:28,800 --> 00:48:33,430
>> Så hvis du er nå den som implementerer strlen 20, 30 år siden,

781
00:48:33,430 --> 00:48:35,520
hvordan du går om å implementere strlen seg selv?

782
00:48:35,520 --> 00:48:39,980
Vi tar for gitt at den eksisterer, akkurat som vi tar for gitt at printf eksisterer,

783
00:48:39,980 --> 00:48:42,850
men hvis HELLO er ordet i spørsmålet

784
00:48:42,850 --> 00:48:45,220
og hva jeg har i minnet er noe som ser ut som dette,

785
00:48:45,220 --> 00:48:48,130
hvis du måtte reimplement strlen fordi du ble bedt om å

786
00:48:48,130 --> 00:48:50,260
eller fordi, ærlig, visste du ikke strlen eksisterte -

787
00:48:50,260 --> 00:48:54,280
du måtte rulle dette på egen hånd - hvordan kunne du gjennomføre strlen

788
00:48:54,280 --> 00:48:57,760
når det gis noe som ser ut som dette?

789
00:48:57,760 --> 00:49:02,750
Nå som vi vet en streng er en matrise, kan vi iterere over hver av de enkelte tegn

790
00:49:02,750 --> 00:49:06,320
bruke noe sånt som - la oss prøve å gjøre dette på fly.

791
00:49:06,320 --> 00:49:12,060
>> La meg gå inn i apparatet. La meg lage en ny fil, strlen.c.

792
00:49:12,060 --> 00:49:19,260
La meg gå videre nå og tar med stdio.h slik at vi har tilgang til printf.

793
00:49:19,260 --> 00:49:25,820
La meg gjøre int main (void). Oh. Jeg skal bare gjøre dette på min egen for nå da. [Humrer]

794
00:49:25,820 --> 00:49:28,300
Takk.

795
00:49:28,300 --> 00:49:31,000
Dette er hva jeg gjør. OK.

796
00:49:31,000 --> 00:49:34,820
Så før jeg skrudde på skjermen, jeg skrev alt dette.

797
00:49:34,820 --> 00:49:37,550
Og nå hva jeg skal gjøre er følgende:

798
00:49:37,550 --> 00:49:40,360
printf ("Gi meg en streng:")

799
00:49:40,360 --> 00:49:42,700
Det er bare LUN instruksjoner.

800
00:49:42,700 --> 00:49:45,700
Nå la meg gjøre string s = GetString.

801
00:49:45,700 --> 00:49:47,260
Jeg har allerede trenger å gjøre en endring nå.

802
00:49:47,260 --> 00:49:52,740
Jeg bruker CS50 bibliotek plutselig, så la meg gå videre og skrive cs50.h.

803
00:49:52,740 --> 00:50:00,720
Og nå la oss gjøre dette: printf ("Lengden er:% d, strlen [s] -

804
00:50:00,720 --> 00:50:03,540
og jeg er ikke ferdig ennå. Hva annet har jeg å legge til dette programmet?

805
00:50:03,540 --> 00:50:05,740
>> [Student] string.h. >> String.h.

806
00:50:05,740 --> 00:50:10,800
Så for nå bruker vi strlen, så la oss sørge for at kompilatoren vet hvor det er,

807
00:50:10,800 --> 00:50:12,390
så litt sunn fornuft sjekk.

808
00:50:12,390 --> 00:50:16,400
Jeg får en streng på linje 8, og i linje 9 Jeg skriver ut sin lengde med% d.

809
00:50:16,400 --> 00:50:19,400
Så la oss gå videre og åpne opp dette.

810
00:50:19,400 --> 00:50:23,380
Vi har å gjøre strlen - sammenstiller greit -

811
00:50:23,380 --> 00:50:30,120
strlen - la meg zoome inn - Enter, H-E-L-L-O, Enter. Lengden er 5.

812
00:50:30,120 --> 00:50:32,730
>> Ok, så strlen ser ut til å fungere, men verden kjente det.

813
00:50:32,730 --> 00:50:37,310
Så la oss nå implementere strlen oss som følger.

814
00:50:37,310 --> 00:50:39,490
La meg ta dette biblioteket unna.

815
00:50:39,490 --> 00:50:42,590
Vi har ikke lenger tilgang til string.h fordi jeg ikke engang at det eksisterte.

816
00:50:42,590 --> 00:50:45,970
Men det er greit fordi jeg kan implementere strlen selv

817
00:50:45,970 --> 00:50:50,200
og må ta det en streng som heter input,

818
00:50:50,200 --> 00:50:53,830
og nå trenger jeg å finne ut lengden på denne strengen.

819
00:50:53,830 --> 00:50:55,880
Så hvordan kan jeg gjøre dette?

820
00:50:55,880 --> 00:51:00,190
Hva hvis jeg gjør - la oss se hvordan du gjør dette - Hva vil du gjøre?

821
00:51:00,190 --> 00:51:04,130
>> [Uhørlig student respons] >> Ok.

822
00:51:04,130 --> 00:51:05,970
Så vi kan gjøre dette på en rekke måter. La meg prøve å ta denne tilnærmingen.

823
00:51:05,970 --> 00:51:10,220
La meg gi meg en int variabel i, så jeg starter på 0.

824
00:51:10,220 --> 00:51:19,380
Og la meg si dette: mens input [i] er ikke lik hva? \ 0.

825
00:51:19,380 --> 00:51:23,480
Så det viser seg, som med tilfellet med alle chars når du skriver dem bokstavelig talt i et program,

826
00:51:23,480 --> 00:51:25,940
du må bruke enkle anførselstegn, ikke doble anførselstegn.

827
00:51:25,940 --> 00:51:29,250
Så hvis jeg skulle skrive bokstaven a, vil jeg gjøre det, bokstav b, vil jeg gjøre det.

828
00:51:29,250 --> 00:51:33,440
Dette, derimot, ville være en streng, ikke en individuell karakter.

829
00:51:33,440 --> 00:51:38,470
>> Så jeg vil \ 0 bokstavelig. Hva ønsker jeg å gjøre i denne loop?

830
00:51:38,470 --> 00:51:42,650
Egentlig trenger jeg en annen variabel, så int lengde får 0.

831
00:51:42,650 --> 00:51:46,190
Selv om du ikke var sikker på hvorfor vi startet den måten vi gjorde,

832
00:51:46,190 --> 00:51:50,110
nå som vi kommer ned denne veien, hva jeg ønsker å gjøre på linje 9?

833
00:51:50,110 --> 00:51:55,820
lengde + + og deretter ned her på linje 10, retur lengde.

834
00:51:55,820 --> 00:51:58,370
Så hvordan er strlen implementert?

835
00:51:58,370 --> 00:52:00,550
Det er faktisk gjennomført trolig som dette.

836
00:52:00,550 --> 00:52:03,470
Kanskje den personen brukte en for loop, kanskje en gjøre mens loop - hvem vet?

837
00:52:03,470 --> 00:52:05,940
Vi hadde virkelig nødt til å se under panseret på selve kildekoden

838
00:52:05,940 --> 00:52:08,520
i noen fil som heter string.c sannsynligvis.

839
00:52:08,520 --> 00:52:10,480
>> Men her la oss tenke på hva jeg gjør.

840
00:52:10,480 --> 00:52:13,640
Jeg erklærer en variabel kalt i, sette den lik 0.

841
00:52:13,640 --> 00:52:17,520
Jeg så erklære en annen variabel kalt lengde, sette den lik 0.

842
00:52:17,520 --> 00:52:25,440
Så jeg sier, mens ith karakter i inngangen er ikke lik den spesielle null karakter, \ 0,

843
00:52:25,440 --> 00:52:27,070
inkrementere lengden.

844
00:52:27,070 --> 00:52:32,550
Men så snart ed karakter er denne spesielle karakter, hva skjer med loop?

845
00:52:32,550 --> 00:52:36,540
Det kortslutninger. Den stopper, noe som betyr at vi da umiddelbart returnere lengde.

846
00:52:36,540 --> 00:52:40,740
>> Så hvis jeg ikke rotet opp, la oss gå videre og gå tilbake til min terminal-vinduet.

847
00:52:40,740 --> 00:52:43,550
La meg rekompilere. Og jeg ikke skru opp.

848
00:52:43,550 --> 00:52:46,320
Uforenlig redeklarasjon av biblioteket funksjon strlen.

849
00:52:46,320 --> 00:52:48,650
Så jeg prøvde å få altfor smart for mitt eget beste her.

850
00:52:48,650 --> 00:52:51,610
Kompilatoren vet faktisk at det er en funksjon kalt strlen

851
00:52:51,610 --> 00:52:55,290
selv om vi ikke har inkludert biblioteket. Det er fint. Uansett.

852
00:52:55,290 --> 00:52:58,230
Vi bare kommer til å samarbeide da. La oss endre navnet på denne lengden.

853
00:52:58,230 --> 00:53:04,110
La meg endre bruken av det til lengde her, og dette vil gjøre Clang lykkeligere.

854
00:53:04,110 --> 00:53:08,900
Som en side, fordi noen av disse funksjonene er så darn felles -

855
00:53:08,900 --> 00:53:12,390
strlen, prinf - de faktisk har slags spesiell status.

856
00:53:12,390 --> 00:53:15,310
Og så Clang vet bare noe spesielt med dem.

857
00:53:15,310 --> 00:53:18,760
Det er ikke alltid tilfelle med de fleste funksjoner, så det er derfor vi fikk skreket til.

858
00:53:18,760 --> 00:53:21,350
>> La meg prøve igjen. Heldigvis, det virket den gangen.

859
00:53:21,350 --> 00:53:23,560
Så nå la meg kjøre min egen strlen program.

860
00:53:23,560 --> 00:53:29,740
Gi meg en streng: H-E-L-L-O, Enter. Og jeg har skrudd opp.

861
00:53:29,740 --> 00:53:34,750
Hvorfor? >> [Uhørlig student respons] >> Nettopp.

862
00:53:34,750 --> 00:53:39,180
Så jeg har meg selv her en veldig pen uendelig loop

863
00:53:39,180 --> 00:53:42,270
fordi selv om jeg økes lengden på hver iterasjon,

864
00:53:42,270 --> 00:53:47,860
hva jeg åpenbart ikke gjør? Jeg er ikke økes i. Okay. Lett å fikse. Ja?

865
00:53:47,860 --> 00:53:52,430
Okay. Nei Nå vil vi kjøre på kant med noen andre vanlige feil der jeg trenger parentes.

866
00:53:52,430 --> 00:53:54,430
Og ærlig, er denne koden begynner å se stygt,

867
00:53:54,430 --> 00:53:56,460
så vi får ta en stikke på rengjøring dette opp i et øyeblikk.

868
00:53:56,460 --> 00:53:58,810
Men nå er jeg økes både lengde og jeg.

869
00:53:58,810 --> 00:54:02,630
Ærlig, jeg ser allerede en mulighet for forbedring her, men vi vil komme tilbake til det.

870
00:54:02,630 --> 00:54:05,270
>> Så nå la oss bare sørge for at vi er minst gjør fremskritt.

871
00:54:05,270 --> 00:54:08,320
Dette har skjedd til noen av dere, og jeg forsømmer å nevne dette på forhånd.

872
00:54:08,320 --> 00:54:12,420
Når du har ulykke av et scenario som dette, hvordan kan du fikse dette

873
00:54:12,420 --> 00:54:15,130
kort med å starte apparatet eller datamaskinen eller lukke vinduet?

874
00:54:15,130 --> 00:54:16,860
Det er faktisk lett.

875
00:54:16,860 --> 00:54:21,680
Kontroll C vil sende denne lille gulrot symbol C, og som bare avslutter de fleste programmer.

876
00:54:21,680 --> 00:54:25,990
Hvis du har en virkelig dårlig uendelig loop som er skrive ting uendelig mange ganger,

877
00:54:25,990 --> 00:54:29,960
noen ganger må du kanskje treffe kontroll C tusen ganger for å gjøre det faktisk høre det.

878
00:54:29,960 --> 00:54:33,910
Så bare innser nå fordi jeg ikke skrive noe, det var ganske enkelt.

879
00:54:33,910 --> 00:54:37,970
Og teknisk, en gang er nok, men jeg bli utålmodig og jeg vanligvis treffer det at mange ganger.

880
00:54:37,970 --> 00:54:43,400
>> Så strlen. Gi meg en streng: HELLO. Er det kommer til å fungere denne gangen?

881
00:54:44,580 --> 00:54:47,490
Okay. En annen vanlig feil. Nødt til å rekompilere.

882
00:54:47,490 --> 00:54:50,430
Som var tilsiktet, at en. OK.

883
00:54:50,430 --> 00:54:54,260
Så strlen, H-E-L-L-O, Enter. Utmerket.

884
00:54:54,260 --> 00:54:55,910
Så vi har nå en strlen til 5.

885
00:54:55,910 --> 00:54:58,100
Så vi har bokstavelig talt reimplemented at hjulet.

886
00:54:58,100 --> 00:55:02,080
Så nå la oss rydde opp dette fordi dette ikke gjør meg imponert

887
00:55:02,080 --> 00:55:04,080
med utformingen av koden min.

888
00:55:04,080 --> 00:55:07,200
Hva kan vi tydelig eliminere i dette programmet for å rydde opp?

889
00:55:07,200 --> 00:55:11,840
[Uhørlig student respons] >> Ja. Bokstavelig talt, vi behandler i og lengde likt.

890
00:55:11,840 --> 00:55:16,440
Så hvorfor ikke vi bare få smart og si mens lengden?

891
00:55:16,440 --> 00:55:20,450
Snarere, la oss bare kalle det lengde til å begynne med, initialisere den til 0

892
00:55:20,450 --> 00:55:23,340
fordi standard strengen har ingen lengde inntil vi finner ut hva det er.

893
00:55:23,340 --> 00:55:26,160
>> Nå gjør vi dette, og nå er dette en ganske elegant program.

894
00:55:26,160 --> 00:55:28,660
En variabel. Jeg ryddet det opp, strammet opp.

895
00:55:28,660 --> 00:55:31,980
Så nå la oss gå tilbake til min terminal-vinduet. La oss gå videre og kjøre denne.

896
00:55:31,980 --> 00:55:35,670
Gjør strlen. Ser bra ut. Kjør strlen igjen, Enter.

897
00:55:35,670 --> 00:55:40,680
Gi meg en streng: HELLO, Enter. Og det ser ut til å virke som 5.

898
00:55:40,680 --> 00:55:45,580
Nå, for å være klar, hvis jeg ikke hadde skrevet, for eksempel, HELLO i en streng

899
00:55:45,580 --> 00:55:48,840
og deretter BYE i en annen, kan vi sikkert ha flere ord.

900
00:55:48,840 --> 00:55:53,150
Hvis uttrykket jeg faktisk ønsket å skrive var ikke HELLO men, for eksempel,

901
00:55:53,150 --> 00:55:58,920
HELLO WORLD, legg merke til at det vi ikke ville ha er denne situasjonen her, ikke sant?

902
00:55:58,920 --> 00:56:00,580
Som skulle tilsi at det er to strenger.

903
00:56:00,580 --> 00:56:06,060
Du sikkert kan ha plass bar tegn, så hvis vi faktisk skrevet i en lengre setning

904
00:56:06,060 --> 00:56:08,390
som HELLO WORLD, hva vi ville virkelig ha i minnet

905
00:56:08,390 --> 00:56:12,730
ser litt noe sånt der.

906
00:56:12,730 --> 00:56:18,910
>> OK. Eventuelle spørsmål da om representasjon her av strenger?

907
00:56:18,910 --> 00:56:20,450
Nei? OK.

908
00:56:20,450 --> 00:56:25,130
Så jeg sa tidligere at ringer strlen igjen og igjen bevisst sånn

909
00:56:25,130 --> 00:56:28,070
sannsynligvis ikke den beste ideen fordi du kommer til å gjøre en hel masse arbeid

910
00:56:28,070 --> 00:56:30,280
igjen og igjen og igjen.

911
00:56:30,280 --> 00:56:36,150
Ja, hva slags arbeid som er nødvendig for å finne ut lengden på en streng, tilsynelatende?

912
00:56:36,150 --> 00:56:40,720
Du må starte på begynnelsen og deretter se, se, se, se, se

913
00:56:40,720 --> 00:56:44,930
til du endelig se den spesielle karakter, noe som medførte, ah, nå vet jeg lengden.

914
00:56:44,930 --> 00:56:48,040
Så tidligere da vi hadde strlen bli kalt igjen og igjen og igjen,

915
00:56:48,040 --> 00:56:52,080
grunnen til at jeg foreslo det var litt dumt er fordi igjen, ser at strengen sånn.

916
00:56:52,080 --> 00:56:54,880
Det kommer ikke til å endres hver gang du iterate gjennom noen loop,

917
00:56:54,880 --> 00:56:56,890
så du gjør unødig arbeid.

918
00:56:56,890 --> 00:57:00,620
Samtidig bør du vet, som en side, at kompilatorer som Clang disse dager

919
00:57:00,620 --> 00:57:02,530
har blitt utviklet over mange år,

920
00:57:02,530 --> 00:57:05,690
og kompilatoren forfattere, programmerere, er ganske smart.

921
00:57:05,690 --> 00:57:10,170
Og så viser det seg at klang og andre kompilatorer kan faktisk finne ut at,

922
00:57:10,170 --> 00:57:13,650
okay, ja, du skrev strlen i din tilstand,

923
00:57:13,650 --> 00:57:17,520
som betyr teknisk at vi vil kalle det igjen og igjen og igjen.

924
00:57:17,520 --> 00:57:21,880
Men smarte kompilatorer kan faktisk optimalisere slike dårlig brukeropplevelse beslutninger

925
00:57:21,880 --> 00:57:23,870
ut av koden din til oppreisning ting.

926
00:57:23,870 --> 00:57:27,360
>> Så bare innse at noen ganger kompilatoren er smartere enn oss

927
00:57:27,360 --> 00:57:29,210
og vil slags skjule våre egne feil.

928
00:57:29,210 --> 00:57:31,620
Men sikkert når det kommer til oppgavesett og lignende,

929
00:57:31,620 --> 00:57:35,340
gjør være å tenke på de fundamentalt feilaktige design beslutninger

930
00:57:35,340 --> 00:57:38,110
potensielt av den enkle grunn at vi skulle gjøre mye mer arbeid

931
00:57:38,110 --> 00:57:41,330
enn vi faktisk har å gjøre. Men hvor mye mer arbeid?

932
00:57:41,330 --> 00:57:44,960
I tilfelle av HELLO WORLD, la oss begynne å generalisere størrelsen på dette problemet.

933
00:57:44,960 --> 00:57:48,100
Hva er lengden på problemet eller størrelsen av problemet

934
00:57:48,100 --> 00:57:50,770
når ordet brukeren skrev inn er HELLO?

935
00:57:50,770 --> 00:57:53,790
Det er tydeligvis 5, kanskje 6. Pluss eller minus 1. Uansett.

936
00:57:53,790 --> 00:57:55,680
Det er så nær vi vil bare kalle det 5.

937
00:57:55,680 --> 00:58:00,480
>> Så hva er størrelsen på problemet her når du prøver å finne ut lengden på HELLO?

938
00:58:00,480 --> 00:58:06,790
Det er 1, 2, 3, 4, 5, og kanskje 6 for det siste tegnet, men la generalisere at som n.

939
00:58:06,790 --> 00:58:10,300
Så n, bare variabelen n, er det dataforskere ville vanligvis bruker

940
00:58:10,300 --> 00:58:13,890
å beskrive størrelsen på et problem, og problemet på hånden er hvor lenge er HELLO?

941
00:58:13,890 --> 00:58:17,050
Hvor mye tid tar strlen?

942
00:58:17,050 --> 00:58:21,010
Det tar på rekkefølgen av n trinn, hvor hvert trinn innebærer se et tegn,

943
00:58:21,010 --> 00:58:23,350
se på et tegn, se på et tegn.

944
00:58:23,350 --> 00:58:26,850
Og vi hadde denne diskusjonen en stund tilbake, antall operasjoner noe tar.

945
00:58:26,850 --> 00:58:29,910
Den aller første dagen i klassen vi hadde alle klønete stå opp,

946
00:58:29,910 --> 00:58:32,060
og deretter begynte alle sammenkobling av med hverandre

947
00:58:32,060 --> 00:58:35,990
for å faktisk telle ideelt hvor mange som var i rommet.

948
00:58:35,990 --> 00:58:39,860
Og vi gjorde også en annen ting der hvis jeg i stedet gjorde det den gamle skolen måte

949
00:58:39,860 --> 00:58:44,800
av bare starter 1, 2, 3, 4, 5, 6 og så videre,

950
00:58:44,800 --> 00:58:49,360
det også, var størrelsen på det problemet av størrelse n. Det var n mennesker i rommet.

951
00:58:49,360 --> 00:58:52,010
Men jeg kunne fremskynde det opp, ikke sant? Klasse på skolen stil jeg kunne begynne å telle i 2s.

952
00:58:52,010 --> 00:58:55,560
2, 4, 6, 8, 10, 12. Og det føles så mye raskere, og faktisk er det.

953
00:58:55,560 --> 00:59:01,720
Det er bokstavelig talt dobbelt så fort, men igjen, hvis en annen 400 mennesker gikk inn i dette rommet

954
00:59:01,720 --> 00:59:08,250
alt på en gang, ville disse algoritmene ta ytterligere 400 eller kanskje 200 trinnene.

955
00:59:08,250 --> 00:59:13,310
>> Men derimot, hvis vi virkelig bli smart og vi i stedet har alle dere telle selv,

956
00:59:13,310 --> 00:59:15,280
husker hvordan det algoritmen fungerte.

957
00:59:15,280 --> 00:59:17,110
Du alle sto opp. La meg spole frem til dette.

958
00:59:17,110 --> 00:59:20,430
Du alle sto opp, du koblet sammen, så halvparten av dere satte seg,

959
00:59:20,430 --> 00:59:22,510
halvparten av dere satte seg, satte halvparten av dere ned,

960
00:59:22,510 --> 00:59:27,350
og på hver iterasjon av denne sløyfen fra uke 0, halvert vi problemet på hånden

961
00:59:27,350 --> 00:59:30,040
og gikk til n / 2, så n / 4, deretter n / 8.

962
00:59:30,040 --> 00:59:35,350
Og konsekvensen av det er at hvis en annen 400 personer gå inn i rommet, ingen big deal,

963
00:59:35,350 --> 00:59:40,120
det vil ta oss en runde til, ikke 400 flere runder, ikke 200 flere runder.

964
00:59:40,120 --> 00:59:43,640
Og så historien vi fortalte en stund tilbake måtte gjøre litt noe med dette.

965
00:59:43,640 --> 00:59:47,750
Denne røde linjen her er lineær, er det rett, og det er merket som n

966
00:59:47,750 --> 00:59:50,250
fordi som størrelsen av et problem vokser,

967
00:59:50,250 --> 00:59:54,690
hvis algoritme eller program som du løse det tar n skritt,

968
00:59:54,690 --> 00:59:58,620
vi kan plotte det som en rett linje hvor det tar mer tid jo større størrelsen av problemet.

969
00:59:58,620 --> 01:00:03,280
Og twosies tilnærming, telling 2, 4, 6, 8, fremdeles en rett linje, bare litt bedre.

970
01:00:03,280 --> 01:00:08,440
Det tar litt mindre tid, så den gule linjen er under den røde linjen punkt for punkt.

971
01:00:08,440 --> 01:00:12,580
>> Men enda bedre var denne hellige gral av det vi kalte logaritmisk tid

972
01:00:12,580 --> 01:00:14,830
der selv om vi igjen doble antall personer i rommet,

973
01:00:14,830 --> 01:00:18,240
Vi dobler størrelsen på den telefonen bok fra første kursdag,

974
01:00:18,240 --> 01:00:22,310
ingen big deal, det tar 1 mer siden tåre, tar en mer sitte ned

975
01:00:22,310 --> 01:00:25,550
for å løse et problem som er dobbelt så stort.

976
01:00:25,550 --> 01:00:27,460
Og så samtalen vi nå får å begynne å ha er

977
01:00:27,460 --> 01:00:30,380
hvordan gjør vi faktisk løse problemer effektivt

978
01:00:30,380 --> 01:00:32,510
hvis vi betrakter den enkleste av problemer som dette?

979
01:00:32,510 --> 01:00:36,210
Anta at vi har åtte dører bak som er noen tall,

980
01:00:36,210 --> 01:00:39,720
og hver av disse tallene ikke er sortert på noen måte,

981
01:00:39,720 --> 01:00:42,830
de er bare tilfeldige heltall bak disse dørene,

982
01:00:42,830 --> 01:00:47,290
og vi stiller spørsmålet hvordan du går om å finne nummeret - hvem vet -

983
01:00:47,290 --> 01:00:50,250
7 bak disse dørene?

984
01:00:50,250 --> 01:00:53,400
Hva ville du, et menneske, gjør for å finne meg nummer 7

985
01:00:53,400 --> 01:00:56,810
hvis igjen hver av disse er dører og for å se en verdi du må åpne en dør?

986
01:00:56,810 --> 01:00:59,650
Hva ville din algoritmen være kanskje?

987
01:00:59,650 --> 01:01:05,310
>> [Uhørlig student respons] >> Så starter med venstre og åpne en dør, åpne en dør, åpner en dør.

988
01:01:05,310 --> 01:01:08,570
Og i verste fall er hvor lang tid det kommer til å ta oss med å finne nummer 7?

989
01:01:08,570 --> 01:01:12,800
Og igjen, de er ikke sortert, så det er ikke så lett som, vel, jeg kommer til å åpne den 7. døren.

990
01:01:12,800 --> 01:01:15,240
Det kan ta oss, maksimalt, 8 trinn.

991
01:01:15,240 --> 01:01:19,940
I verste fall er 7 tilfeldig på slutten av linjen av dører,

992
01:01:19,940 --> 01:01:22,090
så vi må kanskje prøve alle n dører.

993
01:01:22,090 --> 01:01:24,440
Så igjen her, synes vi å ha en lineær algoritme.

994
01:01:24,440 --> 01:01:27,030
Faktisk, vi gjorde dette bare et par år siden.

995
01:01:27,030 --> 01:01:29,910
En av dine forgjengere ble utfordret med nettopp dette

996
01:01:29,910 --> 01:01:32,050
der vi ikke har en digital versjon, vi i stedet hadde en tavle

997
01:01:32,050 --> 01:01:33,780
med noen biter av papir på den.

998
01:01:33,780 --> 01:01:36,940
Og det jeg trodde jeg ville gjøre er å ta en rask titt tilbake på hvordan dette gikk,

999
01:01:36,940 --> 01:01:40,760
en av de beste og kanskje mest pinlige muligheter på scenen

1000
01:01:40,760 --> 01:01:42,530
å ha en demonstrasjon her på Sanders.

1001
01:01:42,530 --> 01:01:44,000
Vi hadde 2 rader med tall.

1002
01:01:44,000 --> 01:01:47,280
Vi kommer bare til å se på hva som skjer her med Sean for toppen av disse radene.

1003
01:01:47,280 --> 01:01:49,660
Med mindre ingen noensinne igjen frivillige i CS50,

1004
01:01:49,660 --> 01:01:52,010
Vi hadde Sean velsignelse for å holde dette på kameraet,

1005
01:01:52,010 --> 01:01:54,670
så han vet at hundrevis av mennesker har vært å se dette nå i år.

1006
01:01:54,670 --> 01:01:59,500
Men Sean gjorde en fantastisk jobb - eller gjorde han? - På å faktisk finne oss et bestemt nummer.

1007
01:01:59,500 --> 01:02:04,570
>> Så la oss se hvordan han løste denne algoritmen slik at vi vil gjenoppta denne samtalen før lenge

1008
01:02:04,570 --> 01:02:08,300
hvordan finner vi ting effektivt.

1009
01:02:08,300 --> 01:02:12,300
[Malan på video] Jeg har gjemt bak disse dørene nummer 7,

1010
01:02:12,300 --> 01:02:16,710
men gjemt bort i noen av disse dørene også er andre ikke-negative tall,

1011
01:02:16,710 --> 01:02:19,980
og målet ditt er å tenke på dette øverste raden med tall som bare en matrise

1012
01:02:19,980 --> 01:02:22,920
eller bare en sekvens av biter av papir med tall bak dem,

1013
01:02:22,920 --> 01:02:26,960
og målet ditt er, bare å bruke den øverste rekke her, finne meg nummer 7.

1014
01:02:26,960 --> 01:02:30,800
Og vi deretter gå til kritikk hvordan du går om å gjøre det. >> Greit.

1015
01:02:30,800 --> 01:02:33,880
[Malan] Finn oss nummer 7, takk.

1016
01:02:36,210 --> 01:02:38,350
[Latter]

1017
01:02:41,610 --> 01:02:44,460
[Malan] Nei [latter]

1018
01:02:45,760 --> 01:02:58,080
5, 19, 13, [latter]. Det er ikke et lurespørsmål.

1019
01:03:00,560 --> 01:03:02,390
1.

1020
01:03:04,560 --> 01:03:06,910
[Latter]

1021
01:03:06,910 --> 01:03:10,760
På dette punktet poengsummen din er ikke veldig bra, så du kan like godt holde det gående. [Latter]

1022
01:03:12,490 --> 01:03:14,070
3.

1023
01:03:17,340 --> 01:03:23,480
Gå på. Oppriktig, jeg kan ikke hjelpe, men lurer på hva du tenker selv om. [Latter]

1024
01:03:25,010 --> 01:03:28,870
Bare den øverste raden, slik at du har tre venstre. Så finn me 7.

1025
01:03:28,870 --> 01:03:45,360
[Studenter mumlet]

1026
01:03:46,270 --> 01:03:49,870
[Malan] 17.

1027
01:03:49,870 --> 01:03:55,460
[Studenter mumlet]

1028
01:03:56,920 --> 01:04:01,550
[Malan] 7! [Applaus]

1029
01:04:01,550 --> 01:04:06,080
>> Så på onsdag vil vi dykke inn i dette og mer sofistikerte algoritmer for å finne ting.

1030
01:04:06,080 --> 01:04:10,200
For nå skal vi la deg med Sean og se deg på onsdag.

1031
01:04:11,280 --> 01:04:13,000
[CS50.TV]