1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [Artikel 4 - meer gemaklik]

2
00:00:02,520 --> 00:00:04,850
[Rob Bowden - Harvard Universiteit]

3
00:00:04,850 --> 00:00:07,370
[Hierdie is CS50. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
Ons het 'n quiz môre, in geval julle ouens het nie geweet dat.

5
00:00:14,810 --> 00:00:20,970
Dit is basies alles wat jy kan in die klas gesien of moet gesien word in die klas.

6
00:00:20,970 --> 00:00:26,360
Dit sluit pointers, selfs al is hulle 'n baie onlangse onderwerp.

7
00:00:26,360 --> 00:00:29,860
Jy moet ten minste verstaan ​​die hoë vlakke van hulle.

8
00:00:29,860 --> 00:00:34,760
Enigiets wat gegaan het om in die klas wat jy moet verstaan ​​vir die quiz.

9
00:00:34,760 --> 00:00:37,320
So as jy vrae het oor hulle, kan jy hulle vra nou.

10
00:00:37,320 --> 00:00:43,280
Maar dit gaan 'n baie student-geleide sessie wees waar julle vra vrae,

11
00:00:43,280 --> 00:00:45,060
so hopelik mense vrae het.

12
00:00:45,060 --> 00:00:48,020
Is daar iemand enige vrae?

13
00:00:49,770 --> 00:00:52,090
Ja. >> [Student] Kan jy weer gaan oor pointers?

14
00:00:52,090 --> 00:00:54,350
Ek gaan oor wysers.

15
00:00:54,350 --> 00:00:59,180
Al jou veranderlikes noodwendig in die geheue,

16
00:00:59,180 --> 00:01:04,450
maar gewoonlik bekommer julle julle nie oor wat en jy moet net sê x + 2 en y + 3

17
00:01:04,450 --> 00:01:07,080
en die vertaler sal uitvind waar die dinge wat vir jou.

18
00:01:07,080 --> 00:01:12,990
Sodra jy met wysers, nou is jy uitdruklik die gebruik van daardie geheue-adresse.

19
00:01:12,990 --> 00:01:19,800
So 'n enkele veranderlike ooit sal leef net by 'n adres op enige gegewe tyd.

20
00:01:19,800 --> 00:01:24,040
As ons wil hê om 'n wyser om te verklaar, wat die tipe gaan lyk?

21
00:01:24,040 --> 00:01:26,210
>> Ek wil 'n wyser p te verklaar. Wat beteken die tipe lyk?

22
00:01:26,210 --> 00:01:33,530
[Student] int * p. >> Ja. So int * p.

23
00:01:33,530 --> 00:01:38,030
En hoe maak ek dit aan x? >> [Student] Ampersand.

24
00:01:40,540 --> 00:01:45,300
[Bowden] So ampersand genoem is letterlik die adres van die operateur.

25
00:01:45,300 --> 00:01:50,460
So wanneer ek sê & x dit is om die geheue-adres van die veranderlike x.

26
00:01:50,460 --> 00:01:56,790
So nou het ek die wyser p, en enige plek wat ek kan gebruik in my kode * p

27
00:01:56,790 --> 00:02:02,960
of ek kan gebruik x en dit sal presies dieselfde ding.

28
00:02:02,960 --> 00:02:09,520
(* P). Wat is dit besig om te doen? Wat nie beteken dat die ster?

29
00:02:09,520 --> 00:02:13,120
[Student] Dit beteken 'n waarde op daardie punt. >> Ja.

30
00:02:13,120 --> 00:02:17,590
So as ons kyk na dit, kan dit baie nuttig wees om die diagramme te teken

31
00:02:17,590 --> 00:02:22,230
waar dit 'n klein boks geheue vir x, wat gebeur die waarde 4 het,

32
00:02:22,230 --> 00:02:25,980
dan het ons 'n klein blokkie van geheue vir p,

33
00:02:25,980 --> 00:02:31,590
en so p punte x, sodat ons trek 'n pyl vanaf P na x.

34
00:02:31,590 --> 00:02:40,270
So wanneer ons sê * p ons sê gaan na die boks wat is p.

35
00:02:40,270 --> 00:02:46,480
Star volg die pyl en dan doen wat jy wil met dié boks reg daar.

36
00:02:46,480 --> 00:03:01,090
Sodat ek kan sê * p = 7; en dit sal gaan na die boks wat x en verandering wat aan 7.

37
00:03:01,090 --> 00:03:13,540
Of ek kon sê int z = * p * 2; Dit is verwarrend, want dit se ster,.

38
00:03:13,540 --> 00:03:19,230
Die een ster p ontwysing vermenigvuldig, is die ander ster deur 2.

39
00:03:19,230 --> 00:03:26,780
Let op ek kan net so goed die * p vervang met x.

40
00:03:26,780 --> 00:03:29,430
Jy kan dit gebruik in die dieselfde manier.

41
00:03:29,430 --> 00:03:38,000
En dan later het ek kan p punt na 'n heeltemal nuwe ding.

42
00:03:38,000 --> 00:03:42,190
Ek kan net sê p = &z;

43
00:03:42,190 --> 00:03:44,940
So nou p nie meer punte aan x; dit wys tot z.

44
00:03:44,940 --> 00:03:50,510
En enige tyd wat ek doen * p dit is dieselfde as die doen z.

45
00:03:50,510 --> 00:03:56,170
So is die nuttige ding oor hierdie is wanneer ons begin om in funksies.

46
00:03:56,170 --> 00:03:59,790
>> Dit is soort van nutteloos om 'n wyser om te verklaar dat na iets

47
00:03:59,790 --> 00:04:03,140
en dan is jy net ontwysing

48
00:04:03,140 --> 00:04:06,060
wanneer jy kon gebruik het om die oorspronklike veranderlike te begin.

49
00:04:06,060 --> 00:04:18,190
Maar wanneer jy in funksies - so laat ons sê ons het 'n paar funksie, int foo,

50
00:04:18,190 --> 00:04:32,810
wat 'n wyser en net * p = 6;

51
00:04:32,810 --> 00:04:39,990
Soos ons gesien het met swap, kan jy nie 'n effektiewe ruil en 'n aparte funksie

52
00:04:39,990 --> 00:04:45,180
net verby die heelgetalle omdat alles in C is altyd verby waarde.

53
00:04:45,180 --> 00:04:48,360
Selfs wanneer jy pointers is verby jy verby waarde.

54
00:04:48,360 --> 00:04:51,940
Dit gebeur net so dat die waardes geheue adresse.

55
00:04:51,940 --> 00:05:00,770
So wanneer ek sê cat (p); ek verby die wyser in die funksie foo

56
00:05:00,770 --> 00:05:03,910
en dan cat * p = 6;

57
00:05:03,910 --> 00:05:08,600
So binnekant van daardie funksie, * p is nog steeds gelyk is aan x,

58
00:05:08,600 --> 00:05:12,720
maar ek kan nie gebruik x binnekant van daardie funksie, want dit is nie scoped binne daardie funksie.

59
00:05:12,720 --> 00:05:19,510
So * p = 6 is die enigste manier wat ek kan toegang tot 'n plaaslike veranderlike van 'n ander funksie.

60
00:05:19,510 --> 00:05:23,600
Of, goed, wysers is die enigste manier wat ek kan toegang tot 'n plaaslike veranderlike van 'n ander funksie.

61
00:05:23,600 --> 00:05:31,600
[Student] Kom ons sê jy wou 'n wyser om terug te keer. Hoe presies doen jy dit?

62
00:05:31,600 --> 00:05:44,270
[Bowden] Terug 'n wyser as iets soos int y = 3, terugkeer & y? >> [Student] Ja.

63
00:05:44,270 --> 00:05:48,480
[Bowden] Goed. Jy nooit moet doen nie. Dit is sleg.

64
00:05:48,480 --> 00:05:59,480
Ek dink ek sien in hierdie lesing skyfies jy begin sien hierdie hele diagram van die geheue

65
00:05:59,480 --> 00:06:02,880
waar hier jy het geheue adres 0

66
00:06:02,880 --> 00:06:09,550
en af ​​hier om jou geheue adres 4 gigs of 2 aan die 32.

67
00:06:09,550 --> 00:06:15,120
So dan het jy 'n paar dinge en 'n paar dinge en dan moet jy jou stapel

68
00:06:15,120 --> 00:06:21,780
en jy het jou hoop, wat jy net begin leer oor grootword.

69
00:06:21,780 --> 00:06:24,390
[Student] Is dit nie die hoop bo die stapel?

70
00:06:24,390 --> 00:06:27,760
>> Ja. Die hoop is op die top, is dit nie? >> [Student] Wel, hy het 0 bo-op.

71
00:06:27,760 --> 00:06:30,320
[Student] O, hy het 0 bo-op. >> [Student] O, okay.

72
00:06:30,320 --> 00:06:36,060
Disclaimer: Enigeplek met CS50 jy gaan om dit op hierdie manier te sien. >> [Student] Goed.

73
00:06:36,060 --> 00:06:40,290
Dit is net dat wanneer jy eers sien stapels,

74
00:06:40,290 --> 00:06:45,000
soos wanneer jy dink van 'n stapel wat jy dink van die stapel van dinge op die top van mekaar.

75
00:06:45,000 --> 00:06:50,810
So is ons geneig om dit om te draai om sodat die stapel is growing up soos 'n stapel normaalweg sou

76
00:06:50,810 --> 00:06:55,940
in plaas van die stapel hang af. >> [Student] Moenie hope tegnies grootword ook al?

77
00:06:55,940 --> 00:07:01,100
Dit hang af wat jy bedoel met grootword.

78
00:07:01,100 --> 00:07:04,010
Die stack en heap altyd in teenoorgestelde rigtings groei.

79
00:07:04,010 --> 00:07:09,420
Groei is altyd 'n stapel in die sin dat dit grootword

80
00:07:09,420 --> 00:07:12,940
na hoër geheue adresse, en die hoop groei

81
00:07:12,940 --> 00:07:17,260
in die sin dat dit groei tot laer geheue-adresse.

82
00:07:17,260 --> 00:07:20,250
Sodat die boonste 0 en die onderkant is 'n hoë geheue adresse.

83
00:07:20,250 --> 00:07:26,390
Hulle is albei groei, net in teenoorgestelde rigtings.

84
00:07:26,390 --> 00:07:29,230
[Student] Ek het net bedoel dat, omdat jy sê jy stapel op die bodem

85
00:07:29,230 --> 00:07:33,640
want dit lyk meer intuïtief, want vir die stapel op die top van 'n hoop om te begin,

86
00:07:33,640 --> 00:07:37,520
hoop is op die top van die self ook so that's - >> Ja.

87
00:07:37,520 --> 00:07:44,960
Jy moet ook dink die hoop as grootword en groter, maar die stapel meer so.

88
00:07:44,960 --> 00:07:50,280
So is die stapel is die een wat ons soort wil om te wys grootword.

89
00:07:50,280 --> 00:07:55,390
Maar oral waar jy kyk anders gaan adres 0 om te wys op die top

90
00:07:55,390 --> 00:07:59,590
en die hoogste geheue adres aan die onderkant, so dit is jou gebruiklike siening van die geheue.

91
00:07:59,590 --> 00:08:02,100
>> Het jy 'n vraag?

92
00:08:02,100 --> 00:08:04,270
[Student] Kan jy ons vertel meer omtrent die hoop?

93
00:08:04,270 --> 00:08:06,180
Ja. Ek sal in 'n tweede.

94
00:08:06,180 --> 00:08:12,220
Eerste, terug te gaan na waarom die terugkeer & y is 'n slegte ding,

95
00:08:12,220 --> 00:08:18,470
op die stapel jy 'n klomp van stapel rame wat verteenwoordig al die funksies

96
00:08:18,470 --> 00:08:20,460
wat geroep is.

97
00:08:20,460 --> 00:08:27,990
So vorige dinge te ignoreer, die top van jou stapel is altyd iets aan die hooffunksie

98
00:08:27,990 --> 00:08:33,090
want dit is die eerste funksie wat genoem word.

99
00:08:33,090 --> 00:08:37,130
En dan wanneer jy noem 'n ander funksie, is die stapel gaan af om te groei.

100
00:08:37,130 --> 00:08:41,640
So as ek noem 'n paar funksie, foo, en dit kry sy eie stapel raam,

101
00:08:41,640 --> 00:08:47,280
dit kan 'n paar funksie, bar noem dit kry sy eie stapel raam.

102
00:08:47,280 --> 00:08:49,840
En 'n bar kan wees rekursiewe en dit self kan noem,

103
00:08:49,840 --> 00:08:54,150
en sodat tweede oproep bar gaan sy eie stapel raam te kry.

104
00:08:54,150 --> 00:08:58,880
En so wat gaan in hierdie stapel rame is almal van die plaaslike veranderlikes

105
00:08:58,880 --> 00:09:03,450
en al die van die funksie argumente wat -

106
00:09:03,450 --> 00:09:08,730
Enige dinge wat plaaslik aan hierdie funksie scoped in hierdie stapel rame.

107
00:09:08,730 --> 00:09:21,520
Dus beteken dit dat wanneer ek sê iets soos bar is 'n funksie,

108
00:09:21,520 --> 00:09:29,270
Ek gaan net 'n heelgetal te verklaar en dan 'n wyser terug te keer na daardie heelgetal.

109
00:09:29,270 --> 00:09:33,790
So, waar y lewe?

110
00:09:33,790 --> 00:09:36,900
[Student] y woon in die bar. >> [Bowden] Ja.

111
00:09:36,900 --> 00:09:45,010
Iewers in hierdie klein vierkant van die geheue is 'n littler vierkant wat in die y.

112
00:09:45,010 --> 00:09:53,370
Wanneer ek terugkeer en y, ek 'n wyser terug na hierdie klein blokkie van die geheue.

113
00:09:53,370 --> 00:09:58,400
Maar dan wanneer 'n funksie opbrengste, kry sy stapel raam oopgespring die stapel af.

114
00:10:01,050 --> 00:10:03,530
En dit is waarom dit genoem stapel.

115
00:10:03,530 --> 00:10:06,570
Dit is soos die stapel data struktuur, as jy weet wat dit is.

116
00:10:06,570 --> 00:10:11,580
Of selfs soos 'n stapel van die bak is altyd die voorbeeld,

117
00:10:11,580 --> 00:10:16,060
hoof gaan om te gaan op die bodem, dan is die eerste funksie wat jy noem gaan om te gaan op die top van dat,

118
00:10:16,060 --> 00:10:20,400
en jy kan nie terug te kry na die hoof totdat jy terugkeer van al die funksies wat geroep is

119
00:10:20,400 --> 00:10:22,340
wat geplaas is op die top van dit.

120
00:10:22,340 --> 00:10:28,650
>> [Student] So as jy gedoen het nie die standaard van die & y, daardie waarde is onderhewig aan verandering sonder kennisgewing.

121
00:10:28,650 --> 00:10:31,290
Ja, it's - >> [student] Dit kan wees oorskryf. >> Ja.

122
00:10:31,290 --> 00:10:34,660
Dit is heeltemal - As jy probeer en -

123
00:10:34,660 --> 00:10:38,040
Dit sou ook 'n int * bar, want dit is 'n wyser terug,

124
00:10:38,040 --> 00:10:41,310
so sy terugkeer tipe int *.

125
00:10:41,310 --> 00:10:46,500
As jy probeer om die terugkeer waarde van hierdie funksie te gebruik, dit is undefined gedrag

126
00:10:46,500 --> 00:10:51,770
want dit wyser wys na slegte geheue. >> [Student] Goed.

127
00:10:51,770 --> 00:11:01,250
So, wat as jy byvoorbeeld verklaar int * y = malloc (sizeof (int))?

128
00:11:01,250 --> 00:11:03,740
Dit is beter. Ja.

129
00:11:03,740 --> 00:11:07,730
[Student] Ons het gepraat oor hoe, wanneer ons sleep dinge aan ons recycle bin

130
00:11:07,730 --> 00:11:11,750
hulle eintlik nie uitgewis is; ons net verloor hul wysers.

131
00:11:11,750 --> 00:11:15,550
Dus, in hierdie geval het ons vee eintlik die waarde of is dit nog daar in die geheue?

132
00:11:15,550 --> 00:11:19,130
Vir die grootste deel, dit gaan nog steeds daar wees.

133
00:11:19,130 --> 00:11:24,220
Maar laat ons sê ons gebeur 'n ander funksie, Baz te roep.

134
00:11:24,220 --> 00:11:28,990
Baz gaan sy eie stapel te kry hier.

135
00:11:28,990 --> 00:11:31,470
Dit gaan word vervang al hierdie dinge,

136
00:11:31,470 --> 00:11:34,180
en dan as jy later probeer en gebruik die wyser wat jy het voor,

137
00:11:34,180 --> 00:11:35,570
dit gaan nie om dieselfde waarde te wees.

138
00:11:35,570 --> 00:11:38,150
Dit gaan net verander omdat jy die funksie genoem Baz.

139
00:11:38,150 --> 00:11:43,080
[Student] Maar het ons nie, sal ons kry nog steeds 3?

140
00:11:43,080 --> 00:11:44,990
[Bowden] In alle waarskynlikheid, jy wil.

141
00:11:44,990 --> 00:11:49,670
Maar jy kan nie staatmaak op daardie. C sê net undefined gedrag.

142
00:11:49,670 --> 00:11:51,920
>> [Student] O, dit doen nie. Okay.

143
00:11:51,920 --> 00:11:58,190
So wanneer jy wil 'n wyser om terug te keer, dit is waar malloc kom in gebruik is.

144
00:12:00,930 --> 00:12:15,960
Ek eintlik skryf net terug malloc (3 * sizeof (int)).

145
00:12:17,360 --> 00:12:24,050
Ons gaan oor malloc meer in 'n tweede, maar die idee van malloc is al van jou plaaslike veranderlikes

146
00:12:24,050 --> 00:12:26,760
altyd op die stapel.

147
00:12:26,760 --> 00:12:31,570
Enigiets wat malloced gaan op die wal, en dit sal vir ewig en altyd op die hoop

148
00:12:31,570 --> 00:12:34,490
totdat jy dit uitdruklik bevry.

149
00:12:34,490 --> 00:12:42,130
So dit beteken dat wanneer jy malloc iets, dit gaan om te oorleef na die funksie opbrengste.

150
00:12:42,130 --> 00:12:46,800
[Student] Sal dit oorleef nadat die program stop hardloop? >> No.

151
00:12:46,800 --> 00:12:53,180
Okay, so dit gaan om daar te wees tot die program is om al die pad hardloop. >> Ja.

152
00:12:53,180 --> 00:12:57,510
Ons kan gaan oor die besonderhede van wat gebeur wanneer die program stop.

153
00:12:57,510 --> 00:13:02,150
Jy dalk nodig het om my te herinner, maar dit is 'n aparte ding heeltemal.

154
00:13:02,150 --> 00:13:04,190
[Student] So malloc 'n wyser skep? >> Ja.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [student] Ek dink malloc klassifiseer 'n blok van die geheue wat 'n wyser kan gebruik.

156
00:13:15,400 --> 00:13:19,610
[Bowden] Ek wil dat die diagram weer. >> [Student] So hierdie funksie werk, al is?

157
00:13:19,610 --> 00:13:26,430
[Student] Ja, malloc klassifiseer 'n blok van die geheue wat jy kan gebruik,

158
00:13:26,430 --> 00:13:30,470
en dan is dit gee die adres van die eerste blok van daardie geheue.

159
00:13:30,470 --> 00:13:36,750
>> [Bowden] Ja. So wanneer jy malloc, jy gryp n blok van die geheue

160
00:13:36,750 --> 00:13:38,260
wat tans in die hoop.

161
00:13:38,260 --> 00:13:43,040
As die hoop te klein is, dan is die hoop is net gaan om te groei, en dit groei in hierdie rigting.

162
00:13:43,040 --> 00:13:44,650
So kom ons sê die hoop is te klein.

163
00:13:44,650 --> 00:13:49,960
Dan is dit oor 'n bietjie om te groei en 'n wyser terug te keer na hierdie blok wat net gegroei.

164
00:13:49,960 --> 00:13:55,130
Wanneer jy free stuff, het jy meer ruimte in die hoop jy maak,

165
00:13:55,130 --> 00:14:00,030
so dan 'n later bel om te malloc kan onthou dat die geheue wat jy voorheen bevry.

166
00:14:00,030 --> 00:14:09,950
Die belangrikste ding oor malloc en gratis is dat dit gee jou volle beheer

167
00:14:09,950 --> 00:14:12,700
oor die leeftyd van hierdie geheue blokke.

168
00:14:12,700 --> 00:14:15,420
Globale veranderlikes is altyd lewe.

169
00:14:15,420 --> 00:14:18,500
Plaaslike veranderlikes is lewendig in hul omvang.

170
00:14:18,500 --> 00:14:22,140
So gou as jy verby 'n krullerige brace, die plaaslike veranderlikes is dood.

171
00:14:22,140 --> 00:14:28,890
Malloced geheue is lewendig wanneer jy dit wil hê om te leef

172
00:14:28,890 --> 00:14:33,480
en dan word vrygestel wanneer jy sê dit om vrygestel te word.

173
00:14:33,480 --> 00:14:38,420
Dit is eintlik die enigste 3 tipes geheue, regtig.

174
00:14:38,420 --> 00:14:41,840
Daar is outomatiese geheue-bestuur, wat is die stapel.

175
00:14:41,840 --> 00:14:43,840
Dinge gebeur outomaties vir jou.

176
00:14:43,840 --> 00:14:46,910
Wanneer jy sê int x, word geheue geallokeer vir int x.

177
00:14:46,910 --> 00:14:51,630
Wanneer X gaan uit van die omvang, is geheue herwin vir x.

178
00:14:51,630 --> 00:14:54,790
Dan is daar dinamiese geheue-bestuur, en dit is wat malloc is,

179
00:14:54,790 --> 00:14:56,740
wat is wanneer jy beheer.

180
00:14:56,740 --> 00:15:01,290
Jy dinamiese besluit wanneer geheue moet en moet nie toegeken word.

181
00:15:01,290 --> 00:15:05,050
En dan is daar statiese, wat beteken net dat dit vir ewig leef,

182
00:15:05,050 --> 00:15:06,610
wat is wat globale veranderlikes is.

183
00:15:06,610 --> 00:15:10,240
Hulle is maar net altyd in die geheue.

184
00:15:10,960 --> 00:15:12,760
>> Vrae?

185
00:15:14,490 --> 00:15:17,230
[Student] Kan jy definieer 'n blok net deur die gebruik van kode tussen krulhakies

186
00:15:17,230 --> 00:15:21,220
maar nie om te het 'n IF stelling of 'n rukkie verklaring of iets soos dit?

187
00:15:21,220 --> 00:15:29,130
Jy kan 'n blok te definieer soos in 'n funksie, maar dit het krullerige draadjies.

188
00:15:29,130 --> 00:15:32,100
[Student] So jy kan net nie soos 'n ewekansige paar van die kode tussen krulhakies in jou kode

189
00:15:32,100 --> 00:15:35,680
wat plaaslike veranderlikes? >> Ja, jy kan.

190
00:15:35,680 --> 00:15:45,900
Binne van int bar wat ons kan hê int y = 3;}.

