Quando usare reinterpret_cast?

Question

Sono poco confuso con l'applicabilità di reinterpret_cast rispetto a static_cast. Da quello che ho letto le regole generali sono quelle di usare il cast statico quando i tipi possono essere interpretati in fase di compilazione da cui la parola static. Questo è il cast che il compilatore C++ usa internamente anche per i cast impliciti.

reinterpret_cast s sono applicabili in due scenari, convertire tipi di interi in tipi di puntatori e viceversa o convertire un tipo di puntatore in un altro. L'idea generale che ottengo è che questo non è commovibile e dovrebbe essere evitato.

Dove sono un po 'confuso è un utilizzo di cui ho bisogno, chiamo C++ da C e il codice C deve rimanere sull'oggetto C++ quindi in pratica contiene uno void*. Quale cast dovrebbe essere usato per convertire tra il void * e il tipo di Classe?

Ho visto l'utilizzo di entrambi static_cast e reinterpret_cast? Anche se da quello che sto leggendo sembra static è meglio come il cast può accadere in fase di compilazione? Anche se dice di usare reinterpret_cast per convertire da un tipo di puntatore a un altro?

Answer 1

serie La C++ garantisce la seguente:

static_cast ing un puntatore da e per void* conserva l'indirizzo. Cioè, in seguito, a, b e c puntano tutti allo stesso indirizzo:

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

reinterpret_cast garantisce solo che se si esegue il cast di un puntatore a un tipo diverso, e poi reinterpret_cast indietro al tipo originale, ottieni il valore originale. Quindi, in quanto segue:

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

A e C contengono lo stesso valore, ma il valore di b non è specificato. (in pratica conterrà tipicamente lo stesso indirizzo di a e c, ma non è specificato nello standard, e potrebbe non essere vero su macchine con sistemi di memoria più complessi.)

Per la trasmissione da e verso il void *, è preferibile il static_cast.

Answer 2

Leggi il FAQ! Tenere i dati C++ in C può essere rischioso.

In C++, un puntatore a un oggetto può essere convertito in void * senza alcun calchi. Ma non è vero il contrario. Avresti bisogno di un static_cast per riavere il puntatore originale.

Answer 3

Il significato di reinterpret_cast non è definito dallo standard C++. Quindi, in teoria un reinterpret_cast potrebbe mandare in crash il tuo programma. In pratica i compilatori cercano di fare ciò che ti aspetti, cioè interpretare i pezzi di ciò che stai passando come se fossero il tipo a cui ti lanci. Se sai cosa fanno i compilatori che utilizzerai con reinterpret_cast puoi usarlo, ma dire che è portatile mentire.

Per il caso che descrivi, e quasi tutti i casi in cui potresti prendere in considerazione lo reinterpret_cast, puoi utilizzare lo static_cast o qualche altra alternativa. Tra le altre cose lo standard ha questo da dire su quello che ci si può aspettare di static_cast (§5.2.9):

An rvalue of type “pointer to cv void” can be explicitly converted to a pointer to object type. A value of type pointer to object converted to “pointer to cv void” and back to the original pointer type will have its original value.

Quindi per la vostra caso d'uso, sembra abbastanza chiaro che il comitato di standardizzazione destinato per l'uso static_cast .

Answer 4

Un caso in cui è necessario reinterpret_cast è quando si interfaccia con tipi di dati opachi. Ciò si verifica frequentemente nelle API del fornitore su cui il programmatore non ha alcun controllo. Ecco un esempio inventato in cui un venditore fornisce un'API per archiviare e recuperare dati globali arbitraria:

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

Per utilizzare questa API, il programmatore deve lanciare i loro dati per VendorGlobalUserData e viceversa. static_cast non funziona, si deve usare 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; 
} 

Di seguito è un'implementazione artificiosa delle API del campione:

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

Answer 5

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

