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

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
>> Det er CS50, og det er i slutningen af ​​uge 4.

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

6
00:00:14,030 --> 00:00:26,240
Ingen foredrag på mandag, ikke noget problem der i næste uge. [Studerende hepper]

7
00:00:26,240 --> 00:00:28,680
Du kommer ikke til at lide, hvor dette foregår.

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

9
00:00:31,590 --> 00:00:37,740
og der er også pr pensum 1 Fredag ​​forelæsning næste fredag, så vi kan blive på sporet.

10
00:00:37,740 --> 00:00:40,580
Men alt bliver filmet som sædvanlig, så ikke at bekymre dig.

11
00:00:40,580 --> 00:00:44,100
>> Og med hensyn til quiz 0 hvad vi vil gøre mod ugens udgang

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

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

14
00:00:50,160 --> 00:00:55,100
I almindelighed vil det være multiple choice, sand-falsk, korte svar, korte koder problemer.

15
00:00:55,100 --> 00:00:57,360
Du kommer ikke til at kunne forventes at gennemføre tilsvarende

16
00:00:57,360 --> 00:01:00,030
af et problem, som du ville se på en Pset, du som har en computer

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

18
00:01:03,240 --> 00:01:06,900
>> Og ja, den bedste guide til at få en fornemmelse af, hvad CS50 quizzer er ligesom

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

20
00:01:09,180 --> 00:01:11,920
og du kan se de sidste mange år værd af quizzer.

21
00:01:11,920 --> 00:01:16,600
Bare indse, at læseplanen ikke altid har været den samme gennem årene.

22
00:01:16,600 --> 00:01:18,510
Nogle gange kan vi tilføje, undertiden trække fra,

23
00:01:18,510 --> 00:01:20,670
så hvis du ser nogle emne på en af ​​de gamle quizzer

24
00:01:20,670 --> 00:01:25,380
at du ikke har nogen idé om, hvad det er vi taler om, så er det enten, at vi dækkede det

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

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

27
00:01:31,110 --> 00:01:34,770
samt et kursus-dækkende gennemgang session søndag aften -

28
00:01:34,770 --> 00:01:37,500
tid og sted vil blive meddelt på kursets hjemmeside -

29
00:01:37,500 --> 00:01:40,120
du har alle en mulighed for at gennemgå med kursets pædagogiske stipendiater

30
00:01:40,120 --> 00:01:44,830
materialet til i år, både i snit og som en fuld klasse,

31
00:01:44,830 --> 00:01:48,400
og dem vil blive filmet som sædvanlig så godt.

32
00:01:48,400 --> 00:01:53,380
>> Ok. Så uden videre, en kommentar til bestået / ikke bestået og tilføje / slip.

33
00:01:53,380 --> 00:01:57,980
Du har måske set mine noter i aftes, og det er virkelig bare nogle ekstra forsikring

34
00:01:57,980 --> 00:02:01,250
at hvis du er blandt dem, især mindre komfortabel eller et sted midt imellem

35
00:02:01,250 --> 00:02:04,870
og du føler dig bare en lille smule i over dit hoved,

36
00:02:04,870 --> 00:02:08,430
indse, at er faktisk helt normal, og der er en rigelig støtte struktur på plads,

37
00:02:08,430 --> 00:02:13,530
hvoraf den ene kontortid var opsat på at forbedre desto mere pr min e-mail i går aftes,

38
00:02:13,530 --> 00:02:16,520
og indse også, at en mulighed som bestået / ikke bestået for en klasse som denne

39
00:02:16,520 --> 00:02:21,540
virkelig er ment som en mekanisme til at tage brodden af ​​et kursus som dette,

40
00:02:21,540 --> 00:02:24,200
så igen, hvis du bruger disse 10, 15, 20 timer

41
00:02:24,200 --> 00:02:28,160
prøver bare at få nogle Pset til at arbejde, og du ved, du er 90-95% af vejen

42
00:02:28,160 --> 00:02:32,100
men du kan ikke finde nogle skide bug, i bestået / ikke bestået model, der er slags okay.

43
00:02:32,100 --> 00:02:36,230
>> Ideen er, at med denne mekanisme, kan du derefter gå fokus på dine andre psets

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

45
00:02:39,530 --> 00:02:43,390
Så indser, at du har indtil den kommende tirsdag - teknisk set den 5. mandag,

46
00:02:43,390 --> 00:02:50,840
men det er en ferie, så dette kommer tirsdag - at skifte fra bestået / ikke bestået til graduerede eller vice versa.

47
00:02:50,840 --> 00:02:54,450
Og hvis du virkelig på afgrunden og tænker på at droppe helt,

48
00:02:54,450 --> 00:02:56,440
behage fange mig efter foredrag eller drop mig en note.

49
00:02:56,440 --> 00:02:59,990
Vi ville elske at mindst chat, før du byde farvel.

50
00:02:59,990 --> 00:03:03,470
Ok. Så vi begyndte at tage støttehjulene off sidste gang.

51
00:03:03,470 --> 00:03:06,030
I særdeleshed har vi fokuseret på snor.

52
00:03:06,030 --> 00:03:09,740
String er noget, der er erklæret i CS50 biblioteket,

53
00:03:09,740 --> 00:03:14,340
specifikt i denne fil kaldet cs50.h, som vi vil begynde at se på denne og næste uge.

54
00:03:14,340 --> 00:03:17,250
Men snor er egentlig bare en forenkling af noget

55
00:03:17,250 --> 00:03:20,980
det er en lidt mere arcanely beskrevet som char *.

56
00:03:20,980 --> 00:03:24,090
Char vi er fortrolige med. Det er bare et enkelt tegn.

57
00:03:24,090 --> 00:03:28,010
Men * som mandag betegnede hvad? >> [Studerende] En pegepind.

58
00:03:28,010 --> 00:03:31,290
En markør. Og hvad er en pointer? >> [Studerende] En adresse.

59
00:03:31,290 --> 00:03:33,420
>> Det er ligesom en adresse, en placering i hukommelsen.

60
00:03:33,420 --> 00:03:35,910
Hvad er en adresse eller beliggenhed eller hukommelse?

61
00:03:35,910 --> 00:03:40,290
Igen, alle af os har bærbare computere med en koncert eller 2 GB RAM mest sandsynligt i disse dage,

62
00:03:40,290 --> 00:03:44,160
og det betyder, at du har en milliard eller 2 milliarder byte værd af hukommelsen.

63
00:03:44,160 --> 00:03:46,240
Og det er faktisk ligegyldigt, hvad det fysisk ser ud,

64
00:03:46,240 --> 00:03:51,220
men tage på tro, at du kan nummerere alle de individuelle bytes, at din egen bærbare computer har -

65
00:03:51,220 --> 00:03:54,580
dette er byte 0, dette er byte 1, dette er byte 2000000000 -

66
00:03:54,580 --> 00:03:56,100
og det er præcis, hvad en computer gør.

67
00:03:56,100 --> 00:04:00,030
Når du allokerer plads til et enkelt tegn, for eksempel,

68
00:04:00,030 --> 00:04:02,480
har det naturligvis til at leve et sted i computerens hukommelse,

69
00:04:02,480 --> 00:04:05,860
og måske er det ved byte nummer 12345,

70
00:04:05,860 --> 00:04:08,470
og det er et eller andet sted op her i computerens hukommelse.

71
00:04:08,470 --> 00:04:12,630
Og den adresse så af denne karakter er 12345.

72
00:04:12,630 --> 00:04:16,140
>> Nu, i uge 0 og nu hidtil har vi ikke virkelig plejet

73
00:04:16,140 --> 00:04:19,170
hvor i hukommelsen tingene gemmes, fordi vi normalt bruger symboler,

74
00:04:19,170 --> 00:04:22,540
variabler, og arrays til rent faktisk at få på vores data.

75
00:04:22,540 --> 00:04:24,950
Men som i mandags, og så meget desto mere i dag, er du nu vil have

76
00:04:24,950 --> 00:04:27,710
alle de mere ekspressive kapaciteter med at skrive programmer

77
00:04:27,710 --> 00:04:31,330
til virkelig at manipulere en computers hukommelse som du har lyst,

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 meget almindelig resultat på dette punkt i at lære det her.

80
00:04:39,620 --> 00:04:42,460
Men hvad betyder det egentlig at være en char *?

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

82
00:04:46,140 --> 00:04:48,670
Lad os tage til et simpelt eksempel her.

83
00:04:48,670 --> 00:04:53,060
Lad mig gemme denne fil som compare.c, og lad mig bare få nogle skabelon kode her

84
00:04:53,060 --> 00:05:00,490
så omfatter stdio.h, lad mig også give mig selv omfatter cs50.h. Jeg zoome ind deroppe.

85
00:05:00,490 --> 00:05:05,850
Lad mig begynde at skrive main int, main (void), og nu vil jeg gøre noget som dette:

86
00:05:05,850 --> 00:05:13,520
printf ("Giv mig en streng:") og så vil jeg bruge string s bliver GetString

87
00:05:13,520 --> 00:05:16,750
at få en snor fra brugeren, så jeg har tænkt mig at bede brugeren om en anden.

88
00:05:16,750 --> 00:05:21,870
("Giv mig en anden streng:") og jeg har tænkt mig at spørge dem via GetString at få det.

89
00:05:21,870 --> 00:05:27,020
Jeg vil kalde det t fordi t kommer efter s og s er en nice navn for en streng, hvis det er temmelig generisk.

90
00:05:27,020 --> 00:05:30,030
Så GetString, og nu vil jeg bare gøre en sanity check og jeg har tænkt mig at sige

91
00:05:30,030 --> 00:05:39,770
if (s == t) så jeg bare at fortælle brugeren printf ("Du har indtastet det samme \ n");

92
00:05:39,770 --> 00:05:45,520
jeg ellers har tænkt mig at udskrive noget lignende ("Du har skrevet noget andet! \ n")

93
00:05:45,520 --> 00:05:48,460
eller hvad straffen vil være. Så sådan noget.

94
00:05:48,460 --> 00:05:52,200
Så som sædvanlig, vil jeg vende tilbage 0, som netop betød, at intet ondt er sket,

95
00:05:52,200 --> 00:05:54,400
og jeg har tænkt mig at gå videre og kompilere og køre dette program.

96
00:05:54,400 --> 00:05:56,540
>> Men mandag kørte vi dette program,

97
00:05:56,540 --> 00:06:00,420
og faktisk fik at vide, at HELLO ikke er goddag og farvel er ikke farvel.

98
00:06:00,420 --> 00:06:03,140
Den adfærd, vi så, var lidt mere som denne.

99
00:06:03,140 --> 00:06:11,450
Lad mig gå ind i min kilde bibliotek, zoome ind her, og lad os gør sammenligne.

100
00:06:11,450 --> 00:06:14,570
Compiled okay. Lad mig løbe sammenligne. Giv mig en streng: HELLO.

101
00:06:14,570 --> 00:06:16,300
Giv mig en anden streng: HELLO.

102
00:06:16,300 --> 00:06:18,000
Du skrev noget andet!

103
00:06:18,000 --> 00:06:22,650
Nå, lad mig prøve noget enklere ligesom 50, 50. Du skrev noget andet!

104
00:06:22,650 --> 00:06:25,740
hi, hi. Så klart er noget der foregår her.

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

106
00:06:28,440 --> 00:06:33,850
Tilsyneladende, linie 12 er helt dysfunktionel.

107
00:06:34,300 --> 00:06:39,430
Hvad er det grundlæggende problem her? Yeah. >> [Studerende] Det er at sammenligne adresser.

108
00:06:39,430 --> 00:06:41,850
Ja, præcis. Det er faktisk sammenligne adresser

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

110
00:06:44,580 --> 00:06:48,290
Det er ikke at sammenligne de breve HELLO igen og igen,

111
00:06:48,290 --> 00:06:52,370
fordi hvad der virkelig er sket, al den tid vi har brugt GetString -

112
00:06:52,370 --> 00:06:56,130
Denne tavle er igen vores computers hukommelse,

113
00:06:56,130 --> 00:07:00,100
og lad os sige, jeg kalder GetString efter at erklære en variabel s.

114
00:07:00,100 --> 00:07:01,930
Hvad betyder min hukommelse ud?

115
00:07:01,930 --> 00:07:07,070
Lad os vilkårligt sige, at s ser sådan ud. Det er et kvadrat.

116
00:07:07,070 --> 00:07:09,040
Og stort set enhver tid jeg har tegnet et stykke hukommelse på skærmen

117
00:07:09,040 --> 00:07:12,860
hvis det er 32 bit, jeg har tegnet kvadrater som dette, fordi faktisk i apparatet,

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

119
00:07:17,380 --> 00:07:19,420
Det kan variere baseret på edb-system.

120
00:07:19,420 --> 00:07:24,630
De af jer, der er vagt bekendt med det faktum, at din Mac eller pc er 64 bit,

121
00:07:24,630 --> 00:07:28,120
der rent faktisk angiver, at computeren bruger 64-bit pointers,

122
00:07:28,120 --> 00:07:33,730
64-bit adresser, og blandt de upsides af det er dine computere

123
00:07:33,730 --> 00:07:35,560
kan have meget mere RAM end gårsdagens.

124
00:07:35,560 --> 00:07:39,240
Lang historie kort, tilbage i dag, hvor computerne kun brugt 32 bit

125
00:07:39,240 --> 00:07:42,740
at repræsentere adresser, det største antal bytes du kunne repræsentere

126
00:07:42,740 --> 00:07:46,280
i dette tilfælde var, hvad hvis du har 32 bit?

127
00:07:46,280 --> 00:07:49,590
Så 4 mia ret, fordi 2 til 32 er 4 mia.

128
00:07:49,590 --> 00:07:51,370
Dette nummer er blevet tilbagevendende i kurset.

129
00:07:51,370 --> 00:07:55,240
>> Så hvis du kun har 32 bits, det højeste antal, du kan tælle til er omkring 4 mia.

130
00:07:55,240 --> 00:07:58,750
Men det var en fundamental begrænsning af computere indtil for et par år siden

131
00:07:58,750 --> 00:08:01,180
fordi hvis du kun kan tælle så højt som 4 milliarder,

132
00:08:01,180 --> 00:08:05,270
det gør ikke noget, hvis du køber 8 GB RAM eller endda 5 gigabyte RAM;

133
00:08:05,270 --> 00:08:07,780
du kan ikke tælle, at høje, så det var nytteløst.

134
00:08:07,780 --> 00:08:11,430
Du kan kun få adgang de første 3 eller 4 gigabyte din computers hukommelse.

135
00:08:11,430 --> 00:08:14,410
Det er mindre af et problem nu, og du kan købe MacBook Pros og Dells

136
00:08:14,410 --> 00:08:17,680
med 8 GB RAM eller endnu mere i disse dage.

