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

2
00:00:00,499 --> 00:00:01,395
[MUSIC PLAYING]

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

4
00:00:05,590 --> 00:00:07,940
>> Doug LLOYD: OK jadi saran
sebelum mulai di sini.

5
00:00:07,940 --> 00:00:11,660
Jika Anda belum menonton video di
pointer Anda mungkin ingin melakukannya pertama.

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

7
00:00:15,860 --> 00:00:17,574
>> Jadi itu akan berbicara
tentang beberapa konsep

8
00:00:17,574 --> 00:00:19,490
bahwa kita menutupi dalam
pointer video, dan kami

9
00:00:19,490 --> 00:00:21,948
akan mengabaikan mereka sekarang,
dengan asumsi bahwa mereka sudah

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

11
00:00:23,090 --> 00:00:25,440
Jadi itu hanya adil peringatan Anda
bahwa jika Anda melihat video ini

12
00:00:25,440 --> 00:00:27,814
dan Anda belum melihat
pointer video, itu mungkin semacam

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 mungkin akan lebih baik
untuk menonton dalam urutan itu.

15
00:00:32,080 --> 00:00:34,710
>> Jadi kita telah melihat satu
cara untuk bekerja dengan pointer,

16
00:00:34,710 --> 00:00:37,810
yang kita mendeklarasikan
variabel, dan kemudian kita

17
00:00:37,810 --> 00:00:42,160
mendeklarasikan variabel lain, pointer
variabel, yang menunjuk ke itu.

18
00:00:42,160 --> 00:00:44,870
Jadi kami telah membuat
variabel dengan nama, kami sudah

19
00:00:44,870 --> 00:00:48,480
menciptakan variabel kedua dengan nama,
dan kami menunjukkan bahwa variabel kedua

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

21
00:00:50,220 --> 00:00:52,370
Ini semacam memiliki
masalah meskipun, karena

22
00:00:52,370 --> 00:00:54,650
mengharuskan kita untuk tahu persis
berapa banyak memori kami

23
00:00:54,650 --> 00:00:57,600
akan membutuhkan saat ini
program kami dikompilasi.

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

25
00:00:58,220 --> 00:01:03,338
Karena kita harus mampu untuk nama atau
mengidentifikasi semua variabel yang mungkin

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

27
00:01:04,129 --> 00:01:07,910
Kita mungkin memiliki sebuah array yang mungkin
mampu menahan banyak informasi,

28
00:01:07,910 --> 00:01:10,110
tapi masih tidak
persis cukup tepat.

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 kita harus pada waktu kompilasi?

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

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

33
00:01:19,810 --> 00:01:23,170
memperkirakan apakah kami
akan membutuhkan 1.000 unit?

34
00:01:23,170 --> 00:01:26,060
>> Ini tidak seperti yang kita bisa
mengatakan pada baris perintah

35
00:01:26,060 --> 00:01:28,040
masukkan berapa banyak item
Anda pikir Anda butuhkan.

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

37
00:01:31,100 --> 00:01:34,300
Alokasi memori dinamis
semacam memungkinkan kita jalan

38
00:01:34,300 --> 00:01:36,867
untuk mengatasi masalah khusus ini.

39
00:01:36,867 --> 00:01:38,700
Dan cara itu melakukannya
adalah dengan menggunakan pointer.

40
00:01:38,700 --> 00:01:42,140
>> Kita bisa menggunakan pointer ke
mendapatkan akses untuk secara dinamis

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

42
00:01:45,710 --> 00:01:48,290
Ini tidak dialokasikan pada waktu kompilasi.

43
00:01:48,290 --> 00:01:51,570
Ketika Anda secara dinamis mengalokasikan
memori itu berasal dari kolam renang

44
00:01:51,570 --> 00:01:53,795
memori yang dikenal sebagai tumpukan.

45
00:01:53,795 --> 00:01:56,420
Sebelumnya semua memori kita sudah
telah bekerja dengan di kursus

46
00:01:56,420 --> 00:01:59,920
telah datang dari kolam renang
memori yang dikenal sebagai stack.

47
00:01:59,920 --> 00:02:02,470
Cara yang baik untuk umum
tetap mind-- dan ini aturan

48
00:02:02,470 --> 00:02:04,720
tidak selalu berlaku,
tapi cukup banyak hampir

49
00:02:04,720 --> 00:02:09,940
selalu memegang true-- adalah bahwa setiap
kali Anda memberikan nama variabel itu

