Nel suo recente discorso "Digitare la punzonatura nel moderno C ++" Timur Doumler ha affermato che std::bit_castnon può essere utilizzato per eseguire il bit di bit floatin un unsigned char[4]perché gli array in stile C non possono essere restituiti da una funzione. Dovremmo usare std::memcpyo attendere fino a C ++ 23 (o successivo) quando qualcosa del genere reinterpret_cast<unsigned char*>(&f)[i]diventerà ben definito.

In C ++ 20, possiamo usare un std::arraycon std::bit_cast,

float f = /* some value */;
auto bits = std::bit_cast<std::array<unsigned char, sizeof(float)>>(f);

invece di un array in stile C per ottenere byte di un float?

Sì, questo funziona su tutti i principali compilatori e, per quanto ne so guardando lo standard, è portatile e garantito per funzionare.

Innanzitutto, std::array<unsigned char, sizeof(float)>è garantito che sia un aggregato ( https://eel.is/c++draft/array#overview-2 ). Da ciò consegue che contiene esattamente un sizeof(float)numero di chars all'interno (in genere come a char[], sebbene afaics lo standard non imponga questa particolare implementazione - ma dice che gli elementi devono essere contigui) e non può avere altri membri non statici.

È quindi banalmente copiabile e anche le sue dimensioni corrispondono a quelle di float.

Queste due proprietà ti permettono bit_casttra di loro.

La risposta accettata non è corretta perché non considera i problemi di allineamento e riempimento.

Per [array] / 1-3 :

L'intestazione <array>definisce un modello di classe per la memorizzazione di sequenze di oggetti di dimensioni fisse. Un array è un contenitore contiguo. Un'istanza di elementi di tipo array<T, N>store , quindi è un invariante.NTsize() == N

Un array è un aggregato che può essere inizializzato in elenco con un massimo di N elementi i cui tipi sono convertibili T.

Una matrice soddisfa tutti i requisiti di un contenitore e di un contenitore reversibile ( [container.requirements]), tranne per il fatto che un oggetto matrice predefinito costruito non è vuoto e che lo scambio non ha complessità costante. Un array soddisfa alcuni dei requisiti di un contenitore di sequenze. Le descrizioni sono fornite qui solo per le operazioni sull'array che non sono descritte in una di queste tabelle e per le operazioni in cui vi sono ulteriori informazioni semantiche.

Lo standard in realtà non richiede std::arraydi avere esattamente un membro di dati pubblici di tipo T[N], quindi in teoria è possibile che sizeof(To) != sizeof(From)o is_­trivially_­copyable_­v<To>.

Sarò sorpreso se questo non funziona in pratica, però.

Sì.

Secondo il documento che descrive il comportamento std::bit_caste l' implementazione proposta nella misura in cui entrambi i tipi hanno le stesse dimensioni e sono banalmente copiabili, il cast dovrebbe avere successo.

Un'implementazione semplificata di std::bit_castdovrebbe essere qualcosa del tipo:

template <class Dest, class Source>
inline Dest bit_cast(Source const &source) {
    static_assert(sizeof(Dest) == sizeof(Source));
    static_assert(std::is_trivially_copyable<Dest>::value);
    static_assert(std::is_trivially_copyable<Source>::value);

    Dest dest;
    std::memcpy(&dest, &source, sizeof(dest));
    return dest;
}

Poiché un galleggiante (4 byte) e una serie di unsigned charcon size_of(float)rispetto tutti coloro afferma il sottostante std::memcpysarà effettuata. Pertanto, ogni elemento nell'array risultante sarà un byte consecutivo del float.

Per dimostrare questo comportamento, ho scritto un piccolo esempio in Compiler Explorer che puoi provare qui: https://godbolt.org/z/4G21zS . Il float 5.0 è correttamente memorizzato come un array di byte ( Ox40a00000) che corrisponde alla rappresentazione esadecimale di quel numero float in Big Endian .