1
00:00:00,000 --> 00:00:02,310
[Powered by Google Translate] [Uke 4, Fortsatt]

2
00:00:02,310 --> 00:00:04,240
[David J. Malan - Harvard University]

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

4
00:00:07,290 --> 00:00:11,290
>> Dette er CS50, og dette er slutten av uke 4.

5
00:00:11,290 --> 00:00:14,030
Så noen gode nyheter og noen dårlige nyheter.

6
00:00:14,030 --> 00:00:26,240
Ingen forelesning på mandag, setter ikke noe problem neste uke. [Studenter jubler]

7
00:00:26,240 --> 00:00:28,680
Du kommer ikke til å like hvor dette går.

8
00:00:28,680 --> 00:00:31,590
Men vi har dette i stedet neste onsdag,

9
00:00:31,590 --> 00:00:37,740
og det er også i henhold til pensum en fredag ​​forelesning neste fredag, slik at vi kan holde deg på sporet.

10
00:00:37,740 --> 00:00:40,580
Men alt vil bli filmet som vanlig, så ikke bekymre deg.

11
00:00:40,580 --> 00:00:44,100
>> Og med hensyn til quiz 0 hva vi skal gjøre mot ukens slutt

12
00:00:44,100 --> 00:00:47,140
er innlegg på kursets hjemmeside cs50.net en forklaring

13
00:00:47,140 --> 00:00:50,160
av hva slags forventninger du bør ha når det kommer til den første quiz.

14
00:00:50,160 --> 00:00:55,100
Generelt vil det være flere valg, true-false, korte svaret, korte koding problemer.

15
00:00:55,100 --> 00:00:57,360
Du kommer ikke til å bli forventet å gjennomføre tilsvarende

16
00:00:57,360 --> 00:01:00,030
av et problem som du ville se på en pset, som du har en datamaskin

17
00:01:00,030 --> 00:01:03,240
og en debugger og lignende, men det vil være små koding problemer.

18
00:01:03,240 --> 00:01:06,900
>> Og ja, den beste guiden for å få en følelse av hva CS50 spørrekonkurranser er som

19
00:01:06,900 --> 00:01:09,180
er å gå til cs50.net, gå til Quizzes link,

20
00:01:09,180 --> 00:01:11,920
og du kan se de siste årene verdt av spørrekonkurranser.

21
00:01:11,920 --> 00:01:16,600
Bare innse at læreplanen ikke alltid har vært den samme gjennom årene.

22
00:01:16,600 --> 00:01:18,510
Noen ganger kan vi legge til, noen ganger trekke fra,

23
00:01:18,510 --> 00:01:20,670
så hvis du ser noen tema på en av de gamle spørrekonkurranser

24
00:01:20,670 --> 00:01:25,380
at du ikke har noen anelse om hva det er snakk om, er det enten at vi dekker det

25
00:01:25,380 --> 00:01:27,210
eller at vi ikke dekke det.

26
00:01:27,210 --> 00:01:31,110
Men i form av anmeldelser, dette søndag, mandag og tirsdag

27
00:01:31,110 --> 00:01:34,770
samt et kurs-wide gjennomgang økt på søndag kveld -

28
00:01:34,770 --> 00:01:37,500
tid og sted vil bli annonsert på kurset hjemmeside -

29
00:01:37,500 --> 00:01:40,120
dere alle har en mulighet til å gjennomgå med kursets undervisning stipendiater

30
00:01:40,120 --> 00:01:44,830
materialet for dette året, både i snitt og som en full klasse,

31
00:01:44,830 --> 00:01:48,400
og de vil bli filmet som vanlig også.

32
00:01:48,400 --> 00:01:53,380
>> OK. Så uten videre, én kommentar bestått / ikke bestått og legg til / slipp.

33
00:01:53,380 --> 00:01:57,980
Du har kanskje sett mine notater i går kveld, og dette er egentlig bare litt ekstra oppmuntring

34
00:01:57,980 --> 00:02:01,250
at hvis du er blant de spesielt mindre komfortable eller et sted i mellom

35
00:02:01,250 --> 00:02:04,870
og du føler deg bare litt over hodet,

36
00:02:04,870 --> 00:02:08,430
skjønner det er faktisk ganske vanlig, og det er en god støtte strukturen på plass,

37
00:02:08,430 --> 00:02:13,530
hvorav kontortid var innstilt på å forbedre alle mer per e-posten min i går kveld,

38
00:02:13,530 --> 00:02:16,520
og innser også at et alternativ som bestått / ikke bestått for en klasse som dette

39
00:02:16,520 --> 00:02:21,540
virkelig er ment som en mekanisme for å ta kanten av av et kurs som dette,

40
00:02:21,540 --> 00:02:24,200
slik at nytt hvis du tilbringer de 10, 15, 20 timer

41
00:02:24,200 --> 00:02:28,160
prøver bare å få litt pset å jobbe og du vet at du 90-95% av veien dit

42
00:02:28,160 --> 00:02:32,100
men du kan ikke finne noen jævla bug, i en bestått / ikke bestått modell som er liksom greit.

43
00:02:32,100 --> 00:02:36,230
>> Tanken er at med den mekanismen kan du deretter gå fokus på de andre psets

44
00:02:36,230 --> 00:02:39,530
eller sove eller hva det er som du ønsker å fokusere på.

45
00:02:39,530 --> 00:02:43,390
Så skjønner at du har inntil førstkommende tirsdag - teknisk 5. mandag,

46
00:02:43,390 --> 00:02:50,840
men det er en ferie, så førstkommende tirsdag - for å bytte fra bestått / ikke bestått til gradert eller vice versa.

47
00:02:50,840 --> 00:02:54,450
Og hvis du er virkelig på stupet og tenker på å slippe helt,

48
00:02:54,450 --> 00:02:56,440
vennligst ta meg etter foredraget eller send meg en melding.

49
00:02:56,440 --> 00:02:59,990
Vi vil gjerne minst chat før du legger inn bud adjø.

50
00:02:59,990 --> 00:03:03,470
OK. Så vi begynte å ta trening hjul av forrige gang.

51
00:03:03,470 --> 00:03:06,030
Spesielt har vi fokusert på streng.

52
00:03:06,030 --> 00:03:09,740
String er noe som deklarert i CS50 biblioteket,

53
00:03:09,740 --> 00:03:14,340
spesielt i den filen som heter cs50.h som vi vil begynne å se på denne uken og neste.

54
00:03:14,340 --> 00:03:17,250
Men strengen er egentlig bare en forenkling av noe

55
00:03:17,250 --> 00:03:20,980
som er litt mer arcanely beskrevet som char *.

56
00:03:20,980 --> 00:03:24,090
Char vi er kjent med. Det er bare ett tegn.

57
00:03:24,090 --> 00:03:28,010
Men * fra mandag betegnet hva? >> [Student] En peker.

58
00:03:28,010 --> 00:03:31,290
En peker. Og hva er en peker? >> [Student] En adresse.

59
00:03:31,290 --> 00:03:33,420
>> Det er som en adresse, et sted i minnet.

60
00:03:33,420 --> 00:03:35,910
Hva er en adresse eller et sted eller minne?

61
00:03:35,910 --> 00:03:40,290
Igjen, alle av oss har bærbare datamaskiner med en gig eller to gigabyte RAM mest sannsynlig i disse dager,

62
00:03:40,290 --> 00:03:44,160
og det betyr at du har en milliard eller 2 milliarder bytes verdt minne.

63
00:03:44,160 --> 00:03:46,240
Og det spiller ingen rolle egentlig hva det fysisk ser ut,

64
00:03:46,240 --> 00:03:51,220
men ta på tro at du kan telle alle de individuelle byte som din egen laptop har -

65
00:03:51,220 --> 00:03:54,580
Dette er byte 0, er det byte 1, dette er byte 2 milliarder -

66
00:03:54,580 --> 00:03:56,100
og det er akkurat hva en datamaskin gjør.

67
00:03:56,100 --> 00:04:00,030
Når du tildele plass for en enkelt karakter, for eksempel,

68
00:04:00,030 --> 00:04:02,480
det har åpenbart å leve et sted i datamaskinens minne,

69
00:04:02,480 --> 00:04:05,860
og kanskje det er på byte nummer 12345,

70
00:04:05,860 --> 00:04:08,470
og det er et sted her oppe i datamaskinens minne.

71
00:04:08,470 --> 00:04:12,630
Og adressen da av at karakteren er 12345.

72
00:04:12,630 --> 00:04:16,140
>> Nå i uke 0 til nå, så langt har vi ikke egentlig brydde

73
00:04:16,140 --> 00:04:19,170
hvor i minnet ting lagres fordi vi vanligvis bruker symboler,

74
00:04:19,170 --> 00:04:22,540
variabler, og arrays å faktisk få på våre data.

75
00:04:22,540 --> 00:04:24,950
Men som av mandag og alle de mer i dag, nå er du nødt til

76
00:04:24,950 --> 00:04:27,710
alle de mer uttrykksfulle evner med å skrive programmer

77
00:04:27,710 --> 00:04:31,330
å virkelig manipulere datamaskinens minne slik du ønsker,

78
00:04:31,330 --> 00:04:33,720
for både gode formål og dårlige,

79
00:04:33,720 --> 00:04:39,620
bugs er en svært vanlig resultat på dette punktet i å lære disse tingene.

80
00:04:39,620 --> 00:04:42,460
Men hva betyr det egentlig å være en char *?

81
00:04:42,460 --> 00:04:46,140
La oss gå videre tilbake til - og vi vil komme tilbake til Binky som lovet i dag.

82
00:04:46,140 --> 00:04:48,670
La oss gå til et enkelt eksempel her.

83
00:04:48,670 --> 00:04:53,060
La meg lagre denne filen som compare.c, og la meg bare få litt malkoder her

84
00:04:53,060 --> 00:05:00,490
så ta stdio.h, la meg også gi meg selv inkluderer cs50.h. Jeg zoome inn der oppe.

85
00:05:00,490 --> 00:05:05,850
La meg begynne å skrive viktigste int, main (void), og nå ønsker jeg å gjøre noe som dette:

86
00:05:05,850 --> 00:05:13,520
printf ("Gi meg en streng:") og da vil jeg bruke streng s blir GetString

87
00:05:13,520 --> 00:05:16,750
å få en streng fra brukeren, så jeg kommer til å be brukeren om en annen.

88
00:05:16,750 --> 00:05:21,870
("Gi meg en annen streng:") og jeg kommer til å be dem via GetString å få det.

89
00:05:21,870 --> 00:05:27,020
Jeg vil kalle det t fordi t kommer etter s og s er et fint navn for en streng hvis det er ganske generisk.

90
00:05:27,020 --> 00:05:30,030
Så GetString, og nå er jeg bare ønsker å gjøre en mental helse sjekk, og jeg kommer til å si

91
00:05:30,030 --> 00:05:39,770
if (s == t) da jeg bare kommer til å fortelle brukeren printf ("Du skrev det samme \ n");

92
00:05:39,770 --> 00:05:45,520
ellers skal jeg skrive ut noe sånt ("Du skrev noe annet! \ n")

93
00:05:45,520 --> 00:05:48,460
eller hva setningen vil bli. Så noe sånt.

94
00:05:48,460 --> 00:05:52,200
Så som vanlig, vil jeg returnere 0 som bare betydde at ingenting dårlig skjedde,

95
00:05:52,200 --> 00:05:54,400
og jeg kommer til å gå videre og kompilere og kjøre dette programmet.

96
00:05:54,400 --> 00:05:56,540
>> Men på mandag kjørte vi dette programmet,

97
00:05:56,540 --> 00:06:00,420
og faktisk ble fortalt at HELLO er ikke hei og farvel er ikke farvel.

98
00:06:00,420 --> 00:06:03,140
Oppførselen vi så var litt mer som dette.

99
00:06:03,140 --> 00:06:11,450
La meg gå inn i min kilde katalog, zoome inn her, og la oss gjør sammenligne.

100
00:06:11,450 --> 00:06:14,570
Utarbeidet greit. La meg kjøre sammenligne. Gi meg en streng: HELLO.

101
00:06:14,570 --> 00:06:16,300
Gi meg en annen streng: HELLO.

102
00:06:16,300 --> 00:06:18,000
Du har skrevet inn noe annet!

103
00:06:18,000 --> 00:06:22,650
Vel, la meg prøve noe enklere som 50, 50. Du har skrevet inn noe annet!

104
00:06:22,650 --> 00:06:25,740
hei, hei. Så klart, er noe som skjer her.

105
00:06:25,740 --> 00:06:28,440
Men hva var forklaringen på hvorfor?

106
00:06:28,440 --> 00:06:33,850
Angivelig, er linje 12 helt dysfunksjonelle.

107
00:06:34,300 --> 00:06:39,430
Hva er det grunnleggende problemet her? Ja. >> [Student] Det sammenligne adressene.

108
00:06:39,430 --> 00:06:41,850
Ja, akkurat. Det er faktisk sammenligne adressene

109
00:06:41,850 --> 00:06:44,580
hvor HELLO og HELLO er lagret.

110
00:06:44,580 --> 00:06:48,290
Det er ikke sammenligne bokstavene HELLO igjen og igjen,

111
00:06:48,290 --> 00:06:52,370
fordi hva som egentlig skjedde, hele denne tiden vi har brukt GetString -

112
00:06:52,370 --> 00:06:56,130
Dette tavle er igjen vår datamaskinens minne,

113
00:06:56,130 --> 00:07:00,100
og la oss si jeg kaller GetString etter å ha erklært en variabel s.

114
00:07:00,100 --> 00:07:01,930
Hvordan ser min hukommelse ut?

115
00:07:01,930 --> 00:07:07,070
La oss vilkårlig si at s ser slik ut. Det er en firkant.

116
00:07:07,070 --> 00:07:09,040
Og ganske mye hver gang jeg har trukket et stykke minne på skjermen

117
00:07:09,040 --> 00:07:12,860
hvis det er 32 biter jeg har vært å tegne firkanter som dette fordi faktisk i apparatet,

118
00:07:12,860 --> 00:07:17,380
en peker, en adresse, er 32 bits. Det er det samme som en int.

119
00:07:17,380 --> 00:07:19,420
Som kan variere basert på datasystemet.

120
00:07:19,420 --> 00:07:24,630
De av dere som er litt kjent med det faktum at Mac-en eller PC er 64 bits,

121
00:07:24,630 --> 00:07:28,120
som betegner faktisk at datamaskinen bruker 64-bits pekere,

122
00:07:28,120 --> 00:07:33,730
64-bits adresser, og blant de upsides av det er datamaskinene

123
00:07:33,730 --> 00:07:35,560
kan ha mye mer RAM enn yesteryear.

124
00:07:35,560 --> 00:07:39,240
Lang historie kort, tilbake i dag da datamaskiner bare brukt 32 bits

125
00:07:39,240 --> 00:07:42,740
å representere adresser, det største antallet byte du kunne representere

126
00:07:42,740 --> 00:07:46,280
i så fall var det om du har 32 bits?

127
00:07:46,280 --> 00:07:49,590
Så 4 milliarder kroner, høyre, fordi 2 til 32 er 4 milliarder.

128
00:07:49,590 --> 00:07:51,370
Dette nummeret har blitt gjentakende i kurset.

129
00:07:51,370 --> 00:07:55,240
>> Så hvis du bare har 32 bits, det høyeste tallet du kan telle til er omtrent 4 milliarder kroner.

130
00:07:55,240 --> 00:07:58,750
Men det var en fundamental begrensning av datamaskiner inntil for få år siden

131
00:07:58,750 --> 00:08:01,180
fordi hvis du bare kan telle så høyt som 4 milliarder kroner,

132
00:08:01,180 --> 00:08:05,270
det spiller ingen rolle om du kjøper 8 gigabyte RAM eller 5 gigabyte RAM;

