1
00:00:00,000 --> 00:00:02,440
[Powered by Google Translate] [Pointer]

2
00:00:02,440 --> 00:00:05,000
[Rob Bowden] [Harvard University]

3
00:00:05,000 --> 00:00:07,360
[Ini adalah CS50] [CS50.TV]

4
00:00:07,360 --> 00:00:08,820
>> Mari kita bicara tentang pointer.

5
00:00:08,820 --> 00:00:13,710
Sampai sekarang, kami selalu hanya disebut hal-hal dalam memori eksplisit dengan nama.

6
00:00:13,710 --> 00:00:22,610
Kami telah mengatakan int n = 42, dan kemudian ketika kita ingin menggunakan n variabel,

7
00:00:22,610 --> 00:00:30,640
kita hanya menyebutnya dengan nama yang kita berikan dengan menulis sesuatu seperti n * 2.

8
00:00:30,640 --> 00:00:34,790
Tapi variabel yang harus tinggal di suatu tempat di memori.

9
00:00:34,790 --> 00:00:37,790
Bila Anda ingin menggunakan nilai yang saat ini disimpan di dalam n,

10
00:00:37,790 --> 00:00:40,730
atau memperbarui nilai bahwa n adalah memegang,

11
00:00:40,730 --> 00:00:44,180
Program Anda harus tahu di mana dalam memori untuk mencari n.

12
00:00:44,180 --> 00:00:48,320
Dimana dalam memori kehidupan variabel disebut alamatnya.

13
00:00:48,320 --> 00:00:49,940
Ini seperti alamat rumah.

14
00:00:49,940 --> 00:00:53,080
Saya bisa menemukan rumah seseorang selama saya tahu alamat rumah mereka,

15
00:00:53,080 --> 00:00:58,110
dan program komputer dapat menemukan variabel asalkan tahu alamat memori.

16
00:00:58,110 --> 00:01:02,660
Apa pointer berikan adalah cara langsung berhubungan dengan alamat memori.

17
00:01:02,660 --> 00:01:06,860
>> Banyak kekuatan di C berasal dari mampu untuk memanipulasi memori seperti ini.

18
00:01:06,860 --> 00:01:09,960
Tapi dengan kekuatan besar datang tanggung jawab besar.

19
00:01:09,960 --> 00:01:14,670
Pointer dapat digunakan berbahaya cukup bahwa banyak bahasa pemrograman

20
00:01:14,670 --> 00:01:16,460
menyembunyikan pointer seluruhnya.

21
00:01:16,460 --> 00:01:19,440
Jadi, mengapa C memberi kita petunjuk kemudian?

22
00:01:19,440 --> 00:01:22,680
Seperti yang Anda ketahui, argumen untuk fungsi C

23
00:01:22,680 --> 00:01:25,370
selalu disalin ke parameter fungsi.

24
00:01:25,370 --> 00:01:33,260
Jadi, memanggil sesuatu seperti swap pada beberapa variabel x dan y

25
00:01:33,260 --> 00:01:38,840
tidak dapat menukar nilai-nilai x dan y dalam pemanggilan fungsi,

26
00:01:38,840 --> 00:01:40,810
meskipun itu mungkin berguna.

27
00:01:40,810 --> 00:01:46,430
Seperti yang akan kita lihat nanti swap, menulis ulang untuk mengambil pointer ke lokasi yang perlu ditukarkan

28
00:01:46,430 --> 00:01:49,690
memungkinkan untuk mempengaruhi variabel pemanggil-nya.

29
00:01:49,690 --> 00:01:54,150
>> Mari kita berjalan melalui contoh yang relatif mudah dari apa pointer dapat dilakukan.

30
00:01:54,150 --> 00:02:15,550
Katakanlah kita memiliki n int = 4, dan int * pointer_to_n = & n.

31
00:02:15,550 --> 00:02:18,990
Whoa! Sedikit sintaks baru untuk menutupi.

32
00:02:18,990 --> 00:02:22,600
Pertama, mari kita menafsirkan ini & n.

33
00:02:22,600 --> 00:02:27,260
Ingatlah bahwa segala sesuatu dalam memori memiliki alamat beberapa.

34
00:02:27,260 --> 00:02:30,800
Ampersand ini disebut "alamat" operator.

35
00:02:30,800 --> 00:02:36,470
Jadi, & n mengacu ke alamat di memori dimana n disimpan.

36
00:02:36,470 --> 00:02:41,560
Sekarang, kita menyimpan alamat ini dalam variabel baru, pointer_to_n.

37
00:02:41,560 --> 00:02:43,870
Apa jenis ini variabel baru?

38
00:02:43,870 --> 00:02:47,410
Tanda bintang adalah bagian dari jenis variabel,

39
00:02:47,410 --> 00:02:49,880
dan kita akan membaca tipe sebagai * int.

40
00:02:49,880 --> 00:02:56,500
* Int berarti bahwa pointer_to_n adalah variabel yang menyimpan alamat integer.

41
00:02:56,500 --> 00:03:02,970
Kita tahu bahwa & n adalah int * sejak n adalah integer, dan kami mengambil alamat dari n.

42
00:03:02,970 --> 00:03:06,660
* Int adalah contoh dari jenis pointer.

43
00:03:06,660 --> 00:03:10,150
Segera setelah Anda mulai melihat tanda bintang dalam jenis,

44
00:03:10,150 --> 00:03:11,950
Anda tahu bahwa Anda sedang berhadapan dengan pointer.

45
00:03:11,950 --> 00:03:16,520
Sama seperti kita dapat mendeklarasikan variabel sebagai int x dan char y,

46
00:03:16,520 --> 00:03:20,410
kita dapat mengatakan int * z dan char * w.

47
00:03:20,410 --> 00:03:25,190
Int * dan char * hanya jenis baru bagi kita untuk menggunakan.

48
00:03:25,190 --> 00:03:29,430
Lokasi * dapat pergi ke mana pun sebelum nama variabel.

49
00:03:29,430 --> 00:03:34,730
Jadi, baik int * pointer_to_n - dengan * sebelah int, seperti yang kita miliki di sini -

50
00:03:34,730 --> 00:03:45,210
dan int * pointer_to_n dengan * sebelah pointer_to_n berlaku.

51
00:03:45,210 --> 00:03:56,470
Tapi di sini, saya akan menempatkan * berikutnya untuk int.

52
00:03:56,470 --> 00:04:00,600
Tidak peduli yang Anda inginkan, hanya konsisten.

53
00:04:00,600 --> 00:04:02,810
>> Mari kita menggambar diagram untuk ini.

54
00:04:02,810 --> 00:04:07,590
Kami pertama memiliki n variabel, yang kita akan menarik sebagai sebuah kotak kecil dari memori.

55
00:04:07,590 --> 00:04:15,400
Untuk contoh ini, mari kita mengatakan bahwa kotak ini terletak di alamat 100.

56
00:04:15,400 --> 00:04:18,820
Di dalam kotak ini, kita menyimpan nilai 4.

57
00:04:18,820 --> 00:04:23,730
Sekarang, kita memiliki variabel baru, pointer_to_n.

58
00:04:23,730 --> 00:04:27,030
Ia memiliki kotak sendiri dalam memori,

59
00:04:27,030 --> 00:04:32,900
yang akan kita katakan adalah di alamat 200.

60
00:04:32,900 --> 00:04:37,220
Di dalam kotak ini, kita menyimpan alamat n,

61
00:04:37,220 --> 00:04:39,890
yang kita sebelumnya mengatakan adalah 100.

62
00:04:39,890 --> 00:04:44,710
Sering dalam diagram, Anda akan melihat ini ditampilkan sebagai panah literal

63
00:04:44,710 --> 00:04:48,730
meninggalkan kotak pointer_to_n menunjuk ke kotak yang menyimpan n.

64
00:04:48,730 --> 00:04:54,620
Sekarang, apa yang bisa kita benar-benar melakukan dengan pointer_to_n?

