Question

我不得不承认我现在有点困惑，如果这个问题不是很清楚或微不足道，那我很抱歉（实际上我希望它是后者）....

我在网络上发送一个字节数组，想在发送方那边做这样的事情：

size_t max_size = 100;
uint8_t buffer[size];
idontknowwhat_t x{buffer};    
uint16_t size = 11;                 // total number of bytes in the buffer
uint16_t id_a,id_b,id_c;            // some ids
uint8_t  a,b,c;                     // some data
x << size << id_a << a << id_b << b << id_c << c;
someMethodToSend(buffer,size);

在接收方这样的事情：

size_t max_size = 100;
uint8_t buffer[size];
someMethodToReceive(buffer);
idontknowwhat_t x{buffer};
uint16_t size;
x >> size;
for (uint16_t i=0; i<size-2; i++) {
    uint16_t id;
    uint8_t data;
    x >> id >> data;
    std::cout << id << " " << data;
}

所以我的目标基本上是避免丑陋的强制转换并手动递增指针，同时在缓冲区中能够拥有uint8_t和uint16_t（可能还有uint32_t）。我在这里放入缓冲区的数据只是一个例子，我知道我需要在通过网络发送时处理字节顺序（如果我必须这样做，那就没关系了＃34;手动＆＃ 34）。

我可以使用某些东西代替我的假设idontknowwhat_t吗？

Answer 1

你无法真正避免做丑陋的演员表，但至少你可以将它们隐藏在idontknowwhat_t班的operator>>和operator<<函数中。使用模板，您可以将代码中的强制转换数量限制在最低限度。

class idontknowwhat_t
{
    uint8_t* _data;

public:
    idontknowwhat_t(uint8_t* buffer)
        : _data(buffer)
    {}

    template<typename insert_type>
    idontknowwhat_t& operator<<(insert_type value)
    {
        *reinterpret_cast<insert_type*>(_data) = value;
        _data += sizeof(insert_type);
        return *this;
    }
    template<typename extract_type>
    idontknowwhat_t& operator>>(extract_type& value)
    {
        value = *reinterpret_cast<extract_type*>(_data);
        _data += sizeof(extract_type);
        return *this;
    }
};

我认为这实际上会直接与您的代码一起使用。在此示例中，idontknowwhat_t类不拥有缓冲区，只是将原始指针保存到它希望读取或写入的下一位数据。出于实际目的，我建议让idontknowwhat_t类管理缓冲存储器。

此外，本页面上的代码都没有真正处理数据的字节序，这肯定是idontknowwhat_t类的责任。有一个boost library。我没有在这里记录该库的使用，因为我认为它会分散问题的真实意义。

Answer 2

你试过std::list吗？您可以将元素分组为类型，并将它们放入具有适当类型的列表中。然后你可以创建一个std :: list的std :: list。

将数据流式传输到字节数组中

2 个答案: