1
00:00:00,000 --> 00:00:02,520
[Powered by Google Translate] [Secció 4 - Més Còmode]

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

3
00:00:04,850 --> 00:00:07,370
[Aquesta és CS50. - CS50.TV]

4
00:00:08,920 --> 00:00:13,350
Tenim un futur examen, en cas que vostès no ho sabia.

5
00:00:14,810 --> 00:00:20,970
És, bàsicament, en tot el que podria haver vist a classe o haurien d'haver vist a classe.

6
00:00:20,970 --> 00:00:26,360
Això inclou els punters, tot i que és un tema molt recent.

7
00:00:26,360 --> 00:00:29,860
Almenys ha de comprendre els alts nivells de les mateixes.

8
00:00:29,860 --> 00:00:34,760
Tot el que passés en la classe que vostè ha d'entendre per al concurs.

9
00:00:34,760 --> 00:00:37,320
Així que si vostè té preguntes sobre ells, vostè pot demanar ara.

10
00:00:37,320 --> 00:00:43,280
Però això serà una sessió molt dirigida pels estudiants on vostès fer preguntes,

11
00:00:43,280 --> 00:00:45,060
així que espero que la gent té preguntes.

12
00:00:45,060 --> 00:00:48,020
Algú té alguna pregunta?

13
00:00:49,770 --> 00:00:52,090
Sí >> [Estudiant] Es pot passar punters de nou?

14
00:00:52,090 --> 00:00:54,350
Vaig a anar més punters.

15
00:00:54,350 --> 00:00:59,180
Totes les variables necessàriament viuen en la memòria,

16
00:00:59,180 --> 00:01:04,450
però en general vostè no es preocupi per això i només dius x + 2 i + 3 i

17
00:01:04,450 --> 00:01:07,080
i el compilador s'adonaran que les coses s'estan vivint per tu.

18
00:01:07,080 --> 00:01:12,990
Quan vostè està tractant amb punters, ara que està explícitament usant aquestes adreces de memòria.

19
00:01:12,990 --> 00:01:19,800
Així que una sola variable només alguna vegada viure en una sola direcció en un moment donat.

20
00:01:19,800 --> 00:01:24,040
Si volem declarar un punter, el que el tipus semblarà?

21
00:01:24,040 --> 00:01:26,210
>> Vull declarar un punter p. Què significa el tipus sembla?

22
00:01:26,210 --> 00:01:33,530
[Estudiant] int * p. Sí >>. Així int * p.

23
00:01:33,530 --> 00:01:38,030
I com puc fer que apunti a x? >> [Estudiant] Ampersand.

24
00:01:40,540 --> 00:01:45,300
[Bowden] Així és, literalment, diu ampersand la direcció de l'operador.

25
00:01:45,300 --> 00:01:50,460
Així que quan dic x i s'està fent la direcció de memòria de la variable x.

26
00:01:50,460 --> 00:01:56,790
Així que ara tinc el punter p, i en qualsevol part del meu codi que pugui utilitzar p *

27
00:01:56,790 --> 00:02:02,960
o podria utilitzar x, i serà exactament el mateix.

28
00:02:02,960 --> 00:02:09,520
(* P). Què fa això? Què fa que l'estrella de dir?

29
00:02:09,520 --> 00:02:13,120
[Estudiant] Es refereix a un valor en aquest punt. Sí >>.

30
00:02:13,120 --> 00:02:17,590
Així que si ens fixem en ell, pot ser molt útil per extreure els diagrames

31
00:02:17,590 --> 00:02:22,230
on es tracta d'una petita caixa de memòria per x, que passa a tenir el valor 4,

32
00:02:22,230 --> 00:02:25,980
llavors tenim una petita caixa de memòria per p,

33
00:02:25,980 --> 00:02:31,590
pel que p apunta x, de manera que dibuixar una fletxa de p per x.

34
00:02:31,590 --> 00:02:40,270
Així que quan diem que p * que estem dient vagi a la caixa que és p.

35
00:02:40,270 --> 00:02:46,480
Star és seguir la fletxa i després fer el que vulguis amb aquesta caixa aquí.

36
00:02:46,480 --> 00:03:01,090
Així que puc dir * p = 7, i que anirà a la caixa que és x i el canvi que a 7.

37
00:03:01,090 --> 00:03:13,540
O podria dir z = int * p * 2; Això és confús, ja que l'estrella, estrella.

38
00:03:13,540 --> 00:03:19,230
L'estrella es desreferencia p, l'altra estrella es multiplica per 2.

39
00:03:19,230 --> 00:03:26,780
Recordeu que podria tenir tan bé substituir el p * amb x.

40
00:03:26,780 --> 00:03:29,430
Vostè les pot utilitzar de la mateixa manera.

41
00:03:29,430 --> 00:03:38,000
I més tard que pot tenir el punt P a una cosa completament nova.

42
00:03:38,000 --> 00:03:42,190
Jo només puc dir p = &z;

43
00:03:42,190 --> 00:03:44,940
Així que ara ap ja no porta x, sinó que apunta a z.

44
00:03:44,940 --> 00:03:50,510
I cada vegada que faig p * és el mateix que fer z.

45
00:03:50,510 --> 00:03:56,170
Així que l'útil d'això és que una vegada que comença a rebre en funcions.

46
00:03:56,170 --> 00:03:59,790
>> És una mica inútil per declarar un punter que apunta a alguna cosa

47
00:03:59,790 --> 00:04:03,140
i si un l'eliminació de referències

48
00:04:03,140 --> 00:04:06,060
quan es podria haver utilitzat la variable original, per començar.

49
00:04:06,060 --> 00:04:18,190
Però quan et fiques en funcions - així que anem a dir que tenim alguna funció, int foo,

50
00:04:18,190 --> 00:04:32,810
que pren un punter i només fa * p = 6;

51
00:04:32,810 --> 00:04:39,990
Com hem vist abans, amb swap, no es pot fer una permuta d'efectiu i una funció separada

52
00:04:39,990 --> 00:04:45,180
amb només passar sencers perquè tot en C sempre passa per valor.

53
00:04:45,180 --> 00:04:48,360
Fins i tot quan estàs passant punters estàs passant per valor.

54
00:04:48,360 --> 00:04:51,940
El que passa és que aquests valors són adreces de memòria.

55
00:04:51,940 --> 00:05:00,770
Així que quan dic foo (p), estic passant el punter a la funció foo

56
00:05:00,770 --> 00:05:03,910
i després foo està fent * p = 6;

57
00:05:03,910 --> 00:05:08,600
Així que dins d'aquesta funció, * p segueix sent equivalent a x,

58
00:05:08,600 --> 00:05:12,720
però no puc utilitzar x dins d'aquesta funció, perquè no és d'àmbit dins d'aquesta funció.

59
00:05:12,720 --> 00:05:19,510
Així que * p = 6 és l'única manera en què pot accedir a una variable local des d'una altra funció.

60
00:05:19,510 --> 00:05:23,600
O, bé, els punters són l'única manera en què pot accedir a una variable local des d'una altra funció.

61
00:05:23,600 --> 00:05:31,600
[Estudiant] Anem a dir que volia tornar un punter. ¿Exactament com es fa això?

62
00:05:31,600 --> 00:05:44,270
[Bowden] Retorna un punter com en alguna cosa com int i = 3; & i tornada? >> [Estudiant] Yeah.

63
00:05:44,270 --> 00:05:48,480
[Bowden] Bé. Vostè mai ha de fer això. Això és dolent.

64
00:05:48,480 --> 00:05:59,480
Crec que he vist en aquestes diapositives de conferències que va començar a veure aquest diagrama complet de la memòria

65
00:05:59,480 --> 00:06:02,880
on fins aquí tens la direcció de memòria 0

66
00:06:02,880 --> 00:06:09,550
i aquí tens la direcció de memòria 4 gigues o 2 a la 32.

67
00:06:09,550 --> 00:06:15,120
Així que tens algunes coses i algunes coses i després tens el teu stack

68
00:06:15,120 --> 00:06:21,780
i tens el teu munt, que acaba de començar a aprendre sobre, creixent.

69
00:06:21,780 --> 00:06:24,390
[Estudiant] No és el munt sobre de la pila?

70
00:06:24,390 --> 00:06:27,760
>> Si. El munt és a dalt, no? >> [Estudiant] Bé, posar 0 a la part superior.

71
00:06:27,760 --> 00:06:30,320
[Estudiant] Oh, posar 0 a la part superior. >> [Estudiant] Oh, està bé.

72
00:06:30,320 --> 00:06:36,060
Descàrrec de responsabilitat: En qualsevol lloc amb CS50 veuràs d'aquesta manera. >> [Estudiant] Bé.

73
00:06:36,060 --> 00:06:40,290
És només que quan estàs veient primer les piles,

74
00:06:40,290 --> 00:06:45,000
com quan vostè pensa en una pila penses d'apilar coses sobre de l'altra.

75
00:06:45,000 --> 00:06:50,810
Per tant, tendeixen a girar al voltant d'aquest de manera que la pila està creixent com una pila de costum

76
00:06:50,810 --> 00:06:55,940
en lloc de la pila penjant cap avall. >> [Els estudiants] no munts tècnicament créixer massa, però?

77
00:06:55,940 --> 00:07:01,100
Depèn del que entenguis per créixer.

78
00:07:01,100 --> 00:07:04,010
La pila i pila sempre créixer en direccions oposades.

79
00:07:04,010 --> 00:07:09,420
Una pila sempre està creixent en el sentit que està creixent

80
00:07:09,420 --> 00:07:12,940
l'augment de les adreces de la memòria i el munt creix cap avall

81
00:07:12,940 --> 00:07:17,260
en què està creixent cap a direccions baixes de memòria.

82
00:07:17,260 --> 00:07:20,250
Així que la part superior és 0 i la part inferior és d'alta direcció de memòria.

83
00:07:20,250 --> 00:07:26,390
Els dos estan en creixement, només en direccions oposades.

84
00:07:26,390 --> 00:07:29,230
[Estudiant] Jo només volia dir que perquè vostè ha dit que posar la pila a la part inferior

85
00:07:29,230 --> 00:07:33,640
perquè sembla més intuïtiu perquè per a la pila per començar a la part superior d'un munt,

86
00:07:33,640 --> 00:07:37,520
pila està per sobre de si mateix també, així que això és - >> Yeah.

87
00:07:37,520 --> 00:07:44,960
També pensar en el munt com creixia i més gran, però la pila més.

88
00:07:44,960 --> 00:07:50,280
Així que la pila és la que ens tipus de ganes de mostrar el seu creixement.

89
00:07:50,280 --> 00:07:55,390
Però a tot arreu es mira d'una altra manera es mostrarà l'adreça 0 a la part superior

90
00:07:55,390 --> 00:07:59,590
i la direcció de memòria més alta a la part inferior, de manera que aquest és la seva vista habitual de la memòria.

91
00:07:59,590 --> 00:08:02,100
>> Té una pregunta?

92
00:08:02,100 --> 00:08:04,270
[Estudiant] Pots dir-nos més sobre la pila?

93
00:08:04,270 --> 00:08:06,180
Si. Vaig a arribar a això en un segon.

94
00:08:06,180 --> 00:08:12,220
En primer lloc, per què tornar a tornar i que i és una cosa dolenta,

95
00:08:12,220 --> 00:08:18,470
a la pila té un munt de marcs de pila que representen totes les funcions

96
00:08:18,470 --> 00:08:20,460
que han estat cridats.

97
00:08:20,460 --> 00:08:27,990
Així que fent cas omís de les coses anteriors, la part superior de la pila sempre serà la funció principal

98
00:08:27,990 --> 00:08:33,090
ja que és la primera funció que està sent anomenat.

99
00:08:33,090 --> 00:08:37,130
I després, quan es diu a una altra funció, la pila creixerà cap avall.

100
00:08:37,130 --> 00:08:41,640
Així que si dic a alguna funció, foo, i es posa el seu propi marc de pila,

101
00:08:41,640 --> 00:08:47,280
pot trucar a alguna funció, bar, sinó que obté el seu propi marc de pila.

102
00:08:47,280 --> 00:08:49,840
I bar podia ser recursiva i pot anomenar-se a si mateixa,

103
00:08:49,840 --> 00:08:54,150
i perquè la segona crida a la barra es va a posar el seu propi marc de pila.

104
00:08:54,150 --> 00:08:58,880
I així, el que passa en aquests marcs de pila són totes les variables locals

105
00:08:58,880 --> 00:09:03,450
i tots els arguments de la funció que -

106
00:09:03,450 --> 00:09:08,730
Les coses que són d'àmbit local a aquesta funció vagi en aquests marcs de pila.

107
00:09:08,730 --> 00:09:21,520
Això vol dir que quan em va dir alguna cosa així com bar és una funció,

108
00:09:21,520 --> 00:09:29,270
Només vaig a declarar un sencer i després tornar un punter a aquest sencer.

109
00:09:29,270 --> 00:09:33,790
Llavors, on i viure?