137
00:08:17,680 --> 00:08:24,100
Men hvis jeg afsætter ganske enkelt i dette program en pegepind, en pointer kaldet s,

138
00:08:24,100 --> 00:08:28,370
det kunne se sådan ud på skærmen, da vi faktisk er nødt til at skrælle tilbage dette lag.

139
00:08:28,370 --> 00:08:33,520
Jeg holde siger streng, men som mandag den streng er virkelig char *,

140
00:08:33,520 --> 00:08:35,590
adressen på nogle tegn.

141
00:08:35,590 --> 00:08:39,280
Så lad os tage denne uddannelse hjul fra, selv om vi vil fortsætte med at bruge GetString for nu.

142
00:08:39,280 --> 00:08:42,600
Så jeg har erklæret s, og det er en luns af hukommelse, 32 bit.

143
00:08:42,600 --> 00:08:47,370
Hvad er herinde i hukommelsen som standard? >> [Uhørlig student svar]

144
00:08:47,370 --> 00:08:50,040
Hvad er det? >> [Studerende] Garbage. >> Garbage. Præcis.

145
00:08:50,040 --> 00:08:54,610
Hvis du programmøren ikke sætte en værdi i en variabel, der ved, hvad det er?

146
00:08:54,610 --> 00:08:57,990
Nogle gange får du heldig, og det er 0, hvilket er lidt af en pæn, ren standardværdi,

147
00:08:57,990 --> 00:09:00,310
men som vi så mandag, nogle gange er det komplet nonsens,

148
00:09:00,310 --> 00:09:04,130
nogle virkelig store positive eller negative tal, der kom fra hvor?

149
00:09:05,350 --> 00:09:07,010
Yeah. >> [Studerende] Funktionen før. >> Yeah.

150
00:09:07,010 --> 00:09:10,170
>> Ofte den funktion, der blev kaldt før, fordi huske,

151
00:09:10,170 --> 00:09:13,920
som du kalder funktioner i hukommelsen, de fylder mere og mere plads nedefra,

152
00:09:13,920 --> 00:09:17,040
og så snart funktionen returnerer, bliver den pågældende hukommelse genbruges

153
00:09:17,040 --> 00:09:20,890
af den næste fyr, der bliver kaldt, er, hvem der bruger din samme skive af hukommelsen.

154
00:09:20,890 --> 00:09:23,450
Og hvis du har forladt skrald der, tidligere værdier,

155
00:09:23,450 --> 00:09:28,190
vi kan forveksles s som havende en vis værdi, når vi virkelig har ikke lagt noget der.

156
00:09:28,190 --> 00:09:30,960
Så vores RAM på dette punkt ser sådan ud.

157
00:09:30,960 --> 00:09:36,030
Nu på den højre side af linien 7 vi kalder GetString,

158
00:09:36,030 --> 00:09:40,150
som vi har gjort nu i flere uger, men hvad GetString virkelig gør?

159
00:09:40,150 --> 00:09:43,350
GetString skrevet af den CS50 personale er lidt intelligent

160
00:09:43,350 --> 00:09:46,500
i, at så snart brugeren begynder at skrive nøgler og hits Enter,

161
00:09:46,500 --> 00:09:50,010
GetString tal på, hvor mange tastetryk gjorde brugeren hit,

162
00:09:50,010 --> 00:09:53,360
hvor mange tegn skal jeg tildele RAM til.

163
00:09:53,360 --> 00:09:55,660
Og når denne RAM kommer fra, hvem ved?

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

165
00:09:58,930 --> 00:10:05,200
Men lad os antage, at computeren fandt plads til ordet HELLO lige 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 trækker dette som en sekvens af tegn, kan vi trække det sådan her.

168
00:10:13,510 --> 00:10:17,860
Men jeg er nødt til at gøre 1 ekstra ting. Hvad hører i slutningen af ​​enhver streng i C?

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

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

171
00:10:23,980 --> 00:10:28,150
at dette er bogstaveligt talt tallet 0, det hele tal 0;

172
00:10:28,150 --> 00:10:32,440
det er ikke for eksempel quote-citat slut 0, som du måske 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 hvad sagde vi siger mandag, at en funktion som GetString

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

176
00:10:39,580 --> 00:10:43,960
Det er ikke returnere en streng i sig selv, fordi der ikke rigtig har betydning

177
00:10:43,960 --> 00:10:47,710
fordi strenge ikke findes. De er en slags fabrikation i CS50 biblioteket.

178
00:10:47,710 --> 00:10:51,300
Hvad er virkelig en streng, mere teknisk? >> [Studerende] Det er det første tegn.

179
00:10:51,300 --> 00:10:55,950
Præcis. Det er ganske enkelt adressen på det første tegn, som brugeren skrevet i.

180
00:10:55,950 --> 00:11:02,810
Så hvis mit ord HELLO ender det op ved byte nummer 123 og derefter ved byte nummer 124,

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

182
00:11:08,320 --> 00:11:12,650
hvad der virkelig GetString er på vej tilbage, er bogstaveligt talt antallet 123.

183
00:11:12,650 --> 00:11:19,270
Så hvad bliver sat i s er antallet 123, ikke bogstavet H, ikke ordet HELLO,

184
00:11:19,270 --> 00:11:23,130
ganske enkelt den adresse, hvor jeg kan finde det første bogstav i HELLO.

185
00:11:23,130 --> 00:11:26,500
Men det virker ikke som nok. Jeg bad dig om en streng, ikke et tegn.

186
00:11:26,500 --> 00:11:32,970
Så hvordan kan vi eller computeren vide, at Ello slags komme sammen med H?

187
00:11:35,760 --> 00:11:37,460
Hvad er den slags aftale, vi har? Yeah.

188
00:11:37,460 --> 00:11:40,100
[Studerende] Det holder fortæller selv at finde nogle flere tegn. >> Præcis.

189
00:11:40,100 --> 00:11:44,570
>> Der er denne human-computer konvention, hvorved når du har at gøre med strygere,

190
00:11:44,570 --> 00:11:49,410
ellers kendt nu som char stjerner, du simpelthen nødt til at finde ud af

191
00:11:49,410 --> 00:11:54,350
hvor enden af ​​hver snor i livet er ved virkelig bare iteration over det med en for-løkke,

192
00:11:54,350 --> 00:11:57,820
en while-løkke, uanset hvad, så når du finder den ende af snoren

193
00:11:57,820 --> 00:12:02,160
nu kan du udlede det, åh, hele ordet var HELLO.

194
00:12:02,160 --> 00:12:04,820
De af jer med forudgående erfaring med programmering måske kender i Java

195
00:12:04,820 --> 00:12:09,880
du kan bare ringe. længde og på andre sprog, kan du ringe til længde eller lignende.

196
00:12:09,880 --> 00:12:14,060
Det er fordi i en masse sprog, især ting kaldet objektorienterede sprog,

197
00:12:14,060 --> 00:12:18,580
længden af ​​noget er slags indkapslet inde i det stykke af selve dataene,

198
00:12:18,580 --> 00:12:24,000
ligesom vi indkapslede ID'er og navne og huse inde i en student på mandag.

199
00:12:24,000 --> 00:12:28,700
Men C er meget lavere niveau. Der er ingen genstande eller klasser, hvis du har hørt disse ord før.

200
00:12:28,700 --> 00:12:31,490
Alt hvad du behøver er virkelig hukommelse adresser.

201
00:12:31,490 --> 00:12:35,540
Så dette er en slags gammeldags måde at repræsentere interessante datastrukturer.

202
00:12:35,540 --> 00:12:38,760
Du har en startværdi som adressen på det første tegn

203
00:12:38,760 --> 00:12:42,340
og så lige nogle vilkårlige konvention, at alle er enige at følge.

204
00:12:42,340 --> 00:12:46,420
Så hvordan er streng længde gennemført, har vi foreslå?

205
00:12:46,420 --> 00:12:51,360
Strlen, strlen, som nogle af jer har nu brugt et par gange. Det er temmelig simpelt, ikke?

206
00:12:51,360 --> 00:12:53,060
Det er ligesom 2 linjer kode.

207
00:12:53,060 --> 00:12:56,140
Det er temmelig meget en for-løkke af en slags, måske med en ekstra lokal variabel.

208
00:12:56,140 --> 00:13:00,540
Men strlen bare nødt til at tage en pegepind og derefter begynde at lede efter \ 0.

209
00:13:00,540 --> 00:13:05,190
>> Og så snart den finder det, kan det vende tilbage det samlede antal skridt, det har taget i denne streng.

210
00:13:05,190 --> 00:13:07,150
Så vi kan udlede af dette, hvad der foregår næste.

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

212
00:13:11,850 --> 00:13:14,280
Dette er noget garbage værdi. Hvem ved i første omgang?

213
00:13:14,280 --> 00:13:18,490
Men på den højre side af linjen på 10 jeg ringer GetString igen.

214
00:13:18,490 --> 00:13:20,050
Hvem ved, hvor det ender?

215
00:13:20,050 --> 00:13:23,830
Lad os vilkårligt sige, at operativsystemet fandt plads til det helt herover.

216
00:13:23,830 --> 00:13:28,610
Jeg tilfældigvis tilfældigvis skrive H-E-L-L-O igen,

217
00:13:28,610 --> 00:13:31,260
og så vi kan drage den samme slags billede.

218
00:13:31,260 --> 00:13:34,290
Men det faktum, at jeg har gentegnes dette billede er bevidst

219
00:13:34,290 --> 00:13:37,720
fordi det er en anderledes HELLO end denne.

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

221
00:13:43,920 --> 00:13:47,170
Så hvad bliver sat hvor spørgsmålstegnet engang var?

222
00:13:47,170 --> 00:13:50,190
I dette tilfælde 456.

223
00:13:50,190 --> 00:13:53,540
Vi plukke disse numre vilkårligt fordi virkelig efter dag

224
00:13:53,540 --> 00:13:57,110
Vi vil ikke bekymre sig så meget om, hvad adressen på noget er.

225
00:13:57,110 --> 00:14:02,690
Alt vi interesserer os er, at vi kan finde ud af adressen på nogle stykke af data ligesom HELLO.

226
00:14:02,690 --> 00:14:07,100
>> Så virkelig hvad de fleste mennesker gør i datalogi når vi taler om hukommelse adresser

227
00:14:07,100 --> 00:14:10,210
og taler om pointers specifikt,

228
00:14:10,210 --> 00:14:14,220
snarere end gider finde ud af 123 - hvem bekymrer sig, når det her egentlig er,

229
00:14:14,220 --> 00:14:17,440
vi bare vide, at det er på nogle numeriske adresse -

230
00:14:17,440 --> 00:14:22,180
Vi forenkler verden og bare sige, at s peger på, at karakter

231
00:14:22,180 --> 00:14:25,080
og t peger på dette tegn.

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

233
00:14:27,430 --> 00:14:31,610
fordi bogstaveligt nu s peger på H og t peger i den anden H

234
00:14:31,610 --> 00:14:34,720
fordi der i slutningen af ​​dagen, er det ligegyldigt, hvad adressen er,

235
00:14:34,720 --> 00:14:40,240
men det betyder noget, at vi har evnen til at udtrykke denne adresse med nogle stykke kode.

236
00:14:40,240 --> 00:14:42,730
Vi har ikke rigtig manipuleret disse adresser bare endnu

237
00:14:42,730 --> 00:14:47,770
så vil vi se, hvor vi kan indskyde og sortere af gøre ting med pegepinde,

238
00:14:47,770 --> 00:14:52,030
men for nu i linje 12 bogstaveligt hvilke værdier vi sammenligner

239
00:14:52,030 --> 00:14:55,500
i henhold til denne historie på linje 12?

240
00:14:56,570 --> 00:15:01,290
Vi siger, er 123 lig lig med 456? Og det er bestemt ikke tilfældet.

241
00:15:01,290 --> 00:15:05,320
Og selv begrebsmæssigt, denne pointer er absolut ikke det samme som dette

242
00:15:05,320 --> 00:15:09,500
fordi du kaldte GetString to gange, og GetString forsøger ikke at være super dygtig,

243
00:15:09,500 --> 00:15:12,470
Det forsøger ikke at indse, åh, du har skrevet HELLO 5 minutter siden;

244
00:15:12,470 --> 00:15:15,090
lad mig give dig det samme pointer som jeg gav dig før,

245
00:15:15,090 --> 00:15:18,450
det bare tildeler en ny bid af hukommelse, hver gang du kalder det.

246
00:15:18,450 --> 00:15:20,350
>> Så hvordan kan vi løse dette problem?

247
00:15:20,350 --> 00:15:24,270
Hvis højere niveau jeg ønsker at sammenligne strengene Hej og HELLO -

248
00:15:24,270 --> 00:15:28,680
Jeg er ligeglad med viserne - hvordan kan jeg gå om at besvare spørgsmålet,

249
00:15:28,680 --> 00:15:31,980
har brugeren skrive det samme? Hvad er nødvendigt her? Yeah.

250
00:15:31,980 --> 00:15:35,200
[Studerende] Brug en funktion. >> Jeg kan bruge en funktion ud af kassen.

251
00:15:35,200 --> 00:15:38,170
Jeg kan anvende en funktion kaldet strcmp, s-t-r-c-m-p,

252
00:15:38,170 --> 00:15:41,190
bare den forkortede version af at sige streng sammenligne.

253
00:15:41,190 --> 00:15:45,070
Og hvis vi går ind i for eksempel sammenligne 2, som er blandt nutidens uddelingskopier,

254
00:15:45,070 --> 00:15:46,690
Jeg gør præcis det.

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

256
00:15:51,750 --> 00:15:54,360
og nu mærke denne del har ændret sig bare en lille smule.

257
00:15:54,360 --> 00:15:57,690
Lad os ignorere linie 28 for et øjeblik og kun fokusere på denne ene.

258
00:15:57,690 --> 00:16:00,410
Hvad sagde vi sige mandag, at str Sammenlign gør?

259
00:16:00,410 --> 00:16:05,200
Det håndterer processen med at tage 2 pegepinde, s og t i denne sag,

260
00:16:05,200 --> 00:16:08,480
slags praktisk talt at sætte fingeren på de 2 bogstaver,

261
00:16:08,480 --> 00:16:11,530
og hvad det skal gøre, er noget i retning af en while-løkke eller en for-løkke,

262
00:16:11,530 --> 00:16:16,050
og det siger er disse det samme? Hvis dette er tilfældet, flytter den fingrene eller pointers fremad.

263
00:16:16,050 --> 00:16:17,970
Er det de samme, disse den samme, disse den samme,

264
00:16:17,970 --> 00:16:22,710
disse samme, disse det samme? Og ooh, jeg er i slutningen af ​​strengen på både s og t.

265
00:16:22,710 --> 00:16:26,780
Jeg har ikke fundet nogen modsigelser. Ja, disse strenge er den samme.

