Pourquoi ne puis-je pas reinterpret_cast uint int?

Parce que ce n'est pas ce reinterpret_cast est pour. Tous les permis de conversions avec reinterpret_cast impliquent des pointeurs ou des références, à l'exception d'un entier ou d'un type enum peut être reinterpret_cast à lui-même. Tout ceci est défini dans la norme, [expr.reinterpret.cast].

Je ne suis pas certain de ce que vous essayez d'atteindre ici, mais si vous voulez randomIntNumber avoir la même valeur que randomUintNumber, puis faire

const int64_t randomIntNumber = randomUintNumber;

Si cela se traduit par un avertissement du compilateur, ou si vous voulez juste pour être plus explicite, alors:

const int64_t randomIntNumber = static_cast<int64_t>(randomUintNumber);

Le résultat de la fonte a la même valeur que l'entrée si randomUintNumber est à moins de 2⁶³. Sinon, le résultat est la mise en œuvre défini, mais j'attends de tous connu des implémentations qui sont int64_t vont le définir à faire la chose la plus évidente: le résultat est équivalent à l'entrée modulo 2⁶⁴.

---

Si vous voulez randomIntNumber d'avoir le même bit-motif randomUintNumber, alors vous pouvez faire ceci:

int64_t tmp;
std::memcpy(&tmp, &randomUintNumber, sizeof(tmp));
const int64_t randomIntNumber = tmp;

Depuis int64_t est garanti à utiliser en complément à deux de la représentation, vous espère que la mise en œuvre définit static_cast pour avoir le même résultat que cela de l'extérieur de la plage de valeurs de uint64_t. Mais ce n'est pas vraiment garanti dans la norme, autant que je sache.

Même si randomUintNumber est une constante de compilation, malheureusement, ici randomIntNumber est pas une constante de compilation. Mais alors, de quelle façon "aléatoire" est une constante de compilation? 😉

Si vous avez besoin de travailler autour de cela, et vous n'avez pas confiance en la mise en œuvre doit être raisonnable sur la conversion hors de la portée des valeurs non signées de types signés, alors quelque chose comme ceci:

const int64_t randomIntNumber = 
    randomUintNumber <= INT64_MAX ? 
        (int64_t) randomUintNumber :
        (int64_t) (randomUintNumber - INT64_MAX - 1) + INT64_MIN;

Maintenant, je suis en faveur de l'écriture véritablement code portable si possible, mais même si je pense que cela confine à la paranoïa.

---

Btw, vous pourriez être tenté d'écrire ceci:

const int64_t randomIntNumber = reinterpret_cast<int64_t&>(randomUintNumber);

ou, de manière équivalente:

const int64_t randomIntNumber = *reinterpret_cast<int64_t*>(&randomUintNumber);

Cela n'est pas garanti, car bien que là où ils existent int64_t et uint64_t sont garantis d'être un type signé et un type non signé de la même taille, ils ne sont pas assurés d'être les entiers signés et non signés versions d'une norme de type entier. Donc, il est spécifique à l'implémentation de savoir si ou non ce code viole stricte de l'aliasing. Code qui viole stricte de l'aliasing a un comportement indéfini. Ce qui suit ne pas violer stricte de l'aliasing, et est OK à condition que le motif de bits dans randomUintNumber est une représentation valide d'une valeur de long long:

unsigned long long x = 0;
const long long y = reinterpret_cast<long long &>(x);

Donc sur des implémentations où int64_t et uint64_t sont typedefs pour long long et unsigned long long, puis mon reinterpret_cast est OK. Et comme avec la mise en œuvre de conversion définis par des valeurs de types signés, vous attendre que la chose la plus sensée pour les implémentations à faire est de les rendre correspondant signé/non signé types. Donc, comme le static_cast et la conversion implicite, vous vous attendez à ce qu'il fonctionne dans n'importe quelle mise en œuvre, mais elle n'est pas effectivement garanti.

OriginalL'auteur Steve Jessop

Non, il n'est pas. reinterpret_cast est principalement destiné à réinterpréter un existant bits de stockage comme un type différent qu'il ne l'est. Beaucoup de ces interprétations est dépendant de l'implémentation, et les listes standard spécifique (plutôt longue à citer ici) liste de choses qui peut être fait avec une reinterpret_cast (principalement la conversion entre les différents pointeur/types de référence), mais il dit:

Aucune autre conversion peut être effectuée de manière explicite à l'aide
reinterpret_cast.

Dans votre cas, vous voudrez probablement une conversion de types, et pas une réinterprétation de stockage existant. Utilisation static_cast à cette fin.

OriginalL'auteur PlasmaHH

reinterpret_cast est utilisé pour réinterpréter le stockage de l'objet comme un objet différent. Si vous ne voulez pas passer par libellé standard, vous pouvez trouver tout ce que reinterpret_cast peut faire ici. Généralement, vous pouvez vous souvenir que vous avez à travailler avec les types pointeur.

Donc, si vous voulez vraiment à réinterpréter les bits utilisés pour votre uint64_t comme int64_t, puis le faire:

int64_t randomIntNumber = reinterpret_cast<int64_t&> (randomUintNumber);

Toutefois, si vous ne voulez convertir que l'objet, la préservation de sa valeur, si possible ... il suffit de faire ce que le compilateur suggère et l'utilisation static_cast à la place.

OriginalL'auteur Fiktik