50
00:02:09,940 --> 00:02:12,090
mungkin hidup di stack.

51
00:02:12,090 --> 00:02:14,650
Dan setiap kali Anda tidak
memberi nama variabel,

52
00:02:14,650 --> 00:02:19,160
yang dapat Anda lakukan dengan memori dinamis
alokasi, ia hidup di heap.

53
00:02:19,160 --> 00:02:22,190
>> Sekarang aku jenis menyajikan ini sebagai
jika ada dua kolam memori.

54
00:02:22,190 --> 00:02:24,740
Tapi Anda mungkin telah melihat ini
diagram, yang umumnya

55
00:02:24,740 --> 00:02:27,290
representasi dari
apa yang tampak seperti memori,

56
00:02:27,290 --> 00:02:30,373
dan kami tidak akan peduli tentang semua
hal-hal di atas dan bawah.

57
00:02:30,373 --> 00:02:33,580
Apa yang kita pedulikan adalah bagian ini di
tengah di sini, tumpukan dan tumpukan.

58
00:02:33,580 --> 00:02:35,570
Seperti yang dapat Anda lihat dengan
melihat diagram ini,

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

60
00:02:38,390 --> 00:02:42,757
Itu salah satu kolam bersama memori
di mana Anda mulai, dalam hal ini visual yang

61
00:02:42,757 --> 00:02:44,590
Anda mulai di bagian bawah
dan mulai mengisi

62
00:02:44,590 --> 00:02:48,040
dari bawah dengan tumpukan, dan Anda
mulai dari atas dan mulai mengisi

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

64
00:02:50,072 --> 00:02:51,780
Tapi itu benar-benar adalah
kolam renang yang sama, hanya saja

65
00:02:51,780 --> 00:02:56,050
tempat yang berbeda, lokasi yang berbeda
dalam memori yang dialokasikan.

66
00:02:56,050 --> 00:02:59,060
Dan Anda dapat kehabisan
memori dengan baik memiliki

67
00:02:59,060 --> 00:03:01,240
tumpukan pergi semua jalan
ke bawah, atau memiliki

68
00:03:01,240 --> 00:03:05,440
stack pergi semua jalan ke atas,
atau memiliki tumpukan dan tumpukan

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

70
00:03:06,740 --> 00:03:09,500
Semua dari mereka dapat menjadi kondisi
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 ingatlah bahwa dalam pikiran.

73
00:03:11,952 --> 00:03:13,660
Ketika kita berbicara tentang
tumpukan dan tumpukan

74
00:03:13,660 --> 00:03:17,880
kita benar-benar berbicara tentang
sepotong umum yang sama dari memori, hanya

75
00:03:17,880 --> 00:03:21,930
bagian yang berbeda dari memori itu.

76
00:03:21,930 --> 00:03:24,910
>> Jadi bagaimana kita bisa secara dinamis
memori yang dialokasikan di tempat pertama?

77
00:03:24,910 --> 00:03:27,740
Bagaimana program kami mendapatkan
memori itu berjalan?

78
00:03:27,740 --> 00:03:32,660
Nah C menyediakan fungsi yang disebut
malloc, pengalokasi memori, yang

79
00:03:32,660 --> 00:03:36,810
Anda membuat panggilan ke, dan Anda lulus dalam
berapa banyak byte memori yang Anda inginkan.

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

81
00:03:39,940 --> 00:03:46,040
Anda mungkin Mallock empat byte
memori, malloc kurung empat.

82
00:03:46,040 --> 00:03:48,540
>> Mallock akan melalui
melihat melalui tumpukan,

83
00:03:48,540 --> 00:03:50,750
karena kita dinamis
mengalokasikan memori,

84
00:03:50,750 --> 00:03:53,500
dan akan kembali kepada Anda
pointer ke memori itu.

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

86
00:03:56,180 --> 00:03:57,950
memberikan Anda pointer untuk itu.

87
00:03:57,950 --> 00:04:00,780
Dan jadi itu sebabnya saya katakan lagi
bahwa penting untuk mungkin

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

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

90
00:04:05,940 --> 00:04:08,950
>> Jika Mallock tidak bisa memberikan apapun
memori karena Anda telah habis,

91
00:04:08,950 --> 00:04:10,645
itu akan memberi Anda kembali pointer null.

