1
00:00:00,000 --> 00:00:06,030
>> [MUSIC PLAYING]

2
00:00:06,030 --> 00:00:08,390
>> Doug LLOYD: Pointer, di sini kita.

3
00:00:08,390 --> 00:00:11,080
Ini mungkin akan
menjadi topik yang paling sulit

4
00:00:11,080 --> 00:00:12,840
yang kita bicarakan di CS50.

5
00:00:12,840 --> 00:00:15,060
Dan jika Anda sudah membaca
apa-apa tentang pointer

6
00:00:15,060 --> 00:00:19,080
sebelum Anda mungkin sedikit
mengintimidasi masuk ke video ini.

7
00:00:19,080 --> 00:00:21,260
Memang benar pointer
mengijinkan Anda kemampuan

8
00:00:21,260 --> 00:00:23,740
untuk mungkin mengacaukan
cukup parah ketika Anda

9
00:00:23,740 --> 00:00:27,450
bekerja dengan variabel, dan data,
dan menyebabkan program anda crash.

10
00:00:27,450 --> 00:00:30,490
Tapi mereka sebenarnya sangat berguna
dan mereka memungkinkan kita cara yang hebat

11
00:00:30,490 --> 00:00:33,340
untuk lulus data bolak-
balik antara fungsi,

12
00:00:33,340 --> 00:00:35,490
bahwa kita dinyatakan tidak dapat dilakukan.

13
00:00:35,490 --> 00:00:37,750
>> Dan jadi apa kita benar-benar
ingin lakukan di sini adalah kereta

14
00:00:37,750 --> 00:00:41,060
Anda untuk memiliki disiplin pointer yang baik, sehingga
Anda dapat menggunakan pointer secara efektif

15
00:00:41,060 --> 00:00:43,850
untuk membuat program Anda yang jauh lebih baik.

16
00:00:43,850 --> 00:00:48,220
Seperti yang saya katakan pointer memberi kita berbeda
cara untuk melewatkan data antara fungsi.

17
00:00:48,220 --> 00:00:50,270
Sekarang jika Anda ingat dari
video sebelumnya, ketika

18
00:00:50,270 --> 00:00:53,720
kami berbicara tentang
lingkup variabel, saya sebutkan

19
00:00:53,720 --> 00:01:00,610
bahwa semua data yang melewati antara kita
fungsi dalam C dilewatkan oleh nilai.

20
00:01:00,610 --> 00:01:03,070
Dan saya mungkin tidak digunakan yang
Istilah, apa yang saya berarti ada

21
00:01:03,070 --> 00:01:07,170
adalah bahwa kita melewati salinan data.

22
00:01:07,170 --> 00:01:12,252
Ketika kami melewati sebuah variabel ke fungsi,
kita tidak benar-benar melewati variabel

23
00:01:12,252 --> 00:01:13,210
ke fungsi, kan?

24
00:01:13,210 --> 00:01:17,670
Kami melewati salinan
bahwa data ke fungsi.

25
00:01:17,670 --> 00:01:20,760
Fungsi melakukan apa yang akan
dan menghitung beberapa nilai,

26
00:01:20,760 --> 00:01:23,180
dan mungkin kita menggunakan nilai yang
ketika memberikan kembali.

27
00:01:23,180 --> 00:01:26,700
>> Ada satu pengecualian untuk
Aturan ini lewat nilai,

28
00:01:26,700 --> 00:01:31,210
dan kami akan kembali ke apa yang
adalah sedikit kemudian di dalam video ini.

29
00:01:31,210 --> 00:01:34,880
Jika kita menggunakan pointer bukan
menggunakan variabel,

30
00:01:34,880 --> 00:01:38,180
atau bukan menggunakan variabel
sendiri atau salinan dari variabel,

31
00:01:38,180 --> 00:01:43,790
kita sekarang dapat melewati variabel sekitar
antara fungsi dengan cara yang berbeda.

32
00:01:43,790 --> 00:01:46,550
Ini berarti bahwa jika kita membuat
perubahan dalam satu fungsi,

33
00:01:46,550 --> 00:01:49,827
perubahan yang benar-benar akan mengambil
efek dalam fungsi yang berbeda.

34
00:01:49,827 --> 00:01:52,160
Sekali lagi, ini adalah sesuatu yang
kita tidak bisa melakukan sebelumnya,

35
00:01:52,160 --> 00:01:56,979
dan jika Anda pernah mencoba untuk menukar
nilai dua variabel dalam suatu fungsi,

36
00:01:56,979 --> 00:01:59,270
Anda telah memperhatikan masalah ini
semacam merangkak naik, kan?

37
00:01:59,270 --> 00:02:04,340
>> Jika kita ingin menukar X dan Y, dan kami
melewati mereka untuk fungsi yang disebut swap,

38
00:02:04,340 --> 00:02:08,680
dalam fungsi swap
variabel melakukan nilai tukar.

39
00:02:08,680 --> 00:02:12,600
Satu menjadi dua, dua menjadi
satu, tapi kami tidak benar-benar

40
00:02:12,600 --> 00:02:16,890
mengubah apa pun dalam bahasa aslinya
fungsi, di pemanggil.

41
00:02:16,890 --> 00:02:19,550
Karena kita tidak bisa, kami hanya
bekerja dengan salinan dari mereka.

42
00:02:19,550 --> 00:02:24,760
Dengan pointer meskipun, kita bisa
benar-benar lulus X dan Y ke fungsi.

43
00:02:24,760 --> 00:02:26,960
Fungsi yang dapat melakukan
sesuatu dengan mereka.

44
00:02:26,960 --> 00:02:29,250
Dan nilai-nilai variabel
benar-benar dapat mengubah.

45
00:02:29,250 --> 00:02:33,710
Jadi itu cukup perubahan
kemampuan kita untuk bekerja dengan data.

46
00:02:33,710 --> 00:02:36,100
>> Sebelum kita menyelam ke
pointer, saya pikir itu layak

47
00:02:36,100 --> 00:02:38,580
mengambil beberapa menit untuk
kembali ke dasar di sini.

48
00:02:38,580 --> 00:02:41,000
Dan kita lihat bagaimana
karya memori komputer

49
00:02:41,000 --> 00:02:45,340
karena dua mata pelajaran ini akan
untuk benar-benar cukup saling terkait.

50
00:02:45,340 --> 00:02:48,480
Seperti Anda mungkin tahu,
pada sistem komputer Anda

51
00:02:48,480 --> 00:02:51,310
Anda memiliki hard drive atau
mungkin solid state drive,

52
00:02:51,310 --> 00:02:54,430
semacam lokasi penyimpanan file.

53
00:02:54,430 --> 00:02:57,950
Ini biasanya di suatu tempat di
lingkungan 250 gigabyte

54
00:02:57,950 --> 00:02:59,810
untuk mungkin beberapa terabyte sekarang.

55
00:02:59,810 --> 00:03:02,270
Dan itu di mana semua Anda
file akhirnya hidup,

56
00:03:02,270 --> 00:03:04,870
bahkan ketika komputer Anda menutup
off, Anda dapat mengubahnya kembali

57
00:03:04,870 --> 00:03:09,190
dan Anda akan menemukan file Anda yang ada
lagi ketika Anda reboot sistem anda.

58
00:03:09,190 --> 00:03:14,820
Tapi disk drive, seperti hard disk drive,
HDD, atau solid state drive, SSD,

59
00:03:14,820 --> 00:03:16,050
adalah ruang penyimpanan hanya.

60
00:03:16,050 --> 00:03:20,400
>> Kita tidak bisa benar-benar melakukan apa-apa dengan
data yang ada di hard disk,

61
00:03:20,400 --> 00:03:22,080
atau solid state drive.

62
00:03:22,080 --> 00:03:24,950
Dalam rangka untuk benar-benar mengubah
data atau bergerak di sekitar,

63
00:03:24,950 --> 00:03:28,800
kita harus memindahkannya ke
RAM, random access memory.

64
00:03:28,800 --> 00:03:31,170
Sekarang RAM, Anda memiliki banyak
kurang dari di komputer Anda.

65
00:03:31,170 --> 00:03:34,185
Anda mungkin memiliki suatu tempat di
lingkungan 512 megabyte

66
00:03:34,185 --> 00:03:38,850
jika Anda memiliki komputer lama,
untuk mungkin dua, empat, delapan, 16,

67
00:03:38,850 --> 00:03:41,820
bahkan mungkin sedikit
lebih, gigabyte RAM.

