CODEWITHSUNDEEP
c
Remy M
Remy M

Reputation: 619

Globally defining an array with unknown dimensions

I am trying to globally define a multidimensional array. The dimensions will ultimately depend on some other computations. Here I'll just consider n and B to be 5 but I place them inside function2 to stress that the dimensions are not known initially. At some point I'll also need to duplicate this array. The code below gives the error Subscripted value is not an array, pointer, or vector on the line where I'm printing the array2 entries. How can I fix this error and is there anything else I need to change to accomplish this?

int n,B;
double ** array;
double ** array2;

void function(){
    double array[n][B][n];
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= B; j++){
            for(int k = 1; k <= n; k++){
                array[i-1][j-1][k-1] = i*j*k;
            }
        }
    }
}

void function2(){
    n=5;
    B = 5;
    function();
    array2 = array;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= B; j++){
            for(int k = 1; k <= n; k++){
                printf("%lf",array2[i-1][j-1][k-1]);
            }
        }
    }
}

int main(){
    function2();
    return 0;
}

Upvotes: 0

Views: 81

Answers (3)

Deepak Terse
Deepak Terse

Reputation: 712

First thing, arrays in C are stored in contiguous memory locations. So if you do not provide the number of rows or the number of columns, how will the compiler know how many rows and columns there are?

So, you have to specify the rows and columns at the start. However, you can have some workaround. Refer to this Initializing Arrays in C/C++ With Unknown Size

There are few issues in the code which you should have a look at:

  1. functions() has a local declaration of array2. So,

    double ** array2;

    and 

    array2 = array;

    are different.

  2. You can't assign arrays in C. You can copy them with the memcpy() function, declared in string.h as follows:

    memcpy(&array2, &array, sizeof array2);

  3. array2 is declared as double ** array2; so array2[i-1][j-1][k-1] cannot be resolved.

Happy coding!

Upvotes: 1

bruno
bruno

Reputation: 32586

First note that in function2 :

function();
array2 = array;

array refers to the global variable, while function initialized its local variable array and not the global one. So array and array value NULL

Subscripted value is not an array, pointer, or vector

array2 is only known as double ** array2; so array2[i-1][j-1][k-1] cannot be resolved because it needs at least the last two dimensions. Note also it is strange to use a double pointer for a 3D array.

If you want to use array2 supposing it is in fact double array2[n][B][n] you can cast it as double (*)[B][n], but in your code array2 is NULL. Or of course you have array2 as a double * and you compute yourself the right offset to access the double you want

Upvotes: 1

Serge Ballesta
Serge Ballesta

Reputation: 148910

Oops... I am trying to globally define a multidimensional array. The dimensions will ultimately depend on some other computations... Don't. At least do not try that in C language. Arrays are not first class citizens in C, not speaking of multi-dimensional ones. Said differently AFAIK, there is no way in C to declare a multi-dimensional array where all dimensions but the last one are not compile time constants.

But there are another problems in your code: double ** array; at global level declares a pointer to pointer (or a pointer to array) which is a totally different animal than a multi-dimensional array. And double array[n][B][n]; (wrongly) declares a totaly independant multi-dim. array, hiding the global symbol.

So my advice is:

  • avoid if possible globaly defined variables. There are indeed correct use cases but most of the time, it is cleaner to pass them as parameter of functions, possibly inside structs

  • make your choice between a multi-dimensional array and an array of pointers. The former is a consecutive containers where all dimensions but the last have to be constant, the latter if much more versatile, because each row could have a different size. But it is slightly more complex to declare and slightly less efficient.

    int a1[5], a2[6], a3[7];
int **parray = {a1, a2, a3};
elt_i_j = parray[i][j];

  • do not forget about the good old idiom allowing to see a 1-D array as a multi-dim one:

    size_t size1, size2, size3;
// compute the sizes...
int *array = malloc(size1, size2, size3);
elt_i_j_k = array[k + size2 * (j + size1 * i)]

Good luck in learning C arrays...

Upvotes: 2

Related Questions