Quand utiliser reinterpret_cast?

Je suis un peu confus avec l'applicabilité de reinterpret_castvs static_cast. D'après ce que j'ai lu, les règles générales consistent à utiliser une conversion statique lorsque les types peuvent être interprétés au moment de la compilation, d'où le mot static. C'est le cast que le compilateur C ++ utilise également en interne pour les conversions implicites.

reinterpret_casts sont applicables dans deux scénarios:

• convertir des types entiers en types pointeurs et vice versa
• convertir un type de pointeur en un autre. L'idée générale que je me fais est que ce n'est pas transférable et doit être évité.

Là où je suis un peu confus, c'est une utilisation dont j'ai besoin, j'appelle C ++ à partir de C et le code C doit s'accrocher à l'objet C ++, donc en gros il contient un void*. Quelle conversion doit être utilisée pour convertir entre le type void *et le type Class?

J'ai vu l'utilisation des deux static_castet reinterpret_cast? Bien que d'après ce que j'ai lu, il semble staticque la diffusion puisse être meilleure au moment de la compilation? Bien qu'il indique d'utiliser reinterpret_castpour convertir d'un type de pointeur à un autre?

La norme C ++ garantit les éléments suivants:

static_castun pointeur vers et depuis void*conserve l’adresse. C'est-à-dire, dans ce qui suit,a , bet ctous les points à la même adresse:

int* a = new int();
void* b = static_cast<void*>(a);
int* c = static_cast<int*>(b);

reinterpret_cast garantit uniquement que si vous transformez un pointeur en un autre type, puis en reinterpret_castle replaçant dans le type d'origine , vous obtenez la valeur d'origine. Donc, dans ce qui suit:

int* a = new int();
void* b = reinterpret_cast<void*>(a);
int* c = reinterpret_cast<int*>(b);

aet ccontiennent la même valeur, mais la valeur de bn'est pas spécifiée. (dans la pratique, il contiendra généralement la même adresse que aet c, mais ce n'est pas spécifié dans la norme, et cela peut ne pas être vrai sur les machines avec des systèmes de mémoire plus complexes.)

Pour la coulée vers et depuis void*, static_castdoit être préférée.

Un cas où cela reinterpret_castest nécessaire est lors de l'interfaçage avec des types de données opaques. Cela se produit fréquemment dans les API des fournisseurs sur lesquelles le programmeur n'a aucun contrôle. Voici un exemple artificiel où un fournisseur fournit une API pour stocker et récupérer des données globales arbitraires:

// vendor.hpp
typedef struct _Opaque * VendorGlobalUserData;
void VendorSetUserData(VendorGlobalUserData p);
VendorGlobalUserData VendorGetUserData();

Pour utiliser cette API, le programmeur doit convertir et inverser ses données VendorGlobalUserData. static_castne fonctionnera pas, il faut utiliser reinterpret_cast:

// main.cpp
#include "vendor.hpp"
#include <iostream>
using namespace std;

struct MyUserData {
    MyUserData() : m(42) {}
    int m;
};

int main() {
    MyUserData u;

        // store global data
    VendorGlobalUserData d1;
//  d1 = &u;                                          // compile error
//  d1 = static_cast<VendorGlobalUserData>(&u);       // compile error
    d1 = reinterpret_cast<VendorGlobalUserData>(&u);  // ok
    VendorSetUserData(d1);

        // do other stuff...

        // retrieve global data
    VendorGlobalUserData d2 = VendorGetUserData();
    MyUserData * p = 0;
//  p = d2;                                           // compile error
//  p = static_cast<MyUserData *>(d2);                // compile error
    p = reinterpret_cast<MyUserData *>(d2);           // ok

    if (p) { cout << p->m << endl; }
    return 0;
}

Voici une implémentation artificielle de l'exemple d'API:

// vendor.cpp
static VendorGlobalUserData g = 0;
void VendorSetUserData(VendorGlobalUserData p) { g = p; }
VendorGlobalUserData VendorGetUserData() { return g; }

La réponse courte: si vous ne savez pas ce que reinterpret_castsignifie, ne l'utilisez pas. Si vous en aurez besoin à l'avenir, vous le saurez.

Réponse complète:

Prenons les types de nombres de base.

Lorsque vous convertissez par exemple int(12)à unsigned float (12.0f)vos besoins de processeur pour appeler certains calculs que les deux nombres a une représentation différente de bits. Voilà ce que static_castreprésente.

D'un autre côté, lorsque vous appelez reinterpret_castle CPU , il n'appelle aucun calcul. Il traite simplement un ensemble de bits dans la mémoire comme s'il avait un autre type. Ainsi, lorsque vous convertissez int*en float*avec ce mot clé, la nouvelle valeur (après le déréférencement du pointeur) n'a rien à voir avec l'ancienne valeur au sens mathématique.

