есть ли ограничение максимальной длины массива в c ++?

<p>есть ли максимальная длина для массива в c++?</p><p>это предел c++ или это зависит от моей машины? это настраивается? зависит ли это от типа массива?</p><p>могу ли я как-то нарушить этот лимит или мне нужно искать лучший способ хранения информации? и какой должен быть самый простой способ?</p><p>что мне нужно сделать, так это хранить long long int в массиве, я работаю в среде linux. мой вопрос: что мне делать, если мне нужно хранить массив из n длинных целых чисел с n> 10 цифрами?</p><p>мне это нужно, потому что я пишу некоторый криптографический алгоритм (как, например, p-pollard) для школы и попадаю в эту стену целых чисел и длины представления массивов.</p>

<p>есть два ограничения, оба не навязанные c++, а аппаратными.</p><p>первый предел (никогда не должен быть достигнут) устанавливается ограничениями типа размера, используемого для описания индекса в массиве (и его размера). он задается максимальным значением, которое может принять системный <code>std::size\_t</code>. этот тип данных всегда должен быть самым большим целочисленным типом системы.</p><p>другой предел - это предел физической памяти. чем больше ваши объекты в массиве, тем раньше будет достигнут этот предел, поскольку память заполнена. например, <code>vector<int></code> заданного размера <em>n</em> обычно занимает в четыре раза больше памяти, чем массив типа <code>vector<char></code> (минус небольшое постоянное значение). следовательно, <code>vector<char></code> может содержать больше элементов, чем <code>vector<int></code>, прежде чем заполнится память. то же самое относится к массивам собственного стиля c <code>int[]</code> и <code>char[]</code>.</p><p>кроме того, на этот верхний предел может влиять тип <code>allocator</code>, используемый для создания <code>vector</code>, поскольку <code>allocator</code> может свободно управлять памятью любым удобным для него способом. очень странный, но, тем не менее, мыслимый распределитель может объединять память таким образом, чтобы идентичные экземпляры объекта совместно использовали ресурсы. таким образом, вы можете вставить много одинаковых объектов в контейнер, который в противном случае использовал бы всю доступную память.</p><p>кроме того, c++ не устанавливает никаких ограничений.</p>

