What is the maximum dimension of array can be accepted in c?

Answer 1

C++ doesn't enforce any limits on array dimensions. Limitations are enforced by the hardware. The first limitation is available memory (including virtual memory). The larger the objects in the array, the fewer elements you can create in memory. The second limitation relates to the maximum integer that can be mapped to a size_t data type (which is dependent upon the architecture), however you're far more likely to run out of memory long before reaching this limit.

For instance, a 32-bit system has 4GB of addressable memory, thus (in theory) can accommodate an array of char with a 4,294,967,295 dimension (assuming an 8-bit char type). However, that would leave no memory for the operating system let alone the IDE, so the maximum would be somewhat lower than 4GB.

On a 64-bit system, a 4GB array of char would be perfectly feasible, even if the system only had 2GB of physical memory, due to the much larger address space available (18,446,744,073,709,551,616 bytes).

However, an array that partially requires virtual memory would be tremendously slow to access due to constant swap file access. Depending on the nature of the array, if it requires more memory than is physically available, it might be better handled via a database or as a random access file stream.

Answer 2

The largest number of elements in any one dimension cannot exceed MAX_SIZE, which is the largest value that can be represented by your implementation's size_t data type (implementation-defined). However, the amount of contiguous memory physically allocated to an array is determined by the product of the dimension(s) and the size of the array type (in bytes), thus you will likely find the actual limit is much lower than MAX_SIZE might suggest.

For instance, a 32-bit implementation might define size_t as an alias (typedef) for a 32-bit unsigned integer, suggesting an upper limit of 4,294,967,295 elements (2^32-1). However, a 32-bit machine can only physically address 4,294,967,295 bytes of memory, some of which will be utilised by your operating system and other running programs. Although virtual memory can make it seem like there's far more memory than physically exists, an array allocated in contiguous virtual memory still has to be allocated in contiguous physical memory. A 64-bit machine with more than 4 GB of physical memory available could probably accommodate such an array, but a 32-bit system definitely could not.

Arrays that are too large to store in memory must be stored on disk instead.