It’s recently that I needed to properly understand reinterpret_cast, which is a method of converting between data types. This type of cast reinterprets the value of a variable of one type as another variable of a different type. It is efficient because it does not copy the value. What it does copy is the pointer to the value. So the two variables can be seen as different projections over the same memory zone.
The good
A use case for reinterpret_cast is transporting data through a buffer. The data model is a well-defined struct that could be transferred between different systems as bytes buffer (which could be a char array).
struct Input {
int a;
int b;
};
using Buffer = char[8];
The Input struct can be casted to the Buffer before being sent over the wire.
Input in{};
in.a = 5;
in.b = 7;
auto buffer = reinterpret_cast<Buffer*>(&in);
Then the buffer, when received, can be converted back to the Input struct.
auto input = reinterpret_cast<Input*>(buffer); assert(input->a == 5); assert(input->b == 7);
Update: As I was told, the sizes of the two types should be equal. This prevents possible data loss.
static_assert(sizeof(Input) == sizeof(Buffer), "input and buffer size mismatch");
Casting implies a pointer copy, which is very cheap. Given a cast from a buffer to a struct:
struct Input {
int a;
int b;
};
int main()
{
int buffer[2] = {5, 7};
auto input = reinterpret_cast<Input*>(buffer);
}
The generated assembly is:
main:
push rbp
mov rbp, rsp
mov DWORD PTR [rbp-16], 5
mov DWORD PTR [rbp-12], 7
lea rax, [rbp-16]
mov QWORD PTR [rbp-8], rax
mov eax, 0
pop rbp
ret