191
00:15:45,900 --> 00:15:48,440
Wat veronderstel is om hier te wees.

192
00:15:48,440 --> 00:15:52,450
Maar wat definieer die omvang van int y heeltemal.

193
00:15:52,450 --> 00:15:57,320
Na die tweede krullerige brace, kan y nie meer gebruik word.

194
00:15:57,910 --> 00:16:00,630
Jy byna nooit doen nie, though.

195
00:16:02,940 --> 00:16:07,370
Om terug na wat gebeur wanneer 'n program eindig,

196
00:16:07,370 --> 00:16:18,760
daar is 'n soort van 'n wanopvatting / 1/2 leuen wat ons gee om net dinge makliker te maak.

197
00:16:18,760 --> 00:16:24,410
Ons vertel jou dat wanneer jy geheue toeken

198
00:16:24,410 --> 00:16:29,860
jy die toekenning van sommige stuk van RAM vir daardie veranderlike.

199
00:16:29,860 --> 00:16:34,190
Maar jy regtig nie direk raak RAM ooit in jou programme.

200
00:16:34,190 --> 00:16:37,490
As jy dink oor dit, hoe ek nader -

201
00:16:37,490 --> 00:16:44,330
En eintlik, as jy gaan deur in GDB jy sien dieselfde ding.

202
00:16:51,120 --> 00:16:57,590
Ongeag van hoeveel keer jy die program loop of watter program jy loop,

203
00:16:57,590 --> 00:16:59,950
die stapel is altyd gaan om te begin -

204
00:16:59,950 --> 00:17:06,510
jy altyd gaan veranderlikes rondom adres oxbffff iets om te sien.

205
00:17:06,510 --> 00:17:09,470
Dit is gewoonlik iewers in daardie streek.

206
00:17:09,470 --> 00:17:18,760
Maar hoe 2 programme kan moontlik verwysings na dieselfde geheue?

207
00:17:20,640 --> 00:17:27,650
[Student] Daar is 'n paar arbitrêre aanwysing van waar oxbfff veronderstel is om te wees op die RAM

208
00:17:27,650 --> 00:17:31,320
wat eintlik kan wees op verskillende plekke, afhangende van wanneer die funksie is geroep.

209
00:17:31,320 --> 00:17:35,920
Ja. Die term is virtuele geheue.

210
00:17:35,920 --> 00:17:42,250
Die idee is dat elke enkele proses, elke enkele program wat loop op jou rekenaar

211
00:17:42,250 --> 00:17:49,450
het sy eie - laat ons veronderstel 32 stukkies - heeltemal onafhanklik adres ruimte.

212
00:17:49,450 --> 00:17:51,590
Dit is die adres ruimte.

213
00:17:51,590 --> 00:17:56,220
Dit het sy eie heeltemal onafhanklik 4 GB om te gebruik.

214
00:17:56,220 --> 00:18:02,220
>> So as jy hardloop 2-programme gelyktydig, is hierdie program sien 4 GB vir homself,

215
00:18:02,220 --> 00:18:04,870
hierdie program sien 4 GB vir homself,

216
00:18:04,870 --> 00:18:07,720
en dit is onmoontlik vir hierdie program te dereference 'n wyser

217
00:18:07,720 --> 00:18:10,920
en eindig met die geheue van hierdie program.

218
00:18:10,920 --> 00:18:18,200
En wat virtuele geheue is, is 'n afbeelding van 'n prosesse adres ruimte

219
00:18:18,200 --> 00:18:20,470
werklike dinge op RAM.

220
00:18:20,470 --> 00:18:22,940
So dit is aan jou bedryfstelsel om te weet dat,

221
00:18:22,940 --> 00:18:28,080
hey, wanneer hierdie man dereferences pointer oxbfff, wat beteken dat baie

222
00:18:28,080 --> 00:18:31,040
dat hy wil RAM byte 1000,

223
00:18:31,040 --> 00:18:38,150
terwyl as hierdie program dereferences oxbfff, hy wil regtig RAM byte 10.000.

