Wann soll reinterpret_cast verwendet werden?

Ich bin wenig mit der Anwendbarkeit von verwechselt reinterpret_castvs static_cast. Nach dem, was ich gelesen habe, besteht die allgemeine Regel darin, statische Umwandlung zu verwenden, wenn die Typen zur Kompilierungszeit interpretiert werden können, daher das Wort static. Dies ist die Besetzung, die der C ++ - Compiler intern auch für implizite Besetzungen verwendet.

reinterpret_casts sind in zwei Szenarien anwendbar:

• Ganzzahlige Typen in Zeigertypen konvertieren und umgekehrt
• Konvertieren Sie einen Zeigertyp in einen anderen. Die allgemeine Idee, die ich bekomme, ist, dass dies nicht portierbar ist und vermieden werden sollte.

Wo ich ein wenig verwirrt bin, ist eine Verwendung, die ich brauche, ich rufe C ++ von C auf und der C-Code muss das C ++ - Objekt festhalten, damit es im Grunde genommen a enthält void*. Welche Besetzung sollte verwendet werden, um zwischen dem void *und dem Klassentyp zu konvertieren ?

Ich habe die Verwendung von beiden gesehen static_castund reinterpret_cast? Obwohl nach dem, was ich gelesen habe, es staticbesser erscheint , da die Besetzung zur Kompilierungszeit erfolgen kann? Obwohl es heißt reinterpret_cast, von einem Zeigertyp in einen anderen zu konvertieren?

Der C ++ - Standard garantiert Folgendes:

static_casteinen Zeiger auf und von void* bleibt die Adresse erhalten. Das heißt, im Folgenden a, bund calle auf die gleiche Adresse:

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

reinterpret_castgarantiert nur, dass Sie den ursprünglichen Wert erhalten , wenn Sie einen Zeiger auf einen anderen Typ und dann reinterpret_castauf den ursprünglichen Typ zurücksetzen. Also im Folgenden:

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

aund centhalten den gleichen Wert, aber der Wert von bist nicht angegeben. (In der Praxis enthält es normalerweise dieselbe Adresse wie aund c, dies ist jedoch nicht im Standard angegeben und gilt möglicherweise nicht für Computer mit komplexeren Speichersystemen.)

Zum Casting von und nach void*,static_cast sollte bevorzugt werden.

Ein Fall, wenn dies reinterpret_casterforderlich ist, ist die Schnittstelle zu undurchsichtigen Datentypen. Dies tritt häufig in Hersteller-APIs auf, über die der Programmierer keine Kontrolle hat. Hier ist ein erfundenes Beispiel, in dem ein Anbieter eine API zum Speichern und Abrufen beliebiger globaler Daten bereitstellt:

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

Um diese API verwenden zu können, muss der Programmierer seine Daten hin VendorGlobalUserDataund zurück übertragen. static_castwird nicht funktionieren, muss man verwenden 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;
}

Im Folgenden finden Sie eine erfundene Implementierung der Beispiel-API:

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

Die kurze Antwort: Wenn Sie nicht wissen, wofür es reinterpret_caststeht, verwenden Sie es nicht. Wenn Sie es in Zukunft brauchen, werden Sie es wissen.

Vollständige Antwort:

Betrachten wir grundlegende Zahlentypen.

Wenn Sie zum Beispiel int(12)in unsigned float (12.0f)Ihren Prozessor konvertieren , müssen Sie einige Berechnungen aufrufen, da beide Zahlen unterschiedliche Bitdarstellungen haben. Dafür static_caststeht.

Wenn Sie dagegen reinterpret_castdie CPU aufrufen, werden keine Berechnungen aufgerufen . Es behandelt nur eine Reihe von Bits im Speicher, als hätte es einen anderen Typ. Also , wenn Sie konvertieren , int*um float*mit diesem Begriff, hat der neuen Wert (nach Zeigern dereferecing) nichts mit dem alten Wert im mathematischen Sinne zu tun.

