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

2
00:00:00,499 --> 00:00:01,395
[Музички]

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

4
00:00:05,590 --> 00:00:07,940
>> Даг LLOYD: Добро па предлог
пред точно тука.

5
00:00:07,940 --> 00:00:11,660
Ако не сте го гледав видеото на
совети можеби ќе сакате да го стори тоа во прв план.

6
00:00:11,660 --> 00:00:15,860
Бидејќи ова видео е уште еден
начин на работа со покажувачи.

7
00:00:15,860 --> 00:00:17,574
>> Па затоа се случува да се зборува
за некои поими

8
00:00:17,574 --> 00:00:19,490
кои ги покриваат во
покажувачи на видео, и ние сме

9
00:00:19,490 --> 00:00:21,948
ќе притајуваат нив сега,
под претпоставка дека тие се веќе

10
00:00:21,948 --> 00:00:23,090
вид на разбрани.

11
00:00:23,090 --> 00:00:25,440
Па тоа е само фер вашиот предупредување
дека ако го гледате ова видео

12
00:00:25,440 --> 00:00:27,814
а вие не сте виделе
покажувачи видео, тоа би можело да вид на

13
00:00:27,814 --> 00:00:29,610
летаат над главата малку.

14
00:00:29,610 --> 00:00:32,080
И затоа таа може да биде подобро
да се види тоа во тој редослед.

15
00:00:32,080 --> 00:00:34,710
>> Така што веќе видовме еден
начин на работа со стрелки,

16
00:00:34,710 --> 00:00:37,810
кој ние се изјасни за
променлива, а потоа ние

17
00:00:37,810 --> 00:00:42,160
прогласи уште една променлива, покажувач
променлива, што укажува на тоа.

18
00:00:42,160 --> 00:00:44,870
Па ние направивме
променлива со име, ние сме

19
00:00:44,870 --> 00:00:48,480
создаде втор променлива со име,
и укажуваме дека втората променлива

20
00:00:48,480 --> 00:00:50,220
во тоа во прв план.

21
00:00:50,220 --> 00:00:52,370
Овој вид има
проблем иако, бидејќи тоа

22
00:00:52,370 --> 00:00:54,650
бара од нас да се знае точно
колку меморија сме

23
00:00:54,650 --> 00:00:57,600
ќе треба во моментот
нашата програма е составена.

24
00:00:57,600 --> 00:00:58,220
>> Зошто е тоа?

25
00:00:58,220 --> 00:01:03,338
Бидејќи ние треба да биде во можност да го именува или
идентификуваат сите можни променливи

26
00:01:03,338 --> 00:01:04,129
ние можеби средба.

27
00:01:04,129 --> 00:01:07,910
Ние би можеле да имаат низа што може да биде
може да се одржи многу информации,

28
00:01:07,910 --> 00:01:10,110
но тоа се уште не е
точно е доволно прецизна.

29
00:01:10,110 --> 00:01:12,640
Што ако ние не знаеме,
што ако ние немаме идеја

30
00:01:12,640 --> 00:01:14,370
колку ние ќе треба во компајлирате време?

31
00:01:14,370 --> 00:01:17,020
Или што ако нашата програма ќе
траат навистина долго време,

32
00:01:17,020 --> 00:01:19,810
прифаќање на различни корисник
на податоци, и не можеме да

33
00:01:19,810 --> 00:01:23,170
процени дали сме
случува да треба 1.000 единици?

34
00:01:23,170 --> 00:01:26,060
>> Тоа не е како што можеме
велат во командната линија

35
00:01:26,060 --> 00:01:28,040
внесете колку елементи
Дали мислите дека ќе ти треба.

36
00:01:28,040 --> 00:01:31,100
Па што ако е тоа претпоставка е во ред?

37
00:01:31,100 --> 00:01:34,300
Динамична алокација на меморија
вид ни овозможува на начин

38
00:01:34,300 --> 00:01:36,867
да се добие околу овој посебен проблем.

39
00:01:36,867 --> 00:01:38,700
И начинот на кој тоа го прави
е со користење на совети.