224
00:18:38,150 --> 00:18:41,590
Hulle kan arbitrêr ver uitmekaar wees.

225
00:18:41,590 --> 00:18:48,730
Dit is selfs waar van die dinge wat in 'n enkele prosesse adres ruimte.

226
00:18:48,730 --> 00:18:54,770
So asof dit sien al 4 GB vir homself nie, maar laat ons sê -

227
00:18:54,770 --> 00:18:57,290
[Student] Is elke enkele proses -

228
00:18:57,290 --> 00:19:01,350
Kom ons sê jy het 'n rekenaar met slegs 4 GB RAM.

229
00:19:01,350 --> 00:19:06,430
Is elke enkele proses sien die hele 4 GB? >> Ja.

230
00:19:06,430 --> 00:19:13,060
Maar die 4 GB dit sien, is 'n leuen.

231
00:19:13,060 --> 00:19:20,460
Dit dink net dit het al die geheue omdat dit nie weet enige ander proses bestaan.

232
00:19:20,460 --> 00:19:28,140
Dit sal net soveel geheue gebruik as wat dit werklik nodig het.

233
00:19:28,140 --> 00:19:32,340
Die bedryfstelsel is nie van plan RAM te gee aan hierdie proses

234
00:19:32,340 --> 00:19:35,750
as dit nie met behulp van 'n geheue in hierdie hele streek.

235
00:19:35,750 --> 00:19:39,300
Dit gaan nie om te gee dit geheue vir daardie streek.

236
00:19:39,300 --> 00:19:54,780
Maar die idee is dat ek probeer om te dink - ek kan nie dink van 'n analogie.

237
00:19:54,780 --> 00:19:56,780
Analogieë is hard.

238
00:19:57,740 --> 00:20:02,700
Een van die kwessies van virtuele geheue of een van die dinge wat dit oplos

239
00:20:02,700 --> 00:20:06,810
is dat prosesse moet heeltemal onbewus van mekaar.

240
00:20:06,810 --> 00:20:12,140
En so kan jy 'n program skryf dat net dereferences enige pointer,

241
00:20:12,140 --> 00:20:19,340
net soos 'n program skryf wat sê * (ox1234),

242
00:20:19,340 --> 00:20:22,890
en dit is ontwysing geheue adres 1234.

243
00:20:22,890 --> 00:20:28,870
>> Maar dit is tot die bedryfstelsel wat 1234 wyse te vertaal.

244
00:20:28,870 --> 00:20:33,960
So as 1234 gebeur met 'n geldige geheue-adres vir hierdie proses,

245
00:20:33,960 --> 00:20:38,800
soos dit op die stapel of iets, dan sal dit die waarde van daardie geheue adres terug

246
00:20:38,800 --> 00:20:41,960
so ver as die proses weet.

247
00:20:41,960 --> 00:20:47,520
Maar as 1234 is nie 'n geldige adres, soos dit gebeur tot grond

248
00:20:47,520 --> 00:20:52,910
in sommige klein stuk van die geheue hier wat is buite die stapel en buite die hoop

249
00:20:52,910 --> 00:20:57,200
en jy het nie regtig gebruik word wat dan, dit is wanneer jy dinge soos segfaults

250
00:20:57,200 --> 00:21:00,260
want jy raak geheue wat jy nie moet raak.

251
00:21:07,180 --> 00:21:09,340
Dit is ook waar -

252
00:21:09,340 --> 00:21:15,440
'N 32-bis-stelsel, 32 stukkies beteken dat jy het 32 ​​bits 'n geheue adres te definieer.

253
00:21:15,440 --> 00:21:22,970
Dit is waarom pointers is 8 bytes omdat 32 stukkies 8 bytes - of 4 grepe.

254
00:21:22,970 --> 00:21:25,250
Pointers is 4 grepe.

255
00:21:25,250 --> 00:21:33,680
So wanneer jy sien 'n wyser soos oxbfffff, wat -

256
00:21:33,680 --> 00:21:40,080
Binne enige gegewe program wat jy kan net bou enige arbitrêre pointer,

257
00:21:40,080 --> 00:21:46,330
oral van ox0 te bees 8 f's - ffffffff.

258
00:21:46,330 --> 00:21:49,180
[Student] Het jy nie sê hulle is 'n 4 bytes? >> Ja.

259
00:21:49,180 --> 00:21:52,730
[Student] Dan sal elke byte - >> [Bowden] heksadesimaal.

260
00:21:52,730 --> 00:21:59,360
Heksadesimale - 5, 6, 7, 8. So pointers jy gaan altyd sien in heksadesimaal.

261
00:21:59,360 --> 00:22:01,710
Dit is net hoe ons klassifiseer wysers.

262
00:22:01,710 --> 00:22:05,240
Elke 2 syfers van heksadesimaal is 1 byte.

263
00:22:05,240 --> 00:22:09,600
So daar gaan wees 8 heksadesimale syfers vir 4 grepe.

264
00:22:09,600 --> 00:22:14,190
So elke enkele wyser op 'n 32-bis-stelsel gaan wees 4 bytes,

265
00:22:14,190 --> 00:22:18,550
wat beteken dat jy in jou proses enige arbitrêre 4 bytes kan konstrueer

266
00:22:18,550 --> 00:22:20,550
en maak 'n wyser uit dit uit,

267
00:22:20,550 --> 00:22:32,730
wat beteken dat, so ver as wat dit is bewus is, kan dit 'n hele 2 aan die 32 grepe van die geheue te spreek.

268
00:22:32,730 --> 00:22:34,760
Selfs al is dit nie regtig toegang tot daardie,

269
00:22:34,760 --> 00:22:40,190
selfs as jou rekenaar slegs 512 megagrepe het, dink dit het dat 'n groot geheue.

270
00:22:40,190 --> 00:22:44,930
En die bedryfstelsel is slim genoeg dat dit net sal ken wat jy werklik nodig het.

271
00:22:44,930 --> 00:22:49,630
Dit maak net nie gaan nie, oh, 'n nuwe proses: 4 gigs.

272
00:22:49,630 --> 00:22:51,930
>> Ja. >> [Student] Wat beteken die os is die inkomste baie beteken? Hoekom skryf jy dit?

273
00:22:51,930 --> 00:22:54,980
Dit is net die simbool vir heksadesimaal.

274
00:22:54,980 --> 00:22:59,590
As jy 'n nommer begin met die os, die opeenvolgende dinge heksadesimale.

275
00:23:01,930 --> 00:23:05,760
[Student] Jy het verduidelik oor wat gebeur wanneer 'n program eindig. >> Ja.

276
00:23:05,760 --> 00:23:09,480
Wat gebeur wanneer 'n program eindig, is die bedryfstelsel

277
00:23:09,480 --> 00:23:13,600
net geweet die afbeeldings dat dit vir hierdie adresse, en dit is dit.

278
00:23:13,600 --> 00:23:17,770
Die bedryfstelsel kan nou net dat die geheue na 'n ander program om te gebruik.

279
00:23:17,770 --> 00:23:19,490
[Student] Goed.

280
00:23:19,490 --> 00:23:24,800
So wanneer jy toeken iets op die hoop of die stapel of globale veranderlikes of enigiets,

281
00:23:24,800 --> 00:23:27,010
hulle almal net sodra die program eindig verdwyn

282
00:23:27,010 --> 00:23:32,120
omdat die bedryfstelsel is nou vry om daardie geheue te gee aan enige ander proses.

283
00:23:32,120 --> 00:23:35,150
[Student] Selfs al is daar waarskynlik nog waardes wat geskryf is in? >> Ja.

284
00:23:35,150 --> 00:23:37,740
Die waardes is waarskynlik nog steeds daar.

285
00:23:37,740 --> 00:23:41,570
Dit is net gaan moeilik wees om te kry op hulle.

286
00:23:41,570 --> 00:23:45,230
Dit is veel meer moeilik om te kry op hulle as wat dit is om te kry by 'n verwyder lêer

287
00:23:45,230 --> 00:23:51,450
omdat die geskrap lêer soort van daar sit vir 'n lang tyd en die hardeskyf is 'n baie groter.

288
00:23:51,450 --> 00:23:54,120
So dit gaan die verskillende dele van die geheue te oorskryf

289
00:23:54,120 --> 00:23:58,640
voordat dit gebeur die stuk van die geheue dat lêer wat gebruik word om op te oorskryf.

290
00:23:58,640 --> 00:24:04,520
Maar die hoof geheue, geheue, jy siklus deur middel van 'n baie vinniger,

291
00:24:04,520 --> 00:24:08,040
so dit gaan om baie vinnig te oorskryf.

292
00:24:10,300 --> 00:24:13,340
Vrae oor hierdie of enige iets anders?

293
00:24:13,340 --> 00:24:16,130
[Student] Ek het vrae oor 'n ander onderwerp. >> Goed.

294
00:24:16,130 --> 00:24:19,060
Is daar iemand vrae het oor hierdie?

295
00:24:20,170 --> 00:24:23,120
>> Okay. Ander onderwerp. >> [Student] Goed.

296
00:24:23,120 --> 00:24:26,550
Ek gaan deur 'n paar van die praktyk te toets,

297
00:24:26,550 --> 00:24:30,480
en in een van hulle was in gesprek oor die sizeof

298
00:24:30,480 --> 00:24:35,630
en die waarde wat dit terugkeer of verskillende veranderlike tipes. >> Ja.

299
00:24:35,630 --> 00:24:45,060
En dit het gesê dat beide int en lang beide opbrengs 4 so, hulle is beide 4 bytes lank.

300
00:24:45,060 --> 00:24:48,070
Is daar 'n verskil tussen 'n int en 'n lang, of is dit dieselfde ding?

301
00:24:48,070 --> 00:24:50,380
Ja, daar is 'n verskil.

302
00:24:50,380 --> 00:24:52,960
Die C-standaard -

303
00:24:52,960 --> 00:24:54,950
Ek waarskynlik gaan opfok.

304
00:24:54,950 --> 00:24:58,800
Die C-standaard is net soos wat C is, die amptelike dokumentasie van C.

305
00:24:58,800 --> 00:25:00,340
Dit is wat dit sê.

306
00:25:00,340 --> 00:25:08,650
So sê die C-standaard net dat 'n kar sal vir ewig en altyd 1 byte.

307
00:25:10,470 --> 00:25:19,040
Alles daarna - 'n kort is altyd net gedefinieer as groter as of gelyk aan 'n char.

308
00:25:19,040 --> 00:25:23,010
Dit kan wees streng groter as, maar nie positief nie.

309
00:25:23,010 --> 00:25:31,940
'N int is net gedefinieer as groter as of gelyk aan 'n kort.

310
00:25:31,940 --> 00:25:36,210
En 'n lang is net gedefinieer as groter as of gelyk aan 'n int.

311
00:25:36,210 --> 00:25:41,600
En 'n lang lang groter as of gelyk aan 'n lang.

312
00:25:41,600 --> 00:25:46,610
Dus is die enigste ding wat die C-standaard bepaal is die relatiewe ordening van alles.

313
00:25:46,610 --> 00:25:54,880
Die werklike bedrag van die geheue dat dinge neem, is oor die algemeen tot implementering,

314
00:25:54,880 --> 00:25:57,640
maar dit is redelik goed gedefinieer op hierdie punt. >> [Student] Goed.

315
00:25:57,640 --> 00:26:02,490
So kortbroek is byna altyd gaan 2 grepe.

316
00:26:04,920 --> 00:26:09,950
Ints is byna altyd gaan wees 4 grepe.

317
00:26:12,070 --> 00:26:15,340
Long longs is byna altyd gaan wees 8 grepe.

318
00:26:17,990 --> 00:26:23,160
En verlang, dit hang af of jy met behulp van 'n 32-bis of 'n 64-bis-stelsel.

319
00:26:23,160 --> 00:26:27,450
So 'n lang gaan stem ooreen met die tipe van die stelsel.

320
00:26:27,450 --> 00:26:31,920
As jy met behulp van 'n 32-bis-stelsel soos die Appliance, gaan dit 4 bytes.

321
00:26:34,530 --> 00:26:42,570
As jy met behulp van 'n 64-bis soos 'n baie van die onlangse rekenaars, gaan dit 8 grepe.

322
00:26:42,570 --> 00:26:45,230
>> Ints is byna altyd 4 grepe op hierdie punt.

323
00:26:45,230 --> 00:26:47,140
Long longs is byna altyd 8 grepe.

324
00:26:47,140 --> 00:26:50,300
In die verlede, ints gebruik net 2 grepe.

325
00:26:50,300 --> 00:26:56,840
Maar let op dat dit heeltemal voldoen aan al van hierdie verhoudings van meer as en gelyk aan.

326
00:26:56,840 --> 00:27:01,280
So lank is perfek toegelaat word om die dieselfde grootte as 'n heelgetal wees,

327
00:27:01,280 --> 00:27:04,030
En dit is ook toegelaat om die dieselfde grootte as 'n lang lang.

328
00:27:04,030 --> 00:27:11,070
En dit gebeur net so te wees dat 99,999% van stelsels, dit gaan gelyk wees aan

329
00:27:11,070 --> 00:27:15,800
óf 'n int of 'n lang lang. Dit hang net op 32-bis of 64-bis. >> [Student] Goed.

330
00:27:15,800 --> 00:27:24,600
In dryf, hoe is die desimale punt aangewys in terme van stukkies?

331
00:27:24,600 --> 00:27:27,160
Soos binêre? >> Ja.

332
00:27:27,160 --> 00:27:30,570
Jy hoef nie om te weet dat vir CS50.

333
00:27:30,570 --> 00:27:32,960
Jy hoef nie eens leer dat in 61.

334
00:27:32,960 --> 00:27:37,350
Jy het nie regtig leer in enige kursus.

