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

2
00:00:00,499 --> 00:00:01,395
[MUZYKI]

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

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK, więc sugestia
przed rozpoczęciem tutaj.

5
00:00:07,940 --> 00:00:11,660
Jeśli nie oglądałem film na
wskaźnikami możesz to zrobić w pierwszej kolejności.

6
00:00:11,660 --> 00:00:15,860
Bo ten film jest inny
sposób pracy ze wskaźnikami.

7
00:00:15,860 --> 00:00:17,574
>> Więc to będzie mówić
o niektórych pojęć

8
00:00:17,574 --> 00:00:19,490
które obejmują w
wskaźnikami wideo, a my jesteśmy

9
00:00:19,490 --> 00:00:21,948
będzie połysk przez nich teraz,
przy założeniu, że są już

10
00:00:21,948 --> 00:00:23,090
rodzaj rozumieć.

11
00:00:23,090 --> 00:00:25,440
Więc to jest tylko twój uczciwe ostrzeżenie
że jeśli widzisz ten film

12
00:00:25,440 --> 00:00:27,814
i nie widziałem
wskaźniki film, to może coś w rodzaju

13
00:00:27,814 --> 00:00:29,610
latać nad głową trochę.

14
00:00:29,610 --> 00:00:32,080
I tak może być lepiej
aby obejrzeć go w tej kolejności.

15
00:00:32,080 --> 00:00:34,710
>> Więc już widzieliśmy jednego
sposób pracy ze wskaźnikami,

16
00:00:34,710 --> 00:00:37,810
co deklarujemy
zmienna, a następnie

17
00:00:37,810 --> 00:00:42,160
Oświadczam, innej zmiennej, wskaźnik
zmienny, który wskazuje na to.

18
00:00:42,160 --> 00:00:44,870
Więc stworzyliśmy
zmienna o nazwie, mamy

19
00:00:44,870 --> 00:00:48,480
utworzył drugą zmienną o nazwie
i wskazać, że druga zmienna

20
00:00:48,480 --> 00:00:50,220
na tym pierwszym.

21
00:00:50,220 --> 00:00:52,370
Ten rodzaj ma
Problem jednak, bo to

22
00:00:52,370 --> 00:00:54,650
wymaga od nas, aby dokładnie wiedzieć,
ile pamięci jesteśmy

23
00:00:54,650 --> 00:00:57,600
będzie potrzebował moment
nasz program jest skompilowany.

24
00:00:57,600 --> 00:00:58,220
>> Dlaczego?

25
00:00:58,220 --> 00:01:03,338
Bo musimy być w stanie wymienić lub
zidentyfikowania wszystkich możliwych zmiennych

26
00:01:03,338 --> 00:01:04,129
możemy spotkać.

27
00:01:04,129 --> 00:01:07,910
Możemy mieć tablicę, która może być
w stanie utrzymać wiele informacji,

28
00:01:07,910 --> 00:01:10,110
ale to nie jest jeszcze
dokładnie tyle precyzyjne.

29
00:01:10,110 --> 00:01:12,640
Co zrobić, jeśli nie wiemy,
co jeśli nie mamy pojęcia

30
00:01:12,640 --> 00:01:14,370
ile będziemy potrzebować w czasie kompilacji?

31
00:01:14,370 --> 00:01:17,020
Albo co jeśli nasz program
trwać naprawdę długo,

32
00:01:17,020 --> 00:01:19,810
przyjmując różne użytkownika
danych, a tak naprawdę nie możemy

33
00:01:19,810 --> 00:01:23,170
Szacujemy, czy jesteśmy
będzie potrzebował 1000 jednostek?

34
00:01:23,170 --> 00:01:26,060
>> To nie tak, możemy
powiedzieć, w wierszu poleceń

35
00:01:26,060 --> 00:01:28,040
wprowadzić jak najwięcej przedmiotów
myślisz, że musisz.

36
00:01:28,040 --> 00:01:31,100
No i co, czy to przypuszczenie jest nie tak?

37
00:01:31,100 --> 00:01:34,300
Dynamiczna alokacja pamięci
rodzaj pozwala nam drogę

38
00:01:34,300 --> 00:01:36,867
obejść tego konkretnego problemu.

39
00:01:36,867 --> 00:01:38,700
A sposób, w jaki to robi
Jest przy użyciu wskaźników.

