Modification d'une constante via un pointeur non const : plongée dans un comportement non défini

Dans l'extrait de code fourni, vous exprimez une confusion sur le comportement de modifier un entier constant (e) via un pointeur non const (w) :

const int e = 2;

int* w = (int*) &e;  // Casting to remove const-ness
*w = 5;            // Modifying the value pointed to by w

Après avoir effectué cette modification, vous observez que :

• Affichage de la valeur pointée par w ( cout w
• Cependant, l'affichage de la valeur de e (*cout

Vous remarquez en outre que l'adresse pointée par w est la même que l'adresse de e (cout cout e reste inchangé malgré la modification apportée via w.

Ce comportement découle du comportement indéfini qui survient lors de la modification d'une constante via un non -pointeur const. Une fois que vous effectuez une telle modification, le code entre dans un territoire de comportement indéfini, où il devient imprévisible et dépend de détails d'implémentation spécifiques.

Dans ce cas, il semble que la modification via w affecte un copie temporaire de e au moment de l'exécution, tandis que l'original e reste inchangé. La raison en est que e est traité comme une constante de compilation et sa valeur est codée en dur dans le code binaire. Par conséquent, toute modification d'exécution apportée à w n'affectera pas le e.

Ce comportement est spécifique à l'implémentation utilisée et ne doit pas être invoqué. La modification de données constantes via des pointeurs non const est considérée comme une mauvaise pratique et doit être évitée. L'approche correcte consiste à utiliser une référence non const ou à créer une copie non const des données que vous avez l'intention de modifier.