335
00:27:37,350 --> 00:27:42,740
Dit is net 'n voorstelling.

336
00:27:42,740 --> 00:27:45,440
Ek vergeet die presiese bietjie toewysings.

337
00:27:45,440 --> 00:27:53,380
Die idee van die floating point is wat jy ken 'n spesifieke aantal bisse te stel -

338
00:27:53,380 --> 00:27:56,550
Basies, alles is in wetenskaplike notasie.

339
00:27:56,550 --> 00:28:05,600
So jy ken 'n spesifieke aantal bisse die getal self voor te stel soos 1,2345.

340
00:28:05,600 --> 00:28:10,200
Ek kan nooit met meer as 5 syfers verteenwoordig 'n aantal.

341
00:28:12,200 --> 00:28:26,300
Dan moet jy ook die toekenning van 'n spesifieke aantal bisse, sodat dit is geneig om te wees soos

342
00:28:26,300 --> 00:28:32,810
jy kan net tot 'n sekere aantal, soos wat is die grootste eksponent wat jy kan hê,

343
00:28:32,810 --> 00:28:36,190
en jy kan net gaan af na 'n sekere eksponent,

344
00:28:36,190 --> 00:28:38,770
soos wat is die kleinste eksponent wat jy kan hê.

345
00:28:38,770 --> 00:28:44,410
>> Ek onthou nie die presiese manier waarop bisse word opgedra aan al hierdie waardes,

346
00:28:44,410 --> 00:28:47,940
maar 'n sekere aantal bisse is toegewyd tot 1,2345,

347
00:28:47,940 --> 00:28:50,930
nog 'n sekere aantal bisse word gewy aan die eksponent,

348
00:28:50,930 --> 00:28:55,670
en dit is net moontlik om 'n eksponent van 'n sekere grootte te stel.

349
00:28:55,670 --> 00:29:01,100
[Student] En 'n dubbele? Is dit soos 'n ekstra lang float? >> Ja.

350
00:29:01,100 --> 00:29:07,940
Dit is dieselfde ding as 'n float behalwe nou jy gebruik 8 grepe in plaas van 4 grepe.

351
00:29:07,940 --> 00:29:11,960
Nou sal jy in staat wees om 9 syfers of 10 syfers te gebruik,

352
00:29:11,960 --> 00:29:16,630
en dit sal in staat wees om te gaan na 300 in plaas van 100. >> [Student] Goed.

353
00:29:16,630 --> 00:29:21,550
En vlotte is ook 4 grepe. >> Ja.

354
00:29:21,550 --> 00:29:27,520
Wel, weer, dit hang af waarskynlik algeheel op algemene implementering,

355
00:29:27,520 --> 00:29:30,610
maar dryf is 4 grepe, dubbelspel is 8.

356
00:29:30,610 --> 00:29:33,440
Dubbelspel is dubbel genoem omdat hulle is dubbel die grootte van dryf.

357
00:29:33,440 --> 00:29:38,380
[Student] Goed. En daar is verdubbel dubbel? >> Daar is nie.

358
00:29:38,380 --> 00:29:43,660
Ek dink - >> [student] Soos lang longs? >> Ja. Ek dink nie so nie. Ja.

359
00:29:43,660 --> 00:29:45,950
[Student] Op verlede jaar se toets was daar 'n vraag oor die hooffunksie

360
00:29:45,950 --> 00:29:49,490
om deel te wees van jou program.

361
00:29:49,490 --> 00:29:52,310
Die antwoord was dat dit nie om deel te wees van jou program.

362
00:29:52,310 --> 00:29:55,100
In watter situasie? Dit is wat ek gesien het.

363
00:29:55,100 --> 00:29:59,090
[Bowden] Dit blyk - >> [student] Watter situasie?

364
00:29:59,090 --> 00:30:02,880
Het jy die probleem? >> [Student] Ja, ek kan beslis trek dit.

365
00:30:02,880 --> 00:30:07,910
Dit hoef nie te wees nie, tegnies, maar basies is dit gaan wees.

366
00:30:07,910 --> 00:30:10,030
[Student] Ek het iemand gesien wat op 'n ander jaar.

367
00:30:10,030 --> 00:30:16,220
Dit was soos 'Waar of Onwaar: 'n Geldige >> O, 'n C-lêer?

368
00:30:16,220 --> 00:30:18,790
[Student] Enige c-lêer moet - [beide praat in 'n keer - onverstaanbaar]

369
00:30:18,790 --> 00:30:21,120
Okay. So dit is apart.

370
00:30:21,120 --> 00:30:26,800
>> 'N c-lêer moet net funksies te bevat.

371
00:30:26,800 --> 00:30:32,400
Jy kan stel 'n lêer in die masjien-kode, binêre, ongeag,

372
00:30:32,400 --> 00:30:36,620
sonder dat dit uitvoerbaar nie.

373
00:30:36,620 --> 00:30:39,420
'N Geldige uitvoerbare moet 'n hoof funksie.

374
00:30:39,420 --> 00:30:45,460
Jy kan skryf 100 funksies in 1 lêer, maar geen hoof

375
00:30:45,460 --> 00:30:48,800
en dan stel dat down binêre,

376
00:30:48,800 --> 00:30:54,460
dan moet jy 'n ander lêer wat slegs belangrikste skryf, maar dit noem 'n klomp van hierdie funksies

377
00:30:54,460 --> 00:30:56,720
in hierdie binêre lêer hier.

378
00:30:56,720 --> 00:31:01,240
En so wanneer jy die uitvoerbare maak, dit is wat die koppelingshistoon doen

379
00:31:01,240 --> 00:31:05,960
is dit kombineer hierdie 2 binêre lêers in 'n uitvoerbare.

380
00:31:05,960 --> 00:31:11,400
So 'n C-lêer hoef nie 'n hoof funksie te hê.

381
00:31:11,400 --> 00:31:19,220
En op groot-kode basisse wat jy sal sien duisende c lêers en 1 hoof lêer.

382
00:31:23,960 --> 00:31:26,110
Nog vrae?

383
00:31:29,310 --> 00:31:31,940
[Student] Daar was 'n ander vraag.

384
00:31:31,940 --> 00:31:36,710
Daar word gesê dat maak, is 'n vertaler. WAAR of ONWAAR?

385
00:31:36,710 --> 00:31:42,030
En die antwoord was vals, en ek verstaan ​​hoekom dit is nie soos kletteren.

386
00:31:42,030 --> 00:31:44,770
Maar wat noem ons maak as dit nie?

387
00:31:44,770 --> 00:31:49,990
Maak is basies net - ek kan sien presies wat dit noem dit.

388
00:31:49,990 --> 00:31:52,410
Maar dit loop net bevele.

389
00:31:53,650 --> 00:31:55,650
Maak.

390
00:31:58,240 --> 00:32:00,870
Ek kan trek hierdie up. Ja.

391
00:32:10,110 --> 00:32:13,180
O, ja. Maak doen ook.

392
00:32:13,180 --> 00:32:17,170
Dit sê die doel van die fabrikaat nut is om outomaties te bepaal

393
00:32:17,170 --> 00:32:19,610
wat stukkies van 'n groot program moet word gehercompileerd

394
00:32:19,610 --> 00:32:22,350
en die opdragte uitreik om hulle te hercompileren.

395
00:32:22,350 --> 00:32:27,690
Jy kan maak maak lêers wat absoluut groot.

396
00:32:27,690 --> 00:32:33,210
Maak kyk na die tyd stempels van lêers en, soos ons vantevore gesê het,

397
00:32:33,210 --> 00:32:36,930
jy kan stel individuele lêers af, en dit is nie totdat jy by die koppelingshistoon

398
00:32:36,930 --> 00:32:39,270
dat hulle saam in 'n uitvoerbare.

399
00:32:39,270 --> 00:32:43,810
So as jy het 10 verskillende lêers en jy maak 'n verandering aan 1 van hulle,

400
00:32:43,810 --> 00:32:47,870
dan Watter maak is gaan om te doen is net heropstel dat 1 lêer

401
00:32:47,870 --> 00:32:50,640
en dan relink alles saam.

402
00:32:50,640 --> 00:32:53,020
Maar dit is baie dommer as dit.

403
00:32:53,020 --> 00:32:55,690
Dit is vir u om te definieer dat dit is wat dit moet doen.

404
00:32:55,690 --> 00:32:59,560
Dit by verstek die vermoë het om hierdie tyd stempel dinge te erken,

405
00:32:59,560 --> 00:33:03,220
maar jy kan 'n fabrikaat lêer skryf om iets te doen.

406
00:33:03,220 --> 00:33:09,150
Jy kan skryf 'n maak-lêer, sodat wanneer jy tik maak dit net cd's na 'n ander gids.

407
00:33:09,150 --> 00:33:15,560
Ek was gefrustreerd omdat ek ryg alles binnekant van my Appliance

408
00:33:15,560 --> 00:33:21,740
en dan sal ek sien die PDF van die Mac.

409
00:33:21,740 --> 00:33:30,720
>> So ek gaan Finder en ek kan gaan doen, Connect met die bediener

410
00:33:30,720 --> 00:33:36,950
en die bediener Ek verbind my Appliance, en dan het ek die PDF

411
00:33:36,950 --> 00:33:40,190
wat kry saamgestel deur LaTeX.

412
00:33:40,190 --> 00:33:49,320
Maar ek is gefrustreerd omdat elke enkele keer wat ek nodig het om die PDF te verfris,

413
00:33:49,320 --> 00:33:53,900
Ek het om dit te kopieer na 'n spesifieke gids wat dit kan toegang tot

414
00:33:53,900 --> 00:33:57,710
en dit is om irriterende.

415
00:33:57,710 --> 00:34:02,650
So in plaas ek 'n make-lêer, wat jy het om te bepaal hoe dit maak dinge geskryf het.

416
00:34:02,650 --> 00:34:06,130
Hoe maak jy in hierdie PDF LaTeX.

417
00:34:06,130 --> 00:34:10,090
Net soos enige ander fabrikaat lêer - of ek dink jy nie gesien het nie die fabrikaat lêers,

418
00:34:10,090 --> 00:34:13,510
maar ons het in die Appliance 'n globale fabrikaat lêer wat net sê,

419
00:34:13,510 --> 00:34:16,679
as jy die opstel van 'n C-lêer, gebruik kletteren.

420
00:34:16,679 --> 00:34:20,960
En so hier in my fabrikaat lêer wat ek maak wat ek sê,

421
00:34:20,960 --> 00:34:25,020
hierdie lêer wat jy gaan om te wil hê om saam te stel met PDF LaTeX.

422
00:34:25,020 --> 00:34:27,889
En dus is dit PDF LaTeX wat doen die opstel.

423
00:34:27,889 --> 00:34:31,880
Maak, is nie die opstel van. Dit is net met hierdie opdragte in die volgorde wat ek gespesifiseer.

424
00:34:31,880 --> 00:34:36,110
So is dit loop PDF LaTeX, kopieer dit na die gids wat ek wil dit gekopieer word,

425
00:34:36,110 --> 00:34:38,270
dit cd's na die gids en doen ander dinge,

426
00:34:38,270 --> 00:34:42,380
maar al wat dit doen word erken wanneer 'n lêer verander,

427
00:34:42,380 --> 00:34:45,489
en indien dit verander, dan sal dit die opdragte wat dit veronderstel is om te hardloop hardloop

428
00:34:45,489 --> 00:34:48,760
wanneer die lêer verander. >> [Student] Goed.

429
00:34:50,510 --> 00:34:54,420
Ek weet nie waar die globale fabrikaat lêers is vir my om dit te check.

430
00:34:57,210 --> 00:35:04,290
Ander vrae? Enigiets uit die verlede vasvrae? Enige pointer dinge?

431
00:35:06,200 --> 00:35:08,730
Daar is subtiele dinge met wysers soos -

432
00:35:08,730 --> 00:35:10,220
Ek gaan nie in staat wees om 'n quiz vraag te kry op dit -

433
00:35:10,220 --> 00:35:16,250
maar net soos hierdie soort van ding.

434
00:35:19,680 --> 00:35:24,060
Maak seker dat jy verstaan ​​dat as ek sê int * x * y -

435
00:35:24,890 --> 00:35:28,130
Dit is nie presies hier iets, dink ek.

436
00:35:28,130 --> 00:35:32,140
Maar soos * x * y, dit is 2 veranderlikes wat op die stapel.

437
00:35:32,140 --> 00:35:37,220
Toe ek sê x = malloc (sizeof (int)), x is nog steeds 'n veranderlike op die stapel,

438
00:35:37,220 --> 00:35:41,180
malloc 'n blok oor in die hoop, en ons is met x punt aan die hoop.

439
00:35:41,180 --> 00:35:43,900
>> So iets op die stapel punte aan die hoop.

440
00:35:43,900 --> 00:35:48,100
Wanneer jy malloc enigiets, jy noodwendig om dit te stoor binnekant van 'n wyser.

441
00:35:48,100 --> 00:35:55,940
So dat die wyser is op die stapel, die malloced blok is op die hoop.

442
00:35:55,940 --> 00:36:01,240
'N baie mense kry verward en sê int * x = malloc, x is op die hoop.

443
00:36:01,240 --> 00:36:04,100
No. Wat x dui op is op die hoop.

444
00:36:04,100 --> 00:36:08,540
x self is op die stapel, tensy vir watter rede ookal jy x het 'n globale veranderlike,

445
00:36:08,540 --> 00:36:11,960
in welke geval dit gebeur te wees in 'n ander streek van die geheue.

446
00:36:13,450 --> 00:36:20,820
So hou nie, hierdie boks en boog diagramme is redelik algemeen vir die quiz.

447
00:36:20,820 --> 00:36:25,740
Of as dit nie op quiz 0, sal dit op quiz 1.

448
00:36:27,570 --> 00:36:31,940
Jy moet weet al hierdie, die stappe in die opstel

449
00:36:31,940 --> 00:36:35,740
want jy het vrae oor daardie te beantwoord. Ja.

450
00:36:35,740 --> 00:36:38,940
[Student] Kan ons gaan oor daardie stappe - >> Sure.

451
00:36:48,340 --> 00:36:58,640
Voordat stappe en die opstel van ons het preprocessing,

452
00:36:58,640 --> 00:37:16,750
die samestelling, vervaardiging, en koppel.

453
00:37:16,750 --> 00:37:21,480
Actuatoren. Wat beteken dit?

454
00:37:29,720 --> 00:37:32,290
Dit is die maklikste stap in - wel, nie soos -

455
00:37:32,290 --> 00:37:35,770
dit beteken nie dat dit moet duidelik wees, maar dit is die maklikste stap.

456
00:37:35,770 --> 00:37:38,410
Julle ouens kan implementeer dit self. Ja.

457
00:37:38,410 --> 00:37:43,410
[Student] Neem wat jy in jou sluit soos hierdie en dit kopieer en dan ook bepaal.

458
00:37:43,410 --> 00:37:49,250
Dit lyk vir dinge soos # include # define,

459
00:37:49,250 --> 00:37:53,800
en dit net kopieer en plak wat daardie eintlik beteken.

460
00:37:53,800 --> 00:37:59,240
So wanneer jy sê # include cs50.h, is die voorverwerker kopieer en plak cs50.h

461
00:37:59,240 --> 00:38:01,030
in daardie lyn.

462
00:38:01,030 --> 00:38:06,640
Wanneer jy sê # define x 4, die voorverwerker gaan deur die hele program

463
00:38:06,640 --> 00:38:10,400
en vervang alle gevalle van x met 4.

464
00:38:10,400 --> 00:38:17,530
So het die voorverwerker neem 'n geldige C lêer en uitsette 'n geldige C lêer

465
00:38:17,530 --> 00:38:20,300
waar dinge is gekopieer en geplak.

466
00:38:20,300 --> 00:38:24,230
So nou die opstel van. Wat beteken dit?

467
00:38:25,940 --> 00:38:28,210
[Student] Dit gaan vanaf C na binêre.

468
00:38:28,210 --> 00:38:30,970
>> [Bowden] Dit gaan nie al die pad na binêre.

469
00:38:30,970 --> 00:38:34,220
[Student] To Machine-kode dan? >> Dit is nie masjien-kode.

470
00:38:34,220 --> 00:38:35,700
[Student] Vergadering? >> Vergadering.

471
00:38:35,700 --> 00:38:38,890
Dit gaan na die Vergadering voordat dit gaan al die pad na C-kode,

472
00:38:38,890 --> 00:38:45,010
en die meeste tale doen iets soos hierdie.

473
00:38:47,740 --> 00:38:50,590
Kies 'n hoë-vlak taal, en as jy gaan om dit op te stel,

474
00:38:50,590 --> 00:38:52,390
dit is waarskynlik te stel in stappe.

475
00:38:52,390 --> 00:38:58,140
Eerste dit gaan Python te stel aan C, dan is dit gaan C op te stel Vergadering,

476
00:38:58,140 --> 00:39:01,600
en dan Vergadering gaan om te vertaal na binêre.

477
00:39:01,600 --> 00:39:07,800
So die opstel gaan dit vanaf C na Vergadering bring.

478
00:39:07,800 --> 00:39:12,130
Die woord opstel van beteken gewoonlik om dit van 'n hoër vlak

479
00:39:12,130 --> 00:39:14,340
na 'n laer vlak programmeertaal.

480
00:39:14,340 --> 00:39:19,190
So, dit is die enigste stap in die samestelling waar jy begin met 'n hoë-vlak taal

481
00:39:19,190 --> 00:39:23,270
en eindig in 'n lae-vlak taal, en dit is waarom die stap is genoem die opstel van.

482
00:39:25,280 --> 00:39:33,370
Student] Tydens die opstel van, laat ons sê dat jy gedoen het # include cs50.h.