40
00:01:38,700 --> 00:01:42,140
>> Можеме да го користите совети како да се
се добие пристап до динамички

41
00:01:42,140 --> 00:01:45,710
распределени меморија, меморија, која е
издвојуваната вашата програма работи.

42
00:01:45,710 --> 00:01:48,290
Тоа не е наменет на компајлирање.

43
00:01:48,290 --> 00:01:51,570
Кога ќе се динамички алоцира
меморија доаѓа од еден базен

44
00:01:51,570 --> 00:01:53,795
меморија познат како грамада.

45
00:01:53,795 --> 00:01:56,420
Претходно сите меморија имаме
работи со во текот

46
00:01:56,420 --> 00:01:59,920
е што доаѓаат од еден базен
меморија познат како оџак.

47
00:01:59,920 --> 00:02:02,470
А добар начин да се генерално
задржи во mind-- и ова правило

48
00:02:02,470 --> 00:02:04,720
не мора секогаш да се одржи точно,
но доста речиси

49
00:02:04,720 --> 00:02:09,940
секогаш има true-- е дека секоја
време да ви даде името на променливата на тоа

50
00:02:09,940 --> 00:02:12,090
најверојатно живее на магацинот.

51
00:02:12,090 --> 00:02:14,650
И во секое време да не стори
дадат променлива име,

52
00:02:14,650 --> 00:02:19,160
што можете да направите со динамичка меморија
распределба, што живее на грамада.

53
00:02:19,160 --> 00:02:22,190
>> Сега јас сум вид на презентација на тоа како
ако има овие два базени на меморија.

54
00:02:22,190 --> 00:02:24,740
Но може да се види ова
дијаграм, кој е генерално

55
00:02:24,740 --> 00:02:27,290
претстава на
меморија што изгледа,

56
00:02:27,290 --> 00:02:30,373
и ние нема да се грижиме за сите
на работи на врвот и на дното.

57
00:02:30,373 --> 00:02:33,580
Она што ние се грижиме само за овој дел во
средината тука, грамада и магацинот.

58
00:02:33,580 --> 00:02:35,570
Како што можете да видите со
во потрага на овој дијаграм,

59
00:02:35,570 --> 00:02:38,390
тие, всушност, не се две
посебни базени на меморија.

60
00:02:38,390 --> 00:02:42,757
Тоа е еден заеднички базен на меморија
каде што ќе почнете со, во овој визуелен

61
00:02:42,757 --> 00:02:44,590
ќе почнете на дното
и да почне полнењето

62
00:02:44,590 --> 00:02:48,040
од дното со стек, а вие
со почеток во врвот и да почне полнењето

63
00:02:48,040 --> 00:02:50,072
од врвот надолу со грамада.

64
00:02:50,072 --> 00:02:51,780
Но, тоа е, всушност,
истиот базен, тоа е само

65
00:02:51,780 --> 00:02:56,050
различни места, различни локации
во меморијата, кои се распределени.

66
00:02:56,050 --> 00:02:59,060
И можете да ја стартувате од
меморија со или имаат

67
00:02:59,060 --> 00:03:01,240
грамада сите одат на патот
на дното, или имаат

68
00:03:01,240 --> 00:03:05,440
магацинот одат сите на патот до врвот,
или да се има на грамада и магацинот

69
00:03:05,440 --> 00:03:06,740
се сретнат еден против друг.

70
00:03:06,740 --> 00:03:09,500
Сите тие може да се услови
кои предизвикуваат вашата програма

71
00:03:09,500 --> 00:03:11,030
да снема меморија.

72
00:03:11,030 --> 00:03:11,952
Па задржи дека во умот.

73
00:03:11,952 --> 00:03:13,660
Кога се зборува за
грамада и магацинот

74
00:03:13,660 --> 00:03:17,880
ние навистина зборуваме за
истите општи парче меморија, само

75
00:03:17,880 --> 00:03:21,930
различни делови од таа меморија.

76
00:03:21,930 --> 00:03:24,910
>> Така како ние да се динамички
распределени меморија на прво место?

77
00:03:24,910 --> 00:03:27,740
Како го прави нашата програма се
меморија како тој работи?

