Updating a pointer to a c array from a function

Question

Say I have a function called array_push in c.

void array_push(int *array_pointer, int array_length, int val) {
    int i;
    int *temp_array = malloc(sizeof(int) * (array_length + 1));

    for (i = 0; i < array_length; i++) {
        temp_array[i] = *array_pointer;
        array_pointer++;
    }

    temp_array[array_length] = val;
    *array_pointer = temp_array;
}

How can I update the pointer *array_pointer so that it points to temp_array and other parts of my program can use the new array? Allowing me to do something like

int t[2] = {0,2};
array_push(t, 2);
/* t should now contain {0,2,3} */

You can't do this. t is not a pointer, it's an array, you can't change the size of an array. — Barmar
– Barmar, Commented Apr 6, 2013 at 6:13
@Barmar - you're absolutely correct. I didn't notice that part of the OP's question at first... — paulsm4
– paulsm4, Commented Apr 6, 2013 at 6:50

NPE · Accepted Answer · 2013-04-06 06:23:30Z

You need to turn array_pointer into a pointer-to-pointer:

void array_push(int **array_pointer, int array_length, int val) {

(note the extra asterisk).

Also, you'll need to change the call site so that t is a pointer, not an array (you can't make an array point someplace else). Finally, to make the caller aware of the new size of the array, array_length also needs to be passed by pointer.

Thus, the overall structure of your code could be something like:

void array_push(int **array_pointer, int *array_length, int val) {
    int *temp_array = malloc(sizeof(int) * (*array_length + 1));
    memcpy(temp_array, *array_pointer, sizeof(int) * *array_length);
    temp_array[(*array_length)++] = val;
    free(*array_pointer);
    *array_pointer = temp_array;
}

int main() {
    int n = ...;
    int* t = malloc(sizeof(int) * n);
    /* ... */
    array_push(&t, &n, 2);
    /* ... */
    free(t);
}

Note how I've allocated t on the heap, and have freed *array_pointer inside array_push(). With this in mind, much of the array_push()'s logic can be simplified by using realloc():

void array_push(int **array_pointer, int *array_length, int val) {
    *array_pointer = realloc(*array_pointer, sizeof(int) * (*array_length + 1));
    (*array_pointer)[(*array_length)++] = val;
}

@Barmar: I know. I am working my way towards it (the answer is still work in progress).

autistic · Accepted Answer · 2013-04-06 06:32:59Z

There are two problems here: You seem confused about pass-by-value, but the more significant problem is that you seem confused about pointers. int *array_pointer array_pointer points to an int, not an array. It may be that it points to the first int in an array. On an unrelated note, a "pointer to an int array" looks like: int (*array_pointer)[array_length].

Back to the point: int *array_pointer array_pointer points to an int. In *array_pointer = temp_array;, the expression *array_pointer gives you the object pointed to, which can store an int. temp_array isn't an int value, though.

I can see that you're attempting to work around the issue that changes made to array_pointer aren't visible to the caller, due to the semantics of pass-by-value. Hence, you need to change array_pointer so that it points to an int * that the caller supplies, so that you're modifying the caller's int *, or use the return type to return the new pointer. As it turns out, both of these options solve both of your problems.

paulsm4 · Accepted Answer · 2013-04-06 06:49:52Z

PROBLEM 1:

If you want to create or modify an *int array inside of a function, then you need to pass a "pointer to a pointer":

// WRONG:
void array_push(int *array_pointer, int array_length, int val) {
...
    int *temp_array = malloc(sizeof(int) * (array_length + 1));
...
    *array_pointer = temp_array;

Instead:

// BETTER:
void array_push(int **array_pointer, int array_length, int val) {
...
    int *temp_array = malloc(sizeof(int) * (array_length + 1));
...
    *array_pointer = temp_array;

Or:

// BETTER YET:
int * array_push(int array_length, int val) {
...
    int *temp_array = malloc(sizeof(int) * (array_length + 1));
...
return temp_array;

PROBLEM 2:

If you want to declare a static array like this int t[2] = {0,2};, then you can't arbitrarily change it's size. Here's a good description of "arrays vs pointers":

http://faq.cprogramming.com/cgi-bin/smartfaq.cgi?answer=1069897882&id=1073086407

One of the first things a new student learns when studying C and C++ is that pointers and arrays are equivalent. This couldn't be further from the truth...

Collectives™ on Stack Overflow

Updating a pointer to a c array from a function

3 Answers 3

2 Comments

Comments

Comments

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Related