reinterpret cast qui ne fonctionne pas?

Bonjour tout le monde,

j'ai besoin d'effectuer un cast sur des pointeurs,

J'ai réalisé un programme de test, celui ci ne me donne pas le résultat escompté. Voici le code

Code:

---

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

#include "stdafx.h" #include<iostream>   using namespace std;   int main()   float *b = new float; double *c = new double;   *b = 100; *c = 10;   b = reinterpret_cast<float*>(c); // je m'attends donc ici à ce que la valeur de *b soit 10;   cout << *b << endl; cout << *c << endl;   return 0; }

---

Ici je m'attends à ce que *b et *c valent 10, or *b vaut 0.

Savez-vous d'où vient mon erreur?

Bonjour ,
dans ton reinterpret_cast<> , vous castez le pointer sur double en pointeur sur float , possible que ca profoque une erreur . apres ,essayez

Code:

---

*b = reinterpret_cast<float>(*c)

---

car il est possible, je ne suis pas expert de ca , que le cast des pointeur , change le type du pointeur , mais pas la valeur pointée , et donc , lors de cout , le float du début ne peut plus s'afficher , car lors du transtypage vers un pointeur vers double , ca a reset l'addresse en mémoire , et donc la valeur de la valeur pointée est 0

Merci pour ta réponse Remilia!

Alors j'ai tenté ta proposition elle ne fonctionne pas, cependant, en combinant ce que tu as écris et ce que j'ai compris des casts, j'ai réussi à trouver une commande qui me donne un résultat satisfaisant:

Code:

---

1 2	*b = static_cast<float>(*c);

---

Je ne comprends cependant pas pourquoi ma première proposition ne fonctionnait pas : est ce que ca vient du fait que le compilateur réinterprète la suite de bit avec la commande reinterpret_cast ?

Je ne comprends pas non plus nouveau point (dites moi si vous pensez que je dois ouvrir un nouveau thread) :

Mon idée originelle était de créer deux variables de types differents : b et c. Je voudrais que ces variables aient toujours la même valeurs. SI a et b avaient été de même type, j'aurais fait par exemple

Code:

---

1 2 3 4 5

int *b, *c; b=new int, c=new int; c= b;

---

et tout le reste de mon programme, *b et *c auraient eu la mème valeur (si j'avais changé *b ou *c).

Le problème est qu'ici je n'arrive pas à réaliser ça avec des variables de type différents et des static_cast...

Avez vous une idée?

Bonjour

Tu peux utiliser une référence pour ça :

Code:

---

1 2	int b = 0; int & c = b;

---

Merci Ehonn,

Cela fonctionne (avec la méthode des pointeurs), si b et c sont de même type... Si ils sont de type differents comment dois-je faire?

Tu peux essayer quelque chose de ce goût là :

Code:

---

1 2	float a = 0.f; double & b = *reinterpret_cast<double*>(&a);

---

Sinon, c'est peut être plus propre avec une union (?)

Et , effectivement , les différents "types" de casts sont les suivants :

• static_cast<> : pour les conversions "standards", est la plupart du temps completement safe MAIS ne peut pas tout convertir
• reinterpret_cast<> : reinterprete les octets de données , marche avec TOUT , mais est completement bourrin , ce qui , en cas d'erreur de logique , peut créer des résultats....surprenants voir corrompre des données (je convertis une std::string en int , ca.....va pas le faire)
• const_cast<> : je ne vais pas l'expliquer , car son utilisation quasi démontre une erreur de conception

Hello

J'ai du mal à saisir quel genre de use case peut justifier de reinterpret_cast un double en float. C'est une très mauvaise pratique, qui à mon avis a un comportement indéfini par la norme. float n'est pas une abstraction de double, c'est un type complètement différent. Pour convertir de l'un à l'autre, il faut utiliser static_cast sur les valeurs et non pas les pointeurs.

awawawa, à mon avis tu ne devrais pas utiliser de pointeurs du tout.

Tu ne peux pas espérer un résultat significatif en faisant un pointer-cast entre float et double, car (en IEEE) les deux ont des formats différents: En particulier, ils n'ont pas le même nombre de bits dans l'exposant, donc tronquer/"étendre par zero" la mantisse ne suffit pas!

Franchement, le pointer-cast sur des float ou double, ça ne sert vraiment qu'à une chose: Afficher la représentation du nombre en binaire ou en hexadécimal (auquel cas on caste en int32_t et int64_t respectivement) ou à faire des calculs bizarres avec.

Salut tout le monde,

Tout d’abord je tiens vraiment à vous remercier pour votre réactivité et pour vos réponses.

Supposons que je possède une classe dont l'une des donnée membre est redondante l'une des données qui existe dans une classe mère. Pas par défaut de conception mais plutôt par défaut de normalisation entres différentes APIs :

Exemple je défini une classe voiture

Code:

---

1 2 3 4

class voiture { int *nbPneus; }

---

Que Renault maintenant me fournisse une API avec la fonction et la structure suivante:

Code:

---

1 2 3 4 5 6

structure Carracteristiques { float *NbRoues; float *nbVolant; } Carracteristiques getCarracteritiques (void);

---

Pour ne pas avoir a tout reprogrammer pour chaque constructeur, je peux imaginer créer une classe renault

Code:

---

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

class renault:: publi voiture { structure Carracteristiques { float *NbRoues; float *nbVolant; }   Carracteristiques getCarracteritiques (void);   private :   Carracteristiques mCarracteritiques }

---

J'aimerais qu'à l’intérieur de la classe Renault, la condition mCarracteristiques.NbRoues ==Nbroues soit toujours verifiée.

D'où ma demande

Pas faisable avec un pointeur.

PS: Caractéristique ne prend qu'un seul R.

Quelque chose me frappe : pourquoi diable utilises-tu des pointeurs partout ? Du reste compter un nombre de roues et de pneus avec un nombre flottant est quelque peu étrange. Peux-tu avoir 1,5 roues ? Un entier ferait mieux l'affaire :).

Pour en revenir à la généralité de ton problème, ce que tu cherches à faire, c'est maintenir un invariant. De mon point de vue, il n'y a aucune raison d'encapsuler Caracteristiques dans Voiture, et aucune raison de dupliquer les données. Si tu ne dupliques pas, ton problème d'invariant ne se posera pas.

Si tu dois mélanger des classes qui ont des incohérences d'API entre elles, alors tu peux cacher cela et fournir des fonctions membres d'accès qui ne modifieront les données qu'en assurant l'invariant.

Merci jblecanard et merci...Médinoc ;)


