Null vs ZeroMemory

Question

What exactly is the difference between setting an object to NULL and using ZeroMemory?

I hear that it is good practice in the WinAPI (which is mostly C) that a person should use ZeroMemory on C objects. I come from a background of C# and this seems like something a C++ guy should really know.

I found that with the DirectX API, whether you ZeroMemory the objects or not, the application still works, but some samples use ZeroMemory and some don't.

Can anyone clarify these things?

Solution 1

ZeroMemory fills a block of memory with zeros.

Setting pointer to NULL will just make the pointer to points to nothing, and it is is different than filling memory which pointer is pointing to with zeros (you will still be able to access that memory via that pointer, for example).

Before you can do anything useful with that object, it is likely that you will need to replace these zeros with something more meaningful - so that is why both programs that use ZeroMemory or not works.

Reason for ZeroMemory in this context is that you could easily find operations on objects which are not initialized at the point of access (for example, Visual Studio is filling uninitialized memory with 0x0c0c0c0c /* or similar */, so when you encounter this pattern during debugging, you know that object has not been initialized yet).

Solution 2

It's completely different things. ZeroMemory macro fills a block of memory with zeros. Setting pointer to NULL... well it makes it pointing to nowhere.

Examples. Assume you have pointer p to object o of type "Type":

struct Type
{
    int i;
    float f;
    bool b;
};
Type o;
Type* p = &o;

// In memory that will be something like this:
// "o" internals = [010101010001010010110010010010100011001001010000011...]
// "p" address = 0x00830748
//(number of bits and hex adress is just example)

If you ZeroMemory it:

ZeroMemory(&o, sizeof(o));
// ---- or -----
ZeroMemory(p, sizeof(o));

// In memory we will have:
// "o" internals = [000000000000000000000000000000000000000000000000000...]
// "p" address = 0x00830748

All variables inside o is now has value of zero:

cout << o.i; // 0
cout << o.f; // 0.0f
cout << o.b; // false

cout << p->i; // 0
cout << p->f; // 0.0f
cout << p->b; // false

If you NUll-ify pointer:

p = NULL;
// In memory we now have:
// "o" internals = [010101010001010010110010010010100011001001010000011...]
// "p" address = 0x00000000

If now you dereference p you will get undefined behavior:

int a = p->i; // Access voilation reading location 0x00000000

If you NUll-ify object: It will not compile, if Type don't have overloaded operator=()

o = NULL; // error C2679: binary '=' : no operator found 
          // which takes a right-hand operand of type 'int' 
          // (or there is no acceptable conversion)

Applying it to DirectX

When you using DirectX, you must fill-in some structs to pass them to API functions. Here is where the magic. You can ZeroMemoryit to values of 0, which is mostly default ones, and then just fill-in needed values, simplifying your code and keeping you from mistakes with strange values (if you create object and will not set some member variable, it will contain garbage value).

Solution 3

In C and C++, "an object" cannot be set to NULL. Pointers to objects can be set to NULL, which means that the pointer itself points as nothing ("the null object").

This is distinct from setting the contents of an object to "all bits zero", which is what ZeroMemory() does. You can typically only do this for structs, not full-fledged C++ objects which might react very badly.

Solution 4

ZeroMemory() sets the memory with the value 0. That is it will clear the memory. Also setting an object(pointer to the object) to NULL means the base address of that object is initialized to 0.

View more solutions

Comments

[Mark Russ]

Ahh! That makes A LOT of sense! Now I know a good reason for why a person should ZeroMemory.

[saeed]

exactly confirms my idea perfect description

[Mark Russ]

Wow! Great detailed answer! Should a person always ZeroMemory before setting to NULL when the object is POD?

[David Heffernan]

@Mark Why are you obsessed with zeroing things? Call ZeroMemory (or memset(..., 0, ...) if you want to zero memory. Don't if you don't.

[Ivan Aksamentov - Drop]

@Mark Russ No, you shouldn't do it always. But do it if you need to do it =)

[Paul Rubel]

Note that if you're zeroing for security reasons, like password/keys, you want to use SecureZeroMemory() as a regular ZeroMemory can be optimized away in some cases.