Более эффективный способ загрузки std :: queueс элементами?

Question

Я пытаюсь найти более эффективный способ загрузки массивов переменной длины байтов uint8_t в std :: queue

Следующий фрагмент кода - это попытка свести реальный код к чему-то более полезному в качестве примера; поэтому, пожалуйста, прости меня, если это слишком сложно.

Фрагмент кода работает, за исключением моей неспособности определить фактическую длину каждого из элементов std :: queue, пока они все еще находятся в начале очереди. У меня вопрос: есть ли способ поместить указатель на массив без знака в очередь без промежуточного шага создания локального массива, копирования в него переданного аргумента и последующего нажатия локального указателя (см. Комментарии в коде)?

#include <queue>
#include <string>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

using namespace std;

std::queue<uint8_t*> _q;

void routineSubroutine(uint8_t array_a[], int size_a)
{
    /*
     * Is there anyway to push the uint8 array_a into the queue (_q) without
     * creating a new pointer to a byte array, copying the passed
     * argument into it and the pushing it?
     */

    uint8_t* a = new uint8_t[size_a];
    memcpy((void*) a, (const void*) array_a, size_a);
    _q.push(a);
}

int main(int argc, char** argv)
{
    uint8_t myArray[512];

    char cfa[] = {"I wish I was at Chick-Fil-A right now"};
    memset((void*) myArray, 0x00, sizeof (myArray));
    memcpy((void*) myArray, (const void*) cfa, strlen(cfa));
    routineSubroutine(myArray, strlen(cfa));

    char five[] = {"Five Guys will do in a pinch"};
    memcpy((void*) myArray, (const void*) five, strlen(five));
    routineSubroutine(myArray, strlen(five));

    while (_q.size() > 0)
    {
        printf("Queue string value = %s\n", (char*) _q.front());
        /*
         * How do I go about determining the number of bytes in the uint8_t
         * array, whose address is at the front of the queue?
         */
        _q.pop();
    }

    return 0;
}

Answer 1

Фрагмент кода работает, за исключением моей неспособности определить фактическую длину каждого из элементов std :: queue пока они все еще находятся в начале очереди

Используйте соответствующий контейнер, который знает его длину / размер, и вызовите соответствующую функцию-член. Простой указатель этого не делает.

Вот пример вашего кода, переписанного для использования std::vector:

#include <queue>
#include <string>
#include <vector>
#include <iostream>

std::queue<std::vector<uint8_t>> _q;

void routineSubroutine(const std::vector<uint8_t>& a)
{
    _q.push(a);
}

int main(int argc, char** argv)
{
    char cfa[] = {"I wish I was at Chick-Fil-A right now"};
    routineSubroutine({std::begin(cfa), std::end(cfa)}); // creates a temp uint8_t vector

    char five[] = {"Five Guys will do in a pinch"};
    routineSubroutine({std::begin(five), std::end(five)}); // creates a temp uint8_t vector

    while ( !_q.empty() )
    {
        // use the `write()` function to control the number of characters
        std::cout.write(reinterpret_cast<const char *>(_q.front().data()), _q.front().size());
        std::cout << "\n";
        _q.pop();
    }
    return 0;
}

Выход:

I wish I was at Chick-Fil-A right now
Five Guys will do in a pinch

Answer 2

В конечном счете, я имею полный контроль над типом очереди, которую я могу использовать, в то время как у меня нет полного контроля над тем, как представлены данные. В частности, данные представлены в виде длины uint8_t * и size_t. Благодаря примеру кода @ PaulMcKenie я смог найти следующее решение (которое, кстати, очень быстро):

std::queue<std::vector<uint8_t>> myQueue;
while(true)
{
    // Pointer (myBuffer) and length (myLength) magically appear here
    myQueue.push({myBuffer, (uint8_t*) (myBuffer + myLength)});
}

Проблема решена.