serializing structure which includes pointers - c++

Question

Description of the problem
I have to serialize the following structure and store it a different memory location (e.g. the flash). The solution has to work when the new memory location is read only:
------------
| Header |
------------
| object 1 |
------------
| object 2 |
------------
| object n |
------------
The Header struct has pointers to the allocated objects like e.g.
struct Header {
int* object1;
};
I know a proper solution would be to store the offset instead of pointers, but I work on an existing code base, where this is only an option if there is no other way to achieve this. The example above is very simplistic. In the actual usage the object list is used by a custom mem pool implementation. It can include hundreds of nested structures which include pointers to each other (the order + amount varies greatly between users. It can be a couple of kilobytes to multiple megabytes of data). In the end the implementation has to be able to return a pointer + size, so an user can store the structure e.g. in the flash.
Current Approach to solve the problem
To achieve this I store the original base pointer of the Header and subtract it from the new base pointer after copying the structure to the new memory location:
struct Header {
char* base_ptr;
char* object1;
char* get_object1(char* new_base_ptr) {
ptrdiff_t offset = (ptrdiff_t)new_base_ptr - (ptrdiff_t)base_ptr;
return (char*)object1 + offset;
}
char* get_object2(char* new_base_ptr) {
ptrdiff_t offset = (ptrdiff_t)object1 - (ptrdiff_t)base_ptr;
return new_base_ptr + offset;
}
};
int main() {
void* alloc = malloc(sizeof(Header) + sizeof(char));
Header* header = new(alloc) Header;
header->base_ptr = (char*)alloc;
header->object1 = (char*)alloc + sizeof(Header);
*header->object1 = 5;
std::cout << (int)*header->get_object1((char*)alloc) << std::endl;
std::cout << (int)*header->get_object2((char*)alloc) << std::endl;
void* alloc2 = malloc(sizeof(Header) + sizeof(char));
memcpy(alloc2, alloc, sizeof(Header) + sizeof(char));
free(alloc);
Header* header2 = (Header*)alloc2;
std::cout << (int)*header2->get_object1((char*)alloc2) << std::endl;
std::cout << (int)*header2->get_object2((char*)alloc2) << std::endl;
}
I did see the following reasons for the implementations get_object1 and get_object2:
get_object1:
+ offset can be calculated once and then reused
- subtracting pointers to two different arrays (one in the flash and one to the old memory location), which might be undefined behavior. See https://en.cppreference.com/w/cpp/types/ptrdiff_t:
Only pointers to elements of the same array (including the pointer one past the end of the array) may be subtracted from each other.
- The offset is bigger than the array size, which might be undefined behavior according to §5.7 ¶5 of the C++11 spec:
If both the pointer operand and the result point to elements of the same array object, or one past the last element of the array object, the evaluation shall not produce an overflow; otherwise, the behavior is undefined.
get_object3:
+ both offset and the final pointer are calculated within the boundary of the array. Therefore it should not have undefined behavior.
Question
I prefer the implementation in get_object1, since I can reuse the offset. However I assume, that this implementation has undefined behavior. Are there similar problems in the get_object2 implementation that I did not account for? Is this guaranteed to work properly when the Header is no standard layout type? Is there a better alternative way to achieve this?

Answer 1

Is there a better alternative way to achieve this?
Don't bother with trying to work around memcpy. Write your own copy function.
Header * copyHeader(const Header * source, void * where) {
Header * dest = new (where) Header;
dest->object1 = new (where + sizeof(Header)) int(source->object1);
return dest;
}
And/or a factory
Header * makeHeader(void * where) {
Header * dest = new (where) Header;
dest->object1 = new (where + sizeof(Header)) int;
return dest;
}