C++ std：：可以快速使用的向量

我希望能够消耗部分缓冲区，直到它变空。我在下面设计了我自己的，但我想知道std库中是否已经有这样的东西，所以我排除了实现我自己的错误的可能性

请注意，我仅将

std:：vector

用于自动存储。我不想使用

push_back

插入和

pop_back

消费，因为我希望数据的消费尽可能快

#include <iostream>
#include <vector>

using namespace std;

    template <class T>
    class Buffer
    {
    public:
        void write(T* buffer, size_t amountToWrite) {
            if (amountToWrite <= this->_buffer.capacity()) {
                std::copy(buffer, buffer + amountToWrite, this->_buffer.data());
                _size += amountToWrite;
            } else {
                //In fact I wanted to increase capacity, not size. However we don't use the vector functions, so does it mater?
                this->_buffer.resize(amountToWrite);
                std::copy(buffer, buffer + amountToWrite, this->_buffer.data());
                _size += amountToWrite;
            }
        }
    
        size_t consume(T* bufferToWrite, size_t amountToConsume) {
            if (_current==_size) {
               //this means we've already read everything. Maybe we should throw or just return 0?
               return 0; 
            }
            if (amountToConsume <= this->_size) {
                std::copy(this->_buffer.data() + _current, this->_buffer.data() + _current + amountToConsume, bufferToWrite);
                _current += amountToConsume;
                return amountToConsume;
            } else {
                size_t remaining = this->_size - amountToConsume;
                std::copy(this->_buffer.data() + _current, this->_buffer.data() + _current + remaining, bufferToWrite);
                _current += remaining;
                return remaining;
            }
        }
    
    private:
        size_t _size = 0;
        std::vector<T> _buffer;
        size_t _current = 0;
    };

int main()
{
    Buffer<uint8_t> b;
    uint8_t u[] = {1,2,3,4,5,6};
    b.write(u, 6);

    uint8_t r[3];
    size_t consumedBytes = b.consume(r, 3);
    std::cout << "consumed " << consumedBytes << std::endl;
    for(int i=0; i<3; i++) {
        std::cout << (int) r[i];
    }
    std::cout << std::endl;
    size_t consumedBytes2 = b.consume(r, 3);
    std::cout << "consumed " << consumedBytes2 << std::endl;
    for(int i=0; i<3; i++) {
        std::cout << (int) r[i];
    }
    std::cout << std::endl;
    size_t consumedBytes3 = b.consume(r, 3);
    std::cout << "consumed " << consumedBytes3 << std::endl;
    return 0;
}

#包括
#包括
使用名称空间std；
模板
类缓冲区
{
公众：
无效写入（T*缓冲区，大小\u T数量写入）{
if（amountToWrite\u buffer.capacity（））{
std:：copy（buffer，buffer+amountToWrite，this->_buffer.data（））；
_大小+=写入的数量；
}否则{
//事实上，我想增加容量，而不是大小。但是我们不使用向量函数，所以这很重要吗？
此->\u buffer.resize（amountToWrite）；
std:：copy（buffer，buffer+amountToWrite，this->_buffer.data（））；
_大小+=写入的数量；
}
}
大小消耗（t*bufferToWrite，大小\t amountToConsume）{
如果（\u当前==\u大小）{
//这意味着我们已经阅读了所有内容。也许我们应该抛出或返回0？
返回0；
}
if（消费数量(单位大小)）{
std:：copy（this->\u buffer.data（）+\u current，this->\u buffer.data（）+\u current+amountToConsume，bufferToWrite）；
_电流+=消耗量；
返回消费金额；
}否则{
剩余大小=此->\u大小-消费金额；
std:：copy（此->\u buffer.data（）+\u current，此->\u buffer.data（）+\u current+剩余，bufferToWrite）；
_当前+=剩余；
返回剩余值；
}
}
私人：
大小\u t\u大小=0；
std:：vector\u缓冲区；
大小_t_电流=0；
};
int main（）
{
缓冲器b；
uint8_t u[]={1,2,3,4,5,6}；
b、 写入（u，6）；
uint8_t r[3]；
size_t consumedBytes=b.消耗（r，3）；
std：：cout我认为您可以利用使用STL中的dequeue。
它实现了一个双链接列表，您可以从它的一侧读取，从另一侧写入

另外，缓冲区的另一个最佳实现是实现

为循环缓冲区留下C++实现代码。< /P>
class MyCircularQueue {
vector<int> mem;
int front;
int rear;
int len;
int cnt;

public:
MyCircularQueue(int k) {
   len = k;
   mem = vector<int> (k); 
   front = 0;
   rear = -1;
   cnt=0; 
}

bool enQueue(int value) {
    if(isFull())
        return false;

    rear = (rear+1) %len;
    mem[rear]= value;
    cnt++;
    return true;
}

bool deQueue() {
    if (isEmpty()) 
        return  false;
    front = (front+1) % len;
    cnt--;
    return true;
}

int Front() {
    if (isEmpty()) 
        return -1;
    return mem[front];
}

int Rear() {
    if (isEmpty()) 
       return -1;
    return mem[rear];
}

bool isEmpty() {
   return (cnt ==0); 
}

bool isFull() {
    return ( cnt == len);
}

类MyCircularQueue{
载体膜；
内锋；
内部后部；
内伦；
int-cnt；
公众：
MyCircularQueue（整数k）{
len=k；
mem=向量（k）；
正面=0；
后部=-1；
cnt=0；
}
布尔排队（int值）{
如果（isFull（））
返回false；
后=（后+1）%len；
mem[后]=值；
cnt++；
返回true；
}
bool-deQueue（）{
if（isEmpty（））
返回false；
前=（前+1）%len；
碳纳米管；
返回true；
}
int Front（）{
if（isEmpty（））
返回-1；
返回内存[前端]；
}
int后（）{
if（isEmpty（））
返回-1；
返回内存[后]；
}
布尔是空的{
返回（cnt==0）；
}
bool isFull（）{
返回值（cnt==len）；
}

}
而
后推
会导致重新分配（除非容量足够）
后推
不会改变容量，基本上与正常的“阵列”一样快访问。这没有任何用途。将普通的
std:：vector
与
reserve
和
insert
一起使用，即使速度不快，也至少会一样快。另外，复制向量的结束部分，然后向下调整大小，即使速度不快，也至少会一样快。我认为测试
amountToWrite(u buffer.capacity)
是可疑的。我相信编写超过
size（）
元素会使您处于未定义的行为区域。“您看到我的实现中有什么错误吗？”--堆栈溢出不是开放式代码检查的地方。@超级为什么保留？插入
是否重新分配？