Краткий ответ

std::bit_cast создаёт значение целевого типа с той же последовательностью битов, что и у исходного объекта. Это побитовое копирование, а не числовое преобразование: оно не вычисляет эквивалентное значение и не меняет представление данных по правилам преобразования типов.

В примере преобразование корректно, потому что float и std::array<std::byte, sizeof(float)> имеют одинаковый размер, а оба типа являются тривиально копируемыми. Обратное преобразование восстанавливает исходное значение, если полученное битовое представление допустимо для float.

Исторический контекст

До C++20 для побитового переноса значения между типами обычно применяли std::memcpy. Такой подход корректен с точки зрения правил доступа к объектам, но многословен и скрывает намерение кода. reinterpret_cast часто использовали ошибочно: разыменование указателя на несовместимый тип может нарушить правила aliasing и привести к неопределённому поведению.

std::bit_cast стандартизировал явно выраженную операцию копирования представления. Компилятор может эффективно реализовать её без фактического промежуточного копирования, но семантически это именно создание нового объекта целевого типа из битового представления исходного.

Постановка проблемы

Задача возникает при разборе бинарных форматов, работе с плавающей точкой, хешировании представления объекта или взаимодействии с аппаратными данными. Нельзя подменять побитовое преобразование обычным приведением: static_cast<int>(value) вычисляет целое числовое значение, тогда как bit_cast сохраняет биты.

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

Подробное решение

std::bit_cast<To>(from) доступен, если sizeof(To) == sizeof(From) и оба типа являются trivially copyable. Результат имеет тип To, а его биты соответствуют битам представления from.

Для целочисленных типов это может превратить, например, битовый шаблон IEEE 754 в значение float, но стандарт C++ не требует от каждой платформы именно IEEE 754. Поэтому фиксированное ожидание конкретного числа допустимо только при явно принятом ограничении на платформу и ABI.

У std::bit_cast есть важные ограничения:

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

В отличие от reinterpret_cast, bit_cast не создаёт ссылку или указатель на тот же участок памяти. Он возвращает отдельный объект целевого типа, поэтому последующее изменение результата не изменяет исходный объект.

Минимальный пример обратимого преобразования представления:

#include <array>
#include <bit>
#include <cassert>
#include <cstddef>

int main() {
    float value = 1.5f;
    auto raw = std::bit_cast<std::array<std::byte, sizeof(float)>>(value);
    float restored = std::bit_cast<float>(raw);
    assert(restored == value);
}

Здесь raw содержит байты представления value, но не обязан иметь одинаковый вид на машинах с разным порядком байтов или разной моделью float.

Ситуация из практики

Компонент должен сохранять float в сетевой бинарный протокол. Первый вариант — записать std::bit_cast<std::array<std::byte, sizeof(float)>>(value) напрямую. Он краток и сохраняет точное машинное представление, но результат зависит от endianess, размера и формата float, поэтому другая система может его неверно прочитать.

Второй вариант — использовать std::memcpy в буфер. По корректности он не лучше bit_cast, а только менее выразителен; платформенные зависимости остаются. Третий вариант — определить формат протокола явно: выбрать IEEE 754 binary32, преобразовать байты в заданный порядок и проверить допустимость входных данных.

Для внутреннего обмена между компонентами одной зафиксированной платформы выбран bit_cast: он ясно показывает намерение и не нарушает правила aliasing. Для внешнего протокола выбрано явное кодирование полей, потому что переносимость важнее краткости; результатом становится стабильный формат, независимый от представления объектов в памяти.

Что кандидаты часто упускают

Допустимо ли заменить std::bit_cast на reinterpret_cast<float&>?

Нет, такая замена неэквивалентна. Она создаёт обращение к объекту через ссылку другого типа и может нарушить правила type aliasing; кроме того, могут возникнуть проблемы с выравниванием. std::bit_cast создаёт отдельный объект и потому не требует, чтобы исходный объект фактически был объектом целевого типа.
Можно ли использовать std::bit_cast для сериализации структуры целиком?

Технически структура может удовлетворять ограничениям bit_cast, но это не делает её представление стабильным форматом. В структуре возможны padding-биты, порядок байтов полей зависит от платформы, а ABI может менять расположение членов. Для сериализации нужно кодировать каждое поле по спецификации формата, а bit_cast применять только там, где представление заранее является частью контракта.
Что произойдёт, если после изменения массива байтов получить float с необычным битовым шаблоном?

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