40
00:01:38,700 --> 00:01:42,140
>> Możemy wykorzystać wskaźniki do
uzyskać dostęp do dynamicznie

41
00:01:42,140 --> 00:01:45,710
przydzielone pamięci, pamięci, która jest
przydzielone w programie jest uruchomiony.

42
00:01:45,710 --> 00:01:48,290
To nie jest przydzielony w czasie kompilacji.

43
00:01:48,290 --> 00:01:51,570
Kiedy dynamicznie przydzielać
Pamięć pochodzi z basenu

44
00:01:51,570 --> 00:01:53,795
znane jako pamięci na stercie.

45
00:01:53,795 --> 00:01:56,420
Wcześniej cała pamięć mamy
Pracuję z w toku

46
00:01:56,420 --> 00:01:59,920
przyjeżdża z puli
pamięci zwany stos.

47
00:01:59,920 --> 00:02:02,470
Dobrym sposobem na ogół
należy mind-- i tej zasady

48
00:02:02,470 --> 00:02:04,720
nie zawsze są prawdziwe,
ale prawie prawie

49
00:02:04,720 --> 00:02:09,940
Zawsze trzyma true-- jest, że każdy
Czas podać nazwę zmiennej it

50
00:02:09,940 --> 00:02:12,090
Prawdopodobnie mieszka na stosie.

51
00:02:12,090 --> 00:02:14,650
I za każdym razem tego nie zrobisz
dać zmiennej nazwę,

52
00:02:14,650 --> 00:02:19,160
które można zrobić z pamięci dynamicznej
alokacji, żyje na stercie.

53
00:02:19,160 --> 00:02:22,190
>> Teraz jestem trochę prezentuje to jako
jeśli jest te dwie pule pamięci.

54
00:02:22,190 --> 00:02:24,740
Ale może widzieliście to
schemat, który jest na ogół

55
00:02:24,740 --> 00:02:27,290
reprezentacją
co Pamięć wygląda,

56
00:02:27,290 --> 00:02:30,373
a my nie będziemy dbać o wszystko
rzeczy na górze i na dole.

57
00:02:30,373 --> 00:02:33,580
Co dbamy o to ta część w
środkowa tutaj, sterty i stosu.

58
00:02:33,580 --> 00:02:35,570
Jak widać przez
patrząc na tym schemacie,

59
00:02:35,570 --> 00:02:38,390
Nie są one w rzeczywistości dwa
oddzielne pule pamięci.

60
00:02:38,390 --> 00:02:42,757
To jedna wspólna pula pamięci
gdzie zacząć, w tym wizualne

61
00:02:42,757 --> 00:02:44,590
rozpocząć na dole
i zacząć zapełniać

62
00:02:44,590 --> 00:02:48,040
od dołu stosu, a ty
rozpoczyna się na górze i rozpocząć tankowanie

63
00:02:48,040 --> 00:02:50,072
z góry na dół z hałdy.

64
00:02:50,072 --> 00:02:51,780
Ale to naprawdę jest
sam basen, to tylko

65
00:02:51,780 --> 00:02:56,050
różne miejsca, różne lokalizacje
w pamięci, które są przydzielane.

66
00:02:56,050 --> 00:02:59,060
A może zabraknie
pamięci, albo o

67
00:02:59,060 --> 00:03:01,240
sterta przejść całą drogę
na dno, lub

68
00:03:01,240 --> 00:03:05,440
stos przejść całą drogę na górę,
lub o sterty i stosu

69
00:03:05,440 --> 00:03:06,740
spotkać się ze sobą.

70
00:03:06,740 --> 00:03:09,500
Wszystkie te mogą być warunki
które powodują swój program

71
00:03:09,500 --> 00:03:11,030
zabraknie pamięci.

72
00:03:11,030 --> 00:03:11,952
Miejcie to na uwadze.

73
00:03:11,952 --> 00:03:13,660
Kiedy mówimy o
sterta i stos

74
00:03:13,660 --> 00:03:17,880
tak naprawdę mówimy o
sam ogólny fragment pamięci, po prostu

75
00:03:17,880 --> 00:03:21,930
różne części tej pamięci.

76
00:03:21,930 --> 00:03:24,910
>> Jak więc się dynamicznie
przydzielona pamięć, w pierwszej kolejności?

