blocks|key|3368519|text|使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3368520|#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;
}|code-block|syntax|javascript|3368521|或者是很接近的东西。我没有打开stdlib引用来重新检查自己。|3368522|是的，我知道我没有按要求编写slurp函数。|offset|length|style|CODE|3368523|entityMap^0|0|0|0|E|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Use 

<pre><code>#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;fstream&gt;

int main()
{
 std::ifstream input("file.txt");
 std::stringstream sstr;

 while(input &gt;&gt; sstr.rdbuf());

 std::cout &lt;&lt; sstr.str() &lt;&lt; std::endl;
}
</code></pre>

or something very close. I don't have a stdlib reference open to double-check myself.

Yes, I understand I didn't write the <code>slurp</code> function as asked.

blocks|key|366789|text|永远不要写入std：：string的const+char+*缓冲区。永远不会！这样做是一个巨大的错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|366790|在std::string中为整个字符串保留()空间，将文件中合理大小的块读取到缓冲区中，然后追加()。块的大小取决于输入文件的大小。我非常肯定所有其他可移植的和符合STL的机制都会做同样的事情(但看起来可能更漂亮)。|366791|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Never write into the std::string's const char * buffer. Never ever! Doing so is a massive mistake. 

Reserve() space for the whole string in your std::string, read chunks from your file of reasonable size into a buffer, and append() it. How large the chunks have to be depends on your input file size. I'm pretty sure all other portable and STL-compliant mechanisms will do the same (yet may look prettier).

blocks|key|362005|text|这样的事情应该不会太糟糕：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|362006|void+slurp(std::string&+data,+const+std::string&+filename,+bool+is_binary)
{
++++std::ios_base::openmode+openmode+=+ios::ate+%7C+ios::in;
++++if+(is_binary)
++++++++openmode+%7C=+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>());
}|code-block|syntax|javascript|362007|这样做的好处是我们先做保留，这样我们就不必在读东西的时候增加字符串了。缺点是我们一个字符一个字符地做。一个更聪明的版本可以抓取整个read+buf，然后调用underflow。|362008|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Something like this shouldn't be too bad:

<pre><code>void slurp(std::string&amp; data, const std::string&amp; 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&lt;char&gt;(file.rdbuf()), 
 istreambuf_iterator&lt;char&gt;());
}
</code></pre>

The advantage here is that we do the reserve first so we won't have to grow the string as we read things in. The disadvantage is that we do it char by char. A smarter version could grab the whole read buf and then call underflow.

blocks|key|363466|text|您可以使用'std::getline‘函数，并指定'eof’作为分隔符。但是结果代码有点晦涩难懂：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|363467|std::string+data;
std::ifstream+in(+"test.txt"+);
std::getline(+in,+data,+std::string::traits_type::to_char_type(+
++++++++++++++++++std::string::traits_type::eof()+)+);|code-block|syntax|javascript|363468|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use the 'std::getline' function, and specify 'eof' as the delimiter. The resulting code is a little bit obscure though:

<pre><code>std::string data;
std::ifstream in( "test.txt" );
std::getline( in, data, std::string::traits_type::to_char_type( 
 std::string::traits_type::eof() ) );
</code></pre>

blocks|key|3155705|text|一种方法是将流缓冲区刷新为单独的内存流，然后将其转换为std::string|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3155706|std::string+slurp(std::ifstream&+in)+{
++++std::ostringstream+sstr;
++++sstr+<<+in.rdbuf();
++++return+sstr.str();
}|code-block|syntax|javascript|3155707|这是非常简洁的。然而，正如问题中所指出的，这执行了一个冗余拷贝，不幸的是，根本没有办法消除这个拷贝。|3155708|不幸的是，避免冗余副本的唯一真正的解决方案是在循环中手动读取。由于C%2B%2B现在保证了连续字符串，因此可以编写以下代码(≥C%2B%2B14)：|3155709|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;
}|3155710|entityMap^0|R|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

