reinterpret_cast conversion

Преобразует между типами путем переинтерпретации базового битового шаблона.

Синтаксис

Возвращает значение типа target-type .

Объяснение

В отличие от static_cast , но подобно const_cast , выражение reinterpret_cast не компилируется в какие-либо инструкции процессора (за исключением преобразований между целыми числами и указателями, или между указателями на экзотических архитектурах, где представление указателя зависит от его типа). Это в основном директива времени компиляции, которая предписывает компилятору рассматривать expression так, как если бы оно имело тип target-type .

Только следующие преобразования могут быть выполнены с помощью reinterpret_cast , за исключением случаев, когда такие преобразования отбрасывают константность (или волатильность).

Как и для всех выражений приведения, результат:

• lvalue, если target-type является типом lvalue-ссылки или rvalue-ссылкой на тип функции (начиная с C++11) ;

• в противном случае является prvalue.

Псевдонимы типов

Доступность типа

Если тип T_ref является подобным любому из следующих типов, объект динамического типа T_obj является тип-доступным через lvalue (до C++11) glvalue (начиная с C++11) типа T_ref :

• char , unsigned char или std::byte (начиная с C++17) : это позволяет исследовать представление объекта любого объекта как массив байтов.
• T_obj
• соответствующий знаковый или беззнаковый тип для T_obj

Если программа пытается прочитать или изменить сохранённое значение объекта через lvalue (until C++11) glvalue (since C++11) через которое оно не является типодоступным, поведение не определено.

Это правило включает анализ псевдонимов на основе типов, при котором компилятор предполагает, что значение, прочитанное через glvalue одного типа, не изменяется записью в glvalue другого типа (с учетом исключений, указанных выше).

Обратите внимание, что многие компиляторы C++ ослабляют это правило в качестве нестандартного расширения языка, разрешая доступ через неактивный член union с неправильным типом (такой доступ не является неопределённым поведением в C).

Совместимость вызовов

Если выполняется любое из следующих условий, тип T_call является call-совместимым с функциональным типом T_func :

• T_call имеет тот же тип, что и T_func .

Если функция вызывается через выражение, чей тип функции не является совместимым по вызову с типом определения вызываемой функции, поведение не определено.

Примечания

При условии соблюдения требований выравнивания, reinterpret_cast не изменяет значение указателя за исключением нескольких ограниченных случаев, связанных с pointer-interconvertible объектами:

struct S1 { int a; } s1;
struct S2 { int a; private: int b; } s2; // не стандартная компоновка
union U { int a; double b; } u = {0};
int arr[2];
int* p1 = reinterpret_cast<int*>(&s1); // значение p1 - "указатель на s1.a", потому что
                                       // s1.a и s1 являются взаимопреобразуемыми по указателю
int* p2 = reinterpret_cast<int*>(&s2); // значение p2 не изменяется reinterpret_cast
                                       // и является "указателем на s2"
int* p3 = reinterpret_cast<int*>(&u);  // значение p3 - "указатель на u.a":
                                       // u.a и u являются взаимопреобразуемыми по указателю
double* p4 = reinterpret_cast<double*>(p3); // значение p4 - "указатель на u.b": u.a и
                                            // u.b являются взаимопреобразуемыми по указателю, потому что
                                            // оба взаимопреобразуемы по указателю с u
int* p5 = reinterpret_cast<int*>(&arr); // значение p5 не изменяется reinterpret_cast
                                        // и является "указателем на arr"

Выполнение доступа к члену класса, который обозначает нестатическое поле данных или нестатическую функцию-член, для glvalue, которое фактически не обозначает объект соответствующего типа - например, полученного с помощью reinterpret_cast - приводит к неопределённому поведению:

struct S { int x; };
struct T { int x; int f(); };
struct S1 : S {};    // стандартная компоновка
struct ST : S, T {}; // не стандартная компоновка
S s = {};
auto p = reinterpret_cast<T*>(&s); // значение p - "указатель на s"
auto i = p->x; // доступ к члену класса - неопределенное поведение;
               // s не является объектом типа T
p->x = 1; // неопределенное поведение
p->f();   // неопределенное поведение
S1 s1 = {};
auto p1 = reinterpret_cast<S*>(&s1); // значение p1 - "указатель на подобъект S объекта s1"
auto i = p1->x; // OK
p1->x = 1;      // OK
ST st = {};
auto p2 = reinterpret_cast<S*>(&st); // значение p2 - "указатель на st"
auto i = p2->x; // неопределенное поведение
p2->x = 1;      // неопределенное поведение

Многие компиляторы выдают предупреждения о "strict aliasing" в таких случаях, даже если технически такие конструкции нарушают нечто иное, чем параграф, обычно известный как "strict aliasing rule".

Цель строгого алиасинга и связанных правил заключается в том, чтобы включить анализ алиасов на основе типов, который был бы разрушен, если бы программа могла корректно создать ситуацию, в которой два указателя на несвязанные типы (например, int * и float * ) могли одновременно существовать и оба могли использоваться для загрузки или сохранения одной и той же памяти (см. это письмо на SG12 reflector ). Таким образом, любая техника, которая, казалось бы, способна создать такую ситуацию, обязательно вызывает неопределённое поведение.

Когда необходимо интерпретировать байты объекта как значение другого типа, std::memcpy или std::bit_cast (since C++20) может быть использован:

double d = 0.1;
std::int64_t n;
static_assert(sizeof n == sizeof d);
// n = *reinterpret_cast<std::int64_t*>(&d); // Неопределённое поведение
std::memcpy(&n, &d, sizeof d);               // OK
n = std::bit_cast<std::int64_t>(d);          // также OK

В C, агрегатное копирование и присваивание обращаются к агрегатному объекту как к целому. Но в C++ такие действия всегда выполняются через вызов функции-члена, которая обращается к отдельным подобъектам, а не ко всему объекту (или, в случае объединений, копирует представление объекта, т.е. через unsigned char ).

Ключевые слова

reinterpret_cast

Пример

#include <cassert>
#include <cstdint>
#include <iostream>
int f() { return 42; }
int main()
{
    int i = 7;
    // pointer to integer and back
    std::uintptr_t v1 = reinterpret_cast<std::uintptr_t>(&i); // static_cast is an error
    std::cout << "The value of &i is " << std::showbase << std::hex << v1 << '\n';
    int* p1 = reinterpret_cast<int*>(v1);
    assert(p1 == &i);
    // pointer to function to another and back
    void(*fp1)() = reinterpret_cast<void(*)()>(f);
    // fp1(); undefined behavior
    int(*fp2)() = reinterpret_cast<int(*)()>(fp1);
    std::cout << std::dec << fp2() << '\n'; // safe
    // type aliasing through pointer
    char* p2 = reinterpret_cast<char*>(&i);
    std::cout << (p2[0] == '\x7' ? "This system is little-endian\n"
                                 : "This system is big-endian\n");
    // type aliasing through reference
    reinterpret_cast<unsigned int&>(i) = 42;
    std::cout << i << '\n';
    [[maybe_unused]] const int &const_iref = i;
    // int &iref = reinterpret_cast<int&>(
    //     const_iref); // compiler error - can't get rid of const
    // Must use const_cast instead: int &iref = const_cast<int&>(const_iref);
}

The value of &i is 0x7fff352c3580
42
This system is little-endian
42

Отчёты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Ссылки

Смотрите также