Array size limits

[Carol Depore]

How do I determine the maximum array size?

For example, int a[10000] works, but a[10000000] does not (run time
error).

Thank you.

[Jack Klein]

On Tue, 31 Aug 2004 02:08:08 GMT, Carol Depore <no****@nowhere .com>
wrote in comp.lang.c:

How do I determine the maximum array size?
You can't
For example, int a[10000] works, but a[10000000] does not (run time
error).

Thank you.

The original C standard (ANSI 1989/ISO 1990) required that a compiler
successfully translate at least one program containing at least one
example of a set of environmental limits. One of those limits was
being able to create an object of at least 32,767 bytes.

This minimum limit was raised in the 1999 update to the C standard to
be at least 65,535 bytes.

No C implementation is required to provide for objects greater than
that size, which means that they don't need to allow for an array of
ints greater than (int)(65535 / sizeof(int)).

In very practical terms, on modern computers, it is not possible to
say in advance how large an array can be created. It can depend on
things like the amount of physical memory installed in the computer,
the amount of virtual memory provided by the OS, the number of other
tasks, drivers, and programs already running and how much memory that
are using. So your program may be able to use more or less memory
running today than it could use yesterday or it will be able to use
tomorrow.

Many platforms place their strictest limits on automatic objects, that
is those defined inside of a function without the use of the 'static'
keyword. On some platforms you can create larger arrays if they are
static or by dynamic allocation.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Ben Pfaff]

Carol Depore <no****@nowhere .com> writes:

How do I determine the maximum array size?

There is no portable way. You are better off using dynamic
allocation, because then you can try different sizes at runtime.
--
"Am I missing something?"
--Dan Pop

[Carol Depore]

On Mon, 30 Aug 2004 21:48:07 -0500, Jack Klein <ja*******@spam cop.net>
wrote:

On Tue, 31 Aug 2004 02:08:08 GMT, Carol Depore <no****@nowhere .com>
wrote in comp.lang.c:

How do I determine the maximum array size?
You can't

For example, int a[10000] works, but a[10000000] does not (run time
error).

Thank you.

The original C standard (ANSI 1989/ISO 1990) required that a compiler
successfully translate at least one program containing at least one
example of a set of environmental limits. One of those limits was
being able to create an object of at least 32,767 bytes.

This minimum limit was raised in the 1999 update to the C standard to
be at least 65,535 bytes.

No C implementation is required to provide for objects greater than
that size, which means that they don't need to allow for an array of
ints greater than (int)(65535 / sizeof(int)).

So...are you saying that I am guaranteed at least int a[65535], but no
guarantees beyond that?



In very practical terms, on modern computers, it is not possible to
say in advance how large an array can be created. It can depend on
things like the amount of physical memory installed in the computer,
the amount of virtual memory provided by the OS, the number of other
tasks, drivers, and programs already running and how much memory that
are using. So your program may be able to use more or less memory
running today than it could use yesterday or it will be able to use
tomorrow.

Many platforms place their strictest limits on automatic objects, that
is those defined inside of a function without the use of the 'static'
keyword. On some platforms you can create larger arrays if they are
static or by dynamic allocation.

[Ben Pfaff]

Carol Depore <no****@nowhere .com> writes:

On Mon, 30 Aug 2004 21:48:07 -0500, Jack Klein <ja*******@spam cop.net>
wrote:

No C implementation is required to provide for objects greater than
that size, which means that they don't need to allow for an array of
ints greater than (int)(65535 / sizeof(int)).

So...are you saying that I am guaranteed at least int a[65535], but no
guarantees beyond that?

No. To start with, sizeof(int) may be, and usually is, greater
than 1.
--
"...what folly I commit, I dedicate to you."
--William Shakespeare, _Troilus and Cressida_

[Carol Depore]

On Mon, 30 Aug 2004 20:48:45 -0700, Ben Pfaff <bl*@cs.stanfor d.edu>
wrote:

Carol Depore <no****@nowhere .com> writes:

On Mon, 30 Aug 2004 21:48:07 -0500, Jack Klein <ja*******@spam cop.net>
wrote:

No C implementation is required to provide for objects greater than
that size, which means that they don't need to allow for an array of
ints greater than (int)(65535 / sizeof(int)).

So...are you saying that I am guaranteed at least int a[65535], but no
guarantees beyond that?

No. To start with, sizeof(int) may be, and usually is, greater
than 1.

Oh, I see...so, if sizeof(int) is 2 bytes, then I am guaranteed at
least int a[32767], but no larger sized arrays are guaranteed.