92
00:04:10,645 --> 00:04:15,282
Apakah Anda ingat apa yang terjadi jika kita
mencoba dan dereference pointer nol?

93
00:04:15,282 --> 00:04:17,019
Kita menderita kesalahan seg, kan?

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
untuk malloc Anda selalu, selalu

96
00:04:21,579 --> 00:04:25,270
perlu memeriksa apakah atau tidak
pointer itu memberi Anda kembali adalah null.

97
00:04:25,270 --> 00:04:28,800
Jika ya, Anda perlu untuk mengakhiri program Anda
karena jika Anda mencoba dan dereference

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

99
00:04:31,360 --> 00:04:34,380
dan program anda adalah
akan crash pula.

100
00:04:34,380 --> 00:04:37,190
Jadi bagaimana kita statis
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
beberapa kali, kan?

103
00:04:40,010 --> 00:04:43,480
Hal ini menciptakan sebuah variabel yang disebut
x yang hidup di stack.

104
00:04:43,480 --> 00:04:46,190
Bagaimana kita dinamis 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 tepat
kita akan mengatakan int bintang px

107
00:04:53,050 --> 00:04:57,680
sama dengan ukuran malloc dari int,
hanya untuk membuang beberapa lebih sedikit

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

109
00:04:59,740 --> 00:05:04,140
Ini akan memperoleh bagi kita
empat byte memori dari tumpukan,

110
00:05:04,140 --> 00:05:06,720
dan pointer kita mendapatkan
kembali ke itu disebut px.

111
00:05:06,720 --> 00:05:08,430
Dan kemudian hanya karena kami sudah
dilakukan sebelumnya kami

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

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

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

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

116
00:05:19,930 --> 00:05:24,030
Bagaimana jika kita ingin membuat sebuah array
dari x mengapung yang hidup di stack?

117
00:05:24,030 --> 00:05:28,210
mengapung stack_array-- itu nama
kami array-- kurung x.

118
00:05:28,210 --> 00:05:32,419
Yang akan menciptakan bagi kita sebuah array
dari x mengapung yang hidup di stack.

119
00:05:32,419 --> 00:05:34,960
Kita dapat membuat array mengapung
yang hidup di heap, juga.

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

121
00:05:37,330 --> 00:05:41,740
tapi kita dapat mengatakan mengapung
Bintang heap_array sama

122
00:05:41,740 --> 00:05:44,360
malloc x kali ukuran float.

123
00:05:44,360 --> 00:05:48,160
Saya perlu cukup ruang untuk menahan
x nilai floating point.

124
00:05:48,160 --> 00:05:51,560
Jadi mengatakan saya perlu 100
mengapung, atau 1.000 mengapung.

125
00:05:51,560 --> 00:05:54,810
Jadi dalam hal ini akan
400 byte untuk 100 mengapung,

126
00:05:54,810 --> 00:05:59,080
atau 4.000 byte untuk 1.000 mengapung,
karena setiap mengapung mengambil

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

128
00:06:01,230 --> 00:06:05,110
>> Setelah melakukan hal ini saya dapat menggunakan
sintaks braket persegi di heap_array.

129
00:06:05,110 --> 00:06:08,970
Sama seperti saya akan di stack_array, saya
dapat mengakses elemen individual

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

131
00:06:11,590 --> 00:06:15,800
Tapi ingat alasan kita bisa melakukan itu
adalah karena nama array di C

132
00:06:15,800 --> 00:06:19,990
benar-benar pointer ke
elemen pertama yang array.

133
00:06:19,990 --> 00:06:23,480
Sehingga fakta bahwa kita mendeklarasikan
array mengapung di stack sini

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

135
00:06:24,810 --> 00:06:27,600
Kami benar-benar berada di
baris kedua kode ada

136
00:06:27,600 --> 00:06:32,360
juga menciptakan pointer ke sepotong
memori yang kemudian kita melakukan beberapa pekerjaan dengan.

137
00:06:32,360 --> 00:06:35,620
>> Inilah masalah besar dengan
dialokasikan secara dinamis memori meskipun,

138
00:06:35,620 --> 00:06:38,360
dan ini adalah mengapa itu benar-benar
penting untuk mengembangkan beberapa kebiasaan yang baik

139
00:06:38,360 --> 00:06:39,800
ketika Anda bekerja dengan itu.

140
00:06:39,800 --> 00:06:43,060
Tidak seperti statis dideklarasikan
memori, memori Anda

