Discussion :

[Remilia]

Bonjour ! Dans un de mes programmes , a un endroit (introduction hyper concise ), l'on utilise de l'arithmétique de pointeurs pour calculer une donnée en mémoire. L'expression de calcul , évaluée par le compilateur comme étant un uintptr_t , "disparait" lors du
reinterpret_cast<>() . L'expression semble être valide, quelques std::cout a l'appui , cepandant , la cast a l'air d'absorber cette expression , donnant lors d'un cout , rien , pas meme 0 ou un espace....(le compilo' ne lance pas le warning "statement has no effect" par ailleur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
 std::cout << (VMA_DMA_buffer+(i*SIZE_OF_SPR_STRUCT)+(3*sizeof(uint16_t))+sizeof(uint8_t)) << '\n' // affiche bien une addresse mémoire valide, et cohérente par rapport aux calculs
 uint8_t* OffsetLargeur = reinterpret_cast<uint8_t *>(VMA_DMA_buffer+(i*SIZE_OF_SPR_STRUCT)+(3*sizeof(uint16_t))+sizeof(uint8_t));
//quelques autres calculs du même acabit, pour calculer d'autre pointeurs,"éffacés eux aussi" , OffsetLargeur n'y est pas impliqué
 std::cout << OffsetLargeur << '\n' // mis pour le debug , est vide....

Le déréférencement de ces pointeurs vides montrent la valeur 0x00 , alors que l'addresse pointée par l'expression est remplie de 0xFF (le memory dump le confirme )
(précision si nécessaire, l'expression calcule l'emplacement de la Largeur d'un sprite dans une memory pool (VMA_DMA_buffer) en fonction du tour de boucle (i) la taille de la structure (SIZE_OF_SPR_STRUCT), et les

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

(3*sizeof(uint16_t))

et le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sizeof(uint8_t)

sont les autres membres de la "structure" a retrouver.

La question est donc : Pourquoi est-ce que ca se fait absorber dans le néant absolu , et auxiliairement comment résoudre ca ??
EDIT : le debugger avec les Watchs montrents aucun changement , commence a l'état "rien" et continue sur cet état, et cela , même en release

[dalfab]

Bonjour,

Le vide n'existe pas en C++.
Un pointeur pointe toujours quelque part, 3 cas possibles :
* le lieu est valide
* le lieu est inaccessible en lecture et/ou écriture
* le lieu est dans une zone erronée mais accessible.

Attention, uintptr_t a un nom trompeur, ça n'est pas un pointeur c'est un entier. uint8_t* est quant à lui un pointeur.
On ne doit jamais jamais utiliser reinterpret_cast à moins de maîtriser ce que l'on fait (revient à dire au compilateur "tu n'es qu'un compilateur et je sais mieux que toi ce que je fais").

Le comportement de cout<< avec un uintptr_t va afficher le nombre.
Le comportement de cout<< avec un uint8_t* peut tenter de déréférencer le pointeur et si le lieu n'est pas valide... tout est possible.

[Remilia]

Ok merci ^^' entre temps je m'en étais rendu compte que cout essayait de déréférencer le pointeur.... Mais quel type de type arithmetique dois-je utiliser pour déduire des addresses mémoires ? J'ai choisi
uintptr_t car il est garanti par le standard d'être assez grand pour contenir des addresses mémoires, puisque ce programme va sans doute run sur des machines 64, 32, et même 16 bits (embedded). Bref , donc , quel type dois-je utiliser ??? Le reinterpret_cast<> est assez sale , mais comment passer d'une addresse mémoire sous forme de nombre a un pointer, puisque le cast le plus propre est le static_cast<> mais ne fonctionne pas ? Ou alors y a-t-il une autre solution pour ce que je veux faire (déduire une addresse)

[dalfab]

Le reinterpret_cast est le moyen le plus propre permettant de convertir des entiers en pointeur ou inversement.
Et si on veut afficher un pointeur, la conversion en uintptr_t est une bonne solution.

Le sujet de ton topic est l'inverse.
On n'affiche normalement pas la valeur d'un pointeur, à part en mode curieux.

[Remilia]

Ok ^^ j'ai les résultats attendus (j'y ait travaillé la nuit derniere), donc tous les problemes sont résolus !! Encore merci dalfab :p