483
00:39:33,370 --> 00:39:42,190
Sal die samesteller heropstel die cs50.h, soos die funksies wat daar is,

484
00:39:42,190 --> 00:39:45,280
en vertaal dit in Vergadering kode sowel,

485
00:39:45,280 --> 00:39:50,830
of sal dit kopieer en plak iets wat pre-Vergadering?

486
00:39:50,830 --> 00:39:56,910
cs50.h sal pretty much nooit 'n einde in die Vergadering.

487
00:39:59,740 --> 00:40:03,680
Denke soos funksie prototipes en dinge is net vir jou om versigtig te wees.

488
00:40:03,680 --> 00:40:09,270
Dit waarborg dat die samesteller dinge kan kyk soos jy 'n beroep funksies

489
00:40:09,270 --> 00:40:12,910
met die regte opbrengs tipes en die regte argumente en stuff.

490
00:40:12,910 --> 00:40:18,350
>> So cs50.h preprocessed word in die lêer, en dan wanneer dit die samestelling van

491
00:40:18,350 --> 00:40:22,310
Dit is basies weggegooi nadat dit maak seker dat alles korrek genoem.

492
00:40:22,310 --> 00:40:29,410
Maar die funksies gedefinieer in die CS50 biblioteek, wat apart van cs50.h

493
00:40:29,410 --> 00:40:33,610
dié sal nie afsonderlik saamgestel word.

494
00:40:33,610 --> 00:40:37,270
Wat eintlik afkom in die koppeling stap, so ons sal kry in 'n tweede.

495
00:40:37,270 --> 00:40:40,100
Maar eers, wat is die samestelling?

496
00:40:41,850 --> 00:40:44,500
[Student] Vergadering binêre? >> Ja.

497
00:40:46,300 --> 00:40:48,190
Byeenkoms.

498
00:40:48,190 --> 00:40:54,710
Ons noem dit nie die opstel omdat Vergadering is pretty much 'n suiwer vertaling van binêre.

499
00:40:54,710 --> 00:41:00,230
Daar is baie min logika gaan van Vergadering na binêre.

500
00:41:00,230 --> 00:41:03,180
Dit is net soos om in 'n tabel, oh, ons het hierdie opdrag;

501
00:41:03,180 --> 00:41:06,290
wat ooreenstem met binêre 01.110.

502
00:41:10,200 --> 00:41:15,230
En so het die lêers wat monteerwerk algemeen uitsette is. O lêers.

503
00:41:15,230 --> 00:41:19,020
En o lêers. Is wat ons het gesê voor,

504
00:41:19,020 --> 00:41:21,570
hoe om 'n lêer hoef nie 'n hoof funksie te hê.

505
00:41:21,570 --> 00:41:27,640
Enige lêer kan saamgestel word na 'n o-lêer. So lank as wat dit is 'n geldige C-lêer.

506
00:41:27,640 --> 00:41:30,300
Dit kan saamgestel word. O.

507
00:41:30,300 --> 00:41:43,030
Nou, 'n skakel is wat werklik bring 'n klomp van die o lêers en bring hulle tot 'n uitvoerbare.

508
00:41:43,030 --> 00:41:51,110
En wat skakeling doen wat jy kan dink van die CS50 biblioteek as 'n o-lêer.

509
00:41:51,110 --> 00:41:56,980
Dit is 'n reeds saamgestel binêre lêer.

510
00:41:56,980 --> 00:42:03,530
En so wanneer jy stel jou lêer, jou hello.c, wat noem GetString,

511
00:42:03,530 --> 00:42:06,360
hello.c kry saamgestel na hello.o,

512
00:42:06,360 --> 00:42:08,910
hello.o is nou in binêre.

513
00:42:08,910 --> 00:42:12,830
Dit maak gebruik van GetString, so is dit nodig om oor te gaan na cs50.o,

514
00:42:12,830 --> 00:42:16,390
en die koppelingshistoon smooshes hulle saam en skryf GetString in hierdie lêer

515
00:42:16,390 --> 00:42:20,640
en kom uit met 'n uitvoerbare wat al die funksies wat dit nodig het.

516
00:42:20,640 --> 00:42:32,620
So cs50.o is nie eintlik 'n O lêer, maar dit is naby genoeg dat daar geen fundamentele verskil.

517
00:42:32,620 --> 00:42:36,880
So koppel net bring 'n klomp van die lêers saam

518
00:42:36,880 --> 00:42:41,390
wat afsonderlik bevat al die funksies wat ek nodig het om te gebruik

519
00:42:41,390 --> 00:42:46,120
en skep die uitvoerbare wat eintlik loop.

520
00:42:48,420 --> 00:42:50,780
>> En so het dit is ook wat ons het gesê voor

521
00:42:50,780 --> 00:42:55,970
waar jy 1000 kan hê. c lêers, jy stel om hulle almal te o lêers.

522
00:42:55,970 --> 00:43:00,040
wat sal waarskynlik 'n rukkie neem, dan moet jy verander 1 c lêer.

523
00:43:00,040 --> 00:43:05,480
Jy hoef net dat 1. C lêer en dan relink alles te hercompileren,

524
00:43:05,480 --> 00:43:07,690
skakel alles weer saam.

525
00:43:09,580 --> 00:43:11,430
[Student] Wanneer ons 'n skakel ons skryf lcs50?

526
00:43:11,430 --> 00:43:20,510
Ja, so-lcs50. Dit vlag seine na die koppelingshistoon wat jy moet koppel in daardie biblioteek.

527
00:43:26,680 --> 00:43:28,910
Vrae?

528
00:43:41,310 --> 00:43:46,860
Het ons deurgetrek binêre anders as wat 5 sekondes in die eerste lesing?

529
00:43:50,130 --> 00:43:53,010
Ek dink nie so nie.

530
00:43:55,530 --> 00:43:58,820
Wat jy moet weet van die groot Os wat ons het oorgevaar en,

531
00:43:58,820 --> 00:44:02,670
en jy moet in staat wees om as ons aan julle gegee het 'n funksie,

532
00:44:02,670 --> 00:44:09,410
jy moet in staat wees om te sê dit is groot O, grof. Of goed, groot-O is grof.

533
00:44:09,410 --> 00:44:15,300
So as jy sien geneste vir loops herhaling oor die dieselfde aantal van die dinge,

534
00:44:15,300 --> 00:44:22,260
soos int i, i <n; int j, j <n - >> [student] n kwadraat. >> Dit is geneig om te wees n kwadraat.

535
00:44:22,260 --> 00:44:25,280
As jy triple geneste, is dit geneig is om te wees n blokkies gesny.

536
00:44:25,280 --> 00:44:29,330
So daardie soort van ding wat jy moet in staat wees om uit te wys onmiddellik.

537
00:44:29,330 --> 00:44:33,890
Jy moet invoeging soort en borrel soort te ken en te sorteer en al daardie saamsmelt.

538
00:44:33,890 --> 00:44:41,420
Dit is makliker om te verstaan ​​waarom hulle dié n kwadraat en n log n en al

539
00:44:41,420 --> 00:44:47,810
want ek dink daar was een jaar waar ons basies wat jy gegee het op 'n quiz

540
00:44:47,810 --> 00:44:55,050
'n implementering van die borrel soort en gesê: "Wat is die looptyd van hierdie funksie?"

541
00:44:55,050 --> 00:45:01,020
So as jy dit herken as borrel soort, dan kan jy dadelik sê n kwadraat.

542
00:45:01,020 --> 00:45:05,470
Maar as jy net kyk na dit, het jy nie eens nodig om te besef dit se borrel soort;

543
00:45:05,470 --> 00:45:08,990
jy kan net sê hierdie en dit doen. Dit is n kwadraat.

544
00:45:12,350 --> 00:45:14,710
[Student] Is daar enige moeilike voorbeelde wat jy kan kom met,

545
00:45:14,710 --> 00:45:20,370
soos 'n soortgelyke idee van die uitzoeken?

546
00:45:20,370 --> 00:45:24,450
>> Ek dink nie ons sal gee jou 'n moeilike voorbeelde.

547
00:45:24,450 --> 00:45:30,180
Die borrel soort ding is omtrent so moeilik soos wat ons sou gaan,

548
00:45:30,180 --> 00:45:36,280
en selfs dat so lank as wat jy verstaan ​​dat jy iterating oor die skikking

549
00:45:36,280 --> 00:45:41,670
vir elke element in die skikking, wat gaan iets wat se N-kwadraat.

550
00:45:45,370 --> 00:45:49,940
Daar is 'n algemene vrae, soos hier wat ons het - Oh.

551
00:45:55,290 --> 00:45:58,530
Net die ander dag, Doug beweer, "Ek het uitgevind 'n algoritme wat kan 'n verskeidenheid sorteer

552
00:45:58,530 --> 00:46:01,780
"Van n getalle in O (log n) tyd!"

553
00:46:01,780 --> 00:46:04,900
So, hoe weet ons dit is onmoontlik?

554
00:46:04,900 --> 00:46:08,850
[Onhoorbaar student reaksie] >> Ja.

555
00:46:08,850 --> 00:46:13,710
Op die heel minste, moet jy elke element in die skikking aan te raak,

556
00:46:13,710 --> 00:46:16,210
so dit is onmoontlik om 'n skikking te sorteer -

557
00:46:16,210 --> 00:46:20,850
As alles is in unsorted einde, dan is jy gaan raak alles in die skikking,

558
00:46:20,850 --> 00:46:25,320
so dit is onmoontlik om dit te doen in minder as O van n.

559
00:46:27,430 --> 00:46:30,340
[Student] Jy het vir ons gewys dat die voorbeeld van in staat is om dit te doen in die O van n

