如何在 C++ 中将整个文件读入 std::string？

Question

如何将文件读入std::string，即一次读取整个文件？

文本或二进制模式应由调用者指定。该解决方案应符合标准、可移植且高效。它不应该不必要地复制字符串的数据，并且应该避免在读取字符串时重新分配内存。

一种方法是统计文件大小，将std::string 和fread() 调整为std::string 的const_cast<char*>()'ed data()。这要求std::string 的数据是连续的，这不是标准所要求的，但似乎所有已知实现都是如此。更糟糕的是，如果以文本模式读取文件，std::string 的大小可能不等于文件的大小。

可以使用std::ifstream 的rdbuf() 到std::ostringstream 并从那里到std::string 构建完全正确、符合标准和可移植的解决方案。但是，这可能会复制字符串数据和/或不必要地重新分配内存。

• 是否所有相关的标准库实现都足够聪明，可以避免所有不必要的开销？
• 还有其他方法吗？
• 我是否错过了一些已经提供所需功能的隐藏 Boost 功能？

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

Answer 1

一种方法是将流缓冲区刷新为单独的内存流，然后将其转换为std::string（省略错误处理）：

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

这非常简洁。但是，正如问题中所述，这会执行冗余副本，不幸的是，基本上没有办法删除此副本。

不幸的是，唯一避免冗余副本的真正解决方案是手动循环读取。由于 C++ 现在已经保证了连续的字符串，因此可以编写以下内容（≥C++17，包括错误处理）：

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

Answer 2

最短变体：Live On Coliru

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

它需要标头<iterator>。

有报道称这种方法比预分配字符串和使用std::istream::read 慢。然而，在启用了优化的现代编译器上，情况似乎不再如此，尽管各种方法的相对性能似乎高度依赖于编译器。

Answer 3

有关类似问题，请参阅 this answer。

为了您的方便，我转贴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);
}

当对 Moby Dick (1.3M) 的文本进行平均 100 次运行时，此解决方案的执行时间比此处提供的其他答案快约 20%。对于可移植的 C++ 解决方案来说还不错，我想看看对文件进行映射的结果；)

Answer 4

如果你有 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;
}

注意：如果您的标准库尚未完全支持 C++17，您可能需要使用 <experimental/filesystem> 和 std::experimental::filesystem。如果不支持non-const std::basic_string data，您可能还需要将result.data() 替换为&result[0]。

Answer 5

使用

#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 函数。

Answer 6

我没有足够的声誉直接评论使用 tellg() 的回复。

请注意，tellg() 可能会在出错时返回 -1。如果您将tellg() 的结果作为分配参数传递，您应该首先检查结果。

问题的一个例子：

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

在上面的例子中，如果tellg() 遇到错误，它将返回-1。有符号（即tellg() 的结果）和无符号（即vector<char> 构造函数的arg）之间的隐式转换将导致您的向量错误地分配非常 大量字节。 （可能是 4294967295 字节，即 4GB。）

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

Answer 7

此解决方案将错误检查添加到基于 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 的插入运算符 (>)，它确实设置了 eofbit。然后检查失败情况file_stream.fail() && !file_stream.eof()。

重要的是，当file_stream >> str_stream.rdbuf() 遇到合法故障时，它不应该设置 eofbit（根据我对规范的理解）。这意味着上述检查足以检测合法故障。

Answer 8

这是一个使用新文件系统库的版本，具有相当强大的错误检查功能：

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

Answer 9

由于这似乎是一个广泛使用的实用程序，我的方法是搜索并更喜欢已经可用的库而不是手工制作的解决方案，特别是如果你的项目中已经链接了 boost 库（链接器标志 -lboost_system -lboost_filesystem）。 Here (and older boost versions too)，boost 提供了一个 load_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;
}

作为一个优点，这个函数不会寻找整个文件来确定大小，而是在内部使用 stat()。不过，作为一个可能可以忽略不计的缺点，人们可以通过查看源代码轻松推断：字符串被不必要地调整为 '\0' 字符，这些字符被文件内容重写。

Answer 10

这样的事情应该不会太糟糕：

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

这里的优点是我们先做保留，这样我们就不必在读入内容时增加字符串。缺点是我们逐个字符地进行。更智能的版本可以抓取整个 read buf，然后调用 underflow。

Answer 11

您可以使用 '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() ) );

Answer 12

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

Answer 13

基于 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() 提取并丢弃其所有内容以获取文件的大小，并基于此构造输出字符串。

其次，我们避免了通过直接写入字符串来将文件数据从std::vector<char>复制到std::string。

就性能而言，这应该是绝对最快的，提前分配适当大小的字符串并调用一次read()。有趣的是，在 gcc 上使用 ignore() 和 countg() 而不是 ate 和 tellg() 会一点一点地编译为 almost the same thing。

Answer 14

#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
main(){
    fstream file;
    //Open a file
    file.open("test.txt");
    string copy,temp;
    //While loop to store whole document in copy string
    //Temp reads a complete line
    //Loop stops until temp reads the last line of document
    while(getline(file,temp)){
        //add new line text in copy
        copy+=temp;
        //adds a new line
        copy+="\n";
    }
    //Display whole document
    cout<<copy;
    //close the document
    file.close();
}