J'ai pris le nombre de pneus, j'aurais pu prendre le niveau d'huile : supposons que Toyota me le donne en float et Renault en double ;)

Je préfère garder la structure de chez Renault dans la classe Renault car elle contient des données propres à ce constructeur, non accessibles à l'utilisateur lambda (qui a accès seulement aux données de la classe voiture), mais qui pourront être utiles en cas de diagnostic, par exemple.

Citation:

---

Si tu dois mélanger des classes qui ont des incohérences d'API entre elles, alors tu peux cacher cela et fournir des fonctions membres d'accès qui ne modifieront les données qu'en assurant l'invariant.

---

Je pense que je vais faire ça au final : c'était ma première idée, mais je me suis dit que pointer le même emplacement mémoire me permettrait de ne pas me soucier des mises à jours des valeurs de ces variables

Comme dit plus haut, float et double n'ont strictement rien à voir binairement parlant, donc espérer avoir la même valeur pointée en castant de la sorte c'est totalement impossible.
Globalement, caster des trucs qui n'ont pas la même taille à coup de reinterpret faut être certain de ce que l'on fait.
Soit c'est n'importe quoi, soit tu cherches à utiliser le static_cast sans le savoir ? :calim2:

Re re re merci tout le monde

Effectivement...

Ce que j'aurais aimé, pour être plus concis, c'est

Code:

---

1 2 3

float *a; double *b;

---

Et maintenir la condition *a==*b pendant toute l'exécution du programme sans avoir à se soucier des mises à jour de *a lorsque *b est changé et vice versa. Du coup je me suis dit : que a et b pointent sur le meme emplacement mémoire[...] (certes il aurait pu avoir un problème de débordement dans un cas mais passons)

D'après vos retours ce n'est pas possible...

À mon avis la bonne solution reste l'utilisation des références (c'est fait pour ça).

Code:

---

1 2	float a = 0; float & b = a;

---

L'équivalent avec des pointeurs serait :

Code:

---

1 2 3

float v = 0; float * const a = &v; float * const b = &v;

---

Après pour l'interprétation double en tant que float, soit tu sais vraiment ce que tu fais et tu joues avec reinterpret_cast, soit tu prends en compte les messages précédents à ce sujet.

Citation:

---

Envoyé par awawawa

D'après vos retours ce n'est pas possible...

---

En fait, en encapsulant ça dans une classe, ça va être possible d'avoir « *a == *b » (suffit de surcharger l'opérateur unaire *) (dans un contexte mono-thread).
On peut te le montrer (pour la pédagogie) mais, promis, ce n'est pas " ce que tu veux ".

