Просмотр кода страницы cpp/language/reinterpret cast

У вас нет прав на выполнение действия «редактирование этой страницы» по следующей причине:
Запрошенное действие могут выполнять участники одной из следующих групп: Участники, Администраторы.
Вы можете просмотреть и скопировать исходный код этой страницы.
{{title|Приведение reinterpret_cast}}
{{cpp/language/expressions/navbar}}

Производит приведение одного типа к другому, меняя интерпретацию подлежащего набора битов.

===Синтаксис===

{{sdsc begin}}
{{sdsc | {{ttb|reinterpret_cast<}} {{spar|целевой-тип}} {{ttb|>(}} {{spar|выражение}} {{ttb|)}} }}
{{sdsc end}}

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

===Объяснение===

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

При помощи {{c/core|reinterpret_cast}} могут быть произведены только следующие преобразования (кроме случаев, когда такие преобразования отменили бы ограничения, налагаемые модификаторами ''const'' или ''volatile''):

@1@ Выражение целочисленного типа, перечисление, указатель, или указатель на элемент могут быть преобразованы в свой собственный тип. Результирующее значение совпадает со значением {{spar|выражения}}.
@2@ Указатель может быть преобразован к любому целочисленному типу достаточного размера, вмещающего все значения его типа (например к {{lc|std::uintptr_t}}).
@3@ Значение любого целочисленного типа или перечисления может быть преобразовано в указательный тип. Указатель, преобразованный в целое число достаточного размера, после обратного преобразования к типу того же указателя гарантированно будет иметь исходное значение, в противном случае результирующий указатель не может быть безопасно разыменован (возможность преобразований туда и обратно в противоположном направлении не гарантирована; один и тот же указатель может иметь множество представлений в виде целого числа). Не гарантируется, что константа нулевого указателя {{lc|NULL}} или целочисленный ноль, дадут значение нулевого указателя целевого типа; для этой цели следует использовать {{rlp|static_cast}} или {{rlp|implicit_cast|неявное преобразование}}.

