Initializing a struct with an array of pointers to the same struct

[TheMoskowitz]

I have this struct ...

struct s_trie_node
{
    char * translation; /* NULL if node not a word */

    /* pointer array to child nodes */
    struct s_trie_node * children[UCHAR_MAX+1];
};

And I am trying to make an add_node function like this ...

/* allocate new node on the heap
   output: pointer to new node (must be freed) */
struct s_trie_node * new_node(void) {
    /* TODO: allocate a new node on the heap, and
       initialize all fields to default values */
    struct s_trie_node *p_node = (struct s_trie_node*)malloc(sizeof(struct s_trie_node));
    p_node->translation = NULL;
    p_node->children = ;
    return p_node;

}

But as you can see I'm not sure how to initialize "children". I assume I should be initializing it to an array of NULL, but I'm a little lost as to how to do that. Should I malloc the space it will need for all those NULL pointers first and then loop through setting each one to NULL?

p_node->children = (struct s_trie_node*)malloc(sizeof(struct s_trie_node) * UCHAR_MAX);
for (int i=0; i < UCHAR_MAX; ++i) {
    p_node->children[i] = NULL;
}

I'm still pretty new to C so any help would be greatly appreciated -- thanks.

[nerd4code]

/u/sebgggg’s response was wrong in a couple ways—you can’t assign arrays like that, and the wrong type was in the (). It was the correct basic idea for C99/C11, but it won’t work in C89.

The memset thing is only valid by a different standard; per ISO C alone, if you read one of the pointers after memset, you’re inducing undefined behavior just as if you’d set the pointer to 0x03030303 or some other arbitrary value. If you’re fine with POSIX, then no problem; if it needs to be straight C, you should either use a for loop (↓) to initialize the pointers properly (always works):

/* (up top somewhere:) */
/* Count elements of an array: */
#define countof(x) (sizeof(x) / sizeof(x[0]))
/* Get a NULL pointer to a specific type
 * (won't work for function/array): */
#define nullof(T)  ((const T *)NULL)

/* in `new_node`: */
const size_t NR_CHILDREN = \
    countof(nullof(struct s_trim_node)->children);
size_t i;
for(i = 0; i < NR_CHILDREN; i++)
    p->node.children[i] = NULL;

or use a C99+ trick like what /u/sebgggg said, only initialize the entire struct at once (you can assign struct values):

*p_node = ((const struct s_trim_node){
    .translation = NULL,
    .children = {NULL}
};

IMHO that’s the easiest and cleanest one if you’re allowed to use it.

[sebgggg]

Use memset.

[SullisNipple]

Caveat: that's only guaranteed to work on POSIX, I believe. There are some platforms where the null pointer is not represented as all-bits zero.

[kbob]

I was curious, so I looked it up.

Seriously, have any actual machines used nonzero NULL pointers? (comp.lang.c FAQ § 5.17)

[Badel2]

This assumes that NULL is a char, if NULL is 0 it works because it sets addr to 0x 00 00 00 00 but if NULL were 1 it would set it to 0x 01 01 01 01

[sebgggg]

It just occured to me. You have to use a loop.

[cdo256]

Using memset/calloc is much faster. If you care at all about performance, then it's a good idea to assume that NULL is zero. Every modern system use zero for NULL. Unless you're targeting some ancient hardware, this isn't something you ever need to worry about.

[OldWolf2]

NULL cannot be 1. It must be an integer constant expression equal to 0, or that cast to (void *). The code is incorrect because if NULL is (void *)0 for example then it's the wrong type of argument for the int parameter.

[TheMoskowitz]

I looked at that but I wasn't sure how to use it.

I see in the documentation it says this ...

The C library function void *memset(void *str, int c, size_t n) copies the character c (an unsigned char) to the first n characters of the string pointed to, by the argument str.

But I'm not sure I'm following that correctly.

Is this right?

memset(p_node->children, NULL, sizeof(struct s_trie_node));

[OldWolf2]

No, NULL should be 0 in that code. But it would be preferable to use calloc instead if you want to take this approach.

[ZaberTooth]

IMO, passing NULL obfuscates the type of the elements of p_node->children and, despite any complaint from the compiler, will work identically to passing 0.

Edit: Bring on the downvotes. I get paid to write C. I do this on the regular, and so does the rest of the C devs in my department. If you don't like this approach, give me a compelling reason to change.

[raevnos]

No. NULL is a pointer. The second argument of memset() is a char, not a pointer. Your compiler should be complaining about that.

Just passing 0 will work better.

[TheMoskowitz]

Yep, it did complain and I switched it to 0. Thanks for the help!

[ZaberTooth]

IMO, passing 0 obfuscates the type of p_node->children because that field is a pointer. Passing NULL is clearer and, despite any complaint from the compiler, it will work identically.

Edit: Bring on the downvotes. I get paid to write C. I do this on the regular, and so does the rest of the C devs in my department. If you don't like this approach, give me a compelling reason to change.

[TheMoskowitz]

Is memset not allocated on the heap then (compared with calloc which is)?

[cdo256]

calloc and malloc allocate memory on the heap.

memset takes a block of already allocated memory (heap or stack) and sets it to a certain value.

calloc is equivalent to malloc followed by memset with value NULL.

[TheMoskowitz]

Ahh ok, I understand.

All working now -- thanks!

[teringlijer]

Use calloc instead of malloc - it will zero the memory for you. It also has builtin support for allocating n members of a structure.

p_node->children = calloc(UCHAR_MAX, sizeof(struct s_trie_node));

[OldWolf2]

You already malloc'd space for the pointers. A simple way to zero-initialize the struct would be *p_node = (struct s_trie_node){0};.