1
00:00:00,000 --> 00:00:00,499

2
00:00:00,499 --> 00:00:01,395
[Jouer de la musique]

3
00:00:01,395 --> 00:00:05,590

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK donc une suggestion
avant de commencer ici.

5
00:00:07,940 --> 00:00:11,660
Si vous ne l'avez pas regardé la vidéo sur
pointeurs vous pouvez le faire en premier.

6
00:00:11,660 --> 00:00:15,860
Parce que cette vidéo est un autre
façon de travailler avec des pointeurs.

7
00:00:15,860 --> 00:00:17,574
>> Donc, il va parler
à propos de certains concepts

8
00:00:17,574 --> 00:00:19,490
que nous couvrons dans le
pointeurs vidéo, et nous sommes

9
00:00:19,490 --> 00:00:21,948
va passer sur eux maintenant,
en supposant qu'ils sont déjà

10
00:00:21,948 --> 00:00:23,090
sorte de compris.

11
00:00:23,090 --> 00:00:25,440
Voilà donc simplement votre avertissement juste
que si vous voyez cette vidéo

12
00:00:25,440 --> 00:00:27,814
et vous avez pas vu le
pointeurs vidéo, il pourrait en quelque sorte

13
00:00:27,814 --> 00:00:29,610
voler au-dessus de votre tête un peu.

14
00:00:29,610 --> 00:00:32,080
Et ainsi il pourrait être mieux
de le regarder dans cet ordre.

15
00:00:32,080 --> 00:00:34,710
>> Donc, nous avons déjà vu un
façon de travailler avec des pointeurs,

16
00:00:34,710 --> 00:00:37,810
qui est, nous déclarons une
variable, puis nous

17
00:00:37,810 --> 00:00:42,160
déclarer une autre variable, un pointeur
variable qui pointe vers elle.

18
00:00:42,160 --> 00:00:44,870
Nous avons donc créé un
variable avec un nom, nous avons

19
00:00:44,870 --> 00:00:48,480
créé une seconde variable avec un nom,
et nous soulignons que cette seconde variable

20
00:00:48,480 --> 00:00:50,220
Lors de cette première.

21
00:00:50,220 --> 00:00:52,370
Ce genre de a une
problème cependant, car il

22
00:00:52,370 --> 00:00:54,650
nous oblige à savoir exactement
combien de mémoire nous sommes

23
00:00:54,650 --> 00:00:57,600
allez avoir besoin du moment
notre programme est compilé.

24
00:00:57,600 --> 00:00:58,220
>> Pourquoi donc?

25
00:00:58,220 --> 00:01:03,338
Parce que nous devons être en mesure de nommer ou
identifier toutes les variables possibles

26
00:01:03,338 --> 00:01:04,129
nous pourrions rencontrer.

27
00:01:04,129 --> 00:01:07,910
Nous pourrions avoir un tableau qui pourrait être
capable de tenir un grand nombre d'informations,

28
00:01:07,910 --> 00:01:10,110
mais il est toujours pas
exactement assez précis.

29
00:01:10,110 --> 00:01:12,640
Que faire si nous ne savons pas,
si nous avons aucune idée

30
00:01:12,640 --> 00:01:14,370
combien nous aurons besoin d'au moment de la compilation?

31
00:01:14,370 --> 00:01:17,020
Ou si Notre programme
courir pour un temps très long,

32
00:01:17,020 --> 00:01:19,810
accepter diverses utilisateur
données, et nous ne pouvons pas vraiment

33
00:01:19,810 --> 00:01:23,170
estimer si nous sommes
allez avoir besoin de 1.000 unités?

34
00:01:23,170 --> 00:01:26,060
>> Il est pas comme si nous pouvons
dire à la ligne de commande

35
00:01:26,060 --> 00:01:28,040
entrez le nombre d'éléments
vous pensez que vous aurez besoin.

36
00:01:28,040 --> 00:01:31,100
Eh bien si cette supposition est erronée?

37
00:01:31,100 --> 00:01:34,300
Allocation dynamique de mémoire
sorte de la façon dont nous permet

38
00:01:34,300 --> 00:01:36,867
pour contourner ce problème particulier.

39
00:01:36,867 --> 00:01:38,700
Et la façon dont il le fait
est en utilisant des pointeurs.