110
00:09:33,790 --> 00:09:36,900
[Estudiant] i viu al bar. >> [Bowden] Yeah.

111
00:09:36,900 --> 00:09:45,010
En algun lloc d'aquesta petita plaça de la memòria és una plaça més escassos i que té en ella.

112
00:09:45,010 --> 00:09:53,370
Quan torni & i, estic tornant un punter a aquest petit bloc de memòria.

113
00:09:53,370 --> 00:09:58,400
Però quan una funció retorna, el seu marc de pila s'extreu de la pila.

114
00:10:01,050 --> 00:10:03,530
I és per això que es diu pila.

115
00:10:03,530 --> 00:10:06,570
És com si l'estructura de dades pila, si saps el que és.

116
00:10:06,570 --> 00:10:11,580
O fins i tot com una pila de safates és sempre l'exemple,

117
00:10:11,580 --> 00:10:16,060
principal anirà a la part inferior, la funció primera vegada que truqui s'anirà per sobre d'això,

118
00:10:16,060 --> 00:10:20,400
i no es pot tornar a principal fins que torni de totes les funcions que han estat cridats

119
00:10:20,400 --> 00:10:22,340
que han estat col · locats a la part superior de la mateixa.

120
00:10:22,340 --> 00:10:28,650
>> [Estudiant] Així que si vostè va fer tornar la i &, aquest valor està subjecte a canvis sense previ avís.

121
00:10:28,650 --> 00:10:31,290
Sí, és - >> [estudiant] Podria ser sobreescrit. Sí >>.

122
00:10:31,290 --> 00:10:34,660
És completament - Intentar -

123
00:10:34,660 --> 00:10:38,040
Aquest seria també un bar * int perquè està tornant un punter,

124
00:10:38,040 --> 00:10:41,310
pel que la seva tipus de retorn és int *.

125
00:10:41,310 --> 00:10:46,500
Si voleu utilitzar el valor de retorn d'aquesta funció, és un comportament indefinit

126
00:10:46,500 --> 00:10:51,770
perquè aquest punter apunta al mal record. >> [Estudiant] Bé.

127
00:10:51,770 --> 00:11:01,250
I què si, per exemple, va declarar int * i = malloc (sizeof (int))?

128
00:11:01,250 --> 00:11:03,740
Això està millor. Sí

129
00:11:03,740 --> 00:11:07,730
[Estudiant] Parlem de com les coses quan arrosseguem a la nostra paperera de reciclatge

130
00:11:07,730 --> 00:11:11,750
no estan realment esborrat, nosaltres només perden els seus punters.

131
00:11:11,750 --> 00:11:15,550
Així que en aquest cas és el que realment esborrar el valor o encara hi ha a la memòria?

132
00:11:15,550 --> 00:11:19,130
En la seva major part, estarà encara allà.

133
00:11:19,130 --> 00:11:24,220
Però diguem que ens va passar a cridar a una altra funció, baz.

134
00:11:24,220 --> 00:11:28,990
Baz es va a posar el seu propi marc de pila a aquí.

135
00:11:28,990 --> 00:11:31,470
Serà sobreescriure tot això,

136
00:11:31,470 --> 00:11:34,180
i si després tractar d'utilitzar el punter que va obtenir abans,

137
00:11:34,180 --> 00:11:35,570
no serà el mateix valor.

138
00:11:35,570 --> 00:11:38,150
Hi haurà canviat només perquè es diu el baz funció.

139
00:11:38,150 --> 00:11:43,080
[Estudiant] Però si no nosaltres, que seguim rebent 3?

140
00:11:43,080 --> 00:11:44,990
[Bowden] El més probable és que sí.

141
00:11:44,990 --> 00:11:49,670
Però no es pot confiar en això. C només diu un comportament indefinit.

142
00:11:49,670 --> 00:11:51,920
>> [Estudiant] Oh, sí. Bé.

143
00:11:51,920 --> 00:11:58,190
Així que quan vostè desitja retornar un punter, aquí és on ve malloc en ús.

144
00:12:00,930 --> 00:12:15,960
Estic escrivint en realitat només retorna malloc (3 * sizeof (int)).

145
00:12:17,360 --> 00:12:24,050
Anem a repassar malloc més en un segon, però és la idea de malloc totes les seves variables locals

146
00:12:24,050 --> 00:12:26,760
sempre van a la pila.

147
00:12:26,760 --> 00:12:31,570
Qualsevol cosa que malloced va a la pila, i serà per sempre i sempre estar al munt

148
00:12:31,570 --> 00:12:34,490
fins que explícitament es l'alliberi.

149
00:12:34,490 --> 00:12:42,130
Així que això significa que quan malloc alguna cosa, que va a sobreviure després que la funció torni.

150
00:12:42,130 --> 00:12:46,800
[Estudiant] Va a sobreviure després que el programa deixi de funcionar? No >>

151
00:12:46,800 --> 00:12:53,180
Molt bé, així que va a ser-hi fins que el programa és tot el camí fet córrer. Sí >>.

152
00:12:53,180 --> 00:12:57,510
Podem repassar els detalls del que succeeix quan el programa deixa d'executar.

153
00:12:57,510 --> 00:13:02,150
És possible que necessiti que em recordi, però això és una cosa separada del tot.

154
00:13:02,150 --> 00:13:04,190
[Estudiant] Així malloc crea un punter? Sí >>.

155
00:13:04,190 --> 00:13:13,030
Malloc - >> [estudiant] Crec que malloc designa un bloc de memòria que pot utilitzar un punter.

156
00:13:15,400 --> 00:13:19,610
[Bowden] Vull aquest diagrama nou. >> [Estudiant] Així funciona aquesta funció, però?

157
00:13:19,610 --> 00:13:26,430
[Estudiant] Sí, malloc designa un bloc de memòria que pot utilitzar,

158
00:13:26,430 --> 00:13:30,470
i, a continuació, torna la direcció del primer bloc d'aquesta memòria.

159
00:13:30,470 --> 00:13:36,750
>> [Bowden] Yeah. Així que quan malloc, que està agafant una mica de bloc de memòria

160
00:13:36,750 --> 00:13:38,260
que està actualment en el munt.

161
00:13:38,260 --> 00:13:43,040
Si la pila és massa petit, llavors el munt és només creixerà, i que creix en aquesta direcció.

162
00:13:43,040 --> 00:13:44,650
Així que diguem que la pila és massa petit.

163
00:13:44,650 --> 00:13:49,960
Després es tracta de fer créixer una mica i tornar un punter a aquest bloc que acaba de créixer.

164
00:13:49,960 --> 00:13:55,130
Quan coses gratis, que està fent més espai en el munt,

165
00:13:55,130 --> 00:14:00,030
Així que una tarda trucar a malloc pot reutilitzar la memòria que havia alliberat prèviament.

166
00:14:00,030 --> 00:14:09,950
L'important de malloc i lliure és el que li dóna un control complet

167
00:14:09,950 --> 00:14:12,700
durant la vida útil d'aquests blocs de memòria.

168
00:14:12,700 --> 00:14:15,420
Les variables globals són sempre viva.

169
00:14:15,420 --> 00:14:18,500
Les variables locals són vius dins del seu àmbit d'aplicació.

170
00:14:18,500 --> 00:14:22,140
Així que es passa d'una clau, les variables locals estan morts.

171
00:14:22,140 --> 00:14:28,890
Memòria Malloced és viu quan vostè vol que sigui viu

172
00:14:28,890 --> 00:14:33,480
i després s'allibera quan l'hi dius a ser posat en llibertat.

173
00:14:33,480 --> 00:14:38,420
Aquestes són realment les úniques tres tipus de memòria, la veritat.

174
00:14:38,420 --> 00:14:41,840
Hi gestió de memòria automàtica, que és la pila.

175
00:14:41,840 --> 00:14:43,840
Les coses succeeixen de forma automàtica.

176
00:14:43,840 --> 00:14:46,910
Quan dius int x, s'assigna memòria per x int.

177
00:14:46,910 --> 00:14:51,630
Quan x està fora d'àmbit, la memòria es recupera per x.

178
00:14:51,630 --> 00:14:54,790
Després hi ha la gestió de memòria dinàmica, que és el que malloc és,

179
00:14:54,790 --> 00:14:56,740
que és quan vostè té el control.

180
00:14:56,740 --> 00:15:01,290
Vostè decideix quan dinàmicament la memòria ha i no ha de ser assignat.

181
00:15:01,290 --> 00:15:05,050
I després hi estàtica, el que significa que només viu per sempre,

182
00:15:05,050 --> 00:15:06,610
que és el que són les variables globals.

183
00:15:06,610 --> 00:15:10,240
Només estan sempre en la memòria.

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

185
00:15:14,490 --> 00:15:17,230
[Estudiant] Es pot definir un bloc només mitjançant l'ús de claus

186
00:15:17,230 --> 00:15:21,220
però no haver de tenir una? if o while o alguna cosa per l'estil

187
00:15:21,220 --> 00:15:29,130
Es pot definir com un bloc en una funció, però que té les claus també.

188
00:15:29,130 --> 00:15:32,100
[Estudiant] Pel que no es pot tenir com un parell de claus a l'atzar en el codi

189
00:15:32,100 --> 00:15:35,680
que té variables locals? >> Sí, es pot.

190
00:15:35,680 --> 00:15:45,900
A l'interior de la barra int podríem tenir {int i = 3;}.

191
00:15:45,900 --> 00:15:48,440
Que se suposa que és just aquí.

192
00:15:48,440 --> 00:15:52,450
Però això defineix completament l'abast de int i.

193
00:15:52,450 --> 00:15:57,320
Després que la segona clau, i no es pot utilitzar més.

194
00:15:57,910 --> 00:16:00,630
Gairebé mai faig això, però.

195
00:16:02,940 --> 00:16:07,370
Tornant al que succeeix quan un programa acaba,

196
00:16:07,370 --> 00:16:18,760
hi ha una mena de mentida error / mitjà que li donem per tal de fer només les coses més fàcils.

197
00:16:18,760 --> 00:16:24,410
Els diem que quan s'assigna memòria

198
00:16:24,410 --> 00:16:29,860
que està assignant part tros de RAM per a aquesta variable.

199
00:16:29,860 --> 00:16:34,190
Però vostè no està realment en contacte directe amb RAM mai en els seus programes.

200
00:16:34,190 --> 00:16:37,490
Si es pensa en això, com vaig dibuixar -

201
00:16:37,490 --> 00:16:44,330
I de fet, si vostè va a través de GDB veurà la mateixa cosa.

202
00:16:51,120 --> 00:16:57,590
Sense importar quantes vegades s'executa el programa o quin programa està funcionant,

203
00:16:57,590 --> 00:16:59,950
la pila sempre començarà -

204
00:16:59,950 --> 00:17:06,510
sempre veuràs les variables voltant d'alguna cosa oxbffff direcció.

205
00:17:06,510 --> 00:17:09,470
En general, en algun lloc d'aquesta regió.

206
00:17:09,470 --> 00:17:18,760
Però, com pot possiblement tenir 2 programes punters a aquesta memòria?

207
00:17:20,640 --> 00:17:27,650
[Estudiant] Hi ha una mica de designació arbitrària de oxbfff on se suposa que ha d'estar a la RAM

208
00:17:27,650 --> 00:17:31,320
que en realitat pot estar en diferents llocs depenent de quan la funció va ser cridada.

209
00:17:31,320 --> 00:17:35,920
Si. El terme és la memòria virtual.

210
00:17:35,920 --> 00:17:42,250
La idea és que cada procés, cada programa que s'executa a l'ordinador

211
00:17:42,250 --> 00:17:49,450
té el seu propi - suposem - 32 bits espai d'adreces completament independent.

212
00:17:49,450 --> 00:17:51,590
Aquest és l'espai d'adreces.

213
00:17:51,590 --> 00:17:56,220
Té els seus propis completament independents 4 gigabytes per al seu ús.

214
00:17:56,220 --> 00:18:02,220
>> Així que si vostè executa dos programes a la vegada, aquest programa de 4 gigabytes veu a si mateix,

215
00:18:02,220 --> 00:18:04,870
Aquest programa de 4 gigabytes veu a si mateix,

216
00:18:04,870 --> 00:18:07,720
i és impossible que aquest programa per eliminar la referència d'un punter

217
00:18:07,720 --> 00:18:10,920
i acabar amb la memòria d'aquest programa.

218
00:18:10,920 --> 00:18:18,200
I què és la memòria virtual és una assignació d'un espai d'adreces de processos

219
00:18:18,200 --> 00:18:20,470
a les coses reals de RAM.

220
00:18:20,470 --> 00:18:22,940
Així que depèn del seu sistema operatiu per saber que,

221
00:18:22,940 --> 00:18:28,080
hey, quan aquest tipus oxbfff desreferencia punter, que és exactament

222
00:18:28,080 --> 00:18:31,040
que vol byte RAM 1000,