133
00:08:05,270 --> 00:08:07,780
du kan ikke telle så høy, så det var ubrukelig.

134
00:08:07,780 --> 00:08:11,430
Du kan bare få tilgang til første 3 eller 4 gigabyte datamaskinens minne.

135
00:08:11,430 --> 00:08:14,410
Det er mindre av et problem nå, og du kan kjøpe MacBook Pro og Dells

136
00:08:14,410 --> 00:08:17,680
med 8 gigabyte RAM eller mer i disse dager.

137
00:08:17,680 --> 00:08:24,100
Men hvis jeg fordele ganske enkelt i dette programmet en peker, kalt en peker s,

138
00:08:24,100 --> 00:08:28,370
det kan se slik ut på skjermen fordi faktisk vi trenger å skrelle tilbake dette laget.

139
00:08:28,370 --> 00:08:33,520
Jeg fortsetter å si streng, men fra mandag er streng virkelig char *,

140
00:08:33,520 --> 00:08:35,590
adressen noen tegn.

141
00:08:35,590 --> 00:08:39,280
Så la oss ta det trening hjulet av, selv om vi vil fortsette å bruke GetString for nå.

142
00:08:39,280 --> 00:08:42,600
Så jeg har erklært s, og dette er en del av minnet, 32 biter.

143
00:08:42,600 --> 00:08:47,370
Hva finnes her i minnet som standard? >> [Uhørlig student respons]

144
00:08:47,370 --> 00:08:50,040
Hva er det? >> [Student] Garbage. >> Garbage. Akkurat.

145
00:08:50,040 --> 00:08:54,610
Hvis du programmerer ikke sette en verdi i en variabel, hvem vet hva det er?

146
00:08:54,610 --> 00:08:57,990
Noen ganger får du heldig, og det er 0, som er slags en fin, ren standard verdi,

147
00:08:57,990 --> 00:09:00,310
men som vi så mandag, noen ganger er det fullstendig meningsløst,

148
00:09:00,310 --> 00:09:04,130
noen virkelig stor positiv eller negativt tall som kom fra hvor?

149
00:09:05,350 --> 00:09:07,010
Ja. >> [Student] Funksjonen før. >> Ja.

150
00:09:07,010 --> 00:09:10,170
>> Ofte den funksjonen som ble kalt før, fordi husk,

151
00:09:10,170 --> 00:09:13,920
som du kaller funksjoner i minnet, de tar opp mer og mer plass fra bunnen opp,

152
00:09:13,920 --> 00:09:17,040
og så snart funksjonen returnerer, blir det minnet om igjen

153
00:09:17,040 --> 00:09:20,890
ved neste mann som blir kalt, er som bruker samme stykke minne.

154
00:09:20,890 --> 00:09:23,450
Og hvis du har forlatt søppel der, tidligere verdier,

155
00:09:23,450 --> 00:09:28,190
vi kan forveksle s som å ha noen verdi når vi virkelig ikke har satt noe der.

156
00:09:28,190 --> 00:09:30,960
Så vår RAM på dette punktet ser slik ut.

157
00:09:30,960 --> 00:09:36,030
Nå på høyre side av linje 7 vi kaller GetString,

158
00:09:36,030 --> 00:09:40,150
som vi har gjort nå i flere uker, men hva er GetString egentlig gjør?

159
00:09:40,150 --> 00:09:43,350
GetString skrevet av CS50 ansatte er litt intelligent

160
00:09:43,350 --> 00:09:46,500
i at så snart brukeren begynner å skrive nøkler og treff Enter,

161
00:09:46,500 --> 00:09:50,010
GetString tall ut hvor mange tastetrykk gjorde brukeren hit,

162
00:09:50,010 --> 00:09:53,360
hvor mange tegn trenger jeg for å fordele RAM for.

163
00:09:53,360 --> 00:09:55,660
Og hvor det RAM kommer fra, hvem vet?

164
00:09:55,660 --> 00:09:58,930
Det er et sted i datamaskinens 2 gigabyte eller whatnot minne.

165
00:09:58,930 --> 00:10:05,200
Men la oss anta at datamaskinen funnet plass for ordet HELLO her.

166
00:10:05,200 --> 00:10:08,710
Ordet jeg skrev var H-E-L-L-O.

167
00:10:08,710 --> 00:10:13,510
Og hvis vi trekke dette som en sekvens av tegn, kan vi trekke det ut som dette.

168
00:10:13,510 --> 00:10:17,860
Men jeg trenger å gjøre en ekstra ting. Hva hører på slutten av noen streng i C?

169
00:10:17,860 --> 00:10:20,710
Null karakter, som vi skriver som \ 0.

170
00:10:20,710 --> 00:10:23,980
Det er teknisk tallet 0, men backslash gjør alt klarere

171
00:10:23,980 --> 00:10:28,150
at dette er bokstavelig talt tallet 0, heltallet 0;

172
00:10:28,150 --> 00:10:32,440
Det er ikke for eksempel, sitat-unquote 0 som du kan skrive på tastaturet.

173
00:10:32,440 --> 00:10:33,940
Så dette er HELLO.

174
00:10:33,940 --> 00:10:36,350
>> Og hva gjorde vi sier mandag at en funksjon som GetString

175
00:10:36,350 --> 00:10:39,580
er faktisk returnere alle disse ukene?

176
00:10:39,580 --> 00:10:43,960
Det er ikke returnere en streng per se fordi det ikke egentlig ha betydning

177
00:10:43,960 --> 00:10:47,710
fordi strenger ikke eksisterer. De er liksom en fabrikasjon i CS50 biblioteket.

178
00:10:47,710 --> 00:10:51,300
Hva er egentlig en streng, mer teknisk? >> [Student] Det er det første tegnet.

179
00:10:51,300 --> 00:10:55,950
Akkurat. Det er rett og slett adressen til den første tegnet på at brukeren har skrevet inn

180
00:10:55,950 --> 00:11:02,810
Så hvis mitt ord HELLO ender det opp på bytenummer 123 og deretter ved byte nummer 124,

181
00:11:02,810 --> 00:11:08,320
125, 126, og så videre, hvis jeg bare mitt nummer bytes fra 0 på opp,

182
00:11:08,320 --> 00:11:12,650
hva som virkelig GetString er tilbake er bokstavelig talt antall 123.

183
00:11:12,650 --> 00:11:19,270
Så hva blir satt i s er antall 123, ikke bokstaven H, ikke ordet HALLO,

184
00:11:19,270 --> 00:11:23,130
ganske enkelt hvilken adresse jeg kan finne den første bokstaven i HELLO.

185
00:11:23,130 --> 00:11:26,500
Men det ser ikke ut som nok. Jeg spurte deg om en streng, ikke et tegn.

186
00:11:26,500 --> 00:11:32,970
Så hvordan vet vi eller datamaskinen gjør at Ello slags kommer sammen med H?

187
00:11:35,760 --> 00:11:37,460
Hva er slags enighet vi har? Ja.

188
00:11:37,460 --> 00:11:40,100
[Student] Det holder å fortelle seg selv å finne noen flere tegn. >> Nettopp.

189
00:11:40,100 --> 00:11:44,570
>> Det er denne menneske-maskin konvensjonen der når du arbeider med strenger,

190
00:11:44,570 --> 00:11:49,410
ellers kjent nå som røye stjerner, du bare nødt til å finne ut

191
00:11:49,410 --> 00:11:54,350
hvor på slutten av hver streng i livet er å egentlig bare gjentar over den med en for løkke,

192
00:11:54,350 --> 00:11:57,820
en stund loop, uansett, slik at når du finner på slutten av strengen

193
00:11:57,820 --> 00:12:02,160
nå kan du slutte fra det, oh, var hele ordet HELLO.

194
00:12:02,160 --> 00:12:04,820
De av dere med tidligere erfaring med programmering kan vite i Java

195
00:12:04,820 --> 00:12:09,880
du kan bare ringe. lengde og i andre språk kan du ringe lengde eller lignende.

196
00:12:09,880 --> 00:12:14,060
Det er fordi i en rekke språk, spesielt ting som kalles objektorienterte språk,

197
00:12:14,060 --> 00:12:18,580
lengden på noe er slags innkapslet inne i stykke data selv,

198
00:12:18,580 --> 00:12:24,000
mye som vi innkapslet IDer og navn og hus inne i en student på mandag.

199
00:12:24,000 --> 00:12:28,700
Men C er mye lavere nivå. Det er ingen objekter eller klasser, hvis du har hørt disse ordene før.

200
00:12:28,700 --> 00:12:31,490
Alt du trenger er egentlig minne adresser.

201
00:12:31,490 --> 00:12:35,540
Så dette er liksom den gammeldagse måten å representere interessante datastrukturer.

202
00:12:35,540 --> 00:12:38,760
Du har en startverdi for eksempel adressen til det første tegnet

203
00:12:38,760 --> 00:12:42,340
og deretter bare noen vilkårlige konvensjonen som alle er enige å følge.

204
00:12:42,340 --> 00:12:46,420
Så hvordan er streng lengde implementert, vi foreslår?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, som noen av dere har nå brukt et par ganger. Det er ganske enkelt, ikke sant?

206
00:12:51,360 --> 00:12:53,060
Det er som to linjer med kode.

207
00:12:53,060 --> 00:12:56,140
Det er ganske mye en for løkke av noe slag, kanskje med en ekstra lokal variabel.

208
00:12:56,140 --> 00:13:00,540
Men strlen har bare å ta en peker og deretter begynne å lete etter \ 0.

209
00:13:00,540 --> 00:13:05,190
>> Og så snart den finner det, kan den returnere det totale antall skritt som det er tatt i strengen.

210
00:13:05,190 --> 00:13:07,150
Så vi kan slutte fra dette hva som foregår på neste.

211
00:13:07,150 --> 00:13:11,850
Anta så jeg erklærer t som jeg har gjort i linje 10.

212
00:13:11,850 --> 00:13:14,280
Dette er noen søppel verdi. Hvem vet på først?

213
00:13:14,280 --> 00:13:18,490
Men på høyre side av linjen på 10 jeg ringer GetString igjen.

214
00:13:18,490 --> 00:13:20,050
Hvem vet hvor dette ender opp?

215
00:13:20,050 --> 00:13:23,830
La oss vilkårlig si at operativsystemet funnet rom for det veien hit.

216
00:13:23,830 --> 00:13:28,610
Jeg tilfeldigvis coincidentally type H-E-L-L-O igjen,

217
00:13:28,610 --> 00:13:31,260
og slik at vi kan trekke samme type bilde.

218
00:13:31,260 --> 00:13:34,290
Men det faktum at jeg har tegnet på nytt dette bildet er bevisst

219
00:13:34,290 --> 00:13:37,720
fordi det er en annen HELLO enn dette.

220
00:13:37,720 --> 00:13:43,920
Så her dette kan være plasseringen 456, dette er 457, og så videre.

221
00:13:43,920 --> 00:13:47,170
Så hva blir satt der spørsmålstegn gang var?

222
00:13:47,170 --> 00:13:50,190
I dette tilfellet 456.

223
00:13:50,190 --> 00:13:53,540
Vi plukker disse tallene vilkårlig fordi egentlig etter dag

224
00:13:53,540 --> 00:13:57,110
Vi kommer ikke til å bry seg så mye om hva adressen alt er.

225
00:13:57,110 --> 00:14:02,690
Alt vi bryr oss om er at vi kan finne ut adressen til noen del av data som HELLO.

226
00:14:02,690 --> 00:14:07,100
>> Så egentlig hva folk flest gjør i informatikk når vi snakker om minneadresser

227
00:14:07,100 --> 00:14:10,210
og snakker om pekere spesielt,

228
00:14:10,210 --> 00:14:14,220
snarere enn bry å finne ut 123 - hvem bryr seg hvor dette ting faktisk er,

229
00:14:14,220 --> 00:14:17,440
Vi bare vet at det er på noen numerisk adresse -

230
00:14:17,440 --> 00:14:22,180
vi forenkle verden og bare si at s peker til det tegnet

231
00:14:22,180 --> 00:14:25,080
og t peker til det tegnet.

232
00:14:25,080 --> 00:14:27,430
Og det faktum at det er en pil er ganske tilsiktet

233
00:14:27,430 --> 00:14:31,610
fordi bokstavelig talt nå s peker på H og t peker på den andre H

234
00:14:31,610 --> 00:14:34,720
fordi på slutten av dagen, spiller det ingen rolle hva adressen er,

235
00:14:34,720 --> 00:14:40,240
men det spiller ingen rolle at vi har evnen til å uttrykke denne adressen med noen del av koden.

236
00:14:40,240 --> 00:14:42,730
Vi har egentlig ikke manipulert disse adressene ennå

237
00:14:42,730 --> 00:14:47,770
så vi får se hvor vi kan skyte og liksom gjøre ting med pekere,

238
00:14:47,770 --> 00:14:52,030
men for nå i linje 12 bokstavelig talt hvilke verdier vi sammenligner

239
00:14:52,030 --> 00:14:55,500
ifølge denne historien på linje 12?

240
00:14:56,570 --> 00:15:01,290
Vi sier er 123 lik lik 456? Og det er definitivt ikke tilfelle.

241
00:15:01,290 --> 00:15:05,320
Og selv konseptuelt, er denne pekeren definitivt ikke det samme som dette

242
00:15:05,320 --> 00:15:09,500
fordi du ringte GetString to ganger, og GetString prøver ikke å være super flink,

243
00:15:09,500 --> 00:15:12,470
det prøver ikke å innse, oh, skrev du HELLO 5 minutter siden;

244
00:15:12,470 --> 00:15:15,090
la meg gi deg den samme pekeren som jeg ga deg før,

245
00:15:15,090 --> 00:15:18,450
den fordeler bare en ny del av minnet hver gang du kaller det.

246
00:15:18,450 --> 00:15:20,350
>> Så hvordan løser vi dette problemet?

247
00:15:20,350 --> 00:15:24,270
Hvis høyere nivå jeg vil sammenligne strengene Hei og hallo -

248
00:15:24,270 --> 00:15:28,680
Jeg bryr meg ikke om pekere - hvordan går jeg om å svare på spørsmålet,

249
00:15:28,680 --> 00:15:31,980
gjorde brukeren skriver det samme? Det som er nødvendig her? Ja.

250
00:15:31,980 --> 00:15:35,200
[Student] Bruk en funksjon. >> Jeg kan bruke en funksjon ut av boksen.

251
00:15:35,200 --> 00:15:38,170
Jeg kan bruke en funksjon kalt strcmp, s-t-r-c-m-p,

252
00:15:38,170 --> 00:15:41,190
bare en forkortet versjon av si streng sammenligne.

253
00:15:41,190 --> 00:15:45,070
Og hvis vi går inn, for eksempel sammenligne 2, som er blant dagens brosjyrer,

254
00:15:45,070 --> 00:15:46,690
Jeg gjør akkurat det.

255
00:15:46,690 --> 00:15:51,750
Jeg holdt alt annet det samme fra linje 1 ned til 26 eller så,

256
00:15:51,750 --> 00:15:54,360
og nå merker denne delen har endret bare litt.

257
00:15:54,360 --> 00:15:57,690
La oss ignorere linje 28 for et øyeblikk og fokusere bare på denne.

258
00:15:57,690 --> 00:16:00,410
Hva sa vi mandag at str Sammenligning gjør?

259
00:16:00,410 --> 00:16:05,200
Den håndterer prosessen med å ta 2 pekere, S og T i dette tilfellet,

260
00:16:05,200 --> 00:16:08,480
slags praktisk talt sette fingeren på de to bokstavene,

261
00:16:08,480 --> 00:16:11,530
og hva det må gjøre er noe som en stund løkke eller en for loop,

262
00:16:11,530 --> 00:16:16,050
og det sier er disse det samme? I så fall flyttes fingrene eller pekere fremover.

263
00:16:16,050 --> 00:16:17,970
Er disse like, disse samme, disse samme,