266
00:16:26,780 --> 00:16:31,940
Og hvad betyder str sammenligne afkast, hvis 2 strenge er de samme, tilsyneladende? Zero.

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

268
00:16:35,900 --> 00:16:40,560
det betyder, at er bare sker for at komme før t alfabetisk eller efter t.

269
00:16:40,560 --> 00:16:43,760
Og hvorfor skulle det være nyttigt at have en funktion, der fortæller dig, hvilken streng kommer før

270
00:16:43,760 --> 00:16:46,720
eller efter i en ordbog?

271
00:16:46,720 --> 00:16:48,740
[Studerende] Søger. >> Søgning og sortering.

272
00:16:48,740 --> 00:16:51,730
>> Så du kan gøre ting som binær søgning eller boble sortere eller fusionere slags

273
00:16:51,730 --> 00:16:53,230
hvor du er nødt til at sammenligne ting.

274
00:16:53,230 --> 00:16:56,420
Så vidt vi har slags skære nogle hjørner og kun talte om sortering

275
00:16:56,420 --> 00:16:59,430
i forbindelse med tal, fordi det er rart og let at tale om,

276
00:16:59,430 --> 00:17:02,430
men du kan helt sikkert sammenligne strenge, æble og banan,

277
00:17:02,430 --> 00:17:05,349
fordi hvis æble er kendt for at komme før banan, på samme måde,

278
00:17:05,349 --> 00:17:09,319
kan du flytte strenge rundt i hukommelsen, ligesom Rob gjorde med fletningen sortere i videoen

279
00:17:09,319 --> 00:17:15,880
og vi gjorde her på scenen med udvælgelse slags, insertion sortere og boble slags.

280
00:17:15,880 --> 00:17:18,710
Så hvor kan vi ellers tage det? Lad os prøve det.

281
00:17:18,710 --> 00:17:23,980
Lad os slags glemme, at lektie for et øjeblik og prøv nu og kopiere 1.C at gøre følgende.

282
00:17:23,980 --> 00:17:26,800
I linie 21 Jeg siger print noget,

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

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

285
00:17:30,690 --> 00:17:33,620
Vi har ikke rigtig fået ind i denne vane endnu, men lad os nu gøre det.

286
00:17:33,620 --> 00:17:40,990
Lad os faktisk skrælle dette lag. Dette er virkelig char *. Denne fyr er virkelig char *.

287
00:17:40,990 --> 00:17:45,690
Så hvad vil det sige at være kontrol, hvis s == NULL?

288
00:17:45,690 --> 00:17:48,380
Det viser sig, at når du kalder en funktion som GetString

289
00:17:48,380 --> 00:17:51,540
eller mere generelt bare bede en computer til at give dig noget hukommelse,

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

291
00:17:53,030 --> 00:17:56,630
Du kunne være vanvittigt og bede computeren for en terabyte hukommelse

292
00:17:56,630 --> 00:18:01,780
ved at bede om billioner af bytes af hukommelse bare ikke findes i computeren,

293
00:18:01,780 --> 00:18:05,130
men GetString og andre funktioner kræver en måde at råbe ad dig

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

295
00:18:06,820 --> 00:18:10,450
Og den måde GetString gør dette er, hvis du har bedt om mere hukommelse

296
00:18:10,450 --> 00:18:14,250
end der er tilgængelig på computeren, selvom det er super, super lav sandsynlighed

297
00:18:14,250 --> 00:18:17,730
fordi ingen af ​​os kommer til at skrive en billion tegn og derefter trykke på Enter,

298
00:18:17,730 --> 00:18:21,980
men lav sandsynlighed selvom det kan være, jeg stadig ønsker at tjekke for det just in case,

299
00:18:21,980 --> 00:18:26,120
og det særlige værdi, GetString, svar og andre funktioner vender tilbage

300
00:18:26,120 --> 00:18:30,630
hvis noget er gået galt, er NULL i alle hætter.

301
00:18:30,630 --> 00:18:36,520
>> Og hvad er NULL? NULL bare så sker for at repræsentere en pegepind. Det er hukommelsen adresse 0.

302
00:18:36,520 --> 00:18:40,800
Verden besluttede, at vilkårligt, hvis dette er min computers hukommelse - ved du hvad? -

303
00:18:40,800 --> 00:18:46,260
vi kommer til at stjæle bare 1 byte af hver computers hukommelse, og det er placering 0.

304
00:18:46,260 --> 00:18:49,560
Vi vil give det et kaldenavn for NULL, og vi vil love

305
00:18:49,560 --> 00:18:52,660
at vi aldrig vil faktisk sætte reelle data der

306
00:18:52,660 --> 00:18:56,770
fordi vi netop vilkårligt brug for en særlig værdi, 0, aka NULL,

307
00:18:56,770 --> 00:19:00,230
så vi kan råbe på brugerne, hvis noget går galt.

308
00:19:00,230 --> 00:19:03,590
Ellers kan du måske ikke ved er 0 betyde sætte noget her

309
00:19:03,590 --> 00:19:05,490
eller betyder det noget gik galt?

310
00:19:05,490 --> 00:19:09,190
Vi er nødt til alle enige om, at NULL betyder intet blev returneret,

311
00:19:09,190 --> 00:19:11,700
nogen egentlig adresse blev returneret.

312
00:19:11,700 --> 00:19:15,210
Nu, her er jeg bare vedtage mit menneskelige konvention af jeg vender tilbage 1 fra main

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

314
00:19:17,040 --> 00:19:20,650
Det er fordi main tilbagevenden konvention er at vende tilbage 0 hvis gode,

315
00:19:20,650 --> 00:19:22,990
1 eller en anden værdi, hvis dårlige.

316
00:19:22,990 --> 00:19:28,200
Men GetString og enhver funktion, der beskæftiger sig hukommelsen returnerer NULL hvis noget går dårligt.

317
00:19:28,200 --> 00:19:33,480
>> Okay. Så desværre linie 27, super simpelt selv om det er helt undlader at 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 påstår på linje 27 til at lave en kopi af s og kalder det t.

320
00:19:40,120 --> 00:19:45,790
Så jeg beder ikke brugeren om 2 strenge denne gang, jeg siger bare værdien i s

321
00:19:45,790 --> 00:19:47,870
bør sættes i t så godt.

322
00:19:47,870 --> 00:19:52,890
Så nu bare at vise, hvordan brudt dette er i linie 29 og fremefter hvad gør jeg?

323
00:19:52,890 --> 00:19:56,980
Først Jeg tjekker, om længden af ​​t er større end 0.

324
00:19:56,980 --> 00:19:59,330
Der er nogle streng der. Brugeren har indtastet noget i.

325
00:19:59,330 --> 00:20:03,410
Hvad er linie 32 gør, tilsyneladende?

326
00:20:03,410 --> 00:20:08,910
[Uhørlig student svar] >> Højre. Du kan slags udlede det fra hvad jeg sagde, at det gør.

327
00:20:08,910 --> 00:20:13,200
Men teknisk set, hvad det gør? t [0] repræsenterer hvad?

328
00:20:13,200 --> 00:20:15,140
[Studerende] The 0:e karakter. >> [Malan] The 0:e karakter.

329
00:20:15,140 --> 00:20:19,620
Eller mere menneskelignende, det første tegn i t, hvad det så end er, H måske i dette tilfælde.

330
00:20:19,620 --> 00:20:24,990
Og toupper gør hvad den siger. Det kapitaliserer 0:e karakter t og det ændrer det.

331
00:20:24,990 --> 00:20:28,430
Så det betyder at den nulte karakter t, gøre det store bogstaver,

332
00:20:28,430 --> 00:20:30,320
og læg den tilbage i det samme sted.

333
00:20:30,320 --> 00:20:35,540
Så hvis jeg skriver hej med små bogstaver, bør dette ændre det lille h til en kapital H.

334
00:20:35,540 --> 00:20:41,400
Men problemet er, at i linjerne 35 og 36, hvad jeg er ved at gøre, er at printe ud for os s og t.

335
00:20:41,400 --> 00:20:43,120
Og hvad er din fornemmelse?

336
00:20:43,120 --> 00:20:47,250
Hvad skal jeg faktisk kommer til at se, om jeg har skrevet i hej i alle små bogstaver?

337
00:20:47,250 --> 00:20:52,280
Hvad skal der blive udskrevet? >> [Uhørlig student svar] >> Hvad er det?

338
00:20:52,280 --> 00:20:58,360
[Studerende] Big H og resten lille. >> Den store H og resten lille til der,? S eller t

339
00:20:58,360 --> 00:21:03,170
[Studerende] Begge. >> Begge. Præcis. Så lad os se hvad der foregår her.

340
00:21:03,170 --> 00:21:08,380
>> Lad mig gå videre og kompilere dette. Det er Kopi1, så gør Kopi1. Ok.

341
00:21:08,380 --> 00:21:14,840
Zoom i. Lad mig gå videre og køre Kopi1, Enter, Sig noget: hej med små bogstaver.

342
00:21:14,840 --> 00:21:19,570
Det kapitaliserede kopien, men det tilsyneladende kapitaliserede originalen så godt,

343
00:21:19,570 --> 00:21:22,070
fordi hvad nu sker i denne historie?

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

345
00:21:27,030 --> 00:21:30,450
men selvom du måske har intuitivt håbet, at at være tilfældet,

346
00:21:30,450 --> 00:21:33,680
hvis du tænker over dette billede, hvad der virkelig har jeg gjort?

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

348
00:21:35,410 --> 00:21:39,390
Så lad os rulle tilbage i tiden, så t endnu ikke eksisterer i historien.

349
00:21:39,390 --> 00:21:43,160
S kan eksistere i historien, men lad os små bogstaver hej denne gang.

350
00:21:43,160 --> 00:21:46,710
Så lad mig ordne det, jeg faktisk skrevet i.

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

352
00:21:51,280 --> 00:21:58,050
Vi vil tegne den som en sekvens af tegn, sætte mine separator linjer her og min \ 0.

353
00:21:58,050 --> 00:22:05,980
Så dette er, hvor vi er, så snart linie 1 til 24-ish, give eller tage, har henrettet.

354
00:22:05,980 --> 00:22:07,800
Det er det billede af min hukommelse.

355
00:22:07,800 --> 00:22:10,800
Når jeg kommer til linie 27, hvad sker der?

356
00:22:10,800 --> 00:22:14,730
Ligesom før, får jeg en pointer, som jeg vil trække da dette torv.

357
00:22:14,730 --> 00:22:19,740
Det hedder t. Og hvad er dens værdi som standard? Hvem ved? Nogle garbage værdi.

358
00:22:19,740 --> 00:22:22,060
>> Så jeg vil abstrakt, at væk som et spørgsmålstegn.

359
00:22:22,060 --> 00:22:27,670
Og så snart den højre side af linien 27 udfører, hvad skal jeg sætte indersiden af ​​t?

360
00:22:27,670 --> 00:22:30,770
Det samme ting, der er i sek.

361
00:22:30,770 --> 00:22:34,120
Så hvis vi for et øjeblik fjerne denne abstraktion af pilen, og vi siger,

362
00:22:34,120 --> 00:22:40,330
åh, det er memory load adresse 123, når du siger t får s, semikolon,

363
00:22:40,330 --> 00:22:42,700
du bogstaveligt talt at sætte 123 her.

364
00:22:42,700 --> 00:22:45,200
Nu, hvis vi slags forenkle vores verden igen med billeder,

365
00:22:45,200 --> 00:22:48,750
hvad du har virkelig gjort, er blot tilføjet en anden pil til din verden

366
00:22:48,750 --> 00:22:52,910
der peger fra t til nøjagtig de samme streng.

367
00:22:52,910 --> 00:22:59,730
Så når i linje 31 og 32 jeg faktisk gå om at ændre t [0],

368
00:22:59,730 --> 00:23:05,580
hvad er t [0] tilsyneladende synonymt med nu? s [0]

369
00:23:05,580 --> 00:23:07,030
Så det er alt, hvad der sker.

370
00:23:07,030 --> 00:23:09,900
Og selvom den slags føles lidt lavt niveau og arcane

371
00:23:09,900 --> 00:23:12,760
og denne slags føles som måske intuitivt dette bør har netop arbejdet -

372
00:23:12,760 --> 00:23:15,410
Jeg har lavet kopier af ting før, og det fungerede bare -

373
00:23:15,410 --> 00:23:18,590
hvis du rent faktisk tænker over, hvad en streng egentlig er, det er en char *.

374
00:23:18,590 --> 00:23:21,700
Nå, hvad er det? Det er adressen på nogle tegn.

375
00:23:21,700 --> 00:23:24,930
Så måske giver det mere mening, at når du forsøger at gøre noget

376
00:23:24,930 --> 00:23:29,220
super tilsyneladende simpelt som dette, alt hvad du laver, er at kopiere en hukommelse adresse.

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

378
00:23:32,530 --> 00:23:37,500
Så selvom du ikke har nogen idé om, hvordan du ville løse dette problem i kode,

379
00:23:37,500 --> 00:23:45,080
højt niveau, begrebsmæssigt, hvad vi skal gøre for at gøre ta tro kopi af s, tilsyneladende?

380
00:23:46,670 --> 00:23:48,820
Yeah. >> [Studerende] Giv det en ny placering? >> Præcis.

381
00:23:48,820 --> 00:23:50,800
>> Vi er nødt til at give t et helt nyt sted.

382
00:23:50,800 --> 00:23:55,230
Vi har brug for en eller anden måde skabe en verden, hvor vi får en ny bid af hukommelse,

383
00:23:55,230 --> 00:24:00,090
der bare for klarhedens skyld vil jeg trække lige under denne ene, men det behøver ikke at være der.

384
00:24:00,090 --> 00:24:04,880
Men det skal være den samme størrelse, så jeg vil tegne disse lodrette linier i det samme sted.

385
00:24:04,880 --> 00:24:09,720
Det er fint, hvis det er alt skrald i første omgang. Hvem ved, hvad var der?

386
00:24:09,720 --> 00:24:13,850
Men trin 1 vil være nødvendigt at give mig så meget hukommelse som jeg har brug for

387
00:24:13,850 --> 00:24:18,630
til at passe en kopi af hej, så finde ud af at kopiere h her, e her,

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

389
00:24:20,390 --> 00:24:24,880
Men dette allerede burde føle sig lidt indlysende, selv om nogle af detaljerne er stadig abstrakte.

390
00:24:24,880 --> 00:24:28,690
Hvis du vil kopiere denne streng ind i dette, det er bare en for-løkke eller en while-løkke

391
00:24:28,690 --> 00:24:31,580
eller noget, som du er blevet endnu mere kendte.

392
00:24:31,580 --> 00:24:35,970
Så lad os prøve dette. Lad mig gå ind i copy2.c.

