Re: Is there in the C++'s standard a note on how large the size of an array is allowed so that the code containing the array's definition is portable?
"ioan" <niciodata.eu@gmail.com> schrieb im Newsbeitrag
news:5461652e-1685-40cb-8356-d98393682ed0@p13g2000yqh.googlegroups.com...
[[The question]]
How many items can there be defined in a C++ array so that the code
containing the C++ array makes a well-defined C++ program considering
that the rest of the C++ program is well-formed?
My assumption is that the maximum number of elements in an array is either
std::numeric_limits<unsigned>::max()
or
std::numeric_limits<unsigned>::max() - 1.
Note that an STL sequence usually has a range [p, q), where q is the
position one past the last element in the array. So if your array has
std::numeric_limits<unsigned>::max() elements, there can hardly be a
position past the last element.
[[My thoughts on this subject:]]
// foo.cpp:
int const maxn = 100 * 1000;
int A[maxn];
int main()
{ return 0; }
// end of foo.cpp:
Is foo.cpp a well-formed C++ program?
Here is how I see the possibilities:
[1]
foo.cpp may be a well-formed program and then any C++ compiler would
build a program from this file. Any machine on which this program (or
some similar program that would actually access the array) would need
to have more than 100*1000 memory locations or the possibility to give
the program (paging memory pages in and out for example).
Even well-formed programs can run out of memory. Your compiler may turn your
source code into an executable, but there is no guarantee that it won't fail
at run time because there is not enough memory.
If your array is local, i.e. created on the stack, then you might get a
stack overflow as soon as the corresponding function is called:
#include <iostream>
void f()
{
// Create an array of 100,000 ints on the stack.
int arr[100 * 1000];
std::cout << "We're done here!" << std::endl;
}
int main()
{
// Program might run out of memory
// due to this function call.
f();
return 0;
}
But if the array is in the global namespace, then the program might not even
start:
// Create an array of 100,000 ints in
// the executable's data segment.
int arr[100 * 1000];
int main()
{
return 0;
}
On Visual C++ 2005 Express Edition, I get an error saying that the total
size of the array may not exceed 0x7fffffff bytes if I do this:
int arr[1000 * 1000 * 1000];
And the same compiler chokes at the following code while saying that it
exceeds a 2GB limit:
void f()
{
const int SIZE = 0x7fffffff / sizeof ( int );
int arr[SIZE];
for ( unsigned n = 0; n < sizeof arr / sizeof ( int ); n++ )
arr[n] = 0;
}
int main()
{
f();
return 0;
}
So I guess that almost every compiler will issue an error if an array is too
big to handle, and those who don't will most likely leave this job to the
operating system.
--
Matthias Hofmann
Anvil-Soft, CEO
http://www.anvil-soft.com - The Creators of Toilet Tycoon
http://www.anvil-soft.de - Die Macher des Klomanagers
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]