65
00:04:54,620 --> 00:05:10,400
Nah, jika kita mengatakan sesuatu seperti * pointer_to_n = 8, ini adalah penggunaan yang berbeda untuk asterisk

66
00:05:10,400 --> 00:05:14,830
yang benar-benar terpisah dari penggunaan tanda dalam mendeklarasikan variabel

67
00:05:14,830 --> 00:05:16,790
dari jenis pointer.

68
00:05:16,790 --> 00:05:21,130
Di sini, tanda ini disebut operator dereference.

69
00:05:21,130 --> 00:05:26,860
Dalam diagram kita, apa * pointer_to_n = 8 berarti adalah,

70
00:05:26,860 --> 00:05:32,220
pergi ke pointer_to_n kotak yang berisi, ikuti panah,

71
00:05:32,220 --> 00:05:38,160
dan kemudian menetapkan ke kotak di ujung panah nilai 8.

72
00:05:38,160 --> 00:05:45,960
Ini berarti bahwa setelah baris ini, jika kita mencoba untuk menggunakan n itu akan memiliki nilai 8.

73
00:05:45,960 --> 00:05:51,600
'Pointer' Kata ini digunakan dalam banyak konteks yang berbeda.

74
00:05:51,600 --> 00:05:54,380
Di sini, kita akan mencoba untuk konsisten.

75
00:05:54,380 --> 00:05:58,330
Sebuah jenis pointer adalah sesuatu seperti * int.

76
00:05:58,330 --> 00:06:04,630
Dalam video ini, pointer hanya akan digunakan untuk berarti nilai dengan tipe pointer,

77
00:06:04,630 --> 00:06:08,180
seperti pointer_to_n yang memiliki tipe int *.

78
00:06:08,180 --> 00:06:15,140
Di mana saja kita digunakan untuk hanya mengatakan n, kita sekarang dapat mengatakan sebaliknya pointer_to_n *,

79
00:06:15,140 --> 00:06:18,020
dan semuanya akan bekerja sama dengan baik.

80
00:06:18,020 --> 00:06:21,120
>> Mari kita berjalan melalui contoh lain yang sederhana.

81
00:06:21,120 --> 00:06:50,390
Katakanlah kita memiliki n int = 14; int * pointer = &n; n + +, dan (* pointer) + +.

82
00:06:50,390 --> 00:06:59,830
Baris pertama menciptakan kotak baru dalam memori berlabel n.

83
00:06:59,830 --> 00:07:05,400
Kali ini, kami tidak akan label kotak dengan alamat eksplisit, tetapi masih memiliki satu.

84
00:07:05,400 --> 00:07:11,810
Di dalam kotak, kita menyimpan nomor 14.

85
00:07:11,810 --> 00:07:22,290
Baris berikutnya menciptakan pointer kotak berlabel kedua.

86
00:07:22,290 --> 00:07:27,210
Dan dalam kotak ini, kita menyimpan pointer ke kotak berlabel n.

87
00:07:27,210 --> 00:07:33,170
Jadi, mari kita menarik panah dari pointer ke n.

88
00:07:33,170 --> 00:07:37,790
Sekarang, n + + increment nilai dalam kotak berlabel n,

89
00:07:37,790 --> 00:07:45,420
jadi kami pergi 14-15.

90
00:07:45,420 --> 00:07:53,330
Akhirnya, (* pointer) + + pergi ke pointer kotak berlabel,

91
00:07:53,330 --> 00:08:02,660
dereferences nilai dalam kotak, yang berarti mengikuti panah ke tempat itu menunjukkan,

92
00:08:02,660 --> 00:08:11,690
dan kenaikan nilai yang tersimpan di sana, jadi kami pergi 15-16.

93
00:08:11,690 --> 00:08:13,480
Dan itu saja.

94
00:08:13,480 --> 00:08:18,480
N sekarang menyimpan nomor 16 setelah dua kali telah bertambah -

95
00:08:18,480 --> 00:08:25,050
sekali langsung dengan menggunakan n nama variabel, dan lainnya melalui suatu pointer_to_n.