ho cercato di concludere e ha scritto un semplice getto di sicurezza utilizzando i modelli . Si noti che questa soluzione non garantisce il cast dei puntatori su una funzione.

Answer 6

È possibile utilizzare reinterprete_cast per controllare l'ereditarietà in fase di compilazione.
Guardate qui: Using reinterpret_cast to check inheritance at compile time

Answer 7

Un uso di reinterpret_cast è se si desidera applicare operazioni bit per bit a (IEEE 754) galleggia. Un esempio di questo è stato l'inversa Fast radice quadrata trucco:

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

Tratta la rappresentazione binaria del flottante come un intero, si sposta a destra e sottrae da una costante, dimezzando in tal modo e negando l'esponente . Dopo riconversione un galleggiante, è sottoposto ad un'iterazione Newton-Raphson per rendere questa approssimazione più precisa:

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

Questo è stato scritto in C, quindi utilizza C getta, ma l'analogo C++ cast è il reinterpret_cast.

Answer 8

Risposta rapida: utilizzare static_cast se compila, altrimenti ricorrere a reinterpret_cast.

Answer 9

In primo luogo Se avete alcuni dati in un tipo specifico come int qui:

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

poi si desidera accedere alla stessa variabile come altro tipo come float: Si può decidere tra

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

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

o

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

//this could be used in c and cpp 

BREVE: significa che la stessa memoria viene utilizzata come un tipo diverso. In questo modo è possibile convertire le rappresentazioni binarie di float come tipo int come sopra in float. 0x80000000 è -0 per esempio (la mantissa e l'esponente sono nulli ma il segno, il msb, è uno. Questo funziona anche per i doppi e i doppi lunghi.

OTTIMIZZARE: Penso che reinterpret_cast sarebbe ottimizzato in molti compilatori, mentre il c-casting è fatto da pointerarithmetic (il valore deve essere copiato nella memoria, perché i puntatori non possono puntare a cpu- registers).

NOTA: in entrambi i casi è necessario salvare il valore del cast in una variabile prima del lancio! Questa macro potrebbe aiutare:

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

Answer 10

La risposta breve: Se non sai cosa sta per reinterpret_cast, non ne fanno uso. Se ne avrai bisogno in futuro, lo saprai.

risposta completa:

Consideriamo tipi di numero di base.

Quando si converte ad esempio int(12) in unsigned float (12.0f), il processore deve richiamare alcuni calcoli poiché entrambi i numeri hanno una rappresentazione bit diversa. Questo è il significato di static_cast.

D'altra parte, quando si chiama reinterpret_cast la CPU non richiama alcun calcolo. Tratta semplicemente un insieme di bit nella memoria come se avesse un altro tipo. Pertanto, quando si converte int* in float* con questa parola chiave, il nuovo valore (dopo il puntatore dereferecing) non ha nulla a che fare con il vecchio valore in significato matematico.

Esempio: E 'vero che reinterpret_cast non è portabile per una ragione - ordine dei byte (endian). Ma questo è spesso sorprendentemente il miglior motivo per usarlo. Immaginiamo l'esempio: devi leggere il numero binario a 32 bit dal file e sai che è big endian. Il codice deve essere generico e funziona correttamente sui sistemi big endian (ad esempio ARM) e little endian (ad esempio x86). Quindi devi controllare l'ordine dei byte. E 'ben noto in fase di compilazione in modo da poter scrivere constexpr funzione:

constexpr bool is_little_endian() { 
    unsigned short x=0x0001; 
    auto p = reinterpret_cast<unsigned char*>(&x); 
    return *p != 0; 
} 

Spiegazione: la rappresentazione binaria di x in memoria potrebbe essere 0000'0000'0000'0001 (grande) o 0000'0001'0000'0000 (little endian). Dopo la reinterpretazione, il byte sotto il puntatore p potrebbe essere rispettivamente 0000'0000 o 0000'0001. Se si utilizza la fusione statica, sarà sempre 0000'0001, indipendentemente dall'uso di endianness.