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

2
00:00:00,499 --> 00:00:01,395
[Bermain muzik]

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

4
00:00:05,590 --> 00:00:07,940
>> DOUG LLOYD: OK jadi cadangan
sebelum memulakan di sini.

5
00:00:07,940 --> 00:00:11,660
Jika anda tidak menonton video pada
Penunjuk anda mungkin mahu untuk berbuat demikian pertama.

6
00:00:11,660 --> 00:00:15,860
Kerana video ini adalah satu lagi
cara bekerja dengan petunjuk.

7
00:00:15,860 --> 00:00:17,574
>> Jadi ia akan bercakap
tentang beberapa konsep

8
00:00:17,574 --> 00:00:19,490
yang kita buat di dalam itu
Penunjuk video, dan kami

9
00:00:19,490 --> 00:00:21,948
akan menyembunyikan mereka sekarang,
menganggap bahawa mereka sudah

10
00:00:21,948 --> 00:00:23,090
semacam difahami.

11
00:00:23,090 --> 00:00:25,440
Jadi itu hanya amaran yang adil
jika anda lihat video ini

12
00:00:25,440 --> 00:00:27,814
dan anda tidak melihat
video petunjuk, ia mungkin jenis

13
00:00:27,814 --> 00:00:29,610
terbang di atas kepala anda sedikit.

14
00:00:29,610 --> 00:00:32,080
Dan jadi ia mungkin lebih baik
menonton dalam perintah itu.

15
00:00:32,080 --> 00:00:34,710
>> Oleh itu, kita telah melihat satu
cara untuk bekerja dengan petunjuk,

16
00:00:34,710 --> 00:00:37,810
yang kita mengisytiharkan
berubah-ubah, dan kemudian kita

17
00:00:37,810 --> 00:00:42,160
mengisytiharkan pembolehubah lain, penunjuk
berubah-ubah, yang menunjuk kepadanya.

18
00:00:42,160 --> 00:00:44,870
Oleh itu, kita telah membuat
ubah dengan nama, kami telah

19
00:00:44,870 --> 00:00:48,480
dicipta pembolehubah kedua dengan nama,
dan kami menunjukkan bahawa pemboleh ubah kedua

20
00:00:48,480 --> 00:00:50,220
pada yang pertama.

21
00:00:50,220 --> 00:00:52,370
Ini jenis mempunyai
masalah walaupun, kerana ia

22
00:00:52,370 --> 00:00:54,650
memerlukan kita untuk mengetahui dengan tepat
berapa banyak memori kami

23
00:00:54,650 --> 00:00:57,600
akan memerlukan masa ini
program kami disusun.

24
00:00:57,600 --> 00:00:58,220
>> Kenapa begitu?

25
00:00:58,220 --> 00:01:03,338
Kerana kita perlu berupaya untuk menamakan atau
mengenal pasti semua pembolehubah mungkin

26
00:01:03,338 --> 00:01:04,129
kita mungkin hadapi.

27
00:01:04,129 --> 00:01:07,910
Kita mungkin mempunyai pelbagai yang mungkin
dapat memegang banyak maklumat,

28
00:01:07,910 --> 00:01:10,110
tetapi ia masih tidak
betul-betul tepat mencukupi.

29
00:01:10,110 --> 00:01:12,640
Bagaimana jika kita tidak tahu,
bagaimana jika kita tidak tahu

30
00:01:12,640 --> 00:01:14,370
berapa banyak yang kita perlu pada masa kompil?

31
00:01:14,370 --> 00:01:17,020
Atau bagaimana jika program kami akan
berjalan untuk masa yang lama,

32
00:01:17,020 --> 00:01:19,810
menerima pelbagai pengguna
data, dan kita tidak boleh benar-benar

33
00:01:19,810 --> 00:01:23,170
menganggarkan sama ada kita berada
akan memerlukan 1,000 unit?

34
00:01:23,170 --> 00:01:26,060
>> Ia tidak seperti yang kita boleh
katakan pada baris arahan

35
00:01:26,060 --> 00:01:28,040
masukkan berapa banyak perkara
anda fikir anda akan perlukan.

36
00:01:28,040 --> 00:01:31,100
Nah bagaimana jika tekaan yang salah?

37
00:01:31,100 --> 00:01:34,300
Peruntukan memori dinamik
semacam membolehkan kami jalan yang

38
00:01:34,300 --> 00:01:36,867
untuk mendapatkan sekitar masalah ini tertentu.

39
00:01:36,867 --> 00:01:38,700
Dan cara ia ia
adalah dengan menggunakan petunjuk.