68
00:03:41,820 --> 00:03:46,390
Jadi itu jauh lebih kecil, tapi itu
di mana semua data volatile ada.

69
00:03:46,390 --> 00:03:48,270
Di situlah kita bisa mengubah keadaan.

70
00:03:48,270 --> 00:03:53,350
Tetapi ketika kita menyalakan komputer kita off,
semua data di RAM hancur.

71
00:03:53,350 --> 00:03:57,150
>> Jadi itu sebabnya kita perlu memiliki hard disk
untuk lokasi yang lebih permanen itu,

72
00:03:57,150 --> 00:03:59,720
sehingga exists- itu akan
benar-benar buruk jika setiap kali kita

73
00:03:59,720 --> 00:04:03,310
berbalik komputer kita off, setiap
file dalam sistem kami dilenyapkan.

74
00:04:03,310 --> 00:04:05,600
Jadi kita bekerja di dalam RAM.

75
00:04:05,600 --> 00:04:09,210
Dan setiap kali kita berbicara tentang
memori, cukup banyak, di CS50,

76
00:04:09,210 --> 00:04:15,080
kita sedang berbicara tentang RAM, hard disk tidak.

77
00:04:15,080 --> 00:04:18,657
>> Jadi ketika kita memindahkan barang-barang ke dalam memori,
tidak memakan sejumlah ruang.

78
00:04:18,657 --> 00:04:20,740
Semua jenis data yang
kami telah bekerja dengan

79
00:04:20,740 --> 00:04:23,480
mengambil yang berbeda
jumlah ruang di RAM.

80
00:04:23,480 --> 00:04:27,600
Jadi setiap kali Anda membuat sebuah integer
variabel, empat byte memori

81
00:04:27,600 --> 00:04:30,750
disisihkan dalam RAM sehingga Anda
dapat bekerja dengan bilangan bulat itu.

82
00:04:30,750 --> 00:04:34,260
Anda dapat mendeklarasikan integer,
mengubahnya, menetapkan

83
00:04:34,260 --> 00:04:36,700
untuk nilai 10 bertambah
persatu, seterusnya dan seterusnya.

84
00:04:36,700 --> 00:04:39,440
Semua yang perlu terjadi di
RAM, dan Anda mendapatkan empat byte

85
00:04:39,440 --> 00:04:42,550
untuk bekerja dengan untuk setiap
integer yang Anda buat.

86
00:04:42,550 --> 00:04:45,410
>> Setiap karakter Anda
buat mendapat satu byte.

87
00:04:45,410 --> 00:04:48,160
Itu hanya berapa banyak ruang adalah
dibutuhkan untuk menyimpan karakter.

88
00:04:48,160 --> 00:04:51,310
Setiap float, nyata
nomor, mendapat empat byte

89
00:04:51,310 --> 00:04:53,390
kecuali itu adalah ganda
presisi floating point

90
00:04:53,390 --> 00:04:56,510
nomor, yang memungkinkan Anda untuk
memiliki lebih tepat atau lebih digit

91
00:04:56,510 --> 00:04:59,300
setelah titik desimal
tanpa kehilangan presisi,

92
00:04:59,300 --> 00:05:01,820
yang mengambil delapan byte memori.

93
00:05:01,820 --> 00:05:06,730
Rindu lama, bilangan bulat yang sangat besar,
juga mengambil delapan byte memori.

94
00:05:06,730 --> 00:05:09,000
Berapa banyak byte memori
jangan string mengambil?

95
00:05:09,000 --> 00:05:12,990
Nah mari kita menempatkan pin dalam pertanyaan yang
untuk saat ini, tapi kami akan kembali ke sana.

96
00:05:12,990 --> 00:05:17,350
>> Jadi kembali ke ide ini dari memori
array besar sel byte berukuran.

97
00:05:17,350 --> 00:05:20,871
Itu benar-benar semua itu, itu
hanya array besar sel,

98
00:05:20,871 --> 00:05:23,370
sama seperti array lain yang
Anda akrab dengan dan melihat,

99
00:05:23,370 --> 00:05:26,430
kecuali setiap elemen adalah satu byte lebar.

100
00:05:26,430 --> 00:05:30,030
Dan seperti sebuah array,
setiap elemen memiliki alamat.

101
00:05:30,030 --> 00:05:32,120
Setiap elemen array
memiliki indeks, dan kami

102
00:05:32,120 --> 00:05:36,302
dapat menggunakan indeks yang melakukan disebut
akses acak pada array.

103
00:05:36,302 --> 00:05:38,510
Kami tidak perlu mulai dari
awal array,

104
00:05:38,510 --> 00:05:40,569
iterate melalui setiap
elemen tunggal daripadanya,

105
00:05:40,569 --> 00:05:41,860
untuk menemukan apa yang kita cari.

106
00:05:41,860 --> 00:05:45,790
Kami hanya bisa mengatakan, saya ingin sampai ke
Unsur 15 atau elemen 100.

107
00:05:45,790 --> 00:05:49,930
Dan Anda hanya bisa lewat di nomor yang
dan mendapatkan nilai yang Anda cari.

108
00:05:49,930 --> 00:05:54,460
>> Demikian pula setiap lokasi
dalam memori memiliki alamat.

109
00:05:54,460 --> 00:05:57,320
Jadi memori Anda mungkin
terlihat seperti ini.

110
00:05:57,320 --> 00:06:01,420
Berikut adalah potongan yang sangat kecil dari
memori, ini adalah 20 byte memori.

111
00:06:01,420 --> 00:06:04,060
Pertama 20 byte karena saya
alamat ada di bagian bawah

112
00:06:04,060 --> 00:06:08,890
adalah 0, 1, 2, 3, dan sebagainya
pada semua jalan sampai ke 19.

113
00:06:08,890 --> 00:06:13,190
Dan ketika saya mendeklarasikan variabel dan
ketika saya mulai bekerja dengan mereka,

114
00:06:13,190 --> 00:06:15,470
sistem akan mengatur
selain beberapa ruang untuk saya

115
00:06:15,470 --> 00:06:17,595
dalam memori ini bekerja
dengan variabel saya.

116
00:06:17,595 --> 00:06:21,610
Jadi saya mungkin mengatakan, char c sama modal
H. Dan apa yang akan terjadi?

117
00:06:21,610 --> 00:06:23,880
Nah sistem ini akan
disisihkan untuk saya satu byte.

118
00:06:23,880 --> 00:06:27,870
Dalam hal ini memilih nomor byte
empat, byte di alamat empat,

119
00:06:27,870 --> 00:06:31,310
dan itu akan menyimpan
H modal huruf di sana bagi saya.

120
00:06:31,310 --> 00:06:34,350
Jika saya kemudian mengatakan kecepatan int
batas sama 65, itu

121
00:06:34,350 --> 00:06:36,806
akan menyisihkan empat
byte memori untuk saya.

122
00:06:36,806 --> 00:06:39,180
Dan itu akan memperlakukan mereka
empat byte sebagai satu kesatuan

123
00:06:39,180 --> 00:06:41,305
karena apa yang kita bekerja
dengan adalah bilangan bulat di sini.

124
00:06:41,305 --> 00:06:44,350
Dan itu akan menyimpan 65 di sana.

125
00:06:44,350 --> 00:06:47,000
>> Sekarang sudah aku agak
memberitahu Anda sedikit kebohongan,

126
00:06:47,000 --> 00:06:50,150
benar, karena kita tahu bahwa
komputer bekerja dalam biner.

127
00:06:50,150 --> 00:06:53,100
Mereka tidak mengerti
tentu apa H modal

128
00:06:53,100 --> 00:06:57,110
atau apa 65 adalah, mereka hanya
memahami biner, nol dan satu.

129
00:06:57,110 --> 00:06:59,000
Dan sebenarnya apa
kita menyimpan di sana

130
00:06:59,000 --> 00:07:03,450
bukan huruf H dan nomor 65,
melainkan representasi biner

131
00:07:03,450 --> 00:07:06,980
daripadanya, yang terlihat
sedikit sesuatu seperti ini.

132
00:07:06,980 --> 00:07:10,360
Dan khususnya dalam
konteks variabel integer,

133
00:07:10,360 --> 00:07:13,559
itu tidak akan hanya meludah ke dalam,
itu tidak akan memperlakukannya sebagai salah satu empat

134
00:07:13,559 --> 00:07:15,350
byte potongan tentu,
itu benar-benar akan

