Conversion de type - reinterpret_cast

Bonjour,
J'étudie pour l'instant les conversions de type explicite, et je rame avec reinterpret_cast. Probablement s'agit il d'une mauvaise compréhension du fonctionnnement de ce cast mais voici le test que je tente d'éffectuer :

Code:

---

1 2 3 4 5 6 7 8 9

double *p1; double x = 5; p1=&x; cout << "Adresse de p1 : " << p1 << endl; cout << "Valeur pointee par p1 : " << *p1 <<endl; float *p2 = reinterpret_cast<float*>(p1);   cout << "Adresse pointee par p2 : " << p2 << endl; // adresse bien identique à adresse p1 cout << "Valeur pointee par p2 : " << *p2 << endl; // mais si je déréférence p2 ... alors la valeur obtenue est 0 ???

---

reinterpret_cast permet bien de caster des types différents tel que double* vers float* pourquoi c'est pas marche ??:calim2: Quelqu'un peut-il m'éclairer sur mon erreur ?
Merci d'avance

Salut,

reinterpret_cast n'est pas un truc magique qui permet de transformer tout en n'importe quoi.
Il ne fait qu'indiquer au compilateur que l'on veut traiter ce paquet binaire en suivant ce format choisi.
Les flottants et doubles ont des représentations binaires assez différentes, reinterpret_cast ici est non avenu.

Oui c'est encore moi, j'ai donc continuer à réfléchir, et j'en suis arrivé à me dire que finalement, reinterpret_cast avait bien transférer l'adresse de p1 dans p2 mais qu'il faudrait peut-être y affecter une valeur de type float. Au départ je pensais que la valeur de type double pointée par p1 aurait été caster en float tout simplement. Bon j'affecte donc une nouvelle valeur de type float en déréférencant p2, et comme attendu je peu afficher cette valeur, mais ce que je ne comprend pas c'est que je peux toujours afficher le valeur de p1 qui se trouve exactement à la même adresse. Surprise, moi qui pensais qu'une adresse ne pouvait contenir qu'une valeur, maintenant j'en ai 2. C'est une de trop faut qu'on m'explique ???
Voici mon bout de code, bien sûr je suis débutant;)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

double *p1; double x = 5; p1=&x; cout << "Adresse de p1 : " << p1 << endl; cout << "Valeur pointee par p1 : " << *p1 <<endl; float *p2 = reinterpret_cast<float*>(p1);   cout << "Adresse pointee par p2 : " << p2 << endl; // adresse bien identique à adresse p1 mais sans aucune valeur float affectée float y = 7.7545; // déclaration d'un variable float *p2 = y; // affectation de cette valeur à l'adresse pointée par p2 cout << "Valeur pointee par p2 : " << *p2 << endl; // valeur pointée 7.7545 - adresse hex xxxxxxxx cout << "Valeur pointee par p1 : " << *p1 <<endl; // valeur pointée 5 - adresse strictement la même ??? cout << "Adresse pointee par p1 : " << p1 << endl; // adresse identique pour p1 et p2 cout << "Adresse pointee par p2 : " << p2 << endl;

---

Merci pour votre aide

Citation:

---

Envoyé par Bousk

Salut,

reinterpret_cast n'est pas un truc magique qui permet de transformer tout en n'importe quoi.
Il ne fait qu'indiquer au compilateur que l'on veut traiter ce paquet binaire en suivant ce format choisi.
Les flottants et doubles ont des représentations binaires assez différentes, reinterpret_cast ici est non avenu.

---

Tout d'abord , merci pour ta réponse. Toutefois je ne suis pas sûr de la comprendre.
1. Qu'entend tu par paquet binaire ??
2. De quel format choisi parles tu ?

Sorry si mes questions paraissent un peu idiotes, mais je ne suis pas encore bien familiarisé avec le vocabulaire de programmeur.
J'ai trouver ceci dans un tutoriel sur internet, et c'est de là qu'est parti ma réflexion, ici il ne s'agit nullement d'un projet quelconque mais simplement une réflexion pédagogique.