223
00:18:31,040 --> 00:18:38,150
mentre que si aquest programa oxbfff desreferencia, que realment vol byte RAM 10000.

224
00:18:38,150 --> 00:18:41,590
Poden ser arbitràriament lluny.

225
00:18:41,590 --> 00:18:48,730
Això és cert fins i tot de les coses dins d'un espai d'adreces de processos únic.

226
00:18:48,730 --> 00:18:54,770
Així que, com veu els 4 gigabytes a si mateix, però direm -

227
00:18:54,770 --> 00:18:57,290
[Estudiant] Cada procés individual -

228
00:18:57,290 --> 00:19:01,350
Diguem que vostè té un ordinador amb només 4 GB de RAM.

229
00:19:01,350 --> 00:19:06,430
Té cada procés veu els 4 gigabytes sencers? Sí >>.

230
00:19:06,430 --> 00:19:13,060
Però els 4 gigabytes que veu és una mentida.

231
00:19:13,060 --> 00:19:20,460
És només que pensa que té tot això de memòria, ja que no conec cap altre procés existeix.

232
00:19:20,460 --> 00:19:28,140
Només s'utilitzarà la memòria tot el que realment necessita.

233
00:19:28,140 --> 00:19:32,340
El sistema operatiu no es donarà a aquest procés RAM

234
00:19:32,340 --> 00:19:35,750
si no s'utilitza cap memòria en tota aquesta regió.

235
00:19:35,750 --> 00:19:39,300
No va a donar-li la memòria d'aquesta regió.

236
00:19:39,300 --> 00:19:54,780
Però la idea és que - Estic tractant de pensar - No puc pensar en una analogia.

237
00:19:54,780 --> 00:19:56,780
Les analogies són difícils.

238
00:19:57,740 --> 00:20:02,700
Un dels temes de la memòria virtual o una de les coses que està resolent

239
00:20:02,700 --> 00:20:06,810
és que els processos han de ser completament inconscient d'un a l'altre.

240
00:20:06,810 --> 00:20:12,140
I perquè pugui escriure qualsevol programa que acaba d'desreferencia qualsevol punter,

241
00:20:12,140 --> 00:20:19,340
com acaba d'escriure un programa que diu * (ox1234),

242
00:20:19,340 --> 00:20:22,890
i que la memòria dereferencing direcció 1234.

243
00:20:22,890 --> 00:20:28,870
>> Però depèn del sistema operatiu per traduir Llavors, què significa 1234.

244
00:20:28,870 --> 00:20:33,960
Així que si 1234 resulta ser una adreça de memòria vàlida per aquest procés,

245
00:20:33,960 --> 00:20:38,800
com si estigués a la pila o alguna cosa així, llavors això va a tornar el valor d'aquesta adreça de memòria

246
00:20:38,800 --> 00:20:41,960
de manera que el procés sap.

247
00:20:41,960 --> 00:20:47,520
Però si 1234 no és una adreça vàlida, tal com passa a la terra

248
00:20:47,520 --> 00:20:52,910
en algun trosset de memòria aquí que està més enllà de la pila i el munt més enllà

249
00:20:52,910 --> 00:20:57,200
i no s'ha utilitzat realment això, llavors és quan vostè aconsegueix coses com segfaults

250
00:20:57,200 --> 00:21:00,260
perquè estàs tocant de memòria que no s'ha de tocar.

251
00:21:07,180 --> 00:21:09,340
Això també és cert -

252
00:21:09,340 --> 00:21:15,440
Un sistema de 32-bits, 32 bits vol dir que vostè té 32 bits per definir una adreça de memòria.

253
00:21:15,440 --> 00:21:22,970
És per això que els punters són 8 bytes ja que 32 bits són 8 bytes - o 4 bytes.

254
00:21:22,970 --> 00:21:25,250
Els punters són 4 bytes.

255
00:21:25,250 --> 00:21:33,680
Així que quan vostè veu un punter com oxbfffff, que és -

256
00:21:33,680 --> 00:21:40,080
Dins de qualsevol programa atès que només pot construir qualsevol punter arbitrari,

257
00:21:40,080 --> 00:21:46,330
en qualsevol lloc de ox0 bou a 8 f 's - FFFFFFFF.

258
00:21:46,330 --> 00:21:49,180
[Estudiant] No diuen que són 4 bytes? Sí >>.

259
00:21:49,180 --> 00:21:52,730
[Estudiant] Després, cada byte té - >> [Bowden] Hexadecimal.

260
00:21:52,730 --> 00:21:59,360
Hexadecimal - 5, 6, 7, 8. Així punters que veuràs sempre en hexadecimal.

261
00:21:59,360 --> 00:22:01,710
És només la manera com classificar punters.

262
00:22:01,710 --> 00:22:05,240
Cada 2 dígits hexadecimal és d'1 byte.

263
00:22:05,240 --> 00:22:09,600
Així que serà de 8 dígits hexadecimals de 4 bytes.

264
00:22:09,600 --> 00:22:14,190
Així, cada indicador individual en un sistema de 32-bit que serà de 4 bytes,

265
00:22:14,190 --> 00:22:18,550
el que significa que en el procés es pot construir qualsevol arbitràries 4 bytes

266
00:22:18,550 --> 00:22:20,550
i fer un punter fora d'ell,

267
00:22:20,550 --> 00:22:32,730
el que significa que la mesura del que és conscient, es pot tractar un enter 2 als 32 bytes de memòria.

268
00:22:32,730 --> 00:22:34,760
Tot i que en realitat no es té accés a què,

269
00:22:34,760 --> 00:22:40,190
encara que l'equip només té 512 megabytes, que pensa que té prou memòria.

270
00:22:40,190 --> 00:22:44,930
I el sistema operatiu és prou intel · ligent que només assignar el que realment necessita.

271
00:22:44,930 --> 00:22:49,630
No només ha d'anar, oh, un nou procés: 4 gigues.

272
00:22:49,630 --> 00:22:51,930
>> Si. >> [Estudiant] Què fa el bou dir? Per què el va escriure?

273
00:22:51,930 --> 00:22:54,980
És només el símbol d'hexadecimal.

274
00:22:54,980 --> 00:22:59,590
Quan vostè veu un nombre d'inici amb el bou, les coses són successives hexadecimal.

275
00:23:01,930 --> 00:23:05,760
[Estudiant] Vostè estava explicant sobre el que passa quan un programa acaba. Sí >>.

276
00:23:05,760 --> 00:23:09,480
Què passa quan un programa acaba és el sistema operatiu

277
00:23:09,480 --> 00:23:13,600
només esborra les assignacions que té per a aquestes adreces, i això és tot.

278
00:23:13,600 --> 00:23:17,770
El sistema operatiu pot simplement donar aquest record a un altre programa per utilitzar-lo.

279
00:23:17,770 --> 00:23:19,490
[Estudiant] Bé.

280
00:23:19,490 --> 00:23:24,800
Així que quan vostè assigna alguna cosa al munt o les variables de pila o global ni res,

281
00:23:24,800 --> 00:23:27,010
tots ells només desapareixen tan bon punt acabi el programa

282
00:23:27,010 --> 00:23:32,120
perquè el sistema operatiu és ara lliure per donar que la memòria a qualsevol altre procés.

283
00:23:32,120 --> 00:23:35,150
[Estudiant] Tot i que és probable que hi hagi encara valors escrits en? Sí >>.

284
00:23:35,150 --> 00:23:37,740
Els valors són probablement encara allà.

285
00:23:37,740 --> 00:23:41,570
És només que serà difícil arribar-hi.

286
00:23:41,570 --> 00:23:45,230
És molt més difícil arribar a ells del que és arribar a un arxiu eliminat

287
00:23:45,230 --> 00:23:51,450
pel fet que el tipus de fitxer esborrat se senti allà durant molt de temps i el disc dur és molt més gran.

288
00:23:51,450 --> 00:23:54,120
Així que va a sobreescriure les diferents parts de la memòria

289
00:23:54,120 --> 00:23:58,640
abans que succeeixi per sobreescriure el bloc de memòria que utilitza aquest arxiu per estar en.

290
00:23:58,640 --> 00:24:04,520
Però la memòria principal, memòria RAM, es desplaça per molt més ràpid,

291
00:24:04,520 --> 00:24:08,040
així que serà molt ràpidament sobreescrit.

292
00:24:10,300 --> 00:24:13,340
Les preguntes sobre aquesta o qualsevol altra cosa?

293
00:24:13,340 --> 00:24:16,130
[Estudiant] Tinc preguntes sobre un tema diferent. >> Okay.

294
00:24:16,130 --> 00:24:19,060
Algú té algun dubte sobre això?

295
00:24:20,170 --> 00:24:23,120
>> Bé. Tema diferent. >> [Estudiant] Bé.

296
00:24:23,120 --> 00:24:26,550
Jo estava passant per algunes de les proves de la pràctica,

297
00:24:26,550 --> 00:24:30,480
i en una d'elles es referia a la sizeof

298
00:24:30,480 --> 00:24:35,630
i el valor que retorna o diferents tipus de variables. Sí >>.

299
00:24:35,630 --> 00:24:45,060
I va dir que tant int i llarg termini tant el retorn 4, pel que ambdós són 4 bytes de longitud.

300
00:24:45,060 --> 00:24:48,070
Hi ha alguna diferència entre un int i un llarg, o és el mateix?

301
00:24:48,070 --> 00:24:50,380
Sí, hi ha una diferència.

302
00:24:50,380 --> 00:24:52,960
L'estàndard de C -

303
00:24:52,960 --> 00:24:54,950
Probablement vaig a ficar la pota.

304
00:24:54,950 --> 00:24:58,800
L'estàndard de C és igual que el que C és la documentació oficial de C.

305
00:24:58,800 --> 00:25:00,340
Això és el que diu.

306
00:25:00,340 --> 00:25:08,650
Així que l'estàndard de C només diu que serà un char per sempre i serà sempre 1 byte.

307
00:25:10,470 --> 00:25:19,040
Tot després que - un curt és sempre acaba de definir com és major que o igual a un char.

308
00:25:19,040 --> 00:25:23,010
Això podria ser estrictament més gran que, però no positiu.

309
00:25:23,010 --> 00:25:31,940
Un int s'acaba de definir com és major que o igual a poca.

310
00:25:31,940 --> 00:25:36,210
I una llarga s'acaba de definir com és major que o igual a un sencer.

311
00:25:36,210 --> 00:25:41,600
I molt de temps és més gran que o igual a un temps.

312
00:25:41,600 --> 00:25:46,610
Així que l'únic que l'estàndard de C defineix és l'ordre relatiu de tot.

313
00:25:46,610 --> 00:25:54,880
La quantitat real de memòria que les coses segueixin en general fins a l'execució,

314
00:25:54,880 --> 00:25:57,640
però està prou ben definit en aquest punt. >> [Estudiant] Bé.

315
00:25:57,640 --> 00:26:02,490
Així que els pantalons curts són gairebé sempre serà de 2 bytes.

316
00:26:04,920 --> 00:26:09,950
INT són gairebé sempre serà de 4 bytes.

317
00:26:12,070 --> 00:26:15,340
Llargs llargs són gairebé sempre serà de 8 bytes.

318
00:26:17,990 --> 00:26:23,160
I anhela, depèn de si vostè està utilitzant un 32-bit o un sistema de 64-bit.

319
00:26:23,160 --> 00:26:27,450
Així un llarg va a correspondre amb el tipus de sistema.

320
00:26:27,450 --> 00:26:31,920
Si utilitzeu un sistema de 32-bit com el Appliance, que serà de 4 bytes.

321
00:26:34,530 --> 00:26:42,570
Si utilitzeu un 64-bit com un munt d'ordinadors recents, que serà de 8 bytes.

322
00:26:42,570 --> 00:26:45,230
>> INT són gairebé sempre 4 bytes en aquest punt.

323
00:26:45,230 --> 00:26:47,140
Llargs llargs són gairebé sempre de 8 bytes.

324
00:26:47,140 --> 00:26:50,300
En el passat, INT solia ser només 2 bytes.

325
00:26:50,300 --> 00:26:56,840
Però cal notar que això satisfà completament totes aquestes relacions de superior i igual a.

326
00:26:56,840 --> 00:27:01,280
Mentre està perfectament autoritzat a tenir la mateixa mida com un enter,

327
00:27:01,280 --> 00:27:04,030
i també se'ls permet tenir la mateixa mida com un llarg temps.

328
00:27:04,030 --> 00:27:11,070
I dóna la casualitat que estigui en 99,999% dels sistemes, que serà igual a

329
00:27:11,070 --> 00:27:15,800
1 int o un llarg termini. Això és decisió 32-bit o 64-bit. >> [Estudiant] Bé.

330
00:27:15,800 --> 00:27:24,600
En carrosses, com està el punt decimal designat en termes de bits?

331
00:27:24,600 --> 00:27:27,160
Igual que com binari? Sí >>.

332
00:27:27,160 --> 00:27:30,570
No és necessari saber que per CS50.

