Як я читаю весь файл у std :: string у C ++?

Як я можу прочитати файл у файл std::string, тобто прочитати весь файл одразу?

Текстовий або двійковий режим повинен бути визначений абонентом. Рішення повинно бути стандартним, портативним та ефективним. Він не повинен копіювати дані рядка, і він повинен уникати перерозподілу пам'яті під час читання рядка.

Один з способів зробити це було б стат розміру файлу, змінювати розмір std::stringі fread()в std::string«s const_cast<char*>()» під ред data(). Для цього потрібні std::stringсуміжні дані, що не вимагається стандартом, але, мабуть, це стосується всіх відомих реалізацій. Що гірше, якщо файл читається в текстовому режимі, std::stringрозмір може не дорівнювати розміру файлу.

Повністю правильні, стандартні та портативні рішення можуть бути побудовані, використовуючи std::ifstream's rdbuf()в a, std::ostringstreamа звідти в a std::string. Однак це може скопіювати рядкові дані та / або непотрібно перерозподілити пам'ять.

• Чи всі відповідні стандартні бібліотечні реалізації достатньо розумні, щоб уникнути зайвих накладних витрат?
• Чи є інший спосіб це зробити?
• Чи пропустив я якусь приховану функцію Boost, яка вже забезпечує бажаний функціонал?

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

Один із способів - перевести буфер потоку в окремий потік пам'яті, а потім перетворити його на std::string:

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

Це гарно стисло. Однак, як зазначено у запитанні, ця копія виконує надлишкові копії, і, на жаль, принципово немає способу усунути цю копію.

На жаль, єдине реальне рішення, яке дозволяє уникнути зайвих копій, - це читання вручну в циклі, на жаль. Оскільки C ++ тепер гарантує суміжні рядки, можна написати наступне (≥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;
}

Дивіться цю відповідь на подібне запитання.

Для вашої зручності я відновлюю рішення 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);
}

Це рішення призвело до приблизно на 20% швидших разів виконання, ніж інші відповіді, представлені тут, при взятті в середньому 100 забігів на текст Мобі Діка (1,3 М). Непогано для портативного рішення C ++, я хотів би побачити результати mmap'ing файлу;)

Найкоротший варіант: Live On Coliru

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

Для цього потрібен заголовок <iterator>.

Були деякі повідомлення про те, що цей метод повільніше, ніж попереднє розміщення рядка та використання std::istream::read. Однак для сучасного компілятора з увімкненими оптимізаціями це вже не так, хоча відносна продуктивність різних методів, як видається, сильно залежить від компілятора.

Використовуйте

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

або щось дуже близьке. У мене немає відкритої посилання на stdlib, щоб двічі перевірити себе.

Так, я розумію, що я не записав slurpфункцію так, як її запитували.

Якщо у вас є C ++ 17 (std :: файлова система), існує також такий спосіб (який отримує розмір файла std::filesystem::file_sizeзамість seekgі 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;
}

Примітка : можливо, вам доведеться використовувати, <experimental/filesystem>і std::experimental::filesystemякщо ваша стандартна бібліотека ще не підтримує повністю C ++ 17. Крім того, можливо , буде потрібно замінити result.data()з , &result[0]якщо він не підтримує неконстантную StD :: basic_string дані .

У мене недостатньо репутації, щоб коментувати безпосередньо відповіді, використовуючи tellg().

Зверніть увагу, що tellg()помилка може повернутися -1. Якщо ви передаєте результат tellg()як параметр розподілу, слід спочатку перевірити результат.

Приклад проблеми:

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

У наведеному вище прикладі, якщо tellg()виникне помилка, вона повернеться -1. Неявне кастинг між підписаним (тобто результатом tellg()) і непідписаним (тобто аргументом до vector<char>конструктора) призведе до того, що ваш вектор помилково виділить дуже велику кількість байтів. (Можливо, 4294967295 байт або 4 Гб.)

Змінення відповіді paxos1977 для врахування вищезазначеного:

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

Це рішення додає перевірку помилок до методу на основі 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();
}

Я додаю цю відповідь, тому що додавання перевірки помилок до оригінального методу не настільки тривіально, як ви очікували. У початковому методі використовується оператор вставки stringstream ( str_stream << file_stream.rdbuf()). Проблема полягає в тому, що при цьому не встановлюється жодних символів. Це може бути пов’язано з помилкою або через те, що файл порожній. Якщо ви перевіряєте несправності, перевіряючи провал, ви побачите помилковий позитив, читаючи порожній файл. Як ви розмежовуєте законне невиконання будь-яких символів та "невдачу" вставити будь-які символи, оскільки файл порожній?

Ви можете подумати, щоб явно перевірити наявність порожнього файлу, але це більше коду та пов’язана з ним перевірка помилок.

Перевірка стану відмови str_stream.fail() && !str_stream.eof()не працює, оскільки операція вставки не встановлює eofbit (на ostringstream і ifstream).

Отже, рішення - змінити операцію. Замість використання оператора вставки ostringstream (<<), використовуйте оператор вилучення ifstream (>>), який встановлює eofbit. Потім перевірте стан несправності file_stream.fail() && !file_stream.eof().

Важливо, що, file_stream >> str_stream.rdbuf()стикаючись із законним збоєм, він ніколи не повинен встановлювати eofbit (відповідно до мого розуміння специфікації). Це означає, що вищевказана перевірка є достатньою для виявлення законних збоїв.

Щось подібне не повинно бути дуже поганим:

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

Перевага тут полягає в тому, що ми робимо резерв спочатку, тому нам не доведеться нарощувати рядок під час читання речей. Недоліком є ​​те, що ми робимо це за допомогою чар. Більш розумна версія може захопити весь зчитуваний buf, а потім зателефонувати.

Ось версія, що використовує нову бібліотеку файлової системи з досить надійною перевіркою помилок:

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

Ви можете використовувати функцію 'std :: getline' і вказати 'eof' як роздільник. Отриманий код трохи незрозумілий:

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

Ніколи не записуйте в буфер std :: string const char *. Ніколи! Це - масова помилка.

Зарезервуйте () простір для всієї строки у std :: string, прочитайте фрагменти з вашого файлу розумного розміру в буфер і додайте (). Наскільки вони повинні бути великими, залежить від розміру вхідного файлу. Я впевнений, що всі інші портативні та сумісні з STL механізми будуть робити те саме (але це може виглядати красивіше).

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

використання:

const string logAsString = GetFileAsString(logFilePath);

Оновлена ​​функція, заснована на рішенні 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;
}

Є дві важливі відмінності:

tellg()не гарантується повернення зміщення в байтах з початку файлу. Натомість, як вказував Puzomor Хорватія, це скоріше маркер, який можна використовувати під час викликів fstream. gcount()проте ж повертають кількість байт неотформатированним останній витягнуті. Тому ми відкриваємо файл, витягуємо та відкидаємо весь його вміст, ignore()щоб отримати розмір файлу, і на основі цього будуємо вихідний рядок.

По-друге, нам не потрібно копіювати дані файлу від a std::vector<char>до a std::string, записуючи безпосередньо в рядок.

З точки зору продуктивності, це має бути абсолютно швидким, достроково виділяючи відповідний розмір рядка і read()один раз телефонувати . Як цікавий факт, використання ignore()і countg()замість ateі tellg()на gcc збирає майже те саме , поступово.

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