probléme de pointeurs? - Page 1

Je suis en train de convertir du code assembleur vers le C++ et j'ai un petit souci d'interprétation..si vous pouviez m'aider..

j'ai 2 pointeurs définis (qui pointent sur des emplacements de méemoire que je vais dumper)

LPVOID pt1;
LPVOID pt2;

je voudrais en final que pt1 pointe vers l'adresse contenu dans le pointeur de pt2..

comment puis-je affecter pt1 de facon à ce qu'il pointe vers l'adresse contenu dans le pointeur pt2

example..
pt2->zone memoire :00 34 56 78

je voudrais que pt1 point vers l'adresse 78 56 34 00

merci de votre aide

pt1 = *pt2 ; ??

pt1 = *((LPVOID*) ptr2);
?

Un pointeur en C est une valeur comme les autres.
ptr2 = ptr1 fait pointer ptr2 vers l'adresse pointée par ptr1, i.e. ptr1 et ptr2 pointent vers la même zone mémoire.

ptr2 = *ptr1 fait prendre à ptr2 la valeur à l'adresse pointée par ptr1. Cette valeur devait-être elle-même une adresse. Ce qui veut dire que ptr2 doit avoir le type suivant :
LPVOID *ptr1; //Pointeur vers un LPVOID
LPVOID **ptr2; // Pointeur vers un pointeur vers un LPVOID

Sinon, si le compilateur ne sait pas que LPVOID est un type pointeur, le cast de PpHd fait la job (TM).

Détruire SVP, double post.

merci de vos reponses en regardant de plus pres

pt1=(LPBYTE)(*(int*)(pt2)) est il correct?

si je reste en LPVOID il ne saura peut etre pas que la longueur de ladresse est de 4 bytes??

1. peut etre. mais ca devient gore.
2. Si.

Frenchy :
merci de vos reponses en regardant de plus pres

pt1=(LPBYTE)(*(int*)(pt2)) est il correct?

si je reste en LPVOID il ne saura peut etre pas que la longueur de ladresse est de 4 bytes??

pt1=(LPBYTE)(*(int*)(pt2))
Cast en LPBYTE les sizeof(int) octets (2 vraisemblablement) à l'adresse pointé par pt2, je ne suis pas sûr que c'est ce que tu veux.

En gros, quand le compilateur voit : (int*)pt2, il se dit 'ça pointe vers un int';
Quand il voit (*(int*)(pt2)) il voit 'le int à l'adresse pt2';
Quand il voit (LPBYTE)(*(int*)(pt2)), il convertie le int à l'adresse pt2 en LPBYTE.

Quand il voit (LPBYTE)(*(int*)(pt2)), il convertie le int à l'adresse pt2 en LPBYTE.

LPBYTE est un pointeur , d'ailleurs peu importe ce que tu mets là..aprés c'est selon les besoins...j'ai testé ca fonctionne..je récupére bien l'adresse..

Frenchy
:

Quand il voit (LPBYTE)(*(int*)(pt2)), il convertie le int à l'adresse pt2 en LPBYTE.

LPBYTE est un pointeur , d'ailleurs peu importe ce que tu mets là..aprés c'est selon les besoins...j'ai testé ca fonctionne..je récupére bien l'adresse..

C'est possible. Mais t'es sur une machine litle-endian (style x86) ou tu as des int de 32 bits, non ? Parceque (LPBYTE)(*(int*)(pt2)) cast un int de sizeof(int) octets en adresse, pas sizeof(LPBYTE) octets.

Le danger est que si, par exemple, tes int sont des 16-bit et tes pointeurs des 32-bit, et que ton adresse ne rentre pas sur 16 bits, tu vas en perdre une partie :

pt => FF 00 00 00

donc, si tes litle-endian, pt pointe vers 00 00 00 FF
quand tu fais : (*(int*)(pt)), tu va chercher ceci : FF 00
Je présume que tu n'as pas de problème parce que les 00 00 de l'adresse 00 00 00 FF ne sont pas significatifs.

Si je me trompe, dites-moi le.

Vu qu'il utilise LPBYTE, il doit se ****** completement des architectures non-*********

PpHd :
Vu qu'il utilise LPBYTE, il doit se ****** completement des architectures non-*********

Je trouve simplement currieux qu'il déréférence un int qui est la plupart du temps 16-bit, pour récupérer une adresse qui est la plupart du temps 32-bit. Je veux juste comprendre pourquoi, voilà tout.

>Je trouve simplement currieux qu'il déréférence un int qui est la plupart du temps 16-bit,
32 bits sur PC $)

PpHd :
>Je trouve simplement currieux qu'il déréférence un int qui est la plupart du temps 16-bit,
32 bits sur PC $)

Ça semble être vrai, et c'est pourquoi son truc est ok. Il me semble que c'est pas plus propre qu'il faut par contre ...

Il me semble que pt1=(LPBYTE)(*(LPBYTE*)(pt2)) aurait été plus clean.

Lorsqu'on veut etre propre on n'utilise pas ls LPVOID, et autre *********

PpHd :
Lorsqu'on veut etre propre on n'utilise pas ls LPVOID, et autre *********

Ça peut toujours être utile de faire des defines, pour faire du du code portable entre autres...

#include <stdint.h>
est mon ami.

Je sais trés bien que je peux être plus rigoureux..Chaque chose en son temps, l'important quand tu as une foule de problème c'est de les prendre un par un..Le problème ici est de trouver une solution à une écriture assembleur..c'est tout..

L'emploi des casts est important en C comme le montre cet exemple..

maintenant le fait que j'utilise un LPVOID ou autre peu importe l'important c'est de dominer ce que l'on fait en fonction des objectifs.

Merci de vos réponses ce post m'a été très instructif

Je suis d'accord. Je voulais comprendre pourquoi

Cela dit Quesoft a raison, ton programme planterait sur ma machine avec le cast en int
Enfin il planterait si j'avais un windows avec de quoi le compiler
Mes pointeurs font 64 bits, mes int en font 32.

Mon petit Linux a les meme tailles