264
00:16:17,970 --> 00:16:22,710
disse samme, disse samme? Og ooh, jeg er på slutten av strengen både s og t.

265
00:16:22,710 --> 00:16:26,780
Jeg har ikke funnet noen selvmotsigelser. Ja, disse strengene er de samme.

266
00:16:26,780 --> 00:16:31,940
Og hva sammenligne str retur hvis to strenger er de samme, tilsynelatende? Zero.

267
00:16:31,940 --> 00:16:35,900
Så 0 er god i dette tilfellet fordi hvis det returnerer -1 eller +1,

268
00:16:35,900 --> 00:16:40,560
det betyr at s bare skjer for å komme før t alfabetisk eller etter t.

269
00:16:40,560 --> 00:16:43,760
Og hvorfor skulle det være nyttig å ha en funksjon som forteller deg hvilke streng kommer før

270
00:16:43,760 --> 00:16:46,720
eller etter i en ordbok?

271
00:16:46,720 --> 00:16:48,740
[Student] Searching. >> Søke og sortering.

272
00:16:48,740 --> 00:16:51,730
>> Så du kan gjøre ting som binære søk eller boble sortere eller flette slag

273
00:16:51,730 --> 00:16:53,230
hvor du må sammenligne ting.

274
00:16:53,230 --> 00:16:56,420
Så langt vi har slags kutte noen hjørner og bare snakket om sortering

275
00:16:56,420 --> 00:16:59,430
i sammenheng med tall fordi det er hyggelig og lett å snakke om,

276
00:16:59,430 --> 00:17:02,430
men du kan sikkert sammenligne strenger, eple og banan,

277
00:17:02,430 --> 00:17:05,349
fordi hvis Apple er kjent for å komme før banan, på samme måte,

278
00:17:05,349 --> 00:17:09,319
kan du flytte strenger rundt i minnet akkurat som Rob gjorde med fletting slags i videoen

279
00:17:09,319 --> 00:17:15,880
og vi gjorde her på scenen med valg sortere, innsetting sortere og boble slag.

280
00:17:15,880 --> 00:17:18,710
Så hvor ellers kan vi ta dette? La oss prøve dette.

281
00:17:18,710 --> 00:17:23,980
La oss liksom glemme at leksjon for et øyeblikk og prøv nå og kopiere 1.c til å gjøre følgende.

282
00:17:23,980 --> 00:17:26,800
I tråd 21 jeg sier print noe,

283
00:17:26,800 --> 00:17:28,520
så jeg får en streng fra brukeren,

284
00:17:28,520 --> 00:17:30,690
så jeg sjekker dette.

285
00:17:30,690 --> 00:17:33,620
Vi har egentlig ikke kommet inn på denne vanen ennå, men la oss nå gjøre dette.

286
00:17:33,620 --> 00:17:40,990
La oss faktisk skrelle tilbake dette laget. Dette er virkelig char *. Denne fyren er virkelig char *.

287
00:17:40,990 --> 00:17:45,690
Så hva betyr det å være sjekker om s == NULL?

288
00:17:45,690 --> 00:17:48,380
Det viser seg at når du ringer en funksjon som GetString

289
00:17:48,380 --> 00:17:51,540
eller mer generelt bare spør en datamaskin for å gi deg noen minne,

290
00:17:51,540 --> 00:17:53,030
noe kunne gå galt.

291
00:17:53,030 --> 00:17:56,630
Du kan være gal, og be datamaskinen om en terabyte med minne

292
00:17:56,630 --> 00:18:01,780
ved å be om billioner av byte som bare ikke eksisterer i datamaskinen,

293
00:18:01,780 --> 00:18:05,130
men GetString og andre funksjoner trenger noen måte roping på deg

294
00:18:05,130 --> 00:18:06,820
Hvis du har bedt om for mye.

295
00:18:06,820 --> 00:18:10,450
Og måten GetString gjør dette er hvis du har bedt om mer minne

296
00:18:10,450 --> 00:18:14,250
enn det som er tilgjengelig i datamaskinen, selv om det er super, super lav sannsynlighet

297
00:18:14,250 --> 00:18:17,730
fordi ingen av oss kommer til å skrive en trillion tegn og trykk Enter,

298
00:18:17,730 --> 00:18:21,980
men lav sannsynlighet selv om det kan være, jeg ønsker fortsatt å se etter det bare i tilfelle,

299
00:18:21,980 --> 00:18:26,120
og den spesielle verdi som GetString, svar, og andre funksjoner avkastning

300
00:18:26,120 --> 00:18:30,630
hvis noe har gått galt er NULL i alle caps.

301
00:18:30,630 --> 00:18:36,520
>> Og hva er NULL? NULL bare så skjer for å representere en peker. Det er minneadresse 0.

302
00:18:36,520 --> 00:18:40,800
Verden besluttet at vilkårlig, hvis dette er min datamaskinens minne - vet du hva? -

303
00:18:40,800 --> 00:18:46,260
vi kommer til å stjele bare 1 byte av hver datamaskinens minne, og dette er stedet 0.

304
00:18:46,260 --> 00:18:49,560
Vi kommer til å gi den et kallenavn av NULL, og vi kommer til å love

305
00:18:49,560 --> 00:18:52,660
at vi aldri vil faktisk sette reelle data der

306
00:18:52,660 --> 00:18:56,770
fordi vi bare vilkårlig trenger en spesiell verdi, 0, aka NULL,

307
00:18:56,770 --> 00:19:00,230
slik at vi kan kjefte på brukere hvis noe går galt.

308
00:19:00,230 --> 00:19:03,590
Ellers kan du kanskje ikke vet betyr 0 sette noe her

309
00:19:03,590 --> 00:19:05,490
eller betyr det noe gikk galt?

310
00:19:05,490 --> 00:19:09,190
Vi må alle enige om at NULL betyr ingenting ble returnert,

311
00:19:09,190 --> 00:19:11,700
ingen faktiske adressen ble returnert.

312
00:19:11,700 --> 00:19:15,210
Nå, her er jeg bare vedta mitt menneskelige konvensjon av jeg kommer tilbake en fra main

313
00:19:15,210 --> 00:19:17,040
hvis noe går galt.

314
00:19:17,040 --> 00:19:20,650
Det er fordi viktigste er tilbake konvensjonen er å returnere 0 hvis bra,

315
00:19:20,650 --> 00:19:22,990
1 eller en annen verdi dersom dårlig.

316
00:19:22,990 --> 00:19:28,200
Men GetString og alle funksjoner som avtaler i minne returnerer NULL hvis noe går dårlig.

317
00:19:28,200 --> 00:19:33,480
>> Okay. Så dessverre, ikke 27 linje, super enkelt om det er helt å kopiere strengen.

318
00:19:33,480 --> 00:19:35,740
Hvorfor? Vi kan se dette som følger.

319
00:19:35,740 --> 00:19:40,120
Jeg vil hevde at i linje 27 som skal lage en kopi av s og kaller det ikke.

320
00:19:40,120 --> 00:19:45,790
Så jeg ikke ber brukeren om to strenger denne gangen, jeg sier bare verdien i s

321
00:19:45,790 --> 00:19:47,870
bør settes i t samt.

322
00:19:47,870 --> 00:19:52,890
Så nå bare for å demonstrere hvor ødelagt dette er, i linje 29 og fremover hva jeg gjør?

323
00:19:52,890 --> 00:19:56,980
Først skal jeg sjekke om lengden på t er større enn 0.

324
00:19:56,980 --> 00:19:59,330
Det er noen streng der. Brukeren har skrevet noe i.

325
00:19:59,330 --> 00:20:03,410
Hva er linje 32 gjør, tilsynelatende?

326
00:20:03,410 --> 00:20:08,910
[Uhørlig student respons] >> Høyre. Du kan slags antyde det fra hva jeg sa det gjør.

327
00:20:08,910 --> 00:20:13,200
Men teknisk sett, er hva dette gjør? t [0] representerer hva?

328
00:20:13,200 --> 00:20:15,140
[Student] The zeroth karakter. >> [Malan] The zeroth karakter.

329
00:20:15,140 --> 00:20:19,620
Eller, mer menneskelignende, det første tegnet i t, uansett hva det er, H kanskje i dette tilfellet.

330
00:20:19,620 --> 00:20:24,990
Og toupper gjør hva den sier. Det drar fordel zeroth karakter t og det forandrer det.

331
00:20:24,990 --> 00:20:28,430
Så dette betyr å ta zeroth karakter t, gjør det store bokstaver,

332
00:20:28,430 --> 00:20:30,320
og sette den tilbake i samme sted.

333
00:20:30,320 --> 00:20:35,540
Så hvis jeg skriver hei med små bokstaver, bør dette endre små h til en kapital H.

334
00:20:35,540 --> 00:20:41,400
Men problemet er at i linjene 35 og 36 hva jeg skal gjøre er å skrive ut for oss s og t.

335
00:20:41,400 --> 00:20:43,120
Og hva er din anelse?

336
00:20:43,120 --> 00:20:47,250
Hva skal jeg faktisk kommer til å se om jeg har skrevet i hallo i alle små bokstaver?

337
00:20:47,250 --> 00:20:52,280
Hva kommer til å få trykt? >> [Uhørlig student respons] >> Hva er det?

338
00:20:52,280 --> 00:20:58,360
[Student] Big H og resten små. >> Den stor h og resten små som, s eller t?

339
00:20:58,360 --> 00:21:03,170
[Student] Begge. >> Begge. Akkurat. Så la oss se hva som skjer her.

340
00:21:03,170 --> 00:21:08,380
>> La meg gå videre og kompilere dette. Dette er Kopi1, så sørg Kopi1. OK.

341
00:21:08,380 --> 00:21:14,840
Zoome i. La meg gå videre og kjøre Kopi1, Enter, Si noe: hello små bokstaver.

342
00:21:14,840 --> 00:21:19,570
Det kapitalisert kopien, men det tilsynelatende aktivert den opprinnelige også,

343
00:21:19,570 --> 00:21:22,070
fordi det som skjer nå i denne historien?

344
00:21:22,070 --> 00:21:27,030
I linje 27 jeg ikke faktisk synes å være å kopiere strengen,

345
00:21:27,030 --> 00:21:30,450
men selv om du kanskje har intuitivt håpet at å være tilfelle,

346
00:21:30,450 --> 00:21:33,680
hvis du tenker på dette bildet, det som virkelig har jeg gjort?

347
00:21:33,680 --> 00:21:35,410
Halvdel av bildet er den samme.

348
00:21:35,410 --> 00:21:39,390
Så la oss rulle tilbake i tid, slik at t ikke eksisterer ennå i historien.

349
00:21:39,390 --> 00:21:43,160
S kan eksistere i historien, men la oss små bokstaver hei denne gangen.

350
00:21:43,160 --> 00:21:46,710
Så la meg fikse hva jeg faktisk skrev i.

351
00:21:46,710 --> 00:21:51,280
I dette tilfellet har vi her h-e-l-l-o.

352
00:21:51,280 --> 00:21:58,050
Vi vil trekke det som en sekvens av tegn, sette min separator linjer her og min \ 0.

353
00:21:58,050 --> 00:22:05,980
Så dette er hvor vi er så snart linje 1 til og med 24-ish, gi eller ta, har gjennomført.

354
00:22:05,980 --> 00:22:07,800
Dette er bildet av min hukommelse.

355
00:22:07,800 --> 00:22:10,800
Når jeg kommer til linje 27, hva skjer?

356
00:22:10,800 --> 00:22:14,730
Akkurat som før, får jeg en peker, som jeg vil trekke så denne plassen.

357
00:22:14,730 --> 00:22:19,740
Det kalles t. Og hva er verdien som standard? Hvem vet? Noen søppel verdi.

358
00:22:19,740 --> 00:22:22,060
>> Så jeg skal abstrakte at bort som et spørsmålstegn.

359
00:22:22,060 --> 00:22:27,670
Og så snart høyre side av linje 27 kjører, hva jeg setter innsiden av t?

360
00:22:27,670 --> 00:22:30,770
Det samme som er i s.

361
00:22:30,770 --> 00:22:34,120
Så hvis vi for et øyeblikk fjerne denne abstraksjon av pilen, og vi sier,

362
00:22:34,120 --> 00:22:40,330
oh, er dette minnet belastning adresse 123, når du sier t får s, semikolon,

363
00:22:40,330 --> 00:22:42,700
du bokstavelig talt setter 123 her.

364
00:22:42,700 --> 00:22:45,200
Hvis vi nå slags forenkle vår verden igjen med bilder,

365
00:22:45,200 --> 00:22:48,750
hva du har virkelig gjort er nettopp lagt en pil til din verden

366
00:22:48,750 --> 00:22:52,910
som er peker fra t til samme nøyaktige strengen.

367
00:22:52,910 --> 00:22:59,730
Så når du er i tråd 31 og 32 faktisk jeg går om å endre t [0],

368
00:22:59,730 --> 00:23:05,580
hva er t [0] tilsynelatende synonymt med nå? s [0]

369
00:23:05,580 --> 00:23:07,030
Så det er alt som skjer.

370
00:23:07,030 --> 00:23:09,900
Og selv om denne typen føles litt lavt nivå og uforståelige

371
00:23:09,900 --> 00:23:12,760
og denne typen føles som kanskje intuitivt dette skulle ha bare jobbet -

372
00:23:12,760 --> 00:23:15,410
Jeg har laget kopier av ting før, og det bare virket -

373
00:23:15,410 --> 00:23:18,590
hvis du faktisk tenke på hva en streng egentlig er, er det en char *.

374
00:23:18,590 --> 00:23:21,700
Vel, hva er det? Det er adressen til noen tegn.

375
00:23:21,700 --> 00:23:24,930
Så kanskje det er mer fornuftig at når du prøver å gjøre noe

376
00:23:24,930 --> 00:23:29,220
super tilsynelatende enkelt som dette, er alt du gjør kopiere et minne adresse.

377
00:23:29,220 --> 00:23:32,530
Du er ikke faktisk gjør noe med selve strengen.

378
00:23:32,530 --> 00:23:37,500
Så selv om du har ingen anelse om hvordan du ville løse dette problemet i koden,

379
00:23:37,500 --> 00:23:45,080
høyt nivå, konseptuelt, hva vi trenger å gjøre for å gjøre ta tro kopi av s, tilsynelatende?

380
00:23:46,670 --> 00:23:48,820
Ja. >> [Student] Gi den et nytt sted? >> Nettopp.

381
00:23:48,820 --> 00:23:50,800
>> Vi trenger å gi t en splitter ny plassering.

382
00:23:50,800 --> 00:23:55,230
Vi må liksom lage en verden der vi får en ny del av minnet,

383
00:23:55,230 --> 00:24:00,090
som bare for klarhet skyld vil jeg trekke rett under dette, men det trenger ikke å være der.

384
00:24:00,090 --> 00:24:04,880
Men det må være samme størrelse, så jeg vil trekke disse vertikale linjer på samme sted.

385
00:24:04,880 --> 00:24:09,720
Det er greit hvis dette er alt søppel i utgangspunktet. Hvem vet hva som var der?

386
00:24:09,720 --> 00:24:13,850
Men trinn 1 er nødt til å være gi meg så mye minne som jeg trenger

387
00:24:13,850 --> 00:24:18,630
å passe en kopi av Hallo, deretter finne ut hvordan du kan kopiere h her, e her,

388
00:24:18,630 --> 00:24:20,390
l her og så videre.

389
00:24:20,390 --> 00:24:24,880
Men dette allerede skal føle litt opplagt selv om noen av detaljene er fortsatt abstrakt.

390
00:24:24,880 --> 00:24:28,690
Å kopiere denne strengen i dette, det er bare en for løkke eller en stund loop

391
00:24:28,690 --> 00:24:31,580
eller noe som du har blitt alt mer kjent.

392
00:24:31,580 --> 00:24:35,970
Så la oss prøve dette. La meg gå inn copy2.c.