135
00:07:15,350 --> 00:07:19,570
memperlakukannya sebagai empat satu potongan byte,
yang mungkin terlihat seperti ini.

136
00:07:19,570 --> 00:07:22,424
Dan bahkan ini tidak
sepenuhnya benar baik,

137
00:07:22,424 --> 00:07:24,840
karena sesuatu yang disebut
sebuah endianness, yang kita tidak

138
00:07:24,840 --> 00:07:26,965
akan masuk ke dalam sekarang, tapi
jika Anda ingin tahu tentang,

139
00:07:26,965 --> 00:07:29,030
Anda dapat membaca tentang sedikit
dan endianness besar.

140
00:07:29,030 --> 00:07:31,640
Tapi demi argumen ini,
demi video ini,

141
00:07:31,640 --> 00:07:34,860
mari kita berasumsi bahwa, dalam
Bahkan, bagaimana jumlah 65 akan

142
00:07:34,860 --> 00:07:36,970
direpresentasikan dalam
memori pada setiap sistem,

143
00:07:36,970 --> 00:07:38,850
meskipun tidak sepenuhnya benar.

144
00:07:38,850 --> 00:07:41,700
>> Tapi mari kita sebenarnya hanya mendapatkan
menyingkirkan semua biner seluruhnya,

145
00:07:41,700 --> 00:07:44,460
dan hanya berpikir tentang dengan H
dan 65, itu jauh lebih mudah

146
00:07:44,460 --> 00:07:47,900
untuk berpikir tentang hal seperti
bahwa sebagai manusia.

147
00:07:47,900 --> 00:07:51,420
Baiklah, sehingga juga tampaknya mungkin
sedikit acak yang I've- sistem saya

148
00:07:51,420 --> 00:07:55,130
tidak memberi saya bytes 5, 6, 7,
dan 8 untuk menyimpan integer.

149
00:07:55,130 --> 00:07:58,580
Ada alasan untuk itu, juga, yang
kita tidak akan masuk ke dalam sekarang, tapi cukup

150
00:07:58,580 --> 00:08:00,496
untuk mengatakan bahwa apa yang
komputer lakukan di sini

151
00:08:00,496 --> 00:08:02,810
mungkin langkah yang baik pada bagian.

152
00:08:02,810 --> 00:08:06,020
Untuk tidak memberikan saya memori itu
tentu kembali ke belakang.

153
00:08:06,020 --> 00:08:10,490
Meskipun akan melakukannya sekarang
jika saya ingin mendapatkan string lain,

154
00:08:10,490 --> 00:08:13,080
disebut nama, dan saya ingin
untuk menempatkan Lloyd di sana.

155
00:08:13,080 --> 00:08:18,360
Aku akan perlu untuk cocok satu
karakter, setiap huruf dari itu

156
00:08:18,360 --> 00:08:21,330
akan memerlukan satu
karakter, satu byte memori.

157
00:08:21,330 --> 00:08:26,230
Jadi jika saya bisa menempatkan Lloyd ke array saya
seperti ini aku cukup baik untuk pergi, kan?

158
00:08:26,230 --> 00:08:28,870
Apa yang hilang?

159
00:08:28,870 --> 00:08:31,840
>> Ingat bahwa setiap string yang kita bekerja
dengan di C berakhir dengan backslash nol,

160
00:08:31,840 --> 00:08:33,339
dan kita tidak bisa menghilangkan itu di sini, baik.

161
00:08:33,339 --> 00:08:36,090
Kita perlu untuk menyisihkan satu byte
memori untuk menahan itu jadi kami

162
00:08:36,090 --> 00:08:39,130
tahu kapan string kita telah berakhir.

163
00:08:39,130 --> 00:08:41,049
Jadi sekali lagi pengaturan ini
dari cara hal-hal

164
00:08:41,049 --> 00:08:42,799
muncul dalam kekuatan memori
sedikit acak,

165
00:08:42,799 --> 00:08:44,870
tetapi sebenarnya adalah bagaimana
kebanyakan sistem yang dirancang.

166
00:08:44,870 --> 00:08:48,330
Garis mereka pada kelipatan
empat, untuk alasan lagi

167
00:08:48,330 --> 00:08:50,080
bahwa kita tidak perlu
masuk ke dalam sekarang.

168
00:08:50,080 --> 00:08:53,060
Tapi ini, sehingga cukup untuk mengatakan bahwa
setelah tiga baris kode,

169
00:08:53,060 --> 00:08:54,810
ini adalah apa memori mungkin terlihat seperti.

170
00:08:54,810 --> 00:08:58,930
Jika saya perlu lokasi memori
4, 8, dan 12 untuk menyimpan data saya,

171
00:08:58,930 --> 00:09:01,100
ini adalah apa ingatan saya mungkin terlihat seperti.

172
00:09:01,100 --> 00:09:04,062
>> Dan hanya menjadi sangat
bertele-tele di sini, ketika

173
00:09:04,062 --> 00:09:06,020
kita sedang berbicara tentang memori
alamat kita biasanya

174
00:09:06,020 --> 00:09:08,390
melakukannya dengan menggunakan notasi heksadesimal.

175
00:09:08,390 --> 00:09:12,030
Jadi kenapa tidak kita mengubah semua ini
dari desimal ke notasi heksadesimal

176
00:09:12,030 --> 00:09:15,010
hanya karena itu umumnya
bagaimana kita mengacu pada memori.

177
00:09:15,010 --> 00:09:17,880
Jadi bukannya 0 melalui
19, apa yang kita miliki adalah nol

178
00:09:17,880 --> 00:09:20,340
x nol nol melalui x1 tiga.

179
00:09:20,340 --> 00:09:23,790
Mereka adalah 20 byte memori yang kita
telah atau kita sedang melihat di gambar ini

180
00:09:23,790 --> 00:09:25,540
disini.

181
00:09:25,540 --> 00:09:29,310
>> Jadi semua itu dikatakan, mari kita
menjauh dari memori untuk kedua

182
00:09:29,310 --> 00:09:30,490
dan kembali ke pointer.

183
00:09:30,490 --> 00:09:32,420
Berikut adalah yang paling penting
hal yang perlu diingat

184
00:09:32,420 --> 00:09:34,070
seperti yang kita mulai bekerja dengan pointer.

185
00:09:34,070 --> 00:09:36,314
Sebuah pointer ada
lebih dari sebuah alamat.

186
00:09:36,314 --> 00:09:38,230
Aku akan mengatakannya lagi karena
itu yang penting,

187
00:09:38,230 --> 00:09:42,730
pointer ada
lebih dari sebuah alamat.

188
00:09:42,730 --> 00:09:47,760
Pointer alamat untuk lokasi
dalam memori di mana variabel hidup.

189
00:09:47,760 --> 00:09:52,590
Mengetahui bahwa itu menjadi mudah-mudahan
sedikit lebih mudah untuk bekerja dengan mereka.

190
00:09:52,590 --> 00:09:54,550
Hal lain yang saya suka
lakukan adalah untuk memiliki semacam

191
00:09:54,550 --> 00:09:58,510
diagram visual yang mewakili apa
terjadi dengan berbagai baris kode.

192
00:09:58,510 --> 00:10:00,660
Dan kami akan melakukan ini beberapa
kali di pointer,

193
00:10:00,660 --> 00:10:03,354
dan ketika kita berbicara tentang dinamis
alokasi memori juga.

194
00:10:03,354 --> 00:10:06,020
Karena saya berpikir bahwa diagram ini
dapat sangat membantu.

195
00:10:06,020 --> 00:10:09,540
>> Jadi jika saya mengatakan misalnya, int k
dalam kode saya, apa yang terjadi?

196
00:10:09,540 --> 00:10:12,524
Nah apa yang pada dasarnya terjadi adalah
Saya mendapatkan memori disisihkan untuk saya,

197
00:10:12,524 --> 00:10:14,690
tapi aku bahkan tidak suka
berpikir tentang hal seperti itu, saya

198
00:10:14,690 --> 00:10:16,300
suka berpikir tentang hal itu seperti sebuah kotak.

199
00:10:16,300 --> 00:10:20,090
Saya memiliki sebuah kotak dan itu
berwarna hijau karena saya

200
00:10:20,090 --> 00:10:21,750
dapat menempatkan bilangan bulat di kotak hijau.

201
00:10:21,750 --> 00:10:23,666
Jika itu adalah karakter saya
mungkin memiliki kotak biru.

202
00:10:23,666 --> 00:10:27,290
Tapi saya selalu mengatakan, jika saya membuat
kotak yang dapat menampung bilangan bulat

