web-dev-qa-db-fra.com

Pointeurs non initialisés dans le code

J'apprends le C++ et j'ai appris que les pointeurs s'ils n'étaient pas initialisés pouvaient pointer vers des emplacements aléatoires dans la mémoire et créer des problèmes que la mémoire pourrait être utilisée par un autre programme.

Maintenant, si c'est le cas, nous ne devrions jamais avoir cette ligne dans aucune partie de notre code:

int* ptr;

Au lieu de cela, nous devrions avoir quelque chose comme

int* ptr = NULL; //Is this going to avoid the problem

Veuillez suggérer car j'ai vu la première ligne (int* ptr;) dans de nombreux livres, je reçois ce doute. Si possible, donnez également quelques exemples.

c++pointersnull-pointer
31
munish
int* ptr = NULL; //Is this going to avoid the problem

Cela entraînera ptr à pointer vers NULL que vous pouvez rechercher explicitement comme valeur par défaut/non initialisée. Il empêche le problème que vous décrivez, mais un programmeur imprudent peut toujours accidentellement déréférencer un pointeur nul sans le vérifier, provoquant un comportement indéfini.

Le principal avantage est votre commodité pour vérifier si le ptr a ou n'a pas été initialisé à quoi que ce soit, à savoir:

 if (ptr != NULL)
 {
     // assume it points to something
 }

Comme c'est assez idiomatique, il est assez dangereux de ne pas initialiser le pointeur sur NULL. Le pointeur serait initialisé à une valeur de déchets non NULL qui ne pointe vraiment vers rien de réel. Pire encore, la vérification ci-dessus passerait, causant des problèmes encore plus graves s'il se trouve que l'adresse dans le pointeur est une mémoire à laquelle vous pouvez légalement accéder. Dans certains environnements intégrés, vous pouvez être en mesure d'accéder à n'importe quelle partie de la mémoire, vous pouvez donc endommager accidentellement des parties aléatoires de la mémoire ou des parties aléatoires de votre code d'exécution.

36
Doug T.

Initialisez toujours vos variables.

Parfois, vous souhaiterez peut-être initialiser à NULL, mais la plupart du temps, vous devriez pouvoir initialiser le pointeur à la valeur qu'il est censé contenir. Déclarez les variables le plus tard possible et initialisez-les à ce stade, pas 15 lignes plus loin dans votre code.

9
jalf

La ligne:

int* ptr;

n'est certainement pas garanti d'initialiser la valeur du pointeur sur quelque chose en particulier. La ligne:

int* ptr = NULL;

Initialise le pointeur pour pointer vers l'adresse zéro, qui en pratique ne contiendra jamais rien d'utile et qui sera conventionnellement vérifié comme valeur de pointeur non valide.

Bien sûr, il est toujours possible, comme l'a dit Doug T., d'essayer d'utiliser ce pointeur sans le vérifier et il se planterait tout de même.

L'initialisation explicite sur NULL a l'avantage de garantir que le déréférencement du pointeur avant de le définir sur quelque chose d'utile se bloquera, ce qui est en fait une bonne chose, car cela empêche le code de fonctionner "accidentellement" tout en masquant un bogue grave.

6
DataGraham

Il est toujours préférable d'initialiser un pointeur sur NULL si, pour une raison quelconque, vous ne pouvez pas l'initialiser pendant la déclaration. Par exemple:

Object *ptr = new Object();

En règle générale, une fonction peut vérifier la valeur du pointeur par rapport à NULL pour vérifier que le pointeur a déjà été initialisé. Si vous ne l'avez pas explicitement défini sur NULL et qu'il pointe vers une valeur aléatoire, il peut être déréférencé, provoquant une erreur de segmentation.

2
Heisenbug

Si le pointeur n'est pas utilisé, le compilateur l'ignorera simplement. L'initialiser à NULL est la chose sûre à faire, à mon humble avis.

Êtes-vous sûr de ne pas confondre avec une déclaration de fonction? Il est très courant qu'une fonction soit déclarée comme

char * do_something (const char * one, const char * two);

Dans ce cas, les pointeurs sont utilisés pour spécifier le type d'argument que vous souhaitez transmettre.

1
Jeroen Baert

C++ fait suite à C en ce qu'il n'est pas conçu pour être un coffre-fort; il est conçu pour être efficace. C'est donc pour cette raison que les variables automatiques ne sont pas initialisées. C'est à vous de vous assurer qu'aucun pointeur n'est utilisé avant son initialisation (bien que de nombreux compilateurs vous avertissent si vous n'initialisez pas vos variables)

1
doron
int a,*ptr;

maintenant

print(ptr,*ptr)

Dans le code ci-dessus, deux cas peuvent être possibles:

  1. Il s'exécutera si la valeur par défaut dans ptr n'est pas l'adresse d'une mémoire de programme utilisée.

    Production:

           ptr             *ptr
eg.  0x400730       -1992206795

  2. Cela donnera une erreur (défaut segmenté) si l'adresse par défaut dans le ptr est l'adresse d'une mémoire de programme utilisée. Par exemple. si l'adresse de la variable a dans la mémoire est également 0x400730.

1
Shubhay