333
00:27:30,570 --> 00:27:32,960
Ni tan sols assabentar-se que en el 61.

334
00:27:32,960 --> 00:27:37,350
No s'aprèn que realment en qualsevol curs.

335
00:27:37,350 --> 00:27:42,740
És només una representació.

336
00:27:42,740 --> 00:27:45,440
Em oblit de les assignacions de bits exactes.

337
00:27:45,440 --> 00:27:53,380
La idea de punt flotant és que es pot assignar un nombre específic de bits per representar -

338
00:27:53,380 --> 00:27:56,550
Bàsicament, tot està en notació científica.

339
00:27:56,550 --> 00:28:05,600
Així que assignar un nombre específic de bits per representar el nombre en si, igual que 1,2345.

340
00:28:05,600 --> 00:28:10,200
Mai pot representar un nombre amb més dígits dels quals 5.

341
00:28:12,200 --> 00:28:26,300
Llavors també assignar un nombre específic de bits de manera que tendeix a ser com

342
00:28:26,300 --> 00:28:32,810
només es pot pujar a un cert nombre, com que és el major exponent que pot tenir,

343
00:28:32,810 --> 00:28:36,190
i només es pot baixar a un cert exponent,

344
00:28:36,190 --> 00:28:38,770
com que és el més petit exponent que pot tenir.

345
00:28:38,770 --> 00:28:44,410
>> No me'n recordo dels bits de forma exacta s'assignen a tots aquests valors,

346
00:28:44,410 --> 00:28:47,940
però un cert nombre de bits es dedica a 1,2345,

347
00:28:47,940 --> 00:28:50,930
altre cert nombre de bits es dedica a la exponent,

348
00:28:50,930 --> 00:28:55,670
i és només possible representar un exponent d'una certa mida.

349
00:28:55,670 --> 00:29:01,100
[Estudiant] I un doble? És com un float extra llarga? Sí >>.

350
00:29:01,100 --> 00:29:07,940
És el mateix que un flotador excepte que ara està utilitzant 8 bytes en lloc de 4 bytes.

351
00:29:07,940 --> 00:29:11,960
Ara podràs utilitzar 9 xifres o dígits 10,

352
00:29:11,960 --> 00:29:16,630
i aquest serà capaç de pujar a 300 en lloc de 100. >> [Estudiant] Bé.

353
00:29:16,630 --> 00:29:21,550
I flotadors són també 4 bytes. Sí >>.

354
00:29:21,550 --> 00:29:27,520
Bé, de nou, probablement en general depèn de l'aplicació general,

355
00:29:27,520 --> 00:29:30,610
però els flotadors són de 4 bytes, els dobles són 8.

356
00:29:30,610 --> 00:29:33,440
Dobles es diu doble, ja que són el doble de la mida de la flota.

357
00:29:33,440 --> 00:29:38,380
[Estudiant] Bé. I hi ha dues dobles? >> No hi ha.

358
00:29:38,380 --> 00:29:43,660
Crec que - >> [estudiant] Igual que anhela llargues? Sí >>. No ho crec. Sí

359
00:29:43,660 --> 00:29:45,950
[Estudiant] L'assaig de l'any passat hi havia una pregunta sobre la funció principal

360
00:29:45,950 --> 00:29:49,490
haver de ser part del seu programa.

361
00:29:49,490 --> 00:29:52,310
La resposta va ser que no ha de ser part del seu programa.

362
00:29:52,310 --> 00:29:55,100
En quina situació? Això és el que vaig veure.

363
00:29:55,100 --> 00:29:59,090
[Bowden] Sembla - >> [estudiant] Quina situació?

364
00:29:59,090 --> 00:30:02,880
Té el problema? >> [Estudiant] Sí, ho puc estirar-lo cap amunt.

365
00:30:02,880 --> 00:30:07,910
No ha de ser, tècnicament, però bàsicament serà.

366
00:30:07,910 --> 00:30:10,030
[Estudiant] Jo vaig veure un en una d'any diferent.

367
00:30:10,030 --> 00:30:16,220
Era com Vertader o Fals: Un vàlid - >> Oh, un arxiu c.?

368
00:30:16,220 --> 00:30:18,790
. [Estudiant] Qualsevol arxiu c ha de tenir - [ambdós termes alhora - inintel · ligible]

369
00:30:18,790 --> 00:30:21,120
Bé. Així que això és a part.

370
00:30:21,120 --> 00:30:26,800
>> Un arxiu. C només necessita contenir funcions.

371
00:30:26,800 --> 00:30:32,400
Vostè pot compilar un arxiu en codi màquina, binari, el que sigui,

372
00:30:32,400 --> 00:30:36,620
sense que sigui executable encara.

373
00:30:36,620 --> 00:30:39,420
Un executable vàlid ha de tenir una funció principal.

374
00:30:39,420 --> 00:30:45,460
Vostè pot escriure 100 funcions en 1 arxiu però no principals

375
00:30:45,460 --> 00:30:48,800
i després compilar que a binari,

376
00:30:48,800 --> 00:30:54,460
llavors vostè escriure un altre arxiu que només ha principal ha de trucar a un munt d'aquestes funcions

377
00:30:54,460 --> 00:30:56,720
a l'arxiu binari aquí.

378
00:30:56,720 --> 00:31:01,240
Així que quan vostè està fent el programa, que és el que fa l'enllaçador

379
00:31:01,240 --> 00:31:05,960
Es combina aquests dos arxius binaris en un arxiu executable.

380
00:31:05,960 --> 00:31:11,400
Així que un arxiu. C no necessita tenir una funció principal en absolut.

381
00:31:11,400 --> 00:31:19,220
I en grans bases de codi veuràs milers d'arxius. C i 1 arxiu principal.

382
00:31:23,960 --> 00:31:26,110
Més preguntes?

383
00:31:29,310 --> 00:31:31,940
[Estudiant] Hi va haver una altra pregunta.

384
00:31:31,940 --> 00:31:36,710
Va dir de fer és un compilador. Vertader o Fals?

385
00:31:36,710 --> 00:31:42,030
I la resposta era falsa, i vaig entendre per què no és com Clang.

386
00:31:42,030 --> 00:31:44,770
Però, com diem a fer si no?

387
00:31:44,770 --> 00:31:49,990
Fer és bàsicament - Puc veure exactament el que el crida.

388
00:31:49,990 --> 00:31:52,410
Però simplement executa les comandes.

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

390
00:31:58,240 --> 00:32:00,870
Jo puc tirar això. Si.

391
00:32:10,110 --> 00:32:13,180
Oh, sí. Assegureu-vos també ho fa.

392
00:32:13,180 --> 00:32:17,170
Això diu que el propòsit de la utilitat make és determinar automàticament

393
00:32:17,170 --> 00:32:19,610
quines peces d'un programa necessiten ser recompilats

394
00:32:19,610 --> 00:32:22,350
i emetre les ordres per compilar.

395
00:32:22,350 --> 00:32:27,690
Vostè pot fer que els arxius que són absolutament enorme.

396
00:32:27,690 --> 00:32:33,210
Fer mira les marques de temps dels arxius i, com hem dit abans,

397
00:32:33,210 --> 00:32:36,930
pot compilar fitxers individuals cap avall, i no és fins que arribi al enllaçador

398
00:32:36,930 --> 00:32:39,270
que estan juntes en un executable.

399
00:32:39,270 --> 00:32:43,810
Així que si vostè té 10 diferents arxius i fer un canvi en una d'elles,

400
00:32:43,810 --> 00:32:47,870
llavors, ¿quina marca farà és recompilar que 1 arxiu

401
00:32:47,870 --> 00:32:50,640
i després tornar a vincular tot junt.

402
00:32:50,640 --> 00:32:53,020
Però és molt més ximple que això.

403
00:32:53,020 --> 00:32:55,690
Depèn de vostè per definir completament que això és el que hauria d'estar fent.

404
00:32:55,690 --> 00:32:59,560
És per defecte té la capacitat de reconèixer aquestes coses segell de temps,

405
00:32:59,560 --> 00:33:03,220
però vostè pot escriure un fitxer make per fer res.

406
00:33:03,220 --> 00:33:09,150
Vostè pot escriure un arxiu per fer que en escriure ho fan només cd a un altre directori.

407
00:33:09,150 --> 00:33:15,560
Estava frustrat perquè tot tatxa interior del meu Appliance

408
00:33:15,560 --> 00:33:21,740
i després veure el PDF de la MAC.

409
00:33:21,740 --> 00:33:30,720
>> Així que anar a Finder i puc anar a fer, Connectar al servidor,

410
00:33:30,720 --> 00:33:36,950
i el servidor em connecto al meu és Appliance, i després obrir el PDF

411
00:33:36,950 --> 00:33:40,190
que es compila per LaTeX.

412
00:33:40,190 --> 00:33:49,320
Però jo estava frustrat perquè cada vegada que havia de actualitzar el PDF,

413
00:33:49,320 --> 00:33:53,900
Vaig haver copiar a un directori específic que pugui accedir

414
00:33:53,900 --> 00:33:57,710
i es feia molest.

415
00:33:57,710 --> 00:34:02,650
Així que en comptes vaig escriure un arxiu de marca, que ha de definir la manera com fa les coses.

416
00:34:02,650 --> 00:34:06,130
Com fer que en això és PDF LaTeX.

417
00:34:06,130 --> 00:34:10,090
Igual que qualsevol altre arxiu de marca - o suposo que ho has vist els arxius Make,

418
00:34:10,090 --> 00:34:13,510
però tenim en l'aparell un arxiu de marca global que només diu:

419
00:34:13,510 --> 00:34:16,679
si està compilant un arxiu de C, utilitzeu Clang.

420
00:34:16,679 --> 00:34:20,960
I aquí en el meu arxiu de marca que faig jo dic,

421
00:34:20,960 --> 00:34:25,020
l'arxiu que vas a voler compilar amb PDF LaTeX.

422
00:34:25,020 --> 00:34:27,889
I el que és LaTeX PDF que està fent la compilació.

423
00:34:27,889 --> 00:34:31,880
Fer no està compilant. És simplement executar aquestes comandes en la seqüència que s'especifica.

424
00:34:31,880 --> 00:34:36,110
Així s'executa LaTeX PDF, el copia al directori on voleu que es copien,

425
00:34:36,110 --> 00:34:38,270
que el cd al directori i fa altres coses,

426
00:34:38,270 --> 00:34:42,380
però l'únic que fa és reconèixer quan canvia un arxiu,

427
00:34:42,380 --> 00:34:45,489
i si canvia, llavors s'executen les comandes que se suposa per funcionar

428
00:34:45,489 --> 00:34:48,760
quan canvia l'arxiu. >> [Estudiant] Bé.

429
00:34:50,510 --> 00:34:54,420
No sé on són els arxius make globals són per a mi comprovar que funciona.

430
00:34:57,210 --> 00:35:04,290
Altres preguntes? Qualsevol cosa del passat proves? Les coses punter?

431
00:35:06,200 --> 00:35:08,730
Hi ha coses subtils amb punters com -

432
00:35:08,730 --> 00:35:10,220
Jo no seré capaç de trobar una pregunta de qüestionari en ell -

433
00:35:10,220 --> 00:35:16,250
però igual que aquest tipus de coses.

434
00:35:19,680 --> 00:35:24,060
Assegureu-vos entendre que quan dic int * x * i -

435
00:35:24,890 --> 00:35:28,130
Això no és exactament res aquí, suposo.

436
00:35:28,130 --> 00:35:32,140
Però igual que * x * i, aquests són dues variables que estan a la pila.

437
00:35:32,140 --> 00:35:37,220
Quan dic x = malloc (sizeof (int)), x és encara una variable a la pila,

438
00:35:37,220 --> 00:35:41,180
malloc algun bloc més al munt, i tindrem el punt x al munt.

439
00:35:41,180 --> 00:35:43,900
>> Així que alguna cosa sobre els punts de la pila a la pila.

440
00:35:43,900 --> 00:35:48,100
Sempre que malloc res, vostè està inevitablement guardar dins d'un punter.

441
00:35:48,100 --> 00:35:55,940
Així que el punter està a la pila, el bloc malloced és al munt.

442
00:35:55,940 --> 00:36:01,240
Moltes persones es confonen i diuen int * x = malloc, x és al munt.

443
00:36:01,240 --> 00:36:04,100
No El que assenyala és x en el munt.

444
00:36:04,100 --> 00:36:08,540
x si mateix està a la pila, llevat que per la raó que sigui que hagi x una variable global,

445
00:36:08,540 --> 00:36:11,960
en aquest cas esdevé en una altra regió de memòria.

446
00:36:13,450 --> 00:36:20,820
Així que fer el seguiment, aquests diagrames de caixa i la fletxa són molt comuns per a la prova.

447
00:36:20,820 --> 00:36:25,740
O si no està en concurs de 0, s'aplicarà el quiz 1.

448
00:36:27,570 --> 00:36:31,940
Vostè ha de saber tot això, els passos de compilació

