Erreur : « GDB ne peut pas accéder à la mémoire à l'adresse » en C++

Cependant, lors de l'utilisation de GDB, vous pouvez rencontrer l'erreur « Erreur : GDB ne peut pas accéder à la mémoire à l'adresse ». Cette erreur peut prêter à confusion et rend difficile le débogage continu. Cet article se concentre sur l'identification de la raison pour laquelle cette erreur se produit et sur quelques exemples de code qui nous aident à comprendre comment résoudre cette erreur.

Exemple 1:

Voyons notre premier exemple de code qui, lors de l'exécution, donne une erreur « GDB ne peut pas accéder à la mémoire à l'adresse ». Tout d’abord, nous examinons le code. Ensuite, nous en verrons l’explication ligne par ligne.

Le programme commence par la déclaration de la directive de préprocesseur « #include  » et en utilisant le « namespace std » qui sont essentiels à inclure dans le programme pour utiliser les fonctions d'entrée et de sortie standard. Après cela, vient le point d’entrée principal qui est « int main(void); ». Cette ligne déclare le point de départ du programme.

Dans la fonction principale, la variable de pointeur « *p » est déclarée. Ici, la variable « p » n'est pas initialisée. Par conséquent, il ne pointe vers aucun emplacement mémoire spécifique réservé à l’entier. Cette ligne provoque une erreur que nous résoudrons plus tard. Dans la ligne suivante, nous essayons d'imprimer la valeur de la variable « *p » à l'aide de l'instruction « cout ».

La variable « p » étant un pointeur de type entier, l’astérisque « * » est utilisé pour la déréférencer. Cela signifie que la valeur se trouve à l’emplacement mémoire vers lequel elle pointe. Cependant, comme le pointeur « p » n’a pas été initialisé et ne pointe vers aucun emplacement spécifique et valide, le déréférencement du pointeur entraînera un comportement indéfini. Par conséquent, cela entraîne la génération de différents types d’erreurs en fonction du système et du compilateur. Puisque nous utilisons le compilateur GDB pour déboguer et exécuter ce programme, le débogueur générera l'erreur suivante. L'erreur est affichée dans l'extrait de sortie :

Comme vous pouvez le voir dans le résultat, le débogueur ne peut pas accéder à la mémoire. Ce programme déréférence un pointeur non initialisé, raison principale de ce comportement non défini. Voyons maintenant comment nous pouvons résoudre ce problème. Le code correct est donné ci-dessous. Jetez-y un œil et nous vous expliquerons comment nous corrigeons le bug dans le code :

Comme vous pouvez le voir, le code est modifié en incluant le « int val =5 ; » déclaration. Cette ligne déclare une variable entière nommée « val » et l'initialise avec la valeur « 5 ». La ligne suivante, « int *p = &val; », déclare une variable de pointeur « *p » et est initialisée pour pointer vers l'adresse de la variable « val ». Auparavant, le pointeur « *p » ne pointait vers aucune adresse mémoire, ce qui provoquait le message « Impossible d'accéder à la mémoire à l'adresse 0x0 ».

Pour résoudre ce problème, la variable « var » est déclarée, initialisée et affectée au pointeur « *p ». Maintenant, le pointeur « *p » pointe vers l'adresse de la variable « val » tandis que l'opérateur « & » prend l'adresse de « val » et l'attribue à « p ». Encore une fois, l'instruction « cout » est utilisée pour imprimer la valeur du pointeur « *p ». Consultez l’extrait de sortie suivant pour voir la valeur du « val » auquel accède le pointeur « *p » :

Comme vous pouvez le constater, l'erreur a été résolue et la valeur de « 5 » est initialisée puisque la variable « val » a été imprimée en appelant le pointeur « *p » valribale.

Exemple 2 :

Considérons un autre exemple qui explique comment répondre à l'erreur « GDB ne peut pas accéder à la mémoire à l'adresse » dans le programme de code C++. Le code est donné ci-dessous pour votre référence. Regarde:

L'un des scénarios les plus courants rencontrés par les développeurs lors de la programmation avec des pointeurs est une allocation de mémoire incorrecte ou inappropriée. Le GDB génère l’erreur chaque fois qu’une allocation et une désallocation de mémoire incorrectes se produisent dans un programme C++.

En considérant l'exemple de code précédent, un pointeur « *p » est initialisé avec un nouveau int[15]. Cette instruction alloue dynamiquement un tableau de 15 entiers à l'aide de l'opérateur new. La variable de pointeur « *p » stocke l'adresse mémoire du tableau.

Dans l'instruction suivante, « delete[] p; » indique que la mémoire a été libérée à l'aide de la commande delete[]. La commande delete[] libère la mémoire précédemment allouée du pointeur « *p », ce qui signifie que l'autre système utilise peut à nouveau allouer le bloc de mémoire précédemment alloué. Lorsque nous essayons d'imprimer la valeur de la variable « *p » à l'aide de l'instruction « cout », nous obtiendrons l'erreur d'accès à la mémoire comme le montre le résultat suivant :

Ce qu'il faut garder à l'esprit ici, c'est que le message d'erreur exact peut différer légèrement en fonction de votre version et de votre système GDB. Mais « erreur : GDB ne peut pas accéder à la mémoire à cet emplacement » et l'erreur donnée dans l'extrait précédent sont les mêmes. Pour résoudre cette erreur, nous décalons simplement la commande delete[] après l'instruction « cout ». Voir le code modifié dans ce qui suit :

Ici, vous pouvez voir que nous avons initialisé le tableau avec des valeurs calculées au moment de l'exécution et que nous imprimons toutes les valeurs de la boucle en utilisant la boucle « for ». La chose la plus importante à noter ici est le décalage de l'instruction delete[] ; il est maintenant appelé après avoir obtenu toutes les valeurs du tableau qui a supprimé l'erreur d'accès mémoire. Consultez le résultat final du code ci-dessous :

Conclusion

En conclusion, l'erreur « Erreur : GDB ne peut pas accéder à la mémoire à l'adresse » indique généralement des problèmes liés à la mémoire dans le code C++. Cet article a exploré certains scénarios courants qui déclenchent cette erreur pour expliquer quand et comment elle peut être résolue. Lorsque cette erreur se produit dans le code, il est essentiel de l'examiner attentivement en accordant une attention particulière aux variables de pointeur, aux allocations de mémoire, aux tableaux et aux structures.

De plus, des fonctionnalités telles que les points d'arrêt fournies par GDB peuvent aider à localiser l'erreur lors du débogage du programme. Ces fonctionnalités peuvent aider à identifier l'emplacement exact des erreurs liées à la mémoire. En résolvant ces problèmes de manière proactive, les développeurs peuvent améliorer la stabilité et la fiabilité de leurs applications C++.