Когда использовать reinterpret_cast?

Стандарт C ++ гарантирует следующее:

static_cast указатель на void* и обратно сохраняет адрес. То есть в дальнейшем a, b и c все указывают на один и тот же адрес:

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

reinterpret_cast гарантирует только то, что если вы приведете указатель к другому типу, , а затем reinterpret_cast обратно к исходному типу, вы получите исходное значение. Итак, в следующем:

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

a и c содержат одно и то же значение, но значение b не указано. (на практике он обычно содержит тот же адрес, что и a и c, но это не указано в стандарте, и это может быть неверно на машинах с более сложными системами памяти.)

Для преобразования в void* и обратно предпочтительнее использовать static_cast.

Один случай, когда reinterpret_cast необходим, - это взаимодействие с непрозрачными типами данных. Это часто происходит в API поставщиков, над которыми программист не властен. Вот надуманный пример, в котором поставщик предоставляет API для хранения и извлечения произвольных глобальных данных:

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

Чтобы использовать этот API, программист должен преобразовать свои данные в VendorGlobalUserData и обратно. static_cast не сработает, нужно использовать 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;
}

Ниже представлена ​​надуманная реализация примера API:

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

Краткий ответ: если вы не знаете, что означает reinterpret_cast, не используйте его. Если вам это понадобится в будущем, вы узнаете.

Полный ответ:

Рассмотрим основные типы чисел.

Когда вы конвертируете, например, int(12) в unsigned float (12.0f), вашему процессору необходимо вызвать некоторые вычисления, поскольку оба числа имеют разное битовое представление. Это то, что означает static_cast.

С другой стороны, когда вы вызываете reinterpret_cast, ЦП не выполняет никаких вычислений. Он просто обрабатывает набор бит в памяти, как если бы он был другого типа. Поэтому, когда вы конвертируете int* в float* с помощью этого ключевого слова, новое значение (после разыменования указателя) не имеет ничего общего со старым значением в математическом смысле.

Пример:. Это правда, что reinterpret_cast не переносится по одной причине - порядок байтов (порядок байтов). Но на удивление часто это лучшая причина для его использования. Представьте себе пример: вам нужно прочитать двоичное 32-битное число из файла, и вы знаете, что оно имеет обратный порядок байтов. Ваш код должен быть универсальным и правильно работать в системах с прямым порядком байтов (например, некоторые ARM) и с прямым порядком байтов (например, x86). Итак, вам нужно проверить порядок байтов. Это хорошо известно во время компиляции, поэтому вы можете написать constexpr function: Для этого вы можете написать функцию:

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

Пояснение: двоичное представление x в памяти может быть 0000'0000'0000'0001 (большой) или 0000'0001'0000'0000 (прямой порядок байтов). После переинтерпретации байт под указателем p может быть соответственно 0000'0000 или 0000'0001. Если вы используете статическое приведение, оно всегда будет 0000'0001, независимо от того, какой порядок байтов используется.

РЕДАКТИРОВАТЬ:

_{В первой версии я сделал пример функции is_little_endian constexpr. Он отлично компилируется на новейшем gcc (8.3.0), но стандарт говорит, что это незаконно. Компилятор clang отказывается его компилировать (что правильно).}

Значение reinterpret_cast не определяется стандартом C ++. Следовательно, теоретически reinterpret_cast может привести к сбою вашей программы. На практике компиляторы пытаются делать то, что вы ожидаете, а именно интерпретировать биты того, что вы передаете, как если бы они были типом, к которому вы приводите. Если вы знаете, что компиляторы, которые вы собираетесь использовать, делают с reinterpret_cast, вы можете использовать его, но сказать, что он переносимый, было бы ложью.

Для случая, который вы описываете, и практически для любого случая, когда вы могли бы рассмотреть reinterpret_cast, вы можете вместо этого использовать static_cast или другую альтернативу. Среди прочего, в стандарте говорится о том, чего можно ожидать от static_cast (§5.2.9):

Значение типа «указатель на cv void» может быть явно преобразовано в указатель на тип объекта. Значение указателя типа на объект, преобразованное в «указатель на cv void» и возвращающееся к исходному типу указателя, будет иметь свое исходное значение.

Таким образом, для вашего варианта использования кажется довольно очевидным, что комитет по стандартизации предназначал для вас использование static_cast.

Один из вариантов использования reinterpret_cast - применить побитовые операции к поплавкам (IEEE 754). Одним из примеров этого был трюк с быстрым обратным квадратным корнем:

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

Он обрабатывает двоичное представление числа с плавающей запятой как целое число, сдвигает его вправо и вычитает его из константы, тем самым уменьшая вдвое и отрицая показатель степени. После преобразования обратно в число с плавающей запятой он подвергается итерации Ньютона-Рафсона, чтобы сделать это приближение более точным:

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

Первоначально он был написан на C, поэтому использует приведение типов C, но аналогичное приведение C ++ - это reinterpret_cast.

Вы можете использовать reinterprete_cast для проверки наследования во время компиляции.
Посмотрите здесь: Использование reinterpret_cast для проверки наследования во время компиляции

Вот вариант программы Ави Гинзбурга, который ясно иллюстрирует свойство reinterpret_cast, упомянутое Крисом Луенго, flodin и cmdLP: компилятор обрабатывает указанную ячейку памяти, как если бы это был объект нового типа:

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

В результате получается такой вывод:

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.

Можно видеть, что объект B встраивается в память сначала как данные, специфичные для B, а затем - внедренный объект A. static_cast правильно возвращает адрес встроенного объекта A, а указатель, созданный static_cast, правильно дает значение поля данных. Указатель, сгенерированный reinterpret_cast, обрабатывает область памяти b, как если бы это был простой объект A, и поэтому, когда указатель пытается получить поле данных, он возвращает некоторые данные, специфичные для B, как если бы это было содержимое этого поля.

Одно из применений reinterpret_cast - преобразование указателя в целое число без знака (когда указатели и целые числа без знака имеют одинаковый размер):

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

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

Я попытался подвести итог и написал простой безопасный слепок с использованием шаблонов. Обратите внимание, что это решение не гарантирует приведения указателей к функциям.

Сначала у вас есть данные определенного типа, например int:

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

Затем вы хотите получить доступ к той же переменной, что и другой тип, например float: вы можете выбрать между

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

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

or

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

//this could be used in c and cpp

КРАТКО: это означает, что одна и та же память используется как другой тип. Таким образом, вы можете преобразовать двоичные представления чисел с плавающей запятой в виде типа int, как указано выше, в числа с плавающей запятой. Например, 0x80000000 равен -0 (мантисса и показатель степени равны нулю, но знак msb равен единице. Это также работает для удвоений и длинных удвоений.

ОПТИМИЗАЦИЯ: я думаю, что reinterpret_cast будет оптимизирован во многих компиляторах, в то время как c-приведение выполняется с помощью указателей (значение должно быть скопировано в память, потому что указатели не могут указывать на регистры процессора).

ПРИМЕЧАНИЕ: В обоих случаях вы должны сохранить приведенное значение в переменной перед приведением! Этот макрос может помочь:

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

Быстрый ответ: используйте static_cast, если он компилируется, в противном случае используйте reinterpret_cast.

Прочтите FAQ! Хранение данных C ++ в C может быть рискованным.

В C ++ указатель на объект может быть преобразован в void * без приведения типов. Но наоборот, это неправда. Вам понадобится static_cast, чтобы вернуть исходный указатель.