96
00:08:25,050 --> 00:08:33,360
>> Cepat kuis. Apa yang Anda pikir itu berarti jika saya mencoba untuk mengatakan sesuatu seperti && n?

97
00:08:33,360 --> 00:08:41,350
Nah, mari kita menulis ulang ini sebagai & (& n) yang menyelesaikan hal yang sama.

98
00:08:41,350 --> 00:08:47,030
The (& n) mengembalikan alamat dari n variabel dalam memori.

99
00:08:47,030 --> 00:08:53,110
Tapi kemudian kemudian ampersand luar mencoba untuk mengembalikan alamat dari alamat.

100
00:08:53,110 --> 00:08:56,600
Itu seperti mencoba untuk melakukan & 2.

101
00:08:56,600 --> 00:09:00,550
Ini tidak masuk akal untuk mendapatkan alamat hanya beberapa nomor

102
00:09:00,550 --> 00:09:03,260
karena itu tidak disimpan dalam memori.

103
00:09:03,260 --> 00:09:07,090
Menggunakan dua ampersands berturut-turut tidak pernah ide yang tepat.

104
00:09:07,090 --> 00:09:28,960
Tapi sekarang, apa artinya jika saya mencoba mengatakan int ** double_pointer = & pointer?

105
00:09:28,960 --> 00:09:40,750
Sekarang, saya sedang membuat kotak baru berlabel double_pointer,

106
00:09:40,750 --> 00:09:44,590
dan di dalam kotak bahwa aku menyimpan alamat dari pointer,

107
00:09:44,590 --> 00:09:50,810
yang berarti saya menggambar panah dari kotak ke kotak double_pointer pointer.

108
00:09:50,810 --> 00:09:56,640
Perhatikan jenis double_pointer, suatu ** int.

109
00:09:56,640 --> 00:10:03,700
N adalah integer, pointer menyimpan alamat n, dan sehingga memiliki * tipe int.

110
00:10:03,700 --> 00:10:10,550
Sekarang, double_pointer menyimpan alamat pointer, sehingga memiliki tipe int **.

111
00:10:10,550 --> 00:10:15,070
>> Jadi, apa yang kita pikirkan cara ini -

112
00:10:15,070 --> 00:10:24,490
Double_pointer ** = 23?

113
00:10:24,490 --> 00:10:28,630
Perhatikan bahwa saya sekarang dereferencing dua kali.

114
00:10:28,630 --> 00:10:32,030
Cukup ikuti diagram kotak-dan-panah kita sudah menyiapkan.

115
00:10:32,030 --> 00:10:36,400
Pertama, kita pergi ke kotak berlabel double_pointer.

116
00:10:36,400 --> 00:10:40,550
The * pertama berarti mengikuti panah sekali.

117
00:10:40,550 --> 00:10:44,110
Sekarang, kita berada di pointer kotak berlabel.

118
00:10:44,110 --> 00:10:49,940
Bintang kedua mengatakan mengikuti panah lagi,

119
00:10:49,940 --> 00:10:58,230
dan sekarang kita berada di kotak berlabel n, dan kami menetapkan nilai dari kotak ini untuk 23.

120
00:10:58,230 --> 00:11:05,940
Perhatikan bahwa 'alamat' dereference dan operator invers satu sama lain.

121
00:11:05,940 --> 00:11:16,990
Hal ini memungkinkan saya untuk melakukan sesuatu seperti * & * & n = 42.

122
00:11:16,990 --> 00:11:22,550
Sementara ini bekerja, Anda tidak harus melakukan sesuatu seperti ini dalam praktek.

123
00:11:22,550 --> 00:11:24,840
Apa yang kita benar-benar lakukan di sini?

124
00:11:24,840 --> 00:11:28,700
Ampersand pertama meraih alamat dari n variabel.

125
00:11:28,700 --> 00:11:34,660
Kemudian, kita memiliki operator dereference, yang berarti kita akan ke alamat tersebut di memori,

126
00:11:34,660 --> 00:11:36,910
jadi kita kembali pada n.