One way is to flush the stream buffer into a separate memory stream, and then convert that to <code>std::string</code>:

<pre><code>std::string slurp(std::ifstream&amp; in) {
 std::ostringstream sstr;
 sstr &lt;&lt; in.rdbuf();
 return sstr.str();
}
</code></pre>

This is nicely concise. However, as noted in the question this performs a redundant copy and unfortunately there is fundamentally no way of eliding this copy.

The only real solution that avoids redundant copies is to do the reading manually in a loop, unfortunately. Since C++ now has guaranteed contiguous strings, one could write the following (≥C++14):

<pre><code>auto read_file(std::string_view path) -&gt; 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(&amp; buf[0], read_size)) {
 out.append(buf, 0, stream.gcount());
 }
 out.append(buf, 0, stream.gcount());
 return out;
}
</code></pre>

blocks|key|3368759|text|关于类似的问题，请参阅this+answer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3368760|为了您的方便，我重新发布了CTT的解决方案：|3368761|string+readFile2(const+string+&fileName)
{
++++ifstream+ifs(fileName.c_str(),+ios::in+%7C+ios::binary+%7C+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);
}|code-block|syntax|javascript|3368762|当对《白鲸》(1.3M)的文本平均运行100次时，该解决方案的执行时间比这里提供的其他答案快了约20%25。对于一个可移植的C%2B%2B解决方案来说还不错，我想看看mmap文件的结果;)|3368763|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/524591/performance-of-creating-a-c-stdstring-from-an-input-iterator/524843#524843^0|B|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

See <a href="https://stackoverflow.com/questions/524591/performance-of-creating-a-c-stdstring-from-an-input-iterator/524843#524843">this answer</a> on a similar question.

For your convenience, I'm reposting CTT's solution:

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

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

 vector&lt;char&gt; bytes(fileSize);
 ifs.read(bytes.data(), fileSize);

 return string(bytes.data(), fileSize);
}
</code></pre>

This solution resulted in about 20% faster execution times than the other answers presented here, when taking the average of 100 runs against the text of Moby Dick (1.3M). Not bad for a portable C++ solution, I would like to see the results of mmap'ing the file ;)

blocks|key|362136|text|如果你有C%2B%2B17+(std::filesystem)，还有这种方法(它通过std::filesystem::file_size而不是seekg和tellg来获取文件的大小)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|362137|#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+%7C+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;
}|code-block|syntax|javascript|362138|注意：如果你的标准库还不完全支持<experimental/filesystem>，你可能需要使用std::experimental::filesystem和C%2B%2B17。如果result.data()不支持non-const+std::basic_string+data，你也可能需要用&result[0]替换它。|BOLD|362139|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/string/basic_string/data^0|12|Q|1V|5|21|5|0|0|0|2|G|P|1D|T|2F|D|3Z|A|2V|W|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@$9|14|A|15|B|M]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|N|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]]]

If you have C++17 (std::filesystem), there is also this way (which gets the file's size through <code>std::filesystem::file_size</code> instead of <code>seekg</code> and <code>tellg</code>):

<pre><code>#include &lt;filesystem&gt;
#include &lt;fstream&gt;
#include &lt;string&gt;

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;
}
</code></pre>

Note: you may need to use <code>&lt;experimental/filesystem&gt;</code> and <code>std::experimental::filesystem</code> if your standard library doesn't yet fully support C++17. You might also need to replace <code>result.data()</code> with <code>&amp;result[0]</code> if it doesn't support <a href="http://en.cppreference.com/w/cpp/string/basic_string/data" rel="noreferrer">non-const std::basic_string data</a>.