393
00:24:35,970 --> 00:24:43,270
I copy2.c vi har næsten det samme program, bortset fra linje 27.

394
00:24:43,270 --> 00:24:47,260
Det ser lidt kompliceret, men hvis vi bryder den ned stykke for stykke,

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 skaber denne ting i hukommelsen, men med et spørgsmålstegn

397
00:24:52,790 --> 00:24:54,680
fordi vi ikke har nogen idé om, hvad er der som standard.

398
00:24:54,680 --> 00:24:57,920
På den højre side er vi nu ved at indføre en ny funktion, malloc,

399
00:24:57,920 --> 00:25:00,640
for hukommelse tildele, giv mig hukommelse,

400
00:25:00,640 --> 00:25:06,900
og det tilsyneladende tager, hvor mange argumenter, hvor mange ting i parenteser?

401
00:25:09,660 --> 00:25:12,130
Jeg hørte murren i 1 og 2, men det er kun 1.

402
00:25:12,130 --> 00:25:15,320
Der er ingen komma, hvilket betyder, at der er kun 1 ting i parenteserne.

403
00:25:15,320 --> 00:25:17,720
Selv om der er andre parenteser, lad mig fremhæve

404
00:25:17,720 --> 00:25:21,460
hvad der er inde i den yderste parenteser, og det er dette udtryk:

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 tror faktisk dette igennem, er dette siger give mig længden af ​​s.

407
00:25:29,190 --> 00:25:34,440
Hvorfor er jeg dog tilsætte 1 på længden? >> [Uhørlig student svar]

408
00:25:34,440 --> 00:25:40,200
Præcis. Vi har brug for plads til denne fyr i halen, det sjette tegn, der ikke har nogen engelske betydning

409
00:25:40,200 --> 00:25:42,250
men har særlig programmatiske betydning.

410
00:25:42,250 --> 00:25:46,800
>> Så vi har brug for en + 1 for at fordi strlen returnerer den menneskelige forventning af længde,

411
00:25:46,800 --> 00:25:50,890
Hej eller 5, betyder det ikke give dig den ekstra null-tegn.

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

413
00:25:52,980 --> 00:25:56,060
Og så dette, * størrelse (char), har vi ikke set det før.

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

415
00:25:57,480 --> 00:26:04,150
Det er en speciel søgeord, der bare fortæller dig, hvad størrelsen er af nogle datatype på en computer

416
00:26:04,150 --> 00:26:06,980
for i virkeligheden, har nogle af os 32-bit computere.

417
00:26:06,980 --> 00:26:10,900
Jeg har en temmelig gammel computer derhjemme, og det kun anvender 32 bits til at repræsentere pointers.

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

419
00:26:13,900 --> 00:26:18,300
Men hvis jeg bruger min nye fancy computer, kan jeg komme tilbage en værdi på 64 bits

420
00:26:18,300 --> 00:26:20,510
for noget som en adresse.

421
00:26:20,510 --> 00:26:25,400
Så i dette tilfælde, at bare være super sikker, vi vil ikke til hårdt kode noget lignende -

422
00:26:25,400 --> 00:26:28,740
godt, hvad er på størrelse med en char efter hvad vi har sagt indtil videre?

423
00:26:28,740 --> 00:26:34,450
Vi har stort set sagt mundtligt, at det er 1 byte, og det er temmelig meget sandt over hele linjen.

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

425
00:26:37,000 --> 00:26:40,850
De fører til buggy software, hvis folk bruger din software på måder, du ikke havde til hensigt.

426
00:26:40,850 --> 00:26:44,750
Så lad os abstrakt dette væk og bare mere generisk sige

427
00:26:44,750 --> 00:26:46,830
Jeg har brug for så mange bidder af hukommelse

428
00:26:46,830 --> 00:26:50,210
og hvert stykke af hukommelsen skal svare til størrelsen af ​​en karakter,

429
00:26:50,210 --> 00:26:54,870
der er faktisk lig med 1 i dette tilfælde, men det er en mere generel måde at skrive det.

430
00:26:54,870 --> 00:27:00,460
Så hvis ordet er hej, hvordan mange bytes malloc tilsyneladende tildele for hej?

431
00:27:00,460 --> 00:27:04,980
[Studerende] Six. >> Six. Præcis så mange, som vi har spørgsmålstegn på skærmen.

432
00:27:04,980 --> 00:27:07,800
Og så tage et gæt nu baseret på din forståelse af GetString

433
00:27:07,800 --> 00:27:12,790
hvad betyder malloc sandsynligvis vende tilbage? >> [Studerende] En adresse.

434
00:27:12,790 --> 00:27:17,020
En adresse på hvad? Af de første bid af hukommelse.

435
00:27:17,020 --> 00:27:20,670
>> Vi har ingen idé om, hvad der er der, fordi en anden funktion

436
00:27:20,670 --> 00:27:23,010
kunne have brugt denne hukommelse tidligere.

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

438
00:27:28,380 --> 00:27:30,540
at det har afsat til dig.

439
00:27:30,540 --> 00:27:38,380
Men hvad den ikke gør udfylde dette emne med en backslash null-tegn

440
00:27:38,380 --> 00:27:43,030
fordi det viser sig, du kan bruge malloc at allokere noget: Ints, strygere, arrays,

441
00:27:43,030 --> 00:27:45,700
flåd, studerende strukturer.

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

443
00:27:47,750 --> 00:27:51,470
Det er ligeglad med eller have at vide, hvad du tildele hukommelse til.

444
00:27:51,470 --> 00:27:55,810
Så det ville være formasteligt for malloc at sætte en \ 0

445
00:27:55,810 --> 00:27:58,340
ved slutningen af ​​hver bid af hukommelse det er at give dig

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

447
00:28:02,620 --> 00:28:06,310
Det er ikke brugt til int'er, er det ikke anvendes til flåd, er det ikke bruges til studerende.

448
00:28:06,310 --> 00:28:11,730
Og så gotcha med malloc er, at byrden er helt på dig programmeringsenheden

449
00:28:11,730 --> 00:28:16,790
at huske, hvor mange bytes du tildelt og ikke at nogensinde bruge en for-løkke

450
00:28:16,790 --> 00:28:21,570
eller en while-løkke og gå forbi grænsen for bid af hukommelse, du har fået.

451
00:28:21,570 --> 00:28:23,540
Sagt på en anden måde, så snart du allokere hukommelse,

452
00:28:23,540 --> 00:28:28,510
du kan ikke bede operativsystemet, åh, forresten, var hvordan store af en luns af hukommelse dette?

453
00:28:28,510 --> 00:28:32,080
Det er helt op til dig at huske, hvis du har brug for denne værdi.

454
00:28:32,080 --> 00:28:34,330
>> Så lad os se, hvordan jeg fortsætte med at bruge denne hukommelse.

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

456
00:28:39,850 --> 00:28:42,260
Bare total tilregnelighed check.

457
00:28:42,260 --> 00:28:45,110
Bare i tilfælde af at noget gik galt, jeg bede om nogle vanvittige mængde hukommelse

458
00:28:45,110 --> 00:28:48,690
eller jeg har så mange ting, der kører på den computer, der er bare ikke nok hukommelse,

459
00:28:48,690 --> 00:28:51,780
sådan noget, jeg i det mindste ønsker at tjekke for null.

460
00:28:51,780 --> 00:28:55,260
I virkeligheden vil de fleste computere giver dig den illusion, at ethvert program

461
00:28:55,260 --> 00:28:57,080
kan bruge hele din RAM,

462
00:28:57,080 --> 00:29:00,740
men alligevel, hvis brugeren skriver i nogle skøre lang snor måske fordi de er en dårlig fyr

463
00:29:00,740 --> 00:29:03,440
og de er faktisk forsøger at gå ned dit program eller hacke sig ind på det,

464
00:29:03,440 --> 00:29:07,300
du ønsker at i det mindste kontrollere returværdien af ​​malloc, og om det er lig nul.

465
00:29:07,300 --> 00:29:11,630
Og hvis det gør, lad os bare afslutte lige nu, fordi jeg ikke ved, hvad de skal gøre i dette tilfælde.

466
00:29:11,630 --> 00:29:13,950
Hvordan kan jeg kopiere strengen? Der er et par måder at gøre dette.

467
00:29:13,950 --> 00:29:18,850
Der er str kopiere funktioner i C, men det er super nemt for os at gøre dette den gammeldags måde.

468
00:29:18,850 --> 00:29:23,110
>> Først lad mig regne ud, hvad længden af ​​s er.

469
00:29:23,110 --> 00:29:26,930
Jeg kunne have sat dette i løkken, men i stedet jeg bare sætte det ud her for klarhed.

470
00:29:26,930 --> 00:29:30,610
Så n nu lagrer længden af ​​den oprindelige streng, som tilsyneladende 5.

471
00:29:30,610 --> 00:29:35,290
Så i min for-løkke, jeg iteration fra 0 på op til n,

472
00:29:35,290 --> 00:29:40,940
og på hver iteration jeg lægger s [i] indersiden af ​​t [i].

473
00:29:40,940 --> 00:29:45,060
Så det er hvad jeg underforstået med mine 2 fingre peger på strengene før.

474
00:29:45,060 --> 00:29:49,260
Da dette for-løkke gentages som denne, vil jeg være kopiering h ind på her,

475
00:29:49,260 --> 00:29:52,890
e ind på her, l ind her, fordi det er s, det er t.

476
00:29:52,890 --> 00:29:58,770
Og så endelig, på linje 35 hvorfor gør jeg dette?

477
00:29:58,770 --> 00:30:03,770
Jeg er nødt til at sørge for, at jeg slutter strengen t.

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

479
00:30:06,170 --> 00:30:09,510
Men foreslå nogen, hvis man kunne, en anderledes måde at gøre dette.

480
00:30:09,510 --> 00:30:13,930
Jeg har ikke rigtig brug linie 35. Der er en anden måde at gøre dette.

481
00:30:13,930 --> 00:30:18,880
Yeah. >> [Uhørlig student svar] >> Sig det højere.

482
00:30:18,880 --> 00:30:20,960
[Studerende] Mindre end eller lig med. >> Præcis.

483
00:30:20,960 --> 00:30:24,450
Vi kunne blot sige mindre end eller lig med n, som generelt har været dårlig

484
00:30:24,450 --> 00:30:28,190
fordi næsten altid, når vi går op til en lige til de ting, vi tælle

485
00:30:28,190 --> 00:30:30,000
vi gå 1 skridt for langt.

486
00:30:30,000 --> 00:30:32,170
Men husk, hvor mange bytes vi tildeler?

487
00:30:32,170 --> 00:30:37,210
Vi tildelte strlen af ​​S, SO 5 + 1 for i alt 6.

488
00:30:37,210 --> 00:30:39,980
Så i dette tilfælde kunne vi gøre noget som dette

489
00:30:39,980 --> 00:30:46,450
så vi kopierer ikke bare den goddag, men også den \ 0 til allersidst.

490
00:30:46,450 --> 00:30:49,860
Alternativt kunne vi bruge en funktion kaldet str kopi, strcpy,

491
00:30:49,860 --> 00:30:51,700
men det ville ikke være nær så meget sjov.

492
00:30:51,700 --> 00:30:54,000
Men det er alt det gør under kølerhjelmen.

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

494
00:30:56,050 --> 00:31:01,620
Jeg udnytte t og så har jeg hævder, at den oprindelige ser sådan her ud, og kopien ligner det.

495
00:31:01,620 --> 00:31:08,570
Så lad os prøve det nu. Lad mig gå ind her. Gør copy2. Vi zoome ind og køre copy2.

496
00:31:08,570 --> 00:31:13,840
Jeg har tænkt mig at skrive hej med små bogstaver, og ja, jeg får små bogstaver hej som den oprindelige

497
00:31:13,840 --> 00:31:16,930
men kapital Hej for kopien.

498
00:31:16,930 --> 00:31:20,300
Men jeg er ikke færdig endnu. Jeg er nødt til at gøre 1 sidste ting her.

499
00:31:20,300 --> 00:31:28,000
46 og 47 er klart frigøre hukommelse, men hvad betyder det egentlig?

500
00:31:28,000 --> 00:31:33,250
Hvad laver jeg, tror du, ved at kalde linie 46 og linie 47?

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

502
00:31:38,900 --> 00:31:43,140
[Uhørlig student svar] >> Præcis.

503
00:31:43,140 --> 00:31:46,380
>> Du er bare at fortælle operativsystemet, hey, tak for denne hukommelse.

504
00:31:46,380 --> 00:31:48,320
Du kan nu bruge det til en anden.

505
00:31:48,320 --> 00:31:50,790
Og her er et perfekt eksempel på skrald værdier.

506
00:31:50,790 --> 00:31:55,430
Jeg har netop brugt denne hukommelse til at skrive ned ordet hej 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 så kalder jeg linie 46 og linie 47, og du ved, hvad der sker der i forhold til billedet?

510
00:32:06,960 --> 00:32:10,010
Faktisk, vent, dette billede er det gamle.

511
00:32:10,010 --> 00:32:12,550
Når vi gøre kopien, er denne fyr faktisk peger her,

512
00:32:12,550 --> 00:32:16,110
så lad os fjerne de numre og bare abstrakt væk som vores pile igen.

513
00:32:16,110 --> 00:32:19,370
Hvad sker der i dette billede, når jeg ringer gratis?

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

515
00:32:22,750 --> 00:32:29,510
Hvis jeg ringe gratis på s og t - slags en trick spørgsmål - dette billede ændrer sig ikke på alle

516
00:32:29,510 --> 00:32:33,880
fordi kalde s og kalde t bare fortæller operativsystemet,

517
00:32:33,880 --> 00:32:39,010
hey, kan du bruge denne hukommelse igen, men det ændrer ikke dette til null

518
00:32:39,010 --> 00:32:41,840
eller nogle specialtegn, ændrer det ikke dette,

519
00:32:41,840 --> 00:32:47,350
det ændrer ikke h eller e eller l, eller l, eller o i enten sted til noget andet.

520
00:32:47,350 --> 00:32:51,610
Med hensyn til billedet,. Så snart du kalder gratis, intet ændres

521
00:32:51,610 --> 00:32:56,570
Og deri ligger oprindelsen af ​​skrald værdier, fordi hvis jeg så senere i dette program

522
00:32:56,570 --> 00:33:01,010
bede operativsystemet for mere hukommelse med GetString eller malloc eller noget i den stil

523
00:33:01,010 --> 00:33:04,900
og operativsystemet siger, sikker, jeg har 12 bytes hukommelse bare frigøres,

524
00:33:04,900 --> 00:33:08,080
bruge disse, hvad vil skal afleveres?

525
00:33:08,080 --> 00:33:10,830
Du kommer til at blive udleveret en bid af hukommelse, som vi typisk ville trække

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

