Artikel ini membahas tentang konsep pointer ke pointer di C++. Pointer ke pointer menunjuk atau menyimpan alamat pointer lain dan memungkinkan manipulasi pointer itu sendiri. Dengan menggunakan konsep ini, kita dapat dengan mudah memodifikasi pointer dari lokasi lain di memori. Pointer ganda bermanfaat dalam memori yang dialokasikan secara dinamis atau array multidimensi untuk memanipulasi elemen array. Kita akan membahas cara kerja dan penggunaan pointer ke pointer di C++ dengan contoh yang tepat.
Skenario 1: Representasi Memori dari Pointer ke Pointer
Dalam skenario ini, mendeklarasikan penunjuk ganda serupa dengan mendeklarasikan penunjuk dengan tambahan tanda bintang (*) sebelum nama penunjuk. Kita dapat dengan mudah merepresentasikan lokasi memori dari penunjuk ganda di C++. Cuplikan kode dari pointer ke pointer diberikan sebagai berikut:
#termasuk
menggunakan namespace std;
ke utama ( )
{
ke dalam angka = lima puluh ;
ke dalam * ptrr;
ptrr = & angka;
ke dalam ** ptrr1;
ptrr1 = & ptrr;
cout << 'Alamat memori penunjuk adalah: \N ' ;
cout << 'ptrr (penunjuk): ' << ptrr << ' \N ' ;
cout << '*ptrr1 (penunjuk ganda): ' <<* ptrr1 << ' \N ' ;
cout << ' Nilai yang disimpan dalam pointer adalah: \N ' ;
cout << '*ptrr = ' <<* ptrr << akhir;
cout << '**ptrr1 (penunjuk ke penunjuk) = ' <<** ptrr1 << akhir;
kembali 0 ;
}
Dalam fungsi utama, kita mengambil variabel yang alamat memorinya perlu disimpan dalam sebuah pointer. Sekarang, kita menginisialisasi variabel “digit”. Setelah itu, kita mendeklarasikan pointer “ptrr” yang menyimpan “digit” alamat memori. Sekarang, kita mendeklarasikan penunjuk ganda bernama “**ptrr1” yang menyimpan alamat penunjuk “*ptrr”. Di akhir kode, kami menampilkan memori dan nilai penunjuk dan penunjuk ganda di layar konsol. Output dari kode ini disebutkan sebagai berikut:
Alamat memori penunjuk “ptrr” adalah “0x6ffe04”, dan penunjuk “*ptrr1” juga menyimpan alamat memori penunjuk “ptrr”. Nilai yang disimpan di dalam pointer adalah “50”. Pada dasarnya alamat penunjuk ganda selalu sama dengan alamat memori penunjuk.
Skenario 2: Penunjuk ke Penunjuk sebagai Parameter Fungsi
Dalam skenario ini, kita akan mempelajari cara meneruskan penunjuk ganda di fungsi apa pun sebagai parameter untuk melakukan alokasi memori sementara di variabel apa pun. Cuplikan kode parameter fungsi dengan penunjuk ganda disebutkan sebagai berikut:
#termasuk
batalkan getMemoryAddress ( ke dalam ** ganda_ptr ) {
cuacamu = 200 ;
* ganda_ptr = & tempp;
}
ke utama ( ) {
ke dalam * ptr_1;
ke dalam ** ganda_ptr;
ganda_ptr = & ptr_1;
dapatkanMemoryAddress ( ganda_ptr ) ;
std::cout << 'Nilai **double_ptr adalah : ' << ** ganda_ptr << std::endl;
kembali 0 ;
}
Di sini, kita akan mempelajari cara kerja konsep pointer ke pointer di C++. Ingatlah bahwa satu penunjuk dideklarasikan dalam program untuk bekerja dengan penunjuk ganda. Jadi, kami membangun fungsi “getMemoryAddress”. Kami merancang fungsi ini sehingga ketika kami meneruskan parameter, secara otomatis mendapatkan alamat memori dari penunjuk ganda.
Dalam fungsinya, kita mengambil variabel “tempp” dan penunjuk ganda “**double_ptr”. Kami meneruskan alamat variabel tertentu yaitu 'tempp' ke penunjuk ganda dan nilai penunjuk ganda sebagai argumen fungsi. Program menampilkan hasil kode fungsi utama di layar konsol, sehingga semua hal yang ada di fungsi utama dapat dieksekusi. Kami mengambil penunjuk “ptr_1” dan penunjuk ganda sebagai “double_ptr” di fungsi utama. Kami meneruskan alamat penunjuk ke penunjuk ganda.
Sekarang, kita meneruskan variabel penunjuk ganda dalam fungsi override dan meneruskan penunjuk ke variabel penunjuk dalam pernyataan aliran keluaran “cout” untuk menampilkan hasil penunjuk ganda.
Ketika kompiler mencapai fungsi override, pemeriksa kompiler tempat fungsi ini didefinisikan mengeksekusi kode di dalam fungsi dan mengembalikan hasilnya ke fungsi utama.
Output dari kode ini terlampir sebagai berikut:
Hasil: Nilai penunjuk ganda adalah 200.
Skenario 3: Menggunakan Array 2D dengan Pointer to Pointer
Dalam contoh ini, kita akan menangani array 2D yang memiliki penunjuk ganda. Kami mengambil array dan meneruskan alamat array di pointer. Kode lengkap skenario ini disediakan sebagai berikut:
ke utama ( ) {konstan ke dalam baris = 3 ;
konstan ke dalam kolom = 2 ;
ke dalam ** matriks = int baru * [ baris ] ;
untuk ( ke dalam saya = 0 ; Saya < baris; ++saya ) {
matriks [ Saya ] = int baru [ kol ] ;
}
untuk ( ke dalam saya = 0 ; Saya < baris; ++saya ) {
untuk ( ke dalam j = 0 ; J < kolom; ++j ) {
matriks [ Saya ] [ J ] = saya * kolom + j;
}
}
untuk ( ke dalam saya = 0 ; Saya < baris; ++saya ) {
untuk ( ke dalam j = 0 ; J < kolom; ++j ) {
cout << matriks [ Saya ] [ J ] << ' ' ;
}
cout << akhir;
}
untuk ( ke dalam saya = 0 ; Saya < baris; ++saya ) {
menghapus [ ] matriks [ Saya ] ;
}
menghapus [ ] matriks;
kembali 0 ;
}
Seperti kita ketahui bersama, kita memiliki banyak baris dan beberapa kolom dalam array 2D. Pada fungsi utama, kita menginisialisasi baris dan kolom yang memiliki “const int”. Setelah itu, kami mengalokasikan ruang memori untuk baris dan ruang memori untuk kolom di setiap baris. Kami meneruskan nilai jumlah baris sebagai penunjuk dalam penunjuk ganda matriks sebagai '**matriks'. Dalam penunjuk ganda ini, perulangan jumlah baris dieksekusi atau benar. Kemudian, perulangan dalam lainnya dijalankan hingga kondisi berubah menjadi salah.
Setelah alokasi memori, kami menetapkan nilai lagi dalam array: loop luar untuk baris dan loop dalam untuk kolom array 2D. Di loop dalam, nilai baris dan kolom ditetapkan ke penunjuk ganda dan melakukan operasi aritmatika yang diperlukan. Kami menampilkan nilai array 2D seperti jumlah baris dan kolom yang dialokasikan dalam memori. Jumlah baris dan kolom selalu menunjuk ke penunjuk ganda yang menyimpan nilai baris dan kolom. Pada akhirnya, kami mengosongkan memori dan membatalkan alokasi array ini dari memori di C++.
Output dari array 2D dengan penunjuk ganda dilampirkan sebagai berikut:
Skenario 4: Menukar Pointer Menggunakan Pointer ke Pointer
Di sini, kita akan mempelajari cara menukar pointer di C++ dengan mendeklarasikan pointer ganda. Cuplikan kode skenario ini terlampir sebagai berikut:
#termasukbatalkan pertukaran ( ke dalam ** ptrr_1, kamu ** ptrr_2 ) {
ke dalam * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
ke utama ( ) {
ke dalam x = limabelas , kamu = 25 ;
ke dalam * ptrrA = & X, * ptrrB = & Dan;
std::cout << 'Sebelum menukar: *ptrrA adalah = ' << * ptrrA << ', *ptrrB adalah = ' << * ptrrB << std::endl;
menukar ( & ptrrA, & ptrrB ) ;
std::cout << 'Setelah pertukaran: *ptrrA is = ' << * ptrrA << ', *ptrrB adalah= ' << * ptrrB << std::endl;
kembali 0 ;
}
Pertama, kita membangun fungsi swap, meneruskan kedua pointer sebagai argumen fungsi. Dalam fungsi swap, kita mengambil pointer “temp” dan meneruskan nilai “pointer1” ke “temp” selama beberapa waktu. Kemudian, kita meneruskan nilai “pointer2” ke “pointer1”. Pada akhirnya, kami meneruskan nilai penunjuk “temp” ke “penunjuk2”.
Pada fungsi utama, kita memerlukan dua pointer yang kita lewati atau timpa pada fungsi “swap”. Kami meneruskan alamat variabel ke pointer yang diberikan. Kemudian, nilai penunjuk sebelum dan sesudah menukar penunjuk ditampilkan.
Output dari kode ini terlampir sebagai berikut:
Seperti yang bisa kita lihat, nilai penunjuk berhasil ditukar menggunakan penunjuk ganda di C++.
Kesimpulan
Kami menyimpulkan bahwa pointer ke pointer selalu menyimpan alamat memori dari setiap pointer di C++. Kita dapat menggunakan penunjuk ganda untuk menggunakan sementara lokasi memori penunjuk mana pun kapan saja. Ini adalah cara yang sangat efektif untuk memanipulasi alamat memori secara tidak langsung dan mendekati data.