C++ déréférencer un pointeur void , la conversion de int ptr à vide ptr

Ces lignes de code ci-dessous montrent d'erreur:

int e = 5, * ePtr = &e;
void * vPtr = ePtr; 
cout << *vPtr;

erreur de syntaxe :

`void*' n'est pas un pointeur vers un objet de type

Je sais:

  1. tout type pointeur peut être stocké dans le vide de type pointeur sans cast explicite
  2. référence à la tentative d'annuler pointeur est une erreur de syntaxe

mais si nous ne pouvons pas faire le point n ° 2, qu'est-ce que l'utilisation du point # 1, à l'exception d'être syntaxiquement correct? Je veux imprimer 5 (c'est à dire e ici) à l'aide de vPtr..est-ce possible?

Cela fonctionne bien:

int e = 5, * ePtr = &e;
void * vPtr = ePtr; //specific to generic Ok!
double * dPtr = (double *)vPtr; //to let compiler know stoarge size
cout << *dPtr; //indirectly it is vPtr i.e. a void ptr, can be deref only if cast
void * est utilisé à peu près exclusivement pour stocker un pointeur de sorte que vous pouvez le jeter en arrière pour le genre et l'utiliser. Et il est beaucoup plus d'un C style de codage.
essayez d'utiliser casting void * vPtr = (void*)ePtr;
Vous êtes à la recherche pour les backticks: `void *vPtr = (void*)ePtr;`

OriginalL'auteur ShivaniDhanked | 2013-05-30

  1. 4

    void* peut pointer vers n'importe quoi, donc l'affectation d'un pointeur vers, il est parfaitement acceptable.

    Mais parce qu'il peut pointer sur n'importe quoi, de déférence, il n'est pas possible: Le compilateur ne sait pas quel type d'objet il points de, de sorte qu'il n'est pas capable de générer du code pour faire la bonne chose selon le type de l'objet.

    OriginalL'auteur Timbo

  2. 5

    La déférence d'un void* pointeur, vous devez lancer le pointeur de retour à un type compatible.

    void* pointeurs sont fréquemment utilisés dans C, cependant, car en C++ on peut faire fonction de la surcharge et polymorphisme, leur utilisation est beaucoup plus limitée.

    Un bon exemple de l'utilisation de void* les pointeurs en C sont des fonctions qui utilisent des rappels :

    int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
                   void *(*start_routine) (void *), void *arg);

    Lorsque vous appelez la fonction pthread_create, il appelle votre start_routine dos.
    Dans ce cas, vous pouvez transmettre certaines données à vos start_routine. Depuis la bibliothèque de threads ne peut pas déclarer une fonction pthread_create pour chaque type, vous pouvez vous passer de vous le rappel, le void*type est utilisé à la place.

    void myCallBack(void* arg) {
   int* value = (int*)arg;

   /* Do something with value: it is an int* now*/
   printf("Message from callback %d\n", *value);
}


/* Some main function or whatever... */
{ 
  /*  ... */
  int foo = 123;
  ret = pthread_create(&thread, &attr,myCallBack, &foo);

  /*  ... */
}

    OriginalL'auteur Matthieu Rouget

  3. 3

    Vous ne pouvez pas le déréférencement d'elle, car le compilateur ne sait pas ce que c'est. Vous devez vous lancer dans un type approprié (et le compilateur a supposer que vous savez ce que vous faites).

    void * pointeurs où vous sont en contact avec les choses à un niveau assez faible (tels que les I/O des pilotes) où vous intéressent que très peu à ce que les données en question, et vous savez que vous avez un tampon et une taille.

    Toute autre utilisation est souvent synonyme de danger. Par exemple

    int i = 5;
void *p = &i;
.....
float *f = (float *)p;

    Ce n'aurez pas de compilateur des erreurs ou des avertissements. Il est parfaitement valide. Mais il est peu probable de faire ce que vous attendez

    OriginalL'auteur Tom Tanner

  4. 2

    Il peut être utile de stocker un pointeur et rester indifférent à son type. C'est ce que void* est pour. C'est une approche que vous pouvez prendre lors de la conception d'un conteneur de stockage (liste liée, hash map) dans le plus pur C.

    Si vous vouliez utiliser le pointeur alors que vous auriez à suivre son type et de sa valeur, puisque vous ne pouvez pas arbitrairement déférence pointeurs, et tout type d'information est perdue lorsque vous lancez à vide*.

    Dans votre exemple, vous pourriez utiliser une structure simple avec un void* et un champ de type.

    En C++, vous pouvez obtenir ces choses avec polymorphe des structures et même des modèles: ce que vous faites est de loin plus C style.

    OriginalL'auteur Bathsheba

  5. 1

    Vous ne pouvez pas imprimer e ici à l'aide de void* sans typecasting.
    Un pointeur n'est pas seulement une simple variable qui stockent l'adresse, mais il a obtenu un type qui indique au compilateur la taille qu'il doit lire à l'aide de cette adresse. Un void*, car il ne possèdent pas de n'importe quel type, ne peut pas être déréférencés sans typecasting. Par typecasting, vous dire au compilateur de combien d'octets il faut lire à partir de l'adresse du pointeur de la porte.

    void* fournit un moyen facile pour le programmeur de facilement stocker et utiliser des pointeurs d'autres types. Nous ne pouvons pas utiliser unsigned int ou similaire pour stocker la valeur d'un pointeur, puisque la taille d'un pointeur dépend du processeur. Aussi, nous pouvons utiliser void* pointeur arguments/valeur de retour de fonctions plus génériques.

    raj raj : c'est pas vrai, faire un "void * vPtr = (int *)ePtr; cout << *vPtr;" génère la même erreur. Donc, une fois déclarée nulle type de pointeur , il ne peut jamais être déréférencés.
    voir modifier, probablement que vous vouliez dire.merci!
    je veux dire, on peut déréférencer un void* après typecasting de la void* à son type réel.

    OriginalL'auteur raj raj

  6. 0

    J'chose si vous voulez stocker int pointeur de pointeur void*.
    Dans cette situation, vous pouvez obtenir de l'alerte de type "cast de pointeur d'entier de taille différente".Pour cela vous devez d'abord assigner une mémoire vide pointeur liées à l'entier, et ensuite utiliser ce vide pointeur peut être comme suivre,

    void *ptr = malloc(sizeof(int));
*((int*)ptr) = 5;
printf("%d\n",*((int*)ptr));

    OriginalL'auteur santosh dhanawade