Prototype for variable-length arrays

Question

I am trying to write a function that takes an array of an variable size in c.

void sort(int s, int e, int arr[*]){
    ...
}

It says that for variable length arrays, it needs to be bounded in the function declaration. What does that mean? I am using xcode 4.0, with the LLVM compiler 2.0.

Thanks for the help.

Answer 1

As I see that no one answers the real question, here I give mine.

In C99 you have variable length arrays (VLA) that are declare with a length that is evaluated at run time, and not only at compile time as for previous versions of C. But passing arrays to functions is a bit tricky.

A one dimensional array is always just passed as a pointer so

void sort(size_t n, int arr[n]) {

}

is equivalent to

void sort(size_t n, int *arr){

}

Higher dimensions are well passed through to the function

void toto(size_t n, size_t m, int arr[n][m]){

}

is equivalent to

void toto(size_t n, size_t m, int (*arr)[m]){

}

With such a definition in the inside of such a function you can access the elements with expressions as arr[i][j] and the compiler knows how to compute the correct element.

Now comes the syntax that you discovered which is only useful for prototypes that is places where you forward-declare the interface of the function

void toto(size_t, size_t, int arr[*][*]);

so here you may replace the array dimension by * as placeholders. But this is only usefull when you don't have the names of the dimensions at hand, and it is much clearer to use exactly the same version as for the definition.

void toto(size_t n, size_t m, int arr[n][m]);

In general for a consistent use of that it is just important that you have the dimensions first in the the parameter list. Otherwise they would not be known when the compiler parses the declaration of arr.

Answer 2

What you want to do it make your argument an int *; pass in the length of the array (which the caller presumably knows, but this routine does not) as a separate argument. You can pass an array as such an argument.

Answer 3

If you're not using the C99 variable length arrays (it appears you are, so see below), the usual solution is to pass in a pointer to the first element, along with any indexes you want to use for accessing the elements.

Here's a piece of code that prints out a range of an array, similar to what you're trying to do with your sort.

#include <stdio.h>

static void fn (int *arr, size_t start, size_t end) {
    size_t idx;
    for (idx = start; idx <= end; idx++) {
        printf ("%d ", arr[idx]);
    }
    putchar ('\n');
}

int main (void) {
    int my_array[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
    fn (my_array, 4, 6);
    return 0;
}

This outputs elements four through six inclusive (zero-based), giving:

5 4 3

A couple of points to note.

• Using my_array in that function call to fn automatically "decays" the array into a pointer to its first element. This actually happens under most (not all) circumstances when you use arrays, so you don't have to explicitly state &(my_array[0]).

• C already has a very good sort function built in to the standard library, called qsort. In many cases, that's what you should be using (unless either you have a specific algorithm you want to use for sorting, or you're doing a homework/self-education exercise).

---

If you are using real VLAs, you should be aware that the [*] construct is only valid in the function prototype, not in an actual definition of the function.

So, while:

void xyzzy(int, int[*]);

is valid, the following is not:

void xyzzy(int sz, int plugh[*]) { doSomething(); }

That's because, while you don't need the size parameter in the prototype, you do very much need it in the definition. And, since you have it, you should just use it:

void xyzzy(int sz, int plugh[sz]) { doSomething(); }

The gcc compiler actually has a reasonably clear error message for this, far better than the "needs to be bounded in the function declaration" one you saw:

error: ‘[*]’ not allowed in other than function prototype scope

Answer 4

The usage of * inside of array brackets for variable-length arrays is limited to prototypes, and serves merely as a placeholder. When the function is later defined, the array's size should be stored in a variable available at either file scope or as one of the parameters. Here's a simple example:

void foo(int, int[*]);
/* asterisk is placeholder */

void foo(int size, int array[size]) {
/* note size of array is specified now */
}