40
00:01:38,700 --> 00:01:42,140
>> Kita boleh menggunakan petunjuk untuk
mendapat akses kepada dinamik

41
00:01:42,140 --> 00:01:45,710
memori diperuntukkan, memori yang
diperuntukkan sebagai program anda sedang berjalan.

42
00:01:45,710 --> 00:01:48,290
Ia tidak diperuntukkan pada masa kompil.

43
00:01:48,290 --> 00:01:51,570
Apabila anda dinamik memperuntukkan
memori ia datang dari kolam

44
00:01:51,570 --> 00:01:53,795
memori dikenali sebagai timbunan itu.

45
00:01:53,795 --> 00:01:56,420
Sebelum ini semua memori kami telah
telah bekerja dengan dalam perjalanan

46
00:01:56,420 --> 00:01:59,920
telah datang dari kolam
memori dikenali sebagai timbunan.

47
00:01:59,920 --> 00:02:02,470
Cara yang baik untuk secara amnya
menyimpan dalam kaedah mind-- dan ini

48
00:02:02,470 --> 00:02:04,720
tidak selalu memegang benar,
tetapi cukup banyak hampir

49
00:02:04,720 --> 00:02:09,940
sentiasa memegang true-- ialah mana-mana
kali anda memberikan nama pembolehubah ia

50
00:02:09,940 --> 00:02:12,090
mungkin hidup dalam timbunan.

51
00:02:12,090 --> 00:02:14,650
Dan bila-bila masa anda tidak
memberi pembolehubah nama,

52
00:02:14,650 --> 00:02:19,160
yang anda boleh lakukan dengan ingatan dinamik
peruntukan, ia hidup dalam timbunan itu.

53
00:02:19,160 --> 00:02:22,190
>> Sekarang saya jenis menyampaikan ini sebagai
jika ada kedua-dua kolam ingatan.

54
00:02:22,190 --> 00:02:24,740
Tetapi anda mungkin telah melihat ini
rajah, yang biasanya

55
00:02:24,740 --> 00:02:27,290
perwakilan
apa memori kelihatan seperti,

56
00:02:27,290 --> 00:02:30,373
dan kami tidak akan mengambil berat tentang semua
barang-barang di bahagian atas dan bahagian bawah.

57
00:02:30,373 --> 00:02:33,580
Apa yang kita mengambil berat tentang adalah bahagian ini dalam
tengah sini, timbunan dan timbunan.

58
00:02:33,580 --> 00:02:35,570
Seperti yang anda boleh lihat dengan
melihat gambar rajah ini,

59
00:02:35,570 --> 00:02:38,390
ini sebenarnya bukan dua
kolam berasingan memori.

60
00:02:38,390 --> 00:02:42,757
Ia adalah salah satu kolam dikongsi memori
di mana anda mula pada yang demikian visual

61
00:02:42,757 --> 00:02:44,590
anda bermula dari bawah
dan mula mengisi

62
00:02:44,590 --> 00:02:48,040
dari bahagian bawah dengan timbunan, dan anda
mula di bahagian atas dan mula mengisi

63
00:02:48,040 --> 00:02:50,072
dari atas ke bawah dengan timbunan itu.

64
00:02:50,072 --> 00:02:51,780
Tetapi ia benar-benar adalah
kolam sama, ia hanya

65
00:02:51,780 --> 00:02:56,050
tempat yang berbeza, lokasi yang berbeza
dalam ingatan yang diperuntukkan.

66
00:02:56,050 --> 00:02:59,060
Dan anda boleh kehabisan
memori dengan sama ada mempunyai

67
00:02:59,060 --> 00:03:01,240
timbunan itu pergi sepanjang jalan
ke bawah, atau mempunyai

68
00:03:01,240 --> 00:03:05,440
timbunan pergi sepanjang jalan ke atas,
atau mempunyai timbunan dan timbunan

69
00:03:05,440 --> 00:03:06,740
bertemu antara satu sama lain.

70
00:03:06,740 --> 00:03:09,500
Semua orang-orang boleh menjadi syarat
yang menyebabkan program anda

71
00:03:09,500 --> 00:03:11,030
kehabisan memori.

72
00:03:11,030 --> 00:03:11,952
Jadi menyimpan bahawa dalam fikiran.

73
00:03:11,952 --> 00:03:13,660
Apabila kita bercakap mengenai
timbunan dan timbunan

74
00:03:13,660 --> 00:03:17,880
kita benar-benar bercakap tentang
sebahagian umum yang sama ingatan, hanya

75
00:03:17,880 --> 00:03:21,930
bahagian yang berlainan memori itu.