Ehonn, tes conseils ne vont pas s'appliquer car awawawa cherche à appliquer cet invariant sur un double un un float, pas sur deux float ou deux double.

Citation:

---

Envoyé par awawawa

(certes il aurait pu avoir un problème de débordement dans un cas mais passons)

D'après vos retours ce n'est pas possible...

---

awawawa, les nombres à virgule flottante ne sont pas encodés comme des entiers, ce n'est pas un problème de débordement que tu vas avoir, mais pire ! Il faut comprendre ce que tu fais. reinterpret_cast est violent et son usage correct nécessite que tu connaisses précisément comment les données sont représentées en mémoire. Ce n'est pas un reproche, mais tout porte à croire que ce n'est pas le cas. reinterpret_cast est inadapté à ton besoin. Tu devrais plutôt utiliser des références et des static_cast.

Merci tout le monde,

Je laisse ce thread ouvert. Je prendrai un peu de temps ce weekend pour tester 2 - 3 choses et je reviens vers vous avec mes conclusions

:)

Bonjour,

Pourquoi ne pas utiliser un variant (style QVariant, ou Boost::variant) ?

Honnêtement, une classe unique, avec un setter/getter pour float, un autre pour double, qui stocke tout en double en interne et cast quand nécessaire, ça me parait le plus judicieux.

Salut,

Autant le dire tout de suite, je n'ai lu que les quelques premières interventions... Ce qui suit aura donc peut être déjà été dit ;)

De manière générale, reinterpret_cast ne devrait servir qu'à une chose : convertir une donnée quelconque en un char * et inversement, sans doute à fins d'une sérialisation en binaire.

Toute tentative d'utilisation de reinterpret_cast autre que celle là présente exactement les même risques que ceux liés au transtypage "à la barbare" tel qu'utilisé en C et mènera systématiquement à des catastrophes.

Quant aux incohérences d'interface, le problème devrait se régler non pas en essayant de convertir les données d'un type en l'autre (des float en double ou l'inverse), mais bien en mettant au point une abstraction commune, qui sait, qui pourrait être proche de

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

class Caracteristique{ public: Caracteristique(Caracteristique const & ) = delete; Caracteristique & operator = (Caracteristique const &) = delete; virtual bool accept(VisiteurCaracteristique /* const */ & ) const; }; class CaracteristiqueRenault : public Caracteristique{ bool accept(VisiteurCaracteristique /* const */ & v) const{ return v.visit(*this); } private: /* donnees spécifiques à Renault */ }; class CaracteristiqueAudi : public Caracteristique{ bool accept(VisiteurCaracteristique /* const */ & v) const{ return v.visit(*this); } private: /* donnees spécifiques à Audi */ }; class Vehicule{ public : /* ... */ private : std::unique_ptr<Caracteristique> caracteristiques_; };

---

Bien sur, il est possible de remplacer le visiteur par n'importe quel autre possibilité ayant recours au double dispatch, ce n'est qu'un exemple "vite fait"... Mais, le principe de base est que l'utilisateur des caractéristiques n'a absolument aucun besoin de savoir la manière dont les données sont représentées en interne par les différentes marques ;).

Tout ce qu'il a besoin de savoir, c'est les services que l'on est en droit de s'attendre de la part de l'abstraction de base ;)

Citation:

---

Envoyé par koala01

De manière générale, reinterpret_cast ne devrait servir qu'à une chose : convertir une donnée quelconque en un char * et inversement, sans doute à fins d'une sérialisation en binaire.

---

Il y a tout de même un autre use case, lorsqu'on utilise une dépendance en C qui utilise des callbacks, pour faire transiter une donnée utilisateur dans un void* (exemples : libevent, libuv, bibliotèques d'interfaces graphiques). Ajouté à celui que tu cites, je n'en vois pas d'autres.

Bêtise, voir réponse de Médinoc.

Citation:

---

Envoyé par jblecanard

Il y a tout de même un autre use case, lorsqu'on utilise une dépendance en C qui utilise des callbacks, pour faire transiter une donnée utilisateur dans un void* (exemples : libevent, libuv, bibliotèques d'interfaces graphiques). Ajouté à celui que tu cites, je n'en vois pas d'autres.

---

Sauf qu'un static_cast<> suffit pour caster depuis void* vers autre chose.

Si peu de dev le font que je l'avais oublié :aie: ... c'est exact.

Oui,

je pense que je vais passer par des accesseurs...


Merci tout le monde en tout cas :)