40
00:01:38,700 --> 00:01:42,140
>> Nous pouvons utiliser des pointeurs vers
avoir accès à dynamiquement

41
00:01:42,140 --> 00:01:45,710
mémoire allouée, mémoire qui est
alloué que votre programme est en cours.

42
00:01:45,710 --> 00:01:48,290
Il est pas attribué lors de la compilation.

43
00:01:48,290 --> 00:01:51,570
Lorsque vous allouez dynamiquement
mémoire, il vient d'une piscine

44
00:01:51,570 --> 00:01:53,795
de mémoire connu sous le tas.

45
00:01:53,795 --> 00:01:56,420
Auparavant toute la mémoire que nous avons
travaille dans le cours

46
00:01:56,420 --> 00:01:59,920
a été en provenance d'un pool
de mémoire connu comme la pile.

47
00:01:59,920 --> 00:02:02,470
Une bonne façon de général
garder à l'mind-- et cette règle

48
00:02:02,470 --> 00:02:04,720
ne tient pas toujours vrai,
mais à peu près presque

49
00:02:04,720 --> 00:02:09,940
maintient toujours true-- est que toute
fois que vous donnez un nom variable, il

50
00:02:09,940 --> 00:02:12,090
vit probablement sur la pile.

51
00:02:12,090 --> 00:02:14,650
Et chaque fois que vous ne
donner une variable un nom,

52
00:02:14,650 --> 00:02:19,160
que vous pouvez faire avec la mémoire dynamique
l'allocation, il vit sur le tas.

53
00:02:19,160 --> 00:02:22,190
>> Maintenant, je suis une sorte de présenter cela comme
si il ya ces deux pools de mémoire.

54
00:02:22,190 --> 00:02:24,740
Mais vous avez peut-être vu cette
diagramme, qui est généralement

55
00:02:24,740 --> 00:02:27,290
une représentation de
ce qui ressemble à la mémoire,

56
00:02:27,290 --> 00:02:30,373
et on ne va pas se soucier de tous les
les trucs dans le haut et le bas.

57
00:02:30,373 --> 00:02:33,580
Qu'est-ce que nous nous soucions de cette partie est en
le milieu ici, tas et de la pile.

58
00:02:33,580 --> 00:02:35,570
Comme vous pouvez le voir par
en regardant ce diagramme,

59
00:02:35,570 --> 00:02:38,390
ce sont en fait deux pas
piscines séparées de mémoire.

60
00:02:38,390 --> 00:02:42,757
Il est une piscine partagée de mémoire
où vous commencez, dans ce visuel

61
00:02:42,757 --> 00:02:44,590
vous commencez au bas
et commencer à remplir

62
00:02:44,590 --> 00:02:48,040
à partir du bas de la pile, et vous
commencer par le haut et commencer à remplir

63
00:02:48,040 --> 00:02:50,072
de haut en bas avec le tas.

64
00:02:50,072 --> 00:02:51,780
Mais il est vraiment le
même pool, il est juste

65
00:02:51,780 --> 00:02:56,050
différents endroits différents endroits,
dans la mémoire qui sont alloués.

66
00:02:56,050 --> 00:02:59,060
Et vous pouvez exécuter sur
soit par mémoire comportant

67
00:02:59,060 --> 00:03:01,240
le tas aller tout le chemin
vers le bas, ou avoir

68
00:03:01,240 --> 00:03:05,440
la pile aller tout le chemin vers le haut,
ou présentant le tas et la pile

69
00:03:05,440 --> 00:03:06,740
rencontrer un contre l'autre.

70
00:03:06,740 --> 00:03:09,500
Tous ceux-ci peuvent être des conditions
qui causent votre programme

71
00:03:09,500 --> 00:03:11,030
à court de mémoire.

72
00:03:11,030 --> 00:03:11,952
Alors garde cela en tête.

73
00:03:11,952 --> 00:03:13,660
Lorsque nous parlons de
le tas et de la pile

74
00:03:13,660 --> 00:03:17,880
nous parlons vraiment de la
même bloc général de la mémoire, tout simplement

75
00:03:17,880 --> 00:03:21,930
que des parties différentes de la mémoire.

76
00:03:21,930 --> 00:03:24,910
>> Alors, comment pouvons-nous obtenir dynamiquement
mémoire allouée en premier lieu?