560
00:46:30,340 --> 00:46:33,920
as jy gebruik maak van 'n baie van die geheue. >> Ja.

561
00:46:33,920 --> 00:46:37,970
En that's - ek vergeet wat that's - Is dit tel soort?

562
00:46:47,360 --> 00:46:51,330
Hmm. Dit is 'n heelgetal sorteringsalgoritme.

563
00:46:59,850 --> 00:47:05,100
Ek was op soek vir die spesiale naam vir hierdie wat ek nie kon onthou verlede week.

564
00:47:05,100 --> 00:47:13,000
Ja. Dit is die aard van die spesies wat dinge kan bereik in die groot O van n.

565
00:47:13,000 --> 00:47:18,430
Maar daar is beperkings, soos jy kan slegs heelgetalle gebruik tot 'n sekere aantal.

566
00:47:20,870 --> 00:47:24,560
Plus as jy probeer om iets that's te sorteer -

567
00:47:24,560 --> 00:47:30,750
As jou skikking is 012, 12, 151, 4 miljoen,

568
00:47:30,750 --> 00:47:35,120
dan daardie enkele element gaan heeltemal te ruïneer die hele sorteer.

569
00:47:42,060 --> 00:47:44,030
>> Vrae?

570
00:47:49,480 --> 00:47:58,870
[Student] As jy 'n rekursiewe funksie en dit net maak die rekursiewe oproepe

571
00:47:58,870 --> 00:48:02,230
binne 'n terugkeer verklaring, wat se stert rekursiewe,

572
00:48:02,230 --> 00:48:07,360
en so sal dit nie gebruik meer geheue tydens runtime

573
00:48:07,360 --> 00:48:12,550
of sou dit ten minste vergelykbaar geheue gebruik as 'n iteratiewe oplossing?

574
00:48:12,550 --> 00:48:14,530
[Bowden] Ja.

575
00:48:14,530 --> 00:48:19,840
Dit sou waarskynlik ietwat stadiger, maar nie regtig.

576
00:48:19,840 --> 00:48:23,290
Stert rekursiewe is redelik goed.

577
00:48:23,290 --> 00:48:32,640
Ons sien daarna weer op stapel rame, laat ons sê dat ons hoof

578
00:48:32,640 --> 00:48:42,920
en ons het 'n int bar (int x) of iets.

579
00:48:42,920 --> 00:48:52,310
Dit is nie 'n perfekte rekursiewe funksie, maar terugkeer bar (x - 1).

580
00:48:52,310 --> 00:48:57,620
So natuurlik, dit is gebrekkig. Jy moet 'n basis gevalle en stuff.

581
00:48:57,620 --> 00:49:00,360
Maar die idee hier is dat hierdie is 'n stert rekursiewe,

582
00:49:00,360 --> 00:49:06,020
wat beteken dat wanneer hoof oproepe bar dit gaan sy stapel raam te kry.

583
00:49:09,550 --> 00:49:12,440
In hierdie stapel raam daar gaan 'n klein blokkie van die geheue

584
00:49:12,440 --> 00:49:17,490
wat ooreenstem met sy argument x.

585
00:49:17,490 --> 00:49:25,840
En so kom ons sê belangrikste gebeur bar (100) te roep;

586
00:49:25,840 --> 00:49:30,050
So x gaan begin as 100.

587
00:49:30,050 --> 00:49:35,660
Indien die vertaler erken dat dit 'n stert rekursiewe funksie,

588
00:49:35,660 --> 00:49:38,540
dan wanneer bar maak sy rekursiewe oproep te staaf,

589
00:49:38,540 --> 00:49:45,490
in plaas van die maak van 'n nuwe stapel raam, en dit is waar die stapel begin grootliks groei,

590
00:49:45,490 --> 00:49:48,220
uiteindelik sal dit loop in die hoop en dan kry jy segfaults

591
00:49:48,220 --> 00:49:51,590
want die geheue begin bots.

592
00:49:51,590 --> 00:49:54,830
>> So in plaas van om sy eie stapel raam, kan dit besef,

593
00:49:54,830 --> 00:49:59,080
hey, ek het nooit regtig nodig het om terug te kom na hierdie stapel raam,

594
00:49:59,080 --> 00:50:08,040
so maar ek sal net hierdie argument met 99 vervang en dan begin bar alles oor.

595
00:50:08,040 --> 00:50:11,810
En dan sal dit doen dit weer en dit sal terugkeer bar bereik (x - 1),

596
00:50:11,810 --> 00:50:17,320
en in plaas van die maak van 'n nuwe stapel raam, sal dit vervang net die huidige argument met 98

597
00:50:17,320 --> 00:50:20,740
en dan terug spring na die begin van die bar.

598
00:50:23,860 --> 00:50:30,430
Dié bedrywighede, wat 1 waarde op die stapel te vervang en spring terug na die begin,

599
00:50:30,430 --> 00:50:32,430
is redelik doeltreffend.

600
00:50:32,430 --> 00:50:41,500
Dus nie net is dit dieselfde geheue gebruik as 'n aparte funksie wat iteratiewe

601
00:50:41,500 --> 00:50:45,390
omdat jy slegs met behulp van 1 stapel raam, maar jy is nie die lyding van die nadele

602
00:50:45,390 --> 00:50:47,240
om funksies uit te roep.

603
00:50:47,240 --> 00:50:50,240
Oproep funksies kan 'n bietjie duur, want dit het al hierdie setup te doen

604
00:50:50,240 --> 00:50:52,470
en tear down en al hierdie dinge.

605
00:50:52,470 --> 00:50:58,160
So hierdie Staartrecursie is goed.

606
00:50:58,160 --> 00:51:01,170
[Student] Waarom word dit nie nuwe stappe doen?

607
00:51:01,170 --> 00:51:02,980
Omdat dit besef dit nie hoef te.

608
00:51:02,980 --> 00:51:07,800
Die oproep tot bar is net die terugkeer van die rekursiewe oproep.

609
00:51:07,800 --> 00:51:12,220
Sodat dit nie nodig om iets te doen het met die terugkeer waarde.

610
00:51:12,220 --> 00:51:15,120
Dit is net gaan om onmiddellik stuur dit terug.

611
00:51:15,120 --> 00:51:20,530
So dit is net gaan om sy eie argument te vervang en begin oor.

612
00:51:20,530 --> 00:51:25,780
En ook, as jy nie die stert rekursiewe weergawe,

613
00:51:25,780 --> 00:51:31,460
dan kry jy al die bars waar wanneer hierdie bar terug

614
00:51:31,460 --> 00:51:36,010
dit het die waarde daarvan om terug te keer na hierdie een, dan is dit bar onmiddellik terug

615
00:51:36,010 --> 00:51:39,620
en dit gee die waarde daarvan aan hierdie een, dan is dit net gaan om onmiddellik terug

616
00:51:39,620 --> 00:51:41,350
en die waarde daarvan terug aan hierdie een.

617
00:51:41,350 --> 00:51:45,350
So jy spaar knal al hierdie dinge af van die stapel

618
00:51:45,350 --> 00:51:48,730
sedert die terugkeer waarde is net gaan al die pad terug tot in elk geval.

619
00:51:48,730 --> 00:51:55,400
So hoekom nie net vervang ons argument met die opgedateerde argument en begin oor?

620
00:51:57,460 --> 00:52:01,150
As die funksie is nie stert rekursiewe, as jy nie iets soos -

621
00:52:01,150 --> 00:52:07,530
[Student] indien bar (x + 1). >> Ja.

622
00:52:07,530 --> 00:52:11,770
>> So as jy dit in die toestand is, dan is jy om iets te doen met die terugkeer waarde.

623
00:52:11,770 --> 00:52:16,260
Of selfs as jy net doen terugkeer 2 * Bar (x - 1).

624
00:52:16,260 --> 00:52:23,560
So nou bar (x - 1) moet om terug te keer sodat dit 2 keer dat die waarde te bereken,

625
00:52:23,560 --> 00:52:26,140
so nou is dit nie nodig sy eie aparte stapel raam,

626
00:52:26,140 --> 00:52:31,180
en nou, maak nie saak hoe hard jy probeer nie, jy gaan nodig om -

627
00:52:31,180 --> 00:52:34,410
Dit is nie stert rekursiewe.

628
00:52:34,410 --> 00:52:37,590
[Student] Sou ek probeer om 'n rekursie te bring om te streef na 'n stert rekursie -

629
00:52:37,590 --> 00:52:41,450
[Bowden] In 'n ideale wêreld, maar in CS50 jy nie.

630
00:52:43,780 --> 00:52:49,280
Ten einde stert rekursie te kry, oor die algemeen, moet jy die opstel van 'n bykomende argument

631
00:52:49,280 --> 00:52:53,550
waar die bar sal int x y

632
00:52:53,550 --> 00:52:56,990
en y ooreenstem met die uiteindelike ding wat jy wil om terug te keer.

633
00:52:56,990 --> 00:53:03,650
So dan is dit jy gaan om terug te keer bar (x - 1) 2 * y.

634
00:53:03,650 --> 00:53:09,810
So dit is net 'n hoë-vlak hoe jy transformeer dinge te wees stert rekursiewe.

635
00:53:09,810 --> 00:53:13,790
Maar die ekstra argument -

636
00:53:13,790 --> 00:53:17,410
En dan aan die einde wanneer jy bereik jou basis geval, jy net terugkom y

637
00:53:17,410 --> 00:53:22,740
omdat jy die opbou van die hele tyd die terugkeer waarde wat jy wil.

638
00:53:22,740 --> 00:53:27,280
Jy soort van het is om dit te doen iteratief maar met behulp van rekursiewe oproepe.

639
00:53:32,510 --> 00:53:34,900
Vrae?

640
00:53:34,900 --> 00:53:39,890
[Student] Miskien oor pointer rekenkunde, soos wanneer met behulp van toue. >> Sure.

641
00:53:39,890 --> 00:53:43,610
Pointer rekenkunde.

642
00:53:43,610 --> 00:53:48,440
By die gebruik van snare dit is maklik omdat snare char sterre,

643
00:53:48,440 --> 00:53:51,860
karakters is vir ewig en altyd 'n enkele greep,

644
00:53:51,860 --> 00:53:57,540
en so wyser rekenkunde is gelykstaande aan 'n gereelde rekenkundige wanneer jy met stringe.

645
00:53:57,540 --> 00:54:08,790
Laat ons net sê char * s = "hallo".

646
00:54:08,790 --> 00:54:11,430
So ons het 'n blok in die geheue.

647
00:54:19,490 --> 00:54:22,380
Dit benodig 6 grepe omdat jy altyd die null terminator nodig.

648
00:54:22,380 --> 00:54:28,620
En char * s gaan om te verwys na die begin van die skikking.

649
00:54:28,620 --> 00:54:32,830
So se punte daar.

650
00:54:32,830 --> 00:54:36,710
Nou, dit is basies hoe om 'n verskeidenheid werk,

651
00:54:36,710 --> 00:54:40,780
ongeag of dit was 'n opgawe deur malloc of dit is op die stapel.

652
00:54:40,780 --> 00:54:47,110
Enige skikking is basies 'n wyser na die begin van die skikking,

653
00:54:47,110 --> 00:54:53,640
en dan enige skikking werking, enige indeksering, is net gaan in daardie skikking 'n sekere geneutraliseer.

654
00:54:53,640 --> 00:55:05,360
>> So as ek sê iets soos s [3]; dit gaan en toe 3 karakters.

655
00:55:05,360 --> 00:55:12,490
So s [3], het ons 0, 1, 2, 3, so s [3] gaan om te verwys na hierdie l.

656
00:55:12,490 --> 00:55:20,460
[Student] En ons kon dieselfde waarde bereik deur te doen s + 3 en dan hakies ster?

657
00:55:20,460 --> 00:55:22,570
Ja.

658
00:55:22,570 --> 00:55:26,010
Dit is gelykstaande aan * (s + 3);

659
00:55:26,010 --> 00:55:31,240
en dit is vir ewig en altyd gelyk maak nie saak wat jy doen nie.

660
00:55:31,240 --> 00:55:34,070
Jy hoef nooit die bracket sintaksis te gebruik.

661
00:55:34,070 --> 00:55:37,770
Kan jy altyd gebruik om die * (s + 3) sintaksis.

662
00:55:37,770 --> 00:55:40,180
Mense is geneig om die bracket sintaksis te hou, al is.

663
00:55:40,180 --> 00:55:43,860
[Student] So was dan al skikkings is eintlik net wysers.

664
00:55:43,860 --> 00:55:53,630
Daar is 'n effense onderskeid wanneer ek sê int x [4]; >> [student] wat die skep van die geheue?

665
00:55:53,630 --> 00:56:03,320
[Bowden] Dit gaan 4 ints op die stapel te skep, so 16 bytes algehele.

666
00:56:03,320 --> 00:56:05,700
Dit gaan 16 bytes te skep op die stapel.

667
00:56:05,700 --> 00:56:09,190
x is nie gestoor word op enige plek.

668
00:56:09,190 --> 00:56:13,420
Dit is net 'n simbool verwys na die aanvang van die saak.

669
00:56:13,420 --> 00:56:17,680
Omdat jy die skikking verklaar binnekant van hierdie funksie,

670
00:56:17,680 --> 00:56:22,340
wat die vertaler gaan doen is net vervang alle gevalle van die veranderlike x

671
00:56:22,340 --> 00:56:26,400
waar dit gebeur het om te kies hierdie 16 bytes te sit.

672
00:56:26,400 --> 00:56:30,040
Dit nie kan doen met char * s omdat s is 'n werklike wyser.

673
00:56:30,040 --> 00:56:32,380
Dit is gratis om te wys na ander dinge.

