C++ 将固定数量的字节复制到std:：deque<；char>；

我正在创建一个类来缓冲从

std:：cin

读取的一些二进制数据；我需要一些有限的 能够在流中反向跟踪。 更详细地说，当我从流中

读取
n
字节时，我希望能够倒带到
n
流中的字节

目前，我通过追加单个字符来追加缓冲区
到std：：deque
，但我希望有更好的复制方法
从
std:：istream
到
std:：deque
的数据块

基本上，有没有办法改进（删除？）while循环
下面的
加载
功能

目前我有：

#include<algorithm>
#include<deque>

class BufferedStdIn{
public:

BufferedStdIn(): m_buffer(), m_cursor(0){
}

// copy data out from my internal buffer to the client's array
// format dictated by external interface requirement
void read(char* dest, size_t n){
    load(n)
    std::copy( m_buffer.begin(), m_buffer.begin()+n, dest );
    m_cursor+=n;
}

// Go backwards in the stream; return the number of bytes moved.
// @retval < input arg n indicates that we can't rewind as far as asked for
size_t rewind(size_t n){
    int final_pos=m_cursor-n;
    if( final_pos < 0 ){
        // can't go as far as the client wants, just go back to start of my buffer
        size_t moved=m_cursor;
        m_cursor=0;
        return moved;
    }
    else{ // can do what client wants
        m_cursor=final_pos;
        return n;
    }
}

void load(n){
    m_buffer.erase( m_buffer.begin(), m_buffer.begin()+m_cursor);
    m_cursor=0;
    while( m_buffer.size()<n){
        char c;
        std::cin.get(c);
        m_buffer.push_back(c);
    }
}

// SNIP: other functions that let clients look at m_buffer

std::deque<char> m_buffer;
size_t m_cursor;


}

#包括
#包括
类BufferedStdIn{
公众：
BufferedStdIn（）：m_buffer（），m_游标（0）{
}
//将数据从内部缓冲区复制到客户端阵列
//由外部接口要求决定的格式
无效读取（字符*dest，大小\u t n）{
负载（n）
std:：copy（m_buffer.begin（），m_buffer.begin（）+n，dest）；
m_光标+=n；
}
//在流中向后移动；返回移动的字节数。
//@retval而（m_buffer.size（）可能效率不高，但更短：

void load(size_t n)
{
    m_buffer.erase( m_buffer.begin(), m_buffer.begin()+m_cursor);
    m_cursor=0;
    if(m_buffer.size() < n)
        std::copy_n(std::istream_iterator<char>(std::cin), n - m_buffer.size(), std::back_inserter(m_buffer));
}

空荷载（尺寸）
{
m_buffer.erase（m_buffer.begin（），m_buffer.begin（）+m_游标）；
m_光标=0；
if（m_buffer.size（）
你想做什么？用向量或istream作为缓冲区怎么样？我选择了
deque
，因为这个过程是：向后推，从前面落下——一种我通常与deque关联的模式。我想我可以使用
vector
并使用
vector:：iterator==T*
（实际上），并提供适当的迭代器（指针）来调用
std:：cin.get（）
。如果是这种情况，我建议使用一个环形缓冲区。boost有一个。本质上，它是一个向量，一旦到达缓冲区边界，它就环绕开始。