393
00:24:35,970 --> 00:24:43,270
I copy2.c har vi nesten det samme programmet med unntak line 27.

394
00:24:43,270 --> 00:24:47,260
Det ser litt komplisert, men hvis vi bryter det ned bit for bit,

395
00:24:47,260 --> 00:24:48,950
den venstre side er den samme.

396
00:24:48,950 --> 00:24:52,790
Char * t skaper denne tingen i minnet, om enn med et spørsmålstegn

397
00:24:52,790 --> 00:24:54,680
fordi vi har ingen anelse om hva som er der som standard.

398
00:24:54,680 --> 00:24:57,920
På høyre side er vi introduserer nå en ny funksjon, malloc,

399
00:24:57,920 --> 00:25:00,640
for minne tildele, gi meg minne,

400
00:25:00,640 --> 00:25:06,900
og det tar tydeligvis hvor mange argumenter, hvor mange ting inne i parenteser?

401
00:25:09,660 --> 00:25:12,130
Jeg hørte knurr av 1 og 2, men det er bare en.

402
00:25:12,130 --> 00:25:15,320
Det er ingen komma, som betyr at det er bare en ting i parentes.

403
00:25:15,320 --> 00:25:17,720
Selv om det er andre parentes, la meg fremheve

404
00:25:17,720 --> 00:25:21,460
hva er inne i de ytterste parentes, og det er dette uttrykket:

405
00:25:21,460 --> 00:25:25,880
(Strlen (s) + 1) * sizeof (char).

406
00:25:25,880 --> 00:25:29,190
Så hvis vi faktisk tenke gjennom dette, dette sier gi meg lengden på s.

407
00:25:29,190 --> 00:25:34,440
Hvorfor er jeg, men legger en på lengden? >> [Uhørlig student respons]

408
00:25:34,440 --> 00:25:40,200
Akkurat. Vi trenger plass for denne fyren på halen, den sjette tegnet som ikke har noen engelske betydningen

409
00:25:40,200 --> 00:25:42,250
men har spesiell programmatisk betydning.

410
00:25:42,250 --> 00:25:46,800
>> Så vi trenger en + 1 for at fordi strlen returnerer den menneskelige forventning om lengde,

411
00:25:46,800 --> 00:25:50,890
Hei eller 5, vil det ikke gi deg den ekstra null karakter.

412
00:25:50,890 --> 00:25:52,980
Så jeg manuelt legge dette med + 1.

413
00:25:52,980 --> 00:25:56,060
Og så dette, * Størrelsen på (char), har vi ikke sett dette før.

414
00:25:56,060 --> 00:25:57,480
Dette er ikke teknisk sett en funksjon.

415
00:25:57,480 --> 00:26:04,150
Det er en spesiell søkeord som bare forteller deg hva størrelsen er av noen datatype på en datamaskin

416
00:26:04,150 --> 00:26:06,980
fordi i virkeligheten, noen av oss har 32-bits datamaskiner.

417
00:26:06,980 --> 00:26:10,900
Jeg har en ganske gammel datamaskin hjemme, og det bare bruker 32 bits til å representere pekere.

418
00:26:10,900 --> 00:26:13,900
Og så hvis jeg gjorde størrelsen på en datatype, kan det være 32 biter.

419
00:26:13,900 --> 00:26:18,300
Men hvis jeg bruker min nye fancy datamaskin, kan jeg få tilbake en verdi på 64 bits

420
00:26:18,300 --> 00:26:20,510
for noe sånt som en adresse.

421
00:26:20,510 --> 00:26:25,400
Så i dette tilfellet, bare for å være super trygg, vi kommer ikke til å hardkode noe sånt -

422
00:26:25,400 --> 00:26:28,740
Vel, hva er på størrelse med en char henhold til hva vi har sagt så langt?

423
00:26:28,740 --> 00:26:34,450
Vi har ganske mye sagt verbalt at det er en byte, og det er ganske mye sant over hele linja.

424
00:26:34,450 --> 00:26:37,000
Men igjen, forutsetninger tendens til å være dårlig.

425
00:26:37,000 --> 00:26:40,850
De fører til buggy programvare hvis folk bruker programvaren på måter du ikke har tenkt.

426
00:26:40,850 --> 00:26:44,750
Så la oss abstrakt dette bort og bare mer generelt si

427
00:26:44,750 --> 00:26:46,830
Jeg trenger dette mange biter av minne

428
00:26:46,830 --> 00:26:50,210
og hver del av minnet skal tilsvare størrelsen på en karakter,

429
00:26:50,210 --> 00:26:54,870
som faktisk er lik 1 i dette tilfellet, men det er en mer generisk måte å skrive det.

430
00:26:54,870 --> 00:27:00,460
Så hvis ordet er hallo, ikke hvor mange byte malloc tilsynelatende tildele for hallo?

431
00:27:00,460 --> 00:27:04,980
[Student] Six. >> Six. Akkurat så mange som vi har spørsmålstegn på skjermen.

432
00:27:04,980 --> 00:27:07,800
Og deretter ta en gjetning nå basert på din forståelse av GetString

433
00:27:07,800 --> 00:27:12,790
hva betyr malloc trolig tilbake? >> [Student] En adresse.

434
00:27:12,790 --> 00:27:17,020
En adresse for hva? Av den første del av minnet.

435
00:27:17,020 --> 00:27:20,670
>> Vi har ingen anelse om hva som er der fordi noen annen funksjon

436
00:27:20,670 --> 00:27:23,010
kunne ha brukt dette minnet tidligere.

437
00:27:23,010 --> 00:27:28,380
Men malloc, som GetString, returnerer adressen til den første byte minne

438
00:27:28,380 --> 00:27:30,540
at det har satt for deg.

439
00:27:30,540 --> 00:27:38,380
Men er å fylle hva det gjør ikke i denne blank med en backslash null tegn

440
00:27:38,380 --> 00:27:43,030
fordi det viser seg at du kan bruke malloc å fordele noe: Ints, strenger, arrayer,

441
00:27:43,030 --> 00:27:45,700
flyter, student strukturer.

442
00:27:45,700 --> 00:27:47,750
Du kan bruke malloc helt generisk.

443
00:27:47,750 --> 00:27:51,470
Det bryr seg ikke eller trenger å vite hva du tildele minne for.

444
00:27:51,470 --> 00:27:55,810
Så det ville være arrogant for malloc å sette en \ 0

445
00:27:55,810 --> 00:27:58,340
på slutten av hver del av minnet er det å gi deg

446
00:27:58,340 --> 00:28:02,620
fordi dette \ 0 ting er bare en konvensjon for strenger.

447
00:28:02,620 --> 00:28:06,310
Det er ikke brukt for ints, er det ikke brukt for flyter, er det ikke brukt for studenter.

448
00:28:06,310 --> 00:28:11,730
Og så fikser med malloc er at belastningen er helt på deg programmerer

449
00:28:11,730 --> 00:28:16,790
å huske hvor mange bytes du tildelt og ikke å stadig bruke en for loop

450
00:28:16,790 --> 00:28:21,570
eller en stund loop og gå forbi grensen for mengde minne du har fått.

451
00:28:21,570 --> 00:28:23,540
Sagt på en annen måte, så snart du allokere minne,

452
00:28:23,540 --> 00:28:28,510
du kan ikke be operativsystemet, oh, forresten, hvor stor av en del av minnet var dette?

453
00:28:28,510 --> 00:28:32,080
Det er helt opp til deg å huske om du trenger denne verdien.

454
00:28:32,080 --> 00:28:34,330
>> Så la oss se hvordan jeg fortsette å bruke dette minnet.

455
00:28:34,330 --> 00:28:38,430
I linje 28 og 29 hvorfor gjør jeg dette?

456
00:28:39,850 --> 00:28:42,260
Bare total mental helse sjekk.

457
00:28:42,260 --> 00:28:45,110
Bare i tilfelle noe gikk galt, ber jeg for noen sprø mengde minne

458
00:28:45,110 --> 00:28:48,690
eller jeg har så mange ting kjører på datamaskinen som det er bare ikke nok minne,

459
00:28:48,690 --> 00:28:51,780
noe sånt, jeg minst ønsker å sjekke for null.

460
00:28:51,780 --> 00:28:55,260
I virkeligheten vil de fleste datamaskiner gi deg en illusjon om at hvert program

461
00:28:55,260 --> 00:28:57,080
kan bruke sin helhet av RAM,

462
00:28:57,080 --> 00:29:00,740
men selv så, hvis brukeren skriver i noen sprø lang streng kanskje fordi de er en dårlig fyr

463
00:29:00,740 --> 00:29:03,440
og de er faktisk prøver å krasje programmet eller banalisere i det,

464
00:29:03,440 --> 00:29:07,300
Vil du i det minste sjekke returverdien av malloc og om det er lik null.

465
00:29:07,300 --> 00:29:11,630
Og hvis den gjør det, la oss bare slutte akkurat nå, fordi jeg ikke vet hva jeg skal gjøre i dette tilfellet.

466
00:29:11,630 --> 00:29:13,950
Hvordan kopierer jeg strengen? Det er noen måter å gjøre dette på.

467
00:29:13,950 --> 00:29:18,850
Det er str kopiere funksjoner i C, men det er super enkelt for oss å gjøre dette på den gammeldagse måten.

468
00:29:18,850 --> 00:29:23,110
>> Først la meg finne ut hva lengden på s er.

469
00:29:23,110 --> 00:29:26,930
Jeg kunne ha satt dette i loop, men i stedet jeg bare sette den ut her for klarhet.

470
00:29:26,930 --> 00:29:30,610
So I lagrer nå lengden av den opprinnelige streng, som er tilsynelatende 5.

471
00:29:30,610 --> 00:29:35,290
Så i min for loop jeg gjentar fra 0 på opptil n,

472
00:29:35,290 --> 00:29:40,940
og på hver iterasjon jeg setter s [i] innsiden av t [i].

473
00:29:40,940 --> 00:29:45,060
Så det er hva jeg antydet med mine 2 fingre peker på strengene før.

474
00:29:45,060 --> 00:29:49,260
Ettersom dette for loop gjentar som dette, kommer jeg til å være kopiere h inn her,

475
00:29:49,260 --> 00:29:52,890
e inn her, jeg inn her fordi dette er s, dette er t.

476
00:29:52,890 --> 00:29:58,770
Og så til slutt, i tråd 35 hvorfor gjør jeg dette?

477
00:29:58,770 --> 00:30:03,770
Jeg må sørge for at jeg slutter strengen t.

478
00:30:03,770 --> 00:30:06,170
Og jeg gjorde det på denne måten å være super eksplisitt.

479
00:30:06,170 --> 00:30:09,510
Men foreslå noen, hvis du kan, en annen måte å gjøre dette på.

480
00:30:09,510 --> 00:30:13,930
Jeg vet egentlig ikke trenger linje 35. Det er en annen måte å gjøre dette.

481
00:30:13,930 --> 00:30:18,880
Ja. >> [Uhørlig student respons] >> Si det høyere.

482
00:30:18,880 --> 00:30:20,960
[Student] Mindre enn eller lik. >> Nettopp.

483
00:30:20,960 --> 00:30:24,450
Vi kan bare si mindre enn eller lik n, som generelt har vært dårlig

484
00:30:24,450 --> 00:30:28,190
fordi nesten alltid når vi går opp til en lik ting vi teller

485
00:30:28,190 --> 00:30:30,000
vi går en skritt for langt.

486
00:30:30,000 --> 00:30:32,170
Men husk, ikke hvor mange byte vi fordele?

487
00:30:32,170 --> 00:30:37,210
Vi allokert strlen av s, så 5 + 1 for en total på 6.

488
00:30:37,210 --> 00:30:39,980
Så i dette tilfellet kan vi gjøre noe som dette

489
00:30:39,980 --> 00:30:46,450
slik at vi kopierer ikke bare hallo, men også \ 0 på slutten.

490
00:30:46,450 --> 00:30:49,860
Alternativt kan vi bruke en funksjon kalt str kopi, strcpy,

491
00:30:49,860 --> 00:30:51,700
men det ville ikke være nesten like mye moro.

492
00:30:51,700 --> 00:30:54,000
Men det er alt den gjør under panseret.

493
00:30:54,000 --> 00:30:56,050
Så til slutt, gjør vi det samme som før.

494
00:30:56,050 --> 00:31:01,620
Jeg kapitalisere t og da jeg hevder at den opprinnelige ser ut som dette, og kopien ser sånn.

495
00:31:01,620 --> 00:31:08,570
Så la oss prøve dette nå. La meg gå inn her. Gjør COPY2. Vi vil zoome inn og kjøre COPY2.

496
00:31:08,570 --> 00:31:13,840
Jeg kommer til å skrive hei med små bokstaver, og faktisk jeg får små bokstaver Hei som den opprinnelige

497
00:31:13,840 --> 00:31:16,930
men hovedstaden Hei for kopien.

498
00:31:16,930 --> 00:31:20,300
Men jeg er ikke ferdig ennå. Jeg trenger å gjøre en siste ting her.

499
00:31:20,300 --> 00:31:28,000
46 og 47 er klart frigjøre minne, men hva betyr det egentlig?

500
00:31:28,000 --> 00:31:33,250
Hva gjør jeg, tror du, ved å kalle linje 46 og linje 47?

501
00:31:33,250 --> 00:31:38,900
Hvilken effekt har det? Ja.

502
00:31:38,900 --> 00:31:43,140
[Uhørlig student respons] >> Nettopp.

503
00:31:43,140 --> 00:31:46,380
>> Du er bare å fortelle operativsystemet, hei, takk for dette minnet.

504
00:31:46,380 --> 00:31:48,320
Du kan nå bruke den til noen andre.

505
00:31:48,320 --> 00:31:50,790
Og her er et perfekt eksempel på søppel verdier.

506
00:31:50,790 --> 00:31:55,430
Jeg har bare brukt dette minnet for å skrive ned ordet hallo i 2 steder,

507
00:31:55,430 --> 00:31:57,490
her, her, her og her.

508
00:31:57,490 --> 00:32:00,910
Så dette er h-e-l-l-o-\ 0.

509
00:32:00,910 --> 00:32:06,960
Men da jeg kaller linje 46 og linje 47, og du vet hva som skjer der i form av bildet?

510
00:32:06,960 --> 00:32:10,010
Egentlig, vent, dette bildet er den gamle.

511
00:32:10,010 --> 00:32:12,550
Når vi gjør kopien, er denne fyren faktisk peker her,

512
00:32:12,550 --> 00:32:16,110
så la oss ta tallene og bare abstrakt bort som våre pilene igjen.

513
00:32:16,110 --> 00:32:19,370
Hva skjer i dette bildet når jeg ringer gratis?

514
00:32:19,370 --> 00:32:22,750
[Uhørlig student respons] >> Ikke engang.

515
00:32:22,750 --> 00:32:29,510
Hvis jeg ringer gratis på s og t - slags et lurespørsmål - dette bildet ikke endres i det hele tatt

516
00:32:29,510 --> 00:32:33,880
fordi ringer s og ringer t forteller bare operativsystemet,

517
00:32:33,880 --> 00:32:39,010
hei, kan du bruke dette minnet igjen, men det endrer ikke dette til null

518
00:32:39,010 --> 00:32:41,840
eller noen spesiell karakter, betyr det ikke endrer dette,

519
00:32:41,840 --> 00:32:47,350
det endrer ikke h eller e eller l eller l eller o i enten sted til noe annet.

520
00:32:47,350 --> 00:32:51,610
I form av bildet, så snart du ringe gratis, ingenting endres.

521
00:32:51,610 --> 00:32:56,570
Og der ligger opprinnelsen av søppel verdier fordi hvis jeg senere i dette programmet

522
00:32:56,570 --> 00:33:01,010
spør operativsystemet for mer minne med GetString eller malloc eller noe sånt