203
00:10:27,290 --> 00:10:28,950
kotak yang berwarna hijau.

204
00:10:28,950 --> 00:10:33,020
Dan aku mengambil spidol permanen
dan saya menulis k di sisi itu.

205
00:10:33,020 --> 00:10:37,590
Jadi saya memiliki kotak disebut k,
di mana saya dapat menempatkan bilangan bulat.

206
00:10:37,590 --> 00:10:41,070
Jadi ketika saya mengatakan int k, yang
apa yang terjadi di kepala saya.

207
00:10:41,070 --> 00:10:43,140
Jika saya mengatakan k sama dengan lima, apa yang saya lakukan?

208
00:10:43,140 --> 00:10:45,110
Yah, aku menempatkan lima
dalam kotak, yang tepat.

209
00:10:45,110 --> 00:10:48,670
Ini cukup sederhana, jika
Saya mengatakan int k, membuat kotak disebut k.

210
00:10:48,670 --> 00:10:52,040
Jika saya mengatakan k sama dengan 5,
menempatkan lima ke dalam kotak.

211
00:10:52,040 --> 00:10:53,865
Mudah-mudahan itu tidak terlalu banyak lompatan.

212
00:10:53,865 --> 00:10:55,990
Di sinilah hal-hal pergi
sedikit menarik meskipun.

213
00:10:55,990 --> 00:11:02,590
Jika saya mengatakan int * pk, baik bahkan jika saya tidak melakukan
tahu apa ini tentu berarti,

214
00:11:02,590 --> 00:11:06,150
itu jelas punya sesuatu
hubungannya dengan integer.

215
00:11:06,150 --> 00:11:08,211
Jadi aku akan mewarnai
kotak ini hijau-ish,

216
00:11:08,211 --> 00:11:10,210
Aku tahu itu punya sesuatu
hubungannya dengan integer,

217
00:11:10,210 --> 00:11:13,400
tapi itu bukan integer sendiri,
karena itu adalah bintang int.

218
00:11:13,400 --> 00:11:15,390
Ada sesuatu yang sedikit
yang berbeda tentang hal itu.

219
00:11:15,390 --> 00:11:17,620
Jadi integer yang terlibat,
tapi selain itu

220
00:11:17,620 --> 00:11:19,830
tidak terlalu berbeda dari
apa yang kita bicarakan.

221
00:11:19,830 --> 00:11:24,240
Ini sebuah kotak, yang punya label,
itu mengenakan pk label,

222
00:11:24,240 --> 00:11:27,280
dan itu mampu memegang
bintang int, apa pun mereka adalah.

223
00:11:27,280 --> 00:11:29,894
Mereka memiliki sesuatu untuk dilakukan
dengan bilangan bulat, jelas.

224
00:11:29,894 --> 00:11:31,060
Berikut baris terakhir sekalipun.

225
00:11:31,060 --> 00:11:37,650
Jika saya mengatakan pk = & k, whoa,
apa yang baru saja terjadi, kan?

226
00:11:37,650 --> 00:11:41,820
Jadi nomor acak ini, tampaknya acak
jumlah, akan dilemparkan ke dalam kotak ada.

227
00:11:41,820 --> 00:11:44,930
Semua itu adalah, adalah pk
mendapat alamat k.

228
00:11:44,930 --> 00:11:52,867
Jadi aku menempel di mana k tinggal di memori,
alamatnya, alamat byte nya.

229
00:11:52,867 --> 00:11:55,200
Semua yang saya lakukan adalah saya katakan
nilai itulah yang akan saya

230
00:11:55,200 --> 00:11:59,430
untuk menempatkan dalam kotak saya disebut pk.

231
00:11:59,430 --> 00:12:02,080
Dan karena hal-hal ini
pointer, dan karena mencari

232
00:12:02,080 --> 00:12:04,955
pada string seperti nol x
delapan nol c tujuh empat delapan

233
00:12:04,955 --> 00:12:07,790
dua nol mungkin
tidak terlalu berarti.

234
00:12:07,790 --> 00:12:12,390
Ketika kita umumnya memvisualisasikan pointer,
kita benar-benar melakukannya sebagai pointer.

235
00:12:12,390 --> 00:12:17,000
Pk memberi kita informasi
kita perlu mencari k di memori.

236
00:12:17,000 --> 00:12:19,120
Jadi pada dasarnya pk memiliki panah di dalamnya.

237
00:12:19,120 --> 00:12:21,670
Dan jika kita berjalan panjang
panah itu, bayangkan

238
00:12:21,670 --> 00:12:25,280
itu sesuatu yang bisa berjalan di atas, jika kita
berjalan sepanjang panah,

239
00:12:25,280 --> 00:12:29,490
di bagian paling ujung panah itu, kita
akan menemukan lokasi di memori

240
00:12:29,490 --> 00:12:31,390
di mana k hidup.

241
00:12:31,390 --> 00:12:34,360
Dan itu benar-benar penting
karena setelah kita tahu di mana k hidup,

242
00:12:34,360 --> 00:12:37,870
kita bisa mulai bekerja dengan data
dalam lokasi memori.

243
00:12:37,870 --> 00:12:40,780
Meskipun kita mendapatkan mungil sebuah
menggigit depan diri kita sendiri untuk saat ini.

244
00:12:40,780 --> 00:12:42,240
>> Jadi apa adalah pointer?

245
00:12:42,240 --> 00:12:45,590
Sebuah pointer adalah item data yang
Nilai adalah alamat memori.

246
00:12:45,590 --> 00:12:49,740
Itu yang nol x delapan nol barang
terjadi, itu adalah alamat memori.

247
00:12:49,740 --> 00:12:52,060
Itu adalah lokasi di memori.

248
00:12:52,060 --> 00:12:55,080
Dan jenis pointer
menjelaskan jenis yang

249
00:12:55,080 --> 00:12:56,930
data Anda akan menemukan di
alamat memori.

250
00:12:56,930 --> 00:12:58,810
Jadi ada int bintang bagian kanan.

251
00:12:58,810 --> 00:13:03,690
Jika saya ikuti panah itu, itu
akan membawa saya ke lokasi.

252
00:13:03,690 --> 00:13:06,980
Dan lokasi itu, apa yang saya
akan menemukan ada dalam contoh saya,

253
00:13:06,980 --> 00:13:08,240
adalah kotak berwarna hijau.

254
00:13:08,240 --> 00:13:12,650
Ini integer, itulah yang saya
akan menemukan jika saya pergi ke alamat tersebut.

255
00:13:12,650 --> 00:13:14,830
Tipe data dari
pointer menjelaskan apa

256
00:13:14,830 --> 00:13:17,936
Anda akan menemukan di alamat memori.

257
00:13:17,936 --> 00:13:19,560
Jadi, inilah hal yang benar-benar keren meskipun.

258
00:13:19,560 --> 00:13:25,090
Pointer memungkinkan kita untuk lulus
variabel antara fungsi.

259
00:13:25,090 --> 00:13:28,520
Dan benar-benar lulus variabel
dan tidak lulus salinan dari mereka.

260
00:13:28,520 --> 00:13:32,879
Karena jika kita tahu persis di mana
dalam memori untuk menemukan variabel,

261
00:13:32,879 --> 00:13:35,670
kita tidak perlu membuat salinan
itu, kita hanya bisa pergi ke lokasi yang

262
00:13:35,670 --> 00:13:37,844
dan bekerja dengan variabel itu.

263
00:13:37,844 --> 00:13:40,260
Jadi pada intinya pointer semacam
dari membuat lingkungan komputer

264
00:13:40,260 --> 00:13:42,360
lebih banyak seperti dunia nyata, benar.

265
00:13:42,360 --> 00:13:44,640
>> Jadi, inilah analogi.

266
00:13:44,640 --> 00:13:48,080
Mari kita mengatakan bahwa saya memiliki notebook,
benar, dan itu penuh dengan catatan.

267
00:13:48,080 --> 00:13:50,230
Dan saya ingin Anda untuk memperbaruinya.

268
00:13:50,230 --> 00:13:53,960
Anda fungsi yang
update catatan, benar.

269
00:13:53,960 --> 00:13:56,390
Dalam cara kita sudah
bekerja sejauh ini, apa yang

270
00:13:56,390 --> 00:14:02,370
terjadi adalah Anda akan mengambil notebook saya,
Anda akan pergi ke toko salinan,