Answer 15

这是我使用的函数，在处理大文件 (1GB+) 时，由于某种原因，std::ifstream::read() 比 std::ifstream::rdbuf( ) 当你知道文件大小时，所以整个“首先检查文件大小”的事情实际上是一个速度优化

#include <string>
#include <fstream>
#include <sstream>
std::string file_get_contents(const std::string &$filename)
{
    std::ifstream file($filename, std::ifstream::binary);
    file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
    file.seekg(0, std::istream::end);
    const std::streampos ssize = file.tellg();
    if (ssize < 0)
    {
        // can't get size for some reason, fallback to slower "just read everything"
        // because i dont trust that we could seek back/fourth in the original stream,
        // im creating a new stream.
        std::ifstream file($filename, std::ifstream::binary);
        file.exceptions(std::ifstream::failbit | std::ifstream::badbit);
        std::ostringstream ss;
        ss << file.rdbuf();
        return ss.str();
    }
    file.seekg(0, std::istream::beg);
    std::string result(size_t(ssize), 0);
    file.read(&result[0], std::streamsize(ssize));
    return result;
}

Answer 16

就性能而言，我没有发现比下面的代码更快的东西。

std::string readAllText(std::string const &path)
{
    assert(path.c_str() != NULL);
    FILE *stream = fopen(path.c_str(), "r");
    assert(stream != NULL);
    fseek(stream, 0, SEEK_END);
    long stream_size = ftell(stream);
    fseek(stream, 0, SEEK_SET);
    void *buffer = malloc(stream_size);
    fread(buffer, stream_size, 1, stream);
    assert(ferror(stream) == 0);
    fclose(stream);
    std::string text((const char *)buffer, stream_size);
    assert(buffer != NULL);
    free((void *)buffer);
    return text;
}

Answer 17

您可以使用我为此开发的rst C++ 库：

#include "rst/files/file_utils.h"

std::filesystem::path path = ...;  // Path to a file.
rst::StatusOr<std::string> content = rst::ReadFile(path);
if (content.err()) {
  // Handle error.
}

std::cout << *content << ", " << content->size() << std::endl;

Answer 18

我知道这是一个非常古老的问题，有很多答案，但没有一个人提到我认为最明显的方法。是的，我知道这是 C++，使用 libc 是邪恶的和错误的或其他什么，但对此很疯狂。使用 libc 很好，尤其是对于这种简单的事情。

本质上：只需打开文件，获取它的大小（不一定按此顺序），然​​后阅读它。

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <sys/stat.h>

static constexpr char const filename[] = "foo.bar";

int main(void)
{
    FILE *fp = ::fopen(filename, "rb");
    if (!fp) {
        ::perror("fopen");
        ::exit(1);
    }

    struct stat st;
    if (::fstat(fileno(fp), &st) == (-1)) {
        ::perror("fstat");
        ::exit(1);
    }

    // You could simply allocate a buffer here and use std::string_view, or
    // even allocate a buffer and copy it to a std::string. Creating a
    // std::string and setting its size is simplest, but will pointlessly
    // initialize the buffer to 0. You can't win sometimes.
    std::string str;
    str.reserve(st.st_size + 1U);
    str.resize(st.st_size);
    ::fread(str.data(), 1, st.st_size, fp);
    str[st.st_size] = '\0';
    ::fclose(fp);
}

除了（实际上）完全可移植之外，这似乎并不比其他一些解决方案更糟糕。当然，也可以抛出异常而不是立即退出。调整 std::string 的大小总是 0 会初始化它，这让我非常恼火，但它无济于事。

请注意，这只适用于为 C++17 及更高版本编写的代码。早期版本（应该）不允许编辑std::string::data()。如果使用早期版本，请考虑使用 std::string_view 或简单地复制原始缓冲区。

Answer 19

#include <string>
#include <fstream>

int main()
{
    std::string fileLocation = "C:\\Users\\User\\Desktop\\file.txt";
    std::ifstream file(fileLocation, std::ios::in | std::ios::binary);

    std::string data;

    if(file.is_open())
    {
        std::getline(file, data, '\0');

        file.close();
    }
}

Answer 20

永远不要写入 std::string 的 const char * 缓冲区。永远不能！这样做是一个巨大的错误。

为 std::string 中的整个字符串保留() 空间，从文件中读取合理大小的块到缓冲区中，然后 append() 它。块的大小取决于您的输入文件大小。我很确定所有其他可移植和符合 STL 的机制都会做同样的事情（但可能看起来更漂亮）。

Answer 21

我知道我迟到了，但现在（2021 年）在我的机器上，这是我测试过的最快的实现：

#include <fstream>
#include <string>

bool fileRead( std::string &contents, const std::string &path ) {
    contents.clear();
    if( path.empty()) {
        return false;
    }
    std::ifstream stream( path );
    if( !stream ) {
        return false;
    }
    stream >> contents;
    return true;
}