class LineIterator: public std::iterator<std::input_iterator_tag,
std::string const>
{
public:
// Default Constructible
LineIterator(): stream(nullptr) {}
explicit LineIterator(std::istream& is): stream(&is) { this->advance(); }
// Equality Comparable
friend bool operator==(LineIterator const& left, LineIterator const& right) {
return left.stream == right.stream
and left.buffer == right.buffer
and left.currentLine == right.currentLine;
}
friend bool operator!=(LineIterator const& left, LineIterator const& right) {
return not (left == right);
}
// Trivial Iterator (non mutable)
pointer operator->() const { return ¤tLine; }
reference operator*() const { return currentLine; }
// Input Iterator
LineIterator& operator++() {
this->advance();
return *this;
} // operator++
LineIterator operator++(int) {
LineIterator tmp(*this);
++*this;
return tmp;
} // operator++
private:
void advance() {
// Advance a valid iterator to fetch the next line from the source stream.
static LineIterator const SingularValue;
assert(*this != SingularValue and "Cannot advance singular iterator");
// Note: in real life, I would use std::getline...
// ... but it would not showcase the double-buffering model
// required to solve the OP problem (because of decoding)
// We use double-buffering, so clear current and swap buffers
currentLine.clear();
swap(buffer, currentLine);
// Check if we found some new line or not
size_t const nl = currentLine.find('\n');
// If we found one already, preserve what's after in the buffer
// as we only want to expose one line worth of material.
if (nl != std::string::npos) {
if (nl == currentLine.size()) { return; } // nothing to preserve
buffer.assign(currentLine.begin() + nl + 1, currentLine.end());
currentLine.erase(currentLine.begin() + nl + 1, currentLine.end());
return;
}
// If we did not, then we need to pump more data into the buffer.
if (not stream) { return; } // Nothing to pump...
static size_t const ReadBufferSize = 256;
char input[ReadBufferSize];
while (stream->read(input, ReadBufferSize)) {
if (this->splitBuffer(input, ReadBufferSize)) { break; }
}
// We end up here either if we found a new line or if some read failed.
// If the stream is still good, we successfully found a new line!
if (*stream) { return; }
// Otherwise, the stream is no good any longer (it dried up!)
// but we may still have read some little things from it.
this->splitBuffer(input, stream->gcount());
stream = SingularValue.stream; // stream dried up,
// so reset it to match singular value.
} // advance
bool splitBuffer(char const* input, size_t const size) {
// Split input at the newline character, the first chunk ends
// up in currentLine, the second chunk in buffer.
// Returns true if a newline character was found, false otherwise.
// Check if we finally found a new line
char const* const newLine = std::find(input, input + size, '\n');
// If we did not, copy everything into currentLine and signal it.
if (newLine == input + size) {
currentLine.append(input, size);
return false;
}
// If we did, copy everything up to it (including it) into currentLine
// and then bufferize the rest for the next iteration.
currentLine.append(input, newLine + 1);
buffer.assign(newLine + 1, input + size);
return true;
} // splitBuffer
std::istream* stream;
std::string buffer;
std::string currentLine;
}; // class LineIterator
这可能有点啰嗦（而且可能存在漏洞...），但它具有我们需要与STL算法组合的接口，例如：
std::ifstream file("someFile.txt");
std::copy(LineIterator(file), LineIterator(), std::ostream_iterator(std::cout));
这将会逐行在终端上输出文件 (点此查看示例)。
现在，您需要用块读取和解压缩来替换获取部分 (stream.read) :)
std::iterator 是一个简单的类，没有方法/状态，只是声明了一些内部类型（比如 reference），这些类型是从迭代器中期望得到的；2. 在 Foo(int i): attribute(i) {} 中，位于 : 和 { 之间的部分是初始化列表，用于在构造函数体开始之前初始化类属性；3. friend 是一种声明允许一个类或函数访问当前类的protected和private部分的方式，而通常情况下是不允许的... - Matthieu M.someclass->时，会调用operator->()，而当你写*someclass时，会调用operator*()（无参数），它们用于提供类似指针的接口。我建议你参考《C++权威指南和书单》来提升你对C++的了解，因为这些都是非常基础的问题，你很可能会反复遇到这些概念。 - Matthieu M.
pipe系统调用来创建管道。一个线程解压文件并将其写入管道；另一个线程从管道中读取数据并执行相应操作。至于通过这种方式是否会得到任何好处，这是一个未知的问题。 - Duck