78
00:03:27,740 --> 00:03:32,660
И Ц обезбедува функција наречена
Примерок, меморија разпределител, која

79
00:03:32,660 --> 00:03:36,810
ќе се направи повик да, и ќе помине во
колку бајти од меморија што го сакате.

80
00:03:36,810 --> 00:03:39,940
Значи, ако вашиот програмата се извршува
а вие сакате цел број траење,

81
00:03:39,940 --> 00:03:46,040
можеби mallock четири бајти на
меморија, Примерок загради четири.

82
00:03:46,040 --> 00:03:48,540
>> mallock ќе поминат низ
гледајќи низ грамада,

83
00:03:48,540 --> 00:03:50,750
бидејќи ние сме динамички
доделување меморија,

84
00:03:50,750 --> 00:03:53,500
и тоа ќе се врати за вас
покажувач на тоа сеќавање.

85
00:03:53,500 --> 00:03:56,180
Тоа не ви даде дека memory--
тоа не го даде името,

86
00:03:56,180 --> 00:03:57,950
тоа ви дава покажувач кон него.

87
00:03:57,950 --> 00:04:00,780
И така тоа е зошто еднаш реков
дека тоа е важно да можеби

88
00:04:00,780 --> 00:04:03,770
го гледавме видео на покажувачи
пред да се дојде премногу далеку во тоа.

89
00:04:03,770 --> 00:04:05,940
Примерок така ќе
ти го врати покажувач.

90
00:04:05,940 --> 00:04:08,950
>> Ако mallock не може да ви даде секое
меморија, бидејќи сте непресушни,

91
00:04:08,950 --> 00:04:10,645
тоа ќе ти го врати нулти покажувач.

92
00:04:10,645 --> 00:04:15,282
Се сеќаваш ли што се случува ако ние
се обиде и dereference нулти покажувач?

93
00:04:15,282 --> 00:04:17,019
Страдаме грешка секунда, нели?

94
00:04:17,019 --> 00:04:18,060
Тоа веројатно не е добро.

95
00:04:18,060 --> 00:04:21,579
>> Па секој пат кога ќе се направи повик
Примерок на вас и секогаш, секогаш

96
00:04:21,579 --> 00:04:25,270
треба да се провери дали или не на
покажувачот го даде вас назад е нула.

97
00:04:25,270 --> 00:04:28,800
Ако е така, треба да се стави крај на својата програма
бидејќи ако се обидете и dereference

98
00:04:28,800 --> 00:04:31,360
нултата покажувачот си оди
да страда дефект на сегментација

99
00:04:31,360 --> 00:04:34,380
и вашата програма е
ќе се сруши во секој случај.

100
00:04:34,380 --> 00:04:37,190
Па, како го правиме статички
се добие цел број?

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

102
00:04:37,730 --> 00:04:40,010
Ние, најверојатно, го направиле тоа
еден куп пати, нели?

103
00:04:40,010 --> 00:04:43,480
Ова создава променлива наречена
X, која живее на магацинот.

104
00:04:43,480 --> 00:04:46,190
Како ние да се динамички се добие цел број?

105
00:04:46,190 --> 00:04:50,010
Int ѕвезда px еднаква Примерок 4.

106
00:04:50,010 --> 00:04:53,050
>> Или посоодветно
ние би рекол int ѕвезда пиксели

107
00:04:53,050 --> 00:04:57,680
Примерок еднаква на големината на цел број,
само да се фрли некои помалку

108
00:04:57,680 --> 00:04:59,740
магија броеви околу нашата програма.

109
00:04:59,740 --> 00:05:04,140
Ова се случува да се добие за нас
четири бајти меморија од грамада,

110
00:05:04,140 --> 00:05:06,720
и покажувачот ќе го добиеме
назад кон тоа се нарекува пиксели.

111
00:05:06,720 --> 00:05:08,430
А потоа само како ние сме
направено претходно ние

112
00:05:08,430 --> 00:05:13,966
може да dereference пиксели
пристап до таа меморија.

113
00:05:13,966 --> 00:05:15,590
Како да се добие цел број од корисникот?