77
00:03:24,910 --> 00:03:27,740
Comment obtenir notre programme
la mémoire car il est en cours d'exécution?

78
00:03:27,740 --> 00:03:32,660
Eh bien C fournit une fonction appelée
malloc, allocateur de mémoire, ce qui

79
00:03:32,660 --> 00:03:36,810
vous effectuez un appel, et vous passez dans
combien d'octets de mémoire que vous souhaitez.

80
00:03:36,810 --> 00:03:39,940
Donc, si votre programme est en marche
et vous voulez un runtime entier,

81
00:03:39,940 --> 00:03:46,040
vous pourriez Mallock quatre octets de
mémoire, malloc parenthèses quatre.

82
00:03:46,040 --> 00:03:48,540
>> Mallock passera par
en regardant à travers le tas,

83
00:03:48,540 --> 00:03:50,750
parce que nous sommes dynamiquement
allouer de la mémoire,

84
00:03:50,750 --> 00:03:53,500
et il reviendra à vous
un pointeur vers cette mémoire.

85
00:03:53,500 --> 00:03:56,180
Il ne vous donne pas que memory--
il ne donne pas de nom,

86
00:03:56,180 --> 00:03:57,950
il vous donne un pointeur vers elle.

87
00:03:57,950 --> 00:04:00,780
Et voilà pourquoi je l'ai dit à nouveau
qu'il est important de peut-être

88
00:04:00,780 --> 00:04:03,770
ont regardé la vidéo pointeurs
avant d'aller trop loin dans cette.

89
00:04:03,770 --> 00:04:05,940
Donc malloc va
vous redonner un pointeur.

90
00:04:05,940 --> 00:04:08,950
>> Si Mallock ne peut vous donner tout
la mémoire parce que vous avez épuisé,

91
00:04:08,950 --> 00:04:10,645
il va vous redonner un pointeur NULL.

92
00:04:10,645 --> 00:04:15,282
Vous rappelez-vous ce qui se passe si nous
essayer de déréférencer un pointeur NULL?

93
00:04:15,282 --> 00:04:17,019
Nous souffrons d'un défaut de seg, non?

94
00:04:17,019 --> 00:04:18,060
Voilà probablement pas bon.

95
00:04:18,060 --> 00:04:21,579
>> Ainsi, chaque fois que vous faites un appel
vous malloc toujours, toujours

96
00:04:21,579 --> 00:04:25,270
besoin de vérifier si oui ou non la
pointeur, il vous a donné est de retour nul.

97
00:04:25,270 --> 00:04:28,800
Si elle est, vous devez mettre fin à votre programme
parce que si vous essayez de déréférencer

98
00:04:28,800 --> 00:04:31,360
le pointeur NULL vous allez
souffrir d'une erreur de segmentation

99
00:04:31,360 --> 00:04:34,380
et votre programme est
nous écraser de toute façon.

100
00:04:34,380 --> 00:04:37,190
Alors, comment avons-nous statiquement
obtenir un nombre entier?

101
00:04:37,190 --> 00:04:37,730
>> int x.

102
00:04:37,730 --> 00:04:40,010
Nous avons probablement fait que
un tas de fois, non?

103
00:04:40,010 --> 00:04:43,480
Cela crée une variable appelée
x qui vit sur la pile.

104
00:04:43,480 --> 00:04:46,190
Comment pouvons-nous obtenir dynamiquement un nombre entier?

105
00:04:46,190 --> 00:04:50,010
Int étoiles px égale malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Ou plus appropriée
nous dirions int étoiles px

107
00:04:53,050 --> 00:04:57,680
est égal à la taille de malloc int,
juste pour jeter un peu moins

108
00:04:57,680 --> 00:04:59,740
nombres magiques autour de notre programme.

109
00:04:59,740 --> 00:05:04,140
Cela va obtenir pour nous
quatre octets de mémoire à partir du tas,

110
00:05:04,140 --> 00:05:06,720
et le pointeur nous obtenons
revenir est appelé px.

111
00:05:06,720 --> 00:05:08,430
Et puis juste comme nous l'avons
nous avons fait précédemment

112
00:05:08,430 --> 00:05:13,966
peut déréférencer px à
accéder à cette mémoire.