674
00:56:32,380 --> 00:56:36,140
x is 'n konstante. Jy kan nie dit punt na 'n ander skikking. >> [Student] Goed.

675
00:56:36,140 --> 00:56:43,420
Maar hierdie idee, hierdie indeksering, is dieselfde, ongeag of dit is 'n tradisionele skikking

676
00:56:43,420 --> 00:56:48,230
of as dit 'n wyser na iets of indien dit is 'n wyser na 'n malloced skikking.

677
00:56:48,230 --> 00:56:59,770
En in die waarheid te sê, dit is so gelyk dat dit ook dieselfde ding.

678
00:56:59,770 --> 00:57:05,440
Dit is eintlik net beteken wat binnekant van die hakies is en wat oorbly van die hakies,

679
00:57:05,440 --> 00:57:07,970
voeg hulle saam en dereferences.

680
00:57:07,970 --> 00:57:14,710
So dit is net so geldig soos * (s + 3) of s [3].

681
00:57:16,210 --> 00:57:22,090
[Student] Kan jy wysers wys na 2-dimensionele skikkings?

682
00:57:22,090 --> 00:57:27,380
>> Dit is moeiliker. Tradisioneel, no.

683
00:57:27,380 --> 00:57:34,720
'N 2-dimensionele skikking is net 'n 1-dimensionele skikking met 'n paar gerieflike sintaksis

684
00:57:34,720 --> 00:57:54,110
want as ek sê int x [3] [3], dit is regtig net 1 skikking met 9 waardes.

685
00:57:55,500 --> 00:58:03,000
En so toe ek indeks, is die samesteller weet wat ek bedoel.

686
00:58:03,000 --> 00:58:13,090
As ek sê x [1] [2], dit weet ek wil om te gaan na die tweede ry, so dit gaan die eerste 3 te slaan,

687
00:58:13,090 --> 00:58:17,460
en dan wil die tweede ding in die sin dat, so dit gaan hierdie een te kry.

688
00:58:17,460 --> 00:58:20,480
Maar dit is nog net 'n enkel-dimensionele skikking.

689
00:58:20,480 --> 00:58:23,660
En so, as ek wou om 'n wyser te wys dat die skikking,

690
00:58:23,660 --> 00:58:29,770
Ek sou sê int * p = x;

691
00:58:29,770 --> 00:58:33,220
Die tipe van x is net -

692
00:58:33,220 --> 00:58:38,280
Dit is ruwe gesê tipe van x, want dit is net 'n simbool en dit is nie 'n werklike veranderlike,

693
00:58:38,280 --> 00:58:40,140
maar dit is net 'n int *.

694
00:58:40,140 --> 00:58:44,840
x is net 'n wyser na die begin van hierdie. >> [Student] Goed.

695
00:58:44,840 --> 00:58:52,560
En daarom sal ek nie in staat wees om [1] [2] om toegang te verkry tot.

696
00:58:52,560 --> 00:58:58,370
Ek dink daar is 'n spesiale sintaksis vir die verklaring van 'n wyser,

