What does memset(foo->a+foo->b, 0, 10) mean? - c

Question

I have this piece of code in one library I'm using and I'm wondering what it does, since I'm having problems with memory I suppose this is the reason.
So the piece of code is following:
int new_size = foo->a_size + 10;
foo->a = realloc(foo->a, new_size*sizeof(struct items));
memset(foo->a+foo->a_size, 0, 10);
foo->a is type struct items* and foo->a_size is type int.
First lines reallocate 10 blocks of new memory but now I'm wondering if memset() sets both foo->a and foo->a_size to 0 or should this set blocks from 11-20 to 0 in foo->a?
I have tried to run this code block on its own and receive only Segmentation fault
EDIT:
Question was that does the memset() set both foo->a and foo->a_size to 0 or does it set blocks from offset foo->a_size to 0 in foo->a. The latter assumption was correct but I need to also fix the memset() so the last argument is 10 * sizeof(struct items). I also edited variable names from foo->b to foo->a_size.

Answer 1

You are initializing 10 Bytes in foo->a(pointer) with foo->b(int) offset. In the other words you just initialized appended memory.
Example:
Lets assume foo->a is int* and is pointing to 5 ints continuous block.
+---+---+---+---+---+
| 0 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+
You need 10 ints, so you will realloc that block to size 10 * sizeof(int) Bytes, but appended 5 * sizeof(int) Bytes are uninitialized.
+---+---+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 | 0 | ? | ? | ? | ? | ? |
+---+---+---+---+---+---+---+---+---+---+
So by doing
memset(pointerToFirstByte + Offset, 0, 5 * sizeof(int));
You will init these appended bytes to 0.
+---+---+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+---+---+---+---+---+
^---^---^---^---^------ Initialized to 0

Answer 2

The line in question sets 10 bytes starting with an offset by foo->b from foo->a to 0. The offset is in steps the size of the structure items. We don't have enough information to further explain this, but my speculation is that foo->a is a pointer to a dynamically allocated array of the structure and here we are setting the fields of part of it(possibly one element?) to 0.

Answer 3

So these 2 lines increase foo->a by 10 lots of whatever struct items is.
int new_size = foo->b + 10;
foo->a = realloc(foo->a, new_size*sizeof(struct items));
This sets 10 bytes of memory of foo->a offset by foo->b * sizeof(struct items) to 0
memset(foo->a+foo->b, 0, 10);
which isn't probably enough as it's unlikely struct items is just 1 byte in size. What you should be doing is clearly 10 lots of struct items like this.
memset(foo->a+foo->b, 0, 10*sizeof(struct items));

Answer 4

The memset in the code fragment initializes 10 bytes in the newly allocated part of foo->a to 0. There are multiple problems in this code:
You do not test for realloc() failure.
You overwrite foo->a with the return value from realloc(). If realloc() fails, the block previouly pointed to by foo->a is still allocated but potentially unreachable, a memory leak.
The space set to 0 is most probably too small.
Initializing to all bits 0 might not be appropriate for the structure items.
You do not update foo->size.
Here is an improved version:
size_t new_size = foo->a_size + 10;
struct items *newp = realloc(foo->a, new_size * sizeof(*foo->a));
if (newp == NULL) {
// handle the error
} else {
memset(newp + foo->a_size, 0, (new_size - foo->a_size) * sizeof(*foo->a));
foo->a = newp;
foo->a_size = new_size;
}

Answer 5

memset(foo->a+foo->b, 0, 10);
This line sets the 10 Bytes of Foo->a to 0.
foo->a + foo->b is a offset value in it.