77
00:03:24,910 --> 00:03:27,740
Jak działa nasz program się
pamięci, jak to działa?

78
00:03:27,740 --> 00:03:32,660
Cóż C zapewnia funkcję o nazwie
malloc, przydzielania pamięci, które

79
00:03:32,660 --> 00:03:36,810
można nawiązać połączenie, i przechodzą w
jak wiele bajtów pamięci, które chcesz.

80
00:03:36,810 --> 00:03:39,940
Więc, gdy Twój program jest uruchomiony
i chcesz, aby czas pracy całkowitą,

81
00:03:39,940 --> 00:03:46,040
możesz Mallock cztery bajty
Pamięć, malloc nawiasach cztery.

82
00:03:46,040 --> 00:03:48,540
>> Mallock przejdzie
patrząc przez hałdy,

83
00:03:48,540 --> 00:03:50,750
bo jesteśmy dynamicznie
przydzielania pamięci,

84
00:03:50,750 --> 00:03:53,500
i wróci do Ciebie
wskaźnik do tej pamięci.

85
00:03:53,500 --> 00:03:56,180
To nie daje ci tego memory--
nie daje mu nazwę,

86
00:03:56,180 --> 00:03:57,950
to daje wskaźnik do niego.

87
00:03:57,950 --> 00:04:00,780
A więc dlatego znów powiedziałem
że ważne jest, aby być może

88
00:04:00,780 --> 00:04:03,770
oglądałem film wskaźniki
zanim się zbyt daleko do tego.

89
00:04:03,770 --> 00:04:05,940
Więc malloc będzie
oddać wskaźnik.

90
00:04:05,940 --> 00:04:08,950
>> Jeśli Mallock nie daje żadnej
Pamięć dlatego, że zabrakło,

91
00:04:08,950 --> 00:04:10,645
będzie to oddać pustego wskaźnika.

92
00:04:10,645 --> 00:04:15,282
Pamiętasz, co się stanie, jeśli
spróbować dereference wskaźnikiem NULL?

93
00:04:15,282 --> 00:04:17,019
Cierpimy usterki seg, prawda?

94
00:04:17,019 --> 00:04:18,060
To chyba nie jest dobry.

95
00:04:18,060 --> 00:04:21,579
>> Dlatego za każdym razem, kiedy nawiązać połączenie
malloc Cię zawsze, zawsze

96
00:04:21,579 --> 00:04:25,270
należy sprawdzić, czy
wyżeł dał kopii jest zerowy.

97
00:04:25,270 --> 00:04:28,800
Jeśli tak jest, trzeba zakończyć swój program
bo jeśli spróbujesz i dereference

98
00:04:28,800 --> 00:04:31,360
null pointer idziesz
cierpieć błąd segmentacji

99
00:04:31,360 --> 00:04:34,380
i Twój program jest
będzie tak upaść.

100
00:04:34,380 --> 00:04:37,190
Jak więc statycznie
uzyskać liczbę całkowitą?

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

102
00:04:37,730 --> 00:04:40,010
Mamy prawdopodobnie zrobisz
kilka razy, prawda?

103
00:04:40,010 --> 00:04:43,480
To tworzy zmienną
x, że mieszka na stosie.

104
00:04:43,480 --> 00:04:46,190
W jaki sposób możemy dynamicznie uzyskać liczbę całkowitą?

105
00:04:46,190 --> 00:04:50,010
Int gwiazda px równa malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Lub więcej odpowiednio
powiedzielibyśmy int gwiazda px

107
00:04:53,050 --> 00:04:57,680
równa malloc rozmiar int,
po prostu wyrzucić niektóre mniej

108
00:04:57,680 --> 00:04:59,740
Magiczne liczby wokół naszego programu.

109
00:04:59,740 --> 00:05:04,140
To będzie dla nas, aby uzyskać
cztery bajty pamięci ze sterty,

110
00:05:04,140 --> 00:05:06,720
i wskaźnik mamy
Wróć do niego jest nazywany px.

111
00:05:06,720 --> 00:05:08,430
A potem, tak jak mamy
zrobione wcześniej mamy

112
00:05:08,430 --> 00:05:13,966
może dereference px do
dostępu do tej pamięci.

113
00:05:13,966 --> 00:05:15,590
W jaki sposób możemy uzyskać liczbę całkowitą od użytkownika?

114
00:05:15,590 --> 00:05:17,970
Można powiedzieć, int x równa się int.