blocks|key|362162|text|我没有足够的声誉来直接评论使用tellg()的回复。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|362163|请注意，tellg()可能会在出错时返回-1。如果您将tellg()的结果作为分配参数传递，则应该首先对结果进行健全性检查。|362164|这个问题的一个例子：|362165|...
std::streamsize+size+=+file.tellg();
std::vector<char>+buffer(size);
...|code-block|syntax|javascript|362166|在上面的示例中，如果tellg()遇到错误，它将返回-1。有符号(即tellg()的结果)和无符号(即vector<char>构造函数的参数)之间的隐式强制转换将导致your向量错误地分配非常大的字节数的。(可能是4294967295字节，或4+4GB。)|BOLD|362167|修改paxos1977的答案以解决上述问题：|362168|string+readFile2(const+string+&fileName)
{
++++ifstream+ifs(fileName.c_str(),+ios::in+%7C+ios::binary+%7C+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);
}|362169|entityMap^0|F|7|0|4|7|R|7|0|0|0|A|7|Y|7|1F|C|2U|Q|0|0|M|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|16|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|Q]]|D|@]|E|$]]|$1|R|3|S|5|6|7|1G|8|@$9|1H|A|1I|B|Q]]|D|@]|E|$]]|$1|T|3|U|5|L|7|1J|8|@]|D|@]|E|$M|N]]|$1|V|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|W|$]]

I do not have enough reputation to comment directly on responses using <code>tellg()</code>.

Please be aware that <code>tellg()</code> can return -1 on error. If you're passing the result of <code>tellg()</code> as an allocation parameter, you should sanity check the result first.

An example of the problem:

<pre><code>...
std::streamsize size = file.tellg();
std::vector&lt;char&gt; buffer(size);
...
</code></pre>

In the above example, if <code>tellg()</code> encounters an error it will return -1. Implicit casting between signed (ie the result of <code>tellg()</code>) and unsigned (ie the arg to the <code>vector&lt;char&gt;</code> constructor) will result in a your vector erroneously allocating a very large number of bytes. (Probably 4294967295 bytes, or 4GB.)

Modifying paxos1977's answer to account for the above:

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

 ifstream::pos_type fileSize = ifs.tellg();
 if (fileSize &lt; 0) &lt;--- ADDED
 return std::string(); &lt;--- ADDED

 ifs.seekg(0, ios::beg);

 vector&lt;char&gt; bytes(fileSize);
 ifs.read(&amp;bytes[0], fileSize);

 return string(&amp;bytes[0], fileSize);
}
</code></pre>

blocks|key|363596|text|此解决方案将错误检查添加到rdbuf()-based方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|363597|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();
}|code-block|syntax|javascript|363598|我之所以添加这个答案，是因为向原始方法添加错误检查并不像您预期的那么简单。原始方法使用stringstream的插入运算符(str_stream+<<+file_stream.rdbuf())。问题是，这会在未插入任何字符时设置字符串流的故障位。这可能是由于错误，也可能是由于文件为空。如果您通过检查故障位来检查故障，则在读取空文件时会遇到误报。如何消除合法的无法插入任何字符和因为文件为空而“无法”插入任何字符的歧义？|offset|length|style|CODE|363599|您可能会考虑显式地检查空文件，但这需要更多的代码和相关的错误检查。|363600|检查失败条件str_stream.fail()+&&+!str_stream.eof()不起作用，因为插入操作没有设置eofbit+(在ostringstream和ifstream上)。|363601|因此，解决方案是更改操作。使用ifstream的提取运算符(>>)，而不是使用ostringstream的插入运算符(<<)，该运算符设置eofbit。然后检查故障条件file_stream.fail()+&&+!file_stream.eof()。|363602|重要的是，当file_stream+>>+str_stream.rdbuf()遇到合法的失败时，它不应该设置eofbit+(根据我对规范的理解)。这意味着上述检查足以检测到合法的故障。|363603|entityMap^0|0|0|1Q|X|0|0|6|12|0|2C|14|0|6|X|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|15|8|@$I|16|J|17|K|L]]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@$I|19|J|1A|K|L]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|V|$]]

This solution adds error checking to the rdbuf()-based method.

