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

Jak wczytać plik do std::string, tj. Czytać cały plik naraz?

Wzywający powinien określić tryb tekstowy lub binarny. Rozwiązanie powinno być zgodne z normami, przenośne i wydajne. Nie powinien niepotrzebnie kopiować danych ciągu i powinien unikać ponownego przydziału pamięci podczas odczytu ciągu.

Jednym ze sposobów na zrobienie tego może być statystyka rozmiaru pliku, zmiana rozmiaru std::stringi fread()na edycję std::string's const_cast<char*>()' data(). Wymaga std::stringto ciągłości danych, co nie jest wymagane przez standard, ale wydaje się, że tak jest w przypadku wszystkich znanych implementacji. Co gorsza, jeśli plik jest czytany w trybie tekstowym, std::stringrozmiar może nie odpowiadać rozmiarowi pliku.

W pełni poprawne, zgodne ze standardami i przenośne rozwiązania mogą być konstruowane przy użyciu std::ifstreamplików rdbuf()a, std::ostringstreama stamtąd do a std::string. Może to jednak spowodować skopiowanie danych ciągu i / lub niepotrzebną zmianę alokacji pamięci.

• Czy wszystkie istotne implementacje bibliotek standardowych są wystarczająco inteligentne, aby uniknąć wszystkich niepotrzebnych kosztów ogólnych?
• Czy jest inny sposób, aby to zrobić?
• Czy przegapiłem jakąś ukrytą funkcję Boost, która już zapewnia pożądaną funkcjonalność?

void slurp(std::string& data, bool is_binary)

Jednym ze sposobów jest opróżnienie buforu strumienia do osobnego strumienia pamięci, a następnie przekonwertowanie go na std::string:

std::string slurp(std::ifstream& in) {
    std::ostringstream sstr;
    sstr << in.rdbuf();
    return sstr.str();
}

To ładnie zwięzłe. Jednak, jak zauważono w pytaniu, powoduje to utworzenie zbędnej kopii i niestety zasadniczo nie ma możliwości usunięcia tej kopii.

Jedynym prawdziwym rozwiązaniem, które pozwala uniknąć zbędnych kopii, jest niestety ręczne wykonanie odczytu w pętli. Ponieważ C ++ ma teraz gwarantowane ciągłe ciągi, można napisać (≥ C ++ 14):

auto read_file(std::string_view path) -> std::string {
    constexpr auto read_size = std::size_t{4096};
    auto stream = std::ifstream{path.data()};
    stream.exceptions(std::ios_base::badbit);

    auto out = std::string{};
    auto buf = std::string(read_size, '\0');
    while (stream.read(& buf[0], read_size)) {
        out.append(buf, 0, stream.gcount());
    }
    out.append(buf, 0, stream.gcount());
    return out;
}

Zobacz tę odpowiedź na podobne pytanie.

Dla Twojej wygody ponownie publikuję rozwiązanie CTT:

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

    ifstream::pos_type fileSize = ifs.tellg();
    ifs.seekg(0, ios::beg);

    vector<char> bytes(fileSize);
    ifs.read(bytes.data(), fileSize);

    return string(bytes.data(), fileSize);
}

To rozwiązanie zaowocowało około 20% szybszym czasem wykonania niż inne przedstawione tutaj odpowiedzi, biorąc pod uwagę średnią ze 100 uruchomień z tekstem Moby Dicka (1,3 mln). Nieźle jak na przenośne rozwiązanie C ++, chciałbym zobaczyć wyniki mmapowania pliku;)

Najkrótszy wariant: Live On Coliru

std::string str(std::istreambuf_iterator<char>{ifs}, {});

Wymaga nagłówka <iterator>.

Pojawiły się doniesienia, że ​​ta metoda jest wolniejsza niż wstępne przydzielanie ciągu i używanie std::istream::read. Jednak w przypadku współczesnego kompilatora z włączoną optymalizacją wydaje się, że nie ma to już miejsca, chociaż względna wydajność różnych metod wydaje się być silnie zależna od kompilatora.

Posługiwać się

