Qu'entend-on EXACTEMENT par “dé-référencement d'un pointeur NULL”?

Je suis un débutant complet, C, et au cours de mes travaux universitaires, je suis venu à travers des commentaires dans le code qui se réfèrent souvent à de référencement d'un pointeur NULL. Je dois avoir de l'expérience en C#, j'ai été faire par que cela peut être similaire à un "NullReferenceException" que vous obtenez dans .Net, mais maintenant, je vais avoir de sérieux doutes.

Quelqu'un peut-il m'expliquer dans les dilettantes termes, exactement ce que c'est et pourquoi c'est mauvais?

Gardez à l'esprit cette opération aboutit à un comportement indéfini. Vous n'obtenez pas d'exceptions ou de quoi que ce soit, en C ou en C++.
Vous pourriez mettre bas un exemple de code. Il semble que les gens (moi y compris) n'obtenez pas ce que vous essayez de le demander.
Pas besoin de code (il n'y a pas tout) - C'est un problème conceptuel, je vais avoir, en essayant d'obtenir ma tête autour de la terminologie de "déréférencement" et pourquoi je devrais être s'inquiéter à ce sujet.
youtube.com/watch?v=bLHL75H_VEM

InformationsquelleAutor Ash | 2010-10-24

c pointers

71

Un NULL d'un pointeur sur la mémoire qui n'existe pas. Cela peut être l'adresse 0x00000000 ou de toute autre mise en valeur définie (tant qu'il ne peut jamais être une adresse réelle). Un déréférencement c'est tenter d'accéder à tout ce qui est pointé par le pointeur. Le * opérateur est l'opérateur de déréférencement:
```
int a, b, c; //some integers
int *pi;     //a pointer to an integer

a = 5;
pi = &a; //pi points to a
b = *pi; //b is now 5
pi = NULL;
c = *pi; //this is a NULL pointer dereference
```
C'est exactement la même chose qu'un NullReferenceException en C#, mais les pointeurs en C peut pointer vers n'importe quel objet de données, les éléments de même à l'intérieur d'un tableau.
- Un pointeur contient une adresse mémoire qui références pour quelque chose. Pour accéder à quelque chose référencés par l'adresse mémoire, vous devez vous de référence l'adresse de la mémoire.
- qui In silico dit, mais quand vous de-reference-vous d'obtenir la valeur stockée à l'adresse de la mémoire. Lui donner un essai. Ne int p; printf("%p\n", &p); il devrait imprimer une adresse. Lorsque vous ne créez pas un pointeur (*var), pour obtenir l'adresse que vous utilisez &var
- Savez-vous quand vous ne char *foo = NULL et ensuite utiliser &foo ?
- Dans votre exemple &foo fait référence à l'adresse de la variable appelée foo, ce qui est bien compte tenu de sa déclaration.
InformationsquelleAutor Greg Hewgill
32

Déréférencement signifie simplement la lecture de la valeur de la mémoire à une adresse donnée. Ainsi, lorsque vous avez un pointeur vers quelque chose, vers déréférencer le pointeur moyen pour lire ou écrire les données que le pointeur pointe.

En C, le unaire * opérateur est l'opérateur de déréférencement. Si x est un pointeur, puis *x est ce que x points. Unaire & l'opérateur est le adresse de de l'opérateur. Si x est rien, alors &x est l'adresse à laquelle x est stockée dans la mémoire. Le * et & opérateurs sont inverses les uns des autres: si x est de toutes les données, et y est un pointeur, alors ces équations sont toujours remplies:
```
*(&x) == x
&(*y) == y
```
Un pointeur null est un pointeur qui ne pointe sur aucune des données valides (mais ce n'est pas le seul de ce type pointeur). La norme dit qu'il est comportement indéfini déréférencer un pointeur null. Cela signifie que tout, absolument tout peut arriver: le programme pourrait tomber en panne, il pourrait continuer à travailler en silence, ou il pourrait effacer de votre disque dur (même si c'est plutôt rare).

Dans la plupart des implémentations, vous obtiendrez un "segmentation fault" ou "violation d'accès" si vous essayez de le faire, ce qui sera presque toujours le résultat de votre programme étant terminé par le système d'exploitation. Voici une façon un pointeur null peut être déréférencé:
```
int *x = NULL;  //x is a null pointer
int y = *x;     //CRASH: dereference x, trying to read it
*x = 0;         //CRASH: dereference x, trying to write it
```
Et oui, un déréférencement d'un pointeur null est à peu près exactement comme un NullReferenceException en C# (ou un NullPointerException en Java), sauf que la langue standard est un peu plus utile ici. En C#, un déréférencement d'une référence null a bien défini comportement: il jette toujours un NullReferenceException. Il n'y a aucun moyen pour que votre programme puisse continuer à travailler en mode silencieux ou effacer votre disque dur comme en C (sauf si il y a un bug dans la langue de l'exécution, mais encore une fois c'est incroyablement peu probable que bien).

InformationsquelleAutor Adam Rosenfield
2

Cela signifie
```
myclass *p = NULL;
*p = ...;  //illegal: dereferencing NULL pointer
... = *p;  //illegal: dereferencing NULL pointer
p->meth(); //illegal: equivalent to (*p).meth(), which is dereferencing NULL pointer

myclass *p = /* some legal, non-NULL pointer */;
*p = ...;  //Ok
... = *p;  //Ok
p->meth(); //Ok, if myclass::meth() exists
```
en gros, presque tout ce qui a trait (*p) ou implicitement impliquant (*p), par exemple p->... qui est une abréviation pour (*p). ...; sauf pour la déclaration de pointeur.
- Il a touché sa question C pas du C++
- et il a exactement la même sémantique en C et en C++, à l'exception peut-être C n'a pas de classe personnalisée.
- N'est-ce pas p->meth() juste un raccourci pour (*p).meth(), ce dernier étant disponible en C et C++?
- Ce code est parfaitement valable C.
InformationsquelleAutor Lie Ryan
0

De wiki

Un pointeur null est une valeur réservée, souvent, mais pas nécessairement la valeur zéro, ce qui indique qu'il fait référence à aucun objet

..

Depuis une valeur null le pointeur ne se réfère pas à un véritable objet, une tentative de déréférencer un pointeur null généralement provoque une erreur d'exécution.
```
int val =1;
int *p = NULL;
*p = val; //Whooosh!!!! 
```
- Merci pour votre réponse, je suis ok avec ce qu'est un pointeur NULL était, je n'étais pas sûr de savoir comment le "déréférencement" s'inscrit dans le schéma des choses.
InformationsquelleAutor Prasoon Saurav
0

Citant wikipédia:

Un pointeur fait référence à un emplacement dans
de la mémoire et de l'obtention de la valeur à la
emplacement un pointeur désigne est connu
comme déréférencement le pointeur.

Déréférencement est fait par l'application de la unary * opérateur sur le pointeur.
```
int x = 5;
int * p;      //pointer declaration
p = &x;       //pointer assignment
*p = 7;       //pointer dereferencing, example 1
int y = *p;   //pointer dereferencing, example 2
```
"Déréférencement d'un pointeur NULL" désigne le fait d' *p lorsque le p est NULL

InformationsquelleAutor Arun

Vous devez vous connecter pour publier un commentaire.