返回指向结构数组的指针

Question

Let's say I have to create an array of structs that is allocated on the heap and return a pointer that points to this array of structs.

typedef struct Pair {
    int x;
    int y;
} Pair;

Pair** foo(int n, int m, int length)
{
    Pair* arr = malloc(sizeof(*arr) * length);

    for (int i = 0; i < length; ++i) {
        arr[i].x = n++;
        arr[i].y = m++;
    }

    return &arr;
}

When I compile a program containing this function, it warns me that I am returning the address of a local variable. I assume this is because the pointer is initialised within the function (ie on the stack), therefore it counts as a local variable.

When I compile it, ignoring this warning, and run it anyway, the program crashes when the returned pointer is accessed.

I have tried allocating the pointer dynamically:

Pair** ptr = malloc(sizeof(**ptr));
ptr = &arr;
...
return ptr;

but the program still crashes when this pointer is accessed. How can I create this array within a function and return a pointer to this array so that it can be safely accessed?

Answer 1

This array is initialized on the stack but the pointer ( arr ) is a local variable, so the caller, main , cannot access it. You do not need to use the address of the pointer. You can access the array with the pointer itself.

Pair* foo(int n, int m, int length)
{
    Pair* arr = malloc(sizeof(*arr) * length);

    for (int i = 0; i < length; ++i) {
        arr[i].x = n++;
        arr[i].y = m++;
    }

    return arr;
}

Answer 2

If you want an array of structs, the code:

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int x;
    int y;
} Pair;

static Pair* foo(int n, int m, int length)   {
    Pair* arr = malloc(sizeof(*arr) * length);
    for (int i = 0; i < length; ++i) {
        arr[i].x = n++;
        arr[i].y = m++;
    }
    return arr;
}

int main(void) {
    Pair *z = foo(111, 222, 3);
    for (int i = 0; i < 3; ++i) 
        printf("z[%d]= { %d, %d }\n", i, z[i].x, z[i].y);
    free(z);
    return 0;
}

gives the output:

z[0]= { 111, 222 }
z[1]= { 112, 223 }
z[2]= { 113, 224 }

Answer 3

If you want an pointer to an array of structs, you can change your function signature from Pair** to be Pair* .

---

If you still want an pointer to an array of pointers, then allocate memory for a Pair struct for each index of arr .

for(int i = 0; i < length; ++i){
    arr[i] = malloc(sizeof(Pair));
    ...
}

Instead of returning &arr , you can declare arr as

Pair** arr = malloc(sizeof(Pair*) * length);

Answer 4

Because arr is a local variable, it will be free when foo end. So you don't have access for arr after. To solve this you should declare array pointer in heap:

     Pair** foo(int n, int m, int length)
     {
           Pair ** arr = (Pair**)malloc(sizeof(Pair*));
           *arr = malloc(sizeof(Pair) * length);

           for (int i = 0; i < length; ++i) {
               (*arr)[i].x = n++;
               (*arr)[i].y = m++;
           }

            return arr;
       }