Question

I have two questions regarding the multidimensional arrays. I declared a 3D array using two stars but when I try to access the elements I get a used-without-initializing error.

unsigned **(test[10]);
**(test[0]) = 5;

Howcome I get that error while when I use the following code, I don’t get an error – What’s the difference?

unsigned test3[10][10][10];
**(test3[0]) = 5;

My second question is this: I’m trying to port a piece of code that was written for Unix to Windows. One of the lines is this:

unsigned **(precomputedHashesOfULSHs[nnStruct->nHFTuples]);

*nHFTuples is of type int but it’s not a constant, and this the error that I’m getting;

error C2057: expected constant expression

Is it possible that I’m getting this error because I’m running it on Windows not Unix? – and how would I solve this problem? I can’t make nHFTuples a constant because the user will need to provide the value for it!

Answer 1

In the first one, you didn’t declare a 3D array, you declared an array of 10 pointers to pointers to unsigned ints. When you dereference it, you’re dereferencing a garbage pointer.

In the second one, you declared the array correctly but you’re using it wrong. Arrays are not pointers and you don’t dereference them.

Do this:

unsigned test3[10][10][10];
test3[0][0][0] = 5;

To answer your second question, you have to use a number that can be known at compile time as the size of an array. GCC has a nonstandard extension that allows you to do that, but it’s not portable and not part of the standard (though C99 introduced them). To fix it, you’ll have to use malloc and free:

int i, j, k;

unsigned*** precomputedHashOfULSHs = malloc(nnStruct->nHFTuples * sizeof(unsigned));

for (i = 0; i < firstDimensionLength; ++i) {
    precomputedHashOfULSHs[i] = malloc(sizeOfFirstDimension * sizeof(unsigned));

    for (j = 0; j < secondDimensionLength; ++j) {
        precomputedHashOfULSHs[i][j] = malloc(sizeOfSecondDimension * sizeof(unsigned));

        for (k = 0; k < sizeOfSecondDimension; ++k)
            precomputedHashOfULSHs[i][j][k] = malloc(sizeof(unsigned));
    }
}

// then when you're done...

for (i = 0; i < firstDimensionLength; ++i) {
    for (j = 0; j < secondDimensionLength; ++j) {
        for (k = 0; k < sizeOfSecondDimension; ++k)
            free(precomputedHashOfULSHs[i][j][k]);

        free(precomputedHashOfULSHs[i][j]);
    }

    free(precomputedHashOfULSHs[i]);
}

free(precomputedHashOfULSHs);

(Pardon me if that allocation/deallocation code is wrong, it’s late :))