113
00:05:13,966 --> 00:05:15,590
Comment pouvons-nous obtenir un nombre entier de l'utilisateur?

114
00:05:15,590 --> 00:05:17,970
Nous pouvons dire int x est égal à obtenir int.

115
00:05:17,970 --> 00:05:19,930
Voilà assez simple.

116
00:05:19,930 --> 00:05:24,030
Que faire si nous voulons créer un tableau
de X flotteurs qui vivent sur la pile?

117
00:05:24,030 --> 00:05:28,210
flotter stack_array-- qui est le nom
de nos array-- supports carrés x.

118
00:05:28,210 --> 00:05:32,419
Cela créera pour nous un tableau
de X flotteurs qui vivent sur la pile.

119
00:05:32,419 --> 00:05:34,960
Nous pouvons créer un réseau de flotteurs
qui vit sur le tas, aussi.

120
00:05:34,960 --> 00:05:37,330
La syntaxe peut sembler un
peu plus lourd,

121
00:05:37,330 --> 00:05:41,740
mais nous pouvons dire flotteur
heap_array étoiles égale

122
00:05:41,740 --> 00:05:44,360
malloc x fois la taille du flotteur.

123
00:05:44,360 --> 00:05:48,160
Je dois assez de place pour contenir
x valeurs à virgule flottante.

124
00:05:48,160 --> 00:05:51,560
Donc, dire que je dois 100
flotteurs, ou 1.000 flotteurs.

125
00:05:51,560 --> 00:05:54,810
Donc, dans ce cas, il serait
400 octets pour 100 chars,

126
00:05:54,810 --> 00:05:59,080
ou 4000 octets pour 1.000 flotteurs,
parce que chaque flotteur prend

127
00:05:59,080 --> 00:06:01,230
quatre octets d'espace.

128
00:06:01,230 --> 00:06:05,110
>> Après avoir fait ce que je peux utiliser le
crochet sur la syntaxe heap_array.

129
00:06:05,110 --> 00:06:08,970
Juste comme je le ferais sur stack_array, je
peut accéder à ses éléments individuellement

130
00:06:08,970 --> 00:06:11,590
en utilisant heap_array zéro, une heap_array.

131
00:06:11,590 --> 00:06:15,800
Mais rappeler la raison nous pouvons le faire
est parce que le nom d'un tableau en C

132
00:06:15,800 --> 00:06:19,990
est vraiment un pointeur vers
premier élément de ce tableau.

133
00:06:19,990 --> 00:06:23,480
Donc, le fait que nous allons déclarer une
gamme de flotteurs sur la pile ici

134
00:06:23,480 --> 00:06:24,810
est en fait un peu trompeur.

135
00:06:24,810 --> 00:06:27,600
Nous sommes vraiment dans le
deuxième ligne de code il

136
00:06:27,600 --> 00:06:32,360
créant également un pointeur vers un morceau de
mémoire que nous faisons ensuite un peu de travail avec.

137
00:06:32,360 --> 00:06:35,620
>> Voici le gros problème avec
la mémoire allouée dynamiquement si,

138
00:06:35,620 --> 00:06:38,360
et cela est pourquoi il est vraiment
important de développer des bonnes habitudes

139
00:06:38,360 --> 00:06:39,800
lorsque vous travaillez avec elle.

140
00:06:39,800 --> 00:06:43,060
Contrairement déclaré statiquement
la mémoire, la mémoire

141
00:06:43,060 --> 00:06:46,790
ne sont pas automatiquement retourné à la
système lorsque votre fonction est fait.

142
00:06:46,790 --> 00:06:49,280
Donc, si nous avons principale, et
principale appelle une fonction

143
00:06:49,280 --> 00:06:53,860
f, où f finitions tout ce qu'il fait
et renvoie le contrôle du programme

144
00:06:53,860 --> 00:06:58,810
Retour au menu principal, toute la mémoire
que f utilisé est restitué.

145
00:06:58,810 --> 00:07:01,250
Il peut être utilisé à nouveau
par un autre programme,

146
00:07:01,250 --> 00:07:04,250
ou une autre fonction que
est appelée plus tard dans la principale.

147
00:07:04,250 --> 00:07:06,970
Il peut utiliser la même mémoire encore.

