Concept de vide pointeur dans la programmation en C

Est-il possible de déréférencer le pointeur void sans conversion de type dans le langage de programmation C...

Non, void indique l'absence de type, il n'est pas quelque chose que vous pouvez déréférencement ou de l'attribuer.

est il n'y a aucune façon de généraliser une fonction qui permet de recevoir des pointeur et de le stocker dans le vide pointeur et en utilisant ce vide pointeur, nous pouvons faire une fonction généralisée..

Vous ne pouvez pas simplement déréférencement d'elle de façon portable, car il ne peut pas être correctement alignées. Il peut être un problème sur certaines architectures comme le BRAS, où pointeur vers un type de données doit être aligné à la limite de la taille du type de données (par exemple, le pointeur d'entier de 32 bits doivent être alignés à la limite de 4 octets pour être déréférencés).

Par exemple, la lecture uint16_t de void*:

/* may receive wrong value if ptr is not 2-byte aligned */
uint16_t value = *(uint16_t*)ptr;
/* portable way of reading a little-endian value */
uint16_t value = *(uint8_t*)ptr
                | ((*((uint8_t*)ptr+1))<<8);

Aussi, est de l'arithmétique des pointeurs avec le vide pointeurs possible...

De l'arithmétique des pointeurs n'est pas possible sur les pointeurs de void en raison du manque de valeur concrète sous le pointeur et donc la taille.

void* p = ...
void *p2 = p + 1; /* what exactly is the size of void?? */

Vous devez être conscient que, dans C, contrairement à Java ou C#, il n'y a absolument aucune possibilité de réussir à "deviner" le type de l'objet d'un pointeur void* points à. Quelque chose de semblable à "getClass()" n'existe tout simplement pas, puisque cette information est nulle part pour être trouvée. Pour cette raison, le genre de "générique" vous cherchez toujours explicite de la métainformation, comme le "int b" dans votre exemple, ou la chaîne de format dans le printf de la famille de fonctions.

Jusqu'à présent, mon sous-estimer à vide pointeur est comme suit.

Lorsqu'un pointeur est une variable déclarée à l'aide de mot-clé void – il devient d'un usage général pointeur de variable. Adresse d'une variable de n'importe quel type de données (char, int, float, etc.)peut être attribué à un vide pointeur de variable.

main()
{
    int *p;

    void *vp;

    vp=p;
} 

Depuis d'autres pointeur de type de données peut être affectée à vide pointeur, je l'ai donc utilisé en absolut_value(code indiqué ci-dessous) de la fonction. D'une façon générale la fonction.

J'ai essayé d'écrire un simple code C qui prend en entier ou flottant comme un argument et tente de faire +ve, si le résultat est négatif. J'ai écrit le code suivant,

#include<stdio.h>

void absolute_value ( void *j) //works if used float, obviously it must work but thats not my interest here.
{
    if ( *j < 0 )
        *j = *j * (-1);

}

int main()
{
    int i = 40;
    float f = -40;
    printf("print intiger i = %d \n",i);
    printf("print float f = %f \n",f);
    absolute_value(&i);
    absolute_value(&f);
    printf("print intiger i = %d \n",i);
    printf("print float f = %f \n",f);
    return 0;
}   

---

Mais j'obtenais l'erreur, donc je suis venu pour savoir que mon entente avec le vide pointeur n'est pas correct :(. Alors maintenant, je vais aller vers de collecter des points pourquoi est-ce si.

Les choses que j'ai besoin d'en savoir plus sur les pointeurs void est que.

Nous avons besoin de transtypage le vide pointeur de variable de déréférencement d'elle. C'est parce que le vide pointeur n'a pas de type de données associé. Il n'y a pas de chemin le compilateur ne peut pas savoir (ou de le deviner?) ce type de données est indiqué par le pointeur void. Donc, pour prendre les données pointé par un pointeur void nous avons catalogué avec le bon type de données repliée à l'intérieur du vide pointeurs emplacement.

void main()

