Pouvez-vous printf valeur à partir d'un void * en C

Il semble que vous êtes en utilisant void * comme un bon marché union. C'est une assez mauvaise idée. Je pense que vous trouverez unions en conjonction avec enums et switches font de ce look tellement plus propre, en C. Vous trouverez les switch parmi les #ifdef SWITCH ... #else, et la switchless version parmi les #else ... #endif.

#include <stdio.h>
struct object {
enum type {
d=0,
s=1,
f=2,
lld=3,
time=4
} type;
union instance {
int d;
char *s;
float f;
long long lld;
char *time;
} instance;
};
#ifdef SWITCH
void print_object(struct object *o) {
switch (o->type) {
case d: printf("%d", o->instance.d); break;
case s: printf("%s", o->instance.s); break;
case f: printf("%f", o->instance.f); break;
case lld: printf("%lld", o->instance.lld); break;
case time: printf("%s", o->instance.time); break;
};
}
#else
void print_d(struct object *o);
void print_s(struct object *o);
void print_f(struct object *o);
void print_lld(struct object *o);
void print_time(struct object *o);
void print_object(struct object *o) {
void (*print_functions[])(struct object *) = {
[d] = print_d,
[s] = print_s,
[f] = print_f,
[lld] = print_lld,
[time] = print_time
};
print_functions[o->type](o);
}
void print_d(struct object *o) { printf("%d", o->instance.d); }
void print_s(struct object *o) { printf("%s", o->instance.s); }
void print_f(struct object *o) { printf("%f", o->instance.f); }
void print_lld(struct object *o) { printf("%lld", o->instance.lld); }
void print_time(struct object *o) { printf("%s", o->instance.time); }
#endif
int main(void) {
struct object o = { .type = d,                /* type: int */
.instance = { .d = 42 }   /* value: 42 */ };
print_object(&o);
return 0;
}

OriginalL'auteur autistic

Pensez-y de cette façon : Any pointeur tout simplement des points pour un unique emplacement de mémoire.Mais le type du pointeur de la souris détermine how many octets après que l'interprétation/envisager.Si c'est char* ensuite (selon le système) 1 octet est interprété,si c'est un int* 4 octets sont interprétés, et ainsi de suite.Mais un void* avait no type.Donc vous ne pouvez pas déréférencer un void pointeur en C, à cause de cette simple raison.Mais vous pouvez imprimer l'adresse des points à l'aide de la %p spécificateur de format dans printf() et en passant que void pointeur en argument.

printf("The address pointed by void pointer is %p",void_ptr); //Correct
printf("The address pointed by void pointer is %p",(void*)int_ptr);//Correct

en supposant int_ptr est un pointeur entier,dire,et void_ptr est un pointeur void.

printf("Value at address pointed by void pointer is %d",*void_ptr);//Wrong
printf("Value at address pointed by void pointer is %d",*(void*)int_ptr);//Wrong

OriginalL'auteur Rüppell's Vulture

Je pense que le printf et ses amis (fprintf, etc.) peut déréférencer seulement char* qui sera interprété comme un c-string.

En fait, vous pouvez écrire une telle fonction de vous-même, parce que vous allez dire à votre fonction de comment déréférencer void* avec format de drapeaux.

Vous pouvez également ajouter à la formats que d'un tiers de la valeur d'un pointeur tenu de déréférencement de fonction qui prendra en argument un void* et sera de retour la valeur à la place du pointeur.
Ainsi, vous aurez besoin d'écrire une fonction pour chacun des types que vous utilisez dans votre formats et d'attribuer à chaque fonction pour chaque format correctement.

OriginalL'auteur JustAnotherCurious