Bahasa pengaturcaraan memerlukan perpustakaan, fungsi, sintaks dan perkara lain apabila bekerja dengannya. Oleh itu, ada kemungkinan kod kami akan mengandungi ralat. Pengaturcaraan dalam C++ mempunyai banyak jenis ralat yang berbeza. Kami akan membincangkan tentang ralat 'int tidak boleh dinyahrujuk dalam C++' di sini. Ralat ini berlaku apabila kami cuba menggunakan operator penyahrujukan “*” dengan data jenis integer “int” kerana “int” ialah jenis data primitif. Kami tidak boleh menolak 'int' dalam pengaturcaraan C++. Di sini, ralat 'int tidak boleh dinyahrujuk dalam C++' dan penyelesaiannya akan diterokai dengan teliti. Beberapa kod diberikan dalam panduan ini di mana kita akan melihat bagaimana ralat ini berlaku dan cara mengendalikan jenis ralat ini dalam C++.
Contoh 1: Dereferencing Int
Dalam kod ini, kami akan cuba menyahrujuk 'int' dalam C++. Sekarang, kami hanya memasukkan fail pengepala 'iostream' untuk menggunakan fungsi yang ditentukan. Di bawah ini, kami menggunakan 'ruang nama std' dan menggunakan kaedah 'utama()' di sini. Kemudian, kami mengisytiharkan pembolehubah 'my_num' dengan jenis data 'int' dan menetapkan '99' kepada pembolehubah ini.
Sekarang, kami mengisytiharkan 'my_value' jenis data 'int' dan memulakannya dengan '*my_num' yang bermaksud bahawa kami cuba menyahrujuk pembolehubah 'my_num' yang merupakan jenis data 'int'. Ralat dijana pada baris ini semasa menyusun kerana kami tidak boleh menafikan 'int'. Kami mahu memaparkan nilai yang kami dapat selepas membatalkan rujukan int, jadi kami meletakkan 'cout' di mana kami menambah pembolehubah 'my_value'.
Kod 1:
#include
menggunakan ruang nama std;
int utama ( ) {
int my_num = 99 ;
int my_value = * my_num;
cout << 'Nilai yang kami dapat melalui penyahrujukan int ialah: ' << my_value << endl;
kembali 0 ;
}
Pengeluaran:
Di sini, kita mungkin dapati bahawa tiada nilai dipaparkan dan ralat berlaku yang mengatakan bahawa terdapat hujah jenis tidak sah bagi '*'. Ini bermakna kita tidak boleh menolak 'int' dalam C++.
Penyelesaian 1: Tanpa Dereferencing
Di sini, kita akan mendapat nilai integer secara langsung tanpa dereferencing. Kami mengimport fail pengepala 'iostream' kerana beberapa definisi fungsi hadir. Kemudian, kami menaip 'ruang nama std' bersama-sama dengan kata kunci 'menggunakan' dan kemudian memanggil kaedah 'utama()' di sini. Sekarang, kami memulakan pembolehubah 'my_num' jenis data 'int' dengan nilai '99'.
Kemudian, kami memulakan pembolehubah lain dengan nama 'my_value' dan menetapkannya dengan pembolehubah 'my_num' yang mengandungi nombor integer. Selepas ini, kita mendapat nilai integer ini secara langsung tanpa membuat rujukan dengan meletakkan 'my_value' dalam 'cout'. Ini mendapat dan memaparkan nilai integer.
Kod 1:
#includemenggunakan ruang nama std;
int utama ( ) {
int my_num = 99 ;
int my_value = my_num;
cout << 'Nilai yang kami perolehi tanpa mengabaikan int ialah: ' << my_value << endl;
kembali 0 ;
}
Pengeluaran:
Nilai integer diberikan di sini yang kami dapat tanpa membuat rujukan dalam kod C++ kami. Kami terus mengakses nilai integer ini dan memaparkannya.
Penyelesaian 2: Dengan Menyahrujuk Penunjuk
Fail pengepala 'iostream' mengandungi definisi fungsi tertentu; kami mengimportnya. Seterusnya, kami menjalankan fungsi 'main()' di sini selepas menaip 'namespace std' dan kata kunci 'menggunakan'. Pembolehubah 'my_num' jenis data 'int' kini dimulakan dengan nilai '99'.
Selepas ini, kami memulakan penunjuk 'my_ptr' dan menetapkan alamat pembolehubah 'my_num' kepada penunjuk ini. Di bawah ini, kami tidak merujuk penuding dan menetapkan nilai yang kami peroleh melalui ini kepada pembolehubah 'my_value' semasa kami memulakan 'my_value' dengan '*my_ptr'. Sekarang, kita letakkan 'cout' di mana kita lulus pembolehubah 'my_value' untuk memaparkan nilai integer yang kita dapat melalui penyahrujukan penunjuk.
Kod 2:
#includemenggunakan ruang nama std;
int utama ( ) {
int my_num = 99 ;
int * my_ptr = & my_num;
int my_value = * my_ptr;
cout << 'Nilai int yang kita perolehi dengan membatalkan rujukan penunjuk ialah: ' << my_value << endl;
kembali 0 ;
}
Pengeluaran:
Nilai integer yang kami perolehi selepas menyahrujuk penuding dalam kod kami kini dipaparkan di sini. Jadi, ini adalah cara yang betul untuk menggunakan penyahrujukan dalam C++.
Contoh 2: Dereferencing Int
Mari cuba untuk menyahrujuk 'int' dalam C++ dalam kod ini. Untuk menggunakan fungsi yang ditakrifkan dalam 'iostream', kami hanya perlu memasukkan fail pengepala 'iostream'. Di sinilah kita menggunakan 'ruang nama std' dan memanggil fungsi 'utama()'. Seterusnya, kami mencipta pembolehubah 'a' dan memberikannya jenis data 'int' bersama-sama dengan nilai '75'.
Di bawah ini, kami mencipta penunjuk bernama 'newPointer' dan menetapkan alamat pembolehubah 'a' kepada penunjuk ini dengan bantuan '&'. Kemudian, kami memulakan pembolehubah 'num' di bawah dengan '*a' yang menunjukkan bahawa kami cuba menyahrujuk pembolehubah 'a' yang merupakan jenis data 'int'. Memandangkan kita tidak boleh membatalkan rujukan 'int', ralat kini dihasilkan pada baris ini semasa penyusunan. Selepas ini, kami juga menggunakan 'cout' di mana kami menambah pembolehubah 'num'.
Kod 2:
#includemenggunakan ruang nama std;
int utama ( ) {
int a = 75 ;
int * newPointer = & a;
nombor int = * a;
cout << 'Nilai penyahrujukan int ialah: ' << pada satu << endl;
kembali 0 ;
}
Pengeluaran:
Di sini, kita dapat melihat bahawa tiada nilai ditunjukkan dan mesej ralat yang menyatakan 'parameter jenis tidak sah bagi unary'*' muncul. Ini menunjukkan bahawa 'int' tidak boleh dinyahrujuk dalam C++.
Penyelesaian 1: Tanpa Dereferencing
Kami tidak perlu membatalkan rujukan untuk mendapatkan nilai integer dengan segera. Kami mengimportnya kerana fail pengepala 'iostream' mengandungi definisi fungsi tertentu. Fungsi 'utama()' kemudiannya digunakan selepas kata kunci 'menggunakan' dan 'ruang nama std' dimasukkan. Pembolehubah 'a' jenis data 'int' kini dimulakan dengan nilai '75'. Selepas itu, kami memasukkan 'a' ke dalam 'cout' untuk mendapatkan nilai integer ini dengan serta-merta tanpa membatalkan rujukan. Ini mendapatkan semula nilai integer dan menunjukkannya di sini.
Kod 1:
#includemenggunakan ruang nama std;
int utama ( ) {
int a = 75 ;
cout << 'Nilai yang kami dapat tanpa dereferencing ialah: ' << a << endl;
kembali 0 ;
}
Pengeluaran:
Nilai integer yang diperoleh daripada kod C++ kami tanpa dereferencing dibentangkan di sini. Nilai integer ini boleh diakses serta-merta dan ditunjukkan di sini.
Penyelesaian 2:
Kami mengimport fail pengepala 'iostream' yang mengandungi beberapa definisi fungsi. Di sini, kami menaip 'ruang nama std' dan kata kunci 'menggunakan' sebelum melaksanakan fungsi 'utama()'. Nilai '75' diberikan kepada pembolehubah 'a'.
Seterusnya, kami mengisytiharkan penunjuk yang dipanggil 'mypointer' dan memulakannya dengan alamat pembolehubah 'a' kepadanya. Di bawah ini, kami tidak merujuk penuding dan menetapkan nilai yang kami peroleh daripada ini kepada pembolehubah 'hasil' semasa kami memulakan 'hasil' dengan '*mypointer'. Selepas menyahrujuk penuding, kami meletakkan arahan 'cout' dan lulus pembolehubah 'hasil' untuk menunjukkan nilai integer.
Kod 2:
#includemenggunakan ruang nama std;
int utama ( ) {
int a = 75 ;
int * mypointer = & a;
int hasil = * mypointer;
cout << 'Nilai yang kita dapat melalui penyahrujukan penunjuk ialah: ' << hasil << endl;
kembali 0 ;
}
Pengeluaran:
Ini adalah teknik yang betul untuk menggunakan penyahrujukan dalam C++. Ia menjadikan nilai integer yang kami perolehi selepas menyahrujuk penuding dan bukannya menafikan 'int'.
Kesimpulan
Kami meneroka bahawa apabila kami cuba mendapatkan nilai dengan membatalkan rujukan 'int' dalam C++, 'parameter jenis tidak sah bagi ralat unary '*' mempunyai int' akan berlaku yang bermaksud bahawa 'int tidak boleh dinyahrujuk dalam C++'. Kami juga menerangkan penyelesaian kepada ralat ini. Kami menggunakan kod di mana ralat berlaku dan kod yang kami menyediakan penyelesaian ralat itu dalam panduan ini.