76
00:03:21,930 --> 00:03:24,910
>> Jadi bagaimana kita mendapatkan dinamik
memori diperuntukkan di tempat pertama?

77
00:03:24,910 --> 00:03:27,740
Bagaimana program kami mendapat
memori kerana ia berjalan?

78
00:03:27,740 --> 00:03:32,660
Well C menyediakan fungsi yang dipanggil
malloc, allocator ingatan, yang

79
00:03:32,660 --> 00:03:36,810
anda membuat panggilan kepada, dan anda lulus dalam
berapa banyak bait memori yang anda mahu.

80
00:03:36,810 --> 00:03:39,940
Jadi, jika program anda berjalan
dan anda mahukan runtime integer,

81
00:03:39,940 --> 00:03:46,040
anda mungkin mallock empat bait
ingatan, malloc kurungan empat.

82
00:03:46,040 --> 00:03:48,540
>> mallock akan melalui
melihat melalui timbunan itu,

83
00:03:48,540 --> 00:03:50,750
kerana kami dinamik
memperuntukkan ingatan,

84
00:03:50,750 --> 00:03:53,500
dan ia akan kembali kepada anda
penunjuk kepada memori itu.

85
00:03:53,500 --> 00:03:56,180
Ia tidak memberikan anda memory-- yang
ia tidak memberikan nama,

86
00:03:56,180 --> 00:03:57,950
ia memberi anda penunjuk kepadanya.

87
00:03:57,950 --> 00:04:00,780
Dan itulah sebabnya mengapa lagi saya berkata
bahawa ia adalah penting untuk mungkin

88
00:04:00,780 --> 00:04:03,770
telah menonton video petunjuk yang
sebelum kita terlalu jauh ke dalam ini.

89
00:04:03,770 --> 00:04:05,940
Jadi malloc akan
memberikan anda kembali penunjuk.

90
00:04:05,940 --> 00:04:08,950
>> Jika mallock tidak boleh memberi apa-apa anda
memori kerana anda telah habis,

91
00:04:08,950 --> 00:04:10,645
ia akan memberikan anda kembali penunjuk null.

92
00:04:10,645 --> 00:04:15,282
Adakah anda masih ingat apa yang berlaku jika kita
cuba dereference penunjuk null?

93
00:04:15,282 --> 00:04:17,019
Kami mengalami kesalahan seg, bukan?

94
00:04:17,019 --> 00:04:18,060
Itu mungkin tidak baik.

95
00:04:18,060 --> 00:04:21,579
>> Jadi setiap kali anda membuat panggilan
malloc anda sentiasa, sentiasa

96
00:04:21,579 --> 00:04:25,270
perlu menyemak sama ada atau tidak
penunjuk ia memberikan anda kembali adalah batal.

97
00:04:25,270 --> 00:04:28,800
Jika ia, anda perlu berakhir program anda
kerana jika anda cuba dan dereference

98
00:04:28,800 --> 00:04:31,360
penunjuk nol anda akan
menderita kesalahan segmentasi

99
00:04:31,360 --> 00:04:34,380
dan program anda
akan kemalangan juga.

100
00:04:34,380 --> 00:04:37,190
Jadi bagaimana kita statik
mendapatkan integer?

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

102
00:04:37,730 --> 00:04:40,010
Kita mungkin telah melakukan itu
sekumpulan kali, bukan?

103
00:04:40,010 --> 00:04:43,480
Ini mewujudkan pembolehubah yang dipanggil
x yang hidup dalam timbunan.

104
00:04:43,480 --> 00:04:46,190
Bagaimana kita secara dinamik mendapatkan integer?

105
00:04:46,190 --> 00:04:50,010
Int bintang px sama malloc 4.

106
00:04:50,010 --> 00:04:53,050
>> Atau lebih sesuai
kita katakan px int bintang

107
00:04:53,050 --> 00:04:57,680
sama saiz malloc int,
hanya untuk membuang beberapa kurang

108
00:04:57,680 --> 00:04:59,740
nombor ajaib sekitar program kami.

109
00:04:59,740 --> 00:05:04,140
Ini akan mendapatkan untuk kita
empat bait memori dari timbunan itu,

110
00:05:04,140 --> 00:05:06,720
dan penunjuk yang kita dapat
kembali ke ia dipanggil px.

111
00:05:06,720 --> 00:05:08,430
Dan kemudian seperti yang kita ada
dilakukan sebelum ini kita

112
00:05:08,430 --> 00:05:13,966
boleh dereference px untuk
mengakses memori itu.

113
00:05:13,966 --> 00:05:15,590
Bagaimana kita mendapatkan integer dari pengguna?