449
00:36:31,940 --> 00:36:35,740
ja que va haver de respondre a preguntes sobre elles. Sí

450
00:36:35,740 --> 00:36:38,940
[Estudiant] Podem repassar els passos - >> Clar.

451
00:36:48,340 --> 00:36:58,640
Abans dels passos i la compilació tenim preprocessament,

452
00:36:58,640 --> 00:37:16,750
compilar, organitzar i vincular.

453
00:37:16,750 --> 00:37:21,480
Preprocessament. Què significa això?

454
00:37:29,720 --> 00:37:32,290
És el pas més fàcil a - bé, no com -

455
00:37:32,290 --> 00:37:35,770
això no vol dir que hauria de ser obvi, però és el pas més fàcil.

456
00:37:35,770 --> 00:37:38,410
Vostès podrien implementar vostès mateixos. Si.

457
00:37:38,410 --> 00:37:43,410
[Estudiant] Prengui el que vostè té en el seu inclou com aquest i el copia i després defineix també.

458
00:37:43,410 --> 00:37:49,250
Es veu les coses com # include i # defineix,

459
00:37:49,250 --> 00:37:53,800
i només copia i enganxa el que els que realment signifiquen.

460
00:37:53,800 --> 00:37:59,240
Així que quan dius # include cs50.h, el preprocessador és copiar i enganxar cs50.h

461
00:37:59,240 --> 00:38:01,030
en aquesta línia.

462
00:38:01,030 --> 00:38:06,640
Quan dius # define x per ser 4, el preprocessador travessa tot el programa

463
00:38:06,640 --> 00:38:10,400
i substitueix a tots els casos de x amb 4.

464
00:38:10,400 --> 00:38:17,530
Així que el preprocessador pren un arxiu de C vàlid i envia un arxiu vàlid de C

465
00:38:17,530 --> 00:38:20,300
on les coses s'han copiat i enganxat.

466
00:38:20,300 --> 00:38:24,230
Així que ara compilar. Què significa això?

467
00:38:25,940 --> 00:38:28,210
[Estudiant] Va de C a binari.

468
00:38:28,210 --> 00:38:30,970
>> [Bowden] No va tot el camí a binari.

469
00:38:30,970 --> 00:38:34,220
[Estudiant] a codi de màquina, llavors? >> No és codi màquina.

470
00:38:34,220 --> 00:38:35,700
[Estudiant] Assemblea? >> Assemblea.

471
00:38:35,700 --> 00:38:38,890
Es va a l'Assemblea abans de que va tot el camí a codi C,

472
00:38:38,890 --> 00:38:45,010
i la majoria de llenguatges fer alguna cosa com això.

473
00:38:47,740 --> 00:38:50,590
Trieu qualsevol llenguatge d'alt nivell, i, si ho aneu a construir

474
00:38:50,590 --> 00:38:52,390
el més probable és que compili en passos.

475
00:38:52,390 --> 00:38:58,140
En primer lloc es va a compilar Python a C, llavors va a compilar C a l'Assemblea,

476
00:38:58,140 --> 00:39:01,600
i després l'Assemblea serà traduït a binari.

477
00:39:01,600 --> 00:39:07,800
Així de compilar el portarà de C a l'Assemblea.

478
00:39:07,800 --> 00:39:12,130
La paraula generalment significa compilar portar des d'un nivell superior

479
00:39:12,130 --> 00:39:14,340
a un llenguatge de programació de baix.

480
00:39:14,340 --> 00:39:19,190
Així que aquest és l'únic pas en la recopilació d'on comences amb un llenguatge d'alt nivell

481
00:39:19,190 --> 00:39:23,270
i acaben en un llenguatge de baix nivell, i és per això que el pas es diu compilació.

482
00:39:25,280 --> 00:39:33,370
[Estudiant] Durant la compilació, diguem que vostè ha fet # include cs50.h.

483
00:39:33,370 --> 00:39:42,190
El compilador recompilar el cs50.h, igual que les funcions que es troben allà,

484
00:39:42,190 --> 00:39:45,280
i traduir això en codi assemblador, així,

485
00:39:45,280 --> 00:39:50,830
o va a copiar i enganxar una cosa que ha estat pre-Assemblea?

486
00:39:50,830 --> 00:39:56,910
cs50.h bastant molt que mai acaben en l'Assemblea.

487
00:39:59,740 --> 00:40:03,680
Coses com prototips de les funcions i les coses són només perquè vagis amb compte.

488
00:40:03,680 --> 00:40:09,270
Garanteix que el compilador pot comprovar les coses com si estiguessis cridant a les funcions

489
00:40:09,270 --> 00:40:12,910
amb els tipus de devolució de drets i els arguments de dret i aquestes coses.

490
00:40:12,910 --> 00:40:18,350
>> Així cs50.h es preprocessat a l'arxiu i, a continuació, quan s'està compilant

491
00:40:18,350 --> 00:40:22,310
que és bàsicament llençar després s'assegura que tot el que es diu correctament.

492
00:40:22,310 --> 00:40:29,410
Però les funcions definides a la biblioteca CS50, que estan separats de cs50.h,

493
00:40:29,410 --> 00:40:33,610
els que no es compilen per separat.

494
00:40:33,610 --> 00:40:37,270
Que en realitat es reduirà en l'etapa d'enllaç, així que arribarem a això en un segon.

495
00:40:37,270 --> 00:40:40,100
Però primer, què és el muntatge?

496
00:40:41,850 --> 00:40:44,500
[Estudiant] Assemblea a binari? Sí >>.

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

498
00:40:48,190 --> 00:40:54,710
Nosaltres no ho diem compilar perquè l'Assemblea és gairebé una pura traducció de binari.

499
00:40:54,710 --> 00:41:00,230
Hi ha una lògica molt poc en passar de l'Assemblea a binari.

500
00:41:00,230 --> 00:41:03,180
És com buscar en una taula, oh, tenim aquesta instrucció;

501
00:41:03,180 --> 00:41:06,290
que correspon a binari 01110.

502
00:41:10,200 --> 00:41:15,230
I perquè els arxius que el muntatge generalment resultats són. Arxius o.

503
00:41:15,230 --> 00:41:19,020
I els arxius. O són ​​el que dèiem abans,

504
00:41:19,020 --> 00:41:21,570
com un fitxer no necessita tenir una funció principal.

505
00:41:21,570 --> 00:41:27,640
Qualsevol arxiu pot ser compilat a un arxiu. O com a molt, ja que és un arxiu vàlid de C.

506
00:41:27,640 --> 00:41:30,300
Pot ser compilat a. O.

507
00:41:30,300 --> 00:41:43,030
Ara, la vinculació és el que realment porta un munt de. Arxius o i els porta a un executable.

508
00:41:43,030 --> 00:41:51,110
I així ho fa és la vinculació que es pugui imaginar la biblioteca CS50 com un arxiu. O.

509
00:41:51,110 --> 00:41:56,980
És un arxiu binari ja compilat.

510
00:41:56,980 --> 00:42:03,530
I així, quan es compila l'arxiu, la seva hello.c, que crida a GetString,

511
00:42:03,530 --> 00:42:06,360
hello.c es compila a hello.o,

512
00:42:06,360 --> 00:42:08,910
hello.o està ara en binari.

513
00:42:08,910 --> 00:42:12,830
Utilitza GetString, de manera que ha d'anar a cs50.o,

514
00:42:12,830 --> 00:42:16,390
i l'enllaçador ells smooshes junts i el copia a l'arxiu GetString

515
00:42:16,390 --> 00:42:20,640
i surt amb un executable que té totes les funcions que necessita.

516
00:42:20,640 --> 00:42:32,620
Així cs50.o no és un arxiu de O, però està prou a prop que no hi ha una diferència fonamental.

517
00:42:32,620 --> 00:42:36,880
Així que la vinculació només porta un munt d'arxius junts

518
00:42:36,880 --> 00:42:41,390
que contenen per separat totes les funcions que necessito per utilitzar

519
00:42:41,390 --> 00:42:46,120
i crea l'executable que realment funciona.

520
00:42:48,420 --> 00:42:50,780
>> I això és també el que dèiem abans

521
00:42:50,780 --> 00:42:55,970
on es pot prendre 1000. arxius c, es compila a tots a. arxius o,

522
00:42:55,970 --> 00:43:00,040
que probablement prendrà un temps, i després es canvia 1. arxiu c.

523
00:43:00,040 --> 00:43:05,480
Només cal recompilar que 1. Arxiu c i després tot torna a vincular més,

524
00:43:05,480 --> 00:43:07,690
vincular tot de nou junts.

525
00:43:09,580 --> 00:43:11,430
[Estudiant] Quan estem vinculant escrivim lcs50?

526
00:43:11,430 --> 00:43:20,510
Sí, així lcs50. Que les senyals de les banderes al enllaçador que ha de ser la vinculació a aquesta biblioteca.

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

528
00:43:41,310 --> 00:43:46,860
Hem anat binari excepte que 5 segons en la primera conferència?

529
00:43:50,130 --> 00:43:53,010
No ho crec.

530
00:43:55,530 --> 00:43:58,820
Vostè ha de saber tot de les grans sortides que hem repassat,

531
00:43:58,820 --> 00:44:02,670
i vostè hauria de ser capaç de fer-ho, si et donem una funció,

532
00:44:02,670 --> 00:44:09,410
vostè hauria de ser capaç de dir que és gran O, més o menys. O bé, gran O és aspra.

533
00:44:09,410 --> 00:44:15,300
Així que si vostè veu bucles for niats recórrer el mateix nombre de coses,

534
00:44:15,300 --> 00:44:22,260
com int i, i <n, int j, j <n->> [estudiant] n al quadrat. >> Que tendeix a ser n al quadrat.

535
00:44:22,260 --> 00:44:25,280
Si ha triples imbricada, que tendeix a ser tallat en cubs núm.

536
00:44:25,280 --> 00:44:29,330
Així que aquest tipus de cosa que vostè ha de ser capaç d'assenyalar immediatament.

537
00:44:29,330 --> 00:44:33,890
Vostè necessita saber l'ordenació per inserció i ordenació de bombolla i fusionar classe i tot això.

538
00:44:33,890 --> 00:44:41,420
És més fàcil entendre per què són els n al quadrat i n log n i tot això

539
00:44:41,420 --> 00:44:47,810
perquè crec que hi havia un concurs en un any en què bàsicament li va donar

540
00:44:47,810 --> 00:44:55,050
una implementació de tipus bombolla i va dir: "Quin és el temps d'execució d'aquesta funció?"

541
00:44:55,050 --> 00:45:01,020
Així que si vostè ho reconeix com una mena de bombolla, llavors immediatament es pot dir en al quadrat.

542
00:45:01,020 --> 00:45:05,470
Però si el que es miri, vostè ni tan sols necessita per adonar-se que és una espècie de bombolla;

543
00:45:05,470 --> 00:45:08,990
només puc dir que està fent això i això. Aquest és n al quadrat.

544
00:45:12,350 --> 00:45:14,710
[Estudiant] Hi ha exemples difícils que poden sorgir amb,

545
00:45:14,710 --> 00:45:20,370
com una idea similar d'esbrinar?

546
00:45:20,370 --> 00:45:24,450
>> No crec que li donem alguns exemples difícils.

547
00:45:24,450 --> 00:45:30,180
El espècie de bombolla és gairebé tan dur com ens agradaria anar,

548
00:45:30,180 --> 00:45:36,280
i fins i tot que, sempre que vostè entengui que vostè està interactuant sobre la matriu

549
00:45:36,280 --> 00:45:41,670
per a cada element de la matriu, que serà una cosa que n al quadrat.

550
00:45:45,370 --> 00:45:49,940
Hi ha qüestions generals, com la que tenim aquí - Oh.

551
00:45:55,290 --> 00:45:58,530
Just l'altre dia, Doug va afirmar: "He inventat un algoritme que pot ordenar una matriu

552
00:45:58,530 --> 00:46:01,780
"De n nombres a O (log n) temps!"

553
00:46:01,780 --> 00:46:04,900
Llavors, com sabem que és impossible?

554
00:46:04,900 --> 00:46:08,850
[Resposta dels estudiants inaudible] >> Si.

555
00:46:08,850 --> 00:46:13,710
Si més no, ha de tocar cada element de la matriu,

556
00:46:13,710 --> 00:46:16,210
pel que és impossible ordenar una matriu de -

557
00:46:16,210 --> 00:46:20,850
Si tot està en ordre sense classificar, llavors vostè estarà en contacte amb tot el que en la matriu,

558
00:46:20,850 --> 00:46:25,320
pel que és impossible fer-ho en menys d'O de n.

559
00:46:27,430 --> 00:46:30,340
[Estudiant] Vostè ens va mostrar l'exemple de ser capaç de fer-ho en O de n

560
00:46:30,340 --> 00:46:33,920
si s'utilitza una gran quantitat de memòria. Sí >>.

561
00:46:33,920 --> 00:46:37,970
I això és - no recordo què això és - ¿Està explicant coses semblants?