<p>никто не упомянул ограничение на размер <b>кадр стека</b>,.</p><p>есть два места, где можно выделить память:</p><ul> <li>на куче (динамически выделяемая память).<br> ограничение размера здесь представляет собой комбинацию доступного оборудования и способности ос имитировать пространство с помощью других устройств для временного хранения неиспользуемых данных (<b>то есть.</b> переместить страницы на жесткий диск).</li> <li>в стеке (локально объявленные переменные).<br> ограничение размера здесь определяется компилятором (с возможными аппаратными ограничениями). если вы читаете документацию компилятора, вы часто можете настроить этот размер.</li> </ul><p>таким образом, если вы выделяете массив динамически (ограничение велико и подробно описано в других публикациях.</p><pre><code>int* a1 = new int[size]; // size limited only by os/hardware </code></pre><p>в качестве альтернативы, если массив расположен в стеке, вы ограничены размером кадра стека. <b>нотабене.</b> векторы и другие контейнеры имеют небольшое присутствие в стеке, но обычно большая часть данных будет в куче.</p><pre><code>int a2[size]; // size limited by compiler to the size of the stack frame </code></pre>

<p>если посмотреть на это с практической, а не теоретической точки зрения, в 32-битной системе windows максимальный общий объем памяти, доступный для одного процесса, составляет 2 гб. вы можете преодолеть ограничение, перейдя на 64-битную операционную систему с гораздо большей физической памятью, но то, делать это или искать альтернативы, во многом зависит от ваших предполагаемых пользователей и их бюджетов. вы также можете немного расширить его, используя <a href="http://en.wikipedia.org/wiki/physical\_address\_extension">pae</a> .</p><p>тип массива очень важен, так как выравнивание структуры по умолчанию на многих компиляторах составляет 8 байтов, что является очень расточительным, если использование памяти является проблемой. если вы используете visual c++ для работы с windows, воспользуйтесь директивой <a href="http://msdn.microsoft.com/en-us/library/2e70t5y1%28vs.80%29.aspx"># pragma pack</a> , чтобы преодолеть это.</p><p>еще одна вещь, которую нужно сделать, это посмотреть, что могут помочь вам методы сжатия памяти, такие как разреженные матрицы, сжатие на лету и т.д. опять же, это сильно зависит от приложения. если вы отредактируете свой пост, чтобы дать больше информации о том, что на самом деле находится в ваших массивах, вы можете получить более полезные ответы.</p><p>правка: учитывая немного больше информации о ваших точных требованиях, ваши потребности в хранилище, по-видимому, находятся между 7,6 гб и 76 гб без сжатия, что потребовало бы довольно дорогой 64-битной коробки для хранения в виде массива в памяти в c++. возникает вопрос, почему вы хотите хранить данные в памяти, где предполагается скорость доступа, и разрешить произвольный доступ. лучший способ хранить эти данные вне массива в значительной степени основан на том, как вы хотите получить к ним доступ. если вам нужен случайный доступ к элементам массива, для большинства приложений существуют способы группировки групп данных, к которым обычно обращаются одновременно. например, в больших гис и пространственных базах данных данные часто разбиваются по географическим областям. в терминах программирования c++ вы можете переопределить оператор массива [], чтобы при необходимости извлекать части ваших данных из внешнего хранилища.</p>

<p>чтобы суммировать ответы, расширить их и ответить на ваш вопрос напрямую:<br> <br> <em> нет, c++ не накладывает никаких ограничений на <strong>размеры</strong> массива. </em><br> <br> но так как массив должен храниться где-то в памяти, применяются ограничения, связанные с памятью, налагаемые другими частями компьютерной системы. обратите внимание, что эти ограничения напрямую не связаны с <strong>размеры</strong> (= количество элементов) массива, а скорее с его <strong>размер</strong> (= количество занятой памяти). размеры (<strong>d</strong>) и размер в памяти (<strong>s</strong>) массива не совпадают, так как они связаны с памятью, занятой одним элементом ( <strong>e</strong>): <strong>s</strong>= <strong>d</strong> * <strong>e</strong>.<br> <br> сейчас <strong>e</strong> зависит от:</p><ul> <li>тип элементов массива (элементы могут быть меньше или больше)</li> <li>выравнивание памяти (для повышения производительности элементы размещаются по адресам, кратным некоторому значению, которое вводит<br> "потраченное впустую пространство" (заполнение) между элементами</li> <li>размер статических частей объектов (в объектно-ориентированном программировании статические компоненты объектов одного типа сохраняются только один раз, независимо от количества таких объектов одного типа)</li> </ul><p>также обратите внимание, что вы обычно получаете различные ограничения, связанные с памятью, выделяя данные массива в стеке (в виде автоматической переменной: <code>int t[n]</code>) или в куче (динамическое размещение с <code>malloc()</code>/<code>new</code> или используя механизмы stl), или в статической части процесса память (как статическая переменная: <code>static int t[n]</code>). даже при выделении в куче вам все равно нужно небольшое количество памяти в стеке для хранения ссылок на выделенные в куче блоки памяти (но обычно это незначительно).<br> <br> размер типа <code>size\_t</code> не влияет на программиста (я предполагаю, что программист использует тип <code>size\_t</code> для индексации, так как он предназначен для него), так как провайдер компилятора должен <code>typedef</code> к целочисленному типу, достаточному для максимального адреса объем памяти, возможный для данной архитектуры платформы.<br> <br> источники ограничений объема памяти проистекают из</p><ul> <li>объем памяти, доступный для процесса (который ограничен 2 ^ 32 байтами для 32-битных приложений, даже в ядрах 64-битных ос),</li> <li>разделение памяти процесса (например, объем памяти процесса, предназначенной для стека или кучи),</li> <li>фрагментация физической памяти (многие разбросанные небольшие фрагменты свободной памяти не применимы для хранения одной монолитной структуры),</li> <li>количество физической памяти,</li> <li>и объем виртуальной памяти.</li> </ul><p>они не могут быть "подправлены" на уровне приложения, но вы можете использовать другой компилятор (для изменения пределов размера стека), или перенести ваше приложение на 64-битную версию, или перенести его на другую ос, или изменить физический/конфигурация виртуальной памяти (виртуальной? физической?) машины.<br> <br> нередко (и даже желательно) рассматривать все вышеперечисленные факторы как внешние помехи и, следовательно, как возможные источники ошибок времени выполнения, а также тщательно проверять и реагировать на ошибки, связанные с выделением памяти в программном коде.<br> <br> <em> и наконец: хотя c++ не накладывает никаких ограничений, вам все равно придется проверять наличие неблагоприятных условий, связанных с памятью, при запуске вашего кода ...: -) </em></p>

<p>я бы согласился с вышесказанным, что если вы начинаете свой массив с</p><pre><code> int myarray[size] </code></pre><p>тогда размер ограничен размером целого числа. но вы всегда можете malloc кусок памяти и иметь указатель на него, настолько большой, насколько вы хотите, если malloc не возвращает null.</p>

<p>как отмечалось много отличных ответов, существует множество ограничений, которые зависят от вашей версии компилятора c++, операционной системы и характеристик компьютера. тем не менее, я предлагаю следующий скрипт для python, который проверяет ограничение на вашем компьютере.</p><p>он использует бинарный поиск и на каждой итерации проверяет, возможен ли средний размер, создавая код, который пытается создать массив такого размера. сценарий пытается скомпилировать его (извините, эта часть работает только в linux) и настроить бинарный поиск в зависимости от успеха. проверьте это:</p><pre><code>import 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) </code></pre><p>вы можете сохранить его на своем компьютере и запустить, и он напечатает максимальный размер, который вы можете создать. для моей машины это 2305843009213693951.</p>

