lire des types different depuis un pointeur void*
Le
WebShaker
bonjour.
j'ai un pointeur de type void *
void *buffer;
comment je peux lire (en une seule instruction) une donnée 32bit et post
incrémenter le pointeur ?
pour le moment, je fais:
uint32_t totalsize = *(uint32_t *)buffer; vptr+=4;
j'aimerai bien faire ça en une seul instruction.
est-ce possible ?
merci
Etienne.
j'ai un pointeur de type void *
void *buffer;
comment je peux lire (en une seule instruction) une donnée 32bit et post
incrémenter le pointeur ?
pour le moment, je fais:
uint32_t totalsize = *(uint32_t *)buffer; vptr+=4;
j'aimerai bien faire ça en une seul instruction.
est-ce possible ?
merci
Etienne.
Oui. Utilise ',' au lieu de ';'.
uint32_t totalsize;
totalsize=(*(uint32_t*)buffer),(buffer+=sizeof(uint32_t));
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.
Heu la c'est exactement la même chose.
ma question était plutôt:
est il possible de coller le ++ quelques part dans la premier instruction.
en gros ou mettre le ++ dans
uint32_t totalsize = *(uint32_t *)buffer;
pour incrémenter le pointeur de la taille de uint32_t ?
Etienne
Non, c'est trés différent. Il y a au moins deux bogues en moins, est
c'est exactement ce que tu demandais: une seule instruction.
Il n'y a là qu'une sule instruction. Ta question est donc insensé.
Tu pourrais écrire:
uint32_t* p=buffer; /* ce n'est pas une instruction, mais une definition */
uint32_t totalsize=(*buffer++); /* ce n'est pas toujours as une instruction */
Total: zero instructions. Donc ça ne répond pas à ta question.
Tu pourrais écrire:
uint32_t* p;
uint32_t totalsize;
p=buffer,totalsize=(*buffer++); /* Une seule instruction */
mais tu ne l'aime pas.
Tu pourrais écrire:
uint32_t* p=buffer;
uint32_t totalsize;
totalsize=(*buffer++); /* Une seule instruction */
mais je ne vois pas l'intérêt.
--
__Pascal Bourguignon__ http://www.informatimago.com/
A bad day in () is better than a good day in {}.
Il me semble que c'est même classique, c'est par exemple ce qu'on fait
tout les jours quand on reçoit le résultat d'un malloc() qui est un
void*.
uint32_t* curseur = buffer; /* ou ... = malloc(...);*/
unuint32_t = *curseur++;
unautreuint32_t = *curseur++;
C'est juste de l'arithmétique des pointeurs.
Pensez également que s'il y a allocation quelque part, il vous faudra
conserver pour libération, d'une façon ou d'une autre, la valeur de
buffer ou la valeur initiale de curseur.
Ou alors je n'ai pas pigé la question ?
--
Pierre Maurette
Déjà, on ne fait pas d'arithmétique sur void*, c'est hasardeux.
Par exemple, GCC considère l'arithmétique sur void* identique à celle de
char* (en émettant un warning). Je ne suis pas sûr que ce soit très sage
de sa part, mais d'autres t'enverront peut-être carrément balader.
Kesako vptr ? un char* ?
Que se passe-t-il si CHAR_BIT > 8 ? :) Mieux vaut utiliser
sizeof(uint32_t) plutôt que 4.
Pas sûr de bien comprendre ce que tu veux faire. Si ton intention est
d'optimiser, tu perds ton temps : un bon compilateur saura faire ce
qu'il faut pour transformer tes "2 instructions" en une seule, si
possible (et en l'occurrence, la plupart des microprocesseurs sont
capables de faire cette opération, et même souvent plus, en un cycle
maximum). De ce point de vue, "une seule instruction" ne signifie pas
grand chose en C.
Ce que tu demandes reviendrait à écrire :
uint32_t totalsize = *((uint32_t *) buffer)++;
Ce qui n'est pas possible puisqu'après le cast, il n'y a plus de lvalue.
Peut-être que ton intention est alors de faciliter l'écriture et la
lecture ? Tu peux t'en sortir avec des macros, mais leur définition
dépend de ce que tu veux vraiment faire... un peu plus d'infos
contextuelles peut-être ? En fait, ce qui semble relativement clair dans
le sujet est obscurci dans l'énoncé.
--
Alexandre