{{rrev|since=c++11|
@4@ Любое значение типа {{lc|std::nullptr_t}}, включая {{c|nullptr}}, может быть преобразовано к любому целочисленному типу, как если бы оно было {{c|(void*)0}}, но никакое значение, в том числе и {{c|nullptr}}, не может быть преобразовано к {{lc|std::nullptr_t}}: для этой цели следует использовать {{c/core|static_cast}}.
}}
@5@ Любой указатель на объектный тип {{tt|T1}} может быть преобразован к указателю на другой объектный тип {{tt|''cv'' T2}}. Такое приведение эквивалентно <{{box|>{{c/core|static_cast<}}''cv''{{c/core| T2*>(static_cast<}}''cv''{{c/core| void*>(}}{{spar|выражение}}{{c/core|))}}}} (подразумевается, что, если требование по выравниванию для {{tt|T2}} не строже, чем для {{tt|T1}}, то значение указателя не изменится и обратное приведение указателя к исходному типу даст исходное значение). В любом случае, результат может быть безопасно разыменован, только если это разрешено правилами на ''псевдоним типа'' (смотрите ниже){{mark unreviewed dr|cwg}}<!-- cwg1412 -->
@6@ {{rev inl|until=c++11|{{rlp|value category#lvalue|lvalue}}}}{{rev inl|since=c++11|{{rlp|value category#glvalue|glvalue}}}} выражение типа {{tt|T1}} может быть преобразовано в ссылку на другой тип {{tt|T2}}. Результатом будет {{c|*reinterpret_cast<T2*>(p)}}, где {{c|p}} это указатель типа “указатель на {{tt|T1}}” на объект, обозначенный {{spar|выражением}}. При этом, ни копии исходного объекта, ни временного объекта не создаётся, а также не вызываются конструкторы и операторы преобразования. Доступ к объекту по результирующей ссылке может быть осуществлён безопасно, только если это разрешено правилами на ''псевдоним типа'' (смотрите ниже).
@7@ Любой указатель на функцию может быть преобразован к указателю на другой функциональный тип. Вызов функции через указатель на другой функциональный тип ��риводит к неопределённому поведению, но приведение такого указателя обратно к указателю на исходный функциональный тип даст указатель на исходную функцию.
@8@ В некоторых реализациях (в частности, в любой POSIX-совместимой системе, как того требует [https://pubs.opengroup.org/onlinepubs/9699919799/functions/dlsym.html {{tt|dlsym}}]), указатель на функцию может быть преобразован в {{c/core|void*}} или к любому другому указателю на объект и наоборот. Если реализация поддерживает преобразование в обоих направлениях, то преобразование к исходному типу даст исходное значение, иначе результирующий указатель не может быть разыменован или вызван безопасно.
@9@ Нулевой указатель любого типа может быть преобразован к любому другому указательному типу, в результате чего будет получено значение нулевого указателя этого типа. Заметьте, что константа {{c|nullptr}} или любое другое значение типа {{lc|std::nullptr_t}} не может быть преобразовано в указатель при помощи {{c/core|reinterpret_cast}}: для этого должно быть использовано неявное преобразование или приведение {{c/core|static_cast}}.
@10@ Указатель на функцию-элемент может быть преобразован в указатель на другую функцию-элемент другого типа. Обратное преобразование к исходному типу даст исходное значение, в противном случае результирующий указатель не может быть безопасно использован.
@11@ Указатель на объект-элемент класса {{tt|T1}} может быть преобразован в указатель на другой объект-элемент другого класса {{tt|T2}}. Если выравнивание {{tt|T2}} не строже, чем выравнивание {{tt|T1}}, то преобразование в исходный тип даст исходное значение, в противном случае результирующий указатель не может быть безопасно использован.

{{cpp/language/cast_return}}

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

{{ltt|cpp/keyword/reinterpret_cast}}

===Псевдоним типа===
Любое чтение или изменение хранимого значения объектного типа {{tt|DynamicType}} через glvalue типа {{tt|AliasedType}} является неопределённым поведением, за исключением случаев:
* {{tt|AliasedType}} и {{tt|DynamicType}} ''подобны''.
* {{tt|AliasedType}} (возможно {{rlp|cv}}-квалифицированный) является знаковым или безнаковым вариантом типа {{tt|DynamicType}}.
* {{tt|AliasedType}} является {{rev inl|since=c++17|{{ltt|cpp/types/byte|std::byte}}, }}{{c/core|char}} или {{c/core|unsigned char}}: это позволяет рассматривать {{rlp|object#Представление объекта и представление значения|объектное представление}} любого объекта, как массив байт.

Неформально два типа являются ''подобными'', если, отбросив cv-квалификаторы верхнего уровня:
* они одного типа; или
* они оба указатели и указываемые типы подобны; или
* они оба указатели на элемент одного класса и типы указываемых элементов подобны; или
{{rrev multi|until1=c++20|rev1=
* они оба массивы одинакового размера или оба массивы, чей размер не задан, и типы их элементов подобны.
|rev2=
* они оба массивы одинакового размера или, по крайней мере, один из них массив с неизвестной границей, и типы элементов массивов похожи.
}}

Например:
*{{c/core|const int * volatile *}} и {{c/core|int * * const}} подобны;
*{{c/core|const int (* volatile S::* const)[20]}} и {{c/core|int (* const S::* volatile)[20]}} подобны;
*{{c/core|int (* const *)(int *)}} и {{c/core|int (* volatile *)(int *)}} подобны;
*{{c/core|int (S::*)() const}} и {{c/core|int (S::*)()}} ''не'' подобны;
*{{c/core|int (*)(int *)}} и {{c/core|int (*)(const int *)}} ''не'' подобны;
*{{c/core|const int (*)(int *)}} и {{c/core|int (*)(int *)}} ''не'' подобны;
*{{c/core|int (*)(int * const)}} и {{c/core|int (*)(int *)}} подобны (типы совпадают);
*{{c/core|std::pair<int, int>}} и {{c/core|std::pair<const int, int>}} ''не'' подобны.

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

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

===Примечание===
Предполагая, что требования по выравниванию соблюдены, {{c/core|reinterpret_cast}} не изменяет {{rlp|pointer#Указатели|значение указателя}}, за исключением некоторого числа ограниченных случаев, имеющих дело с объектами {{rlp|static_cast#взаимоконвертируемые-указатели|''указательно-приводимыми-друг-в-друга''}}:
{{source|1=
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-объекта, который на самом деле не представляет собой объект подходящего типа и полученный через {{c/core|reinterpret_cast}} приводит к неопределённому поведению:

{{source|1=
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; // неопределённое поведение
}}

В этих случаях многие компиляторы выдают предупреждение о "перекрытии объектов в памяти", хотя технически такие выражения вступают в конфликт с чем-то иным, чем параграф, известный как "правило перекрытия объектов в памяти".

Назначение правила перекрытия объектов в памяти и сопутствующих правил состоит в том, чтобы разрешить проведение анализа псевдонимов на основе типа. Этого анализа можно было избежать, если бы программа смогла законным образом создать ситуацию, при которой два указателя на несвязанные типы (например {{c/core|int*}} и {{c/core|float*}}) существовали одновременно и оба могли бы быть использованы для чтения или записи в ту же область памяти (смотрите [https://web.archive.org/web/20201128194944/http://www.open-std.org/pipermail/ub/2016-February/000565.html это электронное письмо на зеркале SG12]). Таким образом, любой способ, который на первый взляд может создать такую ситуацию, неминуемо приведёт к неопределённому поведению.

Если необходимо интерпретировать байты объекта как значение другого типа, могут быть использованы {{lc|std::memcpy}} {{rev inl|since=c++20|или {{ltt|cpp/numeric/bit_cast|std::bit_cast}} }}:

{{source|1=
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
}}

{{rrev|since=c++11|
Если реализация предоставляет {{lc|std::intptr_t}} и/или {{lc|std::uintptr_t}}, то приведение типа указателя к типу объекта или ''cv'' {{c/core|void}} к этим типам всегда чётко определено. Однако это не гарантируется для указателя на функцию.
}}

Параграф стандарта, определяющий правило перекрытия объектов в памяти, содержит два дополнительных пункта, частично перешедших из стандарта C:
* {{tt|AliasedType}} является {{rlp|aggregate_initialization|агрегатным типом}} или типом {{rlp|union|объединения}}, который содержит один из ранее упомянутых типов в качестве элемента или нестатического элемента (включая, рекурсивно, элементы подагрегатов и нестатические данные-элементы содержащихся объединений).
* {{tt|AliasedType}} является (возможно {{rlp|cv}}-квалифицированным) {{rlp|derived_class|базовый класс|базовым классом}} с ��ипом {{tt|DynamicType}}.

Эти параграфы описывают ситуации, которые не могут возникнуть в C++ и, таким образом, не рассмотрены выше. В C, доступ к объекту-агрегату при копировании и присваивании осуществляется как к единому целому. Однако в C++ эти действия всегда выполняются через вызов функции-элемента, которая имеет дело с индивидуальными подобъектами, а не с целым объектом (или, в случае объединений, копирует представление объекта через {{c/core|unsigned char}}). Эти параграфы в конечном итоге были удалены с помощью {{cwg|2051}}.

===Пример===
{{example
 | Демонстрирует некоторые варианты применения {{c/core|reinterpret_cast}}:
 | code=
#include <cassert>
#include <cstdint>
#include <iostream>
int f() { return 42; }
int main()
{
    int i = 7;

    // в указатель на целое число и обратно
    std::uintptr_t v1 = reinterpret_cast<std::uintptr_t>(&i); // static_cast ошибка
    std::cout << "Значение &i - 0x" << std::hex << v1 << '\n';
    int* p1 = reinterpret_cast<int*>(v1);
    assert(p1 == &i);

    // указатель на функцию в указатель на другую функцию и обратно
    void(*fp1)() = reinterpret_cast<void(*)()>(f);
    // fp1(); неопределенное поведение
    int(*fp2)() = reinterpret_cast<int(*)()>(fp1);
    std::cout << std::dec << fp2() << '\n'; // безопасно

    // псевдоним типа через указатель
    char* p2 = reinterpret_cast<char*>(&i);
    if(p2[0] == '\x7')
        std::cout << "Порядок байт - little-endian\n";
    else
        std::cout << "Порядок байт - big-endian\n";

    // псевдоним типа через ссылку
    reinterpret_cast<unsigned int&>(i) = 42;
    std::cout << i << '\n';

    [[maybe_unused]] const int &const_iref = i;
    //int &iref = reinterpret_cast<int&>(const_iref); //ошибка компилятора - ��ельзя избавится от const
    //Здесь должен быть применён const_cast:  int &iref = const_cast<int&>(const_iref);
}
 | p=true
 | output=
Значение &i - 0x7fff352c3580
42
Порядок байт - little-endian
42
}}

===Отчёты о дефектах===
{{dr list begin}}
{{dr list item|wg=cwg|dr=195|std=C++98|before=преобразование между указателями на функции и указателями на<br>объекты не разрешено|after=сделано условно-поддерживаемым}}
{{dr list item|wg=cwg|dr=658|std=C++98|before=результат преобразования указателя не был указан (за исключением<br>преобразования обратно<br>в исходный тип)|after=специфицировано для указателей,<br>типы которых соответствуют<br>требованиям выравнивания}}
{{dr list item|wg=cwg|dr=799|std=C++98|before=было неясно, какое преобразование идентичности может быть<br>выполнено с помощью<br>{{c/core|reinterpret_cast}}|after=сделано понятным}}
{{dr list item|wg=cwg|dr=1268|std=C++11|before={{c/core|reinterpret_cast}} может приводить значения lvalue только к<br>ссылочным типам|after=значения xvalue также разрешены}}
{{dr list end}}

===Смотрите также===
{{dsc begin}}
{{dsc inc | cpp/language/dsc const_cast}}
{{dsc inc | cpp/language/dsc static_cast}}
{{dsc inc | cpp/language/dsc dynamic_cast}}
{{dsc inc | cpp/language/dsc explicit_cast}}
{{dsc inc | cpp/language/dsc implicit_cast}}
{{dsc end}}

{{langlinks|en|de|es|fr|it|ja|pt|zh}}
Шаблоны, используемые на этой странице:
Возврат к странице cpp/language/reinterpret cast.
cppreference.com

Поиск

Пространства имён

Варианты

Просмотры

Действия

Просмотр кода страницы cpp/language/reinterpret cast

Навигация

Инструменты
