Increment pointer when Unpacking Variadic Arguments with Lambda - c++

Question

I have the following code which has a function VariadicWrite and this function accepts a pointer that it can modify by incrementing it to it points to a different memory location depending on how much data is written to it:
#include <iostream>
#include <cstring>
template<typename T>
T Read(void* &ptr) noexcept
{
T result;
memcpy(&result, ptr, sizeof(result));
ptr = static_cast<T*>(ptr) + 1;
return result;
}
template<typename T>
void Write(void* &ptr, T result) noexcept
{
memcpy(ptr, &result, sizeof(result));
ptr = static_cast<T*>(ptr) + 1;
}
template<typename... Args>
auto VariadicWrite(void*& ptr, Args&&... args)
{
(Write(ptr, args), ...); //unpack Args
return 0;
}
int main()
{
void* ptr = malloc(1024);
memset(ptr, 0, 1024);
void* temp = ptr;
VariadicWrite(ptr, 1, 2, 3);
std::cout<<Read<int>(ptr)<<"\n";
std::cout<<Read<int>(ptr)<<"\n";
std::cout<<Read<int>(ptr)<<"\n";
free(temp);
return 0;
}
The problem here is that the code prints out 0, 0, 0, 0 if I use: void*& ptr.
If I do void* ptr it prints out 0, 1, 2, 3 but the ptr pointer is never incremented.
How can I modify the ptr pointer of VariadicWrite? I thought that void*& would have worked but in this case it doesn't :S

Answer 1

The problem is your VariadicWrite() call will modify ptr to point to the end of your written data. Then you call Read() without resetting the pointer back to the start, so you read zeros from the uninitialized portion of your buffer that follows the data already written.
Insert ptr = temp; between the write and read and see if that fixes it.
The reason void* ptr does not work is that each call to Write(ptr, ...) will increment the local copy of the argument in the scope of the Write() function. The variable ptr in VariadicWrite() does not change after a call to Write() so the next call will use the same value.
If you change to VariadicWrite(void* ptr, …) and Write(void*& ptr, …), you might get the behavior you want. But I would suggest this a bad idea.
As we can see from the bug in your example, knowing if the function will modify the pass-by-reference parameter or not is of critical importance, yet not readily apparent from the code using the function. This tends to invite bugs just like the one you have created here. An inconsistent interface, where VariadicWrite() does not modify its argument but Write() does, will only make it doubly hard to avoid this kind of bug.
Generally, it's better to avoid non-const references because they often result in bugs like this. I suggest returning the new pointer instead of modifying the argument.
template<typename T>
void* Write(void* ptr, const T& arg)
{
return static_cast<T*>(ptr) + 1;
}
template<typename... Args>
void* WriteV(void* ptr, Args&&... args)
{
((ptr = Write(ptr, args)), ...);
return ptr;
}