Qu'est ce qu'un pointeur void et qu'est ce qu'un pointeur null?
donc j'ai passé en revue quelques questions d'entrevue et je suis tombé sur un à propos de nulles et nulles pointeurs , qui affirme:
un pointeur sans type de retour est appelé un pointeur null. Il peut être n'importe quel type de type de données.
cela m'a complètement embrouillé! Elle semble nulle et non avenue pourrait être utilisée de façon interchangeable selon cette question, et je ne crois pas que ce soit correct. J'ai supposé nul pour être un type de retour et null pour être une valeur. Mais je ne suis qu'un débutant et je ne suis pas sûr d'avoir raison.
nous vous demandons d'exprimer votre point de vue quant à ce qu'est un pointeur null est et un vide pointeur. Je ne cherche pas la différence entre nul et nul.
9 réponses
les deux concepts sont orthogonaux:
- un pointeur de vide, (
void *) est un pointeur brut vers un emplacement de mémoire. - un pointeur nul est un pointeur spécial qui ne pointe vers rien, par définition. Il peut être un indicateur de n'importe quel type, vide ou autre.
un indicateur de 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 nul 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 vraiment très claire MAUVAIS . Un pointeur type de retour ? VRAIMENT? C'est une mauvaise source...
void* est pointeur universel type parce que n'importe quel type de pointeur (sauf pointeur à const et/ou volatile) peut être implicitement converti en void* . En d'autres termes, vous pouvez assigner n'importe quel pointeur à une variable de type void* . Un pointeur nul est un pointeur valeur 0
le type void en général signifie qu'aucune information sur le type n'est fournie.
vous devez toujours garder à l'esprit qu'un pointeur transmet deux éléments d'information: le type des données pointées( int , double , ...), qui spécifie comment l'interpréter, et le adresse des données qu'il pointe, qui spécifie où vous pouvez obtenir la valeur réelle de la pointe données.
l'information de type est dans le type du pointeur ( double * , int * , ...), alors 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ù les données sont, mais il ne vous dit pas comment l'interpréter. Vous sachez qu'à cette adresse il y a quelque chose, mais vous ne savez pas si c'est un int , un double ou une rangée de vaches volantes. Pour réellement utiliser de telles données, vous devez obtenir des informations de type à ce sujet d'une autre manière (par exemple avec un autre paramètre magique), jeter ce pointeur sur un type de pointeur régulier et ensuite l'utiliser comme d'habitude.
void * est souvent utilisé en C pour fournir une certaine forme de soutien à la programmation générique; voir par exemple le qsort c bibliothèque fonction.
Un NULL pointeur est un pointeur qui pointe vers rien. Dans ce cas, l'information de type sur le pointeur en général est présente, mais c'est l'adresse des données pointées qui est manquante. Bien sûr, il est possible d'avoir un void * qui est NULL .
exemple rapide (supposons que v soit déclaré comme double v; ):
Type information present
+----------------------+----------------------+
| ✔ | ✘ |
+---+----------------------+----------------------+
p c | | | |
v o o | ✔ | double * ptr = &v; | void * ptr = &v; |
a i n | | | |
l n t +---+----------------------+----------------------+
i t e | | | |
d e n | ✘ | double * ptr = NULL; | void * ptr = NULL; |
d t | | | |
+---+----------------------+----------------------+
anecdotes : NULL , au moins dans la norme actuelle, est garanti d'être 0.
dans d'autres zones de la langue, void est toujours utilisé pour spécifier le manque de type. L'utiliser comme valeur de retour (note: je parle maintenant de void , pas de void * ) signifie que la fonction ne renvoie aucune valeur, et lancer une expression à nul est une façon fantaisiste de rejeter une valeur (vous signalez au compilateur et au autres programmeurs que vous êtes conscient que vous n'utilisez pas une certaine valeur).
s'il vous plaît, dites-nous: quelle est la différence:
- entre le réservoir d'essence et pas de gaz de la situation
- entre cookie jar et sans cookies
- entre le terme "argent" et "poches vides
si vous arrivez avec ceux-ci, vous serez en mesure de saisir null vs null* dillema.
Voici quelques différences par rapport à l'arithmétique des pointeurs:
il découle 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 (.6/5)
L'article lié est tout simplement faux. Sa première phrase:
un pointeur sans type de retour est appelé un pointeur nul
déclenche toutes sortes d'alarmes pour moi. C'est un très confus morceau de l'écriture.
vous avez presque raison. "Pointeur sur void" est un type (pas un "type de retour"). Les valeurs de n'importe quel type peuvent être retournées par des fonctions, et ainsi être (la fonction de) type de retour.
un pointeur nul est un pointeur qui, quel que soit son type, pointe vers l'objet nul, qui n'est pas un objet valide qui peut être créé. Un pointeur nul peut être dit pour pointer vers "rien".
un pointeur vers nul peut aussi être nul;
void *nothing = 0;
est un code parfaitement valide, et il dit simplement que ce pointeur est capable de pointer un objet non typé, mais pour l'instant il ne l'est pas.
le pointeur nul est le point 0x000000(ce qui est incorrect pour le pointeur d'accès), tandis que le pointeur nul est un pointeur correct vers un type non spécifié( void * ). Cependant, void pointer peut être null pointeur, mais alors unreferencing le pointeur générera l'erreur.
Un void *ptr est le pointeur qui peut être utilisé pour pointer n'importe quel type de données. Il peut-être int , float , double . Il n'a pas de type retour qui est initialement pointeur est créé avec le type pointeur (ayant une valeur hex) et nous pouvons assigner ce pointeur à n'importe quel type de données.
alors que null pointer est le pointeur ayant une valeur nulle comme adresse, le pointeur se voit attribuer une valeur nulle de sorte qu'il ne peut pas être utilisé pour accéder à d'autres données dont son adresse peut contenir lors de la création. Je pense que c'est une bonne technique de programmation pour assigner un pointeur NULL si elle n'est pas utilisée pour le moment.