C++ errore: terminare la chiamata dopo il lancio di un’istanza di ‘std::bad_alloc’

Ho scritto il codice incollato di seguito per eseguire le seguenti operazioni nell’ordine in cui sono indicati:

  1. Leggere un file di input e di contare il numero di voci
  2. Creare un array di dimensioni appropriate (di dimensione pari al numero di voci)
  3. Tornare all’inizio del file di input e leggerlo di nuovo
  4. Memorizzare le voci in un array
  5. Stampare il numero di voci nel file e le voci stesse.

Ecco il mio codice:

#include <iostream>
#include <fstream>
#include <exception>

using namespace std;

int main(int argc, char* argv[]){

    ifstream inFile(argv[1]); //passing arguments to the main function
    int numEntries;

    if(!inFile){
        cout << "file not found" << endl;
        return 1;
    }

    string entry;
    while (!inFile.eof()){ //counting the number of entries
        getline(inFile,entry);
        ++numEntries;
    }

    const int length = numEntries;  //making an array of appropriate length
    int*arr = new int[length];

    inFile.clear();             //going back to the beginning of the file
    inFile.seekg(0, ios::beg);

    int i = 0;
    const int size = numEntries;    //making an array to store the entries in the file
    int matrix[size];
    int pos = 0;

    int variable = 0;
    while(pos < size){
        inFile >> variable;
        matrix[pos] = variable;
        ++pos;
    }
    cout<< numEntries << "entries have been read"<< endl; 
    inFile.close();
    for(int i = 0; i < pos; ++i)
        cout << matrix[i] << endl; //printing out the entries
    return 0;
}

Quando provo a eseguire il .file cpp continuo a ricevere il messaggio di errore:

terminare la chiamata dopo il lancio di un'istanza di 'std::bad_alloc' 
che cosa(): std::bad_alloc 
Interrotta (core dumped)

Ho raccolto questo ha a che fare con una carenza di memoria o variabili di caduta, la funzione main (), ma non riesco a capire come affrontare il problema in questo caso specifico. Se è rilevante, sto lavorando su un computer Linux.

  • Il programma presenta un comportamento indefinito. numEntries non è mai inizializzato. Esso contiene casuale di immondizia, probabilmente, di un numero molto grande.
  • Lo strumento giusto per risolvere tali problemi è il debugger. Si dovrebbe passaggio attraverso il codice riga per riga, prima di chiedere su Stack Overflow. Per ulteriori informazioni, si prega di leggere Come eseguire il debug di programmi di piccole dimensioni (da Eric Lippert). Come minimo, si dovrebbe [modifica] la tua domanda per includere un Minimal, Completi e Verificabili esempio che riproduce il problema, insieme con le osservazioni che hai fatto nel debugger.
  • Se ti capita spesso di non riuscire a inizializzare i dati, si dovrebbe passare a Windows/Visual Studio. Le funzionalità di Visual Studio di analisi statica del codice, che arriva in questi tipi di bug facilmente.
  • Non è il problema, ma questo codice è troppo indiretto. Sbarazzarsi di length e size; basta usare numEntries in entrambi i luoghi (dopo aver risolto il bug che @IgorTandetnik sottolineato). E di sbarazzarsi di variable e leggere direttamente in matrix[pos]. Inoltre, non c’è bisogno di close il file di input. Il flusso di distruttore di fare.
  • “Lo strumento giusto per risolvere tali problemi è il debugger.” – Solo se a) il tempo non ha valore, e b) sono mancanti utensileria idonea.
  • Perché non utilizzare std::vector e leggere il file una sola volta e push_back ogni entry? In questo modo, tutti i fori nel vostro codice sarà riempito.

InformationsquelleAutor 2good4this | 2016-10-08

 

2 Replies
  1. 4

    Questo codice ha 3 fori:


    Primo foro: int numEntries. Poi lo si fa: ++numEntries;

    Si incrementa non specificato valore. Non so se è UB, ma ancora male.


    Secondo e terzo foro:

    const int length = numEntries;
    int* arr = new int[length];

    E

    const int size = numEntries;
    int matrix[size];

    numEntries ha non specificato valore (primo foro). Si usa per inizializzare length e size – che è Definito il Comportamento. Ma supponiamo si tratta solo di qualche numero grande – si alloca memoria di un imprecisato dimensioni (forse solo di grandi dimensioni), quindi il std::bad_alloc eccezione – che significa che si desidera allocare più memoria disponibile.

    Anche, matrix è VLA indeterminata dimensione, che è non-standard e comportamenti Indefiniti.

  2. 0

    Per me, 1 sec di perdita di messa a fuoco, costo 30 minuti di debug:

    class Cls1{
        int nV;   // <------------- nV is un-initialized
        vector<bool> v1;
    public:
        Cls1 () {
            v1 = vector<bool> (nV + 1, false);  //<------------------ nV is used
        }
    };

    Come si può vedere nV è inizializzata, ma è utilizzato in seguito costruttore.

    Dal momento che il nV ha preso il valore dell’immondizia, diverso per ogni esecuzione, il programma a volte funzionano e a volte si blocca quando nV valore dell’immondizia è molto, molto alta.

    Non volevo usare v1 nel programma che ho scritto, ma in futuro programma, quindi non ho nemmeno guardare in esso.

    Temporaneamente, fino a quando ho risolto il problema, ho spostato un compilatore online, lì non crash, probabilmente a causa di diverse inizializzazione, https://rextester.com/l/cpp_online_compiler_gcc

    Il giorno successivo, ho relooked nel programma, era il 1 ° di linea in un costruttore, un inutilizzati variabile, ha causato il problema, non so perché, Apache Netbeans non vedi questo come un avvertimento.

    Se si utilizza il controllo del codice sorgente, commettendo spesso, si trova facilmente.

    Speranza che aiuta.

Lascia un commento