148
00:07:06,970 --> 00:07:09,620
>> Si vous dynamiquement
allouer de la mémoire si

149
00:07:09,620 --> 00:07:14,380
vous devez indiquer explicitement au
système que vous avez fini avec lui.

150
00:07:14,380 --> 00:07:18,370
Il va le retenir pour vous, ce qui pourrait
conduire à un problème de vous manquer

151
00:07:18,370 --> 00:07:19,290
de mémoire.

152
00:07:19,290 --> 00:07:22,179
Et en fait, nous appelons parfois
à cela comme une fuite de mémoire.

153
00:07:22,179 --> 00:07:24,970
Et parfois, ces fuites de mémoire
peut effectivement être vraiment dévastatrice

154
00:07:24,970 --> 00:07:27,020
pour la performance du système.

155
00:07:27,020 --> 00:07:31,120
>> Si vous êtes un utilisateur d'Internet fréquente
vous pourriez utiliser certains navigateurs web,

156
00:07:31,120 --> 00:07:35,630
et je ne vais pas citer de noms ici, mais
il ya certains navigateurs web là-bas

157
00:07:35,630 --> 00:07:39,150
qui sont connus pour avoir fait
fuites de mémoire qui ne sont corrigés.

158
00:07:39,150 --> 00:07:44,570
Et si vous laissez votre navigateur ouvert
pour une très longue période de temps, jours

159
00:07:44,570 --> 00:07:48,060
et des jours, voire des semaines, parfois vous
peut-être remarqué que votre système

160
00:07:48,060 --> 00:07:49,790
est en cours d'exécution vraiment, vraiment lentement.

161
00:07:49,790 --> 00:07:54,640
Et la raison en est que
le navigateur a alloué la mémoire,

162
00:07:54,640 --> 00:07:57,320
mais alors pas dit le système
qu'il a fait avec elle.

163
00:07:57,320 --> 00:08:01,000
Et donc cela laisse moins de mémoire
disponible pour tous vos autres programmes

164
00:08:01,000 --> 00:08:04,480
d'avoir à partager, parce que vous êtes
leaking-- ce navigateur web

165
00:08:04,480 --> 00:08:06,755
programme est une fuite de mémoire.

166
00:08:06,755 --> 00:08:08,880
Comment donnons-nous la mémoire de retour
quand nous aurons fini avec elle?

167
00:08:08,880 --> 00:08:10,838
Bien heureusement, il est un
moyen très facile de le faire.

168
00:08:10,838 --> 00:08:11,710
Nous venons de le libérer.

169
00:08:11,710 --> 00:08:15,020
Il ya une fonction appelée libre,
il accepte un pointeur vers la mémoire,

170
00:08:15,020 --> 00:08:16,010
et nous sommes bon pour aller.

171
00:08:16,010 --> 00:08:18,310
>> Donc, disons que nous sommes dans la
milieu de notre programme,

172
00:08:18,310 --> 00:08:21,970
nous voulons malloc 50 caractères.

173
00:08:21,970 --> 00:08:25,710
Nous voulons malloc un tableau qui peut
capable de contenir 50 caractères.

174
00:08:25,710 --> 00:08:29,109
Et quand nous obtenons un pointeur sur
que, le nom de ce pointeur est le mot.

175
00:08:29,109 --> 00:08:30,900
Nous faisons tout ce que nous sommes
va faire avec le mot,

176
00:08:30,900 --> 00:08:33,440
et puis quand nous sommes
fait nous venons de le libérer.

177
00:08:33,440 --> 00:08:37,460
Et maintenant, nous avons retourné les 50
octets de mémoire au système.

178
00:08:37,460 --> 00:08:40,147
Une autre fonction peut les utiliser.

179
00:08:40,147 --> 00:08:43,480
Nous ne devons pas nous inquiéter à propos de la souffrance d'un
fuite de mémoire parce que nous avons libéré mot.

180
00:08:43,480 --> 00:08:46,639
Nous avons donné la mémoire de retour,
de sorte que nous aurons fini de travailler avec elle.

181
00:08:46,639 --> 00:08:48,430
Donc, il ya trois
règles d'or qui devrait

182
00:08:48,430 --> 00:08:51,700
être gardé à l'esprit chaque fois que vous êtes
allocation dynamique de mémoire

