Do arrays in C have a maximum index size of 2048?

Question

I've written a piece of code that uses a static array of size 3000.

Ordinarily, I would just use a for loop to scan in 3000 values, but it appears that I can only ever scan in a maximum of 2048 numbers. To me that seems like an issue with memory allocation, but I'm not sure.

The problem arises because I do not want a user to input the amount of numbers they intend to input. They should only input whatever amount of numbers they want, terminate the scan by inputting 0, after which the program does its work. (Otherwise I would just use malloc.)

The code is a fairly simple number occurrence counter, found below:

int main(int argc, char **argv)
{

int c;
int d;
int j = 0;
int temp;
int array[3000];
int i;

// scanning in elements to array (have just used 3000 because no explicit value for the length of the sequence is included) 
for (i = 0; i < 3000; i++)
{
    scanf("%d", &array[i]);
    if (array[i] == 0)
    {
        break;
    }
}

// sorting
for(c = 0; c < i-1; c++)    { 
    for(d = 0; d < i-c-1; d++)  {
        if(array[d] > array[d+1])   { 
            temp        = array[d]; // swaps
            array[d]    = array[d+1];
            array[d+1]  = temp;
        }
    }
}

int arrayLength = i + 1; // saving current 'i' value to use as 'n' value before reset

for(i = 0; i < arrayLength; i = j)
{
    int numToCount = array[i];
    int occurrence = 1; // if a number has been found the occurence is at least 1
    for(j = i+1; j < arrayLength; j++) // new loops starts at current position in array +1 to check for duplicates
    {
        if(array[j] != numToCount) // prints immediately after finding out how many occurences there are, else adds another
        {
            printf("%d: %d\n", numToCount, occurrence); 
            break; // this break keeps 'j' at whatever value is NOT the numToCount, thus making the 'i = j' iterator restart the process at the right number
        } else {
            occurrence++;
        }
    }
}

return 0;
}

This code works perfectly for any number of inputs below 2048. An example of it not working would be inputting: 1000 1s, 1000 2s, and 1000 3s, after which the program would output:

1: 1000
2: 1000
3: 48

My question is whether there is any way to fix this so that the program will output the right amount of occurrences.

Answer 1

To answer your title question: The size of an array in C is limited (in theory) only by the maximum value that can be represented by a size_t variable. This is typically a 32- or 64-bit unsigned integer, so you can have (for the 32-bit case) over 4 billion elements (or much, much more in 64-bit systems).

However, what you are probably encountering in your code is a limit on the memory available to the program, where the line int array[3000]; declares an automatic variable. Space for these is generally allocated on the stack - which is a chunk of memory of limited size made available when the function (or main) is called. This memory has limited size and, in your case (assuming 32-bit, 4-byte integers), you are taking 12,000 bytes from the stack, which may cause problems.

There are two (maybe more?) ways to fix the problem. First, you could declared the array static - this would make the compiler pre-allocate the memory, so it would not need to be taken from the stack at run-time:

static int array[3000];

A second, probably better, approach would be to call malloc to allocate memory for the array; this assigns memory from the heap - which has (on almost all systems) considerably more space than the stack. It is often limited only by the available virtual memory of the operating system (many gigabytes on most modern PCs):

int *array = malloc(3000 * sizeof(int));

Also, the advantage of using malloc is that if, for some reason, there isn't enough memory available, the function will return NULL, and you can test for this. You can access the elements of the array in the same way, using array[i] for example. Of course, you should be sure to release the memory when you've done with it, at the end of your function:

free(array);

(This will be done automatically in your case, when the program exits, but it's good coding style to get used to doing it explicitly!)