Zeroing out a struct in the constructor

Question

A wide range of structures is used in Win32 programming. Many times only some of their fields are used and all the other fields are set to zero. For example:

STARTUPINFO startupInfo; // has more than 10 member variables
ZeroMemory( &startupInfo, sizeof( startupInfo ) ); //zero out
startupInfo.cb = sizeof( startupInfo ); //setting size is required according to MSDN
startupInfo.dwFlags = STARTF_FORCEOFFFEEDBACK;
//Now call CreateProcess() passing the startupInfo into it

I want to stop copy-pasting such code and instead use an abstraction that would care about zeroing and setting parameters. Let's presume I only need the struct initialized as in example, and no other tuning is ever needed. Is the following a good solution? What are possible problems?

class CStartupInfo : public STARTUPINFO {
public:
   CStartupInfo()
   {
       ZeroMemory( this, sizeof( STARTUPINFO ) );
       cb = sizeof( STARTUPINFO );
       dwFlags = STARTF_FORCEOFFFEEDBACK;
   }
};

I'm in particular concerned about the ZeroMemory() call - looks like I fully control the code and the class has no vtable and calling ZeroMemory() this way is safe and there's no big difference between the two code snippets except that the latter provides an abstraction. Are there any caveats?

Answer 1

Instead of subclassing, why not create a function instead?

STARTUPINFO CreateStartupInfo( DWORD flags ) {
  STARTUPINFO info;
  ZeroMemory(&info, sizeof(info));
  info.cb = sizeof(STARTUPINFO);
  info.dwFlags = flags;
  return info;
}

True this can put a non-trivial sized struct on the stack. If the compiler in question does Named Return Value Optimization (link) there will only be one copy created. But in any case, your example you already had once instance and temporarily putting a second is unlikely to cause major problems.

I usually only subclass a struct if there is a resource that is not properly managed in the struct. Typically it's to implement an RAII model. In your particular example no extra resource management is occurring so I would avoid the subclass and just use a function.

Answer 2

You can create special wrappers of types that behave like ordinary types, but initialized with zeros, like:

class zbool {
private:
  bool value;
public:
  zbool(const bool value) { ... }
  operator bool() { ... }
  // ... code skipped
};

And then use such types:

struct MyStruct {
  zbool deleted;
};

Of course this won't work if you trying to initialize external structures.

Answer 3

For structures you can do:

STARTUPINFO startup_info = { sizeof(STARTUPINFO), 0 };
startup_info.dwFlags = STARTF_FORCEOFFFEEDBACK;

which I find is a neat trick to initialise these sort of structures. However the catch is that the cb (or size/length) field must be the first one in the structure. You could also just do the extended version if need be:

STARTUPINFO startup_info = { 0 };
startup_info.cb = sizeof(STARTUPINFO);
startup_info.dwFlags = STARTF_FORCEOFFFEEDBACK;

If you want to wrap the structures with a class I'd recommend you try ATL/WTL first since the structures you're wrapping might already exist as classes there.

If you were still keen on creating your own class I would suggest that you create a constructor that takes every element of the structure in order, with default parameters specified, so that it's easier to change those values later on.

Answer 4

You can use a template:

template <class T>
class selfzero : public T
{
public:
    selfzero() {
     ZeroMemory( this, sizeof( selfzero<T> ));
    };
};

and then:

{
 selfzero<STARTUPINFO> si;
}

The caveat: use this on a class or struct that has a vtable or got a vtable later, and it will go bang.

Answer 5

I've used tonj's suggestion, but since it kills intellisense to often, I ended up prefering this:

template <typename T>
T& ZeroInit(T & data) 
{ 
  ZeroMemory(&data, sizeof(data)); 
  return data;
}

template <typename T>
T& ZeroInitCB(T & data) 
{ 
  ZeroMemory(&data, sizeof(data)); 
  data.cb = sizeof(data); 
  return data;
}

Compared to selfzero<> It's another line in the normal case:

STARTUPINFO si;
ZeroInitCB(si);

But - as said - I opted for helping intellisense ;)

The return T& sometimes allows chaining, but I am not using it that often.

Answer 6

I think this is a fine way to make such structures more bulletproof. I'm not sure why others seem to not like the technique. I use it occasionally, but not as often as I otherwise might because it doesn't seem to be very well liked by coworkers for some reason.

I don't see it used in published material very often - the only one I could find in a quick Google right now is an article by Paul DiLascia in MSJ August 1997 (http://www.microsoft.com/MSJ/0897/C0897.aspx):

CRebarInfo and CRebarBandInfo are programmer-friendly C++ versions of the C structs REBARINFO and REBARBANDINFO, with constructors that initialize the objects to all zeroes before setting the cbSize member appropriately.

I can't think of much in the way of drawbacks (except the lack of acceptance). If anyone else can point to something more concrete, I'd appreciate it.

Answer 7

To improve on TonJ's solution:

template <class T>
class selfzero : public T
{
public:
    selfzero() {
        ZeroMemory( (T*) this, sizeof( T ));
    };
};

Zeroes T, not selfdata. Even safe in cases of multiple inheritance, vtables and the likes. The T structure must be allocated contiguously in memory, and ((T*) this) is properly adjusted for other base classes and vtables.

Answer 8

if all the nonstatic data members of the struct have trival constructors your class has a trivial constructor that is going to intialize members to their default values. Most of the time the exact same as zeroing the struct on purpose. So while might be "good" practice to zero them for initialization, most of the time there won't be any need.