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

One way is to flush the stream buffer into a separate memory stream, and then convert that to std::string (error handling omitted):

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

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++17, error handling included):

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); if (not stream) { throw std::ios_base::failure("file does not exist"); } 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; } 

The shortest variant: Live On Coliru

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

It requires the header <iterator>.

There were some reports that this method is slower than preallocating the string and using std::istream::read. However, on a modern compiler with optimisations enabled this no longer seems to be the case, though the relative performance of various methods seems to be highly compiler dependent.

See this answer on a similar question.

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

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

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

If you have C++17 (std::filesystem), there is also this way (which gets the file's size through std::filesystem::file_size instead of seekg and 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; } 

Note: you may need to use <experimental/filesystem> and std::experimental::filesystem if your standard library doesn't yet fully support C++17. You might also need to replace result.data() with &result[0] if it doesn't support non-const std::basic_string data.

Use

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

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

Yes, I understand I didn't write the slurp function as asked.

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

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

An example of the problem:

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

In the above example, if tellg() encounters an error it will return -1. Implicit casting between signed (ie the result of tellg()) and unsigned (ie the arg to the vector<char> 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:

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

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. Here (and older boost versions too), boost provides a load_string_file utility:

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

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 '\0' character which are rewritten by the file contents.

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

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

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 (str_stream << file_stream.rdbuf()). 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 str_stream.fail() && !str_stream.eof() 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 (<<), use ifstream's extraction operator (>>), which does set the eofbit. Then check for the failiure condition file_stream.fail() && !file_stream.eof().

Importantly, when file_stream >> str_stream.rdbuf() 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.

Something like this shouldn't be too bad:

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

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.

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

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

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.

#include <string> #include <cstdio> #include <cstdlib> #include <cstring> #include <sys/stat.h> static constexpr char filename[] = "foo.bar"; int main(void) { FILE *fp = ::fopen(filename, "rb"); if (!fp) { ::perror("fopen"); ::exit(1); } // Stat isn't strictly part of the standard C library, // but it's in every libc I've ever seen for a hosted system. 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); } 

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 std::string 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 std::string::data(). If working with an earlier version consider replacing str.data() with &str[0].

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

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

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

usage:

const string logAsString = GetFileAsString(logFilePath); 

For performance I haven't found anything faster than the code below.

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

Pulling info from several places... This should be the fastest and best way:

#include <filesystem> #include <fstream> #include <string> //Returns true if successful. bool readInFile(std::string pathString) { //Make sure the file exists and is an actual file. if (!std::filesystem::is_regular_file(pathString)) { return false; } //Convert relative path to absolute path. pathString = std::filesystem::weakly_canonical(pathString); //Open the file for reading (binary is fastest). std::wifstream in(pathString, std::ios::binary); //Make sure the file opened. if (!in) { return false; } //Wide string to store the file's contents. std::wstring fileContents; //Jump to the end of the file to determine the file size. in.seekg(0, std::ios::end); //Resize the wide string to be able to fit the entire file (Note: Do not use reserve()!). fileContents.resize(in.tellg()); //Go back to the beginning of the file to start reading. in.seekg(0, std::ios::beg); //Read the entire file's contents into the wide string. in.read(fileContents.data(), fileContents.size()); //Close the file. in.close(); //Do whatever you want with the file contents. std::wcout << fileContents << L" " << fileContents.size(); return true; } 

This reads in wide characters into a std::wstring, but you can easily adapt if you just want regular characters and a std::string.

You can use the rst C++ library that I developed to do that:

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

For a small to medium sized file I use these methods which are quite fast. The one returning string can be used to "convert" the byte array to string.

auto read_file_bytes(std::string_view filepath) -> std::vector<std::byte> { std::ifstream ifs(filepath.data(), std::ios::binary | std::ios::ate); if (!ifs) throw std::ios_base::failure("File does not exist"); auto end = ifs.tellg(); ifs.seekg(0, std::ios::beg); auto size = std::size_t(end - ifs.tellg()); if (size == 0) // avoid undefined behavior return {}; std::vector<std::byte> buffer(size); if (!ifs.read((char *) buffer.data(), buffer.size())) throw std::ios_base::failure("Read error"); return buffer; } auto read_file_string(std::string_view filepath) -> std::string { auto bytes = read_file_bytes(filepath); return std::string(reinterpret_cast<char *>(bytes.begin().base()), bytes.size()); } 

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 "check filesize first" thing is actually a speed optimization

#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 don't trust that we could seek back/forth in the original stream, // I'm 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; } 

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).

An updated function which builds upon CTT's solution:

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

There are two important differences:

tellg() 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. gcount() however does return the amount of unformatted bytes last extracted. We therefore open the file, extract and discard all of its contents with ignore() 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 std::vector<char> to a std::string 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 read() once. As an interesting fact, using ignore() and countg() instead of ate and tellg() on gcc compiles down to almost the same thing, bit by bit.

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

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

std::string get(std::string_view const& fn) { struct filebuf: std::filebuf { using std::filebuf::egptr; using std::filebuf::gptr; using std::filebuf::gbump; using std::filebuf::underflow; }; std::string r; if (filebuf fb; fb.open(fn.data(), std::ios::binary | std::ios::in)) { r.reserve(fb.pubseekoff({}, std::ios::end)); fb.pubseekpos({}); while (filebuf::traits_type::eof() != fb.underflow()) { auto const gptr(fb.gptr()); auto const sz(fb.egptr() - gptr); fb.gbump(sz); r.append(gptr, sz); } } return r; } 

I know that I am late to the party, but now (2021) on my machine, this is the fastest implementation that I have tested:

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