141
00:06:43,060 --> 00:06:46,790
tidak secara otomatis kembali ke
sistem ketika fungsi Anda dilakukan.

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

143
00:06:49,280 --> 00:06:53,860
f, ketika f selesai apa yang dilakukannya
dan mengembalikan kontrol program

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

145
00:06:58,810 --> 00:07:01,250
Hal ini dapat digunakan lagi
oleh beberapa program lain,

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

147
00:07:04,250 --> 00:07:06,970
Hal ini dapat menggunakan memori yang sama lagi.

148
00:07:06,970 --> 00:07:09,620
>> Jika Anda secara dinamis
mengalokasikan memori meskipun

149
00:07:09,620 --> 00:07:14,380
Anda harus secara eksplisit memberitahu
sistem yang sedang Anda lakukan dengan itu.

150
00:07:14,380 --> 00:07:18,370
Ini akan terus ke atasnya untuk Anda, yang bisa
menyebabkan masalah Anda kehabisan

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

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

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

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

155
00:07:27,020 --> 00:07:31,120
>> Jika Anda adalah pengguna internet sering
Anda mungkin menggunakan web browser tertentu,

156
00:07:31,120 --> 00:07:35,630
dan saya tidak akan menyebut nama di sini, tapi
ada beberapa web browser di luar sana

157
00:07:35,630 --> 00:07:39,150
yang terkenal karena benar-benar memiliki
kebocoran memori yang tidak bisa diperbaiki.

158
00:07:39,150 --> 00:07:44,570
Dan jika Anda meninggalkan browser Anda terbuka
untuk jangka waktu yang sangat lama, hari

159
00:07:44,570 --> 00:07:48,060
dan hari, atau minggu, Anda kadang-kadang
mungkin melihat bahwa sistem Anda

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

161
00:07:49,790 --> 00:07:54,640
Dan alasan untuk itu adalah bahwa
browser telah mengalokasikan memori,

162
00:07:54,640 --> 00:07:57,320
tapi kemudian tidak mengatakan sistem
bahwa hal itu dilakukan dengan itu.

163
00:07:57,320 --> 00:08:01,000
Dan sehingga meninggalkan sedikit memori
tersedia untuk semua program Anda yang lain

164
00:08:01,000 --> 00:08:04,480
harus berbagi, karena Anda
leaking-- yang browser web

165
00:08:04,480 --> 00:08:06,755
Program bocor memori.

166
00:08:06,755 --> 00:08:08,880
Bagaimana kita memberikan memori kembali
ketika kita sudah selesai dengan itu?

167
00:08:08,880 --> 00:08:10,838
Nah untungnya itu adalah
cara yang sangat mudah untuk melakukannya.

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

169
00:08:11,710 --> 00:08:15,020
Ada fungsi yang disebut gratis,
ia menerima pointer ke memori,

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

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

172
00:08:18,310 --> 00:08:21,970
kami ingin malloc 50 karakter.

173
00:08:21,970 --> 00:08:25,710
Kami ingin malloc array yang dapat
mampu memegang 50 karakter.

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

175
00:08:29,109 --> 00:08:30,900
Kami melakukan apa kami
akan melakukan dengan kata,

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

177
00:08:33,440 --> 00:08:37,460
Dan sekarang kami telah kembali mereka 50
byte memori kembali ke sistem.

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

179
00:08:40,147 --> 00:08:43,480
Kami tidak perlu khawatir tentang menderita
kebocoran memori karena kita telah dibebaskan kata.

180
00:08:43,480 --> 00:08:46,639
Kami telah memberikan memori kembali,
jadi kita sudah selesai bekerja dengan itu.

181
00:08:46,639 --> 00:08:48,430
Jadi ada tiga
aturan emas yang seharusnya

182
00:08:48,430 --> 00:08:51,700
diingat setiap kali Anda
dinamis mengalokasikan 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 harus dibebaskan

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

186
00:08:58,430 --> 00:09:02,029
Sekarang lagi, dalam alat atau di
IDE ini semacam terjadi untuk Anda juga

187
00:09:02,029 --> 00:09:04,820
ketika you-- ini akan terjadi pula
ketika program Anda dihentikan,

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

189
00:09:06,880 --> 00:09:10,750
Tapi itu coding umumnya baik
praktek untuk selalu, ketika Anda sudah selesai,

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