271
00:14:02,370 --> 00:14:06,410
Anda akan membuat salinan Xerox
setiap halaman notebook.

272
00:14:06,410 --> 00:14:09,790
Anda akan meninggalkan notebook saya kembali
di meja saya ketika Anda selesai,

273
00:14:09,790 --> 00:14:14,600
Anda akan pergi dan mencoret hal di saya
notebook yang kedaluwarsa atau salah,

274
00:14:14,600 --> 00:14:19,280
dan kemudian Anda akan melewati kembali ke
saya tumpukan halaman Xerox

275
00:14:19,280 --> 00:14:22,850
yang merupakan replika dari notebook saya dengan
perubahan yang Anda buat untuk itu.

276
00:14:22,850 --> 00:14:27,040
Dan pada saat itu, terserah kepada saya sebagai
fungsi panggilan, sebagai pemanggil,

277
00:14:27,040 --> 00:14:30,582
memutuskan untuk mengambil catatan Anda dan
mengintegrasikan mereka kembali ke notebook saya.

278
00:14:30,582 --> 00:14:32,540
Jadi ada banyak langkah-langkah
terlibat di sini, benar.

279
00:14:32,540 --> 00:14:34,850
Seperti tidak akan lebih baik
jika saya hanya mengatakan, hei, bisa Anda

280
00:14:34,850 --> 00:14:38,370
memperbarui notebook saya untuk
saya, tangan Anda notebook saya,

281
00:14:38,370 --> 00:14:40,440
dan Anda mengambil hal-hal dan
benar-benar menyeberang mereka

282
00:14:40,440 --> 00:14:42,810
dan memperbarui catatan saya di notebook saya.

283
00:14:42,810 --> 00:14:45,140
Dan kemudian memberi saya notebook saya kembali.

284
00:14:45,140 --> 00:14:47,320
Itulah jenis apa
pointer memungkinkan kita untuk melakukan,

285
00:14:47,320 --> 00:14:51,320
mereka membuat lingkungan ini banyak
lebih seperti bagaimana kami beroperasi dalam kenyataan.

286
00:14:51,320 --> 00:14:54,640
>> Baiklah jadi itulah yang
pointer, mari kita bicara

287
00:14:54,640 --> 00:14:58,040
tentang bagaimana pointer bekerja di C, dan
bagaimana kita bisa mulai bekerja dengan mereka.

288
00:14:58,040 --> 00:15:02,550
Jadi ada pointer yang sangat sederhana
di C disebut pointer null.

289
00:15:02,550 --> 00:15:04,830
Pointer poin nol untuk apa-apa.

290
00:15:04,830 --> 00:15:08,310
Hal ini mungkin tampak seperti itu
sebenarnya bukan hal yang sangat berguna,

291
00:15:08,310 --> 00:15:10,500
tapi seperti yang kita akan melihat
sedikit nanti, kenyataan

292
00:15:10,500 --> 00:15:15,410
bahwa pointer nol ini ada
sebenarnya benar-benar dapat berguna.

293
00:15:15,410 --> 00:15:19,090
Dan setiap kali Anda membuat pointer, dan
Anda tidak menetapkan immediately- nilainya

294
00:15:19,090 --> 00:15:21,060
contoh pengaturan
nilainya segera

295
00:15:21,060 --> 00:15:25,401
akan menjadi beberapa slide kembali
di mana saya mengatakan pk sama & k,

296
00:15:25,401 --> 00:15:28,740
pk mendapat alamat k, seperti
kita akan melihat apa artinya,

297
00:15:28,740 --> 00:15:32,990
kita akan melihat bagaimana kode yang shortly-
jika kita tidak menetapkan nilai sesuatu

298
00:15:32,990 --> 00:15:35,380
bermakna segera,
Anda harus selalu

299
00:15:35,380 --> 00:15:37,480
mengatur pointer untuk menunjuk ke null.

300
00:15:37,480 --> 00:15:40,260
Anda harus mengaturnya untuk menunjuk ke apa-apa.

301
00:15:40,260 --> 00:15:43,614
>> Itu sangat berbeda dari
hanya meninggalkan nilai seperti itu

302
00:15:43,614 --> 00:15:45,530
dan kemudian mendeklarasikan
pointer dan hanya asumsi

303
00:15:45,530 --> 00:15:48,042
itu nol karena itu jarang benar.

304
00:15:48,042 --> 00:15:50,000
Jadi Anda harus selalu mengatur
nilai pointer

305
00:15:50,000 --> 00:15:55,690
null jika Anda tidak menetapkan nilai
untuk sesuatu yang berarti segera.

306
00:15:55,690 --> 00:15:59,090
Anda dapat memeriksa apakah nilai pointer
adalah null menggunakan operator kesetaraan

307
00:15:59,090 --> 00:16:05,450
(==), Sama seperti Anda membandingkan bilangan bulat apapun
nilai-nilai atau nilai-nilai karakter menggunakan (==)

308
00:16:05,450 --> 00:16:06,320
demikian juga.

309
00:16:06,320 --> 00:16:10,994
Ini semacam khusus konstan
nilai yang dapat Anda gunakan untuk menguji.

310
00:16:10,994 --> 00:16:13,160
Jadi itu sangat sederhana
pointer, pointer null.

311
00:16:13,160 --> 00:16:15,320
Cara lain untuk membuat
pointer adalah untuk mengekstrak

312
00:16:15,320 --> 00:16:18,240
alamat variabel
Anda sudah dibuat,

313
00:16:18,240 --> 00:16:22,330
dan Anda melakukan ini dengan menggunakan &
alamat Operator ekstraksi.

314
00:16:22,330 --> 00:16:26,720
Yang telah kita lihat sebelumnya
dalam diagram contoh pertama saya menunjukkan.

315
00:16:26,720 --> 00:16:31,450
Jadi jika x adalah variabel yang kita sudah
sudah dibuat dari tipe integer,

316
00:16:31,450 --> 00:16:35,110
maka & x adalah pointer ke integer.

317
00:16:35,110 --> 00:16:39,810
& x adalah- ingat, & akan mengekstrak
alamat hal di sebelah kanan.

318
00:16:39,810 --> 00:16:45,350
Dan karena pointer hanya alamat,
dari & x adalah pointer ke integer

319
00:16:45,350 --> 00:16:48,560
Nilai yang mana dalam memori x hidup.

320
00:16:48,560 --> 00:16:50,460
Ini alamat x.

321
00:16:50,460 --> 00:16:53,296
Jadi & x adalah alamat dari x.

322
00:16:53,296 --> 00:16:55,670
Mari mengambil satu langkah
lebih lanjut dan terhubung ke sesuatu

323
00:16:55,670 --> 00:16:58,380
Saya singgung di video sebelumnya.

324
00:16:58,380 --> 00:17:06,730
Jika arr adalah array dari ganda, maka
& braket persegi arr i adalah pointer

325
00:17:06,730 --> 00:17:08,109
untuk ganda.

326
00:17:08,109 --> 00:17:08,970
OKE.

327
00:17:08,970 --> 00:17:12,160
arr braket persegi i, jika
arr adalah array dari ganda,

328
00:17:12,160 --> 00:17:19,069
kemudian arr braket persegi i
elemen ke-i dari array,

329
00:17:19,069 --> 00:17:29,270
dan & arr braket persegi saya adalah di mana di
memori elemen ke-i dari arr ada.

330
00:17:29,270 --> 00:17:31,790
>> Jadi apa implikasinya di sini?

331
00:17:31,790 --> 00:17:34,570
Sebuah nama array, implikasinya
dari semua ini,

332
00:17:34,570 --> 00:17:39,290
adalah bahwa nama array adalah
sebenarnya itu sendiri pointer.

333
00:17:39,290 --> 00:17:41,170
Anda telah bekerja
dengan pointer sepanjang

334
00:17:41,170 --> 00:17:45,290
setiap kali bahwa Anda telah menggunakan sebuah array.

335
00:17:45,290 --> 00:17:49,090
Ingat dari contoh
pada lingkup variabel,

336
00:17:49,090 --> 00:17:53,420
dekat akhir video saya hadir
contoh di mana kita memiliki fungsi

337
00:17:53,420 --> 00:17:56,890
disebut set int dan
fungsi yang disebut set array.

338
00:17:56,890 --> 00:18:00,490
Dan tantangan Anda untuk menentukan
apakah atau tidak, atau apa

339
00:18:00,490 --> 00:18:03,220
nilai-nilai yang kita dicetak
akhir fungsi,

