Question

I have another memset question. It appears as if the code I am editing may have some issues (or it’s not done the same way in different files)

A::LRM las[9]; //A and LRM are both structures with BOOLS and INTS
memset(&las, 0, sizeof(las));

typedef Sec SecArray[16];
SecArray rad_array;
memset(rad_array, 0, sizeof(SecArray));

The second example appears to be correct because rad_array is the same as the first position in the array. Then the sizeof(SecArray)) would make sense. The first one doesn’t seem correct to me. All structs are just BOOLs and INTS nothing dynamic in them.

My understanding from my other post about memset was that it followed this format.

memset("pointer to object", "what to set it to", "size of object")

Can anyone tell me what exactly is going on here if I am incorrect with my theory.

Answer 1

Both calls to memset are correct. Both sizeof(las) (or just sizeof las) and sizeof(SecArray) will return the size of the entire array.

If you are worried about the first argument, then again, both will work. The pointer to the entire array (&las) or the pointer to the first element (rad_array in this context) will work equally well with memset.

In general, with regard to sizeof usage, I would recommend using the first approach, since it is type-independent. A good programming practice is to avoid mentioning type names in your statements, i.e. keep type names restricted to declarations as much as possible.

As for the first argument, in case of an array it is a matter of preference, but in general I would say that if you have an object of type T

T t;

and you want to fill it with zeros by using memset, you’d normally do it as

memset(&t, 0, sizeof t);

I don’t see why an array should be an exception from that rule (especially if the exact nature of the type is hidden behind a typedef-name). The above memset(&t, ... will work regardless of whether T is an array type, a struct type or any other type. I don’t see why one should suddenly drop the & just because T is an array type. Quite the opposite, I’d keep that & to keep the code as type-independent as possible.

Finally, in C++ in both cases the better way to do it would be not to use memset at all and just do

A::LRM las[9] = {};
SecArray rad_array = {};

instead.