115
00:05:17,970 --> 00:05:19,930
To całkiem proste.

116
00:05:19,930 --> 00:05:24,030
Co zrobić, jeśli chcemy stworzyć tablicę
od x pływaków, które żyją na stosie?

117
00:05:24,030 --> 00:05:28,210
unosić stack_array-- to nazwa
naszych array-- nawiasach kwadratowych x.

118
00:05:28,210 --> 00:05:32,419
To stworzy dla nas tablicy
od x pływaków, które żyją na stosie.

119
00:05:32,419 --> 00:05:34,960
Możemy stworzyć tablicę pływaków
który żyje na stercie, też.

120
00:05:34,960 --> 00:05:37,330
Składnia może wyglądać
trochę bardziej kłopotliwe,

121
00:05:37,330 --> 00:05:41,740
ale można powiedzieć, pływak
gwiazda heap_array równa

122
00:05:41,740 --> 00:05:44,360
malloc x razy większy od pływaka.

123
00:05:44,360 --> 00:05:48,160
Muszę wystarczająco dużo miejsca do przechowywania
x zmiennoprzecinkowych.

124
00:05:48,160 --> 00:05:51,560
Więc muszę powiedzieć, 100
pływaki lub 1000 pływaki.

125
00:05:51,560 --> 00:05:54,810
A więc w tym przypadku byłoby
400 bajtów do 100 pływaków,

126
00:05:54,810 --> 00:05:59,080
lub 4000 bajtów do 1000 pływaków,
ponieważ każdy pływak zajmuje

127
00:05:59,080 --> 00:06:01,230
cztery bajty przestrzeni.

128
00:06:01,230 --> 00:06:05,110
>> Po wykonaniu tej czynności można używać
nawias kwadratowy składni na heap_array.

129
00:06:05,110 --> 00:06:08,970
Tak jak bym na stack_array, ja
mogą uzyskać dostęp do jej elementów oddzielnie

130
00:06:08,970 --> 00:06:11,590
za pomocą heap_array zero, heap_array jeden.

131
00:06:11,590 --> 00:06:15,800
Ale przypominam powód możemy to zrobić
Jest tak, ponieważ nazwa tablicy w C

132
00:06:15,800 --> 00:06:19,990
jest naprawdę wskaźnik do
Pierwszy element tej tablicy jest.

133
00:06:19,990 --> 00:06:23,480
Tak więc fakt, że jesteśmy uznającej
Tablica pływaków na stosie tutaj

134
00:06:23,480 --> 00:06:24,810
w rzeczywistości jest nieco mylące.

135
00:06:24,810 --> 00:06:27,600
Naprawdę są w
Druga linia kodu nie

136
00:06:27,600 --> 00:06:32,360
także tworzenie wskaźnik do kawałka
pamięci, które następnie popracować z.

137
00:06:32,360 --> 00:06:35,620
>> Tu jest duży problem z
dynamicznie przydzielana pamięć choć,

138
00:06:35,620 --> 00:06:38,360
i to dlatego, że to naprawdę
ważne, aby rozwijać dobre nawyki

139
00:06:38,360 --> 00:06:39,800
podczas pracy z nim.

140
00:06:39,800 --> 00:06:43,060
W przeciwieństwie statycznie oświadczył
pamięć, pamięć

141
00:06:43,060 --> 00:06:46,790
nie jest automatycznie zwracana do
System, gdy funkcja jest wykonywana.

142
00:06:46,790 --> 00:06:49,280
Więc jeśli mamy głównym i
Głównym wywołuje funkcję

143
00:06:49,280 --> 00:06:53,860
f, gdy f wykończeń cokolwiek to robi
i zwraca sterowanie programem

144
00:06:53,860 --> 00:06:58,810
powrotem do głównego wszystkie pamięci
że f jest stosowany zwrócona.

145
00:06:58,810 --> 00:07:01,250
Może on być ponownie wykorzystywany
za pośrednictwem innego programu,

146
00:07:01,250 --> 00:07:04,250
lub inną funkcją
jest wywoływana później w głównym.

147
00:07:04,250 --> 00:07:06,970
Można go użyć tej samej pamięci na nowo.

148
00:07:06,970 --> 00:07:09,620
>> Jeśli dynamicznie
przydzielić pamięci choć