527
00:33:13,700 --> 00:33:17,000
De befinder sig h-e-l-l-o, h-e-l-l-o.

528
00:33:17,000 --> 00:33:20,940
Det er vores nye skrald værdier så snart du frigøre den hukommelse.

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

530
00:33:22,750 --> 00:33:24,720
Dette sker for at gøre med RAM, men dine computere

531
00:33:24,720 --> 00:33:26,720
rent faktisk gør det samme med disk.

532
00:33:26,720 --> 00:33:30,620
Vi vil tale om dette, navnlig med et fremtidigt problem sæt, der fokuserer på retsvidenskab.

533
00:33:30,620 --> 00:33:36,170
Men hvad sker der egentlig, hvis du har nogle følsomme finansielle fil på skrivebordet

534
00:33:36,170 --> 00:33:39,600
eller nogle sketchy JPEG og du trækker det ind i din papirkurv,

535
00:33:39,600 --> 00:33:44,390
hvad der sker, når du trækker det i skraldespanden eller papirkurven?

536
00:33:44,390 --> 00:33:47,240
Du vidste, hvad jeg talte om. [Latter]

537
00:33:47,240 --> 00:33:52,370
Hvad sker der, når du har trukket disse beviser til din papirkurven eller papirkurven?

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

539
00:33:55,920 --> 00:33:58,000
Nå, så pas på. Hvad sker der, når du gør det?

540
00:33:58,000 --> 00:34:01,030
Det korte svar er intet, right?

541
00:34:01,030 --> 00:34:04,790
Sketchy eller følsomme sag er stadig bare sidder der et eller andet sted på din harddisk.

542
00:34:04,790 --> 00:34:07,940
De fleste af os i det mindste har lært på den hårde måde, at du skal tømme din papirkurv

543
00:34:07,940 --> 00:34:10,429
eller din papirkurven til rent faktisk at slette filer.

544
00:34:10,429 --> 00:34:13,440
Og ja, når du højreklikker eller Control klik på din skraldespand

545
00:34:13,440 --> 00:34:15,580
eller vælg Filer, Tøm papirkurv eller hvad

546
00:34:15,580 --> 00:34:21,420
og du faktisk tømme papirkurven eller papirkurven, hvad der rent faktisk sker der så på dette billede?

547
00:34:22,810 --> 00:34:25,969
Mere intet. Så intet rent faktisk sker på disken.

548
00:34:25,969 --> 00:34:30,880
>> Og hvis vi bare midlertidigt sidespring og skrive - æ bare bruge bagsiden af ​​denne.

549
00:34:30,880 --> 00:34:34,639
Så nu historien ændrer sig fra RAM, hvilket er hvor programmer findes

550
00:34:34,639 --> 00:34:39,250
mens du kører dem til disk, som er hvor de er gemt på lang sigt

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

552
00:34:42,920 --> 00:34:46,380
lad os bare lade som om, at dette repræsenterer harddisken inde i din computer

553
00:34:46,380 --> 00:34:50,110
fordi tilbage i dag, de plejede at være cirkulære diske, meget gerne disketter.

554
00:34:50,110 --> 00:34:55,130
Så hvis du har nogle følsomme Excel-fil, kan det tage op denne luns af hukommelse

555
00:34:55,130 --> 00:34:59,770
på computerens harddisk, og jeg er bare tegning samme vilkårlig 1s og 0'erne.

556
00:34:59,770 --> 00:35:03,970
Når du trækker filen gerne have, at din skraldespand eller papirkurven,

557
00:35:03,970 --> 00:35:07,750
bogstaveligt talt intet sker, fordi Apple og Microsoft netop har besluttet

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

559
00:35:10,450 --> 00:35:14,710
Måske i sidste ende OS vil tømme det for dig, men typisk, at det ikke gør noget,

560
00:35:14,710 --> 00:35:17,090
i hvert fald indtil du er virkelig lav på plads.

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

562
00:35:20,870 --> 00:35:23,460
Ligeledes sker der ingenting til dette billede.

563
00:35:23,460 --> 00:35:28,590
Alt, hvad der sker, er et andet sted på din computer, er der en slags bord.

564
00:35:28,590 --> 00:35:35,400
Det er lidt ligesom en lille snyde ark, der siger, at, lad os sige, resume.doc,

565
00:35:35,400 --> 00:35:40,920
så dit cv i et Microsoft Word-fil bruges til at leve i position 123 på harddisken,

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

567
00:35:43,710 --> 00:35:49,050
og dine sketchy JPEG liv på 456, og din Excel-fil bor på 789 eller andre steder.

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 billede ændrer sig ikke. Den 0'er og 1-taller på din harddisk ikke gå nogen steder.

570
00:35:59,530 --> 00:36:03,930
Men denne tabel, denne lille database slags, ændrer sig.

571
00:36:03,930 --> 00:36:08,750
Når du sletter dit cv, er det som om filen er slettet i en eller anden forstand,

572
00:36:08,750 --> 00:36:12,790
men alt computeren gør, er at glemme, hvor den ting lever på din harddisk.

573
00:36:12,790 --> 00:36:17,870
Den 0'er og 1-taller, der komponere dit CV eller en af ​​de andre filer er stadig intakt.

574
00:36:17,870 --> 00:36:21,960
>> Så hvis du gjorde det ved et uheld, er der stadig en ikke-nul sandsynlighed

575
00:36:21,960 --> 00:36:25,800
at du kan gendanne dine data ved hjælp af Norton Utilities eller nogle kommercielle software

576
00:36:25,800 --> 00:36:29,810
hvis formål i livet er at finde 0'er og 1-taller, der er slags blevet forældreløse,

577
00:36:29,810 --> 00:36:33,300
glemt her, men forlod her, så du kan få dine data tilbage.

578
00:36:33,300 --> 00:36:38,410
Eller retsmedicinske efterforskere med politiet eller FBI ville faktisk tage en harddisk

579
00:36:38,410 --> 00:36:42,550
og faktisk se efter mønstre af 0'er og 1-taller, der ligner JPEG, ligner Excel-filer,

580
00:36:42,550 --> 00:36:46,400
og gendanne dem på den måde, selv hvis computeren har glemt dem der.

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

582
00:36:49,820 --> 00:36:54,190
er at skrubbe eller tørre filen eller harddisk ved -

583
00:36:54,190 --> 00:36:56,540
Du kan ikke rigtig slippe af med 0'er og 1-taller

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 op med en megabyte harddisk, hvis du hele tiden var slette,

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

587
00:37:04,380 --> 00:37:06,310
Så hvad ville du gøre, hvis du virkelig ønskede at dække dine spor

588
00:37:06,310 --> 00:37:10,510
og det grundlæggende problem er, at der stadig er 0'er og 1-taller på disken?

589
00:37:10,510 --> 00:37:14,930
Jeg ser nogen gestikulerende, at du fysisk ville bryde enheden. Det vil virke.

590
00:37:14,930 --> 00:37:19,600
[Latter] Men hvis det er sådan en dyr løsning, hvad ville være mere rimeligt?

591
00:37:19,600 --> 00:37:23,270
Yeah. >> [Studerende] Overskriv dem. >> Overskriv dem med hvad? >> [Studerende] Andre data.

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

593
00:37:29,070 --> 00:37:31,230
>> Og det er faktisk, hvad nogle af softwaren gør.

594
00:37:31,230 --> 00:37:33,570
Du kan købe software eller endda få gratis software,

595
00:37:33,570 --> 00:37:36,610
og endda indbygget i Mac OS disse dage, i mindre grad i Windows,

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

597
00:37:38,660 --> 00:37:41,960
Faktisk, hvis du ønsker at alle køre hjem i dag, hvis du har en Mac og gør dette,

598
00:37:41,960 --> 00:37:45,740
hvis du har fået nogle ting i din papirkurv kan, kan du gøre Sikker tømning af papirkurv,

599
00:37:45,740 --> 00:37:47,610
som gør netop dette.

600
00:37:47,610 --> 00:37:53,350
Snarere end blot slette filer her, betyder det ikke slette den 0'er og 1'ere her,

601
00:37:53,350 --> 00:38:01,240
snarere, det bare ændrer dem alle, for eksempel, til 0'er og prik, prik, prik.

602
00:38:01,240 --> 00:38:05,330
Så en af ​​dine fremtidige psets rent faktisk vil være til forsætligt gendanne data -

603
00:38:05,330 --> 00:38:08,430
billeder, vi har taget af mennesker, steder og ting på campus

604
00:38:08,430 --> 00:38:12,810
som vi vil gøre en retsmedicinsk billede af et digitalt kameras hukommelseskort,

605
00:38:12,810 --> 00:38:17,120
som er den nøjagtige samme idé - og du bliver nødt til at blive udfordret til rent faktisk at finde

606
00:38:17,120 --> 00:38:20,160
de mønstre, der repræsenterer JPEG på din harddisk,

607
00:38:20,160 --> 00:38:23,610
meget gerne, at tidligere studerende, hvis e-mail jeg læste et par uger siden gjorde

608
00:38:23,610 --> 00:38:25,860
at genvinde sin søsters fotografier.

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

610
00:38:33,030 --> 00:38:38,610
Så her er, hvor tingene bliver lidt hjernevridende, men dette er en meget kraftfuld skridt

611
00:38:38,610 --> 00:38:40,480
mod en forståelse dette så meget mere.

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

613
00:38:42,900 --> 00:38:45,430
Det er blandt dagens prøve kode.

614
00:38:45,430 --> 00:38:51,280
Bemærk, at i de første par linjer, 19 til 22, alt, hvad vi laver, er noget som GetString

615
00:38:51,280 --> 00:38:54,460
og returnere en adresse, gemme det i sek.

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

617
00:38:58,380 --> 00:39:01,030
hvor du kan begynde at tage disse støttehjul off dig selv,

618
00:39:01,030 --> 00:39:04,030
Der er ingen grund til at foregive, at strengene eksisterer længere.

619
00:39:04,030 --> 00:39:07,030
Det er helt sikkert i orden at bare begynde at sige char *.

620
00:39:07,030 --> 00:39:12,610
>> Som en sidebemærkning, du i online referencer og i bøger kan ofte se på stjernen ud for variablen.

621
00:39:12,610 --> 00:39:15,600
Du kan endda se mellemrum omkring begge sider af det.

622
00:39:15,600 --> 00:39:17,680
Alle af dem er funktionelt korrekte.

623
00:39:17,680 --> 00:39:21,180
For nu, selv om vi standardisere på denne fremgangsmåde for at gøre super klar

624
00:39:21,180 --> 00:39:24,000
at char * er som at sige karakter pointer.

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

626
00:39:25,680 --> 00:39:28,730
Og så navnet på den variabel er s i denne sag.

627
00:39:28,730 --> 00:39:31,180
Så vi har fået en streng, og vi har kaldt det s.

628
00:39:31,180 --> 00:39:35,180
Og så hernede bemærke, at jeg gør faktisk en lille smule af svindel.

629
00:39:35,180 --> 00:39:39,080
Dette kaldes pointer aritmetik, som er en slags super enkel.

630
00:39:39,080 --> 00:39:41,790
Det betyder bare lægge sammen og trække numre til pegepinde.

631
00:39:41,790 --> 00:39:43,660
Men det rent faktisk virker.

632
00:39:43,660 --> 00:39:49,170
Dette program tilsyneladende udskriver strengen s 1 tegn pr linje, således at slutresultatet -

633
00:39:49,170 --> 00:39:54,920
Bare så vi kan forkæle hvor dette foregår, lave pointere, køre pointere, lad mig zoome ind

634
00:39:54,920 --> 00:39:58,940
Lad mig skrive noget lignende HELLO og type Enter

635
00:39:58,940 --> 00:40:01,080
og den udskriver 1 karakter per linje.

636
00:40:01,080 --> 00:40:04,730
Indtil for et øjeblik siden, ville vi have gjort det med firkantet beslag notation.

637
00:40:04,730 --> 00:40:09,760
Vi ville have en for-løkke, og vi ville gøre printf af s [i], og vi ville gøre det igen og igen og igen

638
00:40:09,760 --> 00:40:11,950
med en backslash n for enden af ​​hver linje.

639
00:40:11,950 --> 00:40:16,800
Men dette program er anderledes. Dette program bruger, bogstaveligt talt, aritmetik.

640
00:40:16,800 --> 00:40:18,860
Så hvad sker der her?

641
00:40:18,860 --> 00:40:24,720
Først og fremmest, før denne sløjfe selv udfører, hvad, bare for at være klar, er s egentlig?

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

643
00:40:27,270 --> 00:40:32,980
>> Og det er den adresse, der er tale om hello, det første tegn i det ord, der er timer.

644
00:40:32,980 --> 00:40:37,370
Så s er i dette særlige eksempel, adressen på timer.

645
00:40:37,370 --> 00:40:41,850
Så hvad betyder det at gøre s + i?

646
00:40:41,850 --> 00:40:46,280
Nå, jeg starter ved 0 i dette for-løkke. Vi har gjort det mange gange.

647
00:40:46,280 --> 00:40:49,760
I kommer til at gå op til længden af ​​strengen, tilsyneladende.

648
00:40:49,760 --> 00:40:53,950
Så på den første iteration af denne løkke, er jeg naturligvis 0.

649
00:40:53,950 --> 00:41:01,740
Så dette udtryk siger s + i - snarere, s +0--det er naturligvis lige s.

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

651
00:41:04,320 --> 00:41:08,530
Nu bruger vi stjernen i en lidt anden måde.

652
00:41:08,530 --> 00:41:13,080
Lad mig gå videre og slippe af t, fordi vi er færdige taler om t og kopier af s.

653
00:41:13,080 --> 00:41:15,540
Nu skal vi bare ønsker at fortælle en historie, der involverer s.

654
00:41:15,540 --> 00:41:20,090
Og så i dette øjeblik, efter at have typen string, ser vores verden helt ligesom det gjorde før

655
00:41:20,090 --> 00:41:26,630
med bare s lagring adressen på h og mere generelt peger på strengen hej.

656
00:41:26,630 --> 00:41:33,170
Hvis jeg nu gøre en linje som * (s + i), lad os prøve dette.

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

658
00:41:40,140 --> 00:41:43,790
Tja, vent lige lidt. Forenkler yderligere. Dette er * (s).

659
00:41:43,790 --> 00:41:47,020
Nå, nu parenteserne er slags dumme, så lad os nu bare gøre * s.

660
00:41:47,020 --> 00:41:50,540
Så i den første iteration af denne løkke, denne linje, der er markeret, 26,

661
00:41:50,540 --> 00:41:53,650
er temmelig meget svarende til udskrivning dette.

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

663
00:41:56,040 --> 00:42:00,770
I denne forbindelse, fordi stjernen tilfældigvis er ved siden af ​​s selv,

664
00:42:00,770 --> 00:42:04,930
men mere specifikt, fordi vi ikke længere erklære s,