562
00:46:47,360 --> 00:46:51,330
Hmm. Que és un algorisme de classificació sencer.

563
00:46:59,850 --> 00:47:05,100
Jo estava buscant el nom especial per això que jo no recordava la setmana passada.

564
00:47:05,100 --> 00:47:13,000
Si. Aquests són els tipus de classes que poden aconseguir les coses en gran O de n.

565
00:47:13,000 --> 00:47:18,430
No obstant això, hi ha limitacions, com que només es pot utilitzar nombres enters fins a un nombre determinat.

566
00:47:20,870 --> 00:47:24,560
A més, si vostè està tractant d'ordenar alguna cosa és. -

567
00:47:24,560 --> 00:47:30,750
Si la matriu és 012, -12, 151, 4 milions,

568
00:47:30,750 --> 00:47:35,120
llavors aquest element només es va a arruïnar per complet la classificació completa.

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

570
00:47:49,480 --> 00:47:58,870
[Estudiant] Si vostè té una funció recursiva i només fa que les trucades recursives

571
00:47:58,870 --> 00:48:02,230
dins d'una instrucció de retorn, que és la cua recursiva,

572
00:48:02,230 --> 00:48:07,360
pel que no caldria utilitzar més memòria en temps d'execució

573
00:48:07,360 --> 00:48:12,550
o que almenys comparable utilitzar la memòria com un procés iteratiu de solució?

574
00:48:12,550 --> 00:48:14,530
[Bowden] Sí

575
00:48:14,530 --> 00:48:19,840
Probablement seria una mica més lent, però en realitat no.

576
00:48:19,840 --> 00:48:23,290
Tail recursiva és bastant bo.

577
00:48:23,290 --> 00:48:32,640
Mirant de nou als marcs de pila, diguem que tenim principal

578
00:48:32,640 --> 00:48:42,920
i d'un bar int (int x) o alguna cosa així.

579
00:48:42,920 --> 00:48:52,310
Això no és una funció recursiva perfecta, però la barra de retorn (x - 1).

580
00:48:52,310 --> 00:48:57,620
Així que, òbviament, això és erroni. Necessita casos base i aquestes coses.

581
00:48:57,620 --> 00:49:00,360
Però la idea és que aquesta és la cua recursiva,

582
00:49:00,360 --> 00:49:06,020
el que significa que les trucades barra principal que va a aconseguir el seu marc de pila.

583
00:49:09,550 --> 00:49:12,440
En aquest marc de pila que serà un petit bloc de memòria

584
00:49:12,440 --> 00:49:17,490
que correspon al seu argument x.

585
00:49:17,490 --> 00:49:25,840
I així diguem principal passa a cridar bar (100);

586
00:49:25,840 --> 00:49:30,050
Així que x començarà com 100.

587
00:49:30,050 --> 00:49:35,660
Si el compilador reconeix que es tracta d'una funció recursiva cua,

588
00:49:35,660 --> 00:49:38,540
llavors quan fa la seva barra crida recursiva a la barra,

589
00:49:38,540 --> 00:49:45,490
en comptes de fer un nou marc de pila, que és on la pila comença a créixer en gran manera,

590
00:49:45,490 --> 00:49:48,220
finalment s'executarà en el munt i després et donen segfaults

591
00:49:48,220 --> 00:49:51,590
perquè la memòria comença a xocar.

592
00:49:51,590 --> 00:49:54,830
>> Així que en lloc de fer el seu propi marc de pila, es pot realitzar,

593
00:49:54,830 --> 00:49:59,080
hey, jo mai hagi de tornar a aquest marc de pila,

594
00:49:59,080 --> 00:50:08,040
així que en comptes que vaig a reemplaçar aquest argument amb 99 i després començar bar per tot arreu.

595
00:50:08,040 --> 00:50:11,810
I llavors ho faré de nou i arribarà bar return (x - 1),

596
00:50:11,810 --> 00:50:17,320
i en lloc de fer un nou marc de pila, s'acaba de substituir la seva actual argument amb el 98

597
00:50:17,320 --> 00:50:20,740
i després saltar de nou al principi de la barra.

598
00:50:23,860 --> 00:50:30,430
Aquestes operacions, reemplaçant el valor 1 a la pila i salta de nou al principi,

599
00:50:30,430 --> 00:50:32,430
són bastant eficients.

600
00:50:32,430 --> 00:50:41,500
Així que no només és l'ús de la memòria mateixa com una funció separada que es iteratiu

601
00:50:41,500 --> 00:50:45,390
perquè només està utilitzant un marc de pila, però no està patint els inconvenients

602
00:50:45,390 --> 00:50:47,240
d'haver de trucar a les funcions.

603
00:50:47,240 --> 00:50:50,240
Crida a funcions pot ser una mica car, ja que té a veure tot aquest muntatge

604
00:50:50,240 --> 00:50:52,470
i el desmuntatge i totes aquestes coses.

605
00:50:52,470 --> 00:50:58,160
Així que aquesta recursió de cua és bo.

606
00:50:58,160 --> 00:51:01,170
[Estudiant] Per què no crear nous passos?

607
00:51:01,170 --> 00:51:02,980
Com que s'adona que no necessita.

608
00:51:02,980 --> 00:51:07,800
El cridat a la barra s'acaba de tornar la crida recursiva.

609
00:51:07,800 --> 00:51:12,220
Així que no cal fer res amb el valor de retorn.

610
00:51:12,220 --> 00:51:15,120
És només va a tornar immediatament.

611
00:51:15,120 --> 00:51:20,530
Per tant, només va a substituir el seu propi argument i començar de nou.

612
00:51:20,530 --> 00:51:25,780
I també, si vostè no té la versió recursiva de cua,

613
00:51:25,780 --> 00:51:31,460
llavors vostè aconsegueix tots aquests bars on quan aquest bar torna

614
00:51:31,460 --> 00:51:36,010
cal retornar el seu valor a aquesta, tan bon punt la barra torna immediatament

615
00:51:36,010 --> 00:51:39,620
i retorna el seu valor a aquesta, llavors només va a tornar immediatament

616
00:51:39,620 --> 00:51:41,350
i retornar el seu valor a aquesta.

617
00:51:41,350 --> 00:51:45,350
Així que vostè està estalviant aquesta fent esclatar totes aquestes coses de la pila

618
00:51:45,350 --> 00:51:48,730
ja que el valor de retorn és només passarà tot el camí de tornada de totes maneres.

619
00:51:48,730 --> 00:51:55,400
Així que per què no substituir el nostre argument amb l'argument d'actualització i començar de nou?

620
00:51:57,460 --> 00:52:01,150
Si la funció no és la cua recursiva, si fas alguna cosa com -

621
00:52:01,150 --> 00:52:07,530
[Estudiant] si bar (x + 1). Sí >>.

622
00:52:07,530 --> 00:52:11,770
>> Així que si vostè ho posa en condició, llavors vostè està fent alguna cosa amb el valor de retorn.

623
00:52:11,770 --> 00:52:16,260
O fins i tot si vostè acaba de fer canvi de 2 * bar (x - 1).

624
00:52:16,260 --> 00:52:23,560
Així que ara bar (x - 1) ha de tornar per tal que per al càlcul de 2 vegades aquest valor,

625
00:52:23,560 --> 00:52:26,140
de manera que ara necessita el seu propi marc de pila separada,

626
00:52:26,140 --> 00:52:31,180
i ara, no importa quant t'esforcis, hauràs -

627
00:52:31,180 --> 00:52:34,410
Aquesta no és la cua recursiva.

628
00:52:34,410 --> 00:52:37,590
[Estudiant] El que tracte de portar una recursivitat per aspirar a una recursió de cua -

629
00:52:37,590 --> 00:52:41,450
[Bowden] En un món ideal, però en CS50 vostè no hagi de fer-ho.

630
00:52:43,780 --> 00:52:49,280
Per tal d'obtenir la recursió de cua, en general, es configura un argument addicional

631
00:52:49,280 --> 00:52:53,550
bar on es durà a int x en i

632
00:52:53,550 --> 00:52:56,990
i i correspon a l'última cosa que vol tornar.

633
00:52:56,990 --> 00:53:03,650
Així que això serà tornar bar (x - 1), 2 * i.

634
00:53:03,650 --> 00:53:09,810
Així que això és només un alt nivell de com es transformen les coses siguin col recursiva.

635
00:53:09,810 --> 00:53:13,790
Però l'argument extra -

636
00:53:13,790 --> 00:53:17,410
I després al final quan arribi a la seva base, la qual acaba de tornar i

637
00:53:17,410 --> 00:53:22,740
perquè ha vingut acumulant durant tot el temps el valor de retorn que desitgi.

638
00:53:22,740 --> 00:53:27,280
D'alguna manera ho han estat fent iterativa, però utilitzant les crides recursives.

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

640
00:53:34,900 --> 00:53:39,890
[Estudiant] Potser sobre l'aritmètica de punters, com quan l'ús de cadenes. >> Clar.

641
00:53:39,890 --> 00:53:43,610
Aritmètica de punters.

642
00:53:43,610 --> 00:53:48,440
Quan l'ús de cadenes és fàcil perquè les cadenes són estrelles char,

643
00:53:48,440 --> 00:53:51,860
chars són per sempre i sempre un sol byte,

644
00:53:51,860 --> 00:53:57,540
de manera que l'aritmètica de punters és equivalent a l'aritmètica normal quan vostè està tractant amb cadenes.

645
00:53:57,540 --> 00:54:08,790
Diguem char * s = "hola".

646
00:54:08,790 --> 00:54:11,430
Així que tenim un bloc a la memòria.

647
00:54:19,490 --> 00:54:22,380
Es necessita de 6 bytes, ja que sempre es necessita el terminador nul.

648
00:54:22,380 --> 00:54:28,620
I char * s va a assenyalar el començament d'aquesta matriu.

649
00:54:28,620 --> 00:54:32,830
Així que s apunti allà.

650
00:54:32,830 --> 00:54:36,710
Ara, això Bàsicament no matriu funciona,

651
00:54:36,710 --> 00:54:40,780
independentment de si es tractava d'un retorn de malloc o si està a la pila.

652
00:54:40,780 --> 00:54:47,110
Qualsevol matriu és bàsicament un punter al començament de la matriu,

653
00:54:47,110 --> 00:54:53,640
i després de qualsevol operació de matriu, qualsevol indexació, és només va en aquesta matriu un cert desfasament.

654
00:54:53,640 --> 00:55:05,360
>> Així que quan dic alguna cosa com s [3], el que va a s i comptar 3 caràcters polz

655
00:55:05,360 --> 00:55:12,490
Així que s [3], tenim 0, 1, 2, 3, de manera que es [3] farà referència a aquest l.

656
00:55:12,490 --> 00:55:20,460
[Estudiant] I podríem assolir el mateix valor que en fer s + 3 estrelles i després entre parèntesi?

657
00:55:20,460 --> 00:55:22,570
Sí

658
00:55:22,570 --> 00:55:26,010
Això és equivalent a * (s + 3);

659
00:55:26,010 --> 00:55:31,240
i que és etern i per sempre equivalent no importa el que facis.

660
00:55:31,240 --> 00:55:34,070
Mai s'ha d'utilitzar la sintaxi suport.

661
00:55:34,070 --> 00:55:37,770
Sempre pots utilitzar el * (s + 3) sintaxi.

662
00:55:37,770 --> 00:55:40,180
La gent tendeix a agradar la sintaxi suport, però.

663
00:55:40,180 --> 00:55:43,860
[Estudiant] Així que totes les matrius són en realitat punters.

664
00:55:43,860 --> 00:55:53,630
Hi ha una diferència lleu quan dic int x [4] >> [estudiant] Això creu la memòria?

665
00:55:53,630 --> 00:56:03,320
[Bowden] Això va a crear 4 sencers a la pila, en general de 16 bytes.

666
00:56:03,320 --> 00:56:05,700
Es crearà 16 bytes a la pila.

667
00:56:05,700 --> 00:56:09,190
x no s'emmagatzema en qualsevol lloc.

668
00:56:09,190 --> 00:56:13,420
És només un símbol referent a l'inici de la cosa.

669
00:56:13,420 --> 00:56:17,680
Perquè declarat la matriu dins d'aquesta funció,

670
00:56:17,680 --> 00:56:22,340
el que el compilador farà és substituir totes les instàncies de la variable x

671
00:56:22,340 --> 00:56:26,400
amb el lloc on va passar a optar per posar aquests 16 bytes.

672
00:56:26,400 --> 00:56:30,040
No es pot fer això amb char * s perquè s és un punter real.

673
00:56:30,040 --> 00:56:32,380
És gratuït per apuntar després a altres coses.

674
00:56:32,380 --> 00:56:36,140
x és una constant. No es pot tenir que apunti a una altra matriu. >> [Estudiant] Bé.

675
00:56:36,140 --> 00:56:43,420
Però aquesta idea, aquesta indexació, és la mateixa independentment de si es tracta d'un règim tradicional

