Take the 2-minute tour ×

How can I make a function which returns an array? I tried this

const int WIDTH=11;
const int HEIGHT=11;

int main() {
  char A[WIDTH][HEIGHT];
  return 0;

// Initializes a random board.
char[][] rand_grid(int i, int k) {
  char* A[i][k];
    for(l=0;l<k;++l) {
  return A;

// Returns a random number from the set {0,...,9}.
int ran(int i) {
  srand((unsigned int) time(0));
share|improve this question
Don't call srand() more than once in your program: that will unnecessarily slow your program down and, most importantly, it will lower the randomness of the rand() function. –  pmg Sep 21 '09 at 8:57

5 Answers 5

up vote 69 down vote accepted

Several things to point out.

First of all, you cannot assign an array object as you do here:

char A[WIDTH][HEIGHT];  

Objects of array type are not modifiable.

Secondly, functions in C cannot return array types. They can return pointers to arrays, though:

char (*foo(int width))[HEIGHT]
   * dynamically allocate memory for a widthxHEIGHT array of char
  char (*newArr)[HEIGHT] = malloc(sizeof *newArr * width);
   * initialize array contents here
  return newArr;

The syntax is a little confusing; it reads as

       foo                                   -- foo
       foo(int width)                        -- is a function
                                             -- taking an int parameter
      *foo(int width)                        -- returning a pointer
     (*foo(int width))[HEIGHT]               -- to a HEIGHT-element array
char (*foo(int width))[HEIGHT]               -- of char

For C89, HEIGHT in the above snippet must be a compile-time constant integral expression (either a macro, a numeric literal, or an arithmetic expression consisting of macros and/or numeric literals). I'm not sure if that's also true for C99.

Based on the snippet you've posted, what you want to do is to take an array you've already allocated and initialize its contents. Remember that in most contexts, an expression of an array type will implicitly be converted to a pointer to the base type. IOW, if you pass an N-element array of T to a function, what the function actually receives is a pointer to T:

void foo (T *p) {...}
T arr[N];

For 2-d arrays, it's a little uglier:

void foo (T (*p)[M]) {...}
T arr[N][M];

This also relies on M being known at compile time, which limits the function's usefulness. What you'd like is a function that can deal with a 2-d array of arbitrary size. The best way I know of to accomplish this is instead of passing a pointer to the array, pass the address of the first element in the array[1], and pass the number of rows and columns as separate parameters:

void foo(T *base, size_t rows, size_t cols) {...}
T arr[N][M];
foo (&arr[0][0], N, M);

So your rand_grid function would look something like this:

void rand_grid(char *base, size_t rows, size_t cols)
  size_t i, j;
       * Since base is a simple char *, we must index it
       * as though it points to a 1-d array.  This works if
       * base points to the first element of a 2-d array,
       * since multi-dimensional arrays are contiguous.  
      base[i*cols+j] = initial_value();

int main(void)
  char A[WIDTH][HEIGHT];
  rand_grid(&A[0][0], WIDTH, HEIGHT);

  1. Even though the expressions &A[0][0] and A yield the same value (the base address of A), the types of the two expressions are different. The first expression evaluates to a simple pointer to char (char *), while the second evaluates to a pointer to a 2-d array of char (char (*)[HEIGHT]).
share|improve this answer
This response is amazingly educational. Thank you! –  JohnK Jun 21 '13 at 1:57
Would a C++ function that returns an array have to use a similar approach? (slightly out of the scope of the question I know, but not different enough to ask a new one) –  Ajay Aug 5 '14 at 18:11

You can't. You can either pass pointer to array as a parameter and have function modify it, or the function itself can allocate data and return pointer.

in your case

void rand_grid(char A[WIDTH][HEIGHT]) {
    A[0][0] = 'A'; // or whatever you intend to do

main() {
    char A[WIDTH][HEIGHT];

Edit: As caf pointed out one can actually return the struct with an array in it, but of course no c-programmer in their right mind would do that.

share|improve this answer
You can actually return the array by value by wrapping it within a struct, but it's a very bad idea. –  caf Sep 21 '09 at 8:41
Thanks. I was wondering how to solve the following problem: I need a grid filled with random integers. I want that the initialization of an array is not on the main function as it would be useful in the rest of the program. How can I use pointers to solve the problem? –  Jaska Sep 21 '09 at 8:47
Jaska, you should make this sub-question as a separate one, i.e. a new question on stackoverflow. –  Frank Grimm Sep 21 '09 at 8:51
Provided that array dimensions are set at compile time you can use the code snippet from my answer. It is effectively a passing of pointer. –  Michael Krelin - hacker Sep 21 '09 at 8:54
Why is it a bad idea to return an array within a struct? Packing small arrays into structs isn't uncommon. It is probably faster and surely easier than mallocing memory and returning a pointer to it. –  Johannes Schaub - litb Sep 23 '09 at 17:38

You can never return a stack-allocated ("auto") variable of something other than a primitive (value) type, and structs of such. For other types, you need to allocate the memory from the heap, using malloc(), or wrap the (fixed-size) array into a struct.

If you're using a fixed-size array, you can model it as a struct and use struct-return:

#define WIDTH  11
#define HEIGHT 11

typedef struct {
  unsigned char cell[WIDTH * HEIGHT];
} Board;

Board board_new(void)
  Board b;
  size_t i;

  for(i = 0; i < sizeof b.cell / sizeof *b.cell; i++)
    b.cell[i] = rand() & 255;
  return b;

This is fine, and should not be more costly than the alternative, of using an explicit pointer:

void board_init(Board *b);

Since the former case of struct-return can be rewritten (by the compiler) to the latter. This is called return value optimization.

share|improve this answer
That's just not true - you can return struct types, which are decidedly non-primitive. It is not a great idea, though. –  caf Sep 21 '09 at 8:38
But struct types will be copied from the stack into a (hidden) local variable near the caller. It could work if the array was defined to be fixed-size so the compiler knows the size of the return structure/array. But it doesn't. It's a dynamic array... –  Wim ten Brink Sep 21 '09 at 8:53
malloc() isn't the only way to allocate memory. You can have static variable within a function –  qrdl Sep 21 '09 at 8:56
Alex, there's no requirement for the array to be dynamically sized. –  Michael Krelin - hacker Sep 21 '09 at 9:00
@caf, Alex: thanks, I forgot about struct return. Fixed now. –  unwind Sep 21 '09 at 9:06

If you really want to do that you can try making the array A static, this way the storage for A is not determined by the scope of function and you can actually return the array(in form of pointer of course).

But this is not a good way to do accomplish what you are trying to achieve, instead pass the array to function rand_grid . Thats what pass by address is meant for.

share|improve this answer
There's no such thing as "pass by address" in C. I'm sure you mean That's what passing the (value of the) array address is meant for. –  pmg Sep 21 '09 at 9:21
yes i meant the same.. –  sud03r Sep 21 '09 at 9:38

All methods of which I am aware to return an array from a function have weaknesses and strengths.

Wrapping in a struc avoids the overhead of allocating and freeing memory, as well as avoids remembering to free. You have those problems on any solution that uses malloc, calloc, and realloc. On the other hand, wrapping in a struct requires knowing the maximum possible size of the array, and is decidedly wasteful of memory and execution time for large arrays (for example, loading a file into memory and passing the file contents around from function to function by copying).

share|improve this answer

Your Answer


