C++: ne peut pas static_cast de la double* int*

Lorsque j'essaie d'utiliser un static_cast de jeter un double* un int*, j'obtiens l'erreur suivante:

invalid static_cast from type ‘double*’ to type ‘int*’

Voici le code:

#include <iostream>
int main()
{
        double* p = new double(2);
        int* r;

        r=static_cast<int*>(p);

        std::cout << *r << std::endl;
}

Je comprends qu'il y aurait des problèmes de conversion entre un double et un int, mais pourquoi il y a un problème de conversion entre un double* et un int*?

Pas dupe, mais connexes: stackoverflow.com/questions/2253168/dynamic-cast-in-c/...
Il y a d'autres erreurs dans votre code, que j'ai détaillé dans ma réponse stackoverflow.com/questions/2473628/...
Si vous souhaitez modifier le flotteur de bits c'est la mauvaise façon de le faire. Utilisation memcpy à la place. Sinon, vous violez stricte aliasing règles et éventuellement violer l'alignement, trop.
"L'utilisation memcpy au lieu de" - et non pas à une int, mais plutôt d'une unsigned char[sizeof(double)]. Ou un uint64_t si vous savez que sizeof(double) == 8 et CHAR_BIT == 8, qui, très probablement, vous ne si vous en savez assez sur la mise en œuvre utilement à faire n'importe quoi avec les bits d'un double.

OriginalL'auteur samoz | 2010-03-18

c++casting static-cast

19

En plus d'être des pointeurs, double* et int* n'ont rien en commun. On pourrait dire la même chose pour Foo* et Bar* types de pointeur de toute dissemblables structures.

static_cast signifie qu'un pointeur du type de source peut être utilisé comme un pointeur du type de destination, ce qui nécessite un sous-type de relation.

OriginalL'auteur Potatoswatter
22

Vous devez utiliser reinterpret_cast pour la coulée des pointeurs, c'est à dire
```
r = reinterpret_cast<int*>(p);
```
Bien sûr, cela n'a aucun sens,

sauf si vous voulez prendre un intniveau de l'oeil à un double! Vous aurez un peu bizarre de sortie et je ne pense pas que ce est ce que vous avez prévu. Si vous voulez lancer le valeur pointé par p à un int puis,
```
*r = static_cast<int>(*p);
```
Aussi, r n'est pas alloué de sorte que vous pouvez effectuer l'une des opérations suivantes:
```
int *r = new int(0);
*r = static_cast<int>(*p);
std::cout << *r << std::endl;
```
Ou
```
int r = 0;
r = static_cast<int>(*p);
std::cout << r << std::endl;
```
"... doit utiliser reinterpret_cast ..." n'est pas une bonne phrase.
De plus comme vous /besoin d ' / utilisation reinterpret_cast pour les pointeurs... la seule valable scénario à utiliser il est bien si vous avez (principalement pour des raisons techniques) à un void* qui ont besoin de jeter un type concret. par exemple, 3e paramètre de pthread_create() est une fonction qui a 1 argument: un void* qui vous devez ensuite coulé à votre structure/etc.
Le monde n'est pas parfait. Vous êtes obligés d'utiliser le code d'autres bibliothèques. Et situation "utiliser reinterpret_cast une bonne phrase 🙂
Il y a d'autres cas - par exemple dans OpenCV les images sont rembourrés afin de traverser double des images à l'aide de l'arithmétique des pointeurs, vous avez besoin de travailler à l'échelle d'une unsigned char de sauter le rembourrage pour se déplacer entre les lignes. Donc, ensuite l'accès à la double valeurs de sens que si vous utilisez reinterpret_cast. C'est le uniquement j'ai utilisé, mais il a fait de mon code beaucoup plus propre.
"mettre certaines informations en p avant de l'utiliser!"... C'est ce nouveau double(2), il initialise la valeur de type double pour 2.

OriginalL'auteur Jacob
4

À virgule flottante-à-entier de conversion est pris en charge, donc int a = static_cast<int>(5.2) est très bien. Cependant, c'est une conversion - le sous-jacent types de données sont totalement incompatibles. Ce que vous me demandez, c'est pour l'exécution de convertir un pointeur vers une 8 octets de la structure d'un pointeur de 4 octets de la structure, il ne peut pas le faire de façon significative.

Ceci étant dit, si vous voulez vraiment interpréter votre double comme un entier, int* r = reinterpret_cast<int*>(p) fonctionnera très bien.

OriginalL'auteur Dathan
0

Vous pouvez convertir entre une chambre double et un int avec static_cast<>, mais pas entre les pointeurs de types différents. Vous pouvez convertir n'importe quel type de pointeur ou de void * avec static_cast<>.

La justification peut être que int * et double * sont souvent efficacement les tableaux et la mise en oeuvre ne sais pas comment big le tableau est.

OriginalL'auteur David Thornley
-1

Parce que vous avez utilisé double * au lieu de double

La * après il signifie que vous devez déclarer un pointeur, ce qui est très différent d'un double régulière.

C++ ne peut en toute sécurité static_cast un pointeur vers un autre type de pointeur comme ça.

Si vous êtes désireux de faire ce genre de chose, vous devez d'abord déréférencement de la variable.
```
r=new int(static_cast<int>(*p));
```
Vous devez utiliser new parce que d'un lit double et d'un entier ne peut pas résider dans le même espace mémoire(sainement)

OriginalL'auteur Earlz

Vous devez vous connecter pour publier un commentaire.

Bien sûr, cela n'a aucun sens,