114
00:05:15,590 --> 00:05:17,970
Kita boleh mengatakan int x sama mendapatkan int.

115
00:05:17,970 --> 00:05:19,930
Itu cukup mudah.

116
00:05:19,930 --> 00:05:24,030
Bagaimana jika kita ingin membuat array
daripada x pelampung yang hidup pada timbunan?

117
00:05:24,030 --> 00:05:28,210
terapung stack_array-- itulah nama
daripada array-- kami kurungan persegi x.

118
00:05:28,210 --> 00:05:32,419
Yang akan mewujudkan untuk kita array
daripada x pelampung yang hidup dalam timbunan.

119
00:05:32,419 --> 00:05:34,960
Kita boleh membuat pelbagai terapung
yang hidup pada timbunan itu juga.

120
00:05:34,960 --> 00:05:37,330
Sintaks yang mungkin kelihatan
sedikit lebih rumit,

121
00:05:37,330 --> 00:05:41,740
tetapi kita boleh mengatakan apungan
heap_array bintang sama

122
00:05:41,740 --> 00:05:44,360
malloc x kali saiz apung.

123
00:05:44,360 --> 00:05:48,160
Saya memerlukan ruang yang cukup untuk memegang
x terapung nilai mata.

124
00:05:48,160 --> 00:05:51,560
Jadi mengatakan saya perlu 100
terapung, terapung atau 1,000.

125
00:05:51,560 --> 00:05:54,810
Jadi, dalam kes itu, ia akan menjadi
400 bait untuk 100 kereta berhias,

126
00:05:54,810 --> 00:05:59,080
atau 4,000 bait untuk 1000 terapung,
kerana setiap apungan mengambil

127
00:05:59,080 --> 00:06:01,230
empat bait ruang.

128
00:06:01,230 --> 00:06:05,110
>> Selepas berbuat demikian, saya boleh menggunakan
persegi sintaks kurungan di heap_array.

129
00:06:05,110 --> 00:06:08,970
Sama seperti saya lakukan pada stack_array, saya
boleh mengakses unsur-unsur secara individu

130
00:06:08,970 --> 00:06:11,590
menggunakan heap_array sifar, satu heap_array.

131
00:06:11,590 --> 00:06:15,800
Tetapi ingat sebab kita boleh berbuat demikian
adalah kerana nama pelbagai dalam C

132
00:06:15,800 --> 00:06:19,990
adalah benar-benar penunjuk kepada
Elemen pertama yang pelbagai ini.

133
00:06:19,990 --> 00:06:23,480
Jadi hakikat bahawa kita mengisytiharkan
pelbagai kereta berhias pada timbunan sini

134
00:06:23,480 --> 00:06:24,810
sebenarnya agak mengelirukan.

135
00:06:24,810 --> 00:06:27,600
Kami benar-benar berada dalam
baris kedua kod terdapat

136
00:06:27,600 --> 00:06:32,360
juga mewujudkan penunjuk kepada sebahagian daripada
memori yang kemudian kita membuat kerja-kerja dengan.

137
00:06:32,360 --> 00:06:35,620
>> Inilah masalah besar dengan
dinamik diperuntukkan ingatan walaupun,

138
00:06:35,620 --> 00:06:38,360
dan ini adalah mengapa ia benar-benar
penting untuk membangunkan beberapa tabiat yang baik

139
00:06:38,360 --> 00:06:39,800
apabila anda bekerja dengannya.

140
00:06:39,800 --> 00:06:43,060
Tidak seperti statik diisytiharkan
ingatan, ingatan anda

141
00:06:43,060 --> 00:06:46,790
tidak secara automatik kembali ke
sistem apabila fungsi selesai.

142
00:06:46,790 --> 00:06:49,280
Jadi, jika kita mempunyai utama, dan
utama panggilan fungsi

143
00:06:49,280 --> 00:06:53,860
f, apabila f kemasan apa sahaja yang ia lakukan
dan mengembalikan kawalan program

144
00:06:53,860 --> 00:06:58,810
kembali ke utama, kesemua memori yang
f yang digunakan diberikan kembali.

145
00:06:58,810 --> 00:07:01,250
Ia boleh digunakan lagi
oleh beberapa program lain,

146
00:07:01,250 --> 00:07:04,250
atau beberapa fungsi lain yang
mendapat dipanggil kemudian di dalam utama.

147
00:07:04,250 --> 00:07:06,970
Ia boleh menggunakan memori yang sama berulang lagi.

148
00:07:06,970 --> 00:07:09,620
>> Jika anda secara dinamik
memperuntukkan memori walaupun