191
00:09:13,810 --> 00:09:16,690
>> Yang mengatakan, hanya hal-hal yang
Anda sudah mallocd harus dibebaskan.

192
00:09:16,690 --> 00:09:19,880
Jika Anda statis mendeklarasikan
integer, int x semi-colon,

193
00:09:19,880 --> 00:09:23,500
yang hidup di stack, Anda
tidak kemudian ingin membebaskan x.

194
00:09:23,500 --> 00:09:25,970
Sehingga hanya hal-hal yang Anda sudah
mallocd harus dibebaskan.

195
00:09:25,970 --> 00:09:28,960
>> Dan terakhir, tidak sesuatu yang gratis dua kali.

196
00:09:28,960 --> 00:09:31,170
Yang dapat menyebabkan
situasi yang aneh lagi.

197
00:09:31,170 --> 00:09:33,530
Jadi segala sesuatu yang Anda sudah
mallocd harus dibebaskan.

198
00:09:33,530 --> 00:09:36,000
Hanya hal-hal yang Anda sudah
malloc harus dibebaskan.

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

200
00:09:38,730 --> 00:09:43,660
>> Jadi mari kita pergi melalui contoh di sini
dari apa yang beberapa dialokasikan secara dinamis

201
00:09:43,660 --> 00:09:46,122
memori mungkin terlihat seperti campuran
dengan beberapa memori statis.

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

203
00:09:47,080 --> 00:09:48,913
Lihat jika Anda dapat mengikuti
bersama dan menebak apa

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

205
00:09:51,720 --> 00:09:53,980
>> Jadi kita katakan int m.

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

207
00:09:54,840 --> 00:09:56,339
Nah ini cukup sederhana.

208
00:09:56,339 --> 00:09:59,650
Saya membuat sebuah variabel integer disebut m.

209
00:09:59,650 --> 00:10:01,400
Aku warna hijau,
karena itulah warna

210
00:10:01,400 --> 00:10:03,730
yang saya gunakan ketika saya sedang berbicara
tentang variabel integer.

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

212
00:10:05,160 --> 00:10:08,400
Ini disebut m, dan Anda dapat
toko bilangan bulat di dalamnya.

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

214
00:10:12,400 --> 00:10:13,530
Nah itu sangat mirip.

215
00:10:13,530 --> 00:10:15,780
Aku menciptakan sebuah kotak yang disebut.

216
00:10:15,780 --> 00:10:19,100
Ini mampu memegang int
bintang, pointer ke bilangan bulat.

217
00:10:19,100 --> 00:10:21,570
Jadi aku mewarnai hijau-ish juga.

218
00:10:21,570 --> 00:10:24,140
>> Aku tahu itu ada
hubungannya dengan integer,

219
00:10:24,140 --> 00:10:25,852
tapi itu tidak sendiri integer.

220
00:10:25,852 --> 00:10:27,310
Tapi itu cukup banyak ide 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 hak ini
sekarang tinggal di stack.

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

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

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

226
00:10:38,560 --> 00:10:44,110
Mengambil kedua dan berpikir tentang apa yang Anda
harapkan terjadi pada diagram ini.

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

228
00:10:50,210 --> 00:10:51,940
>> Nah ini tidak hanya membuat satu kotak.

229
00:10:51,940 --> 00:10:53,800
Ini benar-benar menciptakan dua kotak.

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

231
00:10:58,670 --> 00:11:02,240
Kami telah dialokasikan satu blok
memori di heap.

232
00:11:02,240 --> 00:11:05,940
Perhatikan bahwa kotak kanan atas
ada tidak memiliki nama.

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

234
00:11:06,760 --> 00:11:08,050
Ini ada di heap.

235
00:11:08,050 --> 00:11:10,090
Tapi b memiliki nama.

236
00:11:10,090 --> 00:11:11,950
Ini adalah variabel pointer yang disebut b.

237
00:11:11,950 --> 00:11:13,910
Yang hidup di stack.

238
00:11:13,910 --> 00:11:18,250
>> Jadi itu bagian dari memori
yang menunjuk ke satu sama lain.

239
00:11:18,250 --> 00:11:21,840
b berisi alamat
dari blok memori.

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

241
00:11:23,757 --> 00:11:24,590
Tapi itu menunjukkan untuk itu.

242
00:11:24,590 --> 00:11:29,760
Jadi ketika kita mengatakan int bintang b sama
Ukuran malloc dari int, bahwa di sana,