523
00:33:01,010 --> 00:33:04,900
og operativsystemet sier at, jeg har 12 byte minne bare frigjort,

524
00:33:04,900 --> 00:33:08,080
bruke disse, hva er det du kommer til å bli levert?

525
00:33:08,080 --> 00:33:10,830
Du kommer til å bli levert en del av minnet som vi vanligvis ville trekke

526
00:33:10,830 --> 00:33:13,700
med spørsmålstegn, men hva er de spørsmålstegn?

527
00:33:13,700 --> 00:33:17,000
De måtte være H-e-l-l-o, H-e-l-l-o.

528
00:33:17,000 --> 00:33:20,940
Dette er våre nye søppel verdier så snart du frigjøre dette minnet.

529
00:33:20,940 --> 00:33:22,750
>> Det er en virkelig verden implikasjon her også.

530
00:33:22,750 --> 00:33:24,720
Dette skjer for å gjøre med RAM, men datamaskinene

531
00:33:24,720 --> 00:33:26,720
faktisk gjør det samme med disken.

532
00:33:26,720 --> 00:33:30,620
Vi skal snakke om dette i særlig med et fremtidig problem sett som fokuserer på etterforskning.

533
00:33:30,620 --> 00:33:36,170
Men hva skjer egentlig hvis du har noen sensitive økonomiske filen på skrivebordet

534
00:33:36,170 --> 00:33:39,600
eller noen sketchy JPEG og du drar det inn papirkurven,

535
00:33:39,600 --> 00:33:44,390
hva skjer når du drar den i papirkurven eller papirkurven?

536
00:33:44,390 --> 00:33:47,240
Du visste hva jeg snakket om. [Latter]

537
00:33:47,240 --> 00:33:52,370
Hva skjer når du har dratt at bevis i papirkurven eller papirkurven kan?

538
00:33:52,370 --> 00:33:55,920
[Uhørlig student respons]

539
00:33:55,920 --> 00:33:58,000
Vel, så forsiktig. Hva skjer når du gjør det?

540
00:33:58,000 --> 00:34:01,030
Det korte svaret er ingenting, ikke sant?

541
00:34:01,030 --> 00:34:04,790
Sketchy eller sensitive filen fremdeles bare sitte der et sted på harddisken din.

542
00:34:04,790 --> 00:34:07,940
De fleste av oss minst har lært på den harde måten at du trenger å tømme papirkurven

543
00:34:07,940 --> 00:34:10,429
eller papirkurven å faktisk slette filer.

544
00:34:10,429 --> 00:34:13,440
Og ja, når du høyreklikker eller Kontroll-klikk på papirkurven kan

545
00:34:13,440 --> 00:34:15,580
eller velg Fil, Tøm papirkurv eller hva

546
00:34:15,580 --> 00:34:21,420
og du faktisk tømme papirkurven kan eller papirkurven, hva som faktisk skjer deretter til dette bildet?

547
00:34:22,810 --> 00:34:25,969
Mer ingenting. Slik at ingenting skjer faktisk på disk.

548
00:34:25,969 --> 00:34:30,880
>> Og hvis vi bare midlertidig digress og skrive - Jeg skal bare bruke baksiden av dette.

549
00:34:30,880 --> 00:34:34,639
Så nå historien endrer seg fra RAM, som er der programmer eksisterer

550
00:34:34,639 --> 00:34:39,250
mens du kjører dem, til disk, som er der de er lagret langsiktig

551
00:34:39,250 --> 00:34:42,920
selv når strømmen går ut, for nå - og vi vil komme tilbake til dette i fremtiden -

552
00:34:42,920 --> 00:34:46,380
la oss bare late som om dette representerer harddisken i datamaskinen din

553
00:34:46,380 --> 00:34:50,110
fordi tilbake i dag pleide de å være sirkulære disker, mye som disketter.

554
00:34:50,110 --> 00:34:55,130
Så hvis du har noen sensitive Excel-fil, kan det ta opp denne del av minnet

555
00:34:55,130 --> 00:34:59,770
på datamaskinens disk, og jeg bare tegne samme vilkårlig 1s og 0s.

556
00:34:59,770 --> 00:35:03,970
Når du drar filen sånn til papirkurven kan eller papirkurven,

557
00:35:03,970 --> 00:35:07,750
bokstavelig talt ingenting skjer fordi Apple og Microsoft har nettopp besluttet

558
00:35:07,750 --> 00:35:10,450
papirkurven kan og papirkurven er egentlig bare en midlertidig plassholder.

559
00:35:10,450 --> 00:35:14,710
Kanskje slutt OS vil tømme den for deg, men vanligvis er det ikke gjør noe,

560
00:35:14,710 --> 00:35:17,090
minst til du er veldig lav på plass.

561
00:35:17,090 --> 00:35:20,870
>> Men når du går til Tøm papirkurv eller tom papirkurven,

562
00:35:20,870 --> 00:35:23,460
på samme måte, skjer det ingenting av dette bildet.

563
00:35:23,460 --> 00:35:28,590
Alt som skjer er et annet sted på datamaskinen, er det en slags bord.

564
00:35:28,590 --> 00:35:35,400
Det er liksom som en liten jukselapp som sier det, la oss si, resume.doc,

565
00:35:35,400 --> 00:35:40,920
så din CV i et Microsoft Word-fil som brukes til å leve på stedet 123 på harddisken,

566
00:35:40,920 --> 00:35:43,710
ikke i minnet og ikke i RAM, men på harddisken,

567
00:35:43,710 --> 00:35:49,050
og dine sketchy JPEG liv i 456, og Excel-filen bor på 789 eller der.

568
00:35:49,050 --> 00:35:53,640
Når du sletter filer ved å faktisk tømme papirkurven eller papirkurven,

569
00:35:53,640 --> 00:35:59,530
Dette bildet endrer seg ikke. Den 0'er og 1'ere på harddisken ikke gå hvor som helst.

570
00:35:59,530 --> 00:36:03,930
Men denne tabellen, denne lille database av former, gjør endringen.

571
00:36:03,930 --> 00:36:08,750
Når du sletter din CV, er det som om filen er slettet i en viss forstand,

572
00:36:08,750 --> 00:36:12,790
men alle Datamaskinen glemme er der at ting lever på harddisken.

573
00:36:12,790 --> 00:36:17,870
Den 0'er og 1'ere som komponerer din CV eller noen av disse andre filer er fortsatt intakt.

574
00:36:17,870 --> 00:36:21,960
>> Så hvis du gjorde dette ved et uhell, det er fortsatt en ikke-null sannsynlighet

575
00:36:21,960 --> 00:36:25,800
at du kan gjenopprette data med Norton Utilities eller noen kommersiell programvare

576
00:36:25,800 --> 00:36:29,810
hvis formål i livet er å finne 0'er og 1'ere som har liksom blitt foreldreløse,

577
00:36:29,810 --> 00:36:33,300
glemt her, men igjen her, slik at du kan få dataene tilbake.

578
00:36:33,300 --> 00:36:38,410
Eller rettsmedisinske etterforskere med politiet eller FBI ville faktisk ta en harddisk

579
00:36:38,410 --> 00:36:42,550
og faktisk se etter mønstre av 0'er og 1'ere som ser ut som JPEG, ser ut som Excel-filer,

580
00:36:42,550 --> 00:36:46,400
og gjenopprette dem på den måten selv om datamaskinen har glemt dem der.

581
00:36:46,400 --> 00:36:49,820
Så den eneste måten virkelig å slette data, som vi vil diskutere i fremtiden,

582
00:36:49,820 --> 00:36:54,190
er å skrubbe eller tørk filen eller harddisken ved -

583
00:36:54,190 --> 00:36:56,540
Du kan egentlig ikke bli kvitt den 0'er og 1'ere

584
00:36:56,540 --> 00:36:59,440
fordi ellers du ville starte med en gigabyte harddisk

585
00:36:59,440 --> 00:37:02,380
og du vil ende opp med en megabyte harddisk hvis du stadig var å slette,

586
00:37:02,380 --> 00:37:04,380
bokstavelig talt, 0'er og 1'ere.

587
00:37:04,380 --> 00:37:06,310
Så hva ville du gjøre hvis du virkelig ønsket å dekke dine spor

588
00:37:06,310 --> 00:37:10,510
og det grunnleggende problemet er at det fortsatt er 0'er og 1'ere på disken?

589
00:37:10,510 --> 00:37:14,930
Jeg ser noen gestikulerer at du ville fysisk bryte enheten. Som vil fungere.

590
00:37:14,930 --> 00:37:19,600
[Latter] Men hvis det er slags en kostbar løsning, hva ville være mer fornuftig?

591
00:37:19,600 --> 00:37:23,270
Ja. >> [Student] Overskriv dem. >> Overskrive dem med hva? >> [Student] Andre data.

592
00:37:23,270 --> 00:37:29,070
Andre data. Du kan bare overskrive disken med 0s eller 1s eller alle 0s, alt 1s.

593
00:37:29,070 --> 00:37:31,230
>> Og det er faktisk hva noen av programvaren gjør.

594
00:37:31,230 --> 00:37:33,570
Du kan kjøpe programvare eller selv få fri programvare,

595
00:37:33,570 --> 00:37:36,610
og selv innebygd i Mac OS disse dager, mindre i Windows,

596
00:37:36,610 --> 00:37:38,660
er evnen til å sikkert slette.

597
00:37:38,660 --> 00:37:41,960
Egentlig, hvis du ønsker å alle kjøre hjem i dag hvis du har en Mac og gjøre dette,

598
00:37:41,960 --> 00:37:45,740
hvis du har noen ting i papirkurven kan, kan du gjøre Sikker tømming,

599
00:37:45,740 --> 00:37:47,610
som gjør akkurat det.

600
00:37:47,610 --> 00:37:53,350
Snarere enn bare slette filer her, betyr det ikke slette 0'er og 1'ere her,

601
00:37:53,350 --> 00:38:01,240
heller, endrer det bare dem alle, for eksempel til 0'er og prikk, prikk, prikk.

602
00:38:01,240 --> 00:38:05,330
Så en av dine fremtidige psets vil faktisk være å bevisst gjenopprette data -

603
00:38:05,330 --> 00:38:08,430
bildene vi har tatt av folk, steder og ting på campus

604
00:38:08,430 --> 00:38:12,810
som vi skal gjøre en rettsmedisinsk bilde av et digitalt kamera minnekort,

605
00:38:12,810 --> 00:38:17,120
som er nøyaktig samme idé - og du må bli utfordret til å faktisk finne

606
00:38:17,120 --> 00:38:20,160
mønstrene som representerer JPEG på harddisken,

607
00:38:20,160 --> 00:38:23,610
mye som det tidligere student som e-post leste jeg for noen uker siden gjorde

608
00:38:23,610 --> 00:38:25,860
å gjenopprette hans søster fotografier.

609
00:38:25,860 --> 00:38:30,300
Hvorfor ikke vi ta en 5-minutters pause her, og vi vil omgruppere med mer på minne.

610
00:38:33,030 --> 00:38:38,610
Så her er der ting blir litt mind-bending, men dette er en svært kraftig skritt

611
00:38:38,610 --> 00:38:40,480
mot å forstå dette enda mer.

612
00:38:40,480 --> 00:38:42,900
Her er et program som heter pointers.c.

613
00:38:42,900 --> 00:38:45,430
Det er blant dagens eksempelkode.

614
00:38:45,430 --> 00:38:51,280
Legg merke til at i de første linjene, 19 til 22, er alt vi gjør noe sånt GetString

615
00:38:51,280 --> 00:38:54,460
og returnere en adresse, lagre den i s.

616
00:38:54,460 --> 00:38:58,380
Heretter for pset selv 3 hvis du vil, men pset 4 og på

617
00:38:58,380 --> 00:39:01,030
hvor du kan begynne å ta disse trening hjul utenfor deg selv,

618
00:39:01,030 --> 00:39:04,030
det er ingen grunn til å late som strenger eksisterer lenger.

619
00:39:04,030 --> 00:39:07,030
Det er sikkert greit å bare begynne å si char *.

620
00:39:07,030 --> 00:39:12,610
>> Som en side, i online referanser og i bøker kan du ofte se stjernen ved siden av variabelen.

621
00:39:12,610 --> 00:39:15,600
Du kan selv se områder rundt begge sider av den.

622
00:39:15,600 --> 00:39:17,680
Alle disse er funksjonelt riktig.

623
00:39:17,680 --> 00:39:21,180
For nå, men vil vi standardisere på denne tilnærmingen til å gjøre super klart

624
00:39:21,180 --> 00:39:24,000
at char * er som å si karakter pekeren.

625
00:39:24,000 --> 00:39:25,680
Det er datatypen.

626
00:39:25,680 --> 00:39:28,730
Og så navnet på variabelen er s i dette tilfellet.

627
00:39:28,730 --> 00:39:31,180
Så vi har fått en streng og vi har kalt det er.

628
00:39:31,180 --> 00:39:35,180
Og deretter ned her legge merke til at jeg gjør faktisk litt lureri.

629
00:39:35,180 --> 00:39:39,080
Dette kalles pekeren aritmetikk, som er slags super enkelt.

630
00:39:39,080 --> 00:39:41,790
Det betyr bare legge til og trekke fra tall til pekere.

631
00:39:41,790 --> 00:39:43,660
Men dette fungerer faktisk.

632
00:39:43,660 --> 00:39:49,170
Dette programmet skriver tilsynelatende strengen s 1 tegn per linje slik at sluttresultatet -

633
00:39:49,170 --> 00:39:54,920
Så vi kan ødelegge hvor dette går, gjør pekere, kjøre pekere, la meg zoome inn

634
00:39:54,920 --> 00:39:58,940
Nå la meg skriver noe sånt HELLO og type Enter

635
00:39:58,940 --> 00:40:01,080
og det skrives en tegn per linje.

636
00:40:01,080 --> 00:40:04,730
Opp til en ny siden, ville vi ha gjort dette med hakeparentes notasjon.

637
00:40:04,730 --> 00:40:09,760
Vi ville ha en for loop og vi vil gjøre printf av s [i], og vi vil gjøre det igjen og igjen og igjen

638
00:40:09,760 --> 00:40:11,950
med en omvendt skråstrek n ved enden av hver linje.

639
00:40:11,950 --> 00:40:16,800
Men dette programmet er annerledes. Dette programmet bruker, bokstavelig talt, aritmetikk.

640
00:40:16,800 --> 00:40:18,860
Så hva er det som skjer her?

641
00:40:18,860 --> 00:40:24,720
Først av alt, før denne sløyfen selv utfører, hva, bare for å være klar, er s egentlig?

642
00:40:24,720 --> 00:40:27,270
S er? >> [Student] En adresse. >> En adresse.

643
00:40:27,270 --> 00:40:32,980
>> Og det er adressen, i tilfelle av hei, det første tegnet i det ordet, er som h.

644
00:40:32,980 --> 00:40:37,370
Så s er, i dette spesielle eksempel, adressen h.

645
00:40:37,370 --> 00:40:41,850
Så hva betyr det å gjøre s + jeg?

646
00:40:41,850 --> 00:40:46,280
Vel, begynner jeg på 0 i dette for loop. Vi har gjort det mange ganger.

647
00:40:46,280 --> 00:40:49,760
I er kommer til å gå opp til lengden av strengen, tilsynelatende.

648
00:40:49,760 --> 00:40:53,950
Så på den første iterasjon av denne sløyfen, i er åpenbart 0.

649
00:40:53,950 --> 00:41:01,740
Så dette uttrykket sier s + i - snarere s +0--det er åpenbart bare er.

650
00:41:01,740 --> 00:41:04,320
Så hva er * s her?

651
00:41:04,320 --> 00:41:08,530
Nå vi bruker stjernen i en litt annen måte.

652
00:41:08,530 --> 00:41:13,080
La meg gå videre og bli kvitt t fordi vi er ferdige å snakke om t og kopier av s.