183
00:08:51,700 --> 00:08:52,990
avec malloc.

184
00:08:52,990 --> 00:08:56,480
Chaque bloc de mémoire que
vous devez être libéré malloc

185
00:08:56,480 --> 00:08:58,430
avant que votre programme termine son exécution.

186
00:08:58,430 --> 00:09:02,029
Maintenant, de nouveau, dans l'appareil ou dans le
IDE arrive ce genre de toute façon pour vous

187
00:09:02,029 --> 00:09:04,820
quand vous-- cela se produira de toute façon
lorsque votre programme est terminé,

188
00:09:04,820 --> 00:09:06,880
toute la mémoire sera publié.

189
00:09:06,880 --> 00:09:10,750
Mais il est généralement bon codage
la pratique de toujours, lorsque vous avez terminé,

190
00:09:10,750 --> 00:09:13,810
libérez ce que vous avez mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Cela dit, les seules choses qui
vous avez mallocd doit être libéré.

192
00:09:16,690 --> 00:09:19,880
Si vous déclarez une statiquement
entier, int x point-virgule,

193
00:09:19,880 --> 00:09:23,500
qui vit sur la pile, vous
ne veulent pas alors à x libérer.

194
00:09:23,500 --> 00:09:25,970
Donc seules choses que vous avez
mallocd doit être libéré.

195
00:09:25,970 --> 00:09:28,960
>> Et enfin, ne pas quelque chose de gratuit deux fois.

196
00:09:28,960 --> 00:09:31,170
Cela peut conduire à
une autre situation bizarre.

197
00:09:31,170 --> 00:09:33,530
Donc, tout ce que vous avez
mallocd doit être libéré.

198
00:09:33,530 --> 00:09:36,000
Seuls les choses que vous avez
malloc doit être libéré.

199
00:09:36,000 --> 00:09:38,730
Et ne pas quelque chose de gratuit deux fois.

200
00:09:38,730 --> 00:09:43,660
>> Donc, nous allons passer par un exemple ici
de ce que certains allouée dynamiquement

201
00:09:43,660 --> 00:09:46,122
mémoire pourrait ressembler mixte
avec un peu de mémoire statique.

202
00:09:46,122 --> 00:09:47,080
Ce qui pourrait se produire ici?

203
00:09:47,080 --> 00:09:48,913
Voyez si vous pouvez suivre
long et devinez quoi est

204
00:09:48,913 --> 00:09:51,720
va se passer comme nous allons
à travers toutes ces lignes de code.

205
00:09:51,720 --> 00:09:53,980
>> Donc, nous disons int m.

206
00:09:53,980 --> 00:09:54,840
Qu'est-ce qu'il se passe ici?

207
00:09:54,840 --> 00:09:56,339
Eh bien cela est assez simple.

208
00:09:56,339 --> 00:09:59,650
Je crée une variable entière appelé m.

209
00:09:59,650 --> 00:10:01,400
Je colore en vert,
parce que ce la couleur

210
00:10:01,400 --> 00:10:03,730
que je l'utilise quand je parle
environ variables entières.

211
00:10:03,730 --> 00:10:05,160
Il est une boîte.

212
00:10:05,160 --> 00:10:08,400
Il est appelé m, et vous pouvez
entiers de magasins à l'intérieur.

213
00:10:08,400 --> 00:10:12,400
>> Que faire si je puis dire int étoiles un?

214
00:10:12,400 --> 00:10:13,530
Eh bien ce est assez similaire.

215
00:10:13,530 --> 00:10:15,780
Je crée une boîte appelée.

216
00:10:15,780 --> 00:10:19,100
Il est capable de tenue int
étoiles, des pointeurs vers des entiers.

217
00:10:19,100 --> 00:10:21,570
Donc, je suis colorer en vert-ish ainsi.

218
00:10:21,570 --> 00:10:24,140
>> Je sais qu'il a quelque chose
à faire avec un nombre entier,

219
00:10:24,140 --> 00:10:25,852
mais il est pas lui-même un nombre entier.

220
00:10:25,852 --> 00:10:27,310
Mais il est à peu près la même idée.

221
00:10:27,310 --> 00:10:28,101
Je ai créé une boîte.

222
00:10:28,101 --> 00:10:30,070
Ces deux droit
vivent maintenant sur la pile.