149
00:07:09,620 --> 00:07:14,380
anda perlu memberitahu dengan jelas yang
sistem yang anda selesai dengannya.

150
00:07:14,380 --> 00:07:18,370
Ia akan memegang untuk anda, yang boleh
membawa kepada masalah anda kehabisan

151
00:07:18,370 --> 00:07:19,290
memori.

152
00:07:19,290 --> 00:07:22,179
Dan sebenarnya kita kadang-kadang merujuk
kepada ini sebagai kebocoran memori.

153
00:07:22,179 --> 00:07:24,970
Dan kadang-kadang ini kebocoran memori
sebenarnya boleh menjadi benar-benar dahsyat

154
00:07:24,970 --> 00:07:27,020
untuk prestasi sistem.

155
00:07:27,020 --> 00:07:31,120
>> Jika anda seorang pengguna internet yang kerap
anda mungkin menggunakan pelayar web tertentu,

156
00:07:31,120 --> 00:07:35,630
dan saya tidak akan menamakan nama-nama di sini, tetapi
terdapat sesetengah pelayar web di luar sana

157
00:07:35,630 --> 00:07:39,150
yang terkenal dengan sebenarnya mempunyai
kebocoran memori yang tidak dapat ditetapkan.

158
00:07:39,150 --> 00:07:44,570
Dan jika anda meninggalkan pelayar anda terbuka
untuk tempoh yang sangat lama, hari

159
00:07:44,570 --> 00:07:48,060
dan hari-hari, atau minggu, anda kadang-kadang
mungkin perasan bahawa sistem anda

160
00:07:48,060 --> 00:07:49,790
sedang berjalan benar-benar, benar-benar perlahan-lahan.

161
00:07:49,790 --> 00:07:54,640
Dan sebab itu adalah bahawa
pelayar telah memperuntukkan ingatan,

162
00:07:54,640 --> 00:07:57,320
tetapi kemudian tidak kepada sistem
bahawa ia dilakukan dengan ia.

163
00:07:57,320 --> 00:08:01,000
Dan sebagainya yang meninggalkan memori kurang
disediakan untuk semua program anda yang lain

164
00:08:01,000 --> 00:08:04,480
untuk mempunyai untuk berkongsi, kerana anda
leaking-- bahawa pelayar web

165
00:08:04,480 --> 00:08:06,755
program bocor ingatan.

166
00:08:06,755 --> 00:08:08,880
Bagaimana kita memberi ingatan kembali
apabila kami sudah selesai dengan ia?

167
00:08:08,880 --> 00:08:10,838
Well nasib baik ia adalah satu
cara yang sangat mudah untuk melakukannya.

168
00:08:10,838 --> 00:08:11,710
Kami hanya membebaskan.

169
00:08:11,710 --> 00:08:15,020
Ada fungsi yang dipanggil percuma,
ia menerima penunjuk kepada ingatan,

170
00:08:15,020 --> 00:08:16,010
dan kami baik untuk pergi.

171
00:08:16,010 --> 00:08:18,310
>> Jadi katakan kita berada di
pertengahan program kami,

172
00:08:18,310 --> 00:08:21,970
kita mahu malloc 50 aksara.

173
00:08:21,970 --> 00:08:25,710
Kami mahu malloc pelbagai yang boleh
mampu menampung 50 aksara.

174
00:08:25,710 --> 00:08:29,109
Dan ketika kita mendapatkan penunjuk kembali ke
itu, nama itu penunjuk adalah perkataan.

175
00:08:29,109 --> 00:08:30,900
Kami melakukan apa sahaja yang kita
akan lakukan dengan perkataan,

176
00:08:30,900 --> 00:08:33,440
dan kemudian apabila kami
dilakukan kita hanya membebaskan.

177
00:08:33,440 --> 00:08:37,460
Dan sekarang kita telah kembali mereka 50
bait memori kembali kepada sistem.

178
00:08:37,460 --> 00:08:40,147
Beberapa fungsi lain boleh menggunakannya.

179
00:08:40,147 --> 00:08:43,480
Kami tidak perlu bimbang tentang mengalami
memori kebocoran kerana kita telah dibebaskan perkataan.

180
00:08:43,480 --> 00:08:46,639
Kami telah diberi ingatan kembali,
jadi kami selesai bekerja dengannya.

181
00:08:46,639 --> 00:08:48,430
Jadi, ada tiga
peraturan keemasan yang perlu

182
00:08:48,430 --> 00:08:51,700
diingat setiap kali anda berada
dinamik memperuntukkan memori

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

