解析来自固定大小字节缓冲区的连续块的protobuf消息序列

我发现您的代码有两个主要问题：

std::merge(mResidueBuffer.begin(), mResidueBuffer.end(),  
mReadBuffer.begin(), mReadBuffer.end(), std::back_inserter(mCheckBuffer));

看起来您希望std::merge连接您的缓冲区，但事实上，该函数执行MergeSort意义上的两个排序数组合并为一个排序数组。在这种情况下，这没有任何意义；mCheckBuffer最终将包含无意义内容。

cis.GetDirectBufferPointer((const void**)&bResidueBuffer,
&bResidueBufSize);

在这里，您将&bResidueBuffer强制转换为不兼容的指针类型。bResidueBuffer是一个char数组，因此&bResidueBuffer是指向char数组的指针，而不是指向指针的指针。诚然，这是令人困惑的，因为数组可以隐式转换为指针（指针指向数组的第一个元素），但这实际上是一种转换——bResidueBuffer本身是而不是指针，它只能转换为一个。

我想你也误解了GetDirectBufferPointer()的作用。看起来您希望它将缓冲区的其余部分复制到bResidueBuffer中，但该方法从不复制任何数据。该方法返回一个指向原始缓冲区的指针。

正确的称呼方式是：

const void* ptr;
int size;
cis.GetDirectBufferPointer(&ptr, &size);

现在ptr将指向原始缓冲区。现在，您可以将其与指向缓冲区开头的指针进行比较，以找出您在流中的位置，例如：

size_t pos = (const char*)ptr - &mCheckBuffer[0];

但是，您不应该这样做，因为CodedInputStream已经有了用于此目的的方法CurrentPosition()。这将返回缓冲区中的当前字节偏移量。所以，用它来代替。

好的，感谢Kenton在我的问题中指出主要问题的帮助，我现在已经修改了代码并测试了它的工作情况。我会在这里发布我的解决方案。然而，话虽如此，我对我在这里需要做的所有复杂性和边缘案例检查感到不高兴。我认为它很容易出错。即便如此，我可能真正要做的是在libuv主线程之外的另一个线程中编写我的直接"从流读取"阻塞调用，这样我就不需要使用libuv API了。但为了完整起见，下面是我的代码：

std::vector<char> mCheckBuffer;
std::vector<char> mResidueBuffer;
std::vector<char> mReadBuffer(READ_BUFFER_SIZE);
google::protobuf::uint32 size;
//"in" is the file input stream
while (in.good()) {
    //This part is tricky as you're not guaranteed that what end up in 
    //mReadBuffer is everything you read out from the file. The same 
    //happens with libuv's assigned buffer, after EOF, what's rest in 
    //the buffer could be anything
    in.read(mReadBuffer.data(), READ_BUFFER_SIZE);
    //merge the last remaining chunk that contains incomplete message with
    //the new data chunk I got out from buffer. I couldn't find a more 
    //efficient way doing that
    mCheckBuffer.clear();
    mCheckBuffer.reserve(mResidueBuffer.size() + mReadBuffer.size());
    mCheckBuffer.insert(mCheckBuffer.end(), mResidueBuffer.begin(),
    mResidueBuffer.end());
    mCheckBuffer.insert(mCheckBuffer.end(), mReadBuffer.begin(),
    mReadBuffer.end());
    //Treat the new merged buffer array as the new CIS
    google::protobuf::io::ArrayInputStream ais(&mCheckBuffer[0], 
    mCheckBuffer.size());
    google::protobuf::io::CodedInputStream cis(&ais);
    //No size information, probably first time or last iteration  
    //coincidentally read a complete message out. Otherwise I simply 
    //skip reading size again as I've already populated that from last 
    //iteration when I got an incomplete message
    if(size == 0) {
        cis.ReadVarint32(&size);
    }
    bResidueBufSize = mCheckBuffer.size() - cis.CurrentPosition();
    //Compare the next message size with how much left in the buffer, if      
    //message size is smaller, I know I can read at least one more message 
    //out, keep reading until I run out of buffer. If, it's the end of message 
    //and size (next byte I read from stream) happens to be 0, that
    //will trip me up, cos when I push size 0 into PushLimit and then try 
    //parsing, it will actually return true even if it reads nothing. 
    //So I can get into an infinite loop, if I don't do the check here
    while (size <= bResidueBufSize && size != 0) {
        //If this cis I constructed didn't have the size info at the 
        //beginning, and I just read straight from it hoping to get the  
        //message out from the "size" I got from last iteration
        //push the size constraint to the input stream
        int limit = cis.PushLimit(size); 
        //parse the message from the input stream
        bool result = message.ParseFromCodedStream(&cis);  
        //Parse fail, it could be because last iteration already took care
        //of the last message and that size I read last time is just junk
        //I choose to only check EOF here when result is not true, (which
        //leads me to having to check for size=0 case above), cos it will
        //be too many checks if I check it everytime I finish reading a 
        //message out
        if(!result) {
            if(in.eof()) {
                log.info("Reached EOF, stop processing!");
                break;
            }
            else {
                log.error("Read error or input mal-formatted! Log error!");
                exit;
            }
        }
        cis.PopLimit(limit);
        google::protobuf::TextFormat::PrintToString(message, &str);
        //Do something with the message
        //This is when the last message read out exactly reach the end of 
        //the buffer and there is no size information available on the 
        //stream any more, in which case size will need to be reset to zero
        //so that the beginning of next iteration will read size info first
        if(!cis.ReadVarint32(&size)) {
            size = 0;
        }
        bResidueBufSize = mCheckBuffer.size() - cis.CurrentPosition();
    }
    if(in.eof()) {
        break;
    }
    //Now I am copying the residual buffer into the intermediate
    //mResidueBuffer, which will be merged with newly read data in next iteration
    mResidueBuffer.clear();
    mResidueBuffer.reserve(bResidueBufSize);
    mResidueBuffer.insert(mResidueBuffer.end(), 
    &mCheckBuffer[cis.CurrentPosition()],&mCheckBuffer[mCheckBuffer.size()]);
}
if(!in.eof()) {
    log.error("Something else other than EOF happened to the file, log error!");
    exit;
}