如何适配自定义Writer为std::ostream传入写函数（大流量无中转）

核心原理 #

C++标准库的std::ostream/std::istream本身不直接处理实际IO，所有读写操作都会委托给关联的std::streambuf对象。我们只需要通过自定义std::streambuf的派生类，把流的读写操作直接转发给自定义的Writer/Reader接口，就能完全避免全量内存中转，满足大流量场景的要求。

Writer 接口到 std::ostream 的适配 #

该方案无全量内存缓存，写入操作直接透传到自定义Writer实例，内存占用和写入数据规模无关。

适配实现代码 #

#include <streambuf>
#include <ostream>

// 保留原Writer接口定义
struct Writer {
    virtual size_t write(const char* buffer, size_t size, size_t offset) = 0;
};

class WriterOStreamBuffer : public std::streambuf {
public:
    explicit WriterOStreamBuffer(Writer* writer) 
        : writer_(writer), current_offset_(0) {
        // 配置空写入缓冲区，让所有写入操作直接触发透传逻辑
        setp(nullptr, nullptr);
    }

protected:
    // 批量写入回调，性能优于单字符写入
    std::streamsize xsputn(const char* s, std::streamsize n) override {
        size_t written = writer_->write(s, static_cast<size_t>(n), current_offset_);
        current_offset_ += written;
        return static_cast<std::streamsize>(written);
    }

    // 单字符写入兜底回调
    int_type overflow(int_type c) override {
        if (c == traits_type::eof()) {
            return traits_type::eof();
        }
        char ch = static_cast<char>(c);
        size_t written = writer_->write(&ch, 1, current_offset_);
        if (written == 1) {
            current_offset_ += 1;
            return traits_type::to_int_type(ch);
        }
        return traits_type::eof();
    }

private:
    Writer* writer_;
    size_t current_offset_; // 自动维护Writer需要的写入偏移量
};

使用方式 #

• 拿到已有的Writer实例
• 构造适配的buffer对象，再将buffer与std::ostream绑定
• 直接把构造好的ostream传入目标函数即可

void foo(std::ostream& os); // 无需修改实现的目标函数

int main() {
    Writer& my_writer = get_your_writer_instance(); // 你持有的Writer实例
    
    WriterOStreamBuffer write_buffer(&my_writer);
    std::ostream os(&write_buffer);
    
    // 直接调用，所有写入内容会直接透传到my_writer，无全量中转
    foo(os);
    return 0;
}

补充：如果需要支持流随机定位（seek）操作，只需要在上述buffer类中重写seekoff/seekpos方法，根据定位位置更新内部的current_offset_值即可，核心透传逻辑无需改动。

Reader 接口到 std::istream 的适配 #

首先定义与Writer对称的Reader接口，适配过程使用固定大小的小块读缓存（默认4KB），不会全量加载数据集到内存，内存占用和总数据规模无关。

接口定义（与Writer逻辑对称） #

struct Reader {
    // 从指定offset位置读取size个字节到buffer，返回实际读到的字节数
    virtual size_t read(char* buffer, size_t size, size_t offset) = 0;
};

适配实现代码 #

class ReaderIStreamBuffer : public std::streambuf {
private:
    static constexpr size_t READ_CHUNK_SIZE = 4096; // 固定4KB小块缓存，内存占用极低
    Reader* reader_;
    size_t current_offset_; // 记录下次从Reader读取的偏移位置
    char read_chunk_[READ_CHUNK_SIZE]; // 小块临时缓存

protected:
    // 当读取缓冲区为空时，触发从底层Reader读取新数据块
    int_type underflow() override {
        // 缓冲区还有剩余数据，直接返回当前位置的字符
        if (gptr() < egptr()) {
            return traits_type::to_int_type(*gptr());
        }

        // 从Reader读取一块数据到临时缓存
        size_t bytes_read = reader_->read(read_chunk_, READ_CHUNK_SIZE, current_offset_);
        if (bytes_read == 0) {
            return traits_type::eof();
        }

        current_offset_ += bytes_read;
        // 配置读缓冲区的指针范围
        setg(read_chunk_, read_chunk_, read_chunk_ + bytes_read);
        return traits_type::to_int_type(*gptr());
    }

public:
    explicit ReaderIStreamBuffer(Reader* reader) 
        : reader_(reader), current_offset_(0) {
        // 初始状态：读缓冲区为空，触发首次underflow读取数据
        setg(read_chunk_, read_chunk_, read_chunk_);
    }
};

使用方式 #

void bar(std::istream& is); // 接收istream的目标函数

int main() {
    Reader& my_reader = get_your_reader_instance(); // 你持有的Reader实例

    ReaderIStreamBuffer read_buffer(&my_reader);
    std::istream is(&read_buffer);

    // 所有读取操作会自动通过小块缓存从my_reader取数，无全量加载
    bar(is);
    return 0;
}

方案合规性说明 #

• 完全满足大流量场景要求：Writer侧无任何全量内存缓存，写入直接透传；Reader侧仅用4KB固定大小的临时缓存，内存占用与总数据规模无关，不会出现全量中转的内存爆炸问题
• 无需修改现有代码：不需要改动foo等接收流参数的函数逻辑，也不需要改动你的自定义Writer/Reader接口实现
• 性能足够：批量写入/读取的路径走标准流的批量处理逻辑，和标准库原生流的性能差异可忽略

内容的提问来源于stack exchange，提问作者Peter Jankuliak