340
00:18:03,220 --> 00:18:05,960
pada akhir program utama.

341
00:18:05,960 --> 00:18:08,740
>> Jika Anda ingat dari contoh yang
atau jika Anda sudah menonton video,

342
00:18:08,740 --> 00:18:13,080
Anda tahu bahwa ketika Anda-panggilan untuk
set int efektif tidak apa-apa.

343
00:18:13,080 --> 00:18:16,390
Tetapi panggilan untuk mengatur berbagai dilakukannya.

344
00:18:16,390 --> 00:18:19,280
Dan aku semacam dipoles mengapa
itu terjadi pada saat itu.

345
00:18:19,280 --> 00:18:22,363
Aku hanya berkata, baik itu array, itu
khusus, Anda tahu, ada alasan.

346
00:18:22,363 --> 00:18:25,020
Alasannya adalah bahwa array
Nama benar-benar hanya sebuah pointer,

347
00:18:25,020 --> 00:18:28,740
dan ada ini khusus
sintaks braket persegi yang

348
00:18:28,740 --> 00:18:30,510
membuat hal-hal jauh lebih baik untuk bekerja dengan.

349
00:18:30,510 --> 00:18:34,410
Dan mereka membuat ide
pointer jauh lebih sedikit menakutkan,

350
00:18:34,410 --> 00:18:36,800
dan itulah sebabnya mereka semacam
dari yang disajikan dengan cara itu.

351
00:18:36,800 --> 00:18:38,600
Tapi benar-benar array hanya pointer.

352
00:18:38,600 --> 00:18:41,580
Dan itulah mengapa ketika kita
membuat perubahan ke array,

353
00:18:41,580 --> 00:18:44,880
ketika kami melewati sebuah array sebagai parameter
ke fungsi atau sebagai argumen

354
00:18:44,880 --> 00:18:50,110
ke fungsi, isi dari array
benar-benar berubah di kedua callee

355
00:18:50,110 --> 00:18:51,160
dan di pemanggil.

356
00:18:51,160 --> 00:18:55,846
Yang untuk setiap jenis lain dari
variabel yang kita lihat itu tidak terjadi.

357
00:18:55,846 --> 00:18:58,970
Jadi itu hanya sesuatu yang perlu
keberatan ketika Anda bekerja dengan pointer,

358
00:18:58,970 --> 00:19:01,610
adalah bahwa nama sebuah
array yang sebenarnya pointer

359
00:19:01,610 --> 00:19:04,750
ke elemen pertama dari array itu.

360
00:19:04,750 --> 00:19:08,930
>> OK jadi sekarang kita memiliki semua ini
fakta, mari kita terus, benar.

361
00:19:08,930 --> 00:19:11,370
Mengapa kita peduli
di mana sesuatu yang hidup.

362
00:19:11,370 --> 00:19:14,120
Yah seperti saya katakan, itu cukup
berguna untuk mengetahui di mana sesuatu yang hidup

363
00:19:14,120 --> 00:19:17,240
sehingga Anda dapat pergi ke sana dan mengubahnya.

364
00:19:17,240 --> 00:19:19,390
Bekerja dengan itu dan benar-benar
memiliki hal yang Anda

365
00:19:19,390 --> 00:19:23,710
ingin lakukan untuk efek mengambil variabel,
dan tidak berlaku pada beberapa salinan itu.

366
00:19:23,710 --> 00:19:26,150
Ini disebut dereferencing.

367
00:19:26,150 --> 00:19:28,690
Kami pergi ke referensi dan
kita mengubah nilai di sana.

368
00:19:28,690 --> 00:19:32,660
Jadi jika kita memiliki pointer dan itu disebut
pc, dan itu menunjukkan karakter,

369
00:19:32,660 --> 00:19:40,610
maka kita dapat mengatakan * pc dan pc * adalah
nama apa yang akan kita temukan jika kita pergi

370
00:19:40,610 --> 00:19:42,910
ke alamat pc.

371
00:19:42,910 --> 00:19:47,860
Apa yang kita akan menemukan ada karakter dan
* pc adalah bagaimana kita mengacu pada data pada saat itu

372
00:19:47,860 --> 00:19:48,880
lokasi.

373
00:19:48,880 --> 00:19:54,150
Jadi kita bisa mengatakan sesuatu seperti
* pc = D atau sesuatu seperti itu,

374
00:19:54,150 --> 00:19:59,280
dan itu berarti bahwa apa pun
berada di alamat memori pc,

375
00:19:59,280 --> 00:20:07,040
karakter apapun sebelumnya
ada, sekarang D, jika kita mengatakan * pc = D.

376
00:20:07,040 --> 00:20:10,090
>> Jadi di sini kita pergi lagi dengan
beberapa hal C aneh, benar.

377
00:20:10,090 --> 00:20:14,560
Jadi kita telah melihat * sebelumnya sebagai
entah bagaimana bagian dari jenis data,

378
00:20:14,560 --> 00:20:17,160
dan sekarang sedang digunakan dalam
konteks yang sedikit berbeda

379
00:20:17,160 --> 00:20:19,605
untuk mengakses data di lokasi.

380
00:20:19,605 --> 00:20:22,480
Aku tahu itu sedikit membingungkan dan
itu sebenarnya bagian dari keseluruhan ini

381
00:20:22,480 --> 00:20:25,740
seperti, mengapa pointer memiliki mitologi ini
sekitar mereka sebagai begitu kompleks,

382
00:20:25,740 --> 00:20:28,250
adalah jenis masalah sintaks, jujur.

383
00:20:28,250 --> 00:20:31,810
Tapi * digunakan baik dalam konteks,
baik sebagai bagian dari nama jenis,

384
00:20:31,810 --> 00:20:34,100
dan kita akan melihat sedikit
kemudian sesuatu yang lain, juga.

385
00:20:34,100 --> 00:20:36,490
Dan sekarang adalah
dereference operator.

386
00:20:36,490 --> 00:20:38,760
Jadi pergi ke referensi,
ia mengakses data

387
00:20:38,760 --> 00:20:43,000
di lokasi pointer, dan
memungkinkan Anda untuk memanipulasi di akan.

388
00:20:43,000 --> 00:20:45,900
>> Sekarang ini sangat mirip dengan
mengunjungi tetangga Anda, benar.

389
00:20:45,900 --> 00:20:48,710
Jika Anda tahu apa yang Anda
tetangga tinggal, Anda

390
00:20:48,710 --> 00:20:50,730
tidak bergaul dengan tetangga Anda.

391
00:20:50,730 --> 00:20:53,510
Anda tahu Anda kebetulan
tahu di mana mereka tinggal,

392
00:20:53,510 --> 00:20:56,870
tapi itu tidak berarti bahwa dengan
berdasarkan memiliki pengetahuan yang

393
00:20:56,870 --> 00:20:59,170
Anda berinteraksi dengan mereka.

394
00:20:59,170 --> 00:21:01,920
Jika Anda ingin berinteraksi dengan mereka,
Anda harus pergi ke rumah mereka,

395
00:21:01,920 --> 00:21:03,760
Anda harus pergi ke mana mereka tinggal.

396
00:21:03,760 --> 00:21:07,440
Dan sekali Anda melakukannya,
maka Anda dapat berinteraksi

397
00:21:07,440 --> 00:21:09,420
dengan mereka sama seperti Anda ingin.

398
00:21:09,420 --> 00:21:12,730
Dan sama dengan variabel,
Anda perlu pergi ke alamat mereka

399
00:21:12,730 --> 00:21:15,320
jika Anda ingin berinteraksi mereka,
Anda tidak bisa hanya tahu alamat.

400
00:21:15,320 --> 00:21:21,495
Dan cara Anda pergi ke alamat ini
menggunakan *, operator dereference.

401
00:21:21,495 --> 00:21:23,620
Apa yang Anda pikirkan terjadi
jika kita mencoba dan dereference

402
00:21:23,620 --> 00:21:25,260
pointer yang nilainya nol?

403
00:21:25,260 --> 00:21:28,470
Ingat bahwa nol
pointer menunjuk ke apa-apa.

404
00:21:28,470 --> 00:21:34,110
Jadi jika Anda mencoba dan dereference
tidak ada atau pergi ke alamat apa-apa,

405
00:21:34,110 --> 00:21:36,800
bagaimana menurutmu yang terjadi?

406
00:21:36,800 --> 00:21:39,630
Segmentasi Nah jika Anda menebak
kesalahan, Anda akan benar.

