How to return array from function

We want function which dynamically creates array of integers, so no static declaration is possible because we do not know how big array needs to be.

#include <stdio.h> #include <stdlib.h> int * allocator(int size) { int * array = malloc(size * sizeof(int)); printf ("%p\n", (void*)array); return array; } int main() { int * i = allocator(2); i[0] = 1; i[1] = 2; printf ("%d, %d\n", i[0], i[1]); printf ("%p\n", (void*)i); free(i); return 0; }

We print address of dynamically allocated array in function and in main to be sure it points to the same place and use it to show it is usable. We must use pointer to integer in main because expression

int i[] = allocator(2);

is illegal initializer. It doesn't prevent us from using pointer to integer later as array. Finally we free allocated memory. That what we did is called manual memory allocation and such memory is placed on heap. If we want to use pointer arithmetic we will do something like this:

*i = 1;
*(i + 1) = 2;
printf ("%d, %d\n", *i, *(i+1));

Please note that *(i + 1) is not the same as *i + 1 even if it produces the same output in our example. Dereferencing pointer got higher order of precedence than addition. Because of precedence we are using braces. What if we need two-dimensional array? Two-dimensional array is array of arrays and we will need pointer to pointer.

#include <stdio.h> #include <stdlib.h> int ** allocator(int columns, int rows) { int i; int ** array = malloc(rows * sizeof(int)); printf ("%p\n", (void*)array); for(i = 0; i < columns; i++) array[i] = malloc(columns * sizeof(int)); return array; } int main() { int ** i = allocator(2, 3), j; i[0][0] = 1; i[1][1] = 2; printf ("%d, %d\n", i[0][0], i[1][1]); printf ("%p\n",(void*)i); for(j = 0; j < 3; j++) free(i[j]); free(i); return 0; }

As we see allocating is more complicated and feeing also. It goes in two steps, first we allocate array of rows and after that we allocate arrays of columns. As in previous case we can use array syntax. Now we can go mixing pointer arithmetic and array syntax or go completely pointer arithmetic

*(array+i) = malloc(columns * sizeof(int)); … **i = 1; *(*(i+1)+1) = 2; … *i[0] = 1; *(i[1]+1) = 2; printf ("%d, %d\n", i[0][0], i[1][1]);

Maybe to add that *(*i+1) corresponds to i[0][1]. That was how to do it, now how not to do it. Going heroic and forcing through pointer to array as return type.

typedef int (*array_t)[]; array_t justdont() { static int array[] = { 0, 1}; return &array; } int (*fun())[] { static int array[] = { 0, 1}; return &array; } int main() { int* i = justdont(); printf ("%d, %d\n", i[0], i[1]); printf ("%p\n",(void*)i); i = fun(); printf ("%d, %d\n", i[0], i[1]); printf ("%p\n",(void*)i); return 0; }

This compiles and executes with few warnings, if we change fun return type by adding another pointer int* (*fun())[], that also works. If something looks difficult, like returning address of array, than design needs additional work. For example

int * justdont() { static int array[] = { 0, 1}; return array; }

this is much nicer and easy to understand. Please note that returning static array is perfectly fine and that we do not use free on it. Statically declared variables are allocated automatically and available through execution of program. If we forget to declare array as static than we will return dangling pointer, local variable goes out of scope and returned pointer points to who knows what.