用元素加载 std::queue<uint8_t*> 的更有效方法？

Posted 2023-02-22

【中文标题】用元素加载 std::queue<uint8_t*> 的更有效方法？

【英文标题】：More effective way to load a std::queue<uint8_t*> with elements?

【发布时间】：2019-07-05 20:12:44

【问题描述】：

我正在尝试找到一种更有效的方法将 uint8_t 字节的可变长度数组加载到 std::queue 中

以下代码 sn-p 试图将实际代码简化为更有用的示例；如果过于复杂，请见谅。

代码 sn-p 工作，除了我无法确定 std::queue 的每个元素的实际长度，而它们仍在队列的前面。我的问题是，“有没有办法将指向无符号字节数组的指针推送到队列中，而无需创建本地数组、将传递的参数复制到其中然后推送本地指针的中间步骤（参见代码中的 cmets）？

#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;

【问题讨论】：

我认为std::queue <std::vector <uint8_t>> 会更明智。

简短回答：不，没有，如果您无法控制数组存在的范围。此外，您应该有一个 std::queue 或 std::vectors ，并让 std::vector 为您处理所有分配。现代 C++ 代码很少需要显式地 new 或 delete 任何东西，而只需使用适当的容器。而且，作为额外的奖励，您不再需要担心内存泄漏。

令人惊讶的是，您使用的是std::queue，却完全错过了使用std::vector。 std::vector 几乎总是 C++ 程序员学习并鼓励使用的第一个容器。

没有创建本地数组的中间步骤， -- 您的代码调用new。这本身可能是一个瓶颈。复制连续的内存比每次调用分配器要快得多。

实际代码有多个线程访问队列。对于我需要在问题示例中放入的示例来说太复杂了。在这种情况下，std::queue 操作，正如我们在过去的 OpenVMS 时代所说的那样，是不可中断的（至少按照我们的理解）。实际代码每秒接收数千个数据克并将它们加载到队列中。处理器元素可以花时间访问队列的前面，而无需等待诸如互斥锁等同步元素。这就是 std::queue 的原因。

【参考方案1】：

代码 sn-p 有效，但我无法 确定 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

【参考方案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));

问题解决了。