Passing an array of arrays in C

Question

I need to have a function which takes a 2D array and generates random bits, so the result is an array of random binary strings.

I have the following code,

#define pop_size 50
#define chrom_length 50
main() {
    int population[pop_size][chrom_length];
    init_pop(&population);
}
int init_pop(int *population[][]) {
    for(i = 0; i < pop_size; i++) {
        for(j = 0; j < chrom_length; j++) {
            *population[i][j] = rand() % 2;
        }
    }
    return 0;
}

On compilation, I am getting the following error message:

array type has incomplete element type

Any suggestions?

It is usual to write #defines with uppercase to distinguish them easily from regular variables. I know a guy who used to write #defines in lowercase until he spent a whole day looking for a bug for having a #define and a variable named the same. — pmg
– pmg, Commented Dec 9, 2009 at 18:38

John Bode · Accepted Answer · 2009-12-09 16:54:21Z

Time for the usual spiel...

When an array expression appears in most contexts, its type is implicitly converted from "N-element array of T" to "pointer to T", and its value is set to point to the first element of the array. The exceptions to this rule are when the array expression is an operand of either sizeof or the unary & operators, or if it is a string literal being used as an initializer in a declaration.

What does all that mean in the context of your code?

The type of the expression population is "pop_size-element array of chrome_length-element arrays of int". Going by the rule above, in most contexts the expression population will implicitly be converted to type "pointer to chrome_length-element arrays of int", or int (*)[chrome_length].

The type of the expression &population, however, is "pointer to pop_size-element array of chrome_length-element arrays of int", or int (*)[pop_length][chrome_size], since population is an operand of the unary & operator.

Note that the two expressions have the same value (the address of the first element of the array), but different types.

Based on the code you've written, where you call the function as

init_pop(&population);

the corresponding function definition should be

int init_pop(int (*population)[pop_size][chrome_length]) // note that both dimensions
                                                         // must be specified

and you would access each element as

(*population)[i][j] = initial_value;

Note that this means init_pop can only deal with pop_size x chrome_length arrays; you can't use it on arrays of different sizes.

If you call the function as

init_pop(population); // note no & operator

then the corresponding function definition would have to be

int init_pop(int (*population)[chrome_length]) // or population[][chrome_length],
                                               // which is equivalent

and you would access each element as

 population[i][j] = initial_value;

Note that you don't have to dereference population explicitly in this case. Now you can deal with arrays that have different population sizes, but you're still stuck with fixed chromosome lengths.

A third approach is to explicitly pass a pointer to the first element of the array as a simple pointer to int and treat it as a 1D array, manually computing the offsets based on the array dimensions (passed as separate parameters):

init_pop(&population[0][0], pop_size, chrome_length);
...
int init_pop(int *population, size_t pop_size, size_t chrome_length)
{
  size_t i, j;
  ...
  population[i*chrome_length+j] = initial_value;
  ...
}

Now init_pop can be used on 2D arrays of int of different sizes:

int pop1[10][10];
int pop2[15][20];
int pop3[100][10];
...
init_pop(&pop1[0][0], 10, 10);
init_pop(&pop2[0][0], 15, 20);
init_pop(&pop3[0][0], 100, 10);
...

EDIT: Note that the above trick only works with contiguously allocated 2D arrays; it won't work with dynamically allocated arrays where the major dimension and the minor dimensions are allocated separately.

Here's a handy table, assuming a definition of int a[N][M]:

Expression     Type           Implicitly converted to
----------     ----           -----------------------
a              int [N][M]     int (*)[M]
a[i]           int [M]        int *
a[i][j]        int            
&a             int (*)[N][M]

The most verbose answer, and +1 specifically for mentioning pointers-to-arrays (which seem like the best choice given requirements here).
Well done, this deserves a nomination for "Best of StackOverflow"

Martin Beckett · Accepted Answer · 2009-12-09 16:43:51Z

5

You need to tell the compiler all dimensions except the first, when passing arrays as arguments:

int init_pop(int population[][pop_size])
{ 
 ...
}

Yes, this means it's hard to make it completely dynamic and introduces a place where you have to repeat yourself.

UPDATE: I was confused, and had the requirement inverted. Fixed now.

edited Dec 9, 2009 at 16:43

Martin Beckett

96.3k28 gold badges196 silver badges268 bronze badges

answered Dec 9, 2009 at 15:27

unwind

402k64 gold badges492 silver badges620 bronze badges

2 Comments

Robert Gamble Over a year ago

It's kind of scary that this answer was accepted with 3 upvotes given the fact that it is completely wrong. You need to specify all dimensions except the first.

unwind Over a year ago

@Robert: Thanks, and fixed of course. I should have tested it, sorry.

whacko__Cracko · Accepted Answer · 2009-12-09 16:45:50Z

For multidimensional arrays in C/C++ you have to specify all dimensions except the first.I am modifying your program to make it work correctly:

#include <stdio.h>
#include <stdlib.h>
#define pop_size 3
#define chrom_length 3

void init_pop(int population[][chrom_length]) {
 int i,j;
 for(i = 0; i < pop_size; i++) {
      for(j = 0; j < chrom_length; j++) {
            population[i][j] = rand() % 2;
      }
 }
}

/* For Checking */
void display (int population[][chrom_length]){
  int i,j;
 for(i = 0; i < pop_size; i++) {
      for(j = 0; j < chrom_length; j++) {
          printf("%d ",population[i][j]);
      }
      printf("\n");
    }
}


int main(void) {
 int population[pop_size][chrom_length];
 init_pop(population);
 display(population); /* For Checking */

 return 0;
}

If you not going to use global constants here is the correct way of doing it.

dmckee --- ex-moderator kitten · Accepted Answer · 2009-12-09 18:25:31Z

0

This is the problem:

int *population[][]

A multidimensional array is simply a block of continuous memory, and when you say foo[3][2], the compiler finds the right index by 3*last_dimension_size + 2, which means that it has to know the size of all the dimensions except the last one.

So that declaration is an error.

BTW-- There are several very complete discussion of issues related to multidimensional arrays in c already on SO. Try searching under both or either [c] and [c++]

edited Dec 9, 2009 at 18:25

answered Dec 9, 2009 at 16:14

dmckee --- ex-moderator kitten

102k25 gold badges147 silver badges238 bronze badges

Collectives™ on Stack Overflow

Passing an array of arrays in C

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

2 Comments

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related