184
00:08:52,990 --> 00:08:56,480
Setiap blok memori yang
anda malloc mesti dibebaskan

185
00:08:56,480 --> 00:08:58,430
sebelum program anda selesai berjalan.

186
00:08:58,430 --> 00:09:02,029
Kini sekali lagi, perkakas atau dalam
IDE ini jenis berlaku untuk anda anyway

187
00:09:02,029 --> 00:09:04,820
apabila atasmu, ini akan berlaku pula
apabila program anda ditamatkan,

188
00:09:04,820 --> 00:09:06,880
semua memori akan dikeluarkan.

189
00:09:06,880 --> 00:09:10,750
Tetapi ia pengekodan umumnya baik
amalan untuk biasa, apabila anda selesai,

190
00:09:10,750 --> 00:09:13,810
membebaskan apa yang telah mallocd.

191
00:09:13,810 --> 00:09:16,690
>> Yang berkata, perkara-perkara yang
anda telah mallocd perlu dibebaskan.

192
00:09:16,690 --> 00:09:19,880
Jika anda statik mengisytiharkan
integer, int x koma bertitik,

193
00:09:19,880 --> 00:09:23,500
yang hidup pada timbunan, anda
jangan kemudian mahu membebaskan x.

194
00:09:23,500 --> 00:09:25,970
Jadi hanya perkara yang anda telah
mallocd perlu dibebaskan.

195
00:09:25,970 --> 00:09:28,960
>> Dan akhir sekali, tidak sesuatu yang percuma dua kali.

196
00:09:28,960 --> 00:09:31,170
Yang boleh membawa kepada
lain keadaan pelik.

197
00:09:31,170 --> 00:09:33,530
Jadi semua yang anda telah
mallocd perlu dibebaskan.

198
00:09:33,530 --> 00:09:36,000
Hanya perkara yang anda telah
malloc perlu dibebaskan.

199
00:09:36,000 --> 00:09:38,730
Dan tidak melakukan sesuatu yang percuma dua kali.

200
00:09:38,730 --> 00:09:43,660
>> Jadi mari kita pergi melalui contoh di sini
apa yang sesetengah dinamik diperuntukkan

201
00:09:43,660 --> 00:09:46,122
memori mungkin kelihatan seperti bercampur-campur
dengan beberapa ingatan statik.

202
00:09:46,122 --> 00:09:47,080
Apa yang mungkin berlaku di sini?

203
00:09:47,080 --> 00:09:48,913
Lihat jika anda boleh mengikuti
bersama-sama dan meneka apa yang

204
00:09:48,913 --> 00:09:51,720
akan berlaku seperti yang kita pergi
melalui semua ini baris kod.

205
00:09:51,720 --> 00:09:53,980
>> Oleh itu, kita mengatakan int m.

206
00:09:53,980 --> 00:09:54,840
Apa yang berlaku di sini?

207
00:09:54,840 --> 00:09:56,339
Nah ini adalah agak mudah.

208
00:09:56,339 --> 00:09:59,650
Saya mencipta satu pembolehubah integer dipanggil m.

209
00:09:59,650 --> 00:10:01,400
Saya warna hijau,
kerana itulah warna

210
00:10:01,400 --> 00:10:03,730
yang saya gunakan apabila saya bercakap
tentang pembolehubah integer.

211
00:10:03,730 --> 00:10:05,160
Ia adalah sebuah kotak.

212
00:10:05,160 --> 00:10:08,400
Ia dipanggil m, dan anda boleh
integer kedai di dalamnya.

213
00:10:08,400 --> 00:10:12,400
>> Bagaimana jika saya kemudian berkata int bintang?

214
00:10:12,400 --> 00:10:13,530
Baik yang agak sama.

215
00:10:13,530 --> 00:10:15,780
Saya mewujudkan kotak yang dikenali sebagai.

216
00:10:15,780 --> 00:10:19,100
Ia mampu int pegangan
bintang, petunjuk kepada integer.

217
00:10:19,100 --> 00:10:21,570
Jadi, saya mewarna ia hijau-ish juga.

218
00:10:21,570 --> 00:10:24,140
>> Saya tahu ia mempunyai sesuatu
kaitan dengan integer,

219
00:10:24,140 --> 00:10:25,852
tetapi ia sendiri adalah integer.

220
00:10:25,852 --> 00:10:27,310
Tetapi ia cukup banyak idea yang sama.

221
00:10:27,310 --> 00:10:28,101
Saya telah membuat sebuah kotak.

222
00:10:28,101 --> 00:10:30,070
Kedua-dua hak ini
kini hidup dalam timbunan.