223
00:10:30,070 --> 00:10:32,520
Je leur ai donné les deux noms.

224
00:10:32,520 --> 00:10:36,750
>> int étoiles B est égal à la taille de malloc int.

225
00:10:36,750 --> 00:10:38,560
Celui-ci pourrait être un peu délicat.

226
00:10:38,560 --> 00:10:44,110
Prenez une seconde et de réfléchir à ce que vous
serait attendre à arriver sur ce schéma.

227
00:10:44,110 --> 00:10:50,210
int étoiles B est égal à la taille de malloc int.

228
00:10:50,210 --> 00:10:51,940
>> Eh bien cela ne se crée pas une seule boîte.

229
00:10:51,940 --> 00:10:53,800
Ceci crée en fait deux boîtes.

230
00:10:53,800 --> 00:10:58,670
Et elle lie, il établit également
un point dans une relation.

231
00:10:58,670 --> 00:11:02,240
Nous avons alloué un bloc
de la mémoire sur le tas.

232
00:11:02,240 --> 00:11:05,940
Notez que la boîte en haut à droite
il n'a pas de nom.

233
00:11:05,940 --> 00:11:06,760
>> Nous mallocd elle.

234
00:11:06,760 --> 00:11:08,050
Il existe sur le tas.

235
00:11:08,050 --> 00:11:10,090
Mais b a un nom.

236
00:11:10,090 --> 00:11:11,950
Il est une variable pointeur appelé b.

237
00:11:11,950 --> 00:11:13,910
Qui vit sur la pile.

238
00:11:13,910 --> 00:11:18,250
>> Donc, il est un morceau de la mémoire
que les points les unes aux autres.

239
00:11:18,250 --> 00:11:21,840
b contient l'adresse
de ce bloc de mémoire.

240
00:11:21,840 --> 00:11:23,757
Il n'a pas un nom autrement.

241
00:11:23,757 --> 00:11:24,590
Mais il souligne à elle.

242
00:11:24,590 --> 00:11:29,760
Donc, quand nous disons int étoiles B est égal à
taille de malloc de int, ce droit là,

243
00:11:29,760 --> 00:11:33,490
cette flèche qui a surgi sur la
côté droit il, que toute chose,

244
00:11:33,490 --> 00:11:36,740
Je vais le faire apparaître
encore une fois, est ce qui se passe.

245
00:11:36,740 --> 00:11:39,341
Tout cela se produit dans
que seule ligne de code.

246
00:11:39,341 --> 00:11:41,340
Maintenant, nous aurons un peu plus
simple à nouveau.

247
00:11:41,340 --> 00:11:43,330
une égale esperluette m.

248
00:11:43,330 --> 00:11:46,280
Vous rappelez-vous ce qu'est un
égale esperluette m est?

249
00:11:46,280 --> 00:11:48,920
Eh bien voilà un obtient l'adresse de m.

250
00:11:48,920 --> 00:11:54,150
Ou mettre plus schématiquement,
quelques points à m.

251
00:11:54,150 --> 00:11:56,360
>> A est égal à b.

252
00:11:56,360 --> 00:11:57,560
OK alors voici une autre.

253
00:11:57,560 --> 00:11:59,230
A est égal à b.

254
00:11:59,230 --> 00:12:02,260
Ce qu'il va se passer
le schéma, cette fois?

255
00:12:02,260 --> 00:12:04,330
>> Eh bien rappeler que la
œuvres de l'opérateur d'affectation

256
00:12:04,330 --> 00:12:08,960
en affectant la valeur de la
droit de la valeur du côté gauche.

257
00:12:08,960 --> 00:12:14,820
Ainsi, au lieu d'un pointage à m, un maintenant
des points au même endroit que les points b.

258
00:12:14,820 --> 00:12:18,900
un ne pointe pas à B,
Points Points où b.

259
00:12:18,900 --> 00:12:25,280
>> Si un pointu pour B qui serait
ont été un égal esperluette b.

260
00:12:25,280 --> 00:12:28,150
Mais au lieu d'un égal b juste
signifie que et b sont maintenant

261
00:12:28,150 --> 00:12:31,770
pointant à la même adresse, parce
l'intérieur de b est juste une adresse.