676
00:56:43,420 --> 00:56:48,230
o si és un punter a alguna cosa o si és un punter a una matriu malloced.

677
00:56:48,230 --> 00:56:59,770
I, de fet, és tan equivalent que és també la mateixa cosa.

678
00:56:59,770 --> 00:57:05,440
En realitat, només es tradueix el que hi ha dins dels claudàtors i el que queda dels suports,

679
00:57:05,440 --> 00:57:07,970
els suma, i elimina referències.

680
00:57:07,970 --> 00:57:14,710
Així que això és tan vàlid com * (s + 3) o s [3].

681
00:57:16,210 --> 00:57:22,090
[Estudiant] Es pot tenir punters que apunten a 2-dimensionals?

682
00:57:22,090 --> 00:57:27,380
>> És més difícil. Tradicionalment, no.

683
00:57:27,380 --> 00:57:34,720
Una matriu de 2 dimensions és només un acord 1-dimensional amb una sintaxi convenient

684
00:57:34,720 --> 00:57:54,110
perquè quan dic int x [3] [3], això és en realitat una matriu amb 9 valors.

685
00:57:55,500 --> 00:58:03,000
I així, quan jo índex, el compilador sap a què em refereixo.

686
00:58:03,000 --> 00:58:13,090
Si dic x [1] [2], se sap que vull anar a la segona fila, de manera que passarà els primers 3,

687
00:58:13,090 --> 00:58:17,460
i després vol que la segona cosa en què, pel que va a aconseguir aquest.

688
00:58:17,460 --> 00:58:20,480
Però encara és només una matriu unidimensional.

689
00:58:20,480 --> 00:58:23,660
I així, si volia assignar un punter a la matriu,

690
00:58:23,660 --> 00:58:29,770
Jo diria int * p = x;

691
00:58:29,770 --> 00:58:33,220
El tipus de x és just -

692
00:58:33,220 --> 00:58:38,280
És a dir tipus rude de x, ja que és només un símbol i no és una variable real,

693
00:58:38,280 --> 00:58:40,140
però és només un * int.

694
00:58:40,140 --> 00:58:44,840
x és només un punter al començament d'aquesta. >> [Estudiant] Bé.

695
00:58:44,840 --> 00:58:52,560
Així que no serà capaç d'accedir a [1] [2].

696
00:58:52,560 --> 00:58:58,370
Crec que hi ha una sintaxi especial per a la declaració d'un punter,