114
00:05:15,590 --> 00:05:17,970
Можеме да кажеме int x е еднаква добие Инт.

115
00:05:17,970 --> 00:05:19,930
Тоа е прилично јасна.

116
00:05:19,930 --> 00:05:24,030
Што ако сакаме да се создаде низа
на X плови кои живеат на оџакот?

117
00:05:24,030 --> 00:05:28,210
плови stack_array-- тоа е името
од нашите array-- квадратни загради х.

118
00:05:28,210 --> 00:05:32,419
Што ќе се создаде за нас низа
на X плови кои живеат на магацинот.

119
00:05:32,419 --> 00:05:34,960
Ние можеме да се создаде низа на плови
која живее на грамада, исто така.

120
00:05:34,960 --> 00:05:37,330
Синтаксата може да изгледа
малку повеќе незгодни,

121
00:05:37,330 --> 00:05:41,740
но можеме да кажеме плови
ѕвезда heap_array еднаква

122
00:05:41,740 --> 00:05:44,360
Примерок x пати поголема од големината на плови.

123
00:05:44,360 --> 00:05:48,160
Ми треба доволно простор да се одржи
x подвижна запирка вредности.

124
00:05:48,160 --> 00:05:51,560
Така велат дека ми треба 100
плови, или 1.000 плови.

125
00:05:51,560 --> 00:05:54,810
Така што во тој случај би било
400 бајти за 100 лебди,

126
00:05:54,810 --> 00:05:59,080
или 4.000 бајти за 1.000 лебди,
бидејќи секој плови зазема

127
00:05:59,080 --> 00:06:01,230
четири бајти на просторот.

128
00:06:01,230 --> 00:06:05,110
>> Откако ќе го направите тоа, јас да го користите
квадратни заградата синтаксата на heap_array.

129
00:06:05,110 --> 00:06:08,970
Исто како што јас би на stack_array, јас
може да пристапите до своите елементи поединечно

130
00:06:08,970 --> 00:06:11,590
користење heap_array нула, heap_array еден.

131
00:06:11,590 --> 00:06:15,800
Но, да се потсетиме на причината што можеме да го направи тоа
е затоа што името на низа во C

132
00:06:15,800 --> 00:06:19,990
е навистина покажувач
Првиот елемент таа низа е.

133
00:06:19,990 --> 00:06:23,480
Значи фактот дека ние сме прогласување
Низа на плови на магацинот тука

134
00:06:23,480 --> 00:06:24,810
е, всушност, малку погрешно.

135
00:06:24,810 --> 00:06:27,600
Ние навистина сме во
Втората линија на кодот таму

136
00:06:27,600 --> 00:06:32,360
исто така, создавање покажувач на парче
паметењето што потоа направи некои работи со.

137
00:06:32,360 --> 00:06:35,620
>> Тука е голем проблем со
динамички доделени мемориски иако,

138
00:06:35,620 --> 00:06:38,360
а тоа е зошто тоа е навистина
важно да се развие некои добри навики

139
00:06:38,360 --> 00:06:39,800
кога си работат со него.

140
00:06:39,800 --> 00:06:43,060
За разлика од статички прогласи
меморија, вашата меморија

141
00:06:43,060 --> 00:06:46,790
не се враќа автоматски на
систем, кога вашата функција е направено.

142
00:06:46,790 --> 00:06:49,280
Значи, ако имаме главните, и
Главната повикува функција

143
00:06:49,280 --> 00:06:53,860
ѓ, кога ѓ бои што и да се прави
и се враќа за контрола на програмата

144
00:06:53,860 --> 00:06:58,810
Назад кон главната, сите на меморија
дека f користат е даден назад.

145
00:06:58,810 --> 00:07:01,250
Тоа може да се користи повторно
од страна на некои други програма,

146
00:07:01,250 --> 00:07:04,250
или некоја друга функција што
добива наречен подоцна во главниот.

147
00:07:04,250 --> 00:07:06,970
Тоа може да ја користат таа истата меморија одново.

148
00:07:06,970 --> 00:07:09,620
>> Ако динамички
алоцирам меморија иако

149
00:07:09,620 --> 00:07:14,380
ќе мора експлицитно да кажам
систем што ќе се направи со неа.

