Come leggere riga per riga o un intero file di testo contemporaneamente?


86

Sono in un tutorial che introduce i file (come leggere e scrivere da \ a file)

Prima di tutto, questo non è un compito a casa, è solo un aiuto generale che sto cercando.

So leggere una parola alla volta, ma non so leggere una riga alla volta o come leggere l'intero file di testo.

Cosa succede se il mio file contiene 1000 parole? Non è pratico leggere ogni parola.

Il mio file di testo denominato (Leggi) contiene quanto segue:

Mi piace giocare adoro leggere Ho 2 libri

Questo è ciò che ho realizzato finora:

#include <iostream>
#include <fstream>

using namespace std;
int main (){

  ifstream inFile;
  inFile.open("Read.txt");

  inFile >>

Esiste un modo per leggere l'intero file in una volta, invece di leggere ogni riga o ogni parola separatamente?




La lettura parola per parola è solo marginalmente più lenta di riga per riga. Se hai davvero bisogno di parole, allora è meglio leggere le parole. Leggi le righe se hai a che fare con dati orientati alla riga come file CSV.

@Arkadiy che non è corretto. Per un file da 100 MiB, la lettura riga per riga richiederà facilmente secondi, mentre si legge un blocco di 4 KiB alla volta, secondi meno di un secondo.
Vallentin

@Vallentin: dato che i flussi sono tutti bufferizzati, la lettura effettiva del disco viene già eseguita blocco per blocco. Il resto sta solo manipolando i dati in memoria.

Risposte:


163

Puoi usare std::getline:

#include <fstream>
#include <string>

int main() 
{ 
    std::ifstream file("Read.txt");
    std::string str; 
    while (std::getline(file, str))
    {
        // Process str
    }
}

Nota anche che è meglio costruire il flusso di file con i nomi dei file nel suo costruttore piuttosto che aprirlo esplicitamente (lo stesso vale per la chiusura, lascia che sia il distruttore a fare il lavoro).

Ulteriore documentazione su std::string::getline()può essere letta su CPP Reference .

Probabilmente il modo più semplice per leggere un intero file di testo è semplicemente concatenare quelle righe recuperate.

std::ifstream file("Read.txt");
std::string str;
std::string file_contents;
while (std::getline(file, str))
{
  file_contents += str;
  file_contents.push_back('\n');
}  

9
Sebbene non sia ovvio, while(getline(f, line)) { ...}è davvero il modo consigliato per farlo. Questo è spiegato qui: gehrcke.de/2011/06/… --- lì trovi anche approcci utili per una corretta gestione degli errori.
Dr. Jan-Philip Gehrcke

1
Il codice sopra non verrà compilato senza#include <iostream>
Tyguy7

@ Tyguy7 Perché dovrebbe #include <iostream>essere richiesto? Mi sembra che <fstream>sia <string>sufficiente. Se vuoi dire std::getline, è dentro <string>, non dentro <iostream>.
Fabio dice Reinstate Monica

@FabioTurati non ne sono sicuro, so solo che una volta incluso, tutto è stato compilato bene.
Tyguy7

19

So che questo è un thread davvero molto vecchio, ma vorrei anche sottolineare un altro modo che è in realtà molto semplice ... Questo è un codice di esempio:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main() {

    ifstream file("filename.txt");
    string content;

    while(file >> content) {
        cout << content << ' ';
    }
    return 0;
}

2
Bella risposta, l'ho usato con uno stringstream invece di cout per ottenere l'intero file in un gigantesco stringstream
bjackfly

5

Penso che potresti usare la funzione istream .read (). Puoi semplicemente eseguire un ciclo con una dimensione ragionevole del blocco e leggere direttamente nel buffer di memoria, quindi aggiungerlo a una sorta di contenitore di memoria arbitrario (come std :: vector). Potrei scrivere un esempio, ma dubito che tu voglia una soluzione completa; per favore fatemi sapere se avete bisogno di ulteriori informazioni.


Non so chi abbia votato negativamente questa risposta, ma questo è un bene potrebbe essere che non sono conforme ai tuoi standard ma uso la stessa cosa
Javasist

4

Bene, per fare questo si può anche usare la funzione freopen fornita in C ++ - http://www.cplusplus.com/reference/cstdio/freopen/ e leggere il file riga per riga come segue -:

#include<cstdio>
#include<iostream>

using namespace std;

int main(){
   freopen("path to file", "rb", stdin);
   string line;
   while(getline(cin, line))
       cout << line << endl;
   return 0;
}

1

Un altro metodo che non è stato ancora menzionato è std::vector.

std::vector<std::string> line;

while(file >> mystr)
{
   line.push_back(mystr);
}

Quindi puoi semplicemente iterare sul vettore e modificare / estrarre ciò di cui hai bisogno /


4
Il vectorè un passo inutile. Potresti iterare ifstreamsull'uso std::istream_iterator<std::string>(inFile).
Joseph Mansfield,

0

puoi anche usarlo per leggere tutte le righe nel file una per una e poi stampare i

#include <iostream>
#include <fstream>

using namespace std;



bool check_file_is_empty ( ifstream& file){
    return file.peek() == EOF ;
}

int main (){


    string text[256];
    int lineno ;
    ifstream file("text.txt");
    int num = 0;

    while (!check_file_is_empty(file))
    {    
        getline(file , text[num]);
        num++;
    }
    for (int i = 0; i < num ; i++)
    {
        cout << "\nthis is the text in " <<  "line " << i+1 << " :: " << text[i] << endl ;


    }
    
    system("pause");

    return 0;
}

spero che questo possa aiutarti :)


0

ciao fratello questo è un modo per leggere la stringa nella riga esatta usando questo codice

spero che questo possa aiutarti!

#include <iostream>
#include <fstream>

using namespace std;


int main (){


    string text[1];
    int lineno ;
    ifstream file("text.txt");
    cout << "tell me which line of the file you want : " ;
    cin >> lineno ; 



    for (int i = 0; i < lineno ; i++)
    {
        
        getline(file , text[0]);

    }   

    cout << "\nthis is the text in which line you want befor  :: " << text[0] << endl ;
    system("pause");

    return 0;
}

In bocca al lupo !

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.