Discussion :

[DATA13]

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 :

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

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 ?? Quelqu'un peut-il m'éclairer sur mon erreur ?
Merci d'avance

[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.

[DATA13]

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 :

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

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

Encore merci pour ton temps.

[Matt_Houston]

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 :

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

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;
}

[DATA13]

@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.

[koala01]

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

[DATA13]

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 :

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

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