How to efficiently handle std :: vector as a C buffer?

Question

With buffer C, I often do this:

BYTE buffer[MAX_SIZE];
int dataSize = 0;

while (appRunning()) 
{
    dataSize += Receive(buffer + dataSize, MAX_SIZE - dataSize);

    int processedSize = ProcessBuffer(buffer, dataSize);
    ASSERT(processedSize <= dataSize);
    dataSize -= processedSize;
    memmove(buffer, buffer + processedSize, dataSize);
};

Is it possible to do this with std::vectorno loss in performance?

EDIT: I found a way to replace the raw C buffer with std::vector.

std::vector<BYTE> vbuf;
vbuf.reserve(MAX_SIZE); // allocated at once

while (appRunning()) 
{
    int pendingSize = GetPendingDataSize(); // from a socket
    if (pendingSize > vbuf.capacity())
        pendingSize = vbuf.capacity();

    vbuf.resize(pendingSize);
    int recvSize = Receive(vbuf.data(), vbuf.size());
    ASSERT(recvSize < vbuf.size());
    int processedSize = ProcessBuffer(vbuf.data(), vbuf.size());
    std::rotate(vbuf.begin(), vbuf.begin() + processedSize, vbuf.end());
    vbuf.resize(vbuf.size() - processedSize);
};

In fact, in my practical use, data acquisition and data processing can be performed in multi-threaded mode. Thus, using vector, I don’t need to control the buffer allocation, data size and buffer capacity manually. Compared to buffer C, here vbuf.resize()performance occurs at vbuf.resize(). But I think the penalty is negligible. Any better way is appreciated.

Answer 1

TCP- . memmove .

"" , , memmove , . "" , mmap . , , , .

---

std::vector , , recv. .

Answer 2

++ 11, C std:: array:

std::array<BYTE, MAX_SIZE> buffer;

C. , . .

, C, , . . , .

Answer 3

, C ( , ), Boost static_vector. , .

boost::static_vector<BYTE, MAX_SIZE> buffer;

std :: queue boost :: cirular_buffer , .

Answer 4

std::vector std::array. , .

std::vector<BYTE> buffer(MAX_SIZE);
BYTE * start = buffer.data();
int dataSize = 0;

while (appRunning()) 
{
    dataSize += Receive(start, MAX_SIZE - dataSize);

    int processedSize = ProcessBuffer(buffer.data(), dataSize);
    ASSERT(processedSize <= dataSize);
    dataSize -= processedSize;
    start = std::copy_n(buffer.data() + processedSize, dataSize, buffer.data());
};

Answer 5

, , , :

std::vector<BYTE> buffer;
buffer.reserve(MAX_SIZE);
int dataSize = 0;

while (appRunning()) 
{
    dataSize += Receive(&buffer[0] + dataSize, MAX_SIZE - dataSize);

    int processedSize = ProcessBuffer(&buffer[0], dataSize);
    ASSERT(processedSize <= dataSize);
    dataSize -= processedSize;
    memmove(&buffer[0], &buffer[0] + processedSize, dataSize);
};