Derefernecing a pointer changes its value - c

Question

I was trying to implement rust-style vectors in c, which is defined as
typedef struct
{
int *ptr, // pointer to starting element
int len, // length of the vector
int cap, // capacity; it does not reallocate the whole vector till len == cap
} vector;
I got almost everything working, except the get-value function. Calling vec_getval function always changes the 3rd and 4th elements to 1936877926 and 10 respectively, no matter the length of the vector. Here is all the relevant code with error checking omitted:
#define ELEMENT_SIZE sizeof(int)
extern vec_data vec_getval(vector *vec, size_t index)
{
return *(vec->ptr + (ELEMENT_SIZE * index));
}
extern void vec_push(vector *vec, vec_data val)
{
if (vec->len < vec->cap) // Don't reallocate if length < capacity
{
*(vec->ptr + (ELEMENT_SIZE * vec->len)) = val;
vec->len++;
return;
}
realloc(vec->ptr, ELEMENT_SIZE * (vec->len + 1));
*(vec->ptr + (ELEMENT_SIZE * vec->len)) = val;
vec->len++;
vec->cap++;
}
extern void vec_with_capacity(vector *vec, size_t cap)
{
vec->ptr = (int *)malloc(ELEMENT_SIZE * cap);
vec->cap = cap;
vec->len = 0;
}
int main(int argc, char **args)
{
vector vec;
vec_with_capacity(&vec, 5);
vec_push(&vec, 50u);
vec_push(&vec, 15u);
vec_push(&vec, 40u);
vec_push(&vec, 80u);
vec_push(&vec, 70u);
printf("first value\t: %d\n", vec_getval(&vec, 0)); // Works as expected, but changes 3rd and 4th elements
printf("third value\t: %d\n", vec_getval(&vec, 2)); // Does not work fine!
return 0;
}
And here's the output:
first value : 50
third value : 1936877926

Answer 1

For any pointer or array p and index i, the expression *(p + i) is exactly equal to p[i].
Now if we do this transformation of *(vec->ptr + (ELEMENT_SIZE * index) we get vec->ptr[ELEMENT_SIZE * index]. Which is probably not what you had in mind.
Assuming that sizeof(int) (what ELEMENT_SIZE expands to) is 4 (very common) then attempting to use index 2 will actually use index 8 (4 * 2). Which is out of bounds of your allocated memory (as it only contains 5 elements), and leads to undefined behavior.
The solution is simple: Don't multiply with ELEMENT_SIZE when accessing elements of your array.
You have another two very serious errors as well:
realloc(vec->ptr, ELEMENT_SIZE * (vec->len + 1))
*(vec->ptr + (ELEMENT_SIZE * vec->len)) = val;
Because the first line is missing the semicolon, the statement becomes
realloc(vec->ptr, ELEMENT_SIZE * (vec->len + 1)) * (vec->ptr + (ELEMENT_SIZE * vec->len)) = val;
And that doesn't make any sense.
The second problem, besides the missing semicolon, is that realloc can allocate a new memory area, which it then returns a pointer to. That would make the old pointer invalid as it then points to memory that you no longer own. Always use what realloc returns.
But also note that realloc can return NULL, in which case the old pointer remains valid, so always use a temporary variable:
int *new_ptr = realloc(vec->ptr, ELEMENT_SIZE * (vec->len + 1));
if (new_ptr == NULL)
{
// TODO: Handle error
}
vec->ptr = new_ptr;
vec->ptr[vec->len] = val;