没有人提到堆栈帧的大小限制。
内存可以分配在两个地方：
因此，如果您动态分配数组（该限制很大，并由其他文章详细描述。
int* a1 = new int[SIZE]; // SIZE limited only by OS/Hardware
如果数组分配在堆栈上，那么你受到堆栈帧大小的限制。需要注意的是，向量和其他容器虽然在堆栈中存在，但通常大部分数据都在堆上。
int a2[SIZE]; // SIZE limited by COMPILER to the size of the stack frame
有两个限制，都不是由C++强制实施的，而是由硬件决定的。
第一个限制（不应该被达到）是由用于描述数组中索引的大小类型（及其大小）的限制设置的。它由系统的std::size_t可以取到的最大值给出。这种数据类型足够大，可以包含任何对象的字节数。
另一个限制是物理内存限制。数组中对象越大，内存就越快满。例如，给定尺寸n的vector<int>通常占用多倍于类型为vector<char>（减去一个小常数值）的数组的内存，因为int通常比char更大。因此，在内存满之前，vector<char>可能包含比vector<int>更多的项。对于像int[]和char[]这样的原始C-style数组，情况也是一样。
此外，上限还可能受到用于构造vector的allocator类型的影响，因为allocator可以自由地管理任何内存。一个非常奇怪但可行的allocator可以以这样的方式池化内存，使相同实例的对象共享资源。这样，您可以将大量相同的对象插入到容器中，否则会使用所有可用内存。
除此之外，C++不强制执行任何限制。
new或malloc传递的参数限制。比数组更大的内存块可以通过指针访问。 - Thomas Matthews从实际的角度来看，在一个32位的Windows系统上，单个进程可以使用的最大内存总量为2GB。你可以通过使用64位操作系统和更多的物理内存来突破这一限制，但是是否这样做或寻找替代方案很大程度上取决于您的预期用户及其预算。还可以使用PAE进行一定程度的扩展。
数组的类型非常重要，因为许多编译器的默认结构对齐方式是8字节，如果内存使用是一个问题，这将非常浪费。如果你正在使用Visual C++针对Windows，可以查看#pragma pack指令来解决这个问题。
另一件事情是考虑一下哪些内存压缩技术可能会对你有帮助，例如稀疏矩阵、即时压缩等等...再次强调，这非常依赖于应用程序。如果您编辑您的帖子并提供一些有关数组中实际包含内容的信息，您可能会得到更有用的答案。
编辑：根据您的确切需求提供了更多信息，您的存储需求似乎在7.6GB到76GB之间（未压缩），这将需要一个相当昂贵的64位框来以C++中的数组形式存储。这引发了一个问题，为什么要将数据存储在内存中，通常是为了加快访问速度，并允许随机访问。最好的方式是将这些数据存储在数组之外，这基本上取决于您想如何访问它。如果需要随机访问数组成员，在大多数应用程序中，往往有一些方法可以将被同时访问的数据聚集在一起。例如，在大型GIS和空间数据库中，数据通常按地理区域进行分块处理。在C++编程方面，您可以覆盖[]数组运算符，根据需要从外部存储获取您的数据的部分。
尽管当前的答案大多数都含糊不清，但它们大多数是正确的，但有许多注意事项并不总是被提到。 要点是，您有两个上限，其中只有一个是实际定义的内容，因此 YMMV：
基本上是您的编译器所允许的范围。对于在x64 Windows 10上使用Visual C++ 2017，在超过此编译时上限之前，我的最大限制为2GB，
unsigned __int64 max_ints[255999996]{0};
unsigned __int64 max_ints[255999997]{0};
我得到的错误信息是：
Error C1126 自动分配超过 2G
我不确定 2G 和 255999996/7 有什么关联。我搜索了这两个数字，唯一可能相关的是这个关于 dc 精度问题 的 *nix Q&A。无论你试图填充哪种类型的 int 数组，似乎都无关紧要，只要能够分配多少个元素。
你的堆栈和堆各自有其限制。这些限制都是基于可用系统资源以及应用本身的“重量”而变化的值。例如，使用我的当前系统资源，我可以运行这个程序：
int main()
{
int max_ints[257400]{ 0 };
return 0;
}
int main()
{
int max_ints[257500]{ 0 };
return 0;
}
嘭！堆栈溢出了！
异常抛出于0x00007FF7DC6B1B38，文件名为memchk.exe: 0xC00000FD:堆栈溢出 (参数: 0x0000000000000001, 0x000000AA8DE03000)。未处理的异常发生于0x00007FF7DC6B1B38，文件名为memchk.exe: 0xC00000FD:堆栈溢出 (参数: 0x0000000000000001, 0x000000AA8DE03000)。
为了详细阐述你的应用程序重要性，这一切都是好的：
int main()
{
int maxish_ints[257000]{ 0 };
int more_ints[400]{ 0 };
return 0;
}
int main()
{
int maxish_ints[257000]{ 0 };
int more_ints[500]{ 0 };
return 0;
}
还要注意，通过在堆栈上分配数组数据（作为自动变量：int t[N]），在堆上（使用malloc()/new或使用STL机制进行动态分配），或在进程内存的静态部分（作为静态变量：static int t[N]）中，通常会获得不同的与内存相关的限制。即使在堆上分配，您仍然需要一些微小的堆栈内存来存储对分配的内存块的引用（但这通常是可以忽略的）。
size_t类型的大小对程序员没有影响（我假设程序员将size_t类型用于索引，因为它专为此设计），因为编译器提供者必须将其typedef为整数类型足够大，以便为给定平台架构寻址最大内存量。
内存大小限制的来源有：
这些限制无法在应用程序层面进行“微调”，但是您可以自由选择使用不同的编译器（以更改堆栈大小限制），或将应用程序移植到64位系统，或将其移植到另一个操作系统，或更改（虚拟？物理？）机器的物理/虚拟内存配置。
通常情况下（甚至建议如此），将所有上述因素视为外部干扰和可能的运行时错误来源，并仔细检查并对程序代码中与内存分配相关的错误做出反应。
最后：虽然C++没有强加任何限制，但在运行代码时仍需要检查不良的内存相关条件... :-)
int myArray[SIZE]
如果使用整数，那么SIZE的大小会受到限制。但是，您可以始终分配一块内存，并拥有一个指向它的指针，只要malloc不返回NULL，您就可以拥有任意大小的内存块。
int oops[INT_MAX]{0}; 它会生成错误信息：C2148 - 数组的总大小不能超过0x7fffffff字节。 - kayleeFrye_onDeck66％的内存，我对可以使用多大的int数组进行初始化并赋值为0没有明确的限制。有时我可以使用大约257k个元素，有时会出现堆栈溢出。如果我除了主要的数组之外添加了任何内容，那么这个数字就会下降（显然）。我不得不进行实验来确定这个数字，因此我不认为除了在真空中知道您的理论极限之外，这个指标是可靠的。 - kayleeFrye_onDeckimport os
cpp_source = 'int a[{}]; int main() {{ return 0; }}'
def check_if_array_size_compiles(size):
# Write to file 1.cpp
f = open(name='1.cpp', mode='w')
f.write(cpp_source.format(m))
f.close()
# Attempt to compile
os.system('g++ 1.cpp 2> errors')
# Read the errors files
errors = open('errors', 'r').read()
# Return if there is no errors
return len(errors) == 0
# Make a binary search. Try to create array with size m and
# adjust the r and l border depending on wheather we succeeded
# or not
l = 0
r = 10 ** 50
while r - l > 1:
m = (r + l) // 2
if check_if_array_size_compiles(m):
l = m
else:
r = m
answer = l + check_if_array_size_compiles(r)
print '{} is the maximum avaliable length'.format(answer)
您可以将其保存到计算机并启动它，它将打印您可以创建的最大大小。对于我的机器，它是2305843009213693951。
我们知道"由于系统或库实现限制，即 std::distance(begin(), end()) 为最大容器元素数，此函数返回容器能够容纳的最大元素数。"
std::vector在底层是作为一个动态数组实现的，因此max_size()应该给出关于机器上动态数组的最大长度的非常接近的近似值。#include <iostream>
#include <vector>
#include <string>
#include <limits>
template <typename T>
std::string mx(T e) {
std::vector<T> v;
return std::to_string(v.max_size());
}
std::size_t maxColWidth(std::vector<std::string> v) {
std::size_t maxWidth = 0;
for (const auto &s: v)
if (s.length() > maxWidth)
maxWidth = s.length();
// Add 2 for space on each side
return maxWidth + 2;
}
constexpr long double maxStdSize_t = std::numeric_limits<std::size_t>::max();
// cs stands for compared to std::size_t
template <typename T>
std::string cs(T e) {
std::vector<T> v;
long double maxSize = v.max_size();
long double quotient = maxStdSize_t / maxSize;
return std::to_string(quotient);
}
int main() {
bool v0 = 0;
char v1 = 0;
int8_t v2 = 0;
int16_t v3 = 0;
int32_t v4 = 0;
int64_t v5 = 0;
uint8_t v6 = 0;
uint16_t v7 = 0;
uint32_t v8 = 0;
uint64_t v9 = 0;
std::size_t v10 = 0;
double v11 = 0;
long double v12 = 0;
std::vector<std::string> types = {"data types", "bool", "char", "int8_t", "int16_t",
"int32_t", "int64_t", "uint8_t", "uint16_t",
"uint32_t", "uint64_t", "size_t", "double",
"long double"};
std::vector<std::string> sizes = {"approx max array length", mx(v0), mx(v1), mx(v2),
mx(v3), mx(v4), mx(v5), mx(v6), mx(v7), mx(v8),
mx(v9), mx(v10), mx(v11), mx(v12)};
std::vector<std::string> quotients = {"max std::size_t / max array size", cs(v0),
cs(v1), cs(v2), cs(v3), cs(v4), cs(v5), cs(v6),
cs(v7), cs(v8), cs(v9), cs(v10), cs(v11), cs(v12)};
std::size_t max1 = maxColWidth(types);
std::size_t max2 = maxColWidth(sizes);
std::size_t max3 = maxColWidth(quotients);
for (std::size_t i = 0; i < types.size(); ++i) {
while (types[i].length() < (max1 - 1)) {
types[i] = " " + types[i];
}
types[i] += " ";
for (int j = 0; sizes[i].length() < max2; ++j)
sizes[i] = (j % 2 == 0) ? " " + sizes[i] : sizes[i] + " ";
for (int j = 0; quotients[i].length() < max3; ++j)
quotients[i] = (j % 2 == 0) ? " " + quotients[i] : quotients[i] + " ";
std::cout << "|" << types[i] << "|" << sizes[i] << "|" << quotients[i] << "|\n";
}
std::cout << std::endl;
std::cout << "N.B. max std::size_t is: " <<
std::numeric_limits<std::size_t>::max() << std::endl;
return 0;
}
| data types | approx max array length | max std::size_t / max array size |
| bool | 9223372036854775807 | 2.000000 |
| char | 9223372036854775807 | 2.000000 |
| int8_t | 9223372036854775807 | 2.000000 |
| int16_t | 9223372036854775807 | 2.000000 |
| int32_t | 4611686018427387903 | 4.000000 |
| int64_t | 2305843009213693951 | 8.000000 |
| uint8_t | 9223372036854775807 | 2.000000 |
| uint16_t | 9223372036854775807 | 2.000000 |
| uint32_t | 4611686018427387903 | 4.000000 |
| uint64_t | 2305843009213693951 | 8.000000 |
| size_t | 2305843009213693951 | 8.000000 |
| double | 2305843009213693951 | 8.000000 |
| long double | 1152921504606846975 | 16.000000 |
N.B. max std::size_t is: 18446744073709551615
在 ideone gcc 8.3 上，我得到：
| data types | approx max array length | max std::size_t / max array size |
| bool | 9223372036854775744 | 2.000000 |
| char | 18446744073709551615 | 1.000000 |
| int8_t | 18446744073709551615 | 1.000000 |
| int16_t | 9223372036854775807 | 2.000000 |
| int32_t | 4611686018427387903 | 4.000000 |
| int64_t | 2305843009213693951 | 8.000000 |
| uint8_t | 18446744073709551615 | 1.000000 |
| uint16_t | 9223372036854775807 | 2.000000 |
| uint32_t | 4611686018427387903 | 4.000000 |
| uint64_t | 2305843009213693951 | 8.000000 |
| size_t | 2305843009213693951 | 8.000000 |
| double | 2305843009213693951 | 8.000000 |
| long double | 1152921504606846975 | 16.000000 |
N.B. max std::size_t is: 18446744073709551615
gcc上对于char类型，最大元素数量等于std::size_t的最大值。尝试this时，我们会收到错误提示：prog.cpp: In function ‘int main()’:
prog.cpp:5:61: error: size of array is too large
char* a1 = new char[std::numeric_limits<std::size_t>::max()];
如果你需要处理如此大量的数据，你需要将其分成可管理的块。它不会全部适合任何小型计算机的内存中。你可以从磁盘加载一部分数据（任何合理适合的），对其进行计算和更改，将其存储到磁盘中，然后重复此过程，直到完成。
在之前的回答中可能没有提到的一点是，我总是感觉在重构时会出现“异味”。
从效率和性能的角度来看，那是一个巨大的数组，可能不是表示数据的最佳方式。
祝好，
罗布
new或malloc）实现。 - Thomas Matthews全局数组，虽然不太美观且最好避免使用，但它们不属于栈的限制范围，而且你不需要使用malloc/free就能处理它们。 - ted