3

For example:

struct sth {
    int  t;
    char *p;
    struct sth *next;
}

And the init code:

struct sth *data = malloc(sizeof(*data));
memset(data, 0, sizeof(*data));
data->t = 0;        // A
data->p = NULL;     // B
data->next = NULL;  // C

Since I have used memset, do I still need to write A, B, C?

This is just a sample, I have a struct with lots of pointers...

chqrlie
  • 131,814
  • 10
  • 121
  • 189
vego
  • 889
  • 1
  • 8
  • 20
  • 2
    You are safe -- but note, just because you set each byte to zero, the standard doesn't guarantee that will make the pointers `NULL` (though it does on any compiler I've tested with -- but from the pedantic standpoint you would need to check) On the other hand, to be fully compliant, it costs little to leave your initialization of pointers to `NULL`. Above, you could simply allocate with `calloc` to accomplish the same thing. – David C. Rankin Apr 13 '20 at 07:10
  • You can omit the `memset()` by allocating with `struct sth *data = calloc(1, sizeof(*data));` – chqrlie Apr 13 '20 at 09:56

4 Answers4

3

No need. You can also use the calloc() instead of the malloc(), it will set memory to zero without requiring an additional call to the memset() and may be faster.

bobah
  • 18,364
  • 2
  • 37
  • 70
2

"Do I still need to set ptr to NULL if I use memset() earlier?"

If you want your program to be fully standard-compliant, then yes, as memset() set each byte to 0, which is different to setting NULL to a pointer. (Assuming ptr is equivalent to p inside of the structure sth).

Quote from the current C standard ISO:IEC 9899:2018 (C18), Section 7.22.3.5/2 - The calloc function:

"The space is initialized to all bits zero. 302)"

"302 - Note that this need not be the same as the representation of floating-point zero or a null pointer constant."

"Since I have used memset(), do I still need to write A, B, C"?

A. is redundant, as soon as t is not an object of floating-point type as those can have a floating-point zero value, which may not have all bits set to 0. If t were f.e. of type float or double A. would be useful and appropriate to be standard conform.

B. and C. are appropriate, since according to the standard setting each byte to 0 does not necessarily also set the pointers to NULL, if you explicitly want to have them assigned to NULL (although it should on most systems).

Note that calloc() might be more convenient and also faster in performance as it allocates memory and immediately initialize each bit of it to 0:

struct sth *data = calloc(sizeof(*data));

But again here, p and next do not need to be NULL.

Community
  • 1
  • 1
RobertS supports Monica Cellio
  • 14,524
  • 7
  • 33
  • 80
0

A simpler version is:

struct sth *data = malloc(sizeof(*data));
*data = (struct sth){0};

Your compiler can optimize this to a calloc call if the platform has all-bits-zero for the struct members .

M.M
  • 138,810
  • 21
  • 208
  • 365
0

Setting the structure to all bits zero with memset() effectively sets all integer members to 0. The C Standard specifies that other members will have a value which may or may not correspond to the effect of setting them to 0 manually. But on all current architectures it is the case, and it seems extremely unlikely that any new processor will depart from this convention in the future. So in practice you are safe.

Note also that you should use calloc() to allocate a object initialized to all bits zero:

struct sth *data = calloc(1, sizeof(*data));
chqrlie
  • 131,814
  • 10
  • 121
  • 189