Esiste un limite di lunghezza massima dell'array in C ++?

Esiste una lunghezza massima per un array in C ++?

È un limite C ++ o dipende dalla mia macchina? È modificabile? Dipende dal tipo di matrice?

Posso infrangere questo limite in qualche modo o devo cercare un modo migliore di archiviare le informazioni? E quale dovrebbe essere il modo più semplice?

Quello che devo fare è archiviare int molto a lungo su un array, sto lavorando in un ambiente Linux. La mia domanda è: cosa devo fare se devo memorizzare un array di N numeri interi lunghi lunghi con N> 10 cifre?

Ne ho bisogno perché sto scrivendo un algoritmo crittografico (come ad esempio il p-Pollard) per la scuola e colpendo questo muro di numeri interi e la lunghezza della rappresentazione degli array.

Esistono due limiti, entrambi non applicati da C ++ ma piuttosto dall'hardware.

Il primo limite (che non dovrebbe mai essere raggiunto) è fissato dalle restrizioni del tipo di dimensione utilizzato per descrivere un indice nell'array (e la sua dimensione). È dato dal valore massimo che il sistema std::size_tpuò assumere. Questo tipo di dati è abbastanza grande da contenere la dimensione in byte di qualsiasi oggetto

L'altro limite è un limite di memoria fisica. Più grandi sono i tuoi oggetti nell'array, prima viene raggiunto questo limite perché la memoria è piena. Ad esempio, a vector<int>di una data dimensione n richiede in genere più volte la quantità di memoria di una matrice di tipo vector<char>(meno un valore costante piccolo), poiché di intsolito è maggiore di char. Pertanto, a vector<char>può contenere più elementi rispetto a vector<int>prima che la memoria sia piena. Lo stesso vale per array di tipo C non elaborati come int[]e char[].

Inoltre, questo limite superiore può essere influenzato dal tipo di allocatorusato per costruire il vectorperché allocatorè libero di gestire la memoria come vuole. Un allocatore molto strano ma comunque concepibile potrebbe mettere in comune la memoria in modo tale che istanze identiche di un oggetto condividano risorse. In questo modo, è possibile inserire molti oggetti identici in un contenitore che altrimenti consumerebbe tutta la memoria disponibile.

A parte questo, C ++ non impone alcun limite.

Nessuno ha menzionato il limite sulla dimensione del frame dello stack .

Esistono due posizioni in cui è possibile allocare memoria:

• Sull'heap (memoria allocata dinamicamente).
  Il limite di dimensioni qui è una combinazione di hardware disponibile e la capacità del sistema operativo di simulare lo spazio utilizzando altri dispositivi per archiviare temporaneamente i dati non utilizzati (ad esempio, spostare le pagine sul disco rigido).
• Sullo stack (variabili dichiarate localmente).
  Il limite di dimensioni qui è definito dal compilatore (con possibili limiti hardware). Se leggi la documentazione del compilatore puoi spesso modificare questa dimensione.

