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
>> Даг Ллоид: ОК, сугестија
пре почетка овде.

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
Добар начин да се генерално
имајте у минд-- и овом правилу

48
00:02:02,470 --> 00:02:04,720
не увек важи,
али прилично скоро

49
00:02:04,720 --> 00:02:09,940
Увек држи труе-- је да свака
пут када дати име променљиве ит

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
можда Маллоцк четири бајтова
меморија, маллоц заградама четири.

82
00:03:46,040 --> 00:03:48,540
>> Маллоцк ће проћи кроз
гледајући кроз гомиле,

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
То не ти дати ту мемори--
не му дати име,

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
>> Ако Маллоцк не могу да вам дам
меморије јер сте понестане,

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

92
00:04:10,645 --> 00:04:15,282
Да ли се сећате шта се дешава ако
покушати да дереференце нулл поинтер?

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
Ако јесте, морате да завршите програм
јер ако покушаш и дереференце

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
>> инт.

102
00:04:37,730 --> 00:04:40,010
Вероватно смо урадили
гомила пута, зар не?

103
00:04:40,010 --> 00:04:43,480
Ово ствара променљиву названу
х која живи на стек.

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

105
00:04:46,190 --> 00:04:50,010
Инт звездице пк једнака маллоц 4.

106
00:04:50,010 --> 00:04:53,050
>> Или прикладније
ми кажемо Инт стар пк

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
могу дереференце пк до
приступити то сећање.

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

114
00:05:15,590 --> 00:05:17,970
Можемо рећи инт једнако се инт.

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

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

117
00:05:24,030 --> 00:05:28,210
флоат стацк_арраи-- то је име
наших арраи-- угластим заградама к.

118
00:05:28,210 --> 00:05:32,419
То ће створити за нас низ
од к пловци који живе на стек.

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
али можемо рећи флоат
звездице хеап_арраи једнако

122
00:05:41,740 --> 00:05:44,360
маллоц к пута већа од пловка.

123
00:05:44,360 --> 00:05:48,160
Морам довољно простора да држе
х флоатинг поинт вредности.

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
>> Након тога радим, могу користити
квадрат носач синтакса на хеап_арраи.

129
00:06:05,110 --> 00:06:08,970
Баш као и ја на стацк_арраи, ја
може индивидуално приступити њене елементе

130
00:06:08,970 --> 00:06:11,590
користећи хеап_арраи нула, хеап_арраи један.

131
00:06:11,590 --> 00:06:15,800
Али сећам се разлога можемо то да урадимо
је зато што је име низа у Ц

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
Повратак на главни, сву меморију
да је ф користи је враћен.

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
морати да деле, јер си
леакинг-- да веб бровсер

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
када би-- то ће свакако десити
када је престао ваш програм,

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
ослободити оно што сте маллоцд.

191
00:09:13,810 --> 00:09:16,690
>> То је рекао, само ствари које
Ви сте маллоцд треба ослободити.

192
00:09:16,690 --> 00:09:19,880
Ако статички прогласити
цео број, инт полу-дебело црево,

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

194
00:09:23,500 --> 00:09:25,970
Дакле, само ствари које сте
маллоцд треба ослободити.

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
Дакле, све што сте
маллоцд мора да буде ослобођен.

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
>> Зато ми кажемо инт м.

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
>> Шта ако сам тада рекао Инт Стар А?

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
То је у стању да држи инт
старс, показивачи на целе бројеве.

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
>> Инт звездице Б једнак маллоц величину инт.

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
Инт звездице Б једнак маллоц величину инт.

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
>> Маллоцд смо га.

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
Дакле, када кажемо Инт звездице Б једнак
маллоц величина инт, да тамо,

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
једнака амперсанд м.

248
00:11:43,330 --> 00:11:46,280
Да ли се сећате шта је
једнака Амперсанд м је?

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

250
00:11:48,920 --> 00:11:54,150
Или ставите више шематски,
а указује на м.

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

252
00:11:56,360 --> 00:11:57,560
ОК, ево још једног.

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

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
А не указују на Б, А
указује где Б поена.

259
00:12:18,900 --> 00:12:25,280
>> Ако указао на б да би
да је био једнако амперсанд б.

260
00:12:25,280 --> 00:12:28,150
Али уместо тога једнако Б само
значи да и б сада

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
м износи 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
Звезда Б једнак М плус 2, сећам из
наш показивачи Видео шта стар Б значи.

267
00:12:45,640 --> 00:12:50,230
Идемо у Дереференце б и ставити
нека вредност у тој меморијској локацији.

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

269
00:12:51,860 --> 00:12:55,300
>> Дакле, када смо дереференце тачка
сјећам се само путујемо низ стрелу.

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
>> Ја сам Доуг Ллоид ово је ЦС50.

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