Mapping a structure to uint64_t - c++

Question

What is the right way to convert the structure below to uint64_t?
struct Data
{
uint64_t sign : 1;
uint64_t exp : 4;
uint64_t man : 8;
};
static_assert(sizeof(Data) == sizeof(uint64_t));
the obvious one is
Data data;
uint64_t n = *(reinterpret_cast<const uint64_t*>(&data));
but it does not compile as constexpr and produces the following warnings in GCC:
dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
EDIT1:
The value of resulting uint64_t may be different with different compilers. But the value of Data structure should be the same when I convert it back from uint64_t.
So, saying more exactly I need:
Data data;
uint64_t n = convert(data);
Data data2 = convert_back(n);
static_assert(data == data2);

Answer 1

You std::memcpy the structure to an uint64_t. std::memcpy is a legal way to perform type punning, it is allowed since your structure is trivially-copyable.
In C++20 there is also std::bit_cast.
Unlike std::memcpy it's constexpr, but to make it work at compile-time I had to add uint64_t : 51; at the end of the struct.
Interestingly, Clang (unlike GCC and MSVC) refused to perform it at compile-time:
note: constexpr bit_cast involving bit-field is not yet supported

Answer 2

The conversion is not "obvious" because the exact layout of Data is implementation defined (see bit field). Moreover, your cast via pointers breaks strict aliasing, as the error suggests. There is no uint64_t stored at the adress of data.
You can convert it like this:
constexpr uint64_t Data_2_uint(const Data& d){
return d.sign + (d.exp << 1) + (d.man << 5);
}

Answer 3

If you are looking for an implicit conversion, you may use union to access the same data structure with a different alias
union Data {
struct {
uint64_t sign : 1;
uint64_t exp : 4;
uint64_t man : 8;
}
uint64_t data_as_uint64;
}
To make sure you don't have memory representation problems with padding of the fields, you should use #pragma pack, and set the packing to 1
#pragma pack(push, 1)
union Data {
struct {
uint64_t sign : 1;
uint64_t exp : 4;
uint64_t man : 8;
}
uint64_t data_as_uint64;
}
#pragma pack(pop)
Notice that #pragma pack is compiler dependent, and you need to make sure your compiler supports it.