Les langages de programmation ont besoin de bibliothèques, de fonctions, de syntaxe et d'autres éléments pour travailler avec eux. Il est donc possible que nos codes contiennent des erreurs. La programmation en C++ comporte de nombreux types d’erreurs distincts. Nous discuterons ici de l’erreur « int ne peut pas être déréférencé en C++ ». Cette erreur se produit lorsque nous essayons d'utiliser l'opérateur de déréférencement « * » avec les données de type entier « int » car « int » est un type de données primitif. Nous ne pouvons pas déréférencer le « int » dans la programmation C++. Ici, l'erreur « int ne peut pas être déréférencé en C++ » et sa solution seront explorées en profondeur. Quelques codes sont donnés dans ce guide dans lesquels nous verrons comment cette erreur se produit et comment gérer ce type d'erreur en C++.
Exemple 1 : déréférencement Int
Dans ce code, nous allons essayer de déréférencer le « int » en C++. Maintenant, nous incluons simplement le fichier d'en-tête « iostream » pour utiliser les fonctions définies. En dessous, nous utilisons le « namespace std » et invoquons ici la méthode « main() ». Ensuite, nous déclarons la variable « my_num » avec le type de données « int » et attribuons « 99 » à cette variable.
Maintenant, nous déclarons « my_value » du type de données « int » et l'initialisons avec « *my_num » ce qui signifie que nous essayons de déréférencer la variable « my_num » qui est du type de données « int ». L'erreur est générée sur cette ligne lors de la compilation car on ne peut pas déréférencer le « int ». Nous voulons afficher la valeur que nous obtenons après le déréférencement de int, nous plaçons donc le « cout » dans lequel nous avons ajouté la variable « my_value ».
Codage 1 :
#include
en utilisant l'espace de noms std ;
int main ( ) {
int mon_num = 99 ;
int ma_valeur = * mon_num;
cout << 'La valeur que nous obtenons en déréférençant l'int est : ' << ma_valeur << fin;
retour 0 ;
}
Sortir:
Ici, nous pourrions remarquer qu'aucune valeur n'est affichée et qu'une erreur se produit indiquant qu'il existe un argument de type non valide de type unaire « * ». Cela signifie que nous ne pouvons pas déréférencer le « int » en C++.
Solution 1 : sans déréférencement
Ici, nous obtiendrons directement la valeur entière sans déréférencement. Nous importons le fichier d'en-tête « iostream » car certaines définitions de fonctions sont présentes. Ensuite, nous tapons le « namespace std » avec le mot-clé « using », puis appelons ici la méthode « main() ». Maintenant, nous initialisons la variable « my_num » du type de données « int » avec la valeur « 99 ».
Ensuite, nous initialisons une autre variable avec le nom « my_value » et lui attribuons la variable « my_num » qui contient le nombre entier. Après cela, on obtient cette valeur entière directement sans déréférencement en plaçant « ma_valeur » dans le « cout ». Cela obtient et affiche la valeur entière.
Codage 1 :
#includeen utilisant l'espace de noms std ;
int main ( ) {
int mon_num = 99 ;
int ma_valeur = mon_num;
cout << 'La valeur que nous obtenons sans déréférencer l'int est : ' << ma_valeur << fin;
retour 0 ;
}
Sortir:
La valeur entière est rendue ici et nous obtenons sans déréférencement dans notre code C++. On accède directement à cette valeur entière et on l'affiche.
Solution 2 : en déréférençant le pointeur
Le fichier d'en-tête « iostream » contient certaines définitions de fonctions ; nous les avons importés. Ensuite, nous exécutons ici la fonction « main() » après avoir tapé « namespace std » et le mot-clé « using ». La variable « my_num » de type de données « int » est désormais initialisée avec la valeur « 99 ».
Après cela, nous initialisons un pointeur « my_ptr » et attribuons l'adresse de la variable « my_num » à ce pointeur. En dessous, nous déréférençons le pointeur et attribuons la valeur que nous obtenons à la variable « my_value » lorsque nous avons initialisé « my_value » avec le « *my_ptr ». Maintenant, nous plaçons le « cout » dans lequel nous passons la variable « my_value » pour afficher la valeur entière que nous obtenons en déréférençant le pointeur.
Code 2 :
#includeen utilisant l'espace de noms std ;
int main ( ) {
int mon_num = 99 ;
int * mon_ptr = & mon_num;
int ma_valeur = * mon_ptr;
cout << 'La valeur de int que nous obtenons en déréférençant un pointeur est : ' << ma_valeur << fin;
retour 0 ;
}
Sortir:
La valeur entière que nous obtenons après avoir déréférencé le pointeur dans notre code est maintenant affichée ici. C’est donc la bonne façon d’appliquer le déréférencement en C++.
Exemple 2 : déréférencement de Int
Essayons de déréférencer le « int » en C++ dans ce code. Pour utiliser les fonctions définies dans « iostream », il suffit d'inclure le fichier d'en-tête « iostream ». C'est ici que nous utilisons le « namespace std » et appelons la fonction « main() ». Ensuite, nous créons la variable « a » et lui donnons le type de données « int » ainsi que la valeur « 75 ».
En dessous, nous créons un pointeur nommé « newPointer » et attribuons l'adresse de la variable « a » à ce pointeur à l'aide de « & ». Ensuite, nous initialisons la variable « num » ci-dessous avec « *a » qui indique que nous essayons de déréférencer la variable « a » qui est du type de données « int ». Comme on ne peut pas déréférencer le « int », une erreur est désormais produite sur cette ligne lors de la compilation. Après cela, nous utilisons également le « cout » dans lequel nous ajoutons la variable « num ».
Code 2 :
#includeen utilisant l'espace de noms std ;
int main ( ) {
entier a = 75 ;
int * nouveauPointeur = & un;
numéro entier = * un;
cout << 'La valeur du déréférencement de l'int est : ' << sur une << fin;
retour 0 ;
}
Sortir:
Ici, nous pouvons voir qu'aucune valeur n'est affichée et un message d'erreur indiquant un « paramètre de type non valide de unaire »* » apparaît. Cela indique que le « int » ne peut pas être déréférencé en C++.
Solution 1 : sans déréférencement
Nous n'aurons pas besoin de déréférencer pour obtenir la valeur entière immédiatement. Nous l'importons puisque le fichier d'en-tête « iostream » contient certaines définitions de fonctions. La fonction « main() » est ensuite invoquée après la saisie des mots-clés « using » et « namespace std ». La variable « a » de type de données « int » est désormais initialisée avec la valeur « 75 ». Ensuite, on insère le « a » dans le « cout » pour obtenir cette valeur entière immédiatement sans déréférencement. Cela récupère la valeur entière et l'affiche ici.
Codage 1 :
#includeen utilisant l'espace de noms std ;
int main ( ) {
entier a = 75 ;
cout << 'La valeur que nous obtenons sans déréférencement est : ' << un << fin;
retour 0 ;
}
Sortir:
La valeur entière obtenue à partir de notre code C++ sans déréférencement est présentée ici. Cette valeur entière est immédiatement accessible et est affichée ici.
Solution 2 :
Nous importons le fichier d'en-tête « iostream » contenant quelques définitions de fonctions. Ici, nous tapons le « namespace std » et le mot-clé « using » avant d’exécuter la fonction « main() ». La valeur « 75 » est attribuée à la variable « a ».
Ensuite, nous déclarons un pointeur appelé « mypointer » et l’initialisons avec l’adresse de la variable « a ». En dessous, nous déréférençons le pointeur et attribuons la valeur que nous en obtenons à la variable « result » lorsque nous initialisons le « result » avec « *mypointer ». Après avoir déréférencé le pointeur, nous plaçons la commande « cout » et passons la variable « result » pour afficher la valeur entière.
Code 2 :
#includeen utilisant l'espace de noms std ;
int main ( ) {
entier a = 75 ;
int * mon pointeur = & un;
résultat entier = * mon pointeur ;
cout << 'La valeur que nous obtenons en déréférençant le pointeur est : ' << résultat << fin;
retour 0 ;
}
Sortir:
C'est la technique appropriée pour appliquer le déréférencement en C++. Il restitue la valeur entière que nous avons obtenue après avoir déréférencé le pointeur au lieu de déréférencer le « int ».
Conclusion
Nous avons exploré que lorsque nous essayons d'obtenir la valeur en déréférençant le « int » en C++, l'erreur « paramètre de type non valide de l'unaire « * » ayant un int » se produira, ce qui signifie que « int ne peut pas être déréférencé en C++ ». Nous avons également expliqué la solution à cette erreur. Nous avons utilisé le code dans lequel les erreurs se sont produites et les codes dans lesquels nous avons fourni la solution à cette erreur dans ce guide.