Artikel ini adalah mengenai aritmetik penunjuk dalam C++. Penunjuk ialah pembolehubah yang menyimpan alamat memori data. Aritmetik penunjuk ialah ciri penting dalam dunia bahasa pengaturcaraan C++ yang membenarkan kita berurusan dengan operasi aritmetik yang berbeza di mana penambahan, pendaraban, pembahagian, kenaikan, pengurangan dan penolakan melibatkan penuding untuk membangunkan alamat memori baharu dalam penimbal ingatan kita. . Aritmetik penunjuk dengan mudah mencipta peruntukan memori dinamik. Dalam artikel C++ ini, kita akan belajar cara memanipulasi alamat memori dengan cara yang berbeza dengan bantuan penunjuk dan menyediakan garis panduan dan contoh yang betul.
Senario 1: Penunjuk Melaksanakan Operasi Penambahan dan Penurunan
Di sini, kita akan belajar tentang manipulasi penunjuk untuk menghasilkan alamat memori yang berbeza yang mempunyai tujuan yang berbeza. Penunjuk kenaikan dan penurunan juga merupakan aritmetik penunjuk leverage yang menambah atau mengurangkan alamat dengan faktor satu didarab dengan saiz jenis data yang ditunjukkan olehnya. Coretan kod yang berkaitan dengan senario ini dilampirkan dalam perkara berikut:
#include
menggunakan ruang nama std;
const int Arr_Max = 5 ;
int utama ( ) {
int di mana [ Arr_Max ] = { dua puluh , 150 , 270 } ;
int * ptr; // mengisytiharkan penunjuk
ptr = var;
untuk ( int i = 0 ; i < Arr_Max; i++ ) {
std::cout << 'Alamat ingatan elemen ialah : [' << i << '] = ' ;
std::cout << ptr << endl;
cout << 'Nilai berbanding alamat ialah [' << i << '] = ' ;
cout << * ptr << endl;
std::cout << 'penunjuk berjaya dinaikkan' << endl;
ptr++;
}
std::cout << 'Alamat penunjuk sebelum pengurangan' << ptr << endl;
ptr--;
std::cout << 'Alamat penunjuk selepas pengurangan' << ptr << endl;
kembali 0 ;
}
Di sini, kami mentakrifkan pustaka yang diperlukan dalam kod pada permulaannya: '
Kami menghantar tatasusunan kepada penuding untuk mengakses alamat. Seperti yang kita sedia maklum, tatasusunan sentiasa mengandungi berbilang item di lokasi yang berbeza. Jadi, kami memerlukan gelung dengan penuding 'bantuan' untuk mengakses setiap elemen tatasusunan. Setiap kali gelung dilaksanakan, kami mendapat alamat memori dan nilai terhadap alamat ini dengan bantuan pengendali kenaikan 'ptr++' aritmetik penuding yang mengalihkan alamat memori ke alamat memori seterusnya. Kitaran pelaksanaan gelung bergantung pada saiz tatasusunan. Di luar gelung, kami ingin mengembalikan penuding ke alamat memori sebelumnya dengan hanya menggunakan penuding penurunan “ptr- -” .
Jalankan kod ini dengan mengklik pilihan Laksanakan> Susun & Jalankan dan anda akan mendapat output berikut:
Semoga output ini mudah difahami. Alamat dan nilai memori ditukar. Mengalihkan penuding dari satu lokasi hanya boleh dilakukan daripada aritmetik penuding kenaikan dalam C++.
Senario 2: Menolak Dua Penunjuk dalam C++
Dalam senario ini, kita akan belajar bagaimana untuk menolak dua atau lebih penunjuk dalam C++. Semua operasi aritmetik di mana penolakan datang adalah proses penting kerana kita hanya boleh menolak dua penunjuk secara serentak jika dan hanya jika ia mempunyai jenis data yang sama.
Operasi lain seperti penambahan, pendaraban dan pembahagian tidak boleh dilakukan dalam penunjuk kerana ia tidak masuk akal dalam menangani memori. Coretan kod dilampirkan dalam perkara berikut:
#includeint utama ( ) {
Dia memberi isyarat [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Untuk itu [ 3 ] ; // Penunjuk kepada elemen ketiga ( 42 )
int * ptrr2 = & Untuk itu [ 6 ] ; // Penunjuk kepada unsur keenam ( 89 )
ptrdiff_t ptrtolak = ptrr2 - ptrr1;
std::cout << 'Perbezaan antara alamat ini ialah: ' << ptrtolak << 'elemen' << std::endl;
kembali 0 ;
}
Operasi penolakan mencari perbezaan antara alamat memori dalam C++. Dalam fungsi utama, kami mengambil tatasusunan yang mengandungi nilai yang berbeza pada indeks yang berbeza. Dalam tatasusunan, setiap indeks mempunyai lokasi memori yang berbeza. Kita hanya boleh mencari perbezaan antara dua penunjuk dengan bantuan aritmetik penunjuk. Di sini, kami menggunakan jenis penunjuk khas 'ptrdiff_t' yang mesti digunakan untuk mencari perbezaan antara dua atau lebih penunjuk dalam C++.
Output kod ini dilampirkan dalam yang berikut:
Perbezaan antara alamat ini adalah dengan elemen ragum iaitu 3.
Senario 3: Bandingkan Dua atau Lebih Penunjuk dalam C++
Dalam senario ini, kita akan belajar cara membandingkan penunjuk yang berbeza dalam C++ menggunakan pengendali hubungan yang berbeza seperti “==”, “<=”, “>=”, “<”, ”>”. Kita hanya boleh membandingkan penunjuk jika ia menunjuk ke alamat elemen tatasusunan yang sama. Ingat bahawa membandingkan dua penunjuk dengan jenis yang berbeza boleh menyebabkan tingkah laku yang tidak ditentukan. Coretan kod yang berkaitan dengan perbandingan penuding disebut dalam perkara berikut:
#includemenggunakan ruang nama std;
int utama ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , sebelas , 14 , 16 , 18 , dua puluh , 22 , 25 } ;
int * ptr1 = & arr1 [ 3 ] ;
int * ptr2 = & arr1 [ 6 ] ;
int * ptr3 = & arr1 [ 8 ] ;
int * ptr4 = & arr1 [ 9 ] ;
jika ( ptr1 ==ptr2 )
{
std::cout << 'penunjuk adalah sama' << endl;
}
lain jika ( ptr3 < =ptr4 )
{
std::cout << 'ptr3 kurang daripada atau sama dengan ptr4' << endl ;;
}
lain
{
std::cout << 'petunjuk tidak dibandingkan pada mana-mana peringkat' << endl;
}
kembali 0 ;
}
Di sini, kami mengambil tatasusunan dengan 10 elemen. Kami mengisytiharkan empat penunjuk yang menunjuk kepada indeks tatasusunan yang berbeza. Selepas itu, kami membandingkan empat penunjuk ini pada keadaan yang berbeza seperti yang dilihat dalam kod yang diberikan. Dalam keadaan 'jika', semak sama ada penunjuk 'ptr1' sama dengan penunjuk 'ptr2', dan kemudian cetak 'penunjuk adalah sama'. Apabila kita mempunyai berbilang syarat di mana kita menggunakan syarat 'else if' untuk menyemak sama ada penunjuk 'ptr3' kurang daripada sama dengan penunjuk 'ptr4'. Selepas semua itu, klik pada Laksanakan > Susun & Jalankan pilihan.
Output kod ini dilampirkan dalam yang berikut:
Ia memaparkan keadaan yang sah pada skrin konsol dan keluar dari kompilasi. Penunjuk 'ptr3' mengandungi nilai yang kurang daripada atau sama dengan nilai penunjuk penunjuk 'ptr4'.
Senario 4: Paparkan nombor Ganjil dengan Aritmetik Penunjuk
Di sini, kita akan melihat bagaimana kita boleh memperuntukkan memori secara dinamik untuk tatasusunan integer. Coretan kod yang berkaitan dengan kes ini diberikan dalam perkara berikut:
#includeint utama ( ) {
nombor int [ ] = { 1 , 12 , 33 , 24 , lima belas , 776 , 71 , 18 , 29 , lima puluh } ;
int * ptrr = nombor;
std::cout << 'Nombor ganjil dalam tatasusunan: ' ;
untuk ( int i = 0 ; i < 10 ; ++i ) {
jika ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
kembali 0 ;
}
Dalam fungsi utama, kami mengambil tatasusunan yang mengandungi 10 elemen. Kami memerlukan penunjuk yang menunjukkan semua elemen dalam tatasusunan untuk menyemak nombor ganjil dalam tatasusunan. Dalam gelung 'untuk', semak nombor ganjil dengan membahagikan elemen semasa tatasusunan. Pembilang penunjuk ditambah selepas memeriksa satu elemen tatasusunan.
Selepas melaksanakan kod, output dipaparkan pada skrin konsol yang diberikan dalam perkara berikut:
Dengan cara ini, kita boleh memaparkan nombor ganjil menggunakan aritmetik penunjuk pada skrin konsol.
Kesimpulan
Kami menyimpulkan di sini bahawa aritmetik penunjuk adalah alat yang paling berkesan yang melakukan operasi yang berbeza dalam C++. Pastikan penunjuk menambah atau mengurangkan nilai tatasusunan yang mempunyai jenis data yang sama. Kita boleh membandingkan nilai tatasusunan dengan alamat memori mereka dengan bantuan aritmetik penunjuk dalam bahasa pengaturcaraan C++. Kita boleh melintasi tatasusunan dan mengurus memori dengan mudah dengan bantuan aritmetik penunjuk.