127
00:11:36,910 --> 00:11:40,910
Sekarang, kita ambil alamat n lagi dan segera dereference,

128
00:11:40,910 --> 00:11:50,780
jadi kita kembali pada n dan toko 42.

129
00:11:50,780 --> 00:11:55,490
Jadi, setiap pasangan * & hanya membatalkan.

130
00:11:55,490 --> 00:11:59,980
>> Ada sebuah pointer khusus yang disebut null pointer.

131
00:11:59,980 --> 00:12:03,140
Ini adalah pointer yang kita tidak pernah harus dereference.

132
00:12:03,140 --> 00:12:07,130
Seperti pointer penting karena memberi kita cara untuk membedakan antara

133
00:12:07,130 --> 00:12:10,220
pointer yang harus dan tidak boleh dereferenced.

134
00:12:10,220 --> 00:12:13,050
Jika Anda mencoba untuk dereference pointer nol,

135
00:12:13,050 --> 00:12:17,150
biasanya program anda akan crash dengan kesalahan segmentasi,

136
00:12:17,150 --> 00:12:19,210
yang Anda mungkin telah melihat sebelumnya.

137
00:12:19,210 --> 00:12:30,490
Jadi, katakanlah kita memiliki kode int * x = null; * x = 4.

138
00:12:30,490 --> 00:12:36,190
Dalam contoh ini, mungkin tampak jelas bahwa kita sedang melakukan sesuatu yang buruk,

139
00:12:36,190 --> 00:12:40,650
tapi ingat bahwa nol benar-benar bisa menjadi nilai kembali dari panggilan ke fungsi

140
00:12:40,650 --> 00:12:45,930
seperti malloc, jika malloc tidak dapat mengalokasikan memori yang diminta oleh pengguna.

141
00:12:45,930 --> 00:12:50,200
Untuk alasan ini, jika sebaliknya kita menetapkan nilai x dari panggilan untuk malloc,

142
00:12:50,200 --> 00:13:12,050
seperti dalam int * x = malloc (sizeof (int)), maka kita harus selalu memeriksa eksplisit

143
00:13:12,050 --> 00:13:15,280
untuk melihat apakah null dikembalikan.

144
00:13:15,280 --> 00:13:43,250
Jika (x == null); / / uhoh! return; lain kita dapat melanjutkan dan mengatakan * x = 4.

145
00:13:43,250 --> 00:13:47,780
>> Jadi, sekali lagi, mengapa harus kita pernah menggunakan pointer?

146
00:13:47,780 --> 00:13:51,910
Mari kita lihat contoh program di mana kita perlu menggunakan pointer -

147
00:13:51,910 --> 00:13:54,110
fungsi sederhana swap.

148
00:13:54,110 --> 00:14:08,270
Katakanlah saya memiliki dua bilangan bulat, int x = 4, dan int y = 15;

149
00:14:08,270 --> 00:14:21,220
dan saya ingin menulis sebuah fungsi yang disebut swap yang dapat saya gunakan seperti: swap (x, y).

150
00:14:21,220 --> 00:14:28,270
Setelah baris ini, nilai-nilai dalam variabel x harus 15,

151
00:14:28,270 --> 00:14:32,360
dan nilai dalam variabel y harus 4.

152
00:14:32,360 --> 00:14:36,510
Nilai-nilai dalam x dan y telah bertukar.

153
00:14:36,510 --> 00:14:53,040
Tanpa pointer, kita mungkin mencoba sesuatu seperti swap void (int a, int b);

154
00:14:53,040 --> 00:15:09,750
int tmp = b, b = a; a = tmp.

155
00:15:09,750 --> 00:15:12,960
Tapi, apakah Anda melihat masalah dengan ini?

156
00:15:12,960 --> 00:15:19,000
Ingat bahwa nilai yang disimpan dalam variabel hanyalah sebuah salinan dari nilai x,

157
00:15:19,000 --> 00:15:22,000
dan nilai dalam b disalin dari y.

158
00:15:22,000 --> 00:15:28,000
Setiap perubahan yang dibuat untuk a dan b tidak akan tercermin dalam x dan y.

