C++ 缓冲区及；处理传入数据，按换行符拆分

我刚刚在一些代码中发现了一个解析错误：

while(some_condition){
    char buf[1536] = {};
    len = BIO_read(web, buf, sizeof(buf));
    if(len > 0){
        process(new std::string(buf));
    }
}

传入的数据是json，问题是我希望传入的数据按如下所述进行反传递：

{json packet 1}\n
{json packet 2}\n{json packet 3}\n
{json packet 4}\n

通常情况下是这样的。但我只是注意到，有时我也可以通过以下形式获取数据：

{json pack
et 1}\n
{json packet 2}
\n{json packet 3}\n
{json packet 4}\n

编辑：换行符从不在两个不同的行上（在我的示例中，拆分了“\”和“n”，这是错误的）

这当然会使process函数中的json解析器在获取不完整的json数据时失败

因此，我需要以某种方式缓冲传入的数据，解析换行符，如果找到，则将“完整的json包”发送到process函数，并从缓冲区中删除处理过的数据

关于如何快速高效地完成此任务的建议

编辑： 没有回复描述任何具体的解决方案，所以我猜我没有很好地解释这个问题（你通常会想出聪明的“简单”的解决方案来解决我觉得复杂的问题）

我下面的版本看起来像我想要的那样工作，所以我的后续问题是，您是否看到任何可能的速度改进，或者是否有其他方法的想法，我可以对此进行基准测试和比较。在这种情况下没有“足够快”，越快越好

…或者如果你发现了任何可能的错误

#include <stdio.h>
#include <string>
#include <iostream>

//this is just for simulating incoming data
int dataSimulator(char* buf){
    static unsigned char call_no = 0;
    call_no++;
    switch (call_no){
    case 1:
        memcpy(buf, "111\n", 4);
        return 4;
        break;
    case 2:
        memcpy(buf, "222\n33", 6);
        return 6;
        break;
    case 3:
        memcpy(buf, "3\n444\n", 6);
        return 6;
        break;
    case 4:
    case 5:
    case 6:
        memcpy(buf, "5", 1);
        return 1;
        break;
    case 7:
        memcpy(buf, "\n", 1);
        return 1;
        break;
    case 8:
        memcpy(buf, "666\n777\n888\n", 12);
        return 12;
        break;

    }

    return 0;
}

int main(int argc, char* argv[])
{
    char buff[100] = {};
    int buff_offset = 0;
    int end;
    int start;

    while (1){

        buff_offset = strlen(buff);
        int len = dataSimulator(&buff[buff_offset]);

        if (len > 0)    {

            buff[buff_offset + len] = 0;

            end = 0;
            start = 0;

            while (buff[end]){
                if (buff[end] == '\n'){
                    //end of packet found
                    std::string packet(&buff[start], end - start);
                    std::cout << "packet: " << packet << " received" <<std::endl;
                    //mark old start as processed
                    buff[start] = 0;
                    start = end + 1;
                }
                end++;
            }
            if (start != end){
                //data left in buffer, move remaining stuff to the beginning
                memmove(buff, &buff[start], end - start);
                //make sure it's null terminated
                buff[end - start] = 0;
            }
        }
        else{
            break;
        }
    }
}

---

这个C++代码是在OpenSSL之上构建的吗？“关于如何快速高效地进行这一建议？”——难道你不是在寻找一个有效的解决方案吗？你甚至不知道这是否足够快，因为你甚至没有任何代码来衡量性能。

'\n'

是一个字符，你确定你得到的是这样的输出吗？安德鲁：是的，它是可检查的：我指的是一种比我脑海中突然出现的混乱想法更快、更有效的方法。我想有一些优雅的方法可以做到这一点，既快速又高效。。而且有效。

packet: 111 received
packet: 222 received
packet: 333 received
packet: 444 received
packet: 555 received
packet: 666 received
packet: 777 received
packet: 888 received