valgrind complains about uninitialized bytes on C++ structure - c++

Question

I have distilled by question down to a very simple example where I have a structure constructor that is initializing everything, yet valgrind complains about uninitialized bytes. The culprit seems to be the boolean member of the class, which causes padding bytes to be inserted before the size_t member. What is the right way to initialize those padding bytes so that valgrind doesn't complain?
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define MAX 128
typedef struct foo_struct
{
foo_struct(const std::string& name, bool q = true) : q(q)
{
if (name.size() > MAX)
{
throw std::runtime_error("too big");
}
point_name_size = name.size();
memset(n, 0, sizeof(n));
memcpy(n, name.c_str(), name.size());
}
bool q;
size_t point_name_size;
char n[MAX];
} foo_t;
int main()
{
int fd = open("/tmp/foo", O_WRONLY | O_CREAT, 0666);
if (-1 == fd)
{
throw std::runtime_error("Can't create File Descriptor: " + std::string(strerror(errno)));
}
const foo_t f("hello");
ssize_t written = write(fd, &f, sizeof(f));
std::cout << "wrote " << written << std::endl;
return 0;
}
Compile and run with
g++ try.cpp && valgrind --tool=memcheck --leak-check=yes --show-reachable=yes --num-callers=20 ./a.out
The valgrind error is
==11790== Syscall param write(buf) points to uninitialised byte(s)
==11790== at 0x54ED154: write (write.c:27)
==11790== by 0x1093DE: main (in /home/gri6507/tmp/a.out)
==11790== Address 0x1fff000251 is on thread 1's stack
==11790== in frame #1, created by main (???:)

Answer 1

The right way to serialize a data structure into a chunk of bytes to be written to mass storage is to write a serializer that encodes the data into the desired format. Relying on things not specified by the standard (such as the endianness or type sizes) is simply wrong.
There are plenty of serialization libraries available.

Answer 2

What is the right way to initialize those padding bytes so that valgrind doesn't complain?
I'm not sure about 'the right way' to do this, but there are several possibilities.
you create members for the padding and initialize them
struct bar
{
size_t point_name_size;
char n[MAX];
bool q;
bool unused[7] ={};
};
This 'typically' has the same size as your struct on a 64 bit system. See here.
you fill yourself with 0's if you are trivially copyable
struct bar
{
bar()
{
static_assert(std::is_trivially_copyable_v<bar>);
memset(this, 0, sizeof(bar));
}
size_t point_name_size;
char n[MAX];
bool q;
};