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
изчислите дали сме
ще се нуждаят от 1000 единици?

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
Dynamic разпределение на паметта
нещо като ни позволява пътя

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
Е C осигурява функция, наречена
изчистване, памет разпределител, който

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
Това не ви дава, че 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
>> Ако Малок не може да ви даде всеки
памет, защото е свършило,

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
Int звезда пиксела равнява изчистване 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
плаваш stack_array-- това е името
от нашите array-- квадратни скоби х.

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
но можем да кажем плувка
звезден heap_array равнява

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
плувки, или 1000 поплавъци.

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

126
00:05:54,810 --> 00:05:59,080
или 4000 байта за 1000 поплавъци,
защото всеки поплавък заема

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, I
да получите достъп до неговите елементи поотделно

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
обратно към основната, цялата памет
че е използван, е върната.

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
Сега отново, в уреда или в
IDE този вид се случва така или иначе

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
Ако статично обявят
число, инт х точка и запетая,

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

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
>> Така че ние казваме инт m.

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
Създавам целочислена променлива, наречена m.

209
00:09:59,650 --> 00:10:01,400
I оцветите го направи зелен,
защото това е цветът

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
>> Ние го 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
Така че, когато казваме, инт звезда б равнява
Размер на изчистване на инт, че точно там,

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
а равнява амперсанд m.

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

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
OK така че ето още един.

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
Така че, вместо да посочващо m, а сега
точки на същото място, че В точки.

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
Но вместо това се равнява само на б
означава, че и сега са б

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
Star б равнява m плюс 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
В този случай те б
равнява m плюс 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
Нямам нужда от това повече е
това, което аз им казвам, OK?

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
>> Аз съм Дъг Lloyd това е CS50.

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