Bagaimana cara membaca seluruh file menjadi std :: string dalam C ++?

Bagaimana cara membaca file menjadi std::string, yaitu, membaca seluruh file sekaligus?

Mode teks atau biner harus ditentukan oleh pemanggil. Solusinya harus sesuai standar, portabel dan efisien. Seharusnya tidak perlu menyalin data string, dan harus menghindari realokasi memori saat membaca string.

Salah satu cara untuk melakukan ini adalah dengan stat filesize, mengubah ukuran std::stringdan fread()ke std::string's const_cast<char*>()' ed data(). Ini membutuhkan std::stringdata yang berdekatan yang tidak diperlukan oleh standar, tetapi tampaknya menjadi kasus untuk semua implementasi yang diketahui. Yang lebih parah, jika file dibaca dalam mode teks, std::stringukurannya mungkin tidak sama dengan ukuran file.

Solusi yang sepenuhnya benar, sesuai standar dan portabel dapat dibangun menggunakan std::ifstream's rdbuf()menjadi std::ostringstreamdan dari sana menjadi a std::string. Namun, ini dapat menyalin data string dan / atau mengalokasikan kembali memori yang tidak perlu.

• Apakah semua implementasi perpustakaan standar yang relevan cukup pintar untuk menghindari semua overhead yang tidak perlu?
• Apakah ada cara lain untuk melakukannya?
• Apakah saya melewatkan beberapa fungsi Peningkatan tersembunyi yang sudah menyediakan fungsi yang diinginkan?

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

Salah satu caranya adalah menyiram buffer aliran ke dalam aliran memori yang terpisah, dan kemudian mengubahnya menjadi std::string:

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

Ini sangat ringkas. Namun, seperti disebutkan dalam pertanyaan ini melakukan salinan yang berlebihan dan sayangnya pada dasarnya tidak ada cara untuk menghilangkan salinan ini.

Satu-satunya solusi nyata yang menghindari salinan berlebihan adalah dengan melakukan pembacaan secara manual dalam satu lingkaran, sayangnya. Karena C ++ sekarang telah menjamin string yang berdekatan, orang dapat menulis yang berikut ini (≥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;
}

Lihat jawaban ini pada pertanyaan serupa.

Demi kenyamanan Anda, saya memposting ulang solusi 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);
}

Solusi ini menghasilkan sekitar 20% waktu eksekusi yang lebih cepat daripada jawaban lain yang disajikan di sini, ketika mengambil rata-rata 100 run terhadap teks Moby Dick (1.3M). Tidak buruk untuk solusi C ++ portabel, saya ingin melihat hasil dari mmap'ing file;)

Varian terpendek: Live On Coliru

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

Itu membutuhkan header <iterator>.

Ada beberapa laporan bahwa metode ini lebih lambat daripada mengalokasikan string dan menggunakan std::istream::read. Namun, pada kompiler modern dengan optimisasi yang diaktifkan ini tampaknya tidak lagi menjadi masalah, meskipun kinerja relatif dari berbagai metode tampaknya sangat bergantung pada kompiler.

Menggunakan

#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;
}

atau sesuatu yang sangat dekat. Saya tidak memiliki referensi stdlib terbuka untuk memeriksa ulang sendiri.

Ya, saya mengerti saya tidak menulis slurpfungsi seperti yang diminta.

Jika Anda memiliki C ++ 17 (std :: filesystem), ada juga cara ini (yang mendapatkan ukuran file melalui std::filesystem::file_sizealih-alih seekgdan 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;
}

Catatan : Anda mungkin perlu menggunakan <experimental/filesystem>dan std::experimental::filesystemjika perpustakaan standar Anda belum sepenuhnya mendukung C ++ 17. Anda mungkin juga perlu mengganti result.data()dengan &result[0]jika tidak mendukung data st-:: basic_string non-const .

Saya tidak memiliki reputasi yang cukup untuk mengomentari secara langsung tentang tanggapan menggunakan tellg().

Perlu diketahui bahwa tellg()dapat mengembalikan -1 pada kesalahan. Jika Anda melewatkan hasil tellg()sebagai parameter alokasi, Anda harus memeriksa hasilnya terlebih dahulu.

Contoh masalah:

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

Dalam contoh di atas, jika tellg()menemukan kesalahan, ia akan mengembalikan -1. Casting implisit antara ditandatangani (yaitu hasil tellg()) dan unsigned (yaitu arg ke vector<char>konstruktor) akan menghasilkan vektor Anda keliru mengalokasikan sangat sejumlah besar byte. (Mungkin 4294967295 byte, atau 4GB.)