<pre><code>std::string file_to_string(const std::string&amp; file_name)
{
 std::ifstream file_stream{file_name};

 if (file_stream.fail())
 {
 // Error opening file.
 }

 std::ostringstream str_stream{};
 file_stream &gt;&gt; str_stream.rdbuf(); // NOT str_stream &lt;&lt; file_stream.rdbuf()

 if (file_stream.fail() &amp;&amp; !file_stream.eof())
 {
 // Error reading file.
 }

 return str_stream.str();
}
</code></pre>

I'm adding this answer because adding error-checking to the original method is not as trivial as you'd expect. The original method uses stringstream's insertion operator (<code>str_stream &lt;&lt; file_stream.rdbuf()</code>). The problem is that this sets the stringstream's failbit when no characters are inserted. That can be due to an error or it can be due to the file being empty. If you check for failures by inspecting the failbit, you'll encounter a false positive when you read an empty file. How do you disambiguate legitimate failure to insert any characters and "failure" to insert any characters because the file is empty?

You might think to explicitly check for an empty file, but that's more code and associated error checking.

Checking for the failure condition <code>str_stream.fail() &amp;&amp; !str_stream.eof()</code> doesn't work, because the insertion operation doesn't set the eofbit (on the ostringstream nor the ifstream).

So, the solution is to change the operation. Instead of using ostringstream's insertion operator (&lt;&lt;), use ifstream's extraction operator (>>), which does set the eofbit. Then check for the failiure condition <code>file_stream.fail() &amp;&amp; !file_stream.eof()</code>.

Importantly, when <code>file_stream &gt;&gt; str_stream.rdbuf()</code> encounters a legitimate failure, it shouldn't ever set eofbit (according to my understanding of the specification). That means the above check is sufficient to detect legitimate failures.

blocks|key|364030|text|#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+%7C+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);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|364031|用法：|unstyled|364032|const+string+logAsString+=+GetFileAsString(logFilePath);|364033|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>#include &lt;string&gt;
#include &lt;sstream&gt;

using namespace std;

string GetStreamAsString(const istream&amp; in)
{
 stringstream out;
 out &lt;&lt; in.rdbuf();
 return out.str();
}

string GetFileAsString(static string&amp; filePath)
{
 ifstream stream;
 try
 {
 // Set to throw on failure
 stream.exceptions(fstream::failbit | fstream::badbit);
 stream.open(filePath);
 }
 catch (system_error&amp; error)
 {
 cerr &lt;&lt; "Failed to open '" &lt;&lt; filePath &lt;&lt; "'\n" &lt;&lt; error.code().message() &lt;&lt; endl;
 return "Open fail";
 }

 return GetStreamAsString(stream);
}
</code></pre>

usage:

<pre><code>const string logAsString = GetFileAsString(logFilePath);
</code></pre>

blocks|key|3156034|text|这是一个使用新文件系统库的版本，具有相当健壮的错误检查功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3156035|#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:+"+%2B+filepath.string()));
++}