150
00:07:14,380 --> 00:07:18,370
Тоа ќе го задржи тоа за вас, кои можат да
да доведе до проблеми од вас истекува

151
00:07:18,370 --> 00:07:19,290
меморија.

152
00:07:19,290 --> 00:07:22,179
И всушност ние понекогаш се однесуваат
на тоа како меморија излегуваат во јавноста.

153
00:07:22,179 --> 00:07:24,970
А понекогаш и овие меморија протекување
всушност, може да биде навистина катастрофални

154
00:07:24,970 --> 00:07:27,020
за перформансите на системот.

155
00:07:27,020 --> 00:07:31,120
>> Ако сте често корисник на интернет
може да се користат одредени веб прелистувачи,

156
00:07:31,120 --> 00:07:35,630
и јас не ќе го именувам имиња тука, но
постојат некои веб-пребарувачи таму

157
00:07:35,630 --> 00:07:39,150
кои се познати по тоа всушност да има
меморија протекување, кои не се фиксни.

158
00:07:39,150 --> 00:07:44,570
И ако го оставите вашиот интернет пребарувач со отворен
за многу долго време, денови

159
00:07:44,570 --> 00:07:48,060
и денови или недели, понекогаш
Може да се забележи дека вашиот систем

160
00:07:48,060 --> 00:07:49,790
е работи многу, многу бавно.

161
00:07:49,790 --> 00:07:54,640
А причина за тоа е што
прелистувачот одвои меморија,

162
00:07:54,640 --> 00:07:57,320
но тогаш не кажа на системот
дека тоа е направено со неа.

163
00:07:57,320 --> 00:08:01,000
И така што остава помалку меморија
достапни за сите твои други програми

164
00:08:01,000 --> 00:08:04,480
мора да ги споделат, затоа што ти си
leaking-- дека веб прелистувач

165
00:08:04,480 --> 00:08:06,755
Програмата е протекување меморија.

166
00:08:06,755 --> 00:08:08,880
Како ние да им даде на меморија назад
кога ќе завршиш со тоа?

167
00:08:08,880 --> 00:08:10,838
И за среќа, тоа е
многу лесен начин да го направи тоа.

168
00:08:10,838 --> 00:08:11,710
Ние само го ослободи.

169
00:08:11,710 --> 00:08:15,020
Има функција наречена слободен,
го прифаќа покажувач кон меморијата,

170
00:08:15,020 --> 00:08:16,010
и ние сме добро да отидевме.

171
00:08:16,010 --> 00:08:18,310
>> Па да речеме дека сме во
средината на нашата програма,

172
00:08:18,310 --> 00:08:21,970
сакаме да Примерок 50 карактери.

173
00:08:21,970 --> 00:08:25,710
Ние сакаме да се Примерок низа кој може
способен да држи 50 карактери.

174
00:08:25,710 --> 00:08:29,109
И кога ќе го добиеме покажувач назад до
дека, име кое покажувачот е зборот.

175
00:08:29,109 --> 00:08:30,900
Ние го направи она што ние сме
ќе правите со збор,

176
00:08:30,900 --> 00:08:33,440
и тогаш кога сме
направено ние само го ослободи.

177
00:08:33,440 --> 00:08:37,460
И сега ние се вратија тие 50
бајти меморија назад до систем.

178
00:08:37,460 --> 00:08:40,147
Некои други функција да ги користите.

179
00:08:40,147 --> 00:08:43,480
Ние не треба да се грижите за страдање
меморија излегуваат во јавноста, бидејќи ние ги ослободија збор.

180
00:08:43,480 --> 00:08:46,639
Ние сме со оглед на меморија назад,
па ние завршиш работа со него.

181
00:08:46,639 --> 00:08:48,430
Значи постојат три
златни правила кои треба

182
00:08:48,430 --> 00:08:51,700
се чуваат во умот секогаш кога сте
динамично доделување меморија

183
00:08:51,700 --> 00:08:52,990
со Примерок.

184
00:08:52,990 --> 00:08:56,480
Секој блок од меморија што
Примерок вас мора да се ослободи