653
00:41:13,080 --> 00:41:15,540
Nå er vi bare ønsker å fortelle en historie som involverer s.

654
00:41:15,540 --> 00:41:20,090
Og så i dette øyeblikk, etter å ha typen streng, ser vår verden helt som det gjorde før

655
00:41:20,090 --> 00:41:26,630
med bare s lagring adressen h og mer generelt peker på strengen hallo.

656
00:41:26,630 --> 00:41:33,170
Hvis jeg nå gjøre en linje som * (s + i), la oss prøve dette ut.

657
00:41:33,170 --> 00:41:40,140
Så * (r + i). La meg forenkle dette fordi dette er 0, så dette er * (s +0).

658
00:41:40,140 --> 00:41:43,790
Vel, vent litt. Forenkle videre. Dette er * (s).

659
00:41:43,790 --> 00:41:47,020
Vel, nå parentes slags dum, så nå la oss bare gjøre * s.

660
00:41:47,020 --> 00:41:50,540
Så i første iterasjon av denne sløyfen, den linjen som er uthevet, 26,

661
00:41:50,540 --> 00:41:53,650
er ganske mye tilsvarer skriver dette.

662
00:41:53,650 --> 00:41:56,040
Hva er datatypen for * s?

663
00:41:56,040 --> 00:42:00,770
I denne sammenheng, fordi stjernen tilfeldigvis være ved siden s selv,

664
00:42:00,770 --> 00:42:04,930
men mer spesifikt, fordi vi ikke lenger erklære s,

665
00:42:04,930 --> 00:42:09,730
vi ikke lage en variabel lenger, det er ingen omtale av char * i linje 26,

666
00:42:09,730 --> 00:42:14,280
det er ingen omtale av søkeordet streng, er vi bare bruker en variabel kalt s,

667
00:42:14,280 --> 00:42:19,650
det viser seg nå stjernen har litt annerledes og riktignok forvirrende mening.

668
00:42:19,650 --> 00:42:26,590
* S her betyr å gå til adressen i s og print alt som er der.

669
00:42:26,590 --> 00:42:33,750
Så s er her, er * s - liksom som Chutes og stiger, følger pilen - her.

670
00:42:33,750 --> 00:42:35,850
Så dette er * s.

671
00:42:35,850 --> 00:42:39,060
>> Så hva blir trykket på første iterasjon av at loop i linje 26?

672
00:42:39,060 --> 00:42:42,170
Jeg skriver ut% c, som er plassholder for en karakter,

673
00:42:42,170 --> 00:42:48,520
deretter en \ n for en ny linje. * (S + i) hvor jeg er 0 er nettopp dette.

674
00:42:48,520 --> 00:42:53,670
Så hva røye plasserer jeg i for% c? H.

675
00:42:53,670 --> 00:42:56,900
I neste iterasjon av loopen - du kan sikkert se hvor dette går -

676
00:42:56,900 --> 00:43:01,350
neste iterasjon jeg er åpenbart en, så betyr dette s en,

677
00:43:01,350 --> 00:43:05,580
og så nå jeg trenger parentesene fordi nå stjernen må si

678
00:43:05,580 --> 00:43:08,620
gå til minneadresse s +1.

679
00:43:08,620 --> 00:43:14,170
Hva er s? La oss rulle tilbake i tid og si denne pilen nå ikke faktisk gjør oss noen tjenester.

680
00:43:14,170 --> 00:43:18,450
La oss mer spesifikt si at dette er lagring av nummer 123

681
00:43:18,450 --> 00:43:25,110
fordi begynnelsen av denne strengen hei, er denne adressen 123, dette er 124, og så videre.

682
00:43:25,110 --> 00:43:30,550
Så på den andre iterasjon når jeg sier s +1, er at som å si 123 1,

683
00:43:30,550 --> 00:43:35,340
ellers kjent som 124, så hva røye blir trykt på den andre iterasjon?

684
00:43:35,340 --> 00:43:37,850
E på minneadresse 124.

685
00:43:37,850 --> 00:43:44,440
Så + igjen, 125, 126, 127, og denne sløyfen stopper heldigvis før vi får her

686
00:43:44,440 --> 00:43:49,040
fordi jeg bruker strlen å sørge for at jeg ikke teller for høy.

687
00:43:49,040 --> 00:43:50,810
Slik som er for det.

688
00:43:50,810 --> 00:43:55,000
Igjen, dette er akkurat som om vi hadde gjort for en uke siden.

689
00:43:55,000 --> 00:43:59,200
La meg skrive det på linjen under selv om vi ikke ønsker å gjøre begge deler.

690
00:43:59,200 --> 00:44:02,500
Dette er identisk nå til denne.

691
00:44:02,500 --> 00:44:08,310
>> Så selv om s er en streng, som vi har vært ringer det i ukevis, er er virkelig en char *.

692
00:44:08,310 --> 00:44:13,270
Så hvis vi ønsker å være super anal, det er virkelig riktig å skrive den spesifikke karakter

693
00:44:13,270 --> 00:44:17,490
på ITH plassering ved hjelp av disse numeriske adresser og denne stjernen operatør,

694
00:44:17,490 --> 00:44:20,470
men ærlig, dette er bare så mye renere. Så dette er ikke dårlig.

695
00:44:20,470 --> 00:44:26,720
Ingen grunn til å slutte å gjøre linje 27 her, men 26 er funksjonelt det samme,

696
00:44:26,720 --> 00:44:31,570
og det er funksjonelt det samme for nøyaktig grunnene til at vi har diskutert så langt.

697
00:44:31,570 --> 00:44:33,650
Og til slutt, er 29 bare god praksis.

698
00:44:33,650 --> 00:44:38,420
Ringe gratis s betyr at du nå er å gi tilbake minnet om at GetString ga deg

699
00:44:38,420 --> 00:44:41,630
fordi igjen, som jeg nevnte mandag, GetString uker

700
00:44:41,630 --> 00:44:44,180
har vært innføre en bug i koden din.

701
00:44:44,180 --> 00:44:46,490
Koden for uker har hatt minnelekkasjer

702
00:44:46,490 --> 00:44:49,970
der du har stilt GetString for minne, men du har aldri vært å gi den tilbake.

703
00:44:49,970 --> 00:44:53,410
Og det var bevisst valgt av oss pedagogisk

704
00:44:53,410 --> 00:44:55,880
fordi det er bare for mye å tenke på tidlig.

705
00:44:55,880 --> 00:44:57,710
Men nå trenger vi mer symmetri.

706
00:44:57,710 --> 00:45:00,830
Hvis du spør maskinen for minne, slik tilfellet er for GetString,

707
00:45:00,830 --> 00:45:02,820
slik tilfellet er tilsynelatende for malloc,

708
00:45:02,820 --> 00:45:07,970
Du må nå for pset 4 videre også gratis slike minne.

709
00:45:07,970 --> 00:45:11,650
Merke dette er forskjellig fra å si int n.

710
00:45:11,650 --> 00:45:15,040
Du trenger ikke å frigjøre dette fordi du ikke ringer GetString

711
00:45:15,040 --> 00:45:16,890
og du ikke ringe malloc.

712
00:45:16,890 --> 00:45:20,610
>> Og selv om du ringte GetInt som vi vil til slutt se,

713
00:45:20,610 --> 00:45:25,520
GetInt Tildeler ikke minne for deg fordi du kan faktisk sende rundt heltall

714
00:45:25,520 --> 00:45:29,430
og flyter og chars akkurat slik vi har gjort i flere uker.

715
00:45:29,430 --> 00:45:33,960
Strenger, men er spesielle fordi de virkelig er den sammensetning av flere tegn.

716
00:45:33,960 --> 00:45:37,450
Så de er bare annerledes fra chars og flyter og Ints og lignende.

717
00:45:37,450 --> 00:45:39,980
Men vi vil komme tilbake til det før lenge.

718
00:45:39,980 --> 00:45:44,920
Eventuelle spørsmål så på denne begynnelsen av pekere? Ja.

719
00:45:44,920 --> 00:45:49,690
[Uhørlig student spørsmål]

720
00:45:49,690 --> 00:45:51,440
Ah, veldig godt spørsmål.

721
00:45:51,440 --> 00:45:55,790
En av de få tingene C faktisk gjør for deg, som er praktisk,

722
00:45:55,790 --> 00:46:00,110
er det tall ut for deg hva størrelsen er av datatypen

723
00:46:00,110 --> 00:46:03,060
og gjør deretter den slags multiplikasjon for deg.

724
00:46:03,060 --> 00:46:06,610
Dette er irrelevant når det gjelder tegn fordi nesten alltid en røye er en byte,

725
00:46:06,610 --> 00:46:08,150
så dette bare virker.

726
00:46:08,150 --> 00:46:11,220
Men på grunn av diskusjonen, hvis du var faktisk skrive heltall

727
00:46:11,220 --> 00:46:15,500
og du prøvde å skrive ut noen verdi s som pekte mot et heltall,

728
00:46:15,500 --> 00:46:20,720
du på samme måte ikke trenger å gjøre + 4 * jeg bare fordi en int er 4 byte.

729
00:46:20,720 --> 00:46:25,780
Pointer aritmetiske betyr at C og kompilatoren gjøre alt som regnestykket for deg.

730
00:46:25,780 --> 00:46:29,190
Alt du trenger å bry seg om er opptelling i form av den menneskelige fornuft. Ja.

731
00:46:29,190 --> 00:46:35,200
[Student] Hvis du erklære en streng inne i en for loop, har du å frigjøre det senere?

732
00:46:35,200 --> 00:46:36,760
Godt spørsmål.

733
00:46:36,760 --> 00:46:41,390
>> Hvis du erklært en streng inne i for loop, trenger du å frigjøre det senere?

734
00:46:41,390 --> 00:46:47,520
Du trenger bare å frigjøre minne som du tildeler med GetString eller med malloc.

735
00:46:47,520 --> 00:46:53,110
Så hvis du bare si noe sånt - la meg sette klammeparentes nå så all koden er relatert til.

736
00:46:53,110 --> 00:46:58,580
Hvis du gjorde noe, om enn buggily, som dette, char * t = s,

737
00:46:58,580 --> 00:47:03,450
du trenger ikke å gratis t fordi t ikke innebar noen omtale av malloc eller GetString.

738
00:47:03,450 --> 00:47:08,960
Hvis derimot du gjorde dette, GetString, så ja, ville du trenger å gratis t.

739
00:47:08,960 --> 00:47:14,350
Og faktisk, er din eneste sjanse til å gjøre det nå inne i denne sløyfen, for samme utgave av omfang

740
00:47:14,350 --> 00:47:16,060
at vi har diskutert i det siste.

741
00:47:16,060 --> 00:47:18,830
Ellers ville du være tildele minne, tildele minne, tildele minne,

742
00:47:18,830 --> 00:47:21,230
og på slutten av programmet fordi du er utenfor som loop,

743
00:47:21,230 --> 00:47:24,240
t eksisterer ikke, men du har aldri fortalt operativsystemet

744
00:47:24,240 --> 00:47:26,750
at du ikke trenger det minnet lenger.

745
00:47:26,750 --> 00:47:30,430
Og før lang, for pset 4 eller 5 vil vi utstyre deg med et program som heter Valgrind,

746
00:47:30,430 --> 00:47:34,160
som er lik i ånden til GDB i at det har litt av en uforståelige grensesnitt,

747
00:47:34,160 --> 00:47:35,750
men dens formål i livet er å hjelpe deg.

748
00:47:35,750 --> 00:47:39,380
Og Valgrind er et program som vil i fremtiden søke i programmene

749
00:47:39,380 --> 00:47:42,550
på jakt etter minnelekkasjer, enten fra GetString eller malloc,

750
00:47:42,550 --> 00:47:47,800
som vi vil ta i bruk alle de mer som vi slutter å bruke CS50 bibliotek så mye.

751
00:47:47,800 --> 00:47:53,030
Vi endelig har nå liksom den ordforråd og den slags mental modell i teorien

752
00:47:53,030 --> 00:47:55,170
som å løse denne brutt program.

753
00:47:55,170 --> 00:47:59,410
>> Så i denne brutt program, fungerer swap innsiden av swap,

754
00:47:59,410 --> 00:48:05,280
men det har aldri egentlig jobbet i hoved fordi main vedtatt i x og y, husker,

755
00:48:05,280 --> 00:48:07,260
og de ble vedtatt i av verdier, så å si.

756
00:48:07,260 --> 00:48:09,330
Kopier av dem ble gitt til bytte.

757
00:48:09,330 --> 00:48:12,520
Ved utgangen av swap, hadde a og b faktisk blitt utvekslet,

758
00:48:12,520 --> 00:48:16,120
men selvfølgelig x og y, som vi diskuterte mandag, ikke hadde vært.

759
00:48:16,120 --> 00:48:19,940
Så jeg foreslår i grønt her at dette er faktisk den løsningen her.

760
00:48:19,940 --> 00:48:22,640
Og faktisk, la meg flytte mine stjerner bare for å være konsekvent

761
00:48:22,640 --> 00:48:24,440
selv om, igjen, funksjonelt dette spiller ingen rolle.

762
00:48:24,440 --> 00:48:28,730
I fremtiden uker vil vi forklare når og hvorfor det gjør saken.

763
00:48:28,730 --> 00:48:30,600
Så i grønt er nå en løsning.

764
00:48:30,600 --> 00:48:33,700
Oppriktig, det ser en hel masse messier fordi jeg har alle disse stjernene.

765
00:48:33,700 --> 00:48:35,380
La meg påpeke en ting.

766
00:48:35,380 --> 00:48:40,040
Den øverste linjen her der det står int * a og int * b

767
00:48:40,040 --> 00:48:42,820
er fundamentalt gjør det samme som det alltid har gjort.

768
00:48:42,820 --> 00:48:47,070
Det er erklære 2 argumenter eller parametere for å bytte,

769
00:48:47,070 --> 00:48:49,940
hvorav den første er en int pekeren kalles,

770
00:48:49,940 --> 00:48:53,100
den andre av dem er et int pekeren kalt B.

771
00:48:53,100 --> 00:48:55,770
Det eneste som er nytt på dette punktet er det faktum at det er en stjerne der.

772
00:48:55,770 --> 00:48:59,340
>> Hva betyr det? A er ikke en int, er B ikke en int.

773
00:48:59,340 --> 00:49:04,100
A er adressen til en int og b er adressen til en annen int.

774
00:49:04,100 --> 00:49:06,980
Her nede, dette er hvor jeg innrømme C blir forvirrende.

775
00:49:06,980 --> 00:49:09,790
Nå vi bruker en stjerne, men det har forskjellig betydning i denne sammenheng.

776
00:49:09,790 --> 00:49:13,150
Fordi vi ikke erklære pekere som vi er her oppe,

777
00:49:13,150 --> 00:49:15,500
her er vi dereferencing ting.

778
00:49:15,500 --> 00:49:21,520
Så teknisk, stjernen i denne sammenheng av første, andre og tredje linje innsiden av swap

779
00:49:21,520 --> 00:49:24,560
er å gå på dereferanse operatør, som bare betyr at det.

780
00:49:24,560 --> 00:49:27,400
Så akkurat som min finger fulgte pilen til h,

781
00:49:27,400 --> 00:49:31,100
* En del gå til denne adressen og finne meg int som er der.

782
00:49:31,100 --> 00:49:34,250
* B del gå til adressen og passere meg hva som er der.

783
00:49:34,250 --> 00:49:40,730
Så la oss tegne bildet fra mandag nå bruker en stabel av rammer,

784
00:49:40,730 --> 00:49:43,130
den nederste av som kommer til å være viktigste,

785
00:49:43,130 --> 00:49:47,600
den øvre av hvilke kommer til å være swap,

786
00:49:47,600 --> 00:49:50,880
slik at vår verden ser ut, akkurat som mandag, som dette.