697
00:58:58,370 --> 00:59:12,480
alguna cosa ridícul com int (* p [-. cosa absolutament ridícul que ni tan sols conec.

698
00:59:12,480 --> 00:59:17,090
Però hi ha una sintaxi per declarar punters com amb parèntesi i les coses.

699
00:59:17,090 --> 00:59:22,960
Fins i tot no li permeten fer això.

700
00:59:22,960 --> 00:59:26,640
Podia mirar cap enrere en una cosa que em diguis la veritat.

701
00:59:26,640 --> 00:59:34,160
Vaig a buscar més tard, si hi ha una sintaxi de punt. Però mai ho veurà.

702
00:59:34,160 --> 00:59:39,670
I encara que la sintaxi és tan arcaic que si vostè ho fa servir, la gent es desconcerta.

703
00:59:39,670 --> 00:59:43,540
Els arranjaments multidimensionals són bastant rars com és.

704
00:59:43,540 --> 00:59:44,630
Et pràcticament -

705
00:59:44,630 --> 00:59:48,490
Bé, si vostè està fent les coses de la matriu que no serà estrany,

706
00:59:48,490 --> 00:59:56,730
però en C que està rarament va a utilitzar matrius multidimensionals.

707
00:59:57,630 --> 01:00:00,470
Si. >> [Estudiant] Diguem que vostè té un arsenal molt llarg.

708
01:00:00,470 --> 01:00:03,900
>> Així, en la memòria virtual sembla ser tots consecutius,

709
01:00:03,900 --> 01:00:05,640
com els elements un al costat de l'altre,

710
01:00:05,640 --> 01:00:08,770
però en la memòria física, seria possible que es van separar? Sí >>.

711
01:00:08,770 --> 01:00:16,860
Com funciona la memòria virtual és només separa -

712
01:00:19,220 --> 01:00:24,860
La unitat d'assignació és una pàgina, que tendeix a ser 4 kilobytes

713
01:00:24,860 --> 01:00:29,680
i així, quan un procés, diu, hey, vull utilitzar aquesta memòria,

714
01:00:29,680 --> 01:00:35,970
el sistema operatiu es va a assignar 4 kilobytes perquè poc bloc de memòria.

715
01:00:35,970 --> 01:00:39,100
Fins i tot si només utilitza un sol byte mica en tot el bloc de memòria,

716
01:00:39,100 --> 01:00:42,850
el sistema operatiu es donarà la totalitat de 4 kilobytes.

717
01:00:42,850 --> 01:00:49,410
El que això significa és que podria tenir - anem a dir que aquest és el meu stack.

718
01:00:49,410 --> 01:00:53,180
Aquesta pila es podia separar. La meva pila podria ser megabytes i megabytes.

719
01:00:53,180 --> 01:00:55,020
La meva pila podria ser enorme.

720
01:00:55,020 --> 01:01:00,220
Però la pròpia pila ha de ser dividit en pàgines individuals,

721
01:01:00,220 --> 01:01:09,010
que si mirem cap aquí diguem que aquesta és la nostra RAM,

722
01:01:09,010 --> 01:01:16,600
si tinc 2 GB de RAM, és 0 adreça real com el byte zero de la meva memòria RAM,

723
01:01:16,600 --> 01:01:22,210
i això és de 2 gigabytes tot el camí fins aquí.

724
01:01:22,210 --> 01:01:27,230
Així que aquesta pàgina pot correspondre a aquest bloc per aquí.

725
01:01:27,230 --> 01:01:29,400
Aquesta pàgina pot correspondre a aquest bloc per aquí.

726
01:01:29,400 --> 01:01:31,560
Aquesta podria correspondre a aquest per aquí.

727
01:01:31,560 --> 01:01:35,540
Així que el sistema operatiu és lliure d'assignar memòria física

728
01:01:35,540 --> 01:01:39,320
a qualsevol pàgina individual arbitràriament.

729
01:01:39,320 --> 01:01:46,180
I això vol dir que si això succeeix frontera a cavall sobre una matriu,

730
01:01:46,180 --> 01:01:50,070
una matriu passa a ser l'esquerra i la dreta d'aquest d'aquest ordre d'una pàgina,

731
01:01:50,070 --> 01:01:54,460
a continuació, la matriu es dividirà en la memòria física.

732
01:01:54,460 --> 01:01:59,280
I després, quan vostè surti del programa, quan el procés acaba,

733
01:01:59,280 --> 01:02:05,690
aquestes assignacions s'esborren i llavors és lliure d'utilitzar aquests blocs petits per altres coses.

734
01:02:14,730 --> 01:02:17,410
Més preguntes?

735
01:02:17,410 --> 01:02:19,960
[Estudiant] El punter de l'aritmètica. >> Oh yeah.

736
01:02:19,960 --> 01:02:28,410
Les cadenes eren fàcils, però mirant a alguna cosa com sencers,

737
01:02:28,410 --> 01:02:35,000
Així que tornem a int x [4];

738
01:02:35,000 --> 01:02:41,810
Si es tracta d'una matriu o si es tracta d'un punter a una matriu de 4 sencers malloced,

739
01:02:41,810 --> 01:02:47,060
que serà tractat de la mateixa manera.

740
01:02:50,590 --> 01:02:53,340
[Estudiant] Així matrius són al munt?

741
01:03:01,400 --> 01:03:05,270
Bowden [] Les matrius no són al munt. >> [Estudiant] Oh.

742
01:03:05,270 --> 01:03:08,320
>> [Bowden] Aquest tipus de matriu tendeix a ser a la pila

743
01:03:08,320 --> 01:03:12,220
llevat que ho declarat en - fent cas omís de les variables globals. No utilitzeu variables globals.

744
01:03:12,220 --> 01:03:16,280
Dins d'una funció dic int x [4];

745
01:03:16,280 --> 01:03:22,520
Es crearà un bloc de 4 sencer a la pila per aquesta matriu.

746
01:03:22,520 --> 01:03:26,960
Però aquest malloc (4 * sizeof (int)); anirà en el munt.

747
01:03:26,960 --> 01:03:31,870
Però després d'aquest punt puc utilitzar x i p en més o menys de la mateixa manera,

748
01:03:31,870 --> 01:03:36,140
a part de les excepcions que vaig dir abans sobre tu pot reassignar p.

749
01:03:36,140 --> 01:03:40,960
Tècnicament, les seves mides són una mica diferents, però això és completament irrellevant.

750
01:03:40,960 --> 01:03:43,310
Vostè mai realment utilitzen les seves mides.

751
01:03:48,020 --> 01:03:56,810
El p puc dir p [3] = 2, o x [3] = 2;

752
01:03:56,810 --> 01:03:59,680
Vostè les pot utilitzar en exactament la mateixa manera.

753
01:03:59,680 --> 01:04:01,570
Així que ara punter aritmètica - Sí

754
01:04:01,570 --> 01:04:07,390
[Estudiant] No has de fer * p si té els brackets?

755
01:04:07,390 --> 01:04:11,720
Els suports són un dereference implícita. >> Okay.

756
01:04:11,720 --> 01:04:20,200
En realitat, també el que està dient amb el es pot obtenir matrius multidimensionals

757
01:04:20,200 --> 01:05:02,650
amb punters, el que pots fer és alguna cosa com, diguem, int ** pp = malloc (sizeof (int *) * 5);

758
01:05:02,650 --> 01:05:06,900
Vaig a escriure tot això en primer lloc.

759
01:05:37,880 --> 01:05:41,020
Jo no volia això.

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

761
01:05:42,550 --> 01:05:48,910
El que vaig fer aquí és - Això ha de ser p [i].

762
01:05:48,910 --> 01:05:53,680
Així pp és un punter a un punter.

763
01:05:53,680 --> 01:06:02,420
Ets mallocing pp per apuntar a un arranjament de 5 estrelles int.

764
01:06:02,420 --> 01:06:10,950
Així, en la memòria que tens a la pila pp

765
01:06:10,950 --> 01:06:20,150
Es va a apuntar a un arranjament de 5 blocs que són ells sols punters.

766
01:06:20,150 --> 01:06:28,210
I després, quan malloc aquí baix, jo malloc que cada un dels punters individuals

767
01:06:28,210 --> 01:06:32,080
hauria d'apuntar a un bloc independent de 4 bytes en la pila.

768
01:06:32,080 --> 01:06:35,870
Així que això apunta a 4 bytes.

769
01:06:37,940 --> 01:06:40,660
I aquest apunta a un diferent 4 bytes.

770
01:06:40,660 --> 01:06:43,200
>> I tots ells apunten a les seves pròpies 4 bytes.

771
01:06:43,200 --> 01:06:49,080
Això em dóna una manera de fer les coses multidimensionals.

772
01:06:49,080 --> 01:06:58,030
Podria dir pp [3] [4], però ara això no és el mateix com matrius multidimensionals

773
01:06:58,030 --> 01:07:05,390
ja que les matrius multidimensionals traduït [3] [4] en una sola Desplaçament en la matriu x.

774
01:07:05,390 --> 01:07:14,790
Aquesta p desreferencias, accedeix al tercer índex, a continuació, elimina referències que

775
01:07:14,790 --> 01:07:20,790
i accessos - 4 seria invàlid - el segon índex.

776
01:07:24,770 --> 01:07:31,430
Mentre que quan vam tenir la int x [3] [4] abans com una matriu multidimensional

777
01:07:31,430 --> 01:07:35,740
i en fer doble suport és realment només un dereference sola

778
01:07:35,740 --> 01:07:40,490
vostè està seguint un únic punter i després un desplaçament,

779
01:07:40,490 --> 01:07:42,850
això és realment referències 2D.

780
01:07:42,850 --> 01:07:45,840
Segueixes 2 punteres separats.

781
01:07:45,840 --> 01:07:50,420
Així que això també tècnicament li permet tenir matrius multidimensionals

782
01:07:50,420 --> 01:07:53,550
on cada matriu individual és diferents mides.

783
01:07:53,550 --> 01:07:58,000
Així que crec irregulars matrius multidimensionals és el que s'anomena

784
01:07:58,000 --> 01:08:01,870
ja que realment la primera cosa podria apuntar a alguna cosa que té 10 elements,

785
01:08:01,870 --> 01:08:05,540
la segona cosa que podria apuntar a alguna cosa que té 100 elements.

786
01:08:05,540 --> 01:08:10,790
[Estudiant] Hi ha límit en el nombre de punters que pot tenir

787
01:08:10,790 --> 01:08:14,290
apuntant a altres indicadors? No >>

788
01:08:14,290 --> 01:08:17,010
Vostè pot tenir int ***** p.

789
01:08:18,050 --> 01:08:23,760
Tornar a l'aritmètica de punters - >> [estudiant] Oh. Sí >>.

790
01:08:23,760 --> 01:08:35,649
[Estudiant] Si tinc int p *** i després faig una desreferencia i dic * p és igual a aquest valor,

791
01:08:35,649 --> 01:08:39,560
És només farà un nivell d'eliminació de referències? Sí >>.

792
01:08:39,560 --> 01:08:43,340
Així que si vull accedir al que el punter apunta a l'últim -

793
01:08:43,340 --> 01:08:46,210
Després de fer p ***. >> Okay.

794
01:08:46,210 --> 01:08:54,080
Així que això és p apunta a un bloc, apunta a un altre bloc, apunta a un altre bloc.

795
01:08:54,080 --> 01:09:02,010
Llavors, si vostè fa * p = alguna cosa més, llavors canviarà aquesta

796
01:09:02,010 --> 01:09:13,640
a punt ara a un bloc diferent. >> Okay.

797
01:09:13,640 --> 01:09:17,649
>> [Bowden] I si aquests es malloced, llavors vostè ara ha escapat memòria

798
01:09:17,649 --> 01:09:20,430
llevat que li passa que té diferents referències d'aquests

799
01:09:20,430 --> 01:09:25,270
ja que no pot tornar a aquells que només va tirar.

800
01:09:25,270 --> 01:09:29,550
Aritmètica de punters.

801
01:09:29,550 --> 01:09:36,310
int x [4], es va a assignar una matriu de 4 punts

802
01:09:36,310 --> 01:09:40,670
on x es va a apuntar a la començament de la matriu.

803
01:09:40,670 --> 01:09:50,420
Així que quan dic alguna cosa com x [1], jo vull que signifiqui anar al segon sencer a la matriu,

804
01:09:50,420 --> 01:09:53,319
que seria aquest.

805
01:09:53,319 --> 01:10:04,190
Però, en realitat, això és 4 bytes en la matriu ja que aquest sencer ocupa 4 bytes.

806
01:10:04,190 --> 01:10:08,470
Per tant un desplaçament d'1 significa realment un desplaçament d'1

807
01:10:08,470 --> 01:10:12,030
vegades la mida de qualsevol que sigui el tipus de la matriu és.

808
01:10:12,030 --> 01:10:17,170
Aquest és un arranjament d'enters, pel que sap fer una vegades la mida de int quan es vol compensar.

809
01:10:17,170 --> 01:10:25,260
La resta de la sintaxi. Recorda que això és equivalent a * (x + 1);

810
01:10:25,260 --> 01:10:35,250
Quan dic punter + 1, el que torna és la direcció que el punter està emmagatzemant

811
01:10:35,250 --> 01:10:40,360
més 1 vegades la mida del tipus del punter.

812
01:10:40,360 --> 01:10:59,510
Així que si x = ox100, llavors x + 1 = ox104.

813
01:10:59,510 --> 01:11:19,750
I es pot abusar d'això i dir alguna cosa com char * c = (char *) x;

814
01:11:19,750 --> 01:11:23,050
i ara c serà la mateixa direcció x.

815
01:11:23,050 --> 01:11:26,040
c serà igual a ox100,

816
01:11:26,040 --> 01:11:31,490
però c + 1 serà igual a ox101

817
01:11:31,490 --> 01:11:38,030
ja que l'aritmètica de punters depèn del tipus del punter que va a afegir a.

818
01:11:38,030 --> 01:11:45,390
Així que c + 1, es veu en c, que és un punter char, així que va a afegir una vegades la mida de xerrades,

819
01:11:45,390 --> 01:11:48,110
que sempre serà 1, de manera que obtenir 101,

820
01:11:48,110 --> 01:11:54,890
mentre que si ho faig x, que també segueix sent 100, x + 1 serà 104.

821
01:11:56,660 --> 01:12:06,340
[Estudiant] Es pot fer servir c + + per avançar el punter per 1?

822
01:12:06,340 --> 01:12:09,810
Sí, es pot.

823
01:12:09,810 --> 01:12:16,180
No podeu fer això amb x perquè x és només un símbol, és una constant, no es pot canviar x.

824
01:12:16,180 --> 01:12:22,610
>> Però c passa a ser simplement un punter, de manera que c + + és perfectament vàlid i que s'incrementarà en 1.

825
01:12:22,610 --> 01:12:32,440
Si c és només un int *, llavors c + + seria 104.

826
01:12:32,440 --> 01:12:41,250
+ + Fa aritmètica de punters com c + 1 hauria de fer aritmètica de punters.

827
01:12:43,000 --> 01:12:48,870
Això és en realitat com un munt de coses com l'espècie de barreja -

828
01:12:49,670 --> 01:12:55,710
En lloc de crear còpies de les coses, en el seu lloc pot passar -

829
01:12:55,710 --> 01:13:02,400
Igual que si volia passar aquesta meitat de la matriu - Anem a esborrar alguna cosa d'això.

830
01:13:04,770 --> 01:13:10,520
Diguem que jo volia passar a aquest costat de la matriu en una funció.

831
01:13:10,520 --> 01:13:12,700
Què passaria amb aquesta funció?

832
01:13:12,700 --> 01:13:17,050
Si pas x, estic passant aquesta direcció.

833
01:13:17,050 --> 01:13:23,780
Però vull passar aquesta direcció en particular. Llavors, què hauria de passar?

834
01:13:23,780 --> 01:13:26,590
[Estudiant] Pointer + 2?

835
01:13:26,590 --> 01:13:29,350
[Bowden] Llavors x + 2. Sí

836
01:13:29,350 --> 01:13:31,620
Això serà aquesta direcció.

837
01:13:31,620 --> 01:13:42,810
També molt sovint ho veuen com x [2] i després la direcció d'això.

838
01:13:42,810 --> 01:13:47,850
Així que cal prendre la direcció de la mateixa pel fet que el suport és eliminar la referència implícita.

839
01:13:47,850 --> 01:13:53,250
x [2] es refereix al valor que està en aquesta caixa de text, a continuació, vol que la direcció de la caixa,

840
01:13:53,250 --> 01:13:56,850
pel que diuen i x [2].

841
01:13:56,850 --> 01:14:02,880
Així és com quelcom en espècie de combinació on voleu passar la meitat de la llista a alguna cosa

842
01:14:02,880 --> 01:14:08,790
el que realment passa & x [2], i ara pel que fa a la crida recursiva es refereix,

843
01:14:08,790 --> 01:14:12,510
la meva nova matriu comença allà.

844
01:14:12,510 --> 01:14:15,130
Preguntes d'última hora.

845
01:14:15,130 --> 01:14:20,050
[Estudiant] Si no posem un signe o un - què és això crida? >> Star?

846
01:14:20,050 --> 01:14:23,200
[Estudiant] estrelles. >> Tècnicament, l'operador d'indirecció, però - >> [estudiant] eliminació de referències.

847
01:14:23,200 --> 01:14:29,310
>> Si no posem un estel o un símbol d'unió, què passa si acabo de dir i = x i x és un punter?

848
01:14:29,310 --> 01:14:34,620
Quin és el tipus de i? >> [Estudiant] només diré que és punter 2.

849
01:14:34,620 --> 01:14:38,270
Així que si vostè acaba de dir i = x, x ara i punt i la mateixa cosa. >> [Estudiant] apunten a la mateixa cosa.

850
01:14:38,270 --> 01:14:45,180
I si x és un punter int? Seria >> queixen perquè no es pot assignar punters.

851
01:14:45,180 --> 01:14:46,540
[Estudiant] Bé.

852
01:14:46,540 --> 01:14:51,860
Recordeu que els punters, tot i que dibuixar com fletxes,

853
01:14:51,860 --> 01:15:02,010
realment tot el que botiga - int * x - realment tot x és l'emmagatzematge és com ox100,

854
01:15:02,010 --> 01:15:06,490
que ens ha tocat representar com assenyalar al bloc emmagatzemat a 100.

855
01:15:06,490 --> 01:15:19,660
Així que quan dic int * i = x; només estic copiant a ox100 i,

856
01:15:19,660 --> 01:15:24,630
que només anem a representar i, també apunta a ox100.

857
01:15:24,630 --> 01:15:39,810
I si dic int i = (int) x; llavors em emmagatzemar qualsevol que sigui el valor de ox100 és

858
01:15:39,810 --> 01:15:45,100
dins d'ella, però ara que serà interpretat com un enter en lloc d'un punter.

859
01:15:45,100 --> 01:15:49,310
Però és necessari el guix o en cas contrari es queixarà.

860
01:15:49,310 --> 01:15:53,300
[Estudiant] Llavors, et refereixes a emetre -

861
01:15:53,300 --> 01:16:00,290
¿Estarà tirant int x int o fosa de i?

862
01:16:00,290 --> 01:16:03,700
[Bowden] Què?

863
01:16:03,700 --> 01:16:07,690
[Estudiant] Bé. Després d'aquests parèntesis es hi haurà una xo ai allà?

864
01:16:07,690 --> 01:16:11,500
>> [Bowden] Qualsevol. x i i són equivalents. >> [Estudiant] Bé.

865
01:16:11,500 --> 01:16:14,390
Com que tots dos són punters. Sí >>.

866
01:16:14,390 --> 01:16:21,050
[Estudiant] Pel que seria emmagatzemar el 100 en forma hexadecimal sencer? >> [Bowden] Yeah.

867
01:16:21,050 --> 01:16:23,620
Però no és el valor del que apunta.

868
01:16:23,620 --> 01:16:29,940
[Bowden] Yeah. >> [Estudiant] Només la direcció en forma de nombre sencer. Bé.

869
01:16:29,940 --> 01:16:34,720
[Bowden] Per per alguna estranya raó,

870
01:16:34,720 --> 01:16:38,900
vostè podria tractar exclusivament amb els punters i mai tractar amb nombres enters

871
01:16:38,900 --> 01:16:49,240
i simplement ser com int * x = 0.

872
01:16:49,240 --> 01:16:53,000
Després et quedaràs molt confós una vegada aritmètica de punters comença a succeir.

873
01:16:53,000 --> 01:16:56,570
Així que els nombres que emmagatzemen no tenen sentit.

874
01:16:56,570 --> 01:16:58,940
Només és com s'arriba a interpretar-los.

875
01:16:58,940 --> 01:17:02,920
Així que sóc lliure de copiar ox100 d'un int * a un int,

876
01:17:02,920 --> 01:17:07,790
i jo sóc lliure d'assignar - vostè està probablement va a cridar en fosa per a no -

877
01:17:07,790 --> 01:17:18,160
Sóc lliure per assignar alguna cosa com (int *) ox1234 en aquest * int arbitrària.

878
01:17:18,160 --> 01:17:25,480
Així ox123 és tan vàlida com una adreça de memòria és & i.

879
01:17:25,480 --> 01:17:32,060
& I passa a tornar alguna cosa que és més o menys ox123.

880
01:17:32,060 --> 01:17:35,430
[Estudiant] que seria una forma genial de passar de hexadecimal a format decimal,

881
01:17:35,430 --> 01:17:39,230
com si vostè té un punter i el van fer fora com un int?

882
01:17:39,230 --> 01:17:44,860
[Bowden] Pot realment imprimir utilitzant com printf.

883
01:17:44,860 --> 01:17:50,300
Diguem que tinc int i = 100.

884
01:17:50,300 --> 01:18:02,700
Així printf (% d \ n - com vostè ja ha de saber - que imprimeix en forma de sencer x%.

885
01:18:02,700 --> 01:18:05,190
Anem a imprimir com hexadecimal.

886
01:18:05,190 --> 01:18:10,760
Així que un punter no s'emmagatzema com hexadecimal,

887
01:18:10,760 --> 01:18:12,960
i un nombre enter no s'emmagatzemen com decimal.

888
01:18:12,960 --> 01:18:14,700
Tot s'emmagatzema en forma binària.

889
01:18:14,700 --> 01:18:17,950
És només que tendim a mostrar punters com hexadecimal

890
01:18:17,950 --> 01:18:23,260
perquè pensem en les coses en aquests blocs de 4 bytes,

891
01:18:23,260 --> 01:18:25,390
i les adreces de memòria tendeixen a ser familiar.

892
01:18:25,390 --> 01:18:28,890
Som com, si comença amb bf, a continuació, passa a ser a la pila.

893
01:18:28,890 --> 01:18:35,560
Així que és només nostra interpretació de punters com hexadecimal.

894
01:18:35,560 --> 01:18:39,200
Bé. Les últimes preguntes?

895
01:18:39,200 --> 01:18:41,700
>> Vaig a ser aquí per una mica després si vostè té qualsevol altra cosa.

896
01:18:41,700 --> 01:18:46,070
I aquest és el final de tot.

897
01:18:46,070 --> 01:18:48,360
>> [Estudiant] Yay! [Aplaudiment]

898
01:18:51,440 --> 01:18:53,000
>> [CS50.TV]