Beispiel: Es ist wahr, dassreinterpret_castes aus einem Grund nicht portierbar ist - Bytereihenfolge (Endianness). Dies ist jedoch oft überraschend der beste Grund, es zu verwenden. Stellen wir uns das Beispiel vor: Sie müssen die binäre 32-Bit-Zahl aus der Datei lesen und wissen, dass es sich um Big Endian handelt. Ihr Code muss generisch sein und funktioniert ordnungsgemäß auf Big-Endian-Systemen (z. B. ARM) und Little-Endian-Systemen (z. B. x86). Sie müssen also die Bytereihenfolge überprüfen. Es ist zur Kompilierungszeit bekannt, sodass Sie constexprFunktionen schreiben können: Sie können eine Funktion schreiben, um dies zu erreichen:

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

Erläuterung: Die binäre Darstellungxim Speicher kann0000'0000'0000'0001(groß) oder0000'0001'0000'0000(Little Endian) sein. Nach dem Neuinterpretieren des Castings könnte das Byte unter dempZeiger jeweils0000'0000oder sein0000'0001. Wenn Sie statisches Gießen verwenden, wird es immer sein0000'0001, egal welche Endianness verwendet wird.

BEARBEITEN:

_{In der ersten Version habe ich Beispielfunktion gemacht is_little_endian zu sein constexpr. Es kompiliert gut auf dem neuesten gcc (8.3.0), aber der Standard sagt, dass es illegal ist. Der Clang-Compiler weigert sich, es zu kompilieren (was korrekt ist).}

Die Bedeutung von reinterpret_castwird nicht durch den C ++ - Standard definiert. Theoretisch reinterpret_castkönnte daher Ihr Programm abstürzen. In der Praxis versuchen Compiler, das zu tun, was Sie erwarten, nämlich die Teile Ihrer Übergabe so zu interpretieren, als wären sie der Typ, auf den Sie übertragen. Wenn Sie wissen, was die Compiler, die Sie verwenden werden, damit machen reinterpret_cast , können Sie es verwenden, aber zu sagen, dass es portabel ist, würde lügen.

Für den Fall, den Sie beschreiben, und so ziemlich jeden Fall, den Sie in Betracht ziehen reinterpret_cast, können Sie static_caststattdessen eine andere Alternative verwenden. Der Standard hat unter anderem static_castFolgendes zu sagen, was Sie erwarten können (§5.2.9):

Ein Wert vom Typ "Zeiger auf Lebenslauf ungültig" kann explizit in einen Zeiger auf den Objekttyp konvertiert werden. Ein Wert vom Typ Zeiger auf Objekt, der in „Zeiger auf Lebenslauf ungültig“ und zurück zum ursprünglichen Zeigertyp konvertiert wurde, hat seinen ursprünglichen Wert.

Für Ihren Anwendungsfall scheint es also ziemlich klar zu sein, dass das Standardisierungskomitee für Sie vorgesehen ist static_cast.

Eine Verwendung von reinterpret_cast ist, wenn Sie bitweise Operationen auf (IEEE 754) Floats anwenden möchten. Ein Beispiel hierfür war der Fast Inverse Square-Root-Trick:

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

Es behandelt die binäre Darstellung des Floats als Ganzzahl, verschiebt sie nach rechts und subtrahiert sie von einer Konstanten, wodurch der Exponent halbiert und negiert wird. Nach der Rückkonvertierung in einen Float wird eine Newton-Raphson-Iteration durchgeführt, um diese Annäherung genauer zu machen:

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

Dies wurde ursprünglich in C geschrieben, verwendet also C-Casts, aber die analoge C ++ - Cast ist der reinterpret_cast.

Sie können reinterprete_cast verwenden, um die Vererbung beim Kompilieren zu überprüfen.
Schauen Sie hier: Verwenden Sie reinterpret_cast, um die Vererbung beim Kompilieren zu überprüfen

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

Ich versuchte zu schließen und schrieb eine einfache sichere Besetzung unter Verwendung von Vorlagen. Beachten Sie, dass diese Lösung nicht garantiert, Zeiger auf Funktionen zu setzen.

Zuerst haben Sie einige Daten in einem bestimmten Typ wie int hier:

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

Dann möchten Sie auf dieselbe Variable wie auf einen anderen Typ wie float zugreifen: Sie können zwischen diesen entscheiden

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

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

oder

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

//this could be used in c and cpp