787
00:49:50,880 --> 00:49:53,620
Her er en del av minnet som viktigste kommer til å bruke.

788
00:49:53,620 --> 00:49:56,520
>> Husker fra mandag at programmet bare hadde 2 variabler,

789
00:49:56,520 --> 00:50:01,930
en som heter X og en som heter y, og jeg hadde satt tallene 1 og 2 der.

790
00:50:01,930 --> 00:50:06,580
Nå når jeg kaller bytte som jeg gjorde på mandag,

791
00:50:06,580 --> 00:50:11,000
tidligere når jeg brukte den røde versjonen av dette programmet, som ser slik ut,

792
00:50:11,000 --> 00:50:17,470
Jeg fikk 2 parametere, a og b, og hva gjorde vi skriver her og her?

793
00:50:17,470 --> 00:50:21,160
Bare 1 og 2, bokstavelig kopier av x og y.

794
00:50:21,160 --> 00:50:23,070
I dag har vi endre på det.

795
00:50:23,070 --> 00:50:28,510
Dag i stedet for å sende i ints a og b vi kommer til å passere i to adresser.

796
00:50:28,510 --> 00:50:34,290
Disse adressene skje til å peke på ints, men disse adressene er ikke Ints seg selv.

797
00:50:34,290 --> 00:50:37,330
De er adresser. Det er som en postadresse i stedet.

798
00:50:37,330 --> 00:50:40,580
Så nå må vi bare gi meg selv litt mer detalj på skjermen.

799
00:50:40,580 --> 00:50:43,250
Dette er min datamaskinens minne som det har vært hele dagen.

800
00:50:43,250 --> 00:50:45,120
Nå trenger vi noen vilkårlig nummerering ordningen.

801
00:50:45,120 --> 00:50:50,580
Så la oss bare si, bare ved en tilfeldighet, at dette er minne adresse 123, 124.

802
00:50:50,580 --> 00:50:55,660
La oss bare si dette er 125, er dette 126, og så videre, men det er helt tilfeldig.

803
00:50:55,660 --> 00:50:58,590
Vi trenger bare litt nummereringen i min hukommelse.

804
00:50:58,590 --> 00:51:04,030
Så nå når jeg faktisk passere i x og y, jeg kommer ikke til å passere i x og y;

805
00:51:04,030 --> 00:51:08,400
Jeg kommer til å passere i postadresse, så å si, av x og y

806
00:51:08,400 --> 00:51:11,870
slik at det som blir lagret her og her er ikke 1 og 2,

807
00:51:11,870 --> 00:51:16,030
men hvis du kan se min lille tekst, blir det vedtatt i her og her?

808
00:51:16,030 --> 00:51:23,340
[Uhørlig student respons] >> Nettopp. 123 blir satt her og 124 blir satt her.

809
00:51:23,340 --> 00:51:28,910
>> Nå, fordi jeg brukte stjernen i denne aller første linjen helt opp her på toppen,

810
00:51:28,910 --> 00:51:34,340
mitt program vet bare at 123 og 124, selv om de er åpenbart heltall

811
00:51:34,340 --> 00:51:40,160
at ethvert menneske kunne merke, bør de tolkes som adresser, numeriske adresser.

812
00:51:40,160 --> 00:51:43,250
De er ikke i og for seg ints, de adresser,

813
00:51:43,250 --> 00:51:46,120
og det er fordi jeg har eksplisitt satt stjernene der.

814
00:51:46,120 --> 00:51:51,360
Så nå i min første, andre og tredje linje av faktiske koden hva som skjer her?

815
00:51:51,360 --> 00:51:53,380
La oss trekke resten av bildet.

816
00:51:53,380 --> 00:51:56,980
Tmp er akkurat som det var på mandag. Ingenting spesielt med tmp.

817
00:51:56,980 --> 00:52:03,060
Det er bare en lokal 32 bits variabel, og innsiden av det jeg tydeligvis lagring verdien av * en.

818
00:52:03,060 --> 00:52:08,580
Nå, hvis jeg bare sa tmp = a, hva ville jeg satt her? >> [Student] 123.

819
00:52:08,580 --> 00:52:10,370
123. Men det er ikke det jeg gjør.

820
00:52:10,370 --> 00:52:13,670
Jeg sier tmp = * en. Stjerners del gå dit.

821
00:52:13,670 --> 00:52:19,370
Så her er en, 123. Hvordan går jeg dit? Late som om det er en pil.

822
00:52:19,370 --> 00:52:24,460
Vel, det er det, en. Så hva blir lagret i tmp, tilsynelatende? Bare 1.

823
00:52:24,460 --> 00:52:29,620
Så med andre ord, er tmp * en, * en del gå til adressen som er i en,

824
00:52:29,620 --> 00:52:31,320
som er tilsynelatende 123.

825
00:52:31,320 --> 00:52:33,910
>> Ok, her er vi på stedet 123, ser jeg nummer 1,

826
00:52:33,910 --> 00:52:35,670
så jeg kommer til å sette nummer 1 der.

827
00:52:35,670 --> 00:52:39,020
Nå hva gjør jeg i linje 2, * a = * b?

828
00:52:39,020 --> 00:52:44,570
Dette er en litt mer involvert fordi nå hva er en? Det er 123.

829
00:52:44,570 --> 00:52:50,220
Så * a er der? Akkurat der jeg var før. Så gå dit. Okay.

830
00:52:50,220 --> 00:52:53,420
Nå til slutt, og så til slutt vil begynne å gi mening, forhåpentligvis,

831
00:52:53,420 --> 00:53:00,280
* B betyr hva som er i b? 124. Så jeg trenger å gå dit, som er 2.

832
00:53:00,280 --> 00:53:03,430
Så hva setter jeg hvor?

833
00:53:03,430 --> 00:53:10,100
2 går inn her fordi * b går inn * en. Så jeg skal gjøre det.

834
00:53:10,100 --> 00:53:13,120
Og du kan allerede se, kanskje, at vi er så mye nærmere

835
00:53:13,120 --> 00:53:17,710
å løse dette dumme, enkle problemet riktig for første gang

836
00:53:17,710 --> 00:53:20,920
fordi nå har vi fortsatt en erindring av hva x var,

837
00:53:20,920 --> 00:53:23,230
vi har 2 eksemplarer, riktignok av y,

838
00:53:23,230 --> 00:53:25,850
men linje 3 sier nå * b.

839
00:53:25,850 --> 00:53:31,080
Så her er b. * B betyr gå dit. Så hvor er plasseringen 124?

840
00:53:31,080 --> 00:53:35,560
Det er tydeligvis her. Så hva setter jeg her? Selvfølgelig, tmp.

841
00:53:35,560 --> 00:53:39,600
Så nå gjør jeg dette. Så jeg har en her og 2 her.

842
00:53:39,600 --> 00:53:43,560
Og nå hva om alt dette, 123, den 124, og 1?

843
00:53:43,560 --> 00:53:47,910
Så snart swap tilbake, er dette minnet så godt som tapt

844
00:53:47,910 --> 00:53:51,070
fordi så snart swap avkastning, operativsystemet

845
00:53:51,070 --> 00:53:54,190
er gratis å bruke dette minnet på nytt i fremtiden.

846
00:53:54,190 --> 00:53:58,870
Bare main minne ved bunnen av denne såkalte stabel stikker rundt.

847
00:53:58,870 --> 00:54:01,470
>> Og så skal vi endelig har nå en fungerende versjon.

848
00:54:01,470 --> 00:54:06,310
La meg gå inn swap.c, og legge merke til følgende.

849
00:54:06,310 --> 00:54:11,280
På toppen av programmet har jeg endret min prototype skal være int * a og int * b.

850
00:54:11,280 --> 00:54:15,000
Så det eneste jeg endret til å gå fra rødt, som var dårlig, til grønn, noe som er bra,

851
00:54:15,000 --> 00:54:17,350
er jeg lagt disse stjernene i dag.

852
00:54:17,350 --> 00:54:21,520
Men så her nede i bytte selv jeg måtte kopiere, lime det var bare på lysbildet.

853
00:54:21,520 --> 00:54:24,140
Jeg har en stjerne her, stjerne her - som samsvarer med prototypen -

854
00:54:24,140 --> 00:54:27,930
og deretter alle disse tingene nå har stjerner bortsett tmp

855
00:54:27,930 --> 00:54:30,680
fordi bruken av en midlertidig variabel, er det ikke noe nytt der.

856
00:54:30,680 --> 00:54:33,040
Jeg trenger bare midlertidig lagringsplass for en int.

857
00:54:33,040 --> 00:54:34,820
Så vi trenger ikke en stjerne der.

858
00:54:34,820 --> 00:54:39,310
Vi trenger bare stjernen, slik at vi kan krysse denne typen vilkårlig grense

859
00:54:39,310 --> 00:54:42,900
mellom disse to rammer i datamaskinens minne.

860
00:54:42,900 --> 00:54:45,630
Men en siste ting må endres, og du kan ha skimtet det allerede.

861
00:54:45,630 --> 00:54:48,810
Hva andre linjen er åpenbart annerledes nå? >> [Student] & x.

862
00:54:48,810 --> 00:54:53,270
>> Ja, så 25 den siste linjen med kode jeg trenger å endre for at dette skal fungere.

863
00:54:53,270 --> 00:54:58,360
For en uke siden, og selv på mandag linje 25 så ut som dette, bytte x og y,

864
00:54:58,360 --> 00:55:02,020
og dette var bare brutt fordi hvis du sier swap (x, y)

865
00:55:02,020 --> 00:55:05,660
du gir kopier av x og y å bytte, så det gjør sin ting,

866
00:55:05,660 --> 00:55:09,080
men du aldri faktisk endrer x og y selv.

867
00:55:09,080 --> 00:55:12,880
Så selv om du aldri har sett dette tegnet før med tegnet i koden,

868
00:55:12,880 --> 00:55:15,860
bare ta en gjetning. Hva gjør tegnet, tilsynelatende?

869
00:55:15,860 --> 00:55:17,890
[Student] Tar adressen. >> Tar adressen.

870
00:55:17,890 --> 00:55:21,160
Så tegnet sier gi meg adressen til x.

871
00:55:21,160 --> 00:55:25,590
Hvem vet hvor det er? Det skjer for å være 123. Jeg bryr meg ikke. Bare gi meg adressen til x.

872
00:55:25,590 --> 00:55:28,340
& Y betyr gi meg adressen til y.

873
00:55:28,340 --> 00:55:34,450
Og på det tidspunktet historien er helt konsistent med bildet trakk vi et øyeblikk siden.

874
00:55:34,450 --> 00:55:38,310
>> Så jeg skal innrømme pekere, sikkert for meg da jeg først begynte å lære dette,

875
00:55:38,310 --> 00:55:40,570
var definitivt en av de vanskeligste tingene å pakke meg rundt.

876
00:55:40,570 --> 00:55:43,760
Men innser, særlig ettersom vi fortsette å spille med slike ting,

877
00:55:43,760 --> 00:55:48,030
Hvis du bryter det ned til disse super enkle slags intellektuelt uinteressant problemer

878
00:55:48,030 --> 00:55:52,270
av bare å flytte tall rundt, svaret på mye forvirring med pekere

879
00:55:52,270 --> 00:55:56,590
virkelig kan utledes fra disse svært grunnleggende mekanikken.

880
00:55:56,590 --> 00:55:59,070
Her er en adresse. Gå dit med stjernen.

881
00:55:59,070 --> 00:56:03,830
Eller omvendt, her er et ampersand. Finne ut hva adressen faktisk er.

882
00:56:03,830 --> 00:56:06,270
OK.

883
00:56:06,270 --> 00:56:09,000
Så hvor er alt dette minnet kommer fra?

884
00:56:09,000 --> 00:56:12,360
Vi har trukket dette bildet et par ganger, og jeg holder lovende vi vil komme tilbake til det,

885
00:56:12,360 --> 00:56:14,920
men her er representasjon av datamaskinens minne

886
00:56:14,920 --> 00:56:17,420
som er litt mer merket enn tavle vår her er.

887
00:56:17,420 --> 00:56:21,590
Teksten segmentet på toppen representerer hva med hensyn til programmet?

888
00:56:21,590 --> 00:56:26,090
[Uhørlig student respons] >> Beklager? Si det igjen.

889
00:56:26,090 --> 00:56:28,660
[Student] Selve programmet. >> Selve programmet.

890
00:56:28,660 --> 00:56:32,430
>> Så 0'er og 1'ere som du har samlet etter å skrive C-kode og deretter kjører Clang

891
00:56:32,430 --> 00:56:35,910
og generere 0'er og 1'ere ender opp med å bli gjemt det i minnet

892
00:56:35,910 --> 00:56:38,570
fordi når du dobbeltklikker på et ikon på Mac eller PC

893
00:56:38,570 --> 00:56:43,010
eller kjøre en kommando som mario på ditt spørsmål, ditt 0'er og 1'ere fra disk

894
00:56:43,010 --> 00:56:45,700
få lastet inn i minnet, slik at datamaskinen kan manipulere dem

895
00:56:45,700 --> 00:56:47,540
og gjennomføre dem raskere.

896
00:56:47,540 --> 00:56:50,880
Så initialisert data og uinitialiserte data, vil vi ikke snakke så mye om dem,

897
00:56:50,880 --> 00:56:52,420
men de er bare globale variabler.

898
00:56:52,420 --> 00:56:54,710
Initialisert betyr globale variabler som du ga verdier til;

899
00:56:54,710 --> 00:56:59,300
uinitialisert betyr globale variabler som du ikke ennå gi verdier til.

900
00:56:59,300 --> 00:57:01,900
Så er det disse miljøvariabler som jeg vil helt bølge min hånd på,

901
00:57:01,900 --> 00:57:04,860
men de er der og som lagrer ting som brukernavn

902
00:57:04,860 --> 00:57:08,090
og annen form for lavere nivå detaljer.

903
00:57:08,090 --> 00:57:12,880
Men de saftigste bitene av minnet oppsett er dette som kalles stabelen og haugen.

904
00:57:12,880 --> 00:57:17,470
Stabelen igjen, for å være klar, er minnet som brukes når funksjoner kalles,

905
00:57:17,470 --> 00:57:19,710
når det er lokale variabler

906
00:57:19,710 --> 00:57:22,120
og når det er parametere som er gått rundt.

907
00:57:22,120 --> 00:57:24,490
Alle som skjer i bunken.

908
00:57:24,490 --> 00:57:29,570
Haugen vi ikke har snakket om, men ta en gjetning som bruker haugen.

909
00:57:31,120 --> 00:57:32,690
Bare en annen del av minnet.

910
00:57:32,690 --> 00:57:36,620
Det skjer for å bli trukket her på toppen, men det er en vilkårlig pictorial konvensjonen.

911
00:57:36,620 --> 00:57:41,670
Hvem tilsynelatende brukt minne fra haugen uker?

912
00:57:41,670 --> 00:57:44,830
Det er teknisk deg, men indirekte. >> [Student] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString og malloc. Så her er fundamental forskjell.

914
00:57:47,950 --> 00:57:51,300
>> Du vet for de siste ukene at hvis du trenger minne, bare erklære en variabel.

915
00:57:51,300 --> 00:57:54,560
Hvis du trenger mye minne, erklærer en rekke rett på innsiden av funksjon din.

916
00:57:54,560 --> 00:57:59,620
Men problemet vi har holdt overfor er hvis du deklarerer variabler lokalt innsiden av funksjoner,

917
00:57:59,620 --> 00:58:05,340
så snart funksjonen returnerer, hva skjer med minnet og disse variablene?

918
00:58:05,340 --> 00:58:09,620
Bare slags det er ikke lenger din, ikke sant? Det forsvinner bare slags konseptuelt.

919
00:58:09,620 --> 00:58:13,950
Det er fortsatt fysisk der, selvsagt, men det er ikke lenger din rett til å bruke.

