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?

Answer 1

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]