Pertanto, se si assegna una matrice in modo dinamico (il limite è ampio e descritto in dettaglio da altri post.

int* a1 = new int[SIZE];  // SIZE limited only by OS/Hardware

In alternativa, se l'array è allocato nello stack, si è limitati dalle dimensioni del frame dello stack. NB I vettori e gli altri contenitori hanno una piccola presenza nello stack, ma di solito la maggior parte dei dati sarà nell'heap.

int a2[SIZE]; // SIZE limited by COMPILER to the size of the stack frame

Guardandolo dal punto di vista pratico piuttosto che teorico, su un sistema Windows a 32 bit, la quantità totale massima di memoria disponibile per un singolo processo è di 2 GB. Puoi superare il limite andando su un sistema operativo a 64 bit con molta più memoria fisica, ma se farlo o cercare alternative dipende molto dagli utenti previsti e dai loro budget. Puoi anche estenderlo in qualche modo usando PAE .

Il tipo di array è molto importante, poiché l'allineamento della struttura predefinita su molti compilatori è di 8 byte, il che è molto dispendioso se l'utilizzo della memoria è un problema. Se stai usando Visual C ++ per Windows, dai un'occhiata alla direttiva #pragma pack per superare questo.

Un'altra cosa da fare è guardare a ciò che le tecniche di compressione della memoria potrebbero aiutarti, come matrici sparse, compressione al volo, ecc ... Ancora una volta, questo dipende fortemente dall'applicazione. Se modifichi il tuo post per fornire ulteriori informazioni su ciò che è effettivamente nei tuoi array, potresti ottenere risposte più utili.

Modifica: date un po 'più di informazioni sui tuoi esatti requisiti, le tue esigenze di archiviazione sembrano essere comprese tra 7,6 GB e 76 GB non compressi, il che richiederebbe un box piuttosto costoso a 64 bit da archiviare come array in memoria in C ++. Solleva la domanda sul motivo per cui si desidera archiviare i dati in memoria, dove si presume la velocità di accesso e consentire l'accesso casuale. Il modo migliore per archiviare questi dati al di fuori di un array è praticamente basato su come si desidera accedervi. Se è necessario accedere ai membri dell'array in modo casuale, per la maggior parte delle applicazioni ci sono modi per raggruppare gruppi di dati che tendono ad avere accesso contemporaneamente. Ad esempio, in grandi database GIS e spaziali, i dati vengono spesso affiancati per area geografica. In termini di programmazione C ++ è possibile sovrascrivere l'operatore dell'array [] per recuperare parti dei dati dalla memoria esterna come richiesto.

Sono d'accordo con quanto sopra, che se stai inizializzando il tuo array con

 int myArray[SIZE] 

quindi SIZE è limitato dalla dimensione di un numero intero. Ma puoi sempre mallocare un pezzo di memoria e avere un puntatore ad esso, grande quanto vuoi fino a quando malloc non restituisce NULL.

Per riassumere le risposte, estenderle e rispondere direttamente alla domanda:

No, C ++ non impone alcun limite per le dimensioni di un array.

Ma poiché l'array deve essere archiviato da qualche parte nella memoria, si applicano anche i limiti relativi alla memoria imposti da altre parti del sistema informatico. Si noti che questi limiti non si riferiscono direttamente alle dimensioni (= numero di elementi) dell'array, ma piuttosto alle sue dimensioni (= quantità di memoria occupata). Dimensioni ( D ) e in memoria formato ( S ) di una matrice non è la stessa, in cui sono connesse da memoria occupata da un unico elemento ( E ): S = D * E .

AdessoE dipende da:

• il tipo di elementi dell'array (gli elementi possono essere più piccoli o più grandi)
• allineamento della memoria (per aumentare le prestazioni, gli elementi vengono posizionati su indirizzi che sono moltiplicati di un certo valore, il che introduce
  uno "spazio sprecato" (riempimento) tra gli elementi
• dimensione delle parti statiche degli oggetti (nella programmazione orientata agli oggetti i componenti statici degli oggetti dello stesso tipo vengono memorizzati una sola volta, indipendentemente dal numero di tali oggetti dello stesso tipo)

Si noti inoltre che generalmente si ottengono diverse limitazioni relative alla memoria allocando i dati dell'array sullo stack (come una variabile automatica int t[N]:), o sull'heap (alocation dinamico con malloc()/ newo utilizzando i meccanismi STL) o nella parte statica della memoria di processo (come una variabile statica:) static int t[N]. Anche durante l'allocazione su heap, è ancora necessaria una piccola quantità di memoria sullo stack per memorizzare i riferimenti ai blocchi di memoria allocati dall'heap (ma questo è trascurabile, di solito).

La dimensione del size_ttipo non ha alcuna influenza sul programmatore (suppongo che il programmatore utilizzi il size_ttipo per l'indicizzazione, poiché è progettato per esso), poiché il provider del compilatore deve typedefavere un tipo intero abbastanza grande da indirizzare la massima quantità di memoria possibile per la piattaforma data architettura.

Le fonti dei limiti delle dimensioni della memoria derivano

• quantità di memoria disponibile per il processo (che è limitata a 2 ^ 32 byte per applicazioni a 32 bit, anche su kernel OS a 64 bit),
• la divisione della memoria di processo (ad es. quantità della memoria di processo progettata per stack o heap),
• la frammentazione della memoria fisica (molti piccoli frammenti di memoria libera sparsi non sono applicabili alla memorizzazione di una struttura monolitica),
• quantità di memoria fisica,
• e la quantità di memoria virtuale.

Non possono essere "ottimizzati" a livello di applicazione, ma sei libero di utilizzare un compilatore diverso (per modificare i limiti delle dimensioni dello stack), o trasferire la tua applicazione a 64 bit o portarla su un altro sistema operativo o modificare il fisico / configurazione della memoria virtuale della macchina (virtuale? fisica?).

Non è raro (e nemmeno consigliabile) trattare tutti i suddetti fattori come disturbi esterni e quindi come possibili fonti di errori di runtime e controllare attentamente e reagire agli errori relativi all'allocazione di memoria nel codice del programma.

Quindi alla fine: mentre C ++ non impone alcun limite, devi comunque verificare condizioni avverse relative alla memoria quando esegui il tuo codice ... :-)

Come hanno notato molte risposte eccellenti, ci sono molti limiti che dipendono dalla versione del compilatore C ++, dal sistema operativo e dalle caratteristiche del computer. Tuttavia, suggerisco il seguente script su Python che controlla il limite sulla tua macchina.

Utilizza la ricerca binaria e su ogni iterazione verifica se la dimensione media è possibile creando un codice che tenta di creare un array della dimensione. Lo script tenta di compilarlo (scusate, questa parte funziona solo su Linux) e regola la ricerca binaria in base al successo. Controlla:

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)

Puoi salvarlo sul tuo computer e avviarlo, e stamperà la dimensione massima che puoi creare. Per la mia macchina è 2305843009213693951.

Una cosa che non credo sia stata menzionata nelle risposte precedenti.

Sento sempre un "cattivo odore" nel senso del refactoring quando le persone usano queste cose nel loro design.

Questo è un array enorme e forse non è il modo migliore per rappresentare i tuoi dati sia dal punto di vista dell'efficienza che dal punto di vista delle prestazioni.

Saluti,

rapinare

Se devi gestire dati di dimensioni così grandi, dovrai suddividerli in blocchi gestibili. Non si adatta tutto alla memoria su nessun piccolo computer. Probabilmente puoi caricare una parte dei dati dal disco (qualunque ragionevolmente si adatti), eseguire i tuoi calcoli e le modifiche ad esso, archiviarli sul disco, quindi ripetere fino al completamento.

Per quanto fastidiosamente non specifici come tutte le risposte attuali, sono per lo più giusti ma con molti avvertimenti, non sempre menzionati. In sostanza, hai due limiti superiori e solo uno di questi è qualcosa di realmente definito, quindi YMMV :

1. Termini per la compilazione

Fondamentalmente, ciò che il tuo compilatore consentirà. Per Visual C ++ 2017 su un box Windows 10 x64, questo è il mio limite massimo in fase di compilazione prima di incorrere nel limite di 2 GB,

unsigned __int64 max_ints[255999996]{0};

Se invece lo facessi,

unsigned __int64 max_ints[255999997]{0};

Vorrei ottenere:

Error C1126 automatic allocation exceeds 2G

Non sono sicuro di come 2G si adatta a 255999996/ 7. Ho cercato su Google entrambi i numeri, e l'unica cosa che ho trovato probabilmente correlata è stata questa * nix Domande e risposte su un problema di precisionedc . Ad ogni modo, non sembra importare quale tipo di array int stai cercando di riempire, ma solo quanti elementi possono essere allocati.

2. Limiti di esecuzione

Il tuo stack e heap hanno i loro limiti. Questi limiti sono sia valori che cambiano in base alle risorse di sistema disponibili, sia quanto sia "pesante" la tua stessa app. Ad esempio, con le mie attuali risorse di sistema, posso far funzionare questo:

int main()
{
    int max_ints[257400]{ 0 };
    return 0;
}

Ma se lo modifico solo un po '...

int main()
{
    int max_ints[257500]{ 0 };
    return 0;
}

Bam! Stack overflow!

Exception thrown at 0x00007FF7DC6B1B38 in memchk.exe: 0xC00000FD: Stack overflow (parameters: 0x0000000000000001, 0x000000AA8DE03000). Unhandled exception at 0x00007FF7DC6B1B38 in memchk.exe: 0xC00000FD: Stack overflow (parameters: 0x0000000000000001, 0x000000AA8DE03000).

E solo per dettagliare l'intera pesantezza del tuo punto app, questo è stato buono:

int main()
{
    int maxish_ints[257000]{ 0 };
    int more_ints[400]{ 0 };
    return 0;
}  

Ma ciò ha causato un overflow dello stack:

int main()
{
    int maxish_ints[257000]{ 0 };
    int more_ints[500]{ 0 };
    return 0;
}  

Sono sorpreso che la funzione membro max_size () di std :: vector non sia stata menzionata qui.

"Restituisce il numero massimo di elementi che il contenitore è in grado di contenere a causa delle limitazioni di implementazione del sistema o della libreria, ad esempio std :: distance (begin (), end ()) per il contenitore più grande."

Sappiamo che std::vectorè implementato come un array dinamico sotto il cofano, quindi max_size()dovremmo fornire un'approssimazione molto stretta della lunghezza massima di un array dinamico sul tuo computer.

Il seguente programma crea una tabella della lunghezza massima approssimativa dell'array per vari tipi di dati.

#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;
}