149
00:07:09,620 --> 00:07:14,380
trzeba wyraźnie powiedzieć
System, że jesteś z nim zrobić.

150
00:07:14,380 --> 00:07:18,370
To będzie trzymać się go dla Ciebie, które mogłyby
prowadzić do problemów z was na wyczerpaniu

151
00:07:18,370 --> 00:07:19,290
pamięci.

152
00:07:19,290 --> 00:07:22,179
A w rzeczywistości czasami odnoszą
to jako przeciek pamięci.

153
00:07:22,179 --> 00:07:24,970
I czasami te wycieki pamięci
w rzeczywistości może być bardzo niszczące

154
00:07:24,970 --> 00:07:27,020
na wydajność systemu.

155
00:07:27,020 --> 00:07:31,120
>> Jeśli jesteś częstym użytkownikiem www
można korzystać z niektórych przeglądarek internetowych,

156
00:07:31,120 --> 00:07:35,630
i nie będę wymieniać nazwisk tutaj, ale
istnieje kilka przeglądarek internetowych tam

157
00:07:35,630 --> 00:07:39,150
które są notorycznie faktycznie konieczności
wycieki pamięci, że nie dostać stałe.

158
00:07:39,150 --> 00:07:44,570
A jeśli pozostawić otwartą przeglądarkę
Przez bardzo długi okres czasu, dzień

159
00:07:44,570 --> 00:07:48,060
i dni, lub tygodni, czasami
można zauważyć, że system

160
00:07:48,060 --> 00:07:49,790
jest systemem bardzo, bardzo powoli.

161
00:07:49,790 --> 00:07:54,640
A powodem tego jest to, że
przeglądarka przeznaczyła pamięć,

162
00:07:54,640 --> 00:07:57,320
ale wtedy nie powiedział systemu
że to z nim zrobić.

163
00:07:57,320 --> 00:08:01,000
I tak, że pozostawia mniej pamięci
dostępne dla wszystkich innych programów

164
00:08:01,000 --> 00:08:04,480
aby się podzielić, bo jesteś
leaking-- tego przeglądarkę internetową

165
00:08:04,480 --> 00:08:06,755
Program jest wyciek pamięci.

166
00:08:06,755 --> 00:08:08,880
Jak dajemy pamięć powrotem
kiedy mamy z nim zrobić?

167
00:08:08,880 --> 00:08:10,838
No na szczęście jest to
bardzo prosty sposób to zrobić.

168
00:08:10,838 --> 00:08:11,710
My po prostu uwolnić go.

169
00:08:11,710 --> 00:08:15,020
Jest to funkcja zwana wolna,
przyjmuje wskaźnik do pamięci,

170
00:08:15,020 --> 00:08:16,010
i jesteśmy dobrze iść.

171
00:08:16,010 --> 00:08:18,310
>> Więc powiedzmy, że jesteśmy w
środek naszego programu,

172
00:08:18,310 --> 00:08:21,970
chcemy malloc 50 znaków.

173
00:08:21,970 --> 00:08:25,710
Chcemy malloc tablicę, która może
w stanie utrzymać 50 znaków.

174
00:08:25,710 --> 00:08:29,109
A gdy mamy wskaźnik z powrotem do
że nazwa tego wskaźnika jest słowo.

175
00:08:29,109 --> 00:08:30,900
Robimy co jesteśmy
zamiar zrobić ze słowem,

176
00:08:30,900 --> 00:08:33,440
a następnie, gdy jesteśmy
odbywa się po prostu uwolnić go.

177
00:08:33,440 --> 00:08:37,460
A teraz wróciliśmy te 50
bajtów pamięci z powrotem do systemu.

178
00:08:37,460 --> 00:08:40,147
Niektóre inne funkcje mogą z nich korzystać.

179
00:08:40,147 --> 00:08:43,480
Nie musimy martwić się o cierpienie
wyciek pamięci, ponieważ uwolnił słowo.

180
00:08:43,480 --> 00:08:46,639
Daliśmy pamięć z powrotem,
tak skończymy pracę z nim.

181
00:08:46,639 --> 00:08:48,430
Tak więc są trzy
złotych zasad, które powinny

182
00:08:48,430 --> 00:08:51,700
należy pamiętać, gdy jesteś
dynamicznego przydzielania pamięci

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

