HOWTO · C++

Leggi il file nella stringa in C++

In questo articolo viene illustrato come leggere il file in una stringa in C++

In questa pagina

Per leggere un file in una std::string, usa std::ifstream con std::getline se vuoi elaborare le righe, oppure costruisci la stringa con std::istreambuf_iterator<char> se vuoi leggere l’intero flusso. Gli esempi seguenti creano ciascuno il proprio file temporaneo di input, così ogni programma può essere compilato ed eseguito autonomamente.

Usare std::ifstream e std::getline per leggere un file in una stringa in C++

std::getline rimuove il delimitatore di riga. Aggiungere "\n" dopo ogni chiamata riuscita ripristina i separatori, ma aggiunge anche un carattere di nuova riga dopo l’ultima riga, persino quando il file sorgente non ne termina con uno. Se questa differenza è importante, tieni traccia della presenza del delimitatore oppure usa uno dei metodi per leggere l’intero flusso descritti più avanti.

Questo esempio completo scrive due righe in un file temporaneo, lo apre con std::ifstream e aggiunge ogni riga a una stringa. La spiegazione prima dell’esempio descrive il normale caso d’uso in cui tutto procede correttamente.

#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-lines.txt";
    {
        std::ofstream sample(path);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::ifstream inputFile(path);
    if (!inputFile) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    std::string fileContent;
    std::string line;
    while (std::getline(inputFile, line)) {
        fileContent += line + "\n";
    }
    if (inputFile.bad()) {
        std::cout << "Read failed\n";
        inputFile.close();
        std::filesystem::remove(path);
        return 0;
    }

    std::cout << fileContent;
    inputFile.close();
    std::filesystem::remove(path);
}

Il ciclo termina quando std::getline non riesce più a estrarre una riga. Controllare bad() permette di distinguere un errore di I/O di basso livello dalla normale fine del flusso. Per impostazione predefinita, il file viene aperto in modalità testo; sui sistemi che convertono i terminatori di riga, i byte nella stringa risultante possono differire da quelli memorizzati nel file. Usa la modalità binaria quando è necessario preservare i byte esattamente.

Usare std::istreambuf_iterator per leggere un file in una stringa in C++

Per leggere l’intero flusso, costruisci una stringa a partire da una coppia di iteratori std::istreambuf_iterator<char>. Il primo iteratore legge dal buffer del flusso, mentre quello costruito per impostazione predefinita indica la fine. In questo modo i dati vengono letti senza suddividerli in righe e vengono mantenuti i caratteri di nuova riga forniti dal flusso.

#include <filesystem>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-iterator.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::ifstream inputFile(path, std::ios::binary);
    if (!inputFile) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    const std::string fileContent{
        std::istreambuf_iterator<char>(inputFile),
        std::istreambuf_iterator<char>()};
    if (inputFile.bad()) {
        std::cout << "Read failed\n";
    } else {
        std::cout << fileContent << '\n';
    }
    inputFile.close();
    std::filesystem::remove(path);
}
alpha
beta

Usa questa forma quando l’intero file entra in memoria e non è necessario elaborarlo riga per riga. Aprire il file in modalità binaria evita la conversione dei terminatori di riga tipica della modalità testo. Una std::string può contenere byte nulli, ma le funzioni che trattano c_str() come una stringa di testo terminata da un carattere nullo potrebbero fermarsi al primo di essi.

Usare rdbuf per leggere un file in una stringa in C++

Un’altra possibilità offerta dalla libreria standard consiste nell’inserire rdbuf() del flusso di input in un std::ostringstream e poi chiamare str() per ottenere il contenuto sotto forma di std::string. È comodo quando il flusso di stringhe fa già parte del codice circostante. Se è necessario segnalare gli errori di lettura, controlla il flusso di input dopo il trasferimento.

#include <filesystem>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-rdbuf.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::ifstream inputFile(path, std::ios::binary);
    if (!inputFile) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    std::ostringstream stream;
    stream << inputFile.rdbuf();
    if (inputFile.bad()) {
        std::cout << "Read failed\n";
    } else {
        const std::string fileContent = stream.str();
        std::cout << fileContent << '\n';
    }
    inputFile.close();
    std::filesystem::remove(path);
}

L’inserimento copia i caratteri dal buffer del file nel flusso di stringhe; str() restituisce la stringa accumulata. Per costruire direttamente una stringa con l’intero file, l’approccio con gli iteratori richiede meno passaggi. In entrambi i casi è comunque necessario verificare che il file sia stato aperto e che non si siano verificati errori di lettura.

Usare la funzione fread per leggere un file in una stringa

fread è una funzione della libreria standard C utilizzabile anche in C++. È utile quando il codice usa già flussi FILE* o richiede un’API C orientata ai byte. Non è intrinsecamente più veloce degli approcci basati sui flussi C++; le prestazioni dipendono dal carico di lavoro e dall’implementazione.

