Various people have various solutions, those who use the C API, C++ API, or some variation of tricks with iterators and algorithms. Wondering which method is the fastest, I thought I might as well put the various options to the test, and the results were surprising.
First, let me propose an API that we'll be using for the function. We'll send a function a C string (char *) of a filename, and we'll get back a C++ string (std::string) of the file contents. If the file cannot be opened, we'll throw an error why that is so. Of course you're welcome to change these functions to receive and return whatever format you prefer, but this is the prototype we'll be operating on:
std::string get_file_contents(const char *filename);
Our first technique to consider is using the C API to read directly into a string. We'll open a file using fopen(), calculate the file size by seeking to the end, and then size a string appropriately. We'll read the contents into the string, and then return it.
#include <string> #include <cstdio> #include <cerrno> std::string get_file_contents(const char *filename) { std::FILE *fp = std::fopen(filename, "rb"); if (fp) { std::string contents; std::fseek(fp, 0, SEEK_END); contents.resize(std::ftell(fp)); std::rewind(fp); std::fread(&contents[0], 1, contents.size(), fp); std::fclose(fp); return(contents); } throw(errno); }
I'm dubbing this technique "method C". This is more or less the technique of any proficient C++ programmer who prefers C style I/O would look like.
The next technique we'll review is basically the same idea, but using C++ streams instead.
#include <fstream> #include <string> #include <cerrno> std::string get_file_contents(const char *filename) { std::ifstream infile(filename, std::ios::in | std::ios::binary); if (infile.is_open()){ std::string contents; infile.seekg(0, std::ios::end); contents.resize(infile.tellg()); // same as: std::string contents(infile.tellg(), '\0'); infile.seekg(0, std::ios::beg); infile.read(&contents[0], contents.size()); infile.close(); return(contents); } throw(errno); }
I'm dubbing this technique "method C++". Again, more or less a straight forward C++ implementation based on the same principals as before.
The next technique people consider is using istreambuf_iterator. This iterator is designed for really fast iteration out of stream buffers (files) in C++.
#include <fstream> #include <streambuf> #include <string> #include <cerrno> std::string get_file_contents(const char *filename) { std::ifstream infile(filename, std::ios::in | std::ios::binary); if (infile.is_open()){ return(std::string((std::istreambuf_iterator<char>(infile)), std::istreambuf_iterator<char>())); } throw(errno); }
This method is liked by many because of how little code is needed to implement it, and you can read a file directly into all sorts of containers, not just strings. The method was also popularized by the Effective STL
book. I'm dubbing the technique "method iterator".
Now some have looked at the last technique, and felt it could be optimized further, since if the string has an idea in advance how big it needs to be, it will reallocate less. So the idea is to reserve the size of the string, then pull the data in.
#include <fstream> #include <streambuf> #include <string> #include <cerrno> std::string get_file_contents(const char *filename) { std::ifstream in(filename, std::ios::in | std::ios::binary); if (infile.is_open()){ std::string contents; infile.seekg(0, std::ios::end); contents.reserve(infile.tellg()); infile.seekg(0, std::ios::beg); contents.assign((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>()); infile.close(); return(contents); } throw(errno); }
I will call this technique "method assign", since it uses the string's assign function.
Some have questioned the previous function, as assign() in some implementations may very well replace the internal buffer, and therefore not benefit from reserving. Better to call push_back() instead, which will keep the existing buffer if no reallocation is needed.
#include <fstream> #include <streambuf> #include <string> #include <algorithm> #include <iterator> #include <cerrno> std::string get_file_contents(const char *filename) { std::ifstream infile(filename, std::ios::in | std::ios::binary); if (infile.is_open()){ std::string contents; infile.seekg(0, std::ios::end); contents.reserve(infile.tellg()); infile.seekg(0, std::ios::beg); std::copy((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>(), std::back_inserter(contents)); infile.close(); return(contents); } throw(errno); }
Combining std::copy() and std::back_inserter(), we can achieve our goal. I'm labeling this technique "method copy".
Lastly, some want to try another approach entirely. C++ streams have some very fast copying to another stream via operator<< on their internal buffers. Therefore, we can copy directly into a string stream, and then return the string that string stream uses.
#include <fstream> #include <sstream> #include <string> #include <cerrno> std::string get_file_contents(const char *filename) { std::ifstream infile(filename, std::ios::in | std::ios::binary); if (infile.is_open()) { std::ostringstream contents; contents << infile.rdbuf(); infile.close(); return(contents.str()); } throw(errno); }
We'll call this technique "method rdbuf".
Now which is the fastest method to use if all you actually want to do is read the file into a string and return it? The exact speeds in relation to each other may vary from one implementation to another, but the overall margins between the various techniques should be similar.
I conducted my tests with libstdc++ and GCC 4.6, what you see may vary from this.
I tested with multiple megabyte files, reading in one after another, and repeated the tests a dozen times and averaged the results.
| Method | Duration |
|---|---|
| C | 24.5 |
| C++ | 24.5 |
| Iterator | 64.5 |
| Assign | 68 |
| Copy | 62.5 |
| Rdbuf | 32.5 |
Ordered by speed:
| Method | Duration |
|---|---|
| C/C++ | 24.5 |
| Rdbuf | 32.5 |
| Copy | 62.5 |
| Iterator | 64.5 |
| Assign | 68 |
These results are rather interesting. There was no speed difference at all whether using the C or C++ API for reading a file. This should be obvious to us all, but yet many people strangely think that the C API has less overhead. The straight forward vanilla methods were also faster than anything involving iterators.
C++ stream to stream copying is really fast. It probably only took a bit longer than the vanilla method due to some reallocations needed. If you're doing disk file to disk file though, you probably want to consider this option, and go directly from in stream to out stream.
Using the istreambuf_iterator methods while popular and concise are actually rather slow. Sure they're faster than istream_iterators (with skipping turned off), but they can't compete with more direct methods.
A C++ string's internal assign() function, at least in libstdc++, seems to throw away the existing buffer (at the time of this writing), so reserving then assigning is rather useless. On the other hand, reading directly into a string, or a different container for that matter, isn't necessarily your most optimal solution where iterators are concerned. Using the external std::copy() function, along with back inserting after reservation is faster than straight up initialization. You might want to consider this method for inserting into some other containers. In fact, I found that std::copy() of istreambuf_iterators with back inserter into an std::deque to be faster than straight up initialization (81 vs 88.5), despite a Deque not being able to reserve room in advance (nor does such make sense with a Deque).
I also found this to be a cute way to get a file into a container backwards, despite a Deque being rather useless for working with file contents.
std::deque<char> contents; std::copy((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>(), std::front_inserter(contents));
Now go out there and speed up your applications!
If there's any demand, I'll see about performing these tests with other C++ implementations.
扫一扫
2402
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