223
00:10:30,070 --> 00:10:32,520
Saya telah memberikan mereka kedua-dua nama.

224
00:10:32,520 --> 00:10:36,750
>> int bintang b sama saiz malloc int.

225
00:10:36,750 --> 00:10:38,560
Yang ini mungkin sedikit rumit.

226
00:10:38,560 --> 00:10:44,110
Mengambil kedua dan berfikir tentang apa yang anda
inginkan berlaku pada gambarajah ini.

227
00:10:44,110 --> 00:10:50,210
int bintang b sama saiz malloc int.

228
00:10:50,210 --> 00:10:51,940
>> Nah ini bukan sahaja mewujudkan satu kotak.

229
00:10:51,940 --> 00:10:53,800
Ini sebenarnya mewujudkan dua kotak.

230
00:10:53,800 --> 00:10:58,670
Dan hubungan, ia juga menetapkan
titik dalam hubungan.

231
00:10:58,670 --> 00:11:02,240
Kami telah diperuntukkan satu blok
memori pada timbunan itu.

232
00:11:02,240 --> 00:11:05,940
Perhatikan bahawa kotak atas kanan
terdapat tidak mempunyai nama.

233
00:11:05,940 --> 00:11:06,760
>> Kami mallocd ia.

234
00:11:06,760 --> 00:11:08,050
Ia wujud pada timbunan itu.

235
00:11:08,050 --> 00:11:10,090
Tetapi b mempunyai nama.

236
00:11:10,090 --> 00:11:11,950
Ia adalah satu pembolehubah penunjuk dipanggil b.

237
00:11:11,950 --> 00:11:13,910
Yang hidup dalam timbunan.

238
00:11:13,910 --> 00:11:18,250
>> Jadi ia adalah sekeping memori
yang menunjukkan satu sama lain.

239
00:11:18,250 --> 00:11:21,840
b mengandungi alamat
itu blok ingatan.

240
00:11:21,840 --> 00:11:23,757
Ia tidak mempunyai nama yang sebaliknya.

241
00:11:23,757 --> 00:11:24,590
Tetapi ia menjurus kepadanya.

242
00:11:24,590 --> 00:11:29,760
Oleh itu, apabila kita katakan int bintang b sama
saiz malloc int, yang di sana,

243
00:11:29,760 --> 00:11:33,490
bahawa anak panah yang muncul pada
sampingan di sana, bahawa perkara keseluruhan,

244
00:11:33,490 --> 00:11:36,740
Saya akan mempunyai ia kelihatan
sekali lagi, apa yang berlaku.

245
00:11:36,740 --> 00:11:39,341
Semua itu berlaku dalam
yang baris kod.

246
00:11:39,341 --> 00:11:41,340
Sekarang kita akan mendapat sedikit lebih
terus-terang lagi.

247
00:11:41,340 --> 00:11:43,330
yang sama Ampersand m.

248
00:11:43,330 --> 00:11:46,280
Adakah anda masih ingat apa yang
sama Ampersand m adalah?

249
00:11:46,280 --> 00:11:48,920
Nah itu yang mendapat alamat m.

250
00:11:48,920 --> 00:11:54,150
Atau meletakkan lebih rajah,
satu mata kepada m.

251
00:11:54,150 --> 00:11:56,360
>> yang sama b.

252
00:11:56,360 --> 00:11:57,560
OK jadi di sini adalah satu sama lain.

253
00:11:57,560 --> 00:11:59,230
A sama dengan b.

254
00:11:59,230 --> 00:12:02,260
Apa yang akan berlaku
diagram di masa ini?

255
00:12:02,260 --> 00:12:04,330
>> Juga ingat bahawa
kerja-kerja pengendali tugasan

256
00:12:04,330 --> 00:12:08,960
dengan memberi nilai di
hak untuk nilai di sebelah kiri.

257
00:12:08,960 --> 00:12:14,820
Jadi, daripada yang menunjuk ke m, sekarang
menunjuk ke tempat yang sama yang b mata.

258
00:12:14,820 --> 00:12:18,900
yang tidak menunjukkan b, yang
menunjukkan di mana b mata.

259
00:12:18,900 --> 00:12:25,280
>> Jika tajamnya untuk b yang akan
telah menjadi sama Ampersand b.

260
00:12:25,280 --> 00:12:28,150
Tetapi sebaliknya yang sama b hanya
bermakna dan b adalah sekarang

261
00:12:28,150 --> 00:12:31,770
menunjuk ke alamat yang sama, kerana
bahagian dalam b hanya alamat.

