C++ 使用回调使用std:：vector<；中的数据；uint8_t>；

根据前面的回答，我编写了一个更好的缓冲区，可以快速使用：

#include <iostream>
#include <vector>
#include <functional>
#include <stdio.h>
#include <string.h>
using namespace std;

template <class T>
class Buffer
{
public:

    Buffer(size_t reserve) {
        _buffer.reserve(reserve);
    }

    void write(T* buffer, size_t amountToWrite) {
        this->_buffer.insert(this->_buffer.begin(), buffer, buffer + amountToWrite);
    }

    size_t consume(const size_t amountToConsume, std::function<void(T*, T*)> onConsume) {
        if (_current==this->_buffer.size()) {
        //this means we've already read everything. Maybe we should throw or just return 0?
        return 0; 
        }

        size_t currentActualSize = this->_buffer.size() - this->_current;
        if (amountToConsume <= currentActualSize) {
            onConsume(this->_buffer.data() + this->_current, this->_buffer.data() + this->_current + amountToConsume);
            this->_current += amountToConsume;
            return amountToConsume;
        } else {
            size_t remaining = currentActualSize;
            onConsume(this->_buffer.data() + this->_current, this->_buffer.data() + this->_current + remaining);
            this->_current += remaining;
            return remaining;
        }
    }

private:
    std::vector<T> _buffer;
    size_t _current = 0;
};

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

    uint8_t r[3] = {255, 255, 255};
    
    size_t consumedBytes2 = b.consume(3, [r](const uint8_t* begin, const uint8_t* end){
        std::cout << "begin: " << begin << ", end: " << end << std::endl;
        std::copy(begin, end, (uint8_t*)r);
    });
    
    std::cout << "consumed " << consumedBytes2 << std::endl;
    for(int i=0; i<consumedBytes2; i++) {
        std::cout << (int) r[i] << " - ";
    }
    
    std::cout << std::endl;

    return 0;
}

没有任何内容写入我的缓冲区

---

发生了什么？

您正在按值捕获阵列

通过引用捕获将获得预期的结果

size_t consumedBytes2 = b.consume(3, [&r](const uint8_t* begin, const uint8_t* end){
    std::cout << "begin: " << begin << ", end: " << end << std::endl;
    std::copy(begin, end, (uint8_t*)r);
});

size\u t consumerdbytes2=b.consumer（3，[&r]（const-uint8\u-t*begin，const-uint8\u-t*end）{
std：：cout您正在按值捕获数组

通过引用捕获将获得预期的结果

size_t consumedBytes2 = b.consume(3, [&r](const uint8_t* begin, const uint8_t* end){
    std::cout << "begin: " << begin << ", end: " << end << std::endl;
    std::copy(begin, end, (uint8_t*)r);
});

size\u t consumerdbytes2=b.consumer（3，[&r]（const-uint8\u-t*begin，const-uint8\u-t*end）{
std:：cout如果不是指针集，数组的类型是什么？在这种情况下，它的类型是
uint8\u t[7]
。@Gatonito数组是数组，指针是指针。数组不是指针，指针不是数组。您可以捕获指针：
[uint8\u t*p=r]
如果不是指针集，数组的类型是什么？它的类型是
uint8\t[7] 
在这种情况下。@Gatonito数组是数组，指针是指针。数组不是指针，指针也不是数组。您可以捕获指针：
[uint8\u t*p=r]