407
00:21:39,630 --> 00:21:41,390
Jika Anda mencoba dan dereference
pointer null,

408
00:21:41,390 --> 00:21:43,140
Anda menderita segmentasi sebuah
kesalahan. Tapi tunggu,

409
00:21:43,140 --> 00:21:45,820
tidak saya katakan, bahwa
jika Anda tidak akan

410
00:21:45,820 --> 00:21:49,220
untuk menetapkan nilai Anda dari Anda
pointer ke sesuatu yang berarti,

411
00:21:49,220 --> 00:21:51,000
Anda harus diatur ke nol?

412
00:21:51,000 --> 00:21:55,290
Saya lakukan dan benar-benar segmentasi
kesalahan adalah jenis perilaku yang baik.

413
00:21:55,290 --> 00:21:58,680
>> Apakah Anda pernah menyatakan variabel dan
tidak ditugaskan nilainya segera?

414
00:21:58,680 --> 00:22:02,680
Jadi Anda hanya mengatakan int x; Anda tidak
sebenarnya menetapkan apa-apa

415
00:22:02,680 --> 00:22:05,340
dan kemudian di dalam kode Anda,
Anda mencetak nilai x,

416
00:22:05,340 --> 00:22:07,650
masih belum memiliki
ditugaskan untuk apa-apa.

417
00:22:07,650 --> 00:22:10,370
Sering Anda akan mendapatkan
nol, tapi kadang-kadang Anda

418
00:22:10,370 --> 00:22:15,000
mungkin mendapatkan beberapa nomor acak, dan
Anda tidak tahu dari mana asalnya.

419
00:22:15,000 --> 00:22:16,750
Demikian pula bisa hal
terjadi dengan pointer.

420
00:22:16,750 --> 00:22:20,110
Ketika Anda menyatakan pointer
int * pk misalnya,

421
00:22:20,110 --> 00:22:23,490
dan Anda tidak menetapkan ke nilai,
Anda mendapatkan empat byte untuk memori.

422
00:22:23,490 --> 00:22:25,950
Apapun empat byte
memori sistem dapat

423
00:22:25,950 --> 00:22:28,970
menemukan bahwa memiliki beberapa nilai yang berarti.

424
00:22:28,970 --> 00:22:31,760
Dan mungkin ada
sesuatu yang sudah ada yang

425
00:22:31,760 --> 00:22:34,190
tidak lagi dibutuhkan oleh yang lain
fungsi, sehingga Anda hanya perlu

426
00:22:34,190 --> 00:22:35,900
Data apa pun yang ada.

427
00:22:35,900 --> 00:22:40,570
>> Bagaimana jika Anda mencoba untuk melakukan dereference
beberapa alamat yang Anda tidak- ada

428
00:22:40,570 --> 00:22:43,410
sudah byte dan informasi di
ada, yang sekarang dalam pointer Anda.

429
00:22:43,410 --> 00:22:47,470
Jika Anda mencoba dan dereference pointer itu,
Anda mungkin bermain-main dengan beberapa memori

430
00:22:47,470 --> 00:22:49,390
bahwa Anda tidak berniat
main-main dengan itu semua.

431
00:22:49,390 --> 00:22:51,639
Dan bahkan Anda bisa melakukan
sesuatu yang sangat dahsyat,

432
00:22:51,639 --> 00:22:54,880
seperti istirahat program lain,
atau merusak fungsi lain,

433
00:22:54,880 --> 00:22:58,289
atau melakukan sesuatu yang berbahaya
Anda tidak berniat untuk melakukan sama sekali.

434
00:22:58,289 --> 00:23:00,080
Dan jadi itu sebabnya itu
sebenarnya ide yang baik

435
00:23:00,080 --> 00:23:04,030
untuk mengatur pointer Anda ke null jika Anda
tidak menetapkan mereka untuk sesuatu yang berarti.

436
00:23:04,030 --> 00:23:06,760
Ini mungkin lebih baik di
akhir hari untuk program Anda

437
00:23:06,760 --> 00:23:09,840
untuk kecelakaan maka untuk itu untuk melakukan
sesuatu yang sekrup

438
00:23:09,840 --> 00:23:12,400
program lain atau fungsi lain.

439
00:23:12,400 --> 00:23:15,207
Perilaku yang mungkin bahkan
kurang ideal daripada hanya menabrak.

440
00:23:15,207 --> 00:23:17,040
Dan jadi itu sebabnya itu
sebenarnya kebiasaan yang baik

441
00:23:17,040 --> 00:23:20,920
untuk masuk ke untuk mengatur pointer Anda
null jika Anda tidak menetapkan mereka

442
00:23:20,920 --> 00:23:24,540
ke nilai yang bermakna
segera, nilai yang Anda tahu

443
00:23:24,540 --> 00:23:27,260
dan bahwa Anda dapat dengan aman dereference.

444
00:23:27,260 --> 00:23:32,240
>> Jadi mari kita kembali sekarang dan melihat
di sintaks keseluruhan situasi.

445
00:23:32,240 --> 00:23:37,400
Jika saya mengatakan int * p ;, apa yang telah saya hanya dilakukan?

446
00:23:37,400 --> 00:23:38,530
Apa yang saya lakukan adalah ini.

447
00:23:38,530 --> 00:23:43,290
Saya tahu nilai p adalah alamat
karena semua pointer hanya

448
00:23:43,290 --> 00:23:44,660
alamat.

449
00:23:44,660 --> 00:23:47,750
Aku bisa dereference p
menggunakan operator *.

450
00:23:47,750 --> 00:23:51,250
Dalam konteks ini di sini, di bagian paling
atas ingat * adalah bagian dari jenis.

451
00:23:51,250 --> 00:23:53,510
Int * adalah tipe data.

452
00:23:53,510 --> 00:23:56,150
Tapi aku bisa dereference
p menggunakan operator *,

453
00:23:56,150 --> 00:24:01,897
dan jika saya melakukannya, jika saya pergi ke alamat tersebut,
apa yang akan saya temukan di alamat itu?

454
00:24:01,897 --> 00:24:02,855
Aku akan menemukan sebuah integer.

455
00:24:02,855 --> 00:24:05,910
Jadi int * p pada dasarnya adalah
mengatakan, p adalah alamat.

456
00:24:05,910 --> 00:24:09,500
Aku bisa dereference p dan jika
Saya lakukan, saya akan menemukan sebuah integer

457
00:24:09,500 --> 00:24:11,920
di lokasi memori.

458
00:24:11,920 --> 00:24:14,260
>> OK jadi saya mengatakan ada yang lain
hal yang mengganggu dengan bintang

459
00:24:14,260 --> 00:24:17,060
dan di sinilah yang
hal yang mengganggu dengan bintang adalah.

460
00:24:17,060 --> 00:24:21,640
Apakah Anda pernah mencoba untuk menyatakan
beberapa variabel dari jenis yang sama

461
00:24:21,640 --> 00:24:24,409
pada baris kode yang sama?

462
00:24:24,409 --> 00:24:27,700
Jadi untuk kedua, berpura-pura bahwa garis,
kode saya benar-benar telah ada di green

463
00:24:27,700 --> 00:24:29,366
tidak ada dan itu hanya mengatakan int x, y, z ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
Apa yang akan saya lakukan adalah benar-benar membuat
tiga variabel integer untuk Anda,

466
00:24:34,550 --> 00:24:36,930
satu yang disebut x, salah satu yang disebut
y, dan satu disebut z.

467
00:24:36,930 --> 00:24:41,510
Ini adalah cara untuk melakukannya tanpa
harus membagi ke tiga baris.

468
00:24:41,510 --> 00:24:43,890
>> Di sinilah bintang mendapatkan
mengganggu lagi meskipun,

469
00:24:43,890 --> 00:24:49,200
karena * sebenarnya bagian
dari kedua nama jenis dan bagian

470
00:24:49,200 --> 00:24:50,320
dari nama variabel.

471
00:24:50,320 --> 00:24:56,430
Dan jika saya mengatakan int * px, py, pz, apa yang saya
benar-benar mendapatkan adalah pointer ke integer

472
00:24:56,430 --> 00:25:01,650
disebut px dan dua bilangan bulat, py dan pz.

473
00:25:01,650 --> 00:25:04,950
Dan itu mungkin bukan apa
yang kita inginkan, itu tidak baik.

474
00:25:04,950 --> 00:25:09,290
>> Jadi jika saya ingin membuat beberapa pointer
pada baris yang sama, dari jenis yang sama,

