Kiedy używać reinterpret_cast?

Jestem trochę mylić z stosowalności reinterpret_castvs static_cast. Z tego, co przeczytałem, ogólne zasady używają rzutowania statycznego, gdy typy mogą być interpretowane w czasie kompilacji, stąd słowo static. Jest to rzutowanie, którego kompilator C ++ używa wewnętrznie do rzutowania niejawnego.

reinterpret_castmają zastosowanie w dwóch scenariuszach:

• konwertuj typy liczb całkowitych na typy wskaźników i odwrotnie
• przekonwertować jeden typ wskaźnika na inny. Ogólny pomysł, jaki mam, jest taki, że nie można go przenosić i należy go unikać.

Tam, gdzie jestem trochę zdezorientowany, potrzebuję jednego użycia, wywołuję C ++ z C, a kod C musi trzymać się obiektu C ++, więc w zasadzie zawiera on void*. Jakiej obsady należy użyć do konwersji między void *typem a klasą?

Widziałem użycie obu static_casti reinterpret_cast? Chociaż z tego, co czytałem, wydaje się staticto lepsze, ponieważ obsada może się zdarzyć w czasie kompilacji? Chociaż mówi się, aby użyć reinterpret_castdo konwersji z jednego typu wskaźnika na inny?

Standard C ++ gwarantuje:

static_castwprowadzenie wskaźnika do i z void*zachowuje adres. Oznacza to, że w dalszej części a, ba cwszystko wskazuje na ten sam adres:

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

reinterpret_castgwarantuje tylko, że jeśli rzutujesz wskaźnik na inny typ, a następnie z reinterpret_castpowrotem na typ oryginalny , otrzymujesz oryginalną wartość. Więc w następujący sposób:

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

ai czawierają tę samą wartość, ale wartość nie bjest określona. (w praktyce zwykle będzie zawierał ten sam adres co ai c, ale nie jest to określone w standardzie, i może nie być prawdziwe na komputerach z bardziej złożonymi systemami pamięci).

Do castowania do iz void* , static_castpowinno być preferowane.

Jednym z przypadków, w których reinterpret_castjest to konieczne, jest połączenie z nieprzezroczystymi typami danych. Zdarza się to często w interfejsach API dostawców, nad którymi programista nie ma kontroli. Oto wymyślony przykład, w którym dostawca udostępnia interfejs API do przechowywania i wyszukiwania dowolnych danych globalnych:

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

Aby użyć tego interfejsu API, programista musi przesyłać swoje dane do VendorGlobalUserDataiz powrotem. static_castnie będzie działać, należy użyć 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;
}

Poniżej znajduje się przemyślana implementacja przykładowego interfejsu API:

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

Krótka odpowiedź: jeśli nie wiesz coreinterpret_cast oznacza skrót, nie używaj go. Jeśli będziesz go potrzebować w przyszłości, będziesz wiedział.

Pełna odpowiedź:

Rozważmy podstawowe typy liczb.

Podczas konwersji na przykład int(12)na unsigned float (12.0f)procesor należy wykonać pewne obliczenia, ponieważ obie liczby mają różne odwzorowanie bitów. To właśnie static_castoznacza.

Z drugiej strony, podczas wywoływania reinterpret_castprocesor nie wywołuje żadnych obliczeń. Po prostu traktuje zestaw bitów w pamięci tak, jakby miał inny typ. Więc po konwersji int*do float*z tego słowa kluczowego, nowa wartość (po wskaźnik dereferecing) nie ma nic wspólnego ze starą wartość w matematycznym znaczeniu.

Przykład: Prawdą jest, żereinterpret_castnie jest przenośny z jednego powodu - kolejności bajtów (endianness). Ale często jest to zaskakująco najlepszy powód do korzystania z niego. Wyobraźmy sobie przykład: musisz odczytać binarną 32-bitową liczbę z pliku i wiesz, że to duży endian. Twój kod musi być ogólny i działa poprawnie na systemach big endian (np. Niektóre ARM) i little endian (np. X86). Musisz więc sprawdzić kolejność bajtów. Jest dobrze znany z czasu kompilacji, więc możesz napisać constexprfunkcję: Możesz napisać funkcję, aby to osiągnąć:

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

