Casts, aliasing and reading bytes safely

C++ splits the old C cast into named casts, so that each one says what kind of conversion it is.

A C-style cast (T)x tries these in turn and will happily do a reinterpret_cast or remove const without saying so. That is why code review flags them.

The compiler assumes that pointers to different types do not point to the same memory, with a few exceptions: char, unsigned char and std::byte may alias anything, and signed and unsigned versions of the same type may alias each other. This lets it keep values in registers instead of reloading them after every write through an unrelated pointer.

Reading an object through a pointer of an unrelated type breaks that assumption and is undefined behaviour:

float f = 1.0f;
std::uint32_t bits = *reinterpret_cast<std::uint32_t*>(&f);   // undefined: uint32_t does not alias float
std::uint32_t ok   = std::bit_cast<std::uint32_t>(f);         // defined: copies the bits

Most of the time the first line produces the expected answer, which is why it survives. Under optimisation it can produce stale values, because the compiler reorders the read past a write it believes is unrelated.

Now the question. reinterpret_cast<const Header*>(buf) has three problems:

1. Aliasing and lifetime. There is no Header object at that address; there is an array of char. Reading it through a Header* is undefined, even though the bytes are right.
2. Alignment. If Header contains a uint64_t and buf + offset is not 8-byte aligned, the access is misaligned. x86 tolerates it with at most a small penalty; other architectures fault, and the compiler may emit instructions that assume alignment.
3. Layout and byte order. The struct's padding and field order must match the wire format exactly, and the integers must be in the machine's byte order. Exchange protocols are often little-endian, sometimes big-endian.

The portable way is to copy the bytes into a real object:

#pragma pack(push, 1)
struct Header {                       // matches the exchange's wire layout, no padding
    std::uint16_t length;
    std::uint16_t type;
    std::uint32_t seq;
    std::uint64_t send_time_ns;
};
#pragma pack(pop)
static_assert(sizeof(Header) == 16);
static_assert(std::is_trivially_copyable_v<Header>);

Header read_header(const char* buf) {
    Header h;
    std::memcpy(&h, buf, sizeof h);   // defined behaviour, any alignment
    return h;                         // convert byte order here if the wire is big-endian
}

This looks slower and is not. Compilers recognise a fixed-size memcpy into a local and turn it into the same one or two load instructions the cast would have produced. C++23 adds std::start_lifetime_as for the case where you really want to treat the bytes in place as an object, but memcpy remains the clearest answer.

For many fields, a common pattern is accessor functions that memcpy each field from its offset in the buffer, which avoids packing pragmas altogether.

dynamic_cast walks the type information of the object to check the cast, which costs far more than a virtual call and varies with the depth of the hierarchy. If hot code needs it, the design usually wants a virtual function, a type tag with a switch, or a std::variant instead.