Différence entre un pointeur non initialisé et nul

Existe-t-il une différence entre un pointeur null et un pointeur non initialisé? Cette question a été posée dans l’une des interviews. Pourriez-vous s’il vous plaît expliquer la différence qu’ils ont?

Prenez un pointeur non initialisé:

int* ptr;//points to any location in memory 

Prenez un pointeur nul:

 int* ptr = NULL;//normally points to 0x0 (0) 

Les deux provoqueraient un comportement indéfini s’ils étaient déréférencés. NULL est souvent défini comme 0.

Eh bien, la différence est exactement cela. Le pointeur Null est initialisé à null et, en tant que tel, a une signification définie. Vous pouvez le vérifier pour null et le déréférencement (sur toutes les plates-formes que je connais) fera planter un programme avec des diagnostics significatifs. Vous pouvez également utiliser des pointeurs nuls dans certains hacks spécifiques. Les pointeurs non initialisés, par contre, sont simplement aléatoires et doivent être évités.

Un pointeur non initialisé stocke une valeur non définie.

Un pointeur null stocke une valeur définie, mais celle définie par l’environnement ne doit pas être une adresse valide pour un membre ou un object.

Ok … je l’ai googlé pour vous, voici le lien: pointeur nul vs pointeur non initialisé

La différence de base est qu’un pointeur non initié a une valeur indéterminée alors qu’un pointeur NULL a une valeur définie qui est NULL .

Concernant le pointeur NULL, extrait de C11 , chapitre §6.3.2.3

Une expression constante entière avec la valeur 0, ou une telle expression convertie dans le type void * , est appelée constante de pointeur null. Si une constante de pointeur null est convertie en un type de pointeur, le pointeur résultant, appelé pointeur null, est garanti pour une comparaison inégalée d’un pointeur vers un object ou une fonction.

FWIW, la macro NULL est définie dans , en tant que constante de pointeur null.

Oui. Il y a une différence entre uninitialized et un pointeur nul. Un pointeur non initialisé peut pointer sur n’importe quel emplacement mémoire (inconnu). Un pointeur nul initialisé avec NULL ; constante de pointeur null définie par l’implémentation.

Après accepter la réponse

 void foo(void) { void *uninitialized_pointer; void *null_pointer = null_pointer_generator(); ... } 

uninitialized_pointer in non initialized . Il peut contenir une valeur de pointeur valide. Il peut avoir une valeur comparable à NULL . Il peut ne contenir aucune valeur de pointeur. C n’a pas de méthode définie pour même copier ou imprimer sa valeur.

  // These are undefined behavior. void *another_pointer = uninitialized_pointer; unsigned x = uninitialized_pointer*0; printf("%p\n", uninitialized_pointer); 

Le code peut affecter uninitialized_pointer , calculer sa taille ou transmettre son adresse.

  // These are defined behavior. uninitialized_pointer = malloc(1); uninitialized_pointer = NULL; printf("%zu\n", sizeof uninitialized_pointer); foo(&uninitialized_pointer); 

La variable null_pointer a une valeur null_pointer à la constante du pointeur nul (voir ci-dessous) et donc à un pointeur nul . Un pointeur nul peut être un modèle de bits unique ou il peut y en avoir beaucoup dans un système. Ils se comparent tous également à la constante du pointeur nul et les uns aux autres. Un pointeur null peut ou peut ne pas être une adresse valide dans le système bien qu’il ne soit pas comparable à un object, une variable, un membre ou une fonction de votre programme.

Tenter de déréférencer un pointeur NULL est un comportement indéfini: il peut provoquer une erreur de segmentation – ce n’est peut-être pas le cas.


NULL est la constante du pointeur nul . Lorsqu’il est affecté à un pointeur, ce pointeur est un pointeur nul . Lorsque 0 est affecté à un pointeur, ce pointeur est un pointeur nul . Ceux-ci peuvent / peuvent ne pas être différents pointeurs nuls . Ils se compareront également.

  void *null_pointer1 = NULL; void *null_pointer2 = 0; // The 2 pointer may/may not have the same bit pattern. printf("%p\n%p\n", null_pointer1, null_pointer2); // They will always compare as equal. printf("%d\n", null_pointer1 == null_pointer2); // Always compare as unequal. int x; printf("%d\n", null_pointer1 == &x);