697
00:58:58,370 --> 00:59:12,480
iets belaglik soos int (* p [- iets absoluut belaglik Ek het nie eens weet nie.

698
00:59:12,480 --> 00:59:17,090
Maar daar is 'n sintaksis vir die verwysings soos met hakies en dinge te verklaar.

699
00:59:17,090 --> 00:59:22,960
Dit kan selfs nie toelaat dat jy dit doen.

700
00:59:22,960 --> 00:59:26,640
Ek kon terugkyk op iets wat jou sal vertel my die waarheid.

701
00:59:26,640 --> 00:59:34,160
Ek sal kyk vir dit later, indien daar is 'n sintaksis vir punt. Maar jy sal nooit dit sien.

702
00:59:34,160 --> 00:59:39,670
En selfs die sintaksis is so argaïes dat as jy dit gebruik, sal mense met stomheid geslaan word.

703
00:59:39,670 --> 00:59:43,540
Multidimensionele skikkings is redelik skaars soos dit is.

704
00:59:43,540 --> 00:59:44,630
Jy pretty much -

705
00:59:44,630 --> 00:59:48,490
Wel, as jy doen matriks dinge dit is nie van plan te wees skaars,

706
00:59:48,490 --> 00:59:56,730
maar in C wat jy selde gaan die gebruik van multidimensionele skikkings.

707
00:59:57,630 --> 01:00:00,470
Ja. >> [Student] Kom ons sê jy het 'n baie lang skikking.

708
01:00:00,470 --> 01:00:03,900
>> In virtuele geheue dit sou blyk te wees alle opeenvolgende,

709
01:00:03,900 --> 01:00:05,640
soos die elemente wat reg langs mekaar,

710
01:00:05,640 --> 01:00:08,770
maar in die fisiese geheue, sou dit moontlik wees vir wat verdeel word? >> Ja.

711
01:00:08,770 --> 01:00:16,860
Hoe virtuele geheue werk is dit skei net -

712
01:00:19,220 --> 01:00:24,860
Die eenheid van die toekenning is 'n bladsy, wat geneig is om 4 kilogrepe,

713
01:00:24,860 --> 01:00:29,680
en so wanneer 'n proses, sê, hey, ek wil hierdie geheue te gebruik,

714
01:00:29,680 --> 01:00:35,970
die bedryfstelsel gaan dit 4 kilogrepe vir daardie klein blok geheue te ken.

715
01:00:35,970 --> 01:00:39,100
Selfs as jy net 'n enkele klein byte in die hele blok van die geheue,

716
01:00:39,100 --> 01:00:42,850
die bedryfstelsel gaan gee dit die volle 4 kilogrepe.

717
01:00:42,850 --> 01:00:49,410
So wat dit beteken is ek kon het - laat ons sê dit is my stapel.

718
01:00:49,410 --> 01:00:53,180
Hierdie stapel geskei kan word. My stapel kan wees megagrepe en megagrepe.

719
01:00:53,180 --> 01:00:55,020
My stapel kan groot wees.

720
01:00:55,020 --> 01:01:00,220
Maar die stapel self word verdeel in afsonderlike bladsye,

721
01:01:00,220 --> 01:01:09,010
wat as ons kyk na hier kom ons sê dit is ons RAM,

722
01:01:09,010 --> 01:01:16,600
as ek het 2 GB RAM, dit is 'n werklike adres 0 soos die nulde greep van my RAM,

723
01:01:16,600 --> 01:01:22,210
en dit is 2 GB al die pad af hier.

724
01:01:22,210 --> 01:01:27,230
So hierdie bladsy kan hier stem ooreen met hierdie blok.

725
01:01:27,230 --> 01:01:29,400
Hierdie bladsy kan stem ooreen met hierdie blok hier.

726
01:01:29,400 --> 01:01:31,560
Hierdie een mag stem ooreen met hierdie een hier.

727
01:01:31,560 --> 01:01:35,540
So die bedryfstelsel is gratis fisiese geheue te wys

728
01:01:35,540 --> 01:01:39,320
aan enige individuele bladsy arbitrêr.

729
01:01:39,320 --> 01:01:46,180
En dit beteken dat indien hierdie grens gebeur om 'n skikking te straddle,

730
01:01:46,180 --> 01:01:50,070
'n skikking gebeur te word van hierdie links en regs van die einde van 'n bladsy,

731
01:01:50,070 --> 01:01:54,460
dan is dat die skikking word in fisiese geheue verdeel gaan word.

732
01:01:54,460 --> 01:01:59,280
En dan wanneer jy die program afsluit, wanneer die proses eindig,

733
01:01:59,280 --> 01:02:05,690
hierdie afbeeldings kry skoongemaak, en dan is dit vry om hierdie klein blokke te gebruik vir ander dinge.

734
01:02:14,730 --> 01:02:17,410
Nog vrae?

735
01:02:17,410 --> 01:02:19,960
[Student] Die wyser rekenkunde. >> O ja.

736
01:02:19,960 --> 01:02:28,410
Strings was makliker, maar kyk na iets soos ints,

737
01:02:28,410 --> 01:02:35,000
so terug na int x [4];

738
01:02:35,000 --> 01:02:41,810
Of dit nou 'n skikking of dit is 'n wyser na 'n malloced verskeidenheid van 4 heelgetalle,

739
01:02:41,810 --> 01:02:47,060
dit gaan op dieselfde manier behandel word.

740
01:02:50,590 --> 01:02:53,340
[Student] So skikkings is op die hoop?

741
01:03:01,400 --> 01:03:05,270
[Bowden] Skikkings is nie op die hoop. >> [Student] Oh.

742
01:03:05,270 --> 01:03:08,320
>> [Bowden] Hierdie tipe van 'n skikking is geneig om te wees op die stapel

743
01:03:08,320 --> 01:03:12,220
tensy jy verklaar dit op globale veranderlikes te ignoreer. Globale veranderlikes gebruik nie.

744
01:03:12,220 --> 01:03:16,280
Binnekant van 'n funksie wat ek sê int x [4];

745
01:03:16,280 --> 01:03:22,520
Dit gaan 'n 4-integer blok op die stapel te skep vir hierdie skikking.

746
01:03:22,520 --> 01:03:26,960
Maar dit malloc (4 * sizeof (int)); gaan om te gaan op die wal.

747
01:03:26,960 --> 01:03:31,870
Maar na hierdie punt wat ek kan gebruik X en P in pretty much dieselfde maniere,

748
01:03:31,870 --> 01:03:36,140
behalwe die uitsonderings wat ek het gesê voor oor wat jy kan toewys p.

749
01:03:36,140 --> 01:03:40,960
Tegnies, hulle groottes is ietwat anders, maar dit is heeltemal irrelevant.

750
01:03:40,960 --> 01:03:43,310
Jy het nog nooit eintlik hulle groottes.

751
01:03:48,020 --> 01:03:56,810
Die p ek kon sê p [3] = 2 of x [3] = 2;

752
01:03:56,810 --> 01:03:59,680
Jy kan gebruik om hulle in presies dieselfde manier.

753
01:03:59,680 --> 01:04:01,570
So pointer rekenkundige nou - Ja.

754
01:04:01,570 --> 01:04:07,390
[Student] Het jy nie p * te doen as jy die hakies?

755
01:04:07,390 --> 01:04:11,720
Die hakies is 'n implisiete dereference. >> Goed.

756
01:04:11,720 --> 01:04:20,200
Eintlik, ook wat jy sê met die kan jy multidimensionele skikkings

757
01:04:20,200 --> 01:05:02,650
met wysers, wat jy kan doen, is iets soos, laat ons sê, int ** pp = malloc (sizeof (int *) * 5);

758
01:05:02,650 --> 01:05:06,900
Ek sal net skryf dit alles uit die eerste.

759
01:05:37,880 --> 01:05:41,020
Ek wou nie dat 'n mens.

760
01:05:41,020 --> 01:05:42,550
Okay.

761
01:05:42,550 --> 01:05:48,910
Wat ek hier gedoen het is - Dit moet pp [i].

762
01:05:48,910 --> 01:05:53,680
So pp is 'n verwysing na 'n wyser.

763
01:05:53,680 --> 01:06:02,420
Jy mallocing pp om te verwys na 'n verskeidenheid van 5 int sterre.

764
01:06:02,420 --> 01:06:10,950
So jy het in die geheue op die stapel pp.

765
01:06:10,950 --> 01:06:20,150
Dit gaan om te verwys na 'n verskeidenheid van 5 blokke wat almal hulself wysers.

766
01:06:20,150 --> 01:06:28,210
En dan wanneer ek malloc af hier, ek malloc dat elk van die individuele verwysings

767
01:06:28,210 --> 01:06:32,080
moet verwys na 'n afsonderlike blok van 4 grepe op die hoop.

768
01:06:32,080 --> 01:06:35,870
So hierdie punte tot 4 grepe.

769
01:06:37,940 --> 01:06:40,660
En hierdie een punte na 'n ander 4 grepe.

770
01:06:40,660 --> 01:06:43,200
>> En almal van hulle aan hul eie 4 bytes.

771
01:06:43,200 --> 01:06:49,080
Dit gee my 'n manier van die multidimensionele dinge te doen.

772
01:06:49,080 --> 01:06:58,030
Ek kon sê pp [3] [4], maar nou is dit nie dieselfde ding as multidimensionele skikkings

773
01:06:58,030 --> 01:07:05,390
omdat multidimensionele skikkings vertaal [3] [4] in 'n enkele verreken in die x-skikking.

774
01:07:05,390 --> 01:07:14,790
Hierdie dereferences p, toegang tot die derde indeks, dan dereferences dat

775
01:07:14,790 --> 01:07:20,790
en toegange - 4 ongeldig sou wees - die tweede indeks.

776
01:07:24,770 --> 01:07:31,430
AANGESIEN dat toe ons die int x [3] [4] voor as 'n multi-dimensionele skikking

777
01:07:31,430 --> 01:07:35,740
en wanneer jy dubbel bracket dit is regtig net 'n enkele dereference,

778
01:07:35,740 --> 01:07:40,490
jy na 'n enkele wyser en dan 'n offset,

779
01:07:40,490 --> 01:07:42,850
hierdie is regtig 2D verwysings.

780
01:07:42,850 --> 01:07:45,840
Jy volg 2 aparte wenke.

781
01:07:45,840 --> 01:07:50,420
So het dit ook tegnies kan jy multidimensionele skikkings te hê

782
01:07:50,420 --> 01:07:53,550
waar elke individu skikking is verskillende groottes.

783
01:07:53,550 --> 01:07:58,000
So ek dink kronkelende multidimensionele skikkings is wat dit genoem word

784
01:07:58,000 --> 01:08:01,870
sedert die eerste ding wat werklik kan verwys na iets wat 10 elemente,

785
01:08:01,870 --> 01:08:05,540
die tweede ding kan verwys na iets wat 100 elemente.

786
01:08:05,540 --> 01:08:10,790
[Student] Is daar 'n beperking op die aantal van die wenke wat jy kan hê

787
01:08:10,790 --> 01:08:14,290
wys aan ander wenke? >> No.

788
01:08:14,290 --> 01:08:17,010
Jy kan int ***** p.

789
01:08:18,050 --> 01:08:23,760
Terug na pointer rekenkundige - >> [student] Oh. >> Ja.

790
01:08:23,760 --> 01:08:35,649
[Student] As ek int *** p en dan doen ek 'n ontwysing en Ek sê p * is gelyk aan hierdie waarde,

791
01:08:35,649 --> 01:08:39,560
is dit net 1 vlak van ontwysing te doen? >> Ja.

792
01:08:39,560 --> 01:08:43,340
So as ek wil om toegang te verkry tot die ding wat die laaste wyser wys -

793
01:08:43,340 --> 01:08:46,210
Dan doen jy *** p. >> Goed.

794
01:08:46,210 --> 01:08:54,080
So, dit is p punte tot 1 blok, punte na 'n ander blok, punte na 'n ander blok.

795
01:08:54,080 --> 01:09:02,010
Dan as jy dit doen * p = iets anders, dan is jy is besig om te verander hierdie

796
01:09:02,010 --> 01:09:13,640
nou verwys na 'n ander blok. >> Goed.

797
01:09:13,640 --> 01:09:17,649
>> [Bowden] En as hierdie malloced, dan is jy het nou geheue gelek

798
01:09:17,649 --> 01:09:20,430
tensy jy gebeur verskillende verwysings van hierdie

799
01:09:20,430 --> 01:09:25,270
want jy kan nie terug te kry vir diegene wat wat jy net weggegooi.

800
01:09:25,270 --> 01:09:29,550
Pointer rekenkunde.

801
01:09:29,550 --> 01:09:36,310
int x [4]; gaan om 'n verskeidenheid van 4 heelgetalle te ken

802
01:09:36,310 --> 01:09:40,670
waar x gaan om te verwys na die begin van die skikking.

803
01:09:40,670 --> 01:09:50,420
So as ek sê iets soos x [1], ek wil gaan na die tweede heelgetal in die skikking te beteken,

804
01:09:50,420 --> 01:09:53,319
wat sou hierdie een wees.

805
01:09:53,319 --> 01:10:04,190
Maar regtig, dit is 4 grepe in die skikking aangesien hierdie heelgetal neem 4 bytes.

806
01:10:04,190 --> 01:10:08,470
So 'n afset van 1 beteken regtig 'n afset van 1

807
01:10:08,470 --> 01:10:12,030
keer die grootte van ongeag die tipe van die skikking is.

808
01:10:12,030 --> 01:10:17,170
Dit is 'n verskeidenheid van heelgetalle, so dit weet 1 keer grootte van die int te doen wanneer dit wil verreken.

809
01:10:17,170 --> 01:10:25,260
Die ander sintaksis. Onthou dat dit gelykstaande aan * (x + 1);

810
01:10:25,260 --> 01:10:35,250
Toe ek sê wyser + 1, wat opbrengste is die adres wat die wyser in die stoor

811
01:10:35,250 --> 01:10:40,360
plus 1 keer die grootte van die tipe van die wyser.

812
01:10:40,360 --> 01:10:59,510
So as x = ox100, dan is x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
En jy kan misbruik en iets sê soos: char * c = (char *) x;

814
01:11:19,750 --> 01:11:23,050
en nou C is gaan na dieselfde adres as x wees.

815
01:11:23,050 --> 01:11:26,040
c gaan wees gelyk aan ox100,

816
01:11:26,040 --> 01:11:31,490
maar c + 1 gaan wees gelyk aan ox101

817
01:11:31,490 --> 01:11:38,030
sedert pointer rekenkundige hang af van die tipe van die wyser wat jy toe te voeg tot.

818
01:11:38,030 --> 01:11:45,390
So c + 1, dit lyk op c, dit is 'n char pointer, so dit gaan 1 keer grootte van char by te voeg,

819
01:11:45,390 --> 01:11:48,110
wat altyd gaan wees 1, so jy kry 101,

820
01:11:48,110 --> 01:11:54,890
terwyl as ek doen x, wat ook nog 100, x + 1 gaan wees 104.

821
01:11:56,660 --> 01:12:06,340
[Student] Kan jy maak gebruik van C + + om jou muis te bevorder deur 1?

822
01:12:06,340 --> 01:12:09,810
Ja, jy kan.

823
01:12:09,810 --> 01:12:16,180
Jy nie kan doen met x want x is net 'n simbool, dit is 'n konstante, jy nie kan verander x.

824
01:12:16,180 --> 01:12:22,610
>> Maar c gebeur net 'n wyser, sodat c + + is volkome geldig en dit sal deur 1 inkrementeer.

825
01:12:22,610 --> 01:12:32,440
As c net 'n int *, dan is c + + 104 word.

826
01:12:32,440 --> 01:12:41,250
+ + Nie wyser rekenkundige net soos c + 1 sou hê pointer rekenkundige gedoen.

827
01:12:43,000 --> 01:12:48,870
Dit is eintlik hoe 'n baie van die dinge soos merge soort -

828
01:12:49,670 --> 01:12:55,710
In plaas van die skep van kopieë van dinge, kan jy plaas slaag -

829
01:12:55,710 --> 01:13:02,400
Soos as ek wou om die helfte van die skikking te slaag - laat sommige van hierdie vee.

830
01:13:04,770 --> 01:13:10,520
Kom ons sê ek wou hierdie kant van die skikking te slaag in 'n funksie.

831
01:13:10,520 --> 01:13:12,700
Wat sou ek slaag om daardie funksie?

832
01:13:12,700 --> 01:13:17,050
As ek slaag x, ek verby hierdie adres.

833
01:13:17,050 --> 01:13:23,780
Maar ek wil hierdie spesifieke adres te slaag. So, wat moet ek slaag?

834
01:13:23,780 --> 01:13:26,590
[Student] Pointer + 2?

835
01:13:26,590 --> 01:13:29,350
[Bowden] So x + 2. Ja.

836
01:13:29,350 --> 01:13:31,620
Wat gaan om hierdie adres te wees.

837
01:13:31,620 --> 01:13:42,810
Jy sal dikwels sien dit ook as x [2] en dan die adres van daardie.

838
01:13:42,810 --> 01:13:47,850
So wat jy nodig het om die adres te neem omdat die bracket is 'n implisiete dereference.

839
01:13:47,850 --> 01:13:53,250
x [2] verwys na die waarde wat in hierdie boks, en dan sal jy wil hê dat die adres van daardie boks,

840
01:13:53,250 --> 01:13:56,850
sodat jy sê & x [2].

841
01:13:56,850 --> 01:14:02,880
So dit is hoe iets in merge soort waar jy wil hê dat die helfte van die lys na iets om te slaag

842
01:14:02,880 --> 01:14:08,790
jy regtig net slaag & x [2], en nou so ver as die rekursiewe oproep betrokke is,

843
01:14:08,790 --> 01:14:12,510
my nuwe skikking begin daar.

844
01:14:12,510 --> 01:14:15,130
Laaste minuut vrae.

845
01:14:15,130 --> 01:14:20,050
[Student] As ons nie 'n ampersand of 'n - wat is dit genoem? >> Star?

846
01:14:20,050 --> 01:14:23,200
[Student] Star. >> Tegnies, dereference operateur, maar - >> [student] Dereference.

847
01:14:23,200 --> 01:14:29,310
>> As ons nie 'n ster of 'n ampersand sit, wat gebeur as ek net y sê = x en x is 'n wyser?

848
01:14:29,310 --> 01:14:34,620
Wat is die tipe van y? >> [Student] Ek sal net sê dit is wyser 2.

849
01:14:34,620 --> 01:14:38,270
So as jy net sê y = x, nou x-en y-punt aan die dieselfde ding. >> [Student] Point aan die dieselfde ding.

850
01:14:38,270 --> 01:14:45,180
En as x is 'n int wyser? >> Dit sou kla want jy kan nie wysers wys.

851
01:14:45,180 --> 01:14:46,540
[Student] Goed.

852
01:14:46,540 --> 01:14:51,860
Onthou dat verwysings, alhoewel ons trek hulle soos pyle,

853
01:14:51,860 --> 01:15:02,010
regtig alles wat hulle winkel - int * x - regtig alle x stoor is iets soos ox100,

854
01:15:02,010 --> 01:15:06,490
wat ons gebeur te stel as wys na die blok gestoor word op 100.

855
01:15:06,490 --> 01:15:19,660
So wanneer ek sê int * y = x; ek net die kopiëring van ox100 in y,

856
01:15:19,660 --> 01:15:24,630
wat ons net gaan voor te stel as y, ook verwys na ox100.

857
01:15:24,630 --> 01:15:39,810
En as Ek sê int i = (int) x; dan sal ek gaan om te slaan wat die waarde van ox100 is

858
01:15:39,810 --> 01:15:45,100
binnekant van dit, maar nou is dit gaan vertolk word as 'n heelgetal in plaas van 'n wyser.

859
01:15:45,100 --> 01:15:49,310
Maar jy moet die cast of anders sal dit kla.

860
01:15:49,310 --> 01:15:53,300
[Student] So bedoel jy om te gooi -

861
01:15:53,300 --> 01:16:00,290
Gaan dit beslissende int van x of beslissende int van y?

862
01:16:00,290 --> 01:16:03,700
[Bowden] Wat?

863
01:16:03,700 --> 01:16:07,690
[Student] Goed. Na hierdie hakies is daar gaan 'n x of ay daar?

864
01:16:07,690 --> 01:16:11,500
>> [Bowden] nie. x en y is ekwivalent. >> [Student] Goed.

865
01:16:11,500 --> 01:16:14,390
Want hulle is albei wysers. >> Ja.

866
01:16:14,390 --> 01:16:21,050
[Student] So dit sou die stoor van die heksadesimale 100 in heelgetal vorm? >> [Bowden] Ja.

867
01:16:21,050 --> 01:16:23,620
Maar dit is nie die waarde van wat dit ookal wys na.

868
01:16:23,620 --> 01:16:29,940
[Bowden] Ja. >> [Student] Dus net die adres in heelgetal vorm. Okay.

869
01:16:29,940 --> 01:16:34,720
[Bowden] As jy wou vir sommige vreemd rede,

870
01:16:34,720 --> 01:16:38,900
jy kan uitsluitlik met wysers en nooit gaan met heelgetalle

871
01:16:38,900 --> 01:16:49,240
en net soos int * x = 0.

872
01:16:49,240 --> 01:16:53,000
Dan is jy gaan om te kry regtig verward wanneer wyser rekenkundige begin gebeur.

873
01:16:53,000 --> 01:16:56,570
So het die getalle wat hulle slaan is betekenisloos.

874
01:16:56,570 --> 01:16:58,940
Dit is net hoe jy beland hulle interpretasie.

875
01:16:58,940 --> 01:17:02,920
Dus is ek vry ox100 te kopieer van 'n int * na 'n int,

876
01:17:02,920 --> 01:17:07,790
en ek is vry om te wys jy's waarskynlik gaan om te skree nie vir die beslissende -

877
01:17:07,790 --> 01:17:18,160
Ek is vry om te wys iets soos (int *) ox1234 in hierdie arbitrêre int *.

878
01:17:18,160 --> 01:17:25,480
So ox123 is net so geldig 'n geheue adres & y.

879
01:17:25,480 --> 01:17:32,060
& Y gebeur iets wat pretty much ox123 om terug te keer.

880
01:17:32,060 --> 01:17:35,430
[Student] Sou dit werklik 'n koel manier om te gaan van heksadesimaal desimale vorm,

881
01:17:35,430 --> 01:17:39,230
soos as jy 'n wyser en jy gooi dit as 'n int?

882
01:17:39,230 --> 01:17:44,860
[Bowden] Jy kan regtig net print soos printf gebruik.

883
01:17:44,860 --> 01:17:50,300
Kom ons sê ek het int y = 100.

884
01:17:50,300 --> 01:18:02,700
So printf (% d \ n - as jy reeds behoort te weet - druk as 'n heelgetal,% x.

885
01:18:02,700 --> 01:18:05,190
Ons sal net druk dit as heksadesimale.

886
01:18:05,190 --> 01:18:10,760
So 'n wyser is nie gestoor as heksadesimaal,

887
01:18:10,760 --> 01:18:12,960
en 'n heelgetal is nie gestoor as desimale.

888
01:18:12,960 --> 01:18:14,700
Alles wat gestoor word as binêre.

889
01:18:14,700 --> 01:18:17,950
Dit is net dat ons geneig is wenke om te wys as heksadesimale

890
01:18:17,950 --> 01:18:23,260
omdat ons dink dat van die dinge wat in hierdie 4-byte blokke,

891
01:18:23,260 --> 01:18:25,390
en geheue adresse is geneig om vertroud te wees.

892
01:18:25,390 --> 01:18:28,890
Ons is soos, as dit begin met bf, dan is dit gebeur om te wees op die stapel.

893
01:18:28,890 --> 01:18:35,560
So dit is net ons interpretasie van wysers as heksadesimale.

894
01:18:35,560 --> 01:18:39,200
Okay. Enige laaste vrae?

895
01:18:39,200 --> 01:18:41,700
>> Ek sal hier wees vir 'n bietjie na as jy enigiets anders.

896
01:18:41,700 --> 01:18:46,070
En dit is die einde van daardie.

897
01:18:46,070 --> 01:18:48,360
>> [Student] Yay! [Applous]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]