++std::ifstream+infile;
++infile.exceptions(std::ifstream::failbit+%7C+std::ifstream::badbit);
++try+{
++++infile.open(filepath.c_str(),+std::ios::in+%7C+std::ifstream::binary);
++}+catch+(...)+{
++++std::throw_with_nested(std::runtime_error("Can't+open+input+file+"+%2B+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());+};|code-block|syntax|javascript|3156036|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a version using the new filesystem library with reasonably robust error checking:

<pre><code>#include &lt;cstdint&gt;
#include &lt;exception&gt;
#include &lt;filesystem&gt;
#include &lt;fstream&gt;
#include &lt;sstream&gt;
#include &lt;string&gt;

namespace fs = std::filesystem;

std::string loadFile(const char *const name);
std::string loadFile(const std::string &amp;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 &lt;&lt; "Can't resize to " &lt;&lt; fsize &lt;&lt; " 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 &amp;name) { return loadFile(name.c_str()); };
</code></pre>

blocks|key|364139|text|基于CTT解决方案的更新功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|364140|#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+%7C=+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;
}|code-block|syntax|javascript|364141|这里有两个重要的区别：|364142|不保证tellg()返回文件开始以来的偏移量(以字节为单位)。相反，正如Puzomor克罗地亚指出的那样，它更多的是一个可以在fstream调用中使用的令牌。但是，gcount()会返回上次提取的未格式化字节的数量。因此，我们打开文件，使用ignore()提取并丢弃它的所有内容，以获得文件的大小，并基于此构造输出字符串。|offset|length|style|CODE|364143|其次，通过直接写入字符串，我们避免了将文件数据从std::vector<char>复制到std::string。|364144|就性能而言，这应该是绝对最快的，提前分配适当大小的字符串并调用read()一次。有趣的是，在gcc上使用ignore()和countg()，而不是ate和tellg()，一点一点地编译成almost+the+same+thing。|364145|entityMap|0|LINK|mutability|MUTABLE|url|https://godbolt.org/z/8XvEvS^0|0|0|0|3|7|2A|8|3C|8|0|O|H|18|B|0|V|6|1G|8|1P|8|21|3|25|7|2L|L|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|13|8|@$K|14|L|15|M|N]|$K|16|L|17|M|N]|$K|18|L|19|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$K|1B|L|1C|M|N]|$K|1D|L|1E|M|N]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@$K|1G|L|1H|M|N]|$K|1I|L|1J|M|N]|$K|1K|L|1L|M|N]|$K|1M|L|1N|M|N]|$K|1O|L|1P|M|N]]|9|@$K|1Q|L|1R|1|1S]]|A|$]]|$1|S|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

An updated function which builds upon CTT's solution:
<pre><code>#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;limits&gt;
#include &lt;string_view&gt;
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&lt;std::streamsize&gt;::max());
 std::string data(ifs.gcount(), 0);
 ifs.seekg(0);
 ifs.read(data.data(), data.size());
 return data;
}
</code></pre>
There are two important differences:
<code>tellg()</code> is not guaranteed to return the offset in bytes since the beginning of the file. Instead, as Puzomor Croatia pointed out, it's more of a token which can be used within the fstream calls. <code>gcount()</code> however does return the amount of unformatted bytes last extracted. We therefore open the file, extract and discard all of its contents with <code>ignore()</code> to get the size of the file, and construct the output string based on that.
Secondly, we avoid having to copy the data of the file from a <code>std::vector&lt;char&gt;</code> to a <code>std::string</code> by writing to the string directly.
In terms of performance, this should be the absolute fastest, allocating the appropriate sized string ahead of time and calling <code>read()</code> once. As an interesting fact, using <code>ignore()</code> and <code>countg()</code> instead of <code>ate</code> and <code>tellg()</code> on gcc compiles down to <a href="https://godbolt.org/z/8XvEvS" rel="nofollow noreferrer">almost the same thing</a>, bit by bit.

blocks|key|367059|text|#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%2B=temp;
++++++++//adds+a+new+line
++++++++copy%2B="\n";
++++}
++++//Display+whole+document
++++cout<<copy;
++++//close+the+document
++++file.close();
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|367060|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;string.h&gt;
using namespace std;
main(){
 fstream file;
 //Open a file
 file.open(&quot;test.txt&quot;);
 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+=&quot;\n&quot;;
 }
 //Display whole document
 cout&lt;&lt;copy;
 //close the document
 file.close();
}
</code></pre>

blocks|key|3369140|text|由于这似乎是一个广泛使用的实用程序，我的方法是搜索并优先选择已经可用的库，而不是手工制作的解决方案，特别是如果boost库已经链接到您的项目中(链接器标志-lboost_system+-lboost_filesystem)。Here+(and+older+boost+versions+too)，boost提供了一个load_string_file实用程序：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3369141|#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;
}|code-block|syntax|javascript|3369142|作为一个优点，此函数不会查找整个文件来确定大小，而是在内部使用stat()。然而，一个可能可以忽略不计的缺点是，通过检查源代码可以很容易地推断出:字符串的大小被文件内容重写的'\0'字符不必要地调整了。|style|CODE|3369143|entityMap|0|LINK|mutability|MUTABLE|url|https://www.boost.org/doc/libs/1_74_0/boost/filesystem/string_file.hpp^0|34|Z|0|0|0|2F|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Since this seems like a widely used utility, my approach would be to search for and to prefer already available libraries to hand made solutions, especially if boost libraries are already linked(linker flags -lboost_system -lboost_filesystem) in your project. <a href="https://www.boost.org/doc/libs/1_74_0/boost/filesystem/string_file.hpp" rel="noreferrer">Here (and older boost versions too)</a>, boost provides a load_string_file utility:
<pre><code>#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;boost/filesystem/string_file.hpp&gt;