KURZDARSTELLUNG: Dies bedeutet, dass derselbe Speicher als anderer Typ verwendet wird. Sie können also binäre Darstellungen von Floats als int-Typ wie oben in Floats konvertieren. 0x80000000 ist zum Beispiel -0 (die Mantisse und der Exponent sind null, aber das Vorzeichen, die msb, ist eins. Dies funktioniert auch für Doppelte und lange Doppelte.

OPTIMIEREN: Ich denke, reinterpret_cast würde in vielen Compilern optimiert, während das c-Casting durch Zeigerarithmetik erfolgt (der Wert muss in den Speicher kopiert werden, da Zeiger nicht auf CPU-Register zeigen können).

HINWEIS: In beiden Fällen sollten Sie den Cast-Wert vor dem Cast in einer Variablen speichern! Dieses Makro könnte helfen:

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

Ein Grund für die Verwendung reinterpret_castist, wenn eine Basisklasse keine vtable hat, eine abgeleitete Klasse jedoch. In diesem Fall, static_castund reinterpret_castwird in verschiedenen Zeigerwerten führen (dies ist der Fall , atypische von erwähnten wäre JALF oben ). Nur als Haftungsausschluss sage ich nicht, dass dies Teil des Standards ist, sondern die Implementierung mehrerer weit verbreiteter Compiler.

Nehmen Sie als Beispiel den folgenden Code:

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

Welche Ausgaben so etwas wie:

& b = 0x7ffe10e68b38
a = 0x7ffe10e68b40
ar = 0x7ffe10e68b38
Differenz = 2

In allen Compilern, die ich ausprobiert habe (MSVC 2015 & 2017, Clang 8.0.0, gcc 9.2, ICC 19.0.1 - siehe Godbolt für die letzten 3 ), unterscheidet sich das Ergebnis static_castvon dem reinterpret_castvon 2 (4 für MSVC). Der einzige Compiler, der vor dem Unterschied warnte, war clang mit:

17:16: Warnung: 'reinterpret_cast' von Klasse 'B *' zu seiner Basis bei einem Offset ungleich Null 'A *' verhält sich anders als 'static_cast' [-Wreinterpret-Basisklasse]
const A * ar = reinterpret_cast (& b) ;;
^ ~~~~~~~~~~~~~~~~~~~~~~~
17:16: Hinweis: Verwenden Sie 'static_cast', um den Zeiger beim Upcasting von
const A * ar = reinterpret_cast (& b) korrekt anzupassen. ;;
^
~~~~~~~~~~~~~~~~ static_cast

Eine letzte Einschränkung ist, dass wenn die Basisklasse keine Datenelemente (z. B. die int i;) hat, clang, gcc und icc dieselbe Adresse reinterpret_castwie für zurückgeben static_cast, während MSVC dies immer noch nicht tut.

Hier ist eine Variante von Avi Ginsburgs Programm, die die reinterpret_castvon Chris Luengo, flodin und cmdLP erwähnte Eigenschaft deutlich macht: Der Compiler behandelt den Speicherort, auf den verwiesen wird, als wäre er ein Objekt des neuen Typs:

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

Was zu einer Ausgabe wie dieser führt:

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.

Es ist ersichtlich, dass das B-Objekt zuerst als B-spezifische Daten im Speicher erstellt wird, gefolgt vom eingebetteten A-Objekt. Das static_castgibt die Adresse des eingebetteten A-Objekts korrekt zurück, und der durch static_castkorrekt erstellte Zeiger gibt den Wert des Datenfelds an. Der durch reinterpret_castLeckereien erzeugte Zeigerb den Speicherort des ihn wie ein einfaches A-Objekt. Wenn der Zeiger versucht, das Datenfeld abzurufen, gibt er einige B-spezifische Daten zurück, als wäre es der Inhalt dieses Feldes.

Eine Verwendung von reinterpret_castbesteht darin, einen Zeiger in eine vorzeichenlose Ganzzahl umzuwandeln (wenn Zeiger und vorzeichenlose Ganzzahlen dieselbe Größe haben):

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

Schnelle Antwort: Verwenden static_castSie, wenn es kompiliert wird, andernfalls greifen Sie auf zurück reinterpret_cast.

Lesen Sie die FAQ ! Das Speichern von C ++ - Daten in C kann riskant sein.

In C ++ kann ein Zeiger auf ein Objekt ohne Umwandlungen konvertiert void *werden. Aber umgekehrt ist es nicht wahr. Sie benötigen eine static_cast, um den ursprünglichen Zeiger zurückzubekommen.