159
00:15:28,000 --> 00:15:32,050
Jadi, sementara nilai-nilai a dan b dengan benar bertukar,

160
00:15:32,050 --> 00:15:35,810
x dan y tidak berubah sama sekali.

161
00:15:35,810 --> 00:15:38,480
Sekarang, mari kita mengubah fungsi swap sehingga argumen nya

162
00:15:38,480 --> 00:15:42,180
adalah pointer ke variabel itu harus swap, seperti:

163
00:15:42,180 --> 00:15:56,880
Swap void (int * a, int * b); int tmp = * b; * b = * a; * a = tmp.

164
00:15:56,880 --> 00:16:00,140
Ingat bahwa swap argumen sekarang pointer,

165
00:16:00,140 --> 00:16:05,670
dan jadi kita perlu melewati alamat x dan y dalam panggilan untuk swap, seperti:

166
00:16:05,670 --> 00:16:15,280
swap (& x, & y).

167
00:16:15,280 --> 00:16:20,520
Ini sekarang benar swap nilai-nilai x dan y.

168
00:16:20,520 --> 00:16:24,310
>> Mari kita menggambar diagram kotak-dan-panah untuk melihat mengapa ini bekerja.

169
00:16:24,310 --> 00:16:28,520
Kita mulai dengan dua kotak dalam memori, x dan y.

170
00:16:28,520 --> 00:16:35,780
Di dalam kotak untuk x adalah nomor 4, dan dalam kotak untuk y kita memiliki 15.

171
00:16:35,780 --> 00:16:41,200
Sekarang, dalam panggilan ke fungsi swap, kita memiliki dua kotak lagi

172
00:16:41,200 --> 00:16:45,140
untuk argumen a dan b;

173
00:16:45,140 --> 00:16:50,960
poin ke kotak untuk x, dan poin b ke kotak untuk y.

174
00:16:50,960 --> 00:16:58,070
Sebuah kotak baru dibuat untuk tmp variabel,

175
00:16:58,070 --> 00:17:01,470
dan di dalamnya kita menyimpan hasil dereferencing b,

176
00:17:01,470 --> 00:17:04,980
yang berarti 'mengikuti panah dari kotak berlabel b.'

177
00:17:04,980 --> 00:17:09,880
Jadi, kita menyimpan 15 dalam tmp.

178
00:17:09,880 --> 00:17:20,560
Kemudian, kita mengikuti panah di b dan menyimpan di sini hasil dari suatu dereferencing,

179
00:17:20,560 --> 00:17:24,569
yang merupakan nilai 4.

180
00:17:24,569 --> 00:17:35,590
Akhirnya, kita mengikuti panah di toko dan apa yang saat ini dalam tmp, yaitu 15.

181
00:17:35,590 --> 00:17:42,440
Perhatikan bahwa kotak berlabel x dan y telah benar bertukar nilai-nilai.

182
00:17:42,440 --> 00:17:46,290
>> Setelah kita mempelajari lebih lanjut tentang malloc dan manajemen memori dinamis,

183
00:17:46,290 --> 00:17:49,610
kita akan melihat bahwa kita tidak punya pilihan selain menggunakan pointer.

184
00:17:49,610 --> 00:17:52,690
Berjalan melalui diagram kotak-dan-panah untuk program apapun

185
00:17:52,690 --> 00:17:55,980
dapat membantu Anda mengetahui program apa yang benar-benar melakukan.

186
00:17:55,980 --> 00:17:59,680
>> Nama saya Rob Bowden, dan ini adalah CS50.

187
00:18:00,000 --> 00:18:02,500
[CS50.TV]

188
00:18:02,500 --> 00:18:06,070
>> Ini adalah penggunaan yang berbeda untuk tanda bintang - bleah, aku benci kata itu.

189
00:18:06,070 --> 00:18:13,960
Di mana saja kita digunakan untuk hanya mengatakan n, kita sekarang dapat mengatakan pointer_to_n - tidak Anda tak bisa - pointer_to_n *.