665
00:42:04,930 --> 00:42:09,730
vi ikke skabe en variabel længere, er der ingen omtale af char * i linje 26,

666
00:42:09,730 --> 00:42:14,280
Der er ingen omtale af søgeordet strengen, er vi bare bruge en variabel kaldet s,

667
00:42:14,280 --> 00:42:19,650
Det viser sig nu stjernen har lidt anderledes og ganske vist forvirrende betydning.

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

669
00:42:26,590 --> 00:42:33,750
Så s er her, * s er - lidt ligesom Chutes and Ladders, følg pilen - her.

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

671
00:42:35,850 --> 00:42:39,060
>> Så hvad bliver udskrevet på den første iteration af denne løkke i linje 26?

672
00:42:39,060 --> 00:42:42,170
Jeg udskrive% c, som er pladsholder for en karakter,

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

674
00:42:48,520 --> 00:42:53,670
Så hvad char skal jeg placere i for% c? H.

675
00:42:53,670 --> 00:42:56,900
I den næste iteration af løkken - du kan sandsynligvis se, hvor dette foregår -

676
00:42:56,900 --> 00:43:01,350
den næste iteration i er naturligvis 1, så betyder s en,

677
00:43:01,350 --> 00:43:05,580
og så nu jeg har brug for parenteserne, for nu stjernen nødt til at sige

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

679
00:43:08,620 --> 00:43:14,170
Hvad er s? Lad os rulle tilbage i tiden og sige dette pil nu er faktisk ikke gør os nogen tjeneste.

680
00:43:14,170 --> 00:43:18,450
Lad er mere specifikt sige, at dette er lagring af antallet 123

681
00:43:18,450 --> 00:43:25,110
idet starten af ​​denne streng hallo, er adressen 123, er 124, og så videre.

682
00:43:25,110 --> 00:43:30,550
Så på den anden iteration når jeg siger s +1, er det ligesom at sige, 123 1,

683
00:43:30,550 --> 00:43:35,340
ellers kendt som 124, så hvad char bliver trykt på den anden iteration?

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

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

686
00:43:44,440 --> 00:43:49,040
fordi jeg bruger strlen at sikre, at jeg ikke tæller for højt.

687
00:43:49,040 --> 00:43:50,810
Så det er også det.

688
00:43:50,810 --> 00:43:55,000
Igen, det er bare som om vi havde gjort en uge siden.

689
00:43:55,000 --> 00:43:59,200
Lad mig skrive det på linjen nedenfor, selvom vi ikke ønsker at gøre begge dele.

690
00:43:59,200 --> 00:44:02,500
Dette er identisk nu til dette.

691
00:44:02,500 --> 00:44:08,310
>> Så selvom s er en streng, som vi har kaldt det for uger, s er virkelig en char *.

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

693
00:44:13,270 --> 00:44:17,490
på den i'te placering ved hjælp af disse numeriske adresser og denne stjerne operatør,

694
00:44:17,490 --> 00:44:20,470
men helt ærligt, det er bare så meget renere. Så det er ikke dårligt.

695
00:44:20,470 --> 00:44:26,720
Ingen grund til at stoppe med at gøre linje 27 her, men 26 er funktionelt det samme,

696
00:44:26,720 --> 00:44:31,570
og det er funktionelt det samme for præcis de grunde, vi har diskuteret hidtil.

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

698
00:44:33,650 --> 00:44:38,420
Opkald fri for s betyder, at nu er du give tilbage den hukommelse, som GetString gav dig

699
00:44:38,420 --> 00:44:41,630
fordi igen, da jeg nævnte mandag, GetString i ugevis

700
00:44:41,630 --> 00:44:44,180
har været at indføre en fejl i din kode.

701
00:44:44,180 --> 00:44:46,490
Din kode i ugevis har haft memory leaks

702
00:44:46,490 --> 00:44:49,970
hvor du har bedt GetString for hukommelse, men du har aldrig været at give det tilbage.

703
00:44:49,970 --> 00:44:53,410
Og det blev bevidst valgt af os pædagogisk

704
00:44:53,410 --> 00:44:55,880
fordi det er bare for meget at tænke på et tidligt tidspunkt.

705
00:44:55,880 --> 00:44:57,710
Men nu har vi brug for mere symmetri.

706
00:44:57,710 --> 00:45:00,830
Hvis du beder computeren om hukommelse, som det er tilfældet for GetString,

707
00:45:00,830 --> 00:45:02,820
som det er tilfældet tilsyneladende for malloc,

708
00:45:02,820 --> 00:45:07,970
Du skal nu til Pset 4 og frem også gratis en sådan hukommelse.

709
00:45:07,970 --> 00:45:11,650
Bemærk dette er forskelligt fra at sige int n.

710
00:45:11,650 --> 00:45:15,040
Du behøver ikke at befri dette, fordi du ikke kalde GetString

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

712
00:45:16,890 --> 00:45:20,610
>> Og selv hvis du kaldte GetInt som vi i sidste ende vil se,

713
00:45:20,610 --> 00:45:25,520
GetInt ikke tildele hukommelse til dig, fordi du rent faktisk kan passere rundt heltal

714
00:45:25,520 --> 00:45:29,430
og flåd og specialtegn bare den måde, vi har gjort i ugevis.

715
00:45:29,430 --> 00:45:33,960
Strygere, selv om, er specielle, fordi virkelig de er den sammenkædning af flere tegn.

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

717
00:45:37,450 --> 00:45:39,980
Men vi vil vende tilbage til det inden længe.

718
00:45:39,980 --> 00:45:44,920
Eventuelle spørgsmål derefter på denne begyndelse af pegepinde? Yeah.

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

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

721
00:45:51,440 --> 00:45:55,790
En af de få ting, C faktisk gør for dig, hvilket er praktisk,

722
00:45:55,790 --> 00:46:00,110
er det tal ud for dig, hvad størrelsen er af datatypen

723
00:46:00,110 --> 00:46:03,060
og derefter gør den slags multiplikation for dig.

724
00:46:03,060 --> 00:46:06,610
Det er irrelevant i tilfælde af tegn, fordi næsten altid en char er 1 byte,

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

726
00:46:08,150 --> 00:46:11,220
Men af ​​hensyn til diskussion, hvis du rent faktisk var ved at udskrive heltal

727
00:46:11,220 --> 00:46:15,500
og du prøvede at udskrive en vis værdi s, der pegede mod et heltal,

728
00:46:15,500 --> 00:46:20,720
du ligeledes ville ikke behøver at gøre + 4 * jeg bare fordi en int er 4 bytes.

729
00:46:20,720 --> 00:46:25,780
Pointer aritmetiske betyder, at C og compiler gøre alt, matematik for dig.

730
00:46:25,780 --> 00:46:29,190
Alt du skal bekymre sig om, er optælling i form af den menneskelige fornuft. Yeah.

731
00:46:29,190 --> 00:46:35,200
[Studerende] Hvis du erklærer en streng inde i en for-løkke, behøver du nødt til at befri det senere?

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

733
00:46:36,760 --> 00:46:41,390
>> Hvis du har erklæret en streng inde i for-løkken, har du brug for at frigøre det senere?

734
00:46:41,390 --> 00:46:47,520
Du behøver kun at frigøre hukommelse, som du tildeler med GetString eller med malloc.

735
00:46:47,520 --> 00:46:53,110
Så hvis du bare sige noget lignende - lad mig sige krøllede parenteser nu så al koden er relateret.

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

737
00:46:58,580 --> 00:47:03,450
du behøver ikke at gratis t fordi t ikke indebar nogen omtale af malloc eller GetString.

738
00:47:03,450 --> 00:47:08,960
Hvis derimod du gjorde dette, GetString, så ja, ville du nødt til gratis t.

739
00:47:08,960 --> 00:47:14,350
Og i virkeligheden er din eneste chance for at gøre det nu inde i denne løkke, for samme nummer af anvendelsesområdet

740
00:47:14,350 --> 00:47:16,060
at vi har diskuteret tidligere.

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

742
00:47:18,830 --> 00:47:21,230
og ved afslutningen af ​​programmet, fordi du er uden for denne løkke,

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

744
00:47:24,240 --> 00:47:26,750
at du ikke behøver at hukommelsen længere.

745
00:47:26,750 --> 00:47:30,430
Og inden længe, ​​for Pset 4 eller 5 vil vi udstyre dig med et program kaldet Valgrind,

746
00:47:30,430 --> 00:47:34,160
som er ens i ånd med GDB i at det har fået lidt af en mystisk interface,

747
00:47:34,160 --> 00:47:35,750
men dens formål i livet er at hjælpe dig.

748
00:47:35,750 --> 00:47:39,380
Og Valgrind er et program, der i fremtiden vil søge i dine programmer

749
00:47:39,380 --> 00:47:42,550
udkig efter memory leaks, uanset om GetString eller malloc,

750
00:47:42,550 --> 00:47:47,800
som vi vil begynde at bruge så meget desto mere som vi holder op med at bruge CS50 biblioteket så meget.

751
00:47:47,800 --> 00:47:53,030
Vi endelig har nu slags det ordforråd og den slags mental model i teorien

752
00:47:53,030 --> 00:47:55,170
med til at løse dette brudte program.

753
00:47:55,170 --> 00:47:59,410
>> Så i denne brudt program, arbejder swap inde i swap,

754
00:47:59,410 --> 00:48:05,280
men det faktisk aldrig arbejdet i main fordi main gik i x-og y, recall,

755
00:48:05,280 --> 00:48:07,260
og dem, der blev vedtaget i af værdier, så at sige.

756
00:48:07,260 --> 00:48:09,330
Kopier af dem blev givet til at bytte.

757
00:48:09,330 --> 00:48:12,520
Ved udgangen af ​​swap, var a og b faktisk blevet udvekslet,

758
00:48:12,520 --> 00:48:16,120
men selvfølgelig x og y, som vi diskuterede i mandags, havde ikke været.

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

760
00:48:19,940 --> 00:48:22,640
Og faktisk, lad mig flytte mine stjerner bare for at være i overensstemmelse

761
00:48:22,640 --> 00:48:24,440
selv om igen, funktionelt dette betyder ikke noget.

762
00:48:24,440 --> 00:48:28,730
I de kommende uger vil vi forklare, hvornår og hvorfor det betyder noget.

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

764
00:48:30,600 --> 00:48:33,700
Helt ærligt, det ser en hel masse Messier fordi jeg har alle disse stjerner.

765
00:48:33,700 --> 00:48:35,380
Lad mig påpege én ting.

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

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

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

769
00:48:47,070 --> 00:48:49,940
hvoraf den første er en int pointer kaldet en,

770
00:48:49,940 --> 00:48:53,100
hvoraf den anden er en int pointer kaldet b..

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

772
00:48:55,770 --> 00:48:59,340
>> Hvad betyder det? A er ikke en int, b er ikke en int.

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

774
00:49:04,100 --> 00:49:06,980
Hernede er det her, jeg indrømmer C bliver forvirrende.

775
00:49:06,980 --> 00:49:09,790
Nu vi bruger en stjerne, men det har forskellig betydning i denne sammenhæng.

776
00:49:09,790 --> 00:49:13,150
Fordi vi ikke er erklære pegepinde, som vi er heroppe,

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

778
00:49:15,500 --> 00:49:21,520
Så teknisk set stjernen i denne forbindelse af den første, anden og tredje linje indersiden af ​​swap

779
00:49:21,520 --> 00:49:24,560
er dereference operatør, hvilket betyder bare derned.

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

781
00:49:27,400 --> 00:49:31,100
* Et middel gå til den pågældende adresse og finde mig int, der er der.

782
00:49:31,100 --> 00:49:34,250
* B midler gå til den adresse og passere mig hvad der er.

783
00:49:34,250 --> 00:49:40,730
Så lad os gentegne billedet fra mandag nu ved hjælp af en stak af frames,

784
00:49:40,730 --> 00:49:43,130
den nederste hvoraf bliver hoved,

785
00:49:43,130 --> 00:49:47,600
den øvre hvoraf bliver swap,

786
00:49:47,600 --> 00:49:50,880
så vores verden ser ud, ligesom mandag som denne.

787
00:49:50,880 --> 00:49:53,620
Her er en bid af hukommelse, main skal bruge.

788
00:49:53,620 --> 00:49:56,520
>> Recall fra mandag, at programmet netop havde 2 variabler,

789
00:49:56,520 --> 00:50:01,930
en der hedder x og en kaldet y, og jeg havde lagt tallene 1 og 2 er der.

790
00:50:01,930 --> 00:50:06,580
Nu når jeg kalder bytte ligesom jeg gjorde i mandags,

791
00:50:06,580 --> 00:50:11,000
tidligere, da jeg brugte den røde version af dette program, som ser sådan ud,

792
00:50:11,000 --> 00:50:17,470
Jeg fik 2 parametre, A og B, og hvad gjorde vi skriver her og her?

793
00:50:17,470 --> 00:50:21,160
Blot 1 og 2, bogstaveligt talt kopier af x og y.

794
00:50:21,160 --> 00:50:23,070
I dag har vi ændre det.

795
00:50:23,070 --> 00:50:28,510
Dag i stedet for at passere i int'er a og b vi kommer til at passere i 2 adresser.

796
00:50:28,510 --> 00:50:34,290
Disse adresser tilfældigvis til at pege på int'er, men disse adresser ikke Ints sig selv.

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

798
00:50:37,330 --> 00:50:40,580
Så nu er vi nødt til at bare give mig en lidt mere detaljeret på skærmen.

799
00:50:40,580 --> 00:50:43,250
Dette er min computers hukommelse som det har været hele dagen.

800
00:50:43,250 --> 00:50:45,120
Nu har vi brug for nogle vilkårlig nummersystem.

801
00:50:45,120 --> 00:50:50,580
Så lad os bare sige, blot ved en tilfældighed, at det er memory-adresse 123, 124.

802
00:50:50,580 --> 00:50:55,660
Lad os bare sige det er 125, det er 126, og så videre, men det er helt vilkårlig.

803
00:50:55,660 --> 00:50:58,590
Vi skal bare have nogle nummereringsskema i min hukommelse.

804
00:50:58,590 --> 00:51:04,030
Så nu når jeg rent faktisk går i x og y, jeg ikke kommer til at passere i x og y;

805
00:51:04,030 --> 00:51:08,400
Jeg har tænkt mig at passere i den postadresse, så at sige, af x og y

806
00:51:08,400 --> 00:51:11,870
så det, der bliver gemt 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, bliver hvad gik i her og her?

808
00:51:16,030 --> 00:51:23,340
[Uhørlig student svar] >> Præcis. 123 bliver sat her og 124 bliver sat her.

809
00:51:23,340 --> 00:51:28,910
>> Nu, fordi jeg brugte stjernen i denne allerførste linje op her på toppen,

