Artikel ini adalah mengenai konsep penuding kepada penuding dalam C++. Penunjuk ke penunjuk menunjuk atau menyimpan alamat penuding lain dan membolehkan manipulasi penunjuk itu sendiri. Menggunakan konsep ini, kita boleh mengubah suai penunjuk dari lokasi lain dalam memori dengan mudah. Penunjuk berganda bermanfaat dalam memori yang diperuntukkan secara dinamik atau tatasusunan berbilang dimensi untuk memanipulasi elemen tatasusunan. Kami akan membincangkan penunjuk ini kepada penunjuk berfungsi dan penggunaan dalam C++ dengan contoh yang betul.
Senario 1: Perwakilan Memori Penunjuk kepada Penunjuk
Dalam senario ini, pengisytiharan penunjuk berganda adalah serupa dengan pengisytiharan penuding dengan asterisk tambahan (*) sebelum nama penuding. Kita boleh dengan mudah mewakili lokasi memori penunjuk berganda dalam C++. Coretan kod penuding ke penuding diberikan dalam perkara berikut:
#include
menggunakan ruang nama std;
int utama ( )
{
digit int = lima puluh ;
int * ptrr;
ptrr = & digit;
int ** ptrr1;
ptrr1 = & ptrr;
cout << 'Alamat memori penunjuk ialah: \n ' ;
cout << 'ptrr (penunjuk): ' << ptrr << ' \n ' ;
cout << '*ptrr1 (penunjuk berganda): ' <<* ptrr1 << ' \n ' ;
cout << ' Nilai yang disimpan dalam penunjuk ialah: \n ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (penunjuk ke penunjuk) = ' <<** ptrr1 << endl;
kembali 0 ;
}
Dalam fungsi utama, kami mengambil pembolehubah yang alamat memorinya perlu disimpan dalam penunjuk. Sekarang, kami memulakan pembolehubah 'digit'. Selepas itu, kami mengisytiharkan penunjuk 'ptrr' yang menyimpan alamat memori 'digit'. Sekarang, kami mengisytiharkan penunjuk berganda yang namanya '**ptrr1' yang menyimpan alamat penuding '*ptrr'. Pada penghujung kod, kami memaparkan memori dan nilai penuding dan penuding berganda pada skrin konsol. Output kod ini disebut dalam perkara berikut:
Alamat memori penunjuk 'ptrr' ialah '0x6ffe04', dan penunjuk '*ptrr1' juga menyimpan alamat memori penunjuk 'ptrr'. Nilai yang disimpan di dalam penunjuk ialah '50'. Pada asasnya, alamat penuding berganda sentiasa sama dengan alamat memori penuding.
Senario 2: Tuding ke Penuding sebagai Parameter Fungsi
Dalam senario ini, kita akan belajar cara menghantar penunjuk berganda dalam mana-mana fungsi sebagai parameter untuk melaksanakan peruntukan memori sementara dalam mana-mana pembolehubah. Coretan kod parameter fungsi dengan penuding berganda disebut dalam perkara berikut:
#include
batal getMemoryAddress ( int ** double_ptr ) {
cuaca awak = 200 ;
* double_ptr = & temp;
}
int utama ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << 'Nilai **double_ptr ialah : ' << ** double_ptr << std::endl;
kembali 0 ;
}
Di sini, kita akan belajar bagaimana konsep penuding kepada penuding berfungsi dalam C++. Ingat bahawa satu penunjuk diisytiharkan dalam program untuk berfungsi dengan penunjuk berganda. Jadi, kami membina fungsi 'getMemoryAddress'. Kami mereka bentuk fungsi ini supaya apabila kami melepasi parameter, ia secara automatik mendapat alamat memori penunjuk berganda.
Dalam fungsi, kami mengambil pembolehubah 'tempp' dan penunjuk berganda '**double_ptr'. Kami menghantar alamat pembolehubah yang ditentukan iaitu 'tempp' kepada penunjuk berganda dan nilai penunjuk berganda sebagai hujah fungsi. Program ini memaparkan hasil kod fungsi utama pada skrin konsol, jadi semua perkara yang terdapat dalam fungsi utama boleh dilaksanakan. Kami mengambil penunjuk 'ptr_1' dan penunjuk berganda sebagai 'double_ptr' dalam fungsi utama. Kami menghantar alamat penuding kepada penuding berganda.
Sekarang, kita lulus pembolehubah penunjuk berganda dalam fungsi override dan lulus penuding kepada pembolehubah penunjuk dalam pernyataan aliran keluaran 'cout' untuk menunjukkan hasil penunjuk berganda.
Apabila pengkompil mencapai fungsi override, penyemak pengkompil di mana fungsi ini ditakrifkan melaksanakan kod di dalam fungsi dan mengembalikan hasilnya kepada fungsi utama.
Output kod ini dilampirkan dalam yang berikut:
Keputusan: Nilai penunjuk berganda ialah 200.
Senario 3: Menggunakan Tatasusunan 2D dengan Penunjuk ke Penunjuk
Dalam contoh ini, kita akan berurusan dengan tatasusunan 2D yang mempunyai penuding berganda. Kami mengambil tatasusunan dan menghantar alamat tatasusunan dalam penuding. Kod lengkap senario ini disediakan seperti berikut:
int utama ( ) {baris int const = 3 ;
const int cols = 2 ;
int ** matriks = int baharu * [ barisan ] ;
untuk ( int i = 0 ; i < baris; ++i ) {
matriks [ i ] = int baharu [ cols ] ;
}
untuk ( int i = 0 ; i < baris; ++i ) {
untuk ( int j = 0 ; j < cols; ++j ) {
matriks [ i ] [ j ] = i * kol + j;
}
}
untuk ( int i = 0 ; i < baris; ++i ) {
untuk ( int j = 0 ; j < cols; ++j ) {
cout << matriks [ i ] [ j ] << ' ' ;
}
cout << endl;
}
untuk ( int i = 0 ; i < baris; ++i ) {
padam [ ] matriks [ i ] ;
}
padam [ ] matriks;
kembali 0 ;
}
Seperti yang kita sedia maklum, kita mempunyai banyak baris dan beberapa lajur dalam tatasusunan 2D. Dalam fungsi utama, kami memulakan baris dan lajur yang mempunyai 'const int'. Selepas itu, kami memperuntukkan ruang memori untuk baris dan ruang memori untuk lajur di sepanjang setiap baris. Kami menghantar bilangan nilai baris sebagai penunjuk dalam penuding berganda matriks sebagai '**matriks'. Dalam penunjuk berganda ini, gelung bilangan baris dilaksanakan atau benar. Kemudian, satu lagi gelung dalaman dilaksanakan sehingga keadaan menjadi palsu.
Selepas peruntukan memori, kami menetapkan nilai dalam tatasusunan sekali lagi: gelung luar untuk baris dan gelung dalam untuk lajur tatasusunan 2D. Dalam gelung dalam, nilai baris dan lajur diberikan kepada penuding berganda dan melakukan operasi aritmetik yang diperlukan. Kami memaparkan nilai tatasusunan 2D seperti bilangan baris dan lajur yang diperuntukkan dalam memori. Bilangan baris dan lajur sentiasa menghala ke penunjuk berganda yang menyimpan nilai baris dan lajur. Pada akhirnya, kami mengosongkan memori dan mengagihkan tatasusunan ini daripada memori dalam C++.
Output tatasusunan 2D dengan penuding berganda dilampirkan dalam perkara berikut:
Senario 4: Menukar Penunjuk Menggunakan Penunjuk kepada Penunjuk
Di sini, kita akan belajar cara menukar penunjuk dalam C++ dengan mengisytiharkan penunjuk berganda. Coretan kod senario ini dilampirkan dalam perkara berikut:
#includepertukaran batal ( int ** ptrr_1, awak ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int utama ( ) {
int x = lima belas , y = 25 ;
int * ptrrA = & x, * ptrrB = & dan;
std::cout << 'Sebelum menukar: *ptrrA ialah = ' << * ptrrA << ', *ptrrB ialah = ' << * ptrrB << std::endl;
bertukar-tukar ( & ptrrA, & ptrrB ) ;
std::cout << 'Selepas pertukaran: *ptrrA adalah = ' << * ptrrA << ', *ptrrB adalah=' << * ptrrB << std::endl;
kembali 0 ;
}
Pertama, kita membina fungsi swap, melepasi kedua-dua penunjuk sebagai hujah fungsi. Dalam fungsi swap, kami mengambil penunjuk 'temp' dan lulus nilai 'pointer1' dalam 'temp' untuk beberapa lama. Kemudian, kami menghantar nilai 'pointer2' kepada 'pointer1'. Pada akhirnya, kami menghantar nilai penunjuk 'temp' kepada 'penunjuk2'.
Dalam fungsi utama, kita memerlukan dua petunjuk yang kita luluskan atau tolak dalam fungsi 'swap'. Kami menghantar alamat pembolehubah kepada penunjuk yang diberikan. Kemudian, nilai penuding sebelum dan selepas menukar penuding dipaparkan.
Output kod ini dilampirkan dalam yang berikut:
Seperti yang dapat kita lihat, nilai penuding berjaya ditukar menggunakan penunjuk berganda dalam C++.
Kesimpulan
Kami membuat kesimpulan bahawa penuding kepada penuding sentiasa menyimpan alamat memori mana-mana penuding dalam C++. Kita boleh menggunakan penunjuk berganda untuk menggunakan lokasi memori untuk sebarang penuding buat sementara waktu pada bila-bila masa. Ini adalah cara yang sangat berkesan untuk memanipulasi alamat memori secara tidak langsung dan mendekati data.