184
00:08:52,990 --> 00:08:56,480
Każdy blok pamięci
Ci malloc musi zostać uwolnione

185
00:08:56,480 --> 00:08:58,430
Zanim program zakończy uruchomiony.

186
00:08:58,430 --> 00:09:02,029
Się ponownie w urządzeniu lub w
IDE tego rodzaju dzieje się dla Ciebie tak

187
00:09:02,029 --> 00:09:04,820
kiedy you-- stanie się to tak
gdy program jest zakończony,

188
00:09:04,820 --> 00:09:06,880
cała pamięć zostanie zwolniona.

189
00:09:06,880 --> 00:09:10,750
Ale to jest na ogół dobre kodowanie
Praktyka zawsze, kiedy skończysz,

190
00:09:10,750 --> 00:09:13,810
uwolnić, co masz mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Powiedział, że tylko rzeczy, które
masz mallocd powinny zostać uwolnione.

192
00:09:16,690 --> 00:09:19,880
Jeśli statycznie zadeklarować
całkowita, int x średnik,

193
00:09:19,880 --> 00:09:23,500
że mieszka na stosie, to
nie to chce uwolnić x.

194
00:09:23,500 --> 00:09:25,970
Tak więc tylko rzeczy, które już
mallocd powinny zostać uwolnione.

195
00:09:25,970 --> 00:09:28,960
>> I wreszcie, nie wolny coś dwa razy.

196
00:09:28,960 --> 00:09:31,170
To może prowadzić do
kolejna dziwna sytuacja.

197
00:09:31,170 --> 00:09:33,530
Więc wszystko, co masz
mallocd musi być uwolniona.

198
00:09:33,530 --> 00:09:36,000
Jedyne rzeczy, które zostały
malloc powinny zostać uwolnione.

199
00:09:36,000 --> 00:09:38,730
I nie zrobić bezpłatne coś dwa razy.

200
00:09:38,730 --> 00:09:43,660
>> Więc chodźmy na przykładzie tutaj
co niektóre dynamicznie przydzielane

201
00:09:43,660 --> 00:09:46,122
Pamięć może wyglądać mieszane
w niektóre pamięci statycznej.

202
00:09:46,122 --> 00:09:47,080
Co może się zdarzyć tutaj?

203
00:09:47,080 --> 00:09:48,913
Zobacz, jeśli można śledzić
wzdłuż i odgadnąć, co jest

204
00:09:48,913 --> 00:09:51,720
będzie się działo jak idziemy
przez wszystkie te linie kodu.

205
00:09:51,720 --> 00:09:53,980
>> Tak więc możemy powiedzieć, int m.

206
00:09:53,980 --> 00:09:54,840
co się tutaj stało?

207
00:09:54,840 --> 00:09:56,339
Więc jest to całkiem proste.

208
00:09:56,339 --> 00:09:59,650
Utworzyć zmienną całkowitą o nazwie m.

209
00:09:59,650 --> 00:10:01,400
I kolor to zielony,
bo to kolor

210
00:10:01,400 --> 00:10:03,730
że mogę używać, kiedy mówię
o zmiennych całkowitych.

211
00:10:03,730 --> 00:10:05,160
Jest to okno.

212
00:10:05,160 --> 00:10:08,400
To się nazywa m, i można
Sklep z liczbami całkowitymi w jej wnętrzu.

213
00:10:08,400 --> 00:10:12,400
>> Co jeśli to powiedzieć, int star?

214
00:10:12,400 --> 00:10:13,530
Dobrze, że jest dość podobna.

215
00:10:13,530 --> 00:10:15,780
Tworzę pole nazywa.

216
00:10:15,780 --> 00:10:19,100
Jest w stanie utrzymać int
gwiazdy, wskaźniki do liczb całkowitych.

217
00:10:19,100 --> 00:10:21,570
Więc jestem kolorowanie to Zielona-owski, jak również.

218
00:10:21,570 --> 00:10:24,140
>> Wiem, że ma to coś
do czynienia z liczbą całkowitą,

219
00:10:24,140 --> 00:10:25,852
ale sama nie jest liczbą całkowitą.

220
00:10:25,852 --> 00:10:27,310
Ale to prawie ten sam pomysł.

221
00:10:27,310 --> 00:10:28,101
Stworzyłem okno.

222
00:10:28,101 --> 00:10:30,070
Obie te prawa
teraz mieszkam na stosie.