810
00:51:28,910 --> 00:51:34,340
mit program bare ved, at 123 og 124, selv om de er tydeligvis heltal

811
00:51:34,340 --> 00:51:40,160
at noget menneske kunne mærke, skal de fortolkes som adresser, numeriske adresser.

812
00:51:40,160 --> 00:51:43,250
De er ikke i sig selv int'er, de er adresser,

813
00:51:43,250 --> 00:51:46,120
og det er fordi jeg udtrykkeligt har sat stjerner der.

814
00:51:46,120 --> 00:51:51,360
Så nu i min første, anden og tredje linje af faktiske kode, hvad der sker her?

815
00:51:51,360 --> 00:51:53,380
Lad os trække resten af ​​billedet.

816
00:51:53,380 --> 00:51:56,980
Tmp er ligesom det var i mandags. Intet særligt om tmp.

817
00:51:56,980 --> 00:52:03,060
Det er blot et lokale 32 bit variabel, og indersiden af, at jeg åbenbart lagring af værdien af ​​* en.

818
00:52:03,060 --> 00:52:08,580
Nu, hvis jeg sagde bare tmp = a, hvad ville jeg have her? >> [Studerende] 123.

819
00:52:08,580 --> 00:52:10,370
123. Men det er ikke hvad jeg laver.

820
00:52:10,370 --> 00:52:13,670
Jeg siger tmp = * en. Stjernede midler derned.

821
00:52:13,670 --> 00:52:19,370
Så her er en, 123. Hvordan kan jeg gå der? Foregive som om der er en pil.

822
00:52:19,370 --> 00:52:24,460
Tja, der er det, 1. Så hvad bliver gemt i tmp, tilsyneladende? Bare 1.

823
00:52:24,460 --> 00:52:29,620
Så med andre ord, tmp er * A, * a midler gå til den adresse, der er i øjeblikket i en,

824
00:52:29,620 --> 00:52:31,320
som tilsyneladende 123.

825
00:52:31,320 --> 00:52:33,910
>> Okay, her er vi i position 123, ser jeg nummer 1,

826
00:52:33,910 --> 00:52:35,670
så jeg har tænkt mig at sætte nummer 1 der.

827
00:52:35,670 --> 00:52:39,020
Nu hvad gør jeg på linje 2, * a = * b?

828
00:52:39,020 --> 00:52:44,570
Denne ene er lidt mere involveret, fordi nu, hvad er en? Det er 123.

829
00:52:44,570 --> 00:52:50,220
Så * en er hvor? Lige hvor jeg var før. Så går der. Okay.

830
00:52:50,220 --> 00:52:53,420
Nu, endelig, og så endelig vil begynde at give mening, forhåbentlig,

831
00:52:53,420 --> 00:53:00,280
* B betyder hvad der er i b? 124. Så jeg er nødt til at gå der, hvilket er 2.

832
00:53:00,280 --> 00:53:03,430
Så hvad skal jeg sætte hvor?

833
00:53:03,430 --> 00:53:10,100
2 går ind her, fordi * b går ind * en. Så jeg vil gøre det.

834
00:53:10,100 --> 00:53:13,120
Og du kan allerede se, måske, at vi er så meget tættere

835
00:53:13,120 --> 00:53:17,710
til at løse dette dumme, simple problem korrekt for første gang

836
00:53:17,710 --> 00:53:20,920
fordi nu har vi stadig en erindring om, hvad x var,

837
00:53:20,920 --> 00:53:23,230
vi har 2 kopier, ganske vist af y,

838
00:53:23,230 --> 00:53:25,850
men linje 3 nu siger * b.

839
00:53:25,850 --> 00:53:31,080
Så her er b. * B betyder derned. Så hvor er placering 124?

840
00:53:31,080 --> 00:53:35,560
Det er åbenbart her. Så hvad skal jeg have her? Naturligvis, tmp.

841
00:53:35,560 --> 00:53:39,600
Så nu gør jeg det. Så jeg har 1 her og 2 her.

842
00:53:39,600 --> 00:53:43,560
Og hvad nu om alt dette, 123, den 124, og 1?

843
00:53:43,560 --> 00:53:47,910
Så snart swap vender tilbage, denne hukommelse er så godt som tabt

844
00:53:47,910 --> 00:53:51,070
fordi så snart swap vender tilbage, operativsystemet

845
00:53:51,070 --> 00:53:54,190
er gratis at bruge, at hukommelsen igen i fremtiden.

846
00:53:54,190 --> 00:53:58,870
Kun main hukommelse i bunden af ​​denne såkaldte stak pinde rundt.

847
00:53:58,870 --> 00:54:01,470
>> Og så har vi endelig har nu en fungerende version.

848
00:54:01,470 --> 00:54:06,310
Lad mig gå ind i swap.c, og bemærk følgende.

849
00:54:06,310 --> 00:54:11,280
På toppen af ​​det program, jeg har ændret min prototype til at være int * a og int * b.

850
00:54:11,280 --> 00:54:15,000
Så det eneste, jeg skiftede til at gå fra rød, som var dårligt, til grøn, hvilket er godt,

851
00:54:15,000 --> 00:54:17,350
er jeg tilføjet disse stjerner i dag.

852
00:54:17,350 --> 00:54:21,520
Men så hernede i swappen selv jeg var nødt til at kopiere, indsætte, hvad der var lige på diaset.

853
00:54:21,520 --> 00:54:24,140
Jeg har en stjerne her, stjerne her - der matcher prototype -

854
00:54:24,140 --> 00:54:27,930
og så alle disse ting har nu stjerner bortset tmp

855
00:54:27,930 --> 00:54:30,680
fordi anvendelsen af ​​en midlertidig variabel, er der intet nyt der.

856
00:54:30,680 --> 00:54:33,040
Jeg skal bare have midlertidig lagerplads til en int.

857
00:54:33,040 --> 00:54:34,820
Så vi har ikke brug for en stjerne der.

858
00:54:34,820 --> 00:54:39,310
Vi skal bare bruge stjernen, så vi kan krydse denne form for vilkårlig grænse

859
00:54:39,310 --> 00:54:42,900
mellem disse 2 frames i min computers hukommelse.

860
00:54:42,900 --> 00:54:45,630
Men en sidste ting skal ændres, og du har måske ane det allerede.

861
00:54:45,630 --> 00:54:48,810
Hvilken anden linje er selvfølgelig anderledes nu? >> [Studerende] & x.

862
00:54:48,810 --> 00:54:53,270
>> Ja, så 25 er den sidste linje kode jeg nødt til at ændre for at dette virker.

863
00:54:53,270 --> 00:54:58,360
For en uge siden, og selv på mandag linje 25 lignede dette, bytte x og y,

864
00:54:58,360 --> 00:55:02,020
og dette var blot brudt, fordi hvis du siger swap (x, y)

865
00:55:02,020 --> 00:55:05,660
du giver kopier af x og y for at bytte, så det gør sin ting,

866
00:55:05,660 --> 00:55:09,080
men du er faktisk aldrig skiftende x og y selv.

867
00:55:09,080 --> 00:55:12,880
Så selv hvis du aldrig har set denne karakter før med tegnet i kode,

868
00:55:12,880 --> 00:55:15,860
bare tage et gæt. Hvad betyder tegnet gør, tilsyneladende?

869
00:55:15,860 --> 00:55:17,890
[Studerende] mener adressen. >> Mener adressen.

870
00:55:17,890 --> 00:55:21,160
Så tegnet siger give mig adressen på x.

871
00:55:21,160 --> 00:55:25,590
Hvem ved hvor det er? Det sker for at være 123. Jeg er ligeglad. Bare giv mig adressen på x.

872
00:55:25,590 --> 00:55:28,340
& Y betyder give mig adressen på y.

873
00:55:28,340 --> 00:55:34,450
Og på det tidspunkt, at historien er helt i overensstemmelse med det billede, vi trak et øjeblik siden.

874
00:55:34,450 --> 00:55:38,310
>> Så jeg vil indrømme pejlemærker, i hvert fald for mig, da jeg først begyndte at lære dette,

875
00:55:38,310 --> 00:55:40,570
var afgjort en af ​​de sværeste ting at ombryde mit sind rundt.

876
00:55:40,570 --> 00:55:43,760
Men indse, især da vi fortsætter med at spille med den slags ting,

877
00:55:43,760 --> 00:55:48,030
hvis du bryde det ned til disse super simple slags intellektuelt uinteressant problemer

878
00:55:48,030 --> 00:55:52,270
for bare at flytte numre rundt, svaret på en masse forvirring med pegepinde

879
00:55:52,270 --> 00:55:56,590
virkelig kan udledes af disse meget grundlæggende mekanik.

880
00:55:56,590 --> 00:55:59,070
Her er en adresse. Gå der med stjernen.

881
00:55:59,070 --> 00:56:03,830
Eller omvendt, her er et og-tegn. Regne ud, hvad adressen rent faktisk er.

882
00:56:03,830 --> 00:56:06,270
Ok.

883
00:56:06,270 --> 00:56:09,000
Så hvor er al denne hukommelse kommer fra?

884
00:56:09,000 --> 00:56:12,360
Vi har tegnet dette billede et par gange, og jeg holder lovende vi vil komme tilbage til det,

885
00:56:12,360 --> 00:56:14,920
men her er en repræsentation af computerens hukommelse

886
00:56:14,920 --> 00:56:17,420
det er lidt mere mærket end vores tavle her er.

887
00:56:17,420 --> 00:56:21,590
Teksten segment øverst repræsenterer, hvad med hensyn til dit program?

888
00:56:21,590 --> 00:56:26,090
[Uhørlig student svar] >> Undskyld? Sig det igen.

889
00:56:26,090 --> 00:56:28,660
[Studerende] Den faktiske program. >> Den faktiske program.

890
00:56:28,660 --> 00:56:32,430
>> Så den 0'er og 1-taller, at du har kompileret efter at have skrevet C-kode og derefter kører Dunk

891
00:56:32,430 --> 00:56:35,910
og generering af 0'er og 1-taller ender med at blive gemt der i hukommelsen

892
00:56:35,910 --> 00:56:38,570
fordi når du dobbeltklikker på et ikon på din Mac eller pc

893
00:56:38,570 --> 00:56:43,010
eller køre en kommando som mario på dit hurtige, din 0'er og 1'ere fra disk

894
00:56:43,010 --> 00:56:45,700
bliver indlæst i hukommelsen, så computeren kan manipulere dem

895
00:56:45,700 --> 00:56:47,540
og udføre dem hurtigere.

896
00:56:47,540 --> 00:56:50,880
Så klargjorte data og uden startværdi data, vil vi ikke snakke meget om dem,

897
00:56:50,880 --> 00:56:52,420
men de er bare globale variable.

898
00:56:52,420 --> 00:56:54,710
Initialiseret betyder globale variabler, som du gav værdier til;

899
00:56:54,710 --> 00:56:59,300
initialiseret betyder globale variabler, som du endnu ikke har giver værdier til.

900
00:56:59,300 --> 00:57:01,900
Så er der de 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 der gemmer ting som dit brugernavn

902
00:57:04,860 --> 00:57:08,090
og anden form for lavere niveau detaljer.

903
00:57:08,090 --> 00:57:12,880
Men de juiciest stykker af din hukommelse layout er denne ting kaldet stakken og bunke.

904
00:57:12,880 --> 00:57:17,470
Stakken igen, for at være klar, er hukommelsen, der bruges, når funktioner kaldes,

905
00:57:17,470 --> 00:57:19,710
hvis der er lokale variable

906
00:57:19,710 --> 00:57:22,120
og når der er parametre, der væltes rundt.

907
00:57:22,120 --> 00:57:24,490
Alt dette sker i stakken.

908
00:57:24,490 --> 00:57:29,570
Den bunke vi har ikke talt om, men tage et gæt, der bruger den bunke.

909
00:57:31,120 --> 00:57:32,690
Bare en anden luns af hukommelsen.

910
00:57:32,690 --> 00:57:36,620
Det sker for at blive trukket her øverst, men det er en vilkårlig billedlig konvention.

911
00:57:36,620 --> 00:57:41,670
Hvem tilsyneladende har brugt hukommelse fra bunke i flere uger?

912
00:57:41,670 --> 00:57:44,830
Det er teknisk dig, men indirekte. >> [Studerende] GetString.

913
00:57:44,830 --> 00:57:47,950
GetString og malloc. Så her er den grundlæggende forskel.

914
00:57:47,950 --> 00:57:51,300
>> Du kender i de sidste par uger, hvis du har brug hukommelse, bare erklære en variabel.

915
00:57:51,300 --> 00:57:54,560
Hvis du har brug for masser af hukommelse, erklære en array lige inde i din funktion.

916
00:57:54,560 --> 00:57:59,620
Men det problem, vi har holdt overfor, er, hvis du erklærer variabler lokalt inde i funktioner,

917
00:57:59,620 --> 00:58:05,340
så snart funktionen returnerer, hvad der sker med hukommelsen og disse variabler?

918
00:58:05,340 --> 00:58:09,620
Bare slags er det ikke længere din, ikke? Det bare forsvinder slags konceptuelt.

919
00:58:09,620 --> 00:58:13,950
Det er stadig fysisk der, naturligvis, men det er ikke længere din ret til at bruge.

920
00:58:13,950 --> 00:58:17,160
Det er selvfølgelig problematisk, hvis du ønsker at skrive funktioner i livet

921
00:58:17,160 --> 00:58:20,440
der faktisk allokere hukommelse og ikke give den tilbage med det samme.

922
00:58:20,440 --> 00:58:24,180
Sag i punkt: GetString formål i livet er at have nogen idé i forvejen

923
00:58:24,180 --> 00:58:26,390
hvor stor en streng jeg har tænkt mig at skrive på tastaturet,

924
00:58:26,390 --> 00:58:30,390
men det er nødt til at være i stand til at allokere hukommelse til at holde David eller goddag

925
00:58:30,390 --> 00:58:32,860
eller en hel essay, som brugeren måtte have skrevet i.

926
00:58:32,860 --> 00:58:35,280
Så GetString har brugt malloc.

927
00:58:35,280 --> 00:58:38,910
Malloc derfor skal bruge ikke stakken;

928
00:58:38,910 --> 00:58:40,770
I stedet er det ved hjælp af denne ting kaldet heap.

929
00:58:40,770 --> 00:58:44,430
Der er ikke noget anderledes ved hukommelsen. Det er ikke hurtigere eller langsommere eller noget i den retning.

930
00:58:44,430 --> 00:58:46,570
Det er bare fysisk et andet sted.

931
00:58:46,570 --> 00:58:50,120
>> Men reglen er, at den hukommelse, der er allokeret på heapen

932
00:58:50,120 --> 00:58:56,180
vil aldrig blive taget væk fra dig, indtil du ringer - tage et gæt - fri.