475
00:25:09,290 --> 00:25:12,140
dan bintang, apa yang sebenarnya saya butuhkan
lakukan adalah mengatakan int * pa, * pb, * pc.

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
Sekarang setelah hanya mengatakan bahwa
dan sekarang mengatakan ini,

478
00:25:20,300 --> 00:25:22,170
Anda mungkin tidak akan pernah melakukan hal ini.

479
00:25:22,170 --> 00:25:25,170
Dan itu mungkin hal yang baik jujur,
karena Anda mungkin secara tidak sengaja

480
00:25:25,170 --> 00:25:26,544
menghilangkan bintang, sesuatu seperti itu.

481
00:25:26,544 --> 00:25:29,290
Ini mungkin yang terbaik untuk mungkin menyatakan
pointer pada garis individu,

482
00:25:29,290 --> 00:25:31,373
tapi itu hanya salah satu
dari mereka sintaks mengganggu

483
00:25:31,373 --> 00:25:35,310
hal dengan bintang yang membuat
pointer sehingga sulit untuk bekerja dengan.

484
00:25:35,310 --> 00:25:39,480
Karena itu hanya sintaksis ini
berantakan Anda harus bekerja melalui.

485
00:25:39,480 --> 00:25:41,600
Dengan latihan yang dilakukannya
benar-benar menjadi sifat kedua.

486
00:25:41,600 --> 00:25:45,410
Aku masih melakukan kesalahan dengan itu masih
setelah pemrograman selama 10 tahun,

487
00:25:45,410 --> 00:25:49,630
jadi jangan marah jika sesuatu terjadi
untuk Anda, itu cukup umum jujur.

488
00:25:49,630 --> 00:25:52,850
Ini benar-benar jenis
cacat sintaks.

489
00:25:52,850 --> 00:25:54,900
>> OK jadi aku agak berjanji
bahwa kita akan kembali

490
00:25:54,900 --> 00:25:59,370
konsep seberapa besar adalah string.

491
00:25:59,370 --> 00:26:02,750
Nah jika saya katakan bahwa
String, kita sudah benar-benar jenis

492
00:26:02,750 --> 00:26:04,140
telah berbohong kepada Anda sepanjang waktu.

493
00:26:04,140 --> 00:26:06,181
Tidak ada tipe data yang disebut
tali, dan sebenarnya saya

494
00:26:06,181 --> 00:26:09,730
disebutkan ini di salah satu kami
video paling awal pada jenis data,

495
00:26:09,730 --> 00:26:13,820
string yang merupakan tipe data yang
diciptakan untuk Anda di CS50.h.

496
00:26:13,820 --> 00:26:17,050
Anda harus # include
CS50.h untuk menggunakannya.

497
00:26:17,050 --> 00:26:19,250
>> Nah string yang benar-benar hanya
alias untuk sesuatu

498
00:26:19,250 --> 00:26:23,600
disebut char *, sebuah
pointer ke karakter.

499
00:26:23,600 --> 00:26:26,010
Nah pointer, ingat,
hanya alamat.

500
00:26:26,010 --> 00:26:28,780
Jadi apa ukuran
di byte string?

501
00:26:28,780 --> 00:26:29,796
Baik itu empat atau delapan.

502
00:26:29,796 --> 00:26:32,170
Dan alasan saya mengatakan empat atau
delapan adalah karena sebenarnya

503
00:26:32,170 --> 00:26:36,730
tergantung pada sistem, Jika Anda menggunakan
CS50 ide, char * adalah ukuran char

504
00:26:36,730 --> 00:26:39,340
* Delapan, itu sistem 64-bit.

505
00:26:39,340 --> 00:26:43,850
Setiap alamat dalam memori adalah 64 bit panjang.

506
00:26:43,850 --> 00:26:48,270
Jika Anda menggunakan alat CS50
atau menggunakan mesin 32-bit,

507
00:26:48,270 --> 00:26:51,640
dan Anda telah mendengar bahwa istilah 32-bit
mesin, apa adalah mesin 32-bit?

508
00:26:51,640 --> 00:26:56,090
Baik itu hanya berarti bahwa setiap
alamat dalam memori adalah 32 bit panjang.

509
00:26:56,090 --> 00:26:59,140
Dan 32 bit adalah empat byte.

510
00:26:59,140 --> 00:27:02,710
Jadi char * empat atau delapan
byte tergantung pada sistem Anda.

511
00:27:02,710 --> 00:27:06,100
Dan memang setiap jenis data,
dan pointer ke data apapun

512
00:27:06,100 --> 00:27:12,030
ketik, karena semua pointer hanya
alamat, yang empat atau delapan byte.

513
00:27:12,030 --> 00:27:14,030
Jadi mari kita kembali ini
diagram dan mari kita simpulkan

514
00:27:14,030 --> 00:27:18,130
video ini dengan latihan kecil di sini.

515
00:27:18,130 --> 00:27:21,600
Jadi, inilah diagram kita tinggalkan dengan
di awal video.

516
00:27:21,600 --> 00:27:23,110
Jadi apa yang terjadi jika saya katakan * pk = 35?

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
Jadi apa artinya ketika saya mengatakan, * pk = 35?

519
00:27:30,530 --> 00:27:32,420
Mengambil kedua.

520
00:27:32,420 --> 00:27:34,990
* pk.

521
00:27:34,990 --> 00:27:39,890
Dalam konteks di sini, adalah *
dereference operator.

522
00:27:39,890 --> 00:27:42,110
Jadi ketika dereference
Operator yang digunakan,

523
00:27:42,110 --> 00:27:48,520
kita pergi ke alamat yang ditunjuk
oleh pk, dan kita mengubah apa yang kita temukan.

524
00:27:48,520 --> 00:27:55,270
Jadi * pk = 35 efektif
melakukan ini untuk gambar.

525
00:27:55,270 --> 00:27:58,110
Jadi pada dasarnya sintaksis
identik dengan dari yang mengatakan k = 35.

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> Satu lagi.

528
00:28:01,930 --> 00:28:05,510
Jika saya mengatakan int m, saya membuat
variabel baru yang disebut m.

529
00:28:05,510 --> 00:28:08,260
Sebuah kotak baru, itu kotak hijau karena
itu akan terus integer,

530
00:28:08,260 --> 00:28:09,840
dan itu berlabel m.

531
00:28:09,840 --> 00:28:14,960
Jika saya mengatakan m = 4, saya menempatkan
bilangan bulat ke dalam kotak itu.

532
00:28:14,960 --> 00:28:20,290
Jika katakanlah pk = & m, bagaimana
perubahan diagram ini?

533
00:28:20,290 --> 00:28:28,760
Pk = & m, apakah Anda ingat apa yang
& Operator melakukan atau disebut?

534
00:28:28,760 --> 00:28:34,430
Ingat bahwa & beberapa nama variabel
adalah alamat dari nama variabel.

535
00:28:34,430 --> 00:28:38,740
Jadi apa yang kita katakan adalah
pk mendapat alamat m.

536
00:28:38,740 --> 00:28:42,010
Dan secara efektif apa yang terjadi dengan
diagram adalah bahwa pk poin tidak lagi

537
00:28:42,010 --> 00:28:46,420
untuk k, tapi poin untuk m.

538
00:28:46,420 --> 00:28:48,470
>> Lagi pointer sangat
sulit untuk bekerja dengan

539
00:28:48,470 --> 00:28:50,620
dan mereka mengambil banyak
praktek, tetapi karena

540
00:28:50,620 --> 00:28:54,150
kemampuan mereka untuk memungkinkan Anda
untuk lulus data antara fungsi

541
00:28:54,150 --> 00:28:56,945
dan benar-benar memiliki orang-orang
perubahan berlaku,

542
00:28:56,945 --> 00:28:58,820
mendapatkan kepala Anda sekitar
benar-benar penting.

543
00:28:58,820 --> 00:29:02,590
Mungkin adalah yang paling rumit
topik kita bahas dalam CS50,

544
00:29:02,590 --> 00:29:05,910
tetapi nilai yang Anda
dapatkan dari menggunakan pointer

545
00:29:05,910 --> 00:29:09,200
jauh melebihi komplikasi
yang datang dari belajar mereka.

546
00:29:09,200 --> 00:29:12,690
Jadi saya berharap yang terbaik dari
keberuntungan belajar tentang pointer.

547
00:29:12,690 --> 00:29:15,760
Aku Doug Lloyd, ini CS50.

548
00:29:15,760 --> 00:29:17,447