Exemple: Il est vrai que cereinterpret_castn'est pas portable pour une raison - l'ordre des octets (endianness). Mais c'est souvent étonnamment la meilleure raison de l'utiliser. Imaginons l'exemple: vous devez lire un nombre binaire 32 bits à partir d'un fichier, et vous savez que c'est du big endian. Votre code doit être générique et fonctionne correctement sur les systèmes big endian (par exemple certains ARM) et little endian (par exemple x86). Vous devez donc vérifier l'ordre des octets. Il est bien connu au moment de la compilation, vous pouvez donc écrire une constexprfonction: Vous pouvez écrire une fonction pour y parvenir:

/*constexpr*/ bool is_little_endian() {
  std::uint16_t x=0x0001;
  auto p = reinterpret_cast<std::uint8_t*>(&x);
  return *p != 0;
}

Explication: la représentation binaire dexen mémoire peut être0000'0000'0000'0001(grande) ou0000'0001'0000'0000(peu endienne). Après la réinterprétation, l'octet sous leppointeur peut être respectivement0000'0000ou0000'0001. Si vous utilisez la conversion statique, elle le sera toujours0000'0001, quelle que soit l'endianité utilisée.

ÉDITER:

_{Dans la première version que j'ai fait par exemple la fonction is_little_endiand'être constexpr. Il compile bien sur le plus récent gcc (8.3.0) mais la norme dit qu'il est illégal. Le compilateur clang refuse de le compiler (ce qui est correct).}

La signification de reinterpret_castn'est pas définie par la norme C ++. Par conséquent, en théorie, un programme reinterpret_castpourrait planter. Dans la pratique, les compilateurs essaient de faire ce que vous attendez, c'est-à-dire d'interpréter les morceaux de ce que vous transmettez comme s'ils étaient du type vers lequel vous diffusez. Si vous savez ce que font les compilateurs que vous allez utiliser, reinterpret_cast vous pouvez l’utiliser, mais pour dire qu’il est portable serait mentir.

Pour le cas que vous décrivez, et à peu près tous les cas où vous pourriez envisager reinterpret_cast, vous pouvez utiliser static_castou une autre alternative à la place. Entre autres choses, la norme a ceci à dire sur ce à quoi vous pouvez vous attendre static_cast(§5.2.9):

Une valeur r de type «pointeur vers cv void» peut être explicitement convertie en pointeur vers le type d'objet. Une valeur de type pointeur vers objet converti en "pointeur vers cv void" et revenant au type de pointeur d'origine aura sa valeur d'origine.

Donc, pour votre cas d'utilisation, il semble assez clair que le comité de normalisation vous a destiné à utiliser static_cast.

Une utilisation de reinterpret_cast est si vous souhaitez appliquer des opérations au niveau du bit aux flottants (IEEE 754). Un exemple de ceci était l'astuce Fast Inverse Square-Root:

https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code

Il traite la représentation binaire du flottant comme un entier, le déplace vers la droite et le soustrait d'une constante, réduisant ainsi de moitié et annulant l'exposant. Après la reconversion en float, il est soumis à une itération de Newton-Raphson pour rendre cette approximation plus exacte:

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the deuce? 
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

Cela a été écrit à l'origine en C, donc utilise des transtypages en C, mais le cast C ++ analogue est le reinterpret_cast.

Vous pouvez utiliser reinterprete_cast pour vérifier l'héritage au moment de la compilation.
Regardez ici: Utilisation de reinterpret_cast pour vérifier l'héritage au moment de la compilation

template <class outType, class inType>
outType safe_cast(inType pointer)
{
    void* temp = static_cast<void*>(pointer);
    return static_cast<outType>(temp);
}

J'ai essayé de conclure et j'ai écrit une distribution simple et sûre à l'aide de modèles. Notez que cette solution ne garantit pas de lancer des pointeurs sur une fonction.

Vous avez d'abord quelques données dans un type spécifique comme int ici:

int x = 0x7fffffff://==nan in binary representation

Ensuite, vous voulez accéder à la même variable qu'un autre type comme float: vous pouvez choisir entre

float y = reinterpret_cast<float&>(x);

//this could only be used in cpp, looks like a function with template-parameters

ou

float y = *(float*)&(x);

//this could be used in c and cpp

BREF: cela signifie que la même mémoire est utilisée comme un type différent. Vous pouvez donc convertir des représentations binaires de flottants de type int comme ci-dessus en flottants. 0x80000000 est -0 par exemple (la mantisse et l'exposant sont nuls mais le signe, le msb, est un. Cela fonctionne également pour les doubles et les doubles longs.

OPTIMISER: Je pense que reinterpret_cast serait optimisé dans de nombreux compilateurs, tandis que la conversion C est faite par pointerarithmétique (la valeur doit être copiée dans la mémoire, car les pointeurs ne pouvaient pas pointer vers les registres cpu).

REMARQUE: dans les deux cas, vous devez enregistrer la valeur convertie dans une variable avant la conversion! Cette macro pourrait aider:

#define asvar(x) ({decltype(x) __tmp__ = (x); __tmp__; })

Une raison d'utiliser reinterpret_castest lorsqu'une classe de base n'a pas de table virtuelle, mais une classe dérivée en a. Dans ce cas, static_castetreinterpret_cast entraînera des valeurs de pointeur différentes (ce serait le cas atypique mentionné par jalf ci-dessus ). Juste comme un avertissement, je ne dis pas que cela fait partie de la norme, mais la mise en œuvre de plusieurs compilateurs répandus.

À titre d'exemple, prenez le code ci-dessous:

#include <cstdio>

class A {
public:
    int i;
};

class B : public A {
public:
    virtual void func() {  }
};

int main()
{
    B b;
    const A* a = static_cast<A*>(&b);
    const A* ar = reinterpret_cast<A*>(&b);

    printf("&b = %p\n", &b);
    printf(" a = %p\n", a);
    printf("ar = %p\n", ar);
    printf("difference = %ld\n", (long int)(a - ar));

    return 0;
}

Qui produit quelque chose comme:

& b = 0x7ffe10e68b38
a = 0x7ffe10e68b40
ar = 0x7ffe10e68b38
différence = 2

Dans tous les compilateurs que j'ai essayés (MSVC 2015 et 2017, clang 8.0.0, gcc 9.2, icc 19.0.1 - voir godbolt pour les 3 derniers ) le résultat du static_castdiffère de celui du reinterpret_castpar 2 (4 pour MSVC). Le seul compilateur à avertir de la différence était clang, avec:

17:16: avertissement: 'reinterpret_cast' de la classe 'B *' à sa base avec un décalage non nul 'A *' se comporte différemment de 'static_cast' [-Wreinterpret-base-class]
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~~~~~~~~~
17:16: remarque: utilisez 'static_cast' pour régler correctement le pointeur lors de la conversion ascendante
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~
static_cast

Une dernière mise en garde est que si la classe de base n'a pas de membres de données (par exemple le int i;) alors clang, gcc et icc renvoient la même adresse pour reinterpret_castque pour static_cast, alors que MSVC n'en a toujours pas.

Voici une variante du programme d'Avi Ginsburg qui illustre clairement la propriété reinterpret_castmentionnée par Chris Luengo, flodin et cmdLP: que le compilateur traite l'emplacement pointé vers la mémoire comme s'il s'agissait d'un objet du nouveau type:

#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

class A
{
public:
    int i;
};

class B : public A
{
public:
    virtual void f() {}
};

int main()
{
    string s;
    B b;
    b.i = 0;
    A* as = static_cast<A*>(&b);
    A* ar = reinterpret_cast<A*>(&b);
    B* c = reinterpret_cast<B*>(ar);

    cout << "as->i = " << hex << setfill('0')  << as->i << "\n";
    cout << "ar->i = " << ar->i << "\n";
    cout << "b.i   = " << b.i << "\n";
    cout << "c->i  = " << c->i << "\n";
    cout << "\n";
    cout << "&(as->i) = " << &(as->i) << "\n";
    cout << "&(ar->i) = " << &(ar->i) << "\n";
    cout << "&(b.i) = " << &(b.i) << "\n";
    cout << "&(c->i) = " << &(c->i) << "\n";
    cout << "\n";
    cout << "&b = " << &b << "\n";
    cout << "as = " << as << "\n";
    cout << "ar = " << ar << "\n";
    cout << "c  = " << c  << "\n";

    cout << "Press ENTER to exit.\n";
    getline(cin,s);
}

Ce qui se traduit par une sortie comme celle-ci:

as->i = 0
ar->i = 50ee64
b.i   = 0
c->i  = 0

&(as->i) = 00EFF978
&(ar->i) = 00EFF974
&(b.i) = 00EFF978
&(c->i) = 00EFF978

&b = 00EFF974
as = 00EFF978
ar = 00EFF974
c  = 00EFF974
Press ENTER to exit.

On peut voir que l'objet B est construit en mémoire en tant que données spécifiques à B d'abord, suivi par l'objet A incorporé. Le static_castrenvoie correctement l'adresse de l'objet A incorporé et le pointeur créé par static_castdonne correctement la valeur du champ de données. Le pointeur généré par les reinterpret_castfriandisesb emplacement de mémoire de comme s'il s'agissait d'un simple objet A, et donc lorsque le pointeur essaie d'obtenir le champ de données, il renvoie des données spécifiques à B comme s'il s'agissait du contenu de ce champ.

Une utilisation de reinterpret_castconsiste à convertir un pointeur en un entier non signé (lorsque les pointeurs et les entiers non signés ont la même taille):

int i; unsigned int u = reinterpret_cast<unsigned int>(&i);

Réponse rapide: utilisez static_casts'il compile, sinon recourez à reinterpret_cast.

Lisez la FAQ ! La conservation des données C ++ en C peut être risquée.

En C ++, un pointeur sur un objet peut être converti en void *sans transtypage. Mais ce n'est pas vrai dans l'autre sens. Vous auriez besoin d'un static_castpour récupérer le pointeur d'origine.