223
00:10:30,070 --> 00:10:32,520
Dałem im obie nazwy.

224
00:10:32,520 --> 00:10:36,750
>> int gwiazda b równa malloc rozmiar int.

225
00:10:36,750 --> 00:10:38,560
Ten może być trochę trudne.

226
00:10:38,560 --> 00:10:44,110
Poświęć chwilę i pomyśleć o tym, co
spodziewałby się zdarzyć na tym schemacie.

227
00:10:44,110 --> 00:10:50,210
int gwiazda b równa malloc rozmiar int.

228
00:10:50,210 --> 00:10:51,940
>> No to nie wystarczy utworzyć jedno pole.

229
00:10:51,940 --> 00:10:53,800
To rzeczywiście tworzy dwa pola.

230
00:10:53,800 --> 00:10:58,670
A to wiąże, również ustanawia
punkt w związku.

231
00:10:58,670 --> 00:11:02,240
Mamy przydzielony jeden blok
pamięci na stercie.

232
00:11:02,240 --> 00:11:05,940
Zauważ, że w prawym górnym rogu okno
nie ma nazwy.

233
00:11:05,940 --> 00:11:06,760
>> Mamy mallocd go.

234
00:11:06,760 --> 00:11:08,050
Istnieje on na stercie.

235
00:11:08,050 --> 00:11:10,090
Ale b ma imię.

236
00:11:10,090 --> 00:11:11,950
Jest to wskaźnik o nazwie zmiennej b.

237
00:11:11,950 --> 00:11:13,910
Że mieszka na stosie.

238
00:11:13,910 --> 00:11:18,250
>> Więc jest to kawałek pamięci
który wskazuje na inny.

239
00:11:18,250 --> 00:11:21,840
b zawiera adres
z tego bloku pamięci.

240
00:11:21,840 --> 00:11:23,757
To nie ma nazwy inaczej.

241
00:11:23,757 --> 00:11:24,590
Ale wskazuje na to.

242
00:11:24,590 --> 00:11:29,760
Więc, gdy mówimy, int gwiazda b równa
Rozmiar malloc int, że tam,

243
00:11:29,760 --> 00:11:33,490
że strzałka, która pojawiła się na
tam po prawej stronie, że cała sprawa,

244
00:11:33,490 --> 00:11:36,740
Będę musiał się wydawać
znowu, jest to, co się dzieje.

245
00:11:36,740 --> 00:11:39,341
Wszystko to dzieje się w
że jednej linii kodu.

246
00:11:39,341 --> 00:11:41,340
Teraz będziemy mieli trochę więcej
znowu proste.

247
00:11:41,340 --> 00:11:43,330
A równa ampersand m.

248
00:11:43,330 --> 00:11:46,280
Pamiętasz, co się
równa znaku & m jest?

249
00:11:46,280 --> 00:11:48,920
Dobrze, że to dostaje adres M.

250
00:11:48,920 --> 00:11:54,150
Lub umieścić bardziej schematycznie,
a punkty do m.

251
00:11:54,150 --> 00:11:56,360
>> A równa się b.

252
00:11:56,360 --> 00:11:57,560
OK, więc o jeszcze jeden.

253
00:11:57,560 --> 00:11:59,230
A równa się b.

254
00:11:59,230 --> 00:12:02,260
Co się stanie
na wykresie tym razem?

255
00:12:02,260 --> 00:12:04,330
>> Dobrze pamiętam, że
prace operatora przypisania

256
00:12:04,330 --> 00:12:08,960
przez przypisanie wartości na
Prawo do wartości po lewej stronie.

257
00:12:08,960 --> 00:12:14,820
Więc zamiast skierowana M, A teraz
wskazuje w tym samym miejscu, że B punktów.

258
00:12:14,820 --> 00:12:18,900
A nie wskazują na B, A
wskazuje, gdzie b punktów.

259
00:12:18,900 --> 00:12:25,280
>> Jeśli szpiczasty do b, które
były równe ampersand b.

260
00:12:25,280 --> 00:12:28,150
Ale zamiast równa b prostu
Oznacza to, że i b są teraz

261
00:12:28,150 --> 00:12:31,770
wskazując tym samym adresem, ponieważ
wewnątrz b jest tylko adres.

262
00:12:31,770 --> 00:12:35,004
Teraz wewnątrz a jest tego samego adresu.