Memodifikasi jawaban paxos1977 untuk akun di atas:

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);
}

Solusi ini menambahkan pengecekan kesalahan ke metode berbasis 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();
}

Saya menambahkan jawaban ini karena menambahkan pengecekan kesalahan pada metode asli tidak sepele seperti yang Anda harapkan. Metode asli menggunakan operator penyisipan stringstream ( str_stream << file_stream.rdbuf()). Masalahnya adalah ini menetapkan failbit stringstream ketika tidak ada karakter yang dimasukkan. Itu bisa karena kesalahan atau bisa juga karena file sedang kosong. Jika Anda memeriksa kegagalan dengan memeriksa failbit, Anda akan menemukan false positive ketika Anda membaca file kosong. Bagaimana Anda membedakan kegagalan yang sah untuk menyisipkan karakter apa pun dan "kegagalan" untuk menyisipkan karakter apa pun karena file tersebut kosong?

Anda mungkin berpikir untuk secara eksplisit memeriksa file kosong, tapi itu lebih banyak kode dan pengecekan kesalahan yang terkait.

Memeriksa kondisi kegagalan str_stream.fail() && !str_stream.eof()tidak berfungsi, karena operasi penyisipan tidak mengatur eofbit (pada ostringstream atau ifstream).

Jadi, solusinya adalah mengubah operasi. Alih-alih menggunakan operator penyisipan ostringstream (<<), gunakan operator ekstraksi ifstream (>>), yang memang mengatur eofbit. Kemudian periksa kondisi kegagalan file_stream.fail() && !file_stream.eof().

Yang penting, ketika file_stream >> str_stream.rdbuf()menemukan kegagalan yang sah, seharusnya tidak pernah menetapkan eofbit (sesuai dengan pemahaman saya tentang spesifikasi). Itu berarti cek di atas cukup untuk mendeteksi kegagalan yang sah.

Sesuatu seperti ini seharusnya tidak terlalu buruk:

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>());
}

Keuntungannya di sini adalah kita melakukan cadangan terlebih dahulu sehingga kita tidak perlu menumbuhkan talinya saat kita membaca banyak hal. Kerugiannya adalah kita melakukannya dengan char. Versi yang lebih cerdas dapat mengambil seluruh baca buf dan kemudian memanggil underflow.

Ini adalah versi yang menggunakan pustaka sistem file baru dengan pemeriksaan kesalahan yang cukup kuat:

#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()); };

Anda dapat menggunakan fungsi 'std :: getline', dan tentukan 'eof' sebagai pembatas. Kode yang dihasilkan agak tidak jelas:

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

Jangan pernah menulis ke buffer char * std :: string's str. Tidak akan pernah! Melakukan hal itu adalah kesalahan besar.

Cadangan () ruang untuk seluruh string di std :: string Anda, baca potongan dari file Anda dengan ukuran yang wajar ke dalam buffer, dan tambahkan () itu. Seberapa besar potongan harus tergantung pada ukuran file input Anda. Saya cukup yakin semua mekanisme portabel dan STL lainnya akan melakukan hal yang sama (namun mungkin terlihat lebih cantik).

#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);
}

pemakaian:

const string logAsString = GetFileAsString(logFilePath);

Fungsi yang diperbarui yang didasarkan pada solusi 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;
}

Ada dua perbedaan penting:

tellg()tidak dijamin untuk mengembalikan offset dalam byte sejak awal file. Sebagai gantinya, seperti yang ditunjukkan Puzomor Croatia, itu lebih merupakan token yang dapat digunakan dalam panggilan fstream. gcount()Namun tidak mengembalikan jumlah byte terformat lalu diekstrak. Karena itu kami membuka file, mengekstrak dan membuang semua isinya dengan ignore()untuk mendapatkan ukuran file, dan membangun string keluaran berdasarkan itu.

Kedua, kami menghindari harus menyalin data file dari a std::vector<char>ke a std::stringdengan menulis ke string secara langsung.

Dalam hal kinerja, ini harus menjadi yang tercepat mutlak, mengalokasikan string berukuran yang sesuai sebelumnya dan menelepon read()sekali. Sebagai fakta yang menarik, menggunakan ignore()dan countg()bukannya atedan tellg()pada gcc mengkompilasi ke hal yang hampir sama , sedikit demi sedikit.

#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();
}