Thanks for the help!

[Ravi Uday]

"Carol Depore" <no****@nowhere .com> wrote in message
news:iu******** *************** *********@4ax.c om...

On Mon, 30 Aug 2004 20:48:45 -0700, Ben Pfaff <bl*@cs.stanfor d.edu>
wrote:

Carol Depore <no****@nowhere .com> writes:

On Mon, 30 Aug 2004 21:48:07 -0500, Jack Klein <ja*******@spam cop.net>
wrote:
No C implementation is required to provide for objects greater than
that size, which means that they don't need to allow for an array of
ints greater than (int)(65535 / sizeof(int)).

So...are you saying that I am guaranteed at least int a[65535], but no
guarantees beyond that?
No. To start with, sizeof(int) may be, and usually is, greater
than 1.

Oh, I see...so, if sizeof(int) is 2 bytes, then I am guaranteed at
least int a[32767], but no larger sized arrays are guaranteed.

No, You have to check INT_MAX in your limits.h file to know the exact
maximum
value that an integer can hold on your implementation.

Thanks for the help!

[Keith Thompson]

"Ravi Uday" <ra******@gmail .com> writes:

"Carol Depore" <no****@nowhere .com> wrote in message
news:iu******** *************** *********@4ax.c om...

[...]

Oh, I see...so, if sizeof(int) is 2 bytes, then I am guaranteed at
least int a[32767], but no larger sized arrays are guaranteed.

No, You have to check INT_MAX in your limits.h file to know the exact
maximum
value that an integer can hold on your implementation.

INT_MAX isn't relevant. The limit in question is the maximum size of
an object, which is at least 65535 bytes (in a hosted environment
only). If sizeof(int) is 2, you're guaranteed at least int a[32767];
if sizeof(int) is 4; you're only guaranteed at least int a[16383].

But actually the guarantee is even weaker than that. The standard
only requires that the implementation must be able to translate and
execute at least one program containing an object of 65535 bytes
(along with a number of other limits, such as 127 arguments in one
function call). It's not required to handle *your* program containing
an object of 65535 bytes.

Practically speaking, though, the easiest way to satisfy the
translation limits is generally to impose no explicit limits, but to
support whatever will fit in memory, either at compile time or at run
time. A (non-binding) footnote in C99 5.2.4.1 says, "Implementation s
should avoid imposing fixed translation limits whenever possible."

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[pete]

Keith Thompson wrote:

"Ravi Uday" <ra******@gmail .com> writes:

"Carol Depore" <no****@nowhere .com> wrote in message
news:iu******** *************** *********@4ax.c om...

[...]

Oh, I see...so, if sizeof(int) is 2 bytes, then I am guaranteed at
least int a[32767], but no larger sized arrays are guaranteed.

No, You have to check INT_MAX in your limits.h file to know the exact
maximum
value that an integer can hold on your implementation.

INT_MAX isn't relevant. The limit in question is the maximum size of
an object, which is at least 65535 bytes (in a hosted environment
only). If sizeof(int) is 2, you're guaranteed at least int a[32767];
if sizeof(int) is 4; you're only guaranteed at least int a[16383].

But actually the guarantee is even weaker than that. The standard
only requires that the implementation must be able to translate and
execute at least one program containing an object of 65535 bytes
(along with a number of other limits, such as 127 arguments in one
function call). It's not required to handle *your* program containing
an object of 65535 bytes.

I think what they meant by the "at least one" part,
is closer to saying
"A C implementation is something which can translate and execute
a C program, and anything that can't translate and execute
a C program, isn't a C implementation"

I don't think that they meant to suggest that an implementation
which doesn't self destruct after program translation and execution,
"exceeds ANSI standards".

--
pete

[Carol Depore]

Everyone, thank you for your help. I feel a little like I'm asking
Einstein to explain relativity to me. I'm way out of my league.
So, thanks for your patience.

Anyway, I'm still confused about how large a simple int array can be.
I understand what Jack and Ben said about the Standard guaranteeing
at least int a[32767], but I don't understand why I can't have an
array of int a[600000], especially since I have 311MB of unused memory
on my machine, and I thought the machine would allow programs up to
4GB.

Here's my little test program, which works for 500000, but fails for
600000.

All help to relieve my confusion is appreciated. I think I'm not
understanding something very fundamental.
#include <stdio.h>

//#define NNN 600000
#define NNN 500000

int main() {
long i;
int a[NNN];
for (i=0;i<NNN;i++) {
printf("%i\n",i );
a[i] = 1;
}
}