263
00:12:35,004 --> 00:12:37,170
m wynosi 10, prawdopodobnie
Najprostszą rzeczą

264
00:12:37,170 --> 00:12:38,690
zrobiliśmy w trochę.

265
00:12:38,690 --> 00:12:40,460
Umieścić 10 w polu.

266
00:12:40,460 --> 00:12:45,640
Gwiazda b równa m plus 2, pamiętam z
Wskaźniki wideo, co nasza gwiazda b oznacza.

267
00:12:45,640 --> 00:12:50,230
Jedziemy do wyłuskiwania b i umieścić
jakaś wartość w tym miejscu pamięci.

268
00:12:50,230 --> 00:12:51,860
W tym przypadku 12.

269
00:12:51,860 --> 00:12:55,300
>> Kiedy więc dereference punktu
Przypomnijmy, że po prostu podróżować w dół strzałkę.

270
00:12:55,300 --> 00:12:58,205
Albo innymi słowy, mamy
przejść do tego adresu pamięci

271
00:12:58,205 --> 00:12:59,580
i manipulować nim w jakiś sposób.

272
00:12:59,580 --> 00:13:00,830
Kładziemy jakąś wartość tam.

273
00:13:00,830 --> 00:13:03,960
W tym przypadku gwiazdy b
M plus 2 równa jest po prostu

274
00:13:03,960 --> 00:13:08,230
przejść do zmiennej wskazywanej przez b,
przejść do pamięci wskazywanego przez b,

275
00:13:08,230 --> 00:13:11,750
i umieścić m plus 2 tam, 12.

276
00:13:11,750 --> 00:13:14,970
>> Teraz uwolnić b.

277
00:13:14,970 --> 00:13:16,490
Co się dzieje, kiedy zwolnić b?

278
00:13:16,490 --> 00:13:18,800
Pamiętaj, co powiedziałem wolne środki.

279
00:13:18,800 --> 00:13:21,920
Co ja mówię, kiedy zwolnić b?

280
00:13:21,920 --> 00:13:23,410
>> Skończyłem pracę z nim, prawda?

281
00:13:23,410 --> 00:13:25,702
I w zasadzie zrezygnować z pamięci.

282
00:13:25,702 --> 00:13:26,910
Daję go z powrotem do systemu.

283
00:13:26,910 --> 00:13:33,010
Nie potrzebuję już tego jest
co mam im powiedzieć, OK?

284
00:13:33,010 --> 00:13:37,390
>> Teraz, jeśli powiem, star
wynosi 11 prawdopodobnie można

285
00:13:37,390 --> 00:13:40,460
już powiedzieć, że coś złego
będzie się działo tutaj, prawda?

286
00:13:40,460 --> 00:13:44,160
I rzeczywiście, jeśli Próbowałem, że prawdopodobnie
poniósłby winy segmentacji.

287
00:13:44,160 --> 00:13:47,140
Bo teraz, choć
wcześniej, że fragment pamięci

288
00:13:47,140 --> 00:13:50,220
było coś, co miałem
dostęp do nich w tym momencie

289
00:13:50,220 --> 00:13:54,590
teraz mam dostępu do pamięci, że
nie jest dla mnie prawnego dostępu.

290
00:13:54,590 --> 00:13:57,330
>> A jak będzie prawdopodobnie
pamiętam, kiedy dostęp do pamięci

291
00:13:57,330 --> 00:14:00,000
że nie powinniśmy dotykać,
to jest najczęstszą przyczyną

292
00:14:00,000 --> 00:14:01,860
z segmentacji
przyczepić. I tak mój program

293
00:14:01,860 --> 00:14:05,170
będzie katastrofy, gdy starałem się to zrobić.

294
00:14:05,170 --> 00:14:09,910
Więc jeszcze raz, że to dobry pomysł, aby uzyskać dobry
praktyka i dobre nawyki zakorzenione

295
00:14:09,910 --> 00:14:12,920
podczas pracy z malloc i wolna,
tak, że nie cierpią segmentacji

296
00:14:12,920 --> 00:14:15,310
błędy, i że używasz
Twój dynamicznie przydzielane

297
00:14:15,310 --> 00:14:17,370
Pamięć odpowiedzialnie.

298
00:14:17,370 --> 00:14:20,300
>> Jestem Doug Lloyd to CS50.

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