我目前正在学习C++（来自Java），我试图了解如何在C++中正确使用IO流。
假设我有一个Image类，它包含一个图像的像素，我重载了提取操作符来从流中读取图像：

istream& operator>>(istream& stream, Image& image)
{
    // Read the image data from the stream into the image
    return stream;
}

现在我可以看到这样的图像：

Image image;
ifstream file("somepic.img");
file >> image;

但现在我想使用相同的提取运算符从自定义流中读取图像数据。假设我有一个包含压缩形式的图像的文件。所以我不想使用ifstream，而是想实现自己的输入流。至少我在Java中是这样做的。在Java中，我将编写一个自定义类，扩展InputStream类并实现int read()方法。所以这很简单。用法如下：

InputStream stream = new CompressedInputStream(new FileInputStream("somepic.imgz"));
image.read(stream);

因此，使用相同的模式，也许我想在C++中这样做：

Image image;
ifstream file("somepic.imgz");
compressed_stream stream(file);
stream >> image;

但也许这是错误的方式，不知道。扩展istream类看起来相当复杂，经过一番搜索，我发现了一些关于扩展streambuf的提示。但是这个example对于这样一个简单的任务来说看起来非常复杂。
那么，实现自定义输入/输出流（或streambufs）的最佳方法是什么呢？）在C++？

溶液

有些人建议不要使用iostreams，而是使用迭代器，boost或自定义IO接口。这些可能是有效的替代方案，但我的问题是关于iostreams的。接受的答案导致下面的示例代码。为了更容易阅读，没有头/代码分离，整个std命名空间都被导入（我知道这在真实的代码中是一件坏事）。
这个例子是关于阅读和写入垂直xor编码的图像。格式很简单。每个字节表示两个像素（每个像素4位）。每行与前一行进行异或运算。这种编码为图像的压缩做好了准备（通常会产生大量的0字节，这更容易压缩）。

#include <cstring>
#include <fstream>

using namespace std;

/*** vxor_streambuf class ******************************************/

class vxor_streambuf: public streambuf
{
public:
    vxor_streambuf(streambuf *buffer, const int width) :
        buffer(buffer),
        size(width / 2)
    {
        previous_line = new char[size];
        memset(previous_line, 0, size);
        current_line = new char[size];
        setg(0, 0, 0);
        setp(current_line, current_line + size);
    }

    virtual ~vxor_streambuf()
    {
        sync();
        delete[] previous_line;
        delete[] current_line;
    }

    virtual streambuf::int_type underflow()
    {
        // Read line from original buffer
        streamsize read = buffer->sgetn(current_line, size);
        if (!read) return traits_type::eof();

        // Do vertical XOR decoding
        for (int i = 0; i < size; i += 1)
        {
            current_line[i] ^= previous_line[i];
            previous_line[i] = current_line[i];
        }

        setg(current_line, current_line, current_line + read);
        return traits_type::to_int_type(*gptr());
    }

    virtual streambuf::int_type overflow(streambuf::int_type value)
    {
        int write = pptr() - pbase();
        if (write)
        {
            // Do vertical XOR encoding
            for (int i = 0; i < size; i += 1)
            {
                char tmp = current_line[i];
                current_line[i] ^= previous_line[i];
                previous_line[i] = tmp;
            }

            // Write line to original buffer
            streamsize written = buffer->sputn(current_line, write);
            if (written != write) return traits_type::eof();
        }

        setp(current_line, current_line + size);
        if (!traits_type::eq_int_type(value, traits_type::eof())) sputc(value);
        return traits_type::not_eof(value);
    };

    virtual int sync()
    {
        streambuf::int_type result = this->overflow(traits_type::eof());
        buffer->pubsync();
        return traits_type::eq_int_type(result, traits_type::eof()) ? -1 : 0;
    }

private:
    streambuf *buffer;
    int size;
    char *previous_line;
    char *current_line;
};

/*** vxor_istream class ********************************************/

class vxor_istream: public istream
{
public:
    vxor_istream(istream &stream, const int width) :
        istream(new vxor_streambuf(stream.rdbuf(), width)) {}

    virtual ~vxor_istream()
    {
        delete rdbuf();
    }
};

/*** vxor_ostream class ********************************************/

class vxor_ostream: public ostream
{
public:
    vxor_ostream(ostream &stream, const int width) :
        ostream(new vxor_streambuf(stream.rdbuf(), width)) {}

    virtual ~vxor_ostream()
    {
        delete rdbuf();
    }
};

/*** Test main method **********************************************/

int main()
{
    // Read data
    ifstream infile("test.img");
    vxor_istream in(infile, 288);
    char data[144 * 128];
    in.read(data, 144 * 128);
    infile.close();

    // Write data
    ofstream outfile("test2.img");
    vxor_ostream out(outfile, 288);
    out.write(data, 144 * 128);
    out.flush();
    outfile.close();

    return 0;
}