How to fill buffers with mixed types conveniently in standard conformant way?

Question

There are problems, where we need to fill buffers with mixed types. Two examples:

• programming OpenGL/DirectX, we need to fill vertex buffers, which can have mixed types (which is basically an array of struct, but the struct maybe described by a run-time data)
• creating a memory allocator: putting header/trailer information to the buffer (size, flags, next/prev pointer, sentinels, etc.)

The problem can be described like this:

• there is an allocation function, which gives back some memory (new, malloc, OS dependent allocation function, like mmap or VirtualAlloc)
• there is a need to put mixed types into an allocated buffer, at various offsets

A solution can be this, for example writing an int to an offset:

void *buffer = <allocate>;
int offset = <some_offset>;
char *ptr = static_cast<char*>(buffer);
*reinterpret_cast<int*>(ptr+offset) = int_value;

However, this is inconvenient, and has UB at least two places:

• ptr+offset is UB, as there is no char array at ptr
• writing to the result of reinterpret_cast is UB, as there is no int there

To solve the inconvenience problem, this solution is often used:

union Pointer {
    void *asVoid;
    bool *asBool;
    byte *asByte;
    char *asChar;
    short *asShort;
    int *asInt;

    Pointer(void *p) : asVoid(p) { }
};

So, with this union, we can do this:

Pointer p = <allocate>;
p.asChar += offset;
*p.asInt++ = int_value; // write an int to offset
*p.asShort++ = short_value; // then a short afterwards
// other writes here

This solution is convenient for filling buffers, but has further UB, as the solution uses non-active union members.

So, my question is: how can one solve this problem in a strictly standard conformant, and most convenient way? I mean, I'd like to have the functionality which the union solution gives me, but in a standard conformant way.

(Note: suppose, that we have no alignment issues here, alignment is taken care of by using proper offsets)

Answer 1

A simple (and conformant) way to handle these things is leveraging std::memcpy to move whatever values you need into the correct offsets in your storage area, e.g.

std::int32_t value;
char *ptr;
int offset;
// ...
std::memcpy(ptr+offset, &value, sizeof(value));

Do not worry about performance, since your compiler will not actually perform std::memcpy calls in many cases (e.g. small values). Of course, check the assembly output (and profile!), but it should be fine in general.