185
00:08:56,480 --> 00:08:58,430
пред вашата програма ќе заврши со трчање.

186
00:08:58,430 --> 00:09:02,029
Сега повторно во апаратот или во
ИРО овој вид на се случува за вас во секој случај

187
00:09:02,029 --> 00:09:04,820
you-- кога тоа ќе се случи во секој случај
Кога вашата програма е прекинат,

188
00:09:04,820 --> 00:09:06,880
сите меморија ќе бидат ослободени.

189
00:09:06,880 --> 00:09:10,750
Но, тоа е генерално добра кодирање
пракса за да се секогаш, кога ќе завршиш,

190
00:09:10,750 --> 00:09:13,810
ослободи она што сте го mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Тоа, рече, само работите кои
сте mallocd треба да бидат ослободени.

192
00:09:16,690 --> 00:09:19,880
Ако статички прогласи
цел број, int x точка-запирка,

193
00:09:19,880 --> 00:09:23,500
кој живее на магацинот, вие
тогаш не сакате да се ослободи од x.

194
00:09:23,500 --> 00:09:25,970
Па само работите кои сте
mallocd треба да бидат ослободени.

195
00:09:25,970 --> 00:09:28,960
>> И на крај, не слободни нешто двапати.

196
00:09:28,960 --> 00:09:31,170
Што може да доведе до
друга чудна ситуација.

197
00:09:31,170 --> 00:09:33,530
Значи се што сте
mallocd мора да бидат ослободени.

198
00:09:33,530 --> 00:09:36,000
Единствените нешта кои сте
Примерок треба да бидат ослободени.

199
00:09:36,000 --> 00:09:38,730
И не се слободни нешто двапати.

200
00:09:38,730 --> 00:09:43,660
>> Па ајде да одиме преку еден пример тука
на она што некои динамички доделени

201
00:09:43,660 --> 00:09:46,122
меморија може да изгледа како мешани
во со некои статички меморија.

202
00:09:46,122 --> 00:09:47,080
Што може да се случи во оваа ситуација?

203
00:09:47,080 --> 00:09:48,913
Види дали може да се следат
заедно и се погоди она што е

204
00:09:48,913 --> 00:09:51,720
ќе се случи како што ние одиме
преку сите овие линии на код.

205
00:09:51,720 --> 00:09:53,980
>> Па велиме int м.

206
00:09:53,980 --> 00:09:54,840
Што се случува овде?

207
00:09:54,840 --> 00:09:56,339
Па ова е прилично јасна.

208
00:09:56,339 --> 00:09:59,650
Јас создаде целобројна променлива наречена м.

209
00:09:59,650 --> 00:10:01,400
Јас боја зелена,
затоа што тоа е во боја

210
00:10:01,400 --> 00:10:03,730
дека јас го користам кога јас зборувам
за целобројни променливи.

211
00:10:03,730 --> 00:10:05,160
Тоа е една кутија.

212
00:10:05,160 --> 00:10:08,400
Таа се вика метри, и може да се
Продавница за цели броеви во него.

213
00:10:08,400 --> 00:10:12,400
>> Што ако јас тогаш велат int ѕвезда?

214
00:10:12,400 --> 00:10:13,530
Па тоа е прилично слични.

215
00:10:13,530 --> 00:10:15,780
Јас сум создавање на кутија наречена.

216
00:10:15,780 --> 00:10:19,100
Тоа е состојба на стопанството int
ѕвезди, покажувачи на цели броеви.

217
00:10:19,100 --> 00:10:21,570
Затоа, јас сум тоа боење зелено-носталгичната, како и.

218
00:10:21,570 --> 00:10:24,140
>> Знам дека има нешто
да се направи со цел број,

219
00:10:24,140 --> 00:10:25,852
но самиот не е цел број.

220
00:10:25,852 --> 00:10:27,310
Но, тоа е прилично многу исти идеја.

221
00:10:27,310 --> 00:10:28,101
Јас направивме кутија.

222
00:10:28,101 --> 00:10:30,070
И двете од овие право
сега живеат на магацинот.

223
00:10:30,070 --> 00:10:32,520
Сум ги даде двете имиња.