Objaśnienie: binarna reprezentacjaxw pamięci może być0000'0000'0000'0001(duża) lub0000'0001'0000'0000(mała endian). Po reinterpretacji rzutowania bajtem podpwskaźnikiem może być odpowiednio0000'0000lub0000'0001. Jeśli użyjesz castingu statycznego, zawsze tak będzie0000'0001 , bez względu na to, jaki endianizm jest używany.

EDYTOWAĆ:

_{W pierwszej wersji zrobiłem przykładową funkcję is_little_endianbycia constexpr. Kompiluje się dobrze na najnowszym gcc (8.3.0), ale standard mówi, że jest nielegalny. Kompilator clang nie chce go skompilować (co jest poprawne).}

Znaczenie reinterpret_castnie jest zdefiniowane przez standard C ++. Dlatego teoretycznie reinterpret_castmoże to spowodować awarię programu. W praktyce kompilatory starają się robić to, czego oczekujesz, czyli interpretować bity tego, co przekazujesz, tak jakby były typem, na który rzucasz. Jeśli wiesz, jakie kompilatory zamierzasz używać, reinterpret_cast możesz go użyć, ale powiedzieć, że jest przenośny , kłamałoby.

W przypadku, który opisujesz, a właściwie w każdym przypadku, który możesz rozważyć reinterpret_cast, możesz static_castzamiast tego użyć innej alternatywy. Między innymi standard ma to do powiedzenia na temat tego, czego możesz oczekiwać static_cast(§5.2.9):

Wartość typu „wskaźnik na cv void” można jawnie przekonwertować na wskaźnik na typ obiektu. Wartość wskaźnika typu na obiekt konwertowana na „wskaźnik na cv void” iz powrotem na oryginalny typ wskaźnika będzie miała swoją oryginalną wartość.

Tak więc w twoim przypadku użycia wydaje się dość jasne, że komitet normalizacyjny zamierzał z niego skorzystać static_cast.

Jednym z zastosowań reinterpret_cast jest użycie operacji bitowych na liczbach zmiennoprzecinkowych (IEEE 754). Jednym z przykładów jest sztuczka Fast Inverse Square-Root:

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

Traktuje binarną reprezentację liczby zmiennoprzecinkowej jako liczbę całkowitą, przesuwa ją w prawo i odejmuje od stałej, tym samym zmniejszając o połowę i negując wykładnik potęgi. Po konwersji z powrotem na liczbę zmiennoprzecinkową poddaje się iteracji Newtona-Raphsona w celu dokładniejszego przybliżenia:

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

Zostało to pierwotnie napisane w C, więc używa rzutowań C, ale analogicznym rzutowaniem C ++ jest rzut_interpretacji.

Możesz użyć reinterprete_cast, aby sprawdzić dziedziczenie w czasie kompilacji.
Spójrz tutaj: Korzystanie z reinterpret_cast do sprawdzania dziedziczenia w czasie kompilacji

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

Próbowałem zakończyć i napisałem prostą bezpieczną obsadę za pomocą szablonów. Pamiętaj, że to rozwiązanie nie gwarantuje rzutowania wskaźników na funkcje.

Najpierw masz jakieś dane określonego typu, takie jak int tutaj:

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

Następnie chcesz uzyskać dostęp do tej samej zmiennej, co inny typ, taki jak float: możesz wybrać pomiędzy

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

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

lub

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

//this could be used in c and cpp