int main() {
 std::string result;
 boost::filesystem::load_string_file(&quot;aFileName.xyz&quot;, result);
 std::cout &lt;&lt; result.size() &lt;&lt; std::endl;
}
</code></pre>
As an advantage, this function doesn't seek an entire file to determine the size, instead uses stat() internally. As a possibly negligible disadvantage though, one could easily infer upon inspection of the source code: string is unnecessarily resized with <code>'\0'</code> character which are rewritten by the file contents.

blocks|key|3369164|text|这是我使用的函数，当由于某种原因处理大文件(1GB%2B)时，std::ifstream::read()比std::ifstream::rdbuf()快得多，当你知道文件大小时，所以“首先检查文件大小”这件事实际上是一个速度优化|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3369165|#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+%7C+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+%7C+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;
}|code-block|syntax|javascript|3369166|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

this is the function i use, and when dealing with large files (1GB+) for some reason std::ifstream::read() is much faster than std::ifstream::rdbuf() when you know the filesize, so the whole &quot;check filesize first&quot; thing is actually a speed optimization
<pre><code>#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;sstream&gt;
std::string file_get_contents(const std::string &amp;$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 &lt; 0)
 {
 // can't get size for some reason, fallback to slower &quot;just read everything&quot;
 // 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 &lt;&lt; file.rdbuf();
 return ss.str();
 }
 file.seekg(0, std::istream::beg);
 std::string result(size_t(ssize), 0);
 file.read(&amp;result[0], std::streamsize(ssize));
 return result;
}
</code></pre>

blocks|key|3369288|text|我知道这是一个非常古老的问题，有很多答案，但其中没有一个提到我认为最明显的方法。使用libc很好，特别是对于像这样简单的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3369289|本质上:只需打开文件，获取其大小(不一定是该顺序)，然后读取它。|3369290|#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+%2B+1U);
++++str.resize(st.st_size);
++++::fread(str.data(),+1,+st.st_size,+fp);
++++str[st.st_size]+=+'\0';
++++::fclose(fp);
}|code-block|syntax|javascript|3369291|除了(实际上)完全可移植之外，这看起来并不比其他一些解决方案更糟糕。当然，也可以抛出异常而不是立即退出。将std::string的大小调整为0总是初始化它，这让我非常恼火，但这是无能为力的。|offset|length|style|CODE|3369292|请注意，这只适用于C%2B%2B17及更高版本。早期版本(应该)不允许编辑std::string::data()。如果使用较早的版本，请考虑使用std::string_view或简单地复制原始缓冲区。|BOLD|3369293|entityMap^0|0|0|0|1H|B|0|0|3|X|J|1W|G|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|W|8|@$K|X|L|Y|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Z|8|@$K|10|L|11|M|Q]|$K|12|L|13|M|N]|$K|14|L|15|M|N]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|S|$]]