<p>одна вещь, которую я не думаю, была упомянута в предыдущих ответах.</p><p>я всегда ощущаю "неприятный запах" в смысле рефакторинга, когда люди используют такие вещи в своем дизайне.</p><p>это огромный массив и, возможно, не лучший способ представления ваших данных как с точки зрения эффективности, так и с точки зрения производительности.</p><p>веселит,</p><p>обкрадывать</p>

<p>если вам приходится иметь дело с такими большими данными, вам нужно разделить их на управляемые куски. это не все вписывается в память на любом маленьком компьютере. вероятно, вы можете загрузить часть данных с диска (независимо от того, что уместно), выполнить ваши вычисления и внести в них изменения, сохранить их на диск, а затем повторить до завершения.</p>

<p>как ни досадно неспецифично, как все текущие ответы, они в основном правильные, но со многими оговорками, не всегда упоминаемыми. суть в том, что у вас есть два верхних предела, и только один из них действительно определен, так что <a href="https://en.wiktionary.org/wiki/your\_mileage\_may\_vary#phrase">ymmv</a> :</p><h3>1. ограничение времени компиляции</h3><p>в основном то, что позволит ваш компилятор. для visual c++ 2017 в 64-разрядной версии windows 10 это мой максимальный лимит во время компиляции до ограничения в 2 гб,</p><pre><code>unsigned \_\_int64 max\_ints[255999996]{0}; </code></pre><p>если бы я сделал это вместо этого,</p><pre><code>unsigned \_\_int64 max\_ints[255999997]{0}; </code></pre><p>я бы получил:</p><blockquote> <p><code>error c1126 automatic allocation exceeds 2g</code></p> </blockquote><p>я не уверен, как 2g коррелирует с <code>255999996</code>/<code>7</code>. я гуглил оба числа, и единственное, что я мог найти, что, возможно, было связано, было это * nix q & a о <a href="https://unix.stackexchange.com/a/456797/108615">проблема точности с <code>dc</code></a> . в любом случае, кажется, что не имеет значения, какой тип массива int вы пытаетесь заполнить, сколько элементов может быть выделено.</p><h3>2. ограничения времени выполнения</h3><p>ваш стек и куча имеют свои ограничения. эти ограничения являются значениями, которые изменяются в зависимости от доступных системных ресурсов, а также от того, насколько "тяжелым" является само ваше приложение. например, с моими текущими системными ресурсами я могу заставить это работать:</p><pre><code>int main() { int max\_ints[257400]{ 0 }; return 0; } </code></pre><p>но если я немного подправлю ...</p><pre><code>int main() { int max\_ints[257500]{ 0 }; return 0; } </code></pre><p>бам! переполнение стека!</p><blockquote> <p><code>exception thrown at 0x00007ff7dc6b1b38 in memchk.exe: 0xc00000fd:</code> <code>stack overflow (parameters: 0x0000000000000001, 0x000000aa8de03000).</code> <code>unhandled exception at 0x00007ff7dc6b1b38 in memchk.exe: 0xc00000fd:</code> <code>stack overflow (parameters: 0x0000000000000001, 0x000000aa8de03000).</code></p> </blockquote><p>и просто, чтобы детализировать всю тяжесть вашего приложения, это было хорошо, чтобы пойти:</p><pre><code>int main() { int maxish\_ints[257000]{ 0 }; int more\_ints[400]{ 0 }; return 0; } </code></pre><p>но это вызвало переполнение стека:</p><pre><code>int main() { int maxish\_ints[257000]{ 0 }; int more\_ints[500]{ 0 }; return 0; } </code></pre>

<p>я бы обойти это, создав 2d динамический массив:</p><pre><code>long long** a = new long long*[x]; for (unsigned i = 0; i < x; i++) a[i] = new long long[y]; </code></pre><p>подробнее об этом здесь <a href="https://stackoverflow.com/a/936702/3517001">https://stackoverflow.com/a/936702/3517001</a> </p>

<p>как уже указывалось, размер массива ограничен вашим оборудованием и вашей ос (man ulimit). ваше программное обеспечение может быть ограничено только вашим творческим потенциалом. например, вы можете хранить свой "массив" на диске? вам действительно нужны длинные длинные целые? вам действительно нужен плотный массив? вам вообще нужен массив?</p><p>одним из простых решений было бы использовать 64-битный linux. даже если у вас недостаточно физического озу для массива, ос позволит вам распределять память так, как если бы вы это делали, поскольку виртуальная память, доступная вашему процессу, вероятно, намного больше, чем физическая память. если вам действительно нужен доступ ко всему в массиве, это равносильно хранению его на диске. в зависимости от ваших шаблонов доступа, могут быть более эффективные способы сделать это (например, используя mmap () или просто последовательно хранить данные в файле (в этом случае 32-битного linux будет достаточно)).</p>