Jak odczytać cały plik do std::string w C++?

Jeśli masz C++ 17 (std::filesystem), istnieje również ten sposób (który pobiera rozmiar pliku przez std::filesystem::file_size zamiast seekg i tellg):

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

namespace fs = std::filesystem;

std::string readFile(fs::path path)
{
    // Open the stream to 'lock' the file.
    std::ifstream f(path, std::ios::in | std::ios::binary);

    // Obtain the size of the file.
    const auto sz = fs::file_size(path);

    // Create a buffer.
    std::string result(sz, '\0');

    // Read the whole file into the buffer.
    f.read(result.data(), sz);

    return result;
}

Uwaga: może być konieczne użycie <experimental/filesystem> i std::experimental::filesystem, jeśli Twoja standardowa biblioteka nie obsługuje jeszcze w pełni C++ 17. Może być także konieczne zastąpienie result.data() przez &result[0], jeśli nie obsługuje ono non-const std ::basic_string danych.

Używać

#include <iostream>
#include <sstream>
#include <fstream>

int main()
{
  std::ifstream input("file.txt");
  std::stringstream sstr;

  while(input >> sstr.rdbuf());

  std::cout << sstr.str() << std::endl;
}

lub coś bardzo blisko. Nie mam otwartego odniesienia do stdlib, aby samemu sprawdzić.

Tak, rozumiem, że nie napisałem funkcji slurp zgodnie z pytaniem.

Nie mam wystarczającej reputacji, aby bezpośrednio komentować odpowiedzi za pomocą tellg().

Należy pamiętać, że tellg() może zwrócić -1 w przypadku błędu. Jeśli przekazujesz wynik tellg() jako parametr alokacji, powinieneś najpierw sprawdzić wynik.

Przykład problemu:

...
std::streamsize size = file.tellg();
std::vector<char> buffer(size);
...

W powyższym przykładzie, jeśli tellg() napotka błąd, zwróci -1. Niejawne rzutowanie pomiędzy znakiem (tj. wynikiem tellg()) i unsigned (tj. argumentem do konstruktora vector<char>) spowoduje, że wektor błędnie przydzieli bardzo dużą liczbę bajtów. (Prawdopodobnie 4294967295 bajtów, czyli 4 GB.)

Modyfikowanie odpowiedzi paxos1977 w celu uwzględnienia powyższego:

string readFile2(const string &fileName)
{
    ifstream ifs(fileName.c_str(), ios::in | ios::binary | ios::ate);

    ifstream::pos_type fileSize = ifs.tellg();
    if (fileSize < 0)                             <--- ADDED
        return std::string();                     <--- ADDED

    ifs.seekg(0, ios::beg);

    vector<char> bytes(fileSize);
    ifs.read(&bytes[0], fileSize);

    return string(&bytes[0], fileSize);
}

To rozwiązanie dodaje sprawdzanie błędów do metody opartej na rdbuf().

std::string file_to_string(const std::string& file_name)
{
    std::ifstream file_stream{file_name};

    if (file_stream.fail())
    {
        // Error opening file.
    }

    std::ostringstream str_stream{};
    file_stream >> str_stream.rdbuf();  // NOT str_stream << file_stream.rdbuf()

    if (file_stream.fail() && !file_stream.eof())
    {
        // Error reading file.
    }

    return str_stream.str();
}

Dodaję tę odpowiedź, ponieważ dodanie sprawdzania błędów do oryginalnej metody nie jest tak trywialne, jak można by się spodziewać. Oryginalna metoda wykorzystuje operator wstawiania stringstream (str_stream << file_stream.rdbuf()). Problem polega na tym, że ustawia to bit błędu strumienia stringstream, gdy nie są wstawiane żadne znaki. Może to być spowodowane błędem lub pustym plikiem. Jeśli sprawdzasz błędy, sprawdzając bit błędu, podczas czytania pustego pliku napotkasz fałszywy alarm. Jak ujednoznacznić uzasadniony brak wstawienia jakichkolwiek znaków i „niepowodzenie” wstawienia jakichkolwiek znaków, ponieważ plik jest pusty?

Możesz pomyśleć o jawnym sprawdzeniu pustego pliku, ale to więcej kodu i powiązanego sprawdzania błędów.

Sprawdzanie warunku niepowodzenia str_stream.fail() && !str_stream.eof() nie działa, ponieważ operacja wstawiania nie ustawia eofbitu (w strumieniu ostring ani w strumieniu if).

Rozwiązaniem jest zatem zmiana operacji. Zamiast używać operatora wstawiania ostringstream (‹‹), użyj operatora wyodrębniania ifstream (>>), który ustawia eofbit. Następnie sprawdź warunek awarii file_stream.fail() && !file_stream.eof().

Co ważne, gdy file_stream >> str_stream.rdbuf() napotka uzasadnioną awarię, nie powinien nigdy ustawiać eofbitu (zgodnie z moim zrozumieniem specyfikacji). Oznacza to, że powyższa kontrola jest wystarczająca do wykrycia uzasadnionych błędów.

Coś takiego nie powinno być takie złe:

void slurp(std::string& data, const std::string& filename, bool is_binary)
{
    std::ios_base::openmode openmode = ios::ate | ios::in;
    if (is_binary)
        openmode |= ios::binary;
    ifstream file(filename.c_str(), openmode);
    data.clear();
    data.reserve(file.tellg());
    file.seekg(0, ios::beg);
    data.append(istreambuf_iterator<char>(file.rdbuf()), 
                istreambuf_iterator<char>());
}

Zaletą jest to, że najpierw robimy rezerwę, więc nie będziemy musieli powiększać ciągu podczas wczytywania. Wadą jest to, że robimy to znak po znaku. Inteligentniejsza wersja mogłaby pobrać cały bufor odczytu, a następnie wywołać niedopełnienie.