262
00:12:31,770 --> 00:12:35,004
Et maintenant à l'intérieur d'un est la même adresse.

263
00:12:35,004 --> 00:12:37,170
m est égal à 10, probablement le
chose la plus simple

264
00:12:37,170 --> 00:12:38,690
nous avons fait un petit peu.

265
00:12:38,690 --> 00:12:40,460
Mettez le 10 dans la zone.

266
00:12:40,460 --> 00:12:45,640
Star B est égal à m + 2, de rappeler
signifie que notre pointeurs vidéo quelle étoile b.

267
00:12:45,640 --> 00:12:50,230
Nous allons déréférencer b et de mettre
une certaine valeur dans cet emplacement de mémoire.

268
00:12:50,230 --> 00:12:51,860
Dans ce cas 12.

269
00:12:51,860 --> 00:12:55,300
>> Alors, quand nous déréférencer un point de
Rappelons que nous venons de descendre la flèche.

270
00:12:55,300 --> 00:12:58,205
Ou autrement dit, nous
aller à cette adresse mémoire

271
00:12:58,205 --> 00:12:59,580
et nous manipulons en quelque sorte.

272
00:12:59,580 --> 00:13:00,830
Nous avons mis une certaine valeur dans il.

273
00:13:00,830 --> 00:13:03,960
Dans ce cas étoiles b
est égal à 2 m plus est juste

274
00:13:03,960 --> 00:13:08,230
aller à la variable pointée par b,
aller à la mémoire pointée par b,

275
00:13:08,230 --> 00:13:11,750
et de mettre m plus 2 là, 12.

276
00:13:11,750 --> 00:13:14,970
>> Maintenant je libre b.

277
00:13:14,970 --> 00:13:16,490
Qu'advient-il lorsque je libère b?

278
00:13:16,490 --> 00:13:18,800
Se souvenir de ce que je disais des moyens gratuits.

279
00:13:18,800 --> 00:13:21,920
Que dis-je quand je gratuit B?

280
00:13:21,920 --> 00:13:23,410
>> Je suis fait de travailler avec elle, non?

281
00:13:23,410 --> 00:13:25,702
Je donne l'essentiel de la mémoire.

282
00:13:25,702 --> 00:13:26,910
Je lui donne en retour au système.

283
00:13:26,910 --> 00:13:33,010
Je ne pas besoin de ça est plus
ce que je leur dis, OK?

284
00:13:33,010 --> 00:13:37,390
>> Maintenant, si je dis une étoile
est égal à 11, vous pouvez probablement

285
00:13:37,390 --> 00:13:40,460
dire déjà que quelque chose de mauvais
qui va se passer ici, non?

286
00:13:40,460 --> 00:13:44,160
Et en effet, si je voulais que je doute
subirait une erreur de segmentation.

287
00:13:44,160 --> 00:13:47,140
Parce que maintenant, bien que
précédemment que partie de mémoire

288
00:13:47,140 --> 00:13:50,220
était quelque chose que je devais
l'accès à, à ce stade

289
00:13:50,220 --> 00:13:54,590
maintenant je accéder à la mémoire que
est pas légal pour moi d'accéder.

290
00:13:54,590 --> 00:13:57,330
>> Et comme nous allons probablement
rappeler, quand on accéder à la mémoire

291
00:13:57,330 --> 00:14:00,000
que nous ne sommes pas censés toucher,
qui est la cause la plus fréquente

292
00:14:00,000 --> 00:14:01,860
d'une segmentation
faute. Et si mon programme

293
00:14:01,860 --> 00:14:05,170
échouerait si je essayé de le faire.

294
00:14:05,170 --> 00:14:09,910
Encore une fois, il est une bonne idée pour obtenir une bonne
pratiques et de bonnes habitudes enracinées

295
00:14:09,910 --> 00:14:12,920
lorsque vous travaillez avec malloc et free,
de sorte que vous ne souffrez pas de segmentation

296
00:14:12,920 --> 00:14:15,310
défauts, et que vous utilisez
votre allouée dynamiquement

297
00:14:15,310 --> 00:14:17,370
la mémoire de façon responsable.

298
00:14:17,370 --> 00:14:20,300
>> Je suis Doug Lloyd cela est CS50.

299
00:14:20,300 --> 00:14:21,947