933
00:58:56,180 --> 00:59:00,510
Derimod dig nogen hukommelse bede om på stakken ved blot at erklære et array

934
00:59:00,510 --> 00:59:03,320
eller erklære en variabel ligesom vi har gjort i ugevis,

935
00:59:03,320 --> 00:59:05,640
at som standard ender på stakken.

936
00:59:05,640 --> 00:59:09,550
Og det virker godt 90% af tiden, men på de sjældnere lejligheder

937
00:59:09,550 --> 00:59:12,470
hvor du ønsker at allokere hukommelse og holde det rundt,

938
00:59:12,470 --> 00:59:14,730
så er du nødt til at bruge en funktion som malloc.

939
00:59:14,730 --> 00:59:19,370
Eller vi har brugt en funktion som GetString, som igen bruger malloc.

940
00:59:19,370 --> 00:59:23,300
Lad os se, hvor dette kan bryde ned og derefter tage et kig på Binky.

941
00:59:23,300 --> 00:59:25,820
Vi kommer tilbage til det i fremtiden.

942
00:59:25,820 --> 00:59:29,270
Her er et super simpelt program, der i de første 2 linier gør hvad?

943
00:59:29,270 --> 00:59:33,460
På engelsk, hvad de første 2 linjer kode gør inde i main?

944
00:59:33,460 --> 00:59:35,600
[Uhørlig student svar]

945
00:59:35,600 --> 00:59:37,880
Forsigtig. Det giver ikke mig adressen på x eller y.

946
00:59:37,880 --> 00:59:41,840
[Studerende] Giver henvisninger til int'er. >> Godt. Giv mig 2 pegepinde til heltal.

947
00:59:41,840 --> 00:59:45,130
Med andre ord, give mig 2 bidder af hukommelse, som jeg holder tegning i dag,

948
00:59:45,130 --> 00:59:46,950
selvom jeg slettet det nu, som firkanter.

949
00:59:46,950 --> 00:59:50,000
Giv mig 2 bidder af hukommelse, en kaldet x, en kaldet y -

950
00:59:50,000 --> 00:59:54,320
jeg tidligere kaldte dem s og t - og hvad er den type der bid af hukommelse?

951
00:59:54,320 --> 00:59:57,160
Det kommer til at gemme en adresse.

952
00:59:57,160 --> 00:59:59,110
Det er af typen int *.

953
00:59:59,110 --> 01:00:01,630
>> Så adressen på en int i sidste ende vil leve i x,

954
01:00:01,630 --> 01:00:03,860
adressen på en int i sidste ende vil leve i y,

955
01:00:03,860 --> 01:00:08,460
men i første omgang, hvad der er indeni af x og y? Hvem ved? Garbage værdier.

956
01:00:08,460 --> 01:00:10,180
Det har intet at gøre med pegepinde.

957
01:00:10,180 --> 01:00:12,720
Hvis vi ikke har lagt noget der, hvem ved hvad er faktisk der?

958
01:00:12,720 --> 01:00:18,950
Nu, x. Hvad sker der her? Dette er legit nu, fordi x er en pointer. Det er en int *.

959
01:00:18,950 --> 01:00:21,870
Så det betyder, at jeg kan sætte i x adressen på nogle bid af hukommelse.

960
01:00:21,870 --> 01:00:25,120
Hvad betyder malloc vende tilbage? Perfekt, returneres adresser,

961
01:00:25,120 --> 01:00:28,510
adressen af ​​den første byte i en hel bid af hukommelsen.

962
01:00:28,510 --> 01:00:31,140
Hvor mange bytes er dette tilsyneladende fordeling for eksempel i apparatet?

963
01:00:31,140 --> 01:00:33,510
Hvad er størrelsen af ​​en int? 4.

964
01:00:33,510 --> 01:00:36,600
Hvis du tænker tilbage til uge 1, er det ikke super vigtigt altid at huske,

965
01:00:36,600 --> 01:00:38,870
men i dette tilfælde er det nyttigt at vide, 4 byte.

966
01:00:38,870 --> 01:00:41,770
Så dette er fordeling på heapen 4 byte

967
01:00:41,770 --> 01:00:46,110
og det er tilbage adressen på den første til mig vilkårligt.

968
01:00:46,110 --> 01:00:47,700
Nu, hvad x laver?

969
01:00:47,700 --> 01:00:52,200
A * x = 42 gør hvad?

970
01:00:52,200 --> 01:00:57,150
Hvis der på dette tidspunkt i historien har vi x, der ser sådan ud med nogle skrald værdi,

971
01:00:57,150 --> 01:01:04,120
dette er nu y med nogle skrald værdi, nu i linie 3 Jeg har tildelt 4 byte.

972
01:01:04,120 --> 01:01:06,950
Dette billede væsentlige ligner dette.

973
01:01:06,950 --> 01:01:12,010
Eller mere specifikt, hvis dette er vilkårlig adresse 123, det er det, vores historie nu ser ud.

974
01:01:12,010 --> 01:01:23,940
* X = 42 betyder nu hvad? Det betyder gå til adressen 123 og sætte nummer 42 der.

975
01:01:23,940 --> 01:01:26,220
Jeg behøver ikke at tegne disse linjer, fordi vi ikke laver strenge.

976
01:01:26,220 --> 01:01:29,480
>> Jeg bør har netop skrevet det sådan her, og bare for demonstration skyld,

977
01:01:29,480 --> 01:01:33,240
42 som en int slags fylder en masse plads, 4 byte.

978
01:01:33,240 --> 01:01:35,960
Så det er hvad der er sket der, men der er et problem nu.

979
01:01:35,960 --> 01:01:40,580
* Y = 13. Hvad vil der ske her?

980
01:01:40,580 --> 01:01:46,470
Problemet er * y i vores forenklede verden betyder bare gå til adressen i y.

981
01:01:46,470 --> 01:01:48,590
Hvad er der i y? Det er nogle skrald værdi.

982
01:01:48,590 --> 01:01:53,150
Så lad os antage, at det skrald værdi er 5551212, noget vanvittigt lignende.

983
01:01:53,150 --> 01:01:56,750
* Y midler til løse 5.551.212.

984
01:01:56,750 --> 01:02:00,450
Det er ligesom herovre. Det eksisterer ikke, for eksempel.

985
01:02:00,450 --> 01:02:05,310
Så * y får 13 betyder, jeg forsøger at tegne 13 her. Det findes ikke.

986
01:02:05,310 --> 01:02:08,790
Jeg har overskredet det segment af tavlen. Hvad får jeg?

987
01:02:08,790 --> 01:02:14,930
Denne kryptiske besked segmentering skyld, fordi jeg forsøger at sætte i hukommelsen

988
01:02:14,930 --> 01:02:19,470
en værdi som 13 på et sted, der ikke eksisterer.

989
01:02:19,470 --> 01:02:23,900
Resten af ​​programmet kan arbejde okay, men indtil da er det ikke.

990
01:02:23,900 --> 01:02:25,350
Så lad os prøve at fortælle denne historie.

991
01:02:25,350 --> 01:02:27,830
Vi vil vende tilbage til, at når vi har talt om hex.

992
01:02:27,830 --> 01:02:30,290
Lad os gå tilbage til dette og slutte af med denne ting kaldet Binky,

993
01:02:30,290 --> 01:02:33,710
som husker er en Stanford professor sidder derhjemme leger med claymation,

994
01:02:33,710 --> 01:02:36,380
at fortælle historien om netop det samme program.

995
01:02:36,380 --> 01:02:40,580
Det er bare omkring 3 minutter lang. Her har vi Binky.

996
01:02:40,580 --> 01:02:45,030
[Mandlig taler om video] Hey Binky, vågne op. Det er tid til pointer sjov.

997
01:02:45,030 --> 01:02:50,080
[Binky] Hvad er det? Lær om pointers? Oh, goody!

998
01:02:50,080 --> 01:02:53,700
[Mandlig taler] Tja, at komme i gang, jeg tror vi kommer til at bruge et par pointers.

999
01:02:53,700 --> 01:02:57,890
>> [Binky] Okay. Denne kode tildeler 2 pejlemærker, der kan pege på heltal.

1000
01:02:57,890 --> 01:03:02,220
[Mandlig taler] Okay. Tja, jeg ser de 2 pegepinde, men de synes ikke at pege på noget som helst.

1001
01:03:02,220 --> 01:03:05,550
[Binky] Det er rigtigt. I første omgang, behøver pointers ikke pege på noget som helst.

1002
01:03:05,550 --> 01:03:09,270
De ting, de peger kaldes pointees, og sætte dem op er et separat trin.

1003
01:03:09,270 --> 01:03:12,330
[Mandlig taler] Åh, højre, højre. Jeg vidste det. De pointees er adskilt.

1004
01:03:12,330 --> 01:03:15,630
Is, så hvordan kan du tildele en pointee?

1005
01:03:15,630 --> 01:03:21,510
[Binky] Okay. Denne kode tildeler en ny heltal pointee, og denne del sætter x til at pege på den.

1006
01:03:21,510 --> 01:03:23,500
[Mandlig taler] Hey, det ser bedre ud.

1007
01:03:23,500 --> 01:03:26,030
Så gør det gøre noget. >> [Binky] Okay.

1008
01:03:26,030 --> 01:03:30,300
Jeg vil dereference markøren x for at gemme nummeret 42 i sin pointee.

1009
01:03:30,300 --> 01:03:34,410
For dette trick jeg skal bruge min tryllestav af dereference.

1010
01:03:34,410 --> 01:03:38,610
[Mandlig taler] Din tryllestav af dereferere? Det er godt.

1011
01:03:38,610 --> 01:03:44,230
[Binky] Dette er hvad koden ser ud. Jeg vil bare oprette antallet og ... [Knaldende lyd]

1012
01:03:44,230 --> 01:03:46,100
[Mandlig taler] Hey se, der det går.

1013
01:03:46,100 --> 01:03:50,990
Så gør en dereference på x følger pilen for at få adgang sit pointee,

1014
01:03:50,990 --> 01:03:53,230
i dette tilfælde til at gemme 42 derinde.

1015
01:03:53,230 --> 01:03:57,630
Hey, kan du prøve at bruge det til at gemme nummeret 13 gennem den anden pointer, y.

1016
01:03:57,630 --> 01:04:03,250
[Binky] Okay. Jeg vil bare gå over her til y og få nummer 13 oprettet

1017
01:04:03,250 --> 01:04:08,360
og derefter tage staven fra dereferere og bare ... [Summende lyd] Whoa!

1018
01:04:08,360 --> 01:04:10,980
[Mandlig taler] Oh hey, det virkede ikke.

1019
01:04:10,980 --> 01:04:14,870
>> Sig, Binky, tror jeg ikke dereferere y er en god idé

1020
01:04:14,870 --> 01:04:17,880
fordi oprettelsen af ​​pointee er et separat trin

1021
01:04:17,880 --> 01:04:19,850
og jeg tror ikke, vi nogensinde gjorde det.

1022
01:04:19,850 --> 01:04:21,770
[Binky] Hmm, god pointe.

1023
01:04:21,770 --> 01:04:26,640
[Mandlig taler] Yeah. Vi tildelte markøren y men vi har aldrig sat den til at pege på en pointee.

1024
01:04:26,640 --> 01:04:28,780
[Binky] Hmm, meget opmærksomme.

1025
01:04:28,780 --> 01:04:30,690
[Mandlig taler] Hey, du ser godt ud der, Binky.

1026
01:04:30,690 --> 01:04:34,160
Kan du lave det, så y peger på samme pointee som x? >> [Binky] Sure.

1027
01:04:34,160 --> 01:04:37,100
Jeg vil bruge min tryllestav af pointer opgave.

1028
01:04:37,100 --> 01:04:39,070
[Mandlig taler] Er det vil være et problem som før?

1029
01:04:39,070 --> 01:04:40,840
[Binky] Nej, det betyder ikke røre pointees.

1030
01:04:40,840 --> 01:04:44,780
Det bare ændrer en pegepind til at pege på det samme som en anden. [Knaldende lyd]

1031
01:04:44,780 --> 01:04:48,570
[Mandlig taler] Åh, jeg kan se. Nu y peger på det samme sted som x.

1032
01:04:48,570 --> 01:04:51,140
Så vent. Nu y fast. Det har en pointee.

1033
01:04:51,140 --> 01:04:54,520
Så du kan prøve staven fra dereferere igen for at sende 13 over.

1034
01:04:54,520 --> 01:04:58,130
[Binky] Uh, okay. Her går. [Knaldende lyd]

1035
01:04:58,130 --> 01:05:01,250
[Mandlig taler] Hey, se på det. Nu dereferere værker på y.

1036
01:05:01,250 --> 01:05:05,200
Og fordi de pejlemærker deler, at en pointee, de begge se 13.

1037
01:05:05,200 --> 01:05:06,910
[Binky] Yeah, deling. Uanset hvad.

1038
01:05:06,910 --> 01:05:08,880
>> Så skal vi skifte steder nu?

1039
01:05:08,880 --> 01:05:11,420
[Mandlig taler] Oh look, vi er ude af tid. >> [Binky] Men -

1040
01:05:11,420 --> 01:05:13,880
[Mandlig taler] Bare husk de 3 pointer regler.

1041
01:05:13,880 --> 01:05:18,630
Nummer 1, den grundlæggende struktur er, at du har en pegepind og den peger hen til en pointee.

1042
01:05:18,630 --> 01:05:23,120
Men markøren og pointee er adskilt, og den almindelig fejl er at oprette en pegepind

1043
01:05:23,120 --> 01:05:25,680
men at glemme at give det en pointee.

1044
01:05:25,680 --> 01:05:29,580
Nummer 2, pointer dereference starter ved markøren og følger pilen hen over

1045
01:05:29,580 --> 01:05:31,060
at få adgang til sin pointee.

1046
01:05:31,060 --> 01:05:34,340
Som vi alle ved, er dette kun fungerer, hvis der er en pointee,

1047
01:05:34,340 --> 01:05:36,460
hvilken slags kommer tilbage til regel nummer 1.

1048
01:05:36,460 --> 01:05:39,870
Nummer 3, pointer opgave tager en pointer og ændrer det

1049
01:05:39,870 --> 01:05:42,390
at pege på den samme pointee som en anden pointer.

1050
01:05:42,390 --> 01:05:45,890
Så efter opgaven, vil de 2 pejlemærker peger på samme pointee.

1051
01:05:45,890 --> 01:05:47,800
Nogle gange kaldes deling.

1052
01:05:47,800 --> 01:05:50,910
>> Og det er alt der er til det virkelig. Bye-bye nu.

1053
01:05:50,910 --> 01:05:55,840
Dette er Binky. Det er CS50. Vi vil se dig i næste uge. [Bifald]

1054
01:05:55,840 --> 01:05:59,000
>> [CS50.TV]