{

    int a=10;

    float b=35.75;

    void *ptr; //Declaring a void pointer

    ptr=&a; //Assigning address of integer to void pointer.

    printf("The value of integer variable is= %d",*( (int*) ptr) );//(int*)ptr - is used for type casting. Where as *((int*)ptr) dereferences the typecasted void pointer variable.

    ptr=&b; //Assigning address of float to void pointer.

    printf("The value of float variable is= %f",*( (float*) ptr) );

}

Un vide pointeur peut être très utile si le programmeur n'est pas certain du type de données de données saisies par l'utilisateur final. Dans un tel cas, le programmeur peut utiliser un vide pointeur à l'emplacement de l'inconnu type de données. Le programme peut être configuré de manière à demander à l'utilisateur de déterminer le type de données et le type coulée peut être effectuée selon les informations saisies par l'utilisateur. Un extrait de code est donné ci-dessous.

void funct(void *a, int z)
{
    if(z==1)
    printf("%d",*(int*)a); //If user inputs 1, then he means the data is an integer and type casting is done accordingly.
    else if(z==2)
    printf("%c",*(char*)a); //Typecasting for character pointer.
    else if(z==3)
    printf("%f",*(float*)a); //Typecasting for float pointer
}

Un autre point important que vous devez garder à l'esprit à propos de nulle pointeurs, c'est que – l'arithmétique des pointeurs ne peuvent pas être effectuées dans un vide pointeur.

void *ptr;

int a;

ptr=&a;

ptr++; //This statement is invalid and will result in an error because 'ptr' is a void pointer variable.

Alors maintenant, j'ai compris quel était mon erreur. Je suis en train de corriger le même.

Références :

http://www.antoarts.com/void-pointers-in-c/

http://www.circuitstoday.com/void-pointers-in-c.

Le Nouveau code est comme indiqué ci-dessous.

---

#include<stdio.h>
#define INT 1
#define FLOAT 2

void absolute_value ( void *j, int *n)
{
    if ( *n == INT) {
        if ( *((int*)j) < 0 )
            *((int*)j) = *((int*)j) * (-1);
    }
    if ( *n == FLOAT ) {
        if ( *((float*)j) < 0 )
            *((float*)j) = *((float*)j) * (-1);
    }
}


int main()
{
    int i = 0,n=0;
    float f = 0;
    printf("Press 1 to enter integer or 2 got float then enter the value to get absolute value\n");
    scanf("%d",&n);
    printf("\n");
    if( n == 1) {
        scanf("%d",&i);
        printf("value entered before absolute function exec = %d \n",i);
        absolute_value(&i,&n);
        printf("value entered after absolute function exec = %d \n",i);
    }
    if( n == 2) {
        scanf("%f",&f);
        printf("value entered before absolute function exec = %f \n",f);
        absolute_value(&f,&n);
        printf("value entered after absolute function exec = %f \n",f);
    }
    else
    printf("unknown entry try again\n");
    return 0;
}   

---

Merci,

void abc(void *a, int b) {
  char *format[] = {"%d", "%c", "%f"};
  printf(format[b-1], a);
}

Vous pouvez facilement imprimer un vide imprimante

int p=15;
void *q;
q=&p;
printf("%d",*((int*)q));

vide pointeur est un pointeur générique.. l'Adresse de tout type de données d'une variable peut être attribué à un pointeur void.

int a = 10;
float b = 3.14;
void *ptr;
ptr = &a;
printf( "data is %d " , *((int *)ptr)); 
//(int *)ptr used for typecasting dereferencing as int
ptr = &b;
printf( "data is %f " , *((float *)ptr));
//(float *)ptr used for typecasting dereferencing as float

Vous ne pouvez pas déréférencer un pointeur sans en préciser le type, parce que les différents types de données ont des tailles différentes dans la mémoire, c'est à dire un int soit 4 octets, un char de 1 octet.

Cela ne fonctionne pas, pourtant, void * peut beaucoup vous aider dans la définition de pointeur générique de fonctions et de la passer en argument à une autre fonction (semblable à de rappel en Java) ou de définir une structure similaire à la programmation orientée objet.