KRÓTKI: oznacza, że ​​ta sama pamięć jest używana jako inny typ. Możesz więc konwertować binarne reprezentacje liczb zmiennoprzecinkowych jako typu int jak wyżej na zmiennoprzecinkowe. 0x80000000 ma na przykład wartość -0 (mantysa i wykładnik są zerowe, ale znak msb ma wartość jeden. Działa to również w przypadku podwójnych i długich podwójnych.

OPTYMALIZACJA: Myślę, że reinterpret_cast byłby zoptymalizowany w wielu kompilatorach, podczas gdy rzutowanie c jest wykonywane przez pointerarytmikę (wartość musi zostać skopiowana do pamięci, ponieważ wskaźniki nie mogą wskazywać rejestrów cpu).

UWAGA: W obu przypadkach przed rzutowaniem należy zapisać rzutowaną wartość w zmiennej! To makro może pomóc:

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

Jednym z powodów reinterpret_castjest to, że klasa podstawowa nie ma vtable, ale klasa pochodna ma. W takim przypadku, static_casti reinterpret_castspowoduje różne wartości wskaźnika (byłby to nietypowy przypadek wspomniany powyżej przez jalf ). Jako oświadczenie nie stwierdzam, że jest to część standardu, ale implementacja kilku rozpowszechnionych kompilatorów.

Jako przykład weź poniższy kod:

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

Które generuje coś takiego:

& b = 0x7ffe10e68b38
a = 0x7ffe10e68b40
ar = 0x7ffe10e68b38
różnica = 2

We wszystkich kompilatorach, które wypróbowałem (MSVC 2015 i 2017, clang 8.0.0, gcc 9.2, icc 19.0.1 - patrz godbolt dla ostatnich 3 ) wynik static_castróżni się od wyniku reinterpret_casto 2 (4 dla MSVC). Jedynym kompilatorem ostrzegającym przed różnicą był clang, z:

17:16: ostrzeżenie: „reinterpret_cast” z klasy „B *” do podstawy przy niezerowym przesunięciu „A *” zachowuje się inaczej niż „static_cast” [-Wreinterpret-base-class]
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~~~~~~~~~
17:16: Uwaga: użyj 'static_cast', aby poprawnie ustawić wskaźnik podczas upcastingu
const A * ar = reinterpret_cast (& b) ;
^ ~~~~~~~~~~~~~~~
static_cast

Ostatnim zastrzeżeniem jest to, że jeśli klasa podstawowa nie ma elementów danych (np. int i;), To clang, gcc i icc zwracają ten sam adres reinterpret_castjak dla static_cast, podczas gdy MSVC nadal nie.

Oto wariant programu Avi Ginsburga, który wyraźnie ilustruje właściwość reinterpret_castwspomnianą przez Chrisa Luengo, flodina i cmdLP: kompilator traktuje wskazaną lokalizację pamięci tak, jakby był obiektem nowego typu:

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

Co daje wynik w ten sposób:

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.

Można zauważyć, że obiekt B jest najpierw wbudowany w pamięć jako dane specyficzne dla B, a następnie osadzony obiekt A. static_castPoprawnie zwraca adres wbudowanego obiektu, a wskaźnik stworzony przez static_castprawidłowo daje wartość pola danych. Wskaźnik generowany przez reinterpret_castsmakołykib lokalizację pamięci tak, jakby był zwykłym obiektem A, a więc gdy wskaźnik próbuje uzyskać pole danych, zwraca niektóre dane specyficzne dla B, tak jakby była zawartością tego pola.

Jednym z zastosowań reinterpret_castjest konwersja wskaźnika na liczbę całkowitą bez znaku (gdy wskaźniki i liczby całkowite bez znaku mają ten sam rozmiar):

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

Szybka odpowiedź: użyj, static_castjeśli się skompiluje, w przeciwnym razie skorzystaj z reinterpret_cast.

Przeczytaj FAQ ! Przechowywanie danych C ++ w C może być ryzykowne.

W C ++ wskaźnik do obiektu można przekonwertować void *bez rzutowania. Ale to nie jest prawda na odwrót. Musisz static_castodzyskać oryginalny wskaźnik.