262
00:12:31,770 --> 00:12:35,004
Dan kini di dalam adalah alamat yang sama.

263
00:12:35,004 --> 00:12:37,170
m sama dengan 10, mungkin yang
Perkara yang paling mudah

264
00:12:37,170 --> 00:12:38,690
kita lakukan pada sedikit.

265
00:12:38,690 --> 00:12:40,460
Meletakkan 10 di dalam kotak.

266
00:12:40,460 --> 00:12:45,640
Star b sama dengan m campur 2, ingat dari
apa bintang petunjuk video kami b bermakna.

267
00:12:45,640 --> 00:12:50,230
Kami akan dereference b dan meletakkan
beberapa nilai di lokasi itu ingatan.

268
00:12:50,230 --> 00:12:51,860
Dalam kes ini 12.

269
00:12:51,860 --> 00:12:55,300
>> Jadi, apabila kita dereference titik
ingat kita hanya melakukan perjalanan ke bawah anak panah.

270
00:12:55,300 --> 00:12:58,205
Atau meletakkan cara lain, kami
pergi ke alamat memori

271
00:12:58,205 --> 00:12:59,580
dan kami memanipulasi ia dalam beberapa cara.

272
00:12:59,580 --> 00:13:00,830
Kami meletakkan beberapa nilai di sana.

273
00:13:00,830 --> 00:13:03,960
Di bintang kes ini b
sama dengan m campur 2 sahaja

274
00:13:03,960 --> 00:13:08,230
pergi kepada pembolehubah yang ditunjukkan oleh b,
pergi kepada memori yang ditunjukkan oleh b,

275
00:13:08,230 --> 00:13:11,750
dan meletakkan m campur 2 di sana, 12.

276
00:13:11,750 --> 00:13:14,970
>> Sekarang saya membebaskan b.

277
00:13:14,970 --> 00:13:16,490
Apa yang berlaku apabila saya membebaskan b?

278
00:13:16,490 --> 00:13:18,800
Ingat apa yang saya katakan cara percuma.

279
00:13:18,800 --> 00:13:21,920
Apa yang saya katakan apabila saya membebaskan b?

280
00:13:21,920 --> 00:13:23,410
>> Saya selesai bekerja dengannya, bukan?

281
00:13:23,410 --> 00:13:25,702
Saya pada dasarnya melepaskan memori.

282
00:13:25,702 --> 00:13:26,910
Saya memberikan kembali kepada sistem.

283
00:13:26,910 --> 00:13:33,010
Saya tidak memerlukan ini lagi adalah
apa yang saya memberitahu mereka, OK?

284
00:13:33,010 --> 00:13:37,390
>> Sekarang jika saya katakan bintang
bersamaan 11 anda mungkin boleh

285
00:13:37,390 --> 00:13:40,460
telah memberitahu sesuatu yang tidak baik
yang akan berlaku di sini, bukan?

286
00:13:40,460 --> 00:13:44,160
Dan sesungguhnya jika saya cuba bahawa saya mungkin
akan mengalami kesalahan segmentasi.

287
00:13:44,160 --> 00:13:47,140
Kerana sekarang, walaupun
sebelum ini bahawa sebahagian memori

288
00:13:47,140 --> 00:13:50,220
adalah sesuatu yang saya mempunyai
akses kepada, pada ketika ini

289
00:13:50,220 --> 00:13:54,590
sekarang saya mengakses memori yang
bukan undang-undang bagi saya untuk mengakses.

290
00:13:54,590 --> 00:13:57,330
>> Dan seperti yang kita akan mungkin
ingat, apabila kita mengakses memori

291
00:13:57,330 --> 00:14:00,000
bahawa kita tidak sepatutnya menyentuh,
itulah punca yang paling biasa

292
00:14:00,000 --> 00:14:01,860
segmentasi yang
kesalahan. Dan supaya program saya

293
00:14:01,860 --> 00:14:05,170
akan berlanggar jika saya cuba untuk melakukan ini.

294
00:14:05,170 --> 00:14:09,910
Jadi sekali lagi ia adalah satu idea yang baik untuk mendapatkan yang baik
Tabiat amalan dan baik berakar umbi

295
00:14:09,910 --> 00:14:12,920
apabila bekerja dengan malloc dan bebas,
supaya anda tidak mengalami segmentasi

296
00:14:12,920 --> 00:14:15,310
kesalahan, dan yang anda gunakan
anda diperuntukkan secara dinamik

297
00:14:15,310 --> 00:14:17,370
memori bertanggungjawab.

298
00:14:17,370 --> 00:14:20,300
>> Saya Doug Lloyd ini adalah CS50.

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