Sul mio macOS (clang versione 5.0.1), ottengo quanto segue:

|  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

Su ideone gcc 8.3 ottengo:

|  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

Va notato che questo è un limite teorico e che sulla maggior parte dei computer, la memoria si esaurirà molto prima di raggiungere questo limite. Ad esempio, vediamo che per type charon gcc, il numero massimo di elementi è uguale al massimo di std::size_t. Provando questo , otteniamo l'errore:

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()];

Infine, come sottolinea @MartinYork, per le matrici statiche la dimensione massima è limitata dalla dimensione della pila.

Come è già stato sottolineato, la dimensione dell'array è limitata dall'hardware e dal sistema operativo (man ulimit). Tuttavia, il tuo software potrebbe essere limitato solo dalla tua creatività. Ad esempio, puoi memorizzare il tuo "array" su disco? Hai davvero bisogno di long long ints? Hai davvero bisogno di un array denso? Hai bisogno di un array?

Una soluzione semplice sarebbe quella di utilizzare Linux a 64 bit. Anche se non disponi fisicamente di una RAM sufficiente per il tuo array, il sistema operativo ti consentirà di allocare la memoria come se la memoria virtuale disponibile per il tuo processo fosse probabilmente molto più grande della memoria fisica. Se è davvero necessario accedere a tutto nell'array, ciò equivale a memorizzarlo su disco. A seconda dei modelli di accesso, potrebbero esserci modi più efficienti per farlo (ad es .: usare mmap () o semplicemente archiviare i dati in sequenza in un file (nel qual caso basterebbe Linux a 32 bit)).

Vorrei aggirare questo creando un array dinamico 2d:

long long** a = new long long*[x];
for (unsigned i = 0; i < x; i++) a[i] = new long long[y];

di più su questo qui https://stackoverflow.com/a/936702/3517001