Oto wersja korzystająca z nowej biblioteki systemu plików z dość solidną kontrolą błędów:

#include <cstdint>
#include <exception>
#include <filesystem>
#include <fstream>
#include <sstream>
#include <string>

namespace fs = std::filesystem;

std::string loadFile(const char *const name);
std::string loadFile(const std::string &name);

std::string loadFile(const char *const name) {
  fs::path filepath(fs::absolute(fs::path(name)));

  std::uintmax_t fsize;

  if (fs::exists(filepath)) {
    fsize = fs::file_size(filepath);
  } else {
    throw(std::invalid_argument("File not found: " + filepath.string()));
  }

  std::ifstream infile;
  infile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
  try {
    infile.open(filepath.c_str(), std::ios::in | std::ifstream::binary);
  } catch (...) {
    std::throw_with_nested(std::runtime_error("Can't open input file " + filepath.string()));
  }

  std::string fileStr;

  try {
    fileStr.resize(fsize);
  } catch (...) {
    std::stringstream err;
    err << "Can't resize to " << fsize << " bytes";
    std::throw_with_nested(std::runtime_error(err.str()));
  }

  infile.read(fileStr.data(), fsize);
  infile.close();

  return fileStr;
}

std::string loadFile(const std::string &name) { return loadFile(name.c_str()); };

Ponieważ wydaje się to powszechnie używanym narzędziem, moje podejście polegałoby na wyszukiwaniu i preferowaniu już dostępnych bibliotek od ręcznie stworzonych rozwiązań, zwłaszcza jeśli biblioteki wspomagające są już połączone (flagi linkera -lboost_system -lboost_filesystem) w twoim projekcie. Tutaj (i starsze wersje boost), boost zapewnia narzędzie loading_string_file:

#include <iostream>
#include <string>
#include <boost/filesystem/string_file.hpp>

int main() {
    std::string result;
    boost::filesystem::load_string_file("aFileName.xyz", result);
    std::cout << result.size() << std::endl;
}

Zaletą tej funkcji jest to, że nie wyszukuje całego pliku w celu określenia rozmiaru, zamiast tego używa wewnętrznie funkcji stat(). Jednak jako prawdopodobnie nieistotną wadę można łatwo wywnioskować po sprawdzeniu kodu źródłowego: rozmiar łańcucha jest niepotrzebnie zmieniany za pomocą znaku '\0', który jest przepisywany przez zawartość pliku.

Możesz użyć funkcji „std::getline” i określić „eof” jako ogranicznik. Wynikowy kod jest jednak trochę niejasny:

std::string data;
std::ifstream in( "test.txt" );
std::getline( in, data, std::string::traits_type::to_char_type( 
                  std::string::traits_type::eof() ) );

#include <string>
#include <sstream>

using namespace std;

string GetStreamAsString(const istream& in)
{
    stringstream out;
    out << in.rdbuf();
    return out.str();
}

string GetFileAsString(static string& filePath)
{
    ifstream stream;
    try
    {
        // Set to throw on failure
        stream.exceptions(fstream::failbit | fstream::badbit);
        stream.open(filePath);
    }
    catch (system_error& error)
    {
        cerr << "Failed to open '" << filePath << "'\n" << error.code().message() << endl;
        return "Open fail";
    }

    return GetStreamAsString(stream);
}

stosowanie:

const string logAsString = GetFileAsString(logFilePath);

Zaktualizowana funkcja oparta na rozwiązaniu CTT:

#include <string>
#include <fstream>
#include <limits>
#include <string_view>
std::string readfile(const std::string_view path, bool binaryMode = true)
{
    std::ios::openmode openmode = std::ios::in;
    if(binaryMode)
    {
        openmode |= std::ios::binary;
    }
    std::ifstream ifs(path.data(), openmode);
    ifs.ignore(std::numeric_limits<std::streamsize>::max());
    std::string data(ifs.gcount(), 0);
    ifs.seekg(0);
    ifs.read(data.data(), data.size());
    return data;
}

Istnieją dwie istotne różnice:

tellg() nie gwarantuje zwrócenia przesunięcia w bajtach od początku pliku. Zamiast tego, jak zauważył Puzomor Croatia, jest to raczej token, którego można używać w wywołaniach fstream. gcount() jednakże zwraca ilość ostatnio wyodrębnionych niesformatowanych bajtów. Dlatego otwieramy plik, wyodrębniamy i odrzucamy całą jego zawartość za pomocą ignore(), aby uzyskać rozmiar pliku, i na tej podstawie konstruujemy ciąg wyjściowy.

Po drugie, unikamy konieczności kopiowania danych pliku z std::vector<char> do std::string, zapisując bezpośrednio do ciągu.

Pod względem wydajności powinno to być absolutnie najszybsze rozwiązanie, przydzielając z wyprzedzeniem ciąg znaków o odpowiednim rozmiarze i jednokrotnie wywołując read(). Co ciekawe, użycie ignore() i countg() zamiast ate i tellg() na gcc kompiluje do prawie tego samego kawałek po kawałku.

Nigdy nie zapisuj do bufora const char * std::string. Nigdy przenigdy! Takie postępowanie jest ogromnym błędem.

Zarezerwuj() miejsce na cały ciąg w std::string, przeczytaj fragmenty pliku o rozsądnym rozmiarze do bufora i dodaj je(). Wielkość porcji zależy od rozmiaru pliku wejściowego. Jestem prawie pewien, że wszystkie inne mechanizmy przenośne i zgodne z STL zrobią to samo (choć mogą wyglądać ładniej).