Qu’est-ce qu’un pointeur vide et qu’est-ce qu’un pointeur nul?

Les deux concepts sont orthogonaux:

1. Un pointeur vide ( void * ) est un pointeur brut vers un emplacement de mémoire.
2. Un pointeur nul est un pointeur spécial qui, par définition, ne pointe rien. Ce peut être un pointeur sur n’importe quel type, vide ou non.

Un pointeur vide peut être nul ou non:

 void *void_ptr1 = nullptr; void *void_ptr2 = malloc(42); void *void_ptr3 = new Foo; // void * can point to almost anything void *void_ptr4 = (char*)void_ptr3 + 1; // even somewhere inside an object 

Un pointeur non vide peut aussi être nul ou non:

 Foo *f = nullptr; Foo *g = new Foo; 

Oubliez simplement cette réponse. Une citation de votre lien:

“un pointeur sans type de retour est appelé un pointeur null.”

C’est tellement simple. Le type de retour d’ un pointeur? VRAIMENT? C’est une mauvaise source …

void* est un type de pointeur universel, car tout type de pointeur (à l’exception du pointeur sur const et / ou volatile) peut être implicitement converti en void* . En d’autres termes, vous pouvez affecter n’importe quel pointeur à une variable de type void* . Un pointeur nul est une valeur de pointeur 0

Le type de void en général signifie qu’aucune information de type n’est donnée.

Gardez toujours à l’esprit qu’un pointeur véhicule deux informations: le type des données pointées ( int , double , …), qui spécifie comment les interpréter, et l’ adresse des données sur lesquelles il pointe, qui spécifie où vous pouvez obtenir la valeur réelle des données pointées.

Les informations de type sont dans le type du pointeur ( double * , int * , …), tandis que l’adresse des données est la valeur réelle contenue dans la variable de pointeur.

Ainsi, un pointeur void ( void * ) est un pointeur qui ne spécifie aucune information de type. Il vous indique où se trouvent les données, mais ne vous dit pas comment les interpréter. Vous savez qu’à cette adresse, il y a quelque chose, mais vous ne savez pas s’il s’agit d’un int , d’un double ou d’un ensemble de vaches volantes. Pour utiliser réellement de telles données, vous devez obtenir les informations de type les concernant d’une autre manière (par exemple, avec un autre paramètre magique), transtyper ce pointeur sur un type de pointeur normal, puis l’utiliser normalement.

void * est souvent utilisé en C pour fournir une sorte de support à la programmation générique; voir par exemple la fonction de bibliothèque qsort C.

Un pointeur NULL , à la place, est un pointeur qui ne pointe vers rien. Dans ce cas, les informations de type concernant le pointeur en général sont présentes, mais c’est l’adresse des données pointées qui manque. Bien sûr, il est possible d’avoir un void * qui est NULL .

Exemple rapide (en supposant que v soit déclaré double v; ):

  Type information present +----------------------+----------------------+ | ✔ | ✘ | +---+----------------------+----------------------+ pc | | | | voo | ✔ | double * ptr = &v; | void * ptr = &v; | ain | | | | lnt +---+----------------------+----------------------+ ite | | | | den | ✘ | double * ptr = NULL; | void * ptr = NULL; | dt | | | | +---+----------------------+----------------------+ 

Anecdote : NULL , du moins dans la norme actuelle, est garanti à 0.

Dans d’autres zones de la langue, void est toujours utilisé pour spécifier un manque de type. L’utiliser comme valeur de retour (note: je parle maintenant de void , not void * ) signifie que la fonction ne renvoie aucune valeur, et transformer une expression en void est une manière élégante de supprimer une valeur (vous signalez à le compilateur et aux autres programmeurs (vous êtes conscient de ne pas utiliser une certaine valeur).

S’il vous plaît, dites-nous: Quelle est la différence:

• entre réservoir d’essence et situation sans essence
• entre cookie jar et no-cookies
• entre terme ‘argent’ et ‘poches vides’

Si vous trouvez cela, vous serez en mesure de saisir null vs void * dillema.

void est un non-type. null est une non-valeur.

Voici quelques différences en ce qui concerne l’arithmétique de pointeur:

Cela provient du fait que le vide est un type incomplet.

 void *vp; vp++; // error, incomplete type vp += 2; // same error void *p = 0; p++; // still same error int *p = 0; p++; // well-formed program, but UB ($5.6/5) 

L’article lié est tout simplement faux. Sa première phrase:

un pointeur sans type de retour s’appelle un pointeur nul

déclenche toutes sortes d’alarmes pour moi. C’est un écrit très confus.

Vous avez presque raison. “Pointeur à annuler” est un type (pas un “type de retour”). Des valeurs de n’importe quel type peuvent être retournées par des fonctions, et sont donc le type de retour (de la fonction).

Un pointeur null est un pointeur qui, quel que soit son type, pointe sur l’object null, qui n’est pas un object valide pouvant être créé. On peut dire qu’un pointeur nul pointe sur “rien”.

Un pointeur à annuler peut également être nul;

 void *nothing = 0; 

est un code parfaitement valide, et indique simplement que ce pointeur est capable de pointer un object non typé, mais qu’il ne l’est pas pour le moment.

Le pointeur null pointe sur 0x000000 (ce qui est incorrect pour accéder au pointeur), alors que le pointeur vide est un pointeur correct sur un type non spécifié ( void * ). Toutefois, le pointeur vide peut être un pointeur nul, mais le fait de ne pas faire référence au pointeur générera alors une erreur.

void *ptr est le pointeur qui peut être utilisé pour pointer tout type de données. Il peut être int , float , double . Il n’a pas de type de retour. Le pointeur initial est créé avec un type de pointeur (ayant une valeur hexadécimale) et nous pouvons affecter ce pointeur à tout type de données.

Alors que le pointeur NULL est le pointeur dont la valeur est NULL en tant qu’adresse, il est affecté à la valeur NULL de sorte qu’il ne puisse pas être utilisé pour accéder à d’autres données que son adresse peut contenir lors de la création. Je pense que c’est une bonne technique de programmation d’atsortingbuer un pointeur NULL s’il n’est pas utilisé pour le moment.