Visualizzazione dei risultati da 1 a 10 su 10

Discussione: [C++] Stack Overflow

  1. #1

    [C++] Stack Overflow

    Ciao a tutti ho un problema bello e buono da risolvere.

    Devo fare per l'università una esercitazione e per fare i calcoli sto scrivendo un programmino in C++.
    Ho però un problema....di stack overflow.
    In pratica quel che devo fare:
    Ho un numero n di sezioni lungo la condotta in cui in per vari valori di tempo N devo calcolare vari parametri (pressione e velocità).
    Avevo impostato il tutto con 2 array multidimensionali di tipo double del tipo:
    codice:
    double parametro[N][n]
    ma per valori troppo elevati di N e n il programma non parte e mi restituisce Stack Overflow... abbassando n e N il programma funziona.
    Idee?? che limiti ho?
    Rispondete il prima possibile

    Grazie

  2. #2
    crei la matrice dentro una funzione?
    Se la metti globale?
    Se no dovresti usare l'allocazione dinamica...

  3. #3
    eh???
    per ora..per far le cose abbastanza velocemente dentro la main ho creato queste matrici che vado a riempire, sono sempre dentro main() e uso un pò di cicli nulla di più.

    uso una funzione esterna solo per dare un valore in certi casi a queste matrici, una cosa del tipo:
    matrice[i][j]=funzione(par1,par2,..);

    ..(allocazione dinamica??..servirebbe a..?)

  4. #4
    prova a fare così
    #includeblablabla
    crei matrici
    int main(void)
    {tutto tranne creazione matrici
    }

    se non ti funziona posta il codice, così posso verificare il problema
    cmq l'allocazione dinamica serve a creare oggetti di grandezza non fissa (che vengono salvati nello stack).

  5. #5
    Le variabili locali non vanno bene per allocare grosse quantità di dati, dal momento che sono allocate sullo stack, che ha dimensione abbastanza limitata (nell'ordine dei megabyte sulle macchine "normali").
    Se devi gestire grandi quantità di dati devi usare l'allocazione dinamica (new[]/delete[]), che usa la memoria dall'heap, che è in genere limitato solo dalla disponibilità di memoria virtuale e di spazio di indirizzi del processo.
    Amaro C++, il gusto pieno dell'undefined behavior.

  6. #6
    Originariamente inviato da MItaly
    Se devi gestire grandi quantità di dati devi usare l'allocazione dinamica (new[]/delete[]), che usa la memoria dall'heap, che è in genere limitato solo dalla disponibilità di memoria virtuale e di spazio di indirizzi del processo.
    Cioè 4GB ? O_O
    Spesso mi chiedo veramente a cosa serva l'allocazione dinamica, solo a quello ?
    Oltre a allocare risorse di memoria indefinita e a poterla manipolare a piacimento, tipo aggiungere o togliere memoria, però poi oltre a quello, a che serve ?
    E' da un po' che me lo chiedo.

  7. #7
    Originariamente inviato da menphisx
    Cioè 4GB ? O_O
    Cioè dipende da sistema operativo e configurazione. Sui sistemi a 64 bit è più facile che finisca per prima la memoria virtuale (RAM+paging), sui sistemi a 32 bit attuali in genere finisce prima lo spazio di indirizzi virtuale, che è di 2 GB per Windows (3 usando un particolare switch per il kernel), e in genere 3 GB per Linux a 32 bit. In genere poi non sarà comunque possibile fare singole allocazioni così grosse perché lo spazio di indirizzi è in parte frammentato.
    Spesso mi chiedo veramente a cosa serva l'allocazione dinamica, solo a quello ?
    Oltre a allocare risorse di memoria indefinita e a poterla manipolare a piacimento, tipo aggiungere o togliere memoria, però poi oltre a quello, a che serve ?
    E' da un po' che me lo chiedo.
    Come ho scritto qui, è strettamente necessaria:
    • quando non è noto a compile-time quanti oggetti di un certo tipo sono necessari (ad esempio gli elementi delle liste linkate);
    • quando servono strutture dati di dimensioni note solo a compile-time (ad esempio stringhe basate su input arbitrario);
    • quando la dimensione di una struttura dati è nota al momento della compilazione, ma è troppo grande per lo stack e non avrebbe senso renderla globale (ad esempio grossi vettori da manipolare); nota tra l'altro che tutte le variabili globali in genere vengono mappate 1:1 in una sezione dell'eseguibile, per cui creare un vettore globale di 1 MB farà crescere le dimensioni dell'eseguibile finale di 1 MB;
    • last but not least, quando è necessario avere un oggetto la cui durata di vita è diversa da quanto previsto per le variabili automatiche, che sono legate allo scope in cui sono dichiarate (=>sono distrutte quando l'esecuzione esce dal loro scope); ad esempio, dati che sono condivisi tra oggetti con durate di vita differenti e cancellati quando non vengono più usati.

    Non è completamente impossibile cavarsela senza allocazione dinamica (molti progetti per microcontrollori sono fatti senza), ma ci sono dei casi in cui di fatto la si deve emulare usando grossi buffer statici e scrivendosi un allocatore.
    Amaro C++, il gusto pieno dell'undefined behavior.

  8. #8
    Ok grazie MItaly molto interessante
    [OT]
    Ma per gestire quindi grosse quantità di dati, tipo file da 1 GB in su, come si fa ?
    [/OT]

    Marco.

  9. #9
    In genere si usano i file mappati in memoria, mappando effettivamente nello spazio di indirizzi solo le porzioni di file in uso al momento.
    Amaro C++, il gusto pieno dell'undefined behavior.

  10. #10
    Originariamente inviato da MItaly
    In genere si usano i file mappati in memoria, mappando effettivamente nello spazio di indirizzi solo le porzioni di file in uso al momento.
    Buono a sapersi.


Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.