Как мне прочитать весь файл в std :: string в C ++?

Как мне прочитать файл в std::string, т.е. прочитать весь файл одновременно?

Текстовый или двоичный режим должен быть указан вызывающим абонентом. Решение должно быть совместимым со стандартами, переносимым и эффективным. Он не должен без необходимости копировать данные строки и должен избегать перераспределения памяти при чтении строки.

Один из способов сделать это - указать размер файла, изменить размер std::stringи ввести fread()в std::string«s const_cast<char*>()» data(). Это требует, чтобы std::stringданные были смежными, что не требуется стандартом, но, похоже, имеет место для всех известных реализаций. Что еще хуже, если файл читается в текстовом режиме, std::stringразмер файла может не совпадать с размером файла.

Полностью правильные, совместимые со стандартами и портативные решения могут быть построены с использованием std::ifstream символов rdbuf()a в 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 :: filesystem), также есть этот способ (который определяет размер файла 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. Неявное приведение между sign (то есть результатом tellg()) и unsigned (т.е. аргументом 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() ). Проблема в том, что это устанавливает битовый поток stringstream, когда никакие символы не вставлены. Это может быть связано с ошибкой или с пустым файлом. Если вы проверите на наличие ошибок, проверив бит-бит, вы получите ложное срабатывание при чтении пустого файла. Как вы устраняете неоднозначность законного сбоя при вставке любых символов и «сбоя» при вставке любых символов, потому что файл пуст?

Вы можете явно проверить наличие пустого файла, но это больше кода и связанной с этим проверки ошибок.

Проверка состояния сбоя str_stream.fail() && !str_stream.eof()не работает, потому что операция вставки не устанавливает eofbit (ни для потока ostring, ни для потока if).

Таким образом, решение состоит в том, чтобы изменить операцию. Вместо использования оператора вставки 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 и затем вызвать underflow.

Вот версия, использующая новую библиотеку файловой системы с достаточно надежной проверкой ошибок:

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

Никогда не записывайте в буфер stst :: 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 Croatia, это скорее токен, который можно использовать в вызовах 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();
}