reinterpret_cast преобразование

Преобразует значения между типами, переинтерпретируя базовый битовый шаблон.

Синтаксис

Возвращает значение типа целевой-тип.

Пояснение

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

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

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

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

• prvalue в остальных случаях.

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

Доступность через тип

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

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

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

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

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

Совместимость для вызова

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

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

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

Примечания

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

struct S1 { int a; } s1;
struct S2 { int a; private: int b; } s2; // not standard-layout
union U { int a; double b; } u = {0};
int arr[2];

int* p1 = reinterpret_cast<int*>(&s1); // value of p1 is "pointer to s1.a" because
                                       // s1.a and s1 are pointer-interconvertible

int* p2 = reinterpret_cast<int*>(&s2); // value of p2 is unchanged by reinterpret_cast
                                       // and is "pointer to s2". 

int* p3 = reinterpret_cast<int*>(&u);  // value of p3 is "pointer to u.a":
                                       // u.a and u are pointer-interconvertible

double* p4 = reinterpret_cast<double*>(p3); // value of p4 is "pointer to u.b": u.a and
                                            // u.b are pointer-interconvertible because
                                            // both are pointer-interconvertible with u

int* p5 = reinterpret_cast<int*>(&arr); // value of p5 is unchanged by reinterpret_cast
                                        // and is "pointer to arr"

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

struct S { int x; };
struct T { int x; int f(); };
struct S1 : S {};    // standard-layout
struct ST : S, T {}; // not standard-layout
 
S s = {};
auto p = reinterpret_cast<T*>(&s); // value of p is "pointer to s"
auto i = p->x; // class member access expression is undefined behavior;
               // s is not a T object
p->x = 1; // undefined behavior
p->f();   // undefined behavior
 
S1 s1 = {};
auto p1 = reinterpret_cast<S*>(&s1); // value of p1 is "pointer to the S subobject of s1"
auto i = p1->x; // OK
p1->x = 1;      // OK
 
ST st = {};
auto p2 = reinterpret_cast<S*>(&st); // value of p2 is "pointer to st"
auto i = p2->x; // undefined behavior
p2->x = 1;      // undefined behavior

Во многих случаях компиляторы выдают предупреждения о «строгом алиасинге», хотя технически такие конструкции нарушают нечто иное, чем правило, обычно называемое «правилом строгого алиасинга».

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

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

double d = 0.1;
std::int64_t n;
static_assert(sizeof n == sizeof d);
// n = *reinterpret_cast<std::int64_t*>(&d); // Undefined behavior
std::memcpy(&n, &d, sizeof d);               // OK
n = std::bit_cast<std::int64_t>(d);          // also OK

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

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

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++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 7.6.1.10 Преобразование reinterpret [expr.reinterpret.cast]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 7.6.1.9 Преобразование reinterpret [expr.reinterpret.cast]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 8.2.10 Преобразование reinterpret [expr.reinterpret.cast]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 5.2.10 Преобразование reinterpret [expr.reinterpret.cast]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 5.2.10 Преобразование reinterpret [expr.reinterpret.cast]
• Стандарт C++98 (ISO/IEC 14882:1998):
• 5.2.10 Преобразование reinterpret [expr.reinterpret.cast]
• Стандарт C++03 (ISO/IEC 14882:2003):
• 5.2.10 Преобразование reinterpret [expr.reinterpret.cast]

См. также