Questo esempio usa fseek e ftell per determinare la dimensione di un file di esempio scorribile, alloca una stringa di quella dimensione e vi legge i byte. Per flussi non scorribili o file troppo grandi per la memoria, leggi invece blocchi di dimensione fissa. La dimensione del file può cambiare tra la misurazione e la lettura: è quindi comunque necessario controllare il numero di byte restituito e ferror.

#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-fread.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    std::FILE* file = std::fopen(path.string().c_str(), "rb");
    if (file == nullptr) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    if (std::fseek(file, 0, SEEK_END) != 0) {
        std::cout << "Could not seek sample file\n";
        std::fclose(file);
        std::filesystem::remove(path);
        return 0;
    }
    const long length = std::ftell(file);
    if (length < 0 || std::fseek(file, 0, SEEK_SET) != 0) {
        std::cout << "Could not determine sample size\n";
        std::fclose(file);
        std::filesystem::remove(path);
        return 0;
    }

    std::string content(static_cast<std::size_t>(length), '\0');
    const std::size_t bytesRead = std::fread(content.data(), 1, content.size(), file);
    const bool failed = std::ferror(file) != 0 || bytesRead != content.size();
    std::fclose(file);
    std::filesystem::remove(path);

    if (failed) {
        std::cout << "Read failed or file changed while reading\n";
        return 0;
    }
    std::cout << content << '\n';
}

Il terzo argomento indica il numero di elementi e il secondo la dimensione di ciascun elemento; usando 1 come dimensione dell’elemento, il valore restituito corrisponde al numero di byte. fread può restituire meno byte di quelli richiesti, quindi non dare per scontato che una singola chiamata riempia il buffer. Questo esempio riguarda un file scorribile e usa l’intervallo long supportato da ftell; per file più grandi, le applicazioni dovrebbero usare API per file di grandi dimensioni appropriate alla piattaforma oppure leggere a blocchi. La stringa memorizza byte e non aggiunge un terminatore nullo per le funzioni che operano su stringhe C.

Usare read per leggere un file in una stringa

La funzione POSIX read opera su un descrittore di file e su un buffer fornito dal chiamante. Non fa parte del C++ standard: includi gli header POSIX appropriati e usa questo metodo solo sulle piattaforme che forniscono l’API. Una chiamata riuscita può restituire meno byte di quelli richiesti, quindi ripeti le chiamate fino alla fine del file e gestisci interruzioni ed errori.

Il programma POSIX specifico seguente legge a blocchi, senza basarsi su una misurazione preventiva della dimensione del file. Le sue chiamate di sistema non sono disponibili su tutte le piattaforme C++, quindi consideralo un esempio POSIX e non codice C++ portabile.

#include <cerrno>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
#include <fcntl.h>
#include <unistd.h>

int main() {
    const auto path = std::filesystem::temp_directory_path() / "cpp-string-read.txt";
    {
        std::ofstream sample(path, std::ios::binary);
        sample << "alpha\nbeta";
        if (!sample) {
            std::cout << "Could not create sample file\n";
            return 0;
        }
    }

    const int fd = ::open(path.c_str(), O_RDONLY);
    if (fd < 0) {
        std::cout << "Could not open sample file\n";
        std::filesystem::remove(path);
        return 0;
    }

    std::string content;
    char buffer[4096];
    bool failed = false;
    for (;;) {
        const ssize_t count = ::read(fd, buffer, sizeof buffer);
        if (count > 0) {
            content.append(buffer, static_cast<std::size_t>(count));
        } else if (count == 0) {
            break;
        } else if (errno != EINTR) {
            failed = true;
            break;
        }
    }
    if (::close(fd) != 0) {
        failed = true;
    }
    std::filesystem::remove(path);

    if (failed) {
        std::cout << "Read or close failed\n";
        return 0;
    }
    std::cout << content << '\n';
}

Per un file normale, read restituisce zero alla fine del file. Con altri tipi di descrittore, il comportamento dipende dal dispositivo o dal flusso. Ogni valore positivo restituito indica il numero di byte da aggiungere; un valore negativo segnala un errore, mentre EINTR indica che la chiamata può essere ripetuta. Chiudi sempre il descrittore e gestisci le letture parziali senza presumere che una sola chiamata riempia il buffer richiesto. L’esempio usa std::string::append per preservare il numero esatto di byte, inclusi eventuali byte nulli.

Conclusione

Per scrivere codice C++ portabile, scegli std::istreambuf_iterator o rdbuf() quando vuoi trasformare l’intero flusso in una stringa, e usa std::getline quando è utile elaborare le righe. Ricorda che l’estrazione delle righe rimuove i delimitatori e che aggiungerli di nuovo può modificare una riga finale priva di terminatore. Usa fread quando l’interfaccia C FILE* si integra bene con il codice circostante, e ricorri a read di POSIX solo quando è adatta la sua API specifica per descrittori. Per i file grandi, valuta l’elaborazione a blocchi invece di mantenere l’intero file in memoria e controlla sia l’apertura sia l’esito delle letture.