Dans ce didacticiel, nous allons découvrir les pointeurs vides et comment les utiliser à l'aide d'exemples.
Avant de poursuivre ce didacticiel, assurez-vous de vérifier les pointeurs C ++.
En C ++, nous ne pouvons pas affecter l'adresse d'une variable d'un type de données à un pointeur d'un autre type de données. Prenons cet exemple:
// pointer is of int type int *ptr; // variable is of double type double d = 9.0; // Error // can't assign double* to int* ptr = &d;
Ici, l'erreur s'est produite car l'adresse est une doublevariable de type. Cependant, le pointeur est de inttype.
Dans de telles situations, nous pouvons utiliser le pointeur vers void (pointeurs void) en C ++. Par exemple,
// void pointer void *ptr; double d = 9.0; // valid code ptr = &d;
Le pointeur void est un pointeur générique qui est utilisé lorsque nous ne connaissons pas le type de données de la variable vers laquelle pointe le pointeur.
Exemple 1: pointeur vide C ++
#include using namespace std; int main() ( void* ptr; float f = 2.3f; // assign float address to void ptr = &f; cout << &f << endl; cout << ptr << endl; return 0; )
Production
0xffd117ac 0xffd117ac
Ici, le pointeur ptrreçoit la valeur de &f.
La sortie montre que le pointeur void ptr stocke l'adresse d'une floatvariable f.
Comme voidc'est un type vide, les pointeurs vides ne peuvent pas être déréférencés.
void* ptr; float* fptr; float f = 2.3; // assign float address to void pointer ptr = &f; cout << *ptr << endl; // Error // assign float address to float pointer fptr = &f; cout << *fptr << endl; // Valid
Exemple 2: impression du contenu du pointeur d'annulation
Pour imprimer le contenu d'un pointeur void, nous utilisons l' static_castopérateur. Il convertit le pointeur de void*type en type de données respectif de l'adresse que le pointeur stocke:
#include using namespace std; int main() ( void* ptr; float f = 2.3f; // assign float address to void pointer ptr = &f; cout << "The content of pointer is "; // use type casting to print pointer content cout << *(static_cast(ptr)); return 0; )
Production
Le contenu du pointeur est 2,3
Ce programme imprime la valeur de l'adresse pointée par le voidpointeur ptr.
Puisque nous ne pouvons pas déréférencer un voidpointeur, nous ne pouvons pas utiliser *ptr.
Toutefois, si nous convertissons le void*type de pointeur en float*type, nous pouvons utiliser la valeur pointée par le voidpointeur.
Dans cet exemple, nous avons utilisé l' static_castopérateur pour convertir le type de données du pointeur de void*vers float*.
Coulée de style C
Nous pouvons également utiliser un casting de style C pour imprimer la valeur.
// valid cout << *((float*)ptr);
Cependant, il static_castest préféré au moulage de type C.
Remarque: les pointeurs void ne peuvent pas être utilisés pour stocker des adresses de variables avec constou des volatilequalificatifs.
void *ptr; const double d = 9.0; // Error: invalid conversion from const void* to void* ptr = &d;