224
00:10:32,520 --> 00:10:36,750
>> int b ѕвезда еднаква Примерок големината на Инт.

225
00:10:36,750 --> 00:10:38,560
Ова би можело да биде малку незгодно.

226
00:10:38,560 --> 00:10:44,110
Се земе втора и размислува за она што
може да се очекува да се случи на овој дијаграм.

227
00:10:44,110 --> 00:10:50,210
int b ѕвезда еднаква Примерок големината на Инт.

228
00:10:50,210 --> 00:10:51,940
>> Па тоа не само да се создаде една кутија.

229
00:10:51,940 --> 00:10:53,800
Ова, всушност, создава две кутии.

230
00:10:53,800 --> 00:10:58,670
И тоа, исто така и за воспоставување
точка во врска.

231
00:10:58,670 --> 00:11:02,240
Ние сме распределени еден блок
од меморијата на грамада.

232
00:11:02,240 --> 00:11:05,940
Забележи дека во горниот десен кутија
таму нема да има име.

233
00:11:05,940 --> 00:11:06,760
>> Ние тоа го mallocd.

234
00:11:06,760 --> 00:11:08,050
Таа постои на грамада.

235
00:11:08,050 --> 00:11:10,090
Но б има име.

236
00:11:10,090 --> 00:11:11,950
Тоа е променлива покажувач наречен б.

237
00:11:11,950 --> 00:11:13,910
Која живее на магацинот.

238
00:11:13,910 --> 00:11:18,250
>> Така, тоа е едно парче од меморијата
што укажува на уште еден.

239
00:11:18,250 --> 00:11:21,840
б содржи адресата
тој блок од меморија.

240
00:11:21,840 --> 00:11:23,757
Тоа не мора да биде име на друг начин.

241
00:11:23,757 --> 00:11:24,590
Но, тоа укажува на тоа.

242
00:11:24,590 --> 00:11:29,760
Така, кога велиме ѕвезда int b е еднаква
големина Примерок на цел број, тоа право таму,

243
00:11:29,760 --> 00:11:33,490
дека стрелката што се појави на
десната страна има, дека целата работа,

244
00:11:33,490 --> 00:11:36,740
Ќе морам да изгледа
повторно, е она што се случува.

245
00:11:36,740 --> 00:11:39,341
Сето ова се случува во
дека една линија код.

246
00:11:39,341 --> 00:11:41,340
Сега ние ќе добиете малку повеќе
јасна повторно.

247
00:11:41,340 --> 00:11:43,330
a е еднакво на симболот м.

248
00:11:43,330 --> 00:11:46,280
Се сеќаваш ли што е
еднаква на симболот m е?

249
00:11:46,280 --> 00:11:48,920
Па тоа е добива адреса на m.

250
00:11:48,920 --> 00:11:54,150
Или да се стави повеќе diagrammatically,
на поени, на м.

251
00:11:54,150 --> 00:11:56,360
>> a е еднакво на б.

252
00:11:56,360 --> 00:11:57,560
OK, па тука е уште еден.

253
00:11:57,560 --> 00:11:59,230
A е еднаков со б.

254
00:11:59,230 --> 00:12:02,260
Што ќе се случи
со дијаграмот ова време?

255
00:12:02,260 --> 00:12:04,330
>> Добро да се потсетиме дека
оператор задача дела

256
00:12:04,330 --> 00:12:08,960
со доделување на вредност на
право на вредноста на левата страна.

257
00:12:08,960 --> 00:12:14,820
Така, наместо на испружен да метри, сега
укажува на истото место што б поени.

258
00:12:14,820 --> 00:12:18,900
а не точка на b, A
укажува каде б поени.

259
00:12:18,900 --> 00:12:25,280
>> Ако зашилен да б, кои би
да е еднаква на симболот б.

260
00:12:25,280 --> 00:12:28,150
Туку, напротив, е еднакво на само б
значи дека и b се сега

261
00:12:28,150 --> 00:12:31,770
што укажува на истата адреса, бидејќи
внатрешноста на Б е само на адреса.