243
00:11:29,760 --> 00:11:33,490
bahwa panah yang muncul pada
sisi kanan ada, yang semuanya,

244
00:11:33,490 --> 00:11:36,740
Aku akan tampak
lagi, adalah apa yang terjadi.

245
00:11:36,740 --> 00:11:39,341
Semua itu terjadi di
bahwa baris kode.

246
00:11:39,341 --> 00:11:41,340
Sekarang kita akan mendapatkan sedikit lebih
mudah lagi.

247
00:11:41,340 --> 00:11:43,330
a sama dengan ampersand m.

248
00:11:43,330 --> 00:11:46,280
Apakah Anda ingat apa
sama dengan ampersand m adalah?

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

250
00:11:48,920 --> 00:11:54,150
Atau menempatkan lebih diagram,
poin untuk m.

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

252
00:11:56,360 --> 00:11:57,560
OK jadi inilah satu lagi.

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

254
00:11:59,230 --> 00:12:02,260
Apa yang akan terjadi
diagram kali ini?

255
00:12:02,260 --> 00:12:04,330
>> Nah ingat bahwa
karya operator penugasan

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

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

258
00:12:14,820 --> 00:12:18,900
a tidak menunjuk ke b, a
menunjukkan di mana b poin.

259
00:12:18,900 --> 00:12:25,280
>> Jika menunjuk ke b yang akan
telah sama ampersand b.

260
00:12:25,280 --> 00:12:28,150
Tapi bukan sama b hanya
berarti dan b sekarang

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

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

263
00:12:35,004 --> 00:12:37,170
m sama dengan 10, mungkin
kebanyakan hal sederhana

264
00:12:37,170 --> 00:12:38,690
kami lakukan di sedikit.

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

266
00:12:40,460 --> 00:12:45,640
Bintang b sama dengan m ditambah 2, ingat dari
pointer video kami star apa b berarti.

267
00:12:45,640 --> 00:12:50,230
Kita akan dereference b dan put
beberapa nilai di lokasi memori.

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

269
00:12:51,860 --> 00:12:55,300
>> Jadi ketika kita dereference titik
mengingat kami hanya melakukan perjalanan ke panah.

270
00:12:55,300 --> 00:12:58,205
Atau dengan kata lain, kita
pergi ke alamat memori

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

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

273
00:13:00,830 --> 00:13:03,960
Dalam hal ini bintang b
sama m ditambah 2 hanya

274
00:13:03,960 --> 00:13:08,230
pergi ke variabel yang ditunjuk oleh b,
pergi ke memori yang ditunjuk oleh b,

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

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

277
00:13:14,970 --> 00:13:16,490
Apa yang terjadi ketika saya bebas b?

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

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

280
00:13:21,920 --> 00:13:23,410
>> Aku sudah selesai bekerja dengan itu, kan?

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

282
00:13:25,702 --> 00:13:26,910
Aku memberikannya kembali ke sistem.

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

284
00:13:33,010 --> 00:13:37,390
>> Sekarang jika saya mengatakan bintang
sama 11 mungkin Anda dapat

285
00:13:37,390 --> 00:13:40,460
sudah mengatakan bahwa sesuatu yang buruk
yang akan terjadi di sini, kan?

286
00:13:40,460 --> 00:13:44,160
Dan memang jika saya mencoba bahwa saya mungkin
akan menderita kesalahan segmentasi.

287
00:13:44,160 --> 00:13:47,140
Karena sekarang, meskipun
sebelumnya bahwa sepotong memori

288
00:13:47,140 --> 00:13:50,220
adalah sesuatu yang saya punya
akses ke, pada titik ini

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

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

291
00:13:57,330 --> 00:14:00,000
bahwa kita tidak seharusnya menyentuh,
itulah penyebab paling umum

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

293
00:14:01,860 --> 00:14:05,170
akan crash jika saya mencoba untuk melakukan hal ini.

294
00:14:05,170 --> 00:14:09,910
Jadi sekali lagi itu adalah ide yang baik untuk mendapatkan yang baik
praktek dan kebiasaan yang baik tertanam

295
00:14:09,910 --> 00:14:12,920
ketika bekerja dengan malloc dan bebas,
sehingga Anda tidak menderita segmentasi

296
00:14:12,920 --> 00:14:15,310
kesalahan, dan bahwa Anda menggunakan
Anda dialokasikan secara dinamis

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

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

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