920
00:58:13,950 --> 00:58:17,160
Dette er åpenbart problematisk hvis du ønsker å skrive funksjoner i livet

921
00:58:17,160 --> 00:58:20,440
som faktisk allokere minne og ikke gi den tilbake umiddelbart.

922
00:58:20,440 --> 00:58:24,180
Case in point: GetString hensikt i livet er å ha ingen anelse på forhånd

923
00:58:24,180 --> 00:58:26,390
hvor stor av en streng jeg kommer til å skrive på tastaturet,

924
00:58:26,390 --> 00:58:30,390
men det må være i stand til å allokere minne til å holde David eller Hallo

925
00:58:30,390 --> 00:58:32,860
eller en hel essay som brukeren kan ha skrevet inn

926
00:58:32,860 --> 00:58:35,280
Så GetString har brukt malloc.

927
00:58:35,280 --> 00:58:38,910
Malloc derfor må bruke ikke stabelen;

928
00:58:38,910 --> 00:58:40,770
i stedet den bruker dette som kalles haugen.

929
00:58:40,770 --> 00:58:44,430
Det er ikke noe annerledes om minnet. Det er ikke raskere eller langsommere eller noe sånt.

930
00:58:44,430 --> 00:58:46,570
Det er bare fysisk på et annet sted.

931
00:58:46,570 --> 00:58:50,120
>> Men regelen er at minnet som er tildelt på haugen

932
00:58:50,120 --> 00:58:56,180
vil aldri bli tatt bort fra deg før du ringer - ta en gjetning - gratis.

933
00:58:56,180 --> 00:59:00,510
Derimot, noe minne du be om på bunken med bare erklære en matrise

934
00:59:00,510 --> 00:59:03,320
eller erklære en variabel som vi har gjort i flere uker,

935
00:59:03,320 --> 00:59:05,640
at som standard ender opp på stakken.

936
00:59:05,640 --> 00:59:09,550
Og som fungerer bra 90% av tiden, men på disse sjeldnere anledninger

937
00:59:09,550 --> 00:59:12,470
der du ønsker å allokere minne og holde den rundt,

938
00:59:12,470 --> 00:59:14,730
så må du bruke en funksjon som malloc.

939
00:59:14,730 --> 00:59:19,370
Eller vi har brukt en funksjon som GetString, som igjen bruker malloc.

940
00:59:19,370 --> 00:59:23,300
La oss se hvor dette kan bryte ned og deretter ta en titt på Binky.

941
00:59:23,300 --> 00:59:25,820
Vi vil komme tilbake til det i fremtiden.

942
00:59:25,820 --> 00:59:29,270
Her er en super enkelt program som i de første to linjene gjør hva?

943
00:59:29,270 --> 00:59:33,460
På engelsk, hva disse første to linjer med kode gjør inne i main?

944
00:59:33,460 --> 00:59:35,600
[Uhørlig student respons]

945
00:59:35,600 --> 00:59:37,880
Forsiktig. Det gir ikke meg adressen til x eller y.

946
00:59:37,880 --> 00:59:41,840
[Student] Gir pekere til ints. >> Bra. Gi meg 2 pekere til heltall.

947
00:59:41,840 --> 00:59:45,130
Med andre ord, gi meg 2 biter av minnet som jeg holder tegning i dag,

948
00:59:45,130 --> 00:59:46,950
selv om jeg slettet det nå, som firkanter.

949
00:59:46,950 --> 00:59:50,000
Gi meg 2 biter av minne, ett kalt x, kalt en y -

950
00:59:50,000 --> 00:59:54,320
tidligere jeg ringte dem s og t - og hva er den type som del av minnet?

951
00:59:54,320 --> 00:59:57,160
Det kommer til å lagre en adresse.

952
00:59:57,160 --> 00:59:59,110
Det er av type int *.

953
00:59:59,110 --> 01:00:01,630
>> Så adressen til en int vil til slutt leve i x,

954
01:00:01,630 --> 01:00:03,860
adressen til en int vil etterhvert leve i y,

955
01:00:03,860 --> 01:00:08,460
men i utgangspunktet, hva som er inni av x og y? Hvem vet? Garbage verdier.

956
01:00:08,460 --> 01:00:10,180
Det har ingenting å gjøre med pekere.

957
01:00:10,180 --> 01:00:12,720
Hvis vi ikke har satt noe der, hvem vet hva som er faktisk det?

958
01:00:12,720 --> 01:00:18,950
Nå, x. Hva skjer her? Dette er legit nå fordi x er en peker. Det er en int *.

959
01:00:18,950 --> 01:00:21,870
Så det betyr at jeg kan sette i x adressen til noen del av minnet.

960
01:00:21,870 --> 01:00:25,120
Hva kommer ikke tilbake malloc? Perfekt, returnerer den adresser,

961
01:00:25,120 --> 01:00:28,510
adressen til den første byte i en hel del av minnet.

962
01:00:28,510 --> 01:00:31,140
Hvor mange byte er dette tilsynelatende tildeling, for eksempel i enheten?

963
01:00:31,140 --> 01:00:33,510
Hva er størrelsen på en int? 4.

964
01:00:33,510 --> 01:00:36,600
Hvis du tenker tilbake til uke 1, er det ikke super viktig å alltid huske det,

965
01:00:36,600 --> 01:00:38,870
men i dette tilfellet er det nyttig å vite, 4 bytes.

966
01:00:38,870 --> 01:00:41,770
Så dette er tildeling på haugen 4 byte

967
01:00:41,770 --> 01:00:46,110
og den returnerer adressen til den første for meg vilkårlig.

968
01:00:46,110 --> 01:00:47,700
Nå er det x gjør?

969
01:00:47,700 --> 01:00:52,200
A * x = 42 er gjør hva?

970
01:00:52,200 --> 01:00:57,150
Dersom du på dette punktet i historien vi har x, som ser ut som dette med noen søppel verdi,

971
01:00:57,150 --> 01:01:04,120
dette er nå y med noen søppel verdi, nå på linje 3 har jeg tildelt fire byte.

972
01:01:04,120 --> 01:01:06,950
Dette bildet ser egentlig ut som dette.

973
01:01:06,950 --> 01:01:12,010
Eller mer spesifikt, hvis dette er vilkårlig adresse 123, dette er hva vår historie nå ser ut.

974
01:01:12,010 --> 01:01:23,940
* X = 42 nå betyr det? Det betyr gå til adressen 123 og sette nummer 42 der.

975
01:01:23,940 --> 01:01:26,220
Jeg trenger ikke å trekke disse linjene fordi vi ikke gjør strenger.

976
01:01:26,220 --> 01:01:29,480
>> Jeg skal bare skrevet det slik, og bare for demonstrasjon skyld,

977
01:01:29,480 --> 01:01:33,240
42 som en int slags tar opp mye plass, 4 byte.

978
01:01:33,240 --> 01:01:35,960
Så det er hva som har skjedd der, men det er et problem nå.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. Hva kommer til å skje her?

980
01:01:40,580 --> 01:01:46,470
Problemet er * y i vår forenklede verden betyr bare gå til adressen i y.

981
01:01:46,470 --> 01:01:48,590
Hva er i y? Det er noen søppel verdi.

982
01:01:48,590 --> 01:01:53,150
Så la oss anta at det søppel verdien er 5551212, noe sprøtt som det.

983
01:01:53,150 --> 01:01:56,750
* Y del gå for å løse 5551212.

984
01:01:56,750 --> 01:02:00,450
Det er som over her. Det finnes ikke, for eksempel.

985
01:02:00,450 --> 01:02:05,310
Så * y får 13 betyr jeg prøver å trekke 13 her. Det eksisterer ikke.

986
01:02:05,310 --> 01:02:08,790
Jeg har overskredet den delen av tavlen. Hva får jeg?

987
01:02:08,790 --> 01:02:14,930
Det kryptiske meldingen segmentering feil fordi jeg prøver å sette i minnet

988
01:02:14,930 --> 01:02:19,470
en verdi som 13 på et sted som ikke eksisterer.

989
01:02:19,470 --> 01:02:23,900
Resten av programmet kan fungere greit, men frem til det punktet det ikke.

990
01:02:23,900 --> 01:02:25,350
Så la oss prøve å fortelle denne historien.

991
01:02:25,350 --> 01:02:27,830
Vi vil komme tilbake til det når vi har snakket om hex.

992
01:02:27,830 --> 01:02:30,290
La oss gå tilbake til dette og konkluderer med dette som kalles Binky,

993
01:02:30,290 --> 01:02:33,710
som tilbakekallingen er en Stanford professor sitte hjemme å spille med claymation,

994
01:02:33,710 --> 01:02:36,380
å fortelle historien om akkurat det samme programmet.

995
01:02:36,380 --> 01:02:40,580
Det er bare ca 3 minutter lang. Her har vi Binky.

996
01:02:40,580 --> 01:02:45,030
[Mannlige høyttaler på video] Hei Binky, våkne opp. Det er tid for pekeren moro.

997
01:02:45,030 --> 01:02:50,080
[Binky] Hva er det? Lær om pekere? Oh, goody!

998
01:02:50,080 --> 01:02:53,700
[Mannlige høyttaler] Vel, for å komme i gang, antar jeg vi kommer til å trenge et par pekere.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] Okay. Denne koden tildeler to tips som kan peke til heltall.

1000
01:02:57,890 --> 01:03:02,220
[Mannlige høyttaler] Okay. Vel, jeg ser de to pekere, men de synes ikke å peke mot noe.

1001
01:03:02,220 --> 01:03:05,550
[Binky] Det er riktig. Begynnelsen, vil pekere ikke peke på noe.

1002
01:03:05,550 --> 01:03:09,270
De tingene de peker til kalles pointees, og sette dem opp er et separat trinn.

1003
01:03:09,270 --> 01:03:12,330
[Mannlige høyttaler] Oh, høyre, høyre. Jeg visste det. De pointees er atskilt.

1004
01:03:12,330 --> 01:03:15,630
Eh, så hvordan fordele du en pointee?

1005
01:03:15,630 --> 01:03:21,510
[Binky] Okay. Denne koden tildeler en ny heltall pointee, og denne delen setter x for å peke på det.

1006
01:03:21,510 --> 01:03:23,500
[Mannlige høyttaler] Hei, det ser bedre ut.

1007
01:03:23,500 --> 01:03:26,030
Så gjør det gjør noe. >> [Binky] Okay.

1008
01:03:26,030 --> 01:03:30,300
Jeg skal dereferanse pekeren x for å lagre nummeret 42 i pointee sin.

1009
01:03:30,300 --> 01:03:34,410
For dette trikset jeg trenger min tryllestav av dereferencing.

1010
01:03:34,410 --> 01:03:38,610
[Mannlige høyttaler] Din tryllestav av dereferencing? Det er flott.

1011
01:03:38,610 --> 01:03:44,230
[Binky] Dette er hva koden ser ut. Jeg vil bare sette opp nummeret og ... [Hvesing]

1012
01:03:44,230 --> 01:03:46,100
[Mannlige høyttaler] Hei ser, det det går.

1013
01:03:46,100 --> 01:03:50,990
Så gjør en dereferanse på x følger pilen for å få tilgang til pointee,

1014
01:03:50,990 --> 01:03:53,230
i dette tilfellet å lagre 42 i det.

1015
01:03:53,230 --> 01:03:57,630
Hei, prøv å bruke den til å lagre nummer 13 gjennom den andre pekeren, y.

1016
01:03:57,630 --> 01:04:03,250
[Binky] Okay. Jeg vil bare gå over her til y og få nummer 13 satt opp

1017
01:04:03,250 --> 01:04:08,360
og deretter ta staven av dereferencing og bare ... [Summende lyd] Whoa!

1018
01:04:08,360 --> 01:04:10,980
[Mannlige høyttaler] Oh hei, det gikk ikke.

1019
01:04:10,980 --> 01:04:14,870
>> Si, Binky, tror jeg ikke dereferencing y er en god idé

1020
01:04:14,870 --> 01:04:17,880
fordi sette opp pointee er et separat trinn

1021
01:04:17,880 --> 01:04:19,850
og jeg tror ikke vi noen gang gjorde det.

1022
01:04:19,850 --> 01:04:21,770
[Binky] Hmm, godt poeng.

1023
01:04:21,770 --> 01:04:26,640
[Mannlige høyttaler] Yeah. Vi tildelt pekeren y, men vi har aldri sett det til å peke på en pointee.

1024
01:04:26,640 --> 01:04:28,780
[Binky] Hmm, veldig observant.

1025
01:04:28,780 --> 01:04:30,690
[Mannlige høyttaler] Hei, du ser bra der, Binky.

1026
01:04:30,690 --> 01:04:34,160
Kan du fikse det slik at y peker til samme pointee som x? >> [Binky] Sure.

1027
01:04:34,160 --> 01:04:37,100
Jeg skal bruke min tryllestav av pekeren oppdrag.

1028
01:04:37,100 --> 01:04:39,070
[Mannlige høyttaler] Er det kommer til å bli et problem som før?

1029
01:04:39,070 --> 01:04:40,840
[Binky] Nei, dette ikke berører pointees.

1030
01:04:40,840 --> 01:04:44,780
Det endrer bare ett pekeren å peke på det samme som en annen. [Hvesing]

1031
01:04:44,780 --> 01:04:48,570
[Mannlige høyttaler] Oh, ser jeg. Nå y peker til samme sted som x.

1032
01:04:48,570 --> 01:04:51,140
Så vent. Nå y er løst. Den har en pointee.

1033
01:04:51,140 --> 01:04:54,520
Så du kan prøve staven av dereferencing igjen for å sende 13 over.

1034
01:04:54,520 --> 01:04:58,130
[Binky] Uh, okay. Her går. [Hvesing]

1035
01:04:58,130 --> 01:05:01,250
[Mannlige høyttaler] Hei, se på det. Nå dereferencing fungerer på y.

1036
01:05:01,250 --> 01:05:05,200
Og fordi pekere deler at en pointee, de begge se 13.

1037
01:05:05,200 --> 01:05:06,910
[Binky] Yeah, deling. Uansett.

1038
01:05:06,910 --> 01:05:08,880
>> Så skal vi bytte plass nå?

1039
01:05:08,880 --> 01:05:11,420
[Mannlige høyttaler] Oh look, vi er ute av tiden. >> [Binky] Men -

1040
01:05:11,420 --> 01:05:13,880
[Mannlige høyttaler] Bare husk de 3 pekeren regler.

1041
01:05:13,880 --> 01:05:18,630
Nummer 1, er den grunnleggende struktur som du har en peker og den peker over til en pointee.

1042
01:05:18,630 --> 01:05:23,120
Men pekeren og pointee er separate, og vanlig feil er å sette opp en peker

1043
01:05:23,120 --> 01:05:25,680
men å glemme å gi den en pointee.

1044
01:05:25,680 --> 01:05:29,580
Nummer 2, starter pekeren dereferencing på pekeren og følger sin pilen over

1045
01:05:29,580 --> 01:05:31,060
å få tilgang til pointee.

1046
01:05:31,060 --> 01:05:34,340
Som vi alle vet, fungerer dette bare hvis det er en pointee,

1047
01:05:34,340 --> 01:05:36,460
hva slags kommer tilbake til regel nummer 1.

1048
01:05:36,460 --> 01:05:39,870
Nummer 3, tar pekeren oppdrag en peker og endrer det

1049
01:05:39,870 --> 01:05:42,390
å peke på den samme pointee som en annen pekeren.

1050
01:05:42,390 --> 01:05:45,890
Så etter oppdraget, vil de to pekere peker til samme pointee.

1051
01:05:45,890 --> 01:05:47,800
Noen ganger som kalles deling.

1052
01:05:47,800 --> 01:05:50,910
>> Og det er alt som skal til egentlig. Bye-bye nå.

1053
01:05:50,910 --> 01:05:55,840
Dette er Binky. Dette er CS50. Vi får se deg neste uke. [Applaus]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]