#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 bliskiego. Nie mam otwartego odwołania do biblioteki standardowej, aby sprawdzić się dwukrotnie.

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

Jeśli masz C ++ 17 (std :: filesystem), jest też ten sposób (który pobiera rozmiar pliku std::filesystem::file_sizezamiast seekgi 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>a std::experimental::filesystemTwoja standardowa biblioteka nie obsługuje jeszcze w pełni C ++ 17. Może być również konieczne zastąpienie result.data()przez, &result[0]jeśli nie obsługuje danych innych niż stałe std :: basic_string .

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

Pamiętaj o tym tellg() w przypadku błędu może zwrócić -1. 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 między znakiem ze znakiem (tj. Wynikiem tellg()) i bez znaku (tj. Argumentem do vector<char>konstruktora) spowoduje, że Twój wektor błędnie przydzieli bardzo dużą liczbę bajtów. (Prawdopodobnie 4294967295 bajtów lub 4 GB.)

Modyfikacja 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 używa operatora wstawiania stringstream (str_stream << file_stream.rdbuf() ). Problem polega na tym, że ustawia to bit failstream łańcucha, gdy nie są wstawiane żadne znaki. Może to być spowodowane błędem lub pustym plikiem. Jeśli sprawdzisz błędy, sprawdzając bit błędów, napotkasz fałszywy alarm podczas odczytu pustego pliku. Jak rozróżnić 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 związanego z nim sprawdzania błędów.

Sprawdzanie stanu awarii str_stream.fail() && !str_stream.eof() nie działa, ponieważ operacja wstawiania nie ustawia eofbita (w strumieniu ostringstream ani w strumieniu ifstream).

Tak więc rozwiązaniem jest zmiana operacji. Zamiast używać operatora wstawiania ostringstream (<<), użyj operatora ekstrakcji ifstream (>>), który ustawia eofbit. Następnie sprawdź stan awarii file_stream.fail() && !file_stream.eof().

Co ważne, gdy file_stream >> str_stream.rdbuf()napotka uzasadnioną awarię, nie powinien nigdy ustawiać eofbit (zgodnie z moim rozumieniem specyfikacji). Oznacza to, że powyższe sprawdzenie jest wystarczające do wykrycia uzasadnionych awarii.

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ć łańcucha podczas czytania. Wadą jest to, że robimy to char po znaku. Bardziej inteligentna wersja mogłaby pobrać całą odczytaną wartość bufora, a następnie wywołać niedomiar.

Oto wersja korzystająca z nowej biblioteki systemu plików z dość solidnym sprawdzaniem 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()); };

Możesz użyć funkcji „std :: getline” i określić „eof” jako separator. Wynikowy kod jest jednak nieco 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() ) );

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

Zarezerwuj () miejsce na cały ciąg w swoim std :: string, wczytaj fragmenty pliku o rozsądnym rozmiarze do bufora i dołącz () go. Jak duże muszą być fragmenty, zależy od rozmiaru pliku wejściowego. Jestem prawie pewien, że wszystkie inne przenośne i zgodne z STL mechanizmy zrobią to samo (ale mogą wyglądać ładniej).

#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 ważne różnice:

tellg()nie gwarantuje zwrócenia przesunięcia w bajtach od początku pliku. Zamiast tego, jak wskazał Puzomor Croatia, jest to raczej token, którego można używać w wywołaniach fstream. gcount()jednak nie zwraca ilość niesformatowanych bajtów ostatni wyodrębnione. 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 a std::vector<char>do a std::string, zapisując bezpośrednio do ciągu.

Pod względem wydajności powinno to być absolutnie najszybsze, przydzielając ciąg o odpowiednim rozmiarze z wyprzedzeniem i wywołując read()raz. Ciekawostką jest to, że użycie ignore()i countg()zamiast atei tellg()na gcc kompiluje się do prawie tego samego , krok po kroku.

#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
main(){
    fstream file;
    file.open("test.txt");
    string copy,temp;
    while(getline(file,temp)){
        copy+=temp;
        copy+="\n";
    }
    cout<<copy;
    file.close();
}