"Ce genre de pratique est tout à fait réalisable en C++ mais cette fois, on utilisera le mot-clef reinterpret_cast . Pour l'exemple de conversion double* vers float*, on procédera donc de la manière suivante :

Code:

---

1 2	double* dp; float* fp = reinterpret_cast<float*>(dp);

---

Encore merci pour ton temps.

Cherche un autre tutoriel. Ce que tu essaies de faire, à savoir déréférencer un pointeur (ici du type float *) auquel tu as affecté la valeur d'un pointeur d'un autre type incompatible (soit ici double *), mènera invariablement à un comportement indéterminé. En somme, il pourra se passer n'importe quoi et tu ne peux rien en déduire.

On a rarement besoin de reinterpret_cast, et certainement pas pour faire ça.

Tu peux l'utiliser comme ceci en revanche :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <iostream> #include <iomanip>   int main() { auto d = 3.14159; std::cout << "d: " << d << std::endl;   auto c = reinterpret_cast<const unsigned char *>(&d);   std::cout << "c: " << std::hex << std::setw(2); for (auto i = 0u; i < sizeof d; ++i) std::cout << "0x" << static_cast<unsigned int>(c[i]) << ' '; // inspecter la zone mémoire occupée par un objet via unsigned char * est autorisé   std::cout << std::endl << "contents of c as double: " << std::dec << *reinterpret_cast<const double *>(c) << std::endl; // OK : const double * correspond bien au type de l'objet pointé   return 0; }

---

@Matt_Houston,

Merci pour ta réponse, je vais étudier le bout de code que tu m'as envoyé et oublier le mien, je crois éffectivement que c'était un mauvais départ. Finalement j'aime bien démonté les fonctions et mettre les opérateurs à toutes les sauces afin de bien comprendre leurs fonctionnement et les possibilités qu'on peut en tirer. Ce qui peut nous envoyer dans le mur quand le fil conducteur n'est pas le bon. Encore merci.

Salut,

De manière générale, tu dois partir du principe que tu ne dois JAMAIS avoir recours au transtypage:

1. si tu dois avoir recours à static_cast / dynamic_cast, tu es sans doute face à un problème conceptuel, car tu as été "assez bête" pour "perdre" le type réel de l'objet que tu manipule. Les fonctions virtuelles et le double dispatch (dont un exemple classique est le patron de conception visiteur) seront tes principaux alliés pour t'en sortir
2. Si tu dois avoir recours à const_cast, c'est rarement une bonne chose, car tu avais sans doute une bonne raison de vouloir interdire la modification de l'objet
3. reinterpret_cast est, enfin, le transtypage le plus dangereux que l'on puisse trouver, car il permet de convertir tout en n'importe quoi. Le seul cas dans lequel il peut éventuellement être envisagé est celui où tu souhaite extraire ou injecter des données d'un (dans un) flux binaire (ex: un fichier au format binaire). L'idée générale est alors de n'utiliser que les conversions qui pourront aller : De char * vers le type correct de l'élément transtypé et inversément
4. Le transtypage "C style" (ex: (char * ) monFloat) devrait être banni, essentiellement à cause de la difficulté qu'il y a à le retrouver dans une base de code importante. En plus, il correspond à ce que l'on obtiendrait à l'aide d'un reinterpret_cast

Bonjour, merci à tous ceux qui m'ont aidé à voir plus clair dans ces conversions de type implicites et explicites avec lesquels je me débat depuis plusieurs jours. Je crois en effet qu'il faut éviter autant que possible de manipuler son code avec ces opérateurs, et que l'idéal reste de maintenir une certaine rigueur dans sa conception. Toutefois ceci était un excellent exercice pour mes neurones fatigués.
Problème solutionné.
Merci encore. Dany;);)