262
00:12:31,770 --> 00:12:35,004
А сега во внатрешноста на еден е на истата адреса.

263
00:12:35,004 --> 00:12:37,170
m е еднакво на 10, веројатно
најдиректниот работа

264
00:12:37,170 --> 00:12:38,690
ние го направивме во малку.

265
00:12:38,690 --> 00:12:40,460
Стави на 10 во кутија.

266
00:12:40,460 --> 00:12:45,640
Ѕвезда б еднаква m, плус 2, се сети од
нашите совети видео што ѕвездата б значи.

267
00:12:45,640 --> 00:12:50,230
Ние ќе треба да dereference б и го стави
некоја вредност во кои мемориска локација.

268
00:12:50,230 --> 00:12:51,860
Во овој случај 12.

269
00:12:51,860 --> 00:12:55,300
>> Значи, кога ќе dereference точка на
потсетиме ние само патуваат одредување на тастатурата.

270
00:12:55,300 --> 00:12:58,205
Или поинаку кажано, ние
одат на таа меморија адреса

271
00:12:58,205 --> 00:12:59,580
и ние ја манипулира некој начин.

272
00:12:59,580 --> 00:13:00,830
Ние се стави некоја вредност во таму.

273
00:13:00,830 --> 00:13:03,960
Во овој случај ѕвезда б
еднаква метри плус 2 е само

274
00:13:03,960 --> 00:13:08,230
одат во променлива посочени од б,
одат на меморија посочени од б,

275
00:13:08,230 --> 00:13:11,750
и го стави метри плус 2 во таму, 12.

276
00:13:11,750 --> 00:13:14,970
>> Јас сега се ослободи б.

277
00:13:14,970 --> 00:13:16,490
Што се случува кога ќе се ослободи б?

278
00:13:16,490 --> 00:13:18,800
Запомни што реков слободни средства.

279
00:13:18,800 --> 00:13:21,920
Што сум јас зборуваш кога ќе се ослободи б?

280
00:13:21,920 --> 00:13:23,410
>> Јас сум се направи да работи со него, нели?

281
00:13:23,410 --> 00:13:25,702
Јас во основа се откаже од меморијата.

282
00:13:25,702 --> 00:13:26,910
Јас го даде назад кон системот.

283
00:13:26,910 --> 00:13:33,010
Не ми треба ова повеќе е
она што јас ги кажувам, во ред?

284
00:13:33,010 --> 00:13:37,390
>> Сега ако кажам ѕвезда
еднаква на 11 вие веројатно може да

285
00:13:37,390 --> 00:13:40,460
веќе кажам дека нешто лошо
ќе се случува тука, нели?

286
00:13:40,460 --> 00:13:44,160
И, навистина, ако јас се обидував дека јас веројатно
ќе страдаат дефект на сегментација.

287
00:13:44,160 --> 00:13:47,140
Затоа што сега, иако
претходно дека парче меморија

288
00:13:47,140 --> 00:13:50,220
беше нешто што морав
пристап до, во овој момент

289
00:13:50,220 --> 00:13:54,590
сега сум пристап меморија, која
не е правен за мене да им пристапите.

290
00:13:54,590 --> 00:13:57,330
>> И како што веројатно ќе
потсетиме, ако имаме пристап меморија

291
00:13:57,330 --> 00:14:00,000
дека ние не би требало да се допре,
тоа е најчестата причина

292
00:14:00,000 --> 00:14:01,860
на сегментација
вина. И така мојата програма

293
00:14:01,860 --> 00:14:05,170
ќе се сруши ако јас се обидував да го направите тоа.

294
00:14:05,170 --> 00:14:09,910
Значи, повторно, тоа е добра идеја да се добие добар
практика и добри навики вкоренето

295
00:14:09,910 --> 00:14:12,920
кога се работи со Примерок и слободни,
така што да не страдаат сегментација

296
00:14:12,920 --> 00:14:15,310
грешки, и што ќе се користи
Вашиот динамички доделени

297
00:14:15,310 --> 00:14:17,370
меморија одговорно.

298
00:14:17,370 --> 00:14:20,300
>> Јас сум Даг Лојд ова е CS50.

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