I know this is a positively ancient question with a plethora of answers, but not one of them mentions what I would have considered the most obvious way to do this. Yes, I know this is C++, and using libc is evil and wrong or whatever, but nuts to that. Using libc is fine, especially for such a simple thing as this.
Essentially: just open the file, get it's size (not necessarily in that order), and read it.
<pre><code>#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;
#include &lt;cstring&gt;
#include &lt;sys/stat.h&gt;

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

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

 struct stat st;
 if (::fstat(fileno(fp), &amp;st) == (-1)) {
 ::perror(&quot;fstat&quot;);
 ::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);
}
</code></pre>
This doesn't really seem worse than some of the other solutions, in addition to being (in practice) completely portable. One could also throw an exception instead of exiting immediately, of course. It seriously irritates me that resizing the <code>std::string</code> always 0 initializes it, but it can't be helped.
PLEASE NOTE that this is only going to work as written for C++17 and later. Earlier versions (ought to) disallow editing <code>std::string::data()</code>. If working with an earlier version consider using <code>std::string_view</code> or simply copying a raw buffer.

blocks|key|3369295|text|在性能方面，我没有发现比下面的代码更快的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3369296|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;
}|code-block|syntax|javascript|3369297|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For performance I haven't found anything faster than the code below.
<pre><code>std::string readAllText(std::string const &amp;path)
{
 assert(path.c_str() != NULL);
 FILE *stream = fopen(path.c_str(), &quot;r&quot;);
 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;
}
</code></pre>

blocks|key|3369465|text|您可以使用我开发的rst+C%2B%2B库来完成此操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3369466|#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;|code-block|syntax|javascript|3369467|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/sabbakumov/rst/blob/master/rst/files/file_utils.h#L79^0|9|3|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can use the <a href="https://github.com/sabbakumov/rst/blob/master/rst/files/file_utils.h#L79" rel="nofollow noreferrer">rst</a> C++ library that I developed to do that:
<pre><code>#include &quot;rst/files/file_utils.h&quot;

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

std::cout &lt;&lt; *content &lt;&lt; &quot;, &quot; &lt;&lt; content-&gt;size() &lt;&lt; std::endl;
</code></pre>

blocks|key|3369477|text|我知道我来晚了，但现在(2021)在我的机器上，这是我测试过的最快的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3369478|#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;
}|code-block|syntax|javascript|3369479|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I know that I am late to the party, but now (2021) on my machine, this is the fastest implementation that I have tested:
<pre><code>#include &lt;fstream&gt;
#include &lt;string&gt;

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

blocks|key|367191|text|#include+<string>
#include+<fstream>

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

++++std::string+data;

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

++++++++file.close();
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|367192|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#include &lt;string&gt;
#include &lt;fstream&gt;

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

 std::string data;

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

 file.close();
 }
}
</code></pre>

How do I read a file into a <code>std::string</code>, i.e., read the whole file at once?

Text or binary mode should be specified by the caller. The solution should be standard-compliant, portable and efficient. It should not needlessly copy the string's data, and it should avoid reallocations of memory while reading the string.

One way to do this would be to stat the filesize, resize the <code>std::string</code> and <code>fread()</code> into the <code>std::string</code>'s <code>const_cast&lt;char*&gt;()</code>'ed <code>data()</code>. This requires the <code>std::string</code>'s data to be contiguous which is not required by the standard, but it appears to be the case for all known implementations. What is worse, if the file is read in text mode, the <code>std::string</code>'s size may not equal the file's size.

A fully correct, standard-compliant and portable solutions could be constructed using <code>std::ifstream</code>'s <code>rdbuf()</code> into a <code>std::ostringstream</code> and from there into a <code>std::string</code>. However, this could copy the string data and/or needlessly reallocate memory. 

<ul>
<li>Are all relevant standard library implementations smart enough to avoid all unnecessary overhead? </li>
<li>Is there another way to do it? </li>
<li>Did I miss some hidden Boost function that already provides the desired functionality?</li>
</ul>

 

<pre><code>void slurp(std::string&amp; data, bool is_binary)
</code></pre>

How do I read an entire file into a std::string in C++?

文件系统

如何将文件读入std::string，即一次性读取整个文件？文本或二进制模式应由调用方指定。该解决方案应该是符合标准的、可移植的和高效的。它不应该不必要地复制字符串的数据，并且应该避免在读取字符串时重新分配内存。要做到这一点，一种方法是统计文件大小，将std::string和fread()调整为std::string的...

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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