Início / coding / Perguntas / 78547417
Accepted
Harry
Asked: 2024-05-29 13:13:28 +0800 CST

reinterpretar bytes do buffer de acordo com o endianess do sistema (nativo)

  • 772

Estou recebendo dados de outro host via soquete de rede no formato big endian. Como interpretar os bytes recebidos no formato endian nativo (como obter uma visualização ou reinterpretar esses bytes) sem copiar para uma variável temporária.

#include <iostream>
#include <cstdint>

struct A {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct A
    }
};

struct B {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct B
    }
};

struct C {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct C
    }
};

int main() {
    char buff[8192];
    while (true) {
        // data is received in network byte order (big endian) but my system is little endian
        const auto recvd_len = recvfrom(sock_fd, buff, sizeof(buff), 0, nullptr, nullptr);
        const uint16_t msg_id = (buff[0] << 8) | (buff[1] & 0xFF);

        switch (msg_id) {
            case 0x0001: {
                // reinterpret the bytes received as struct A, copy elision
                const A* a_obj = reinterpret_cast<const A*>(buff);
                a_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            case 0x0002: {
                // reinterpret the bytes received as struct B, copy elision
                const B* b_obj = reinterpret_cast<const B*>(buff);
                b_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            case 0x0003: {
                // reinterpret the bytes received as struct C, copy elision
                const C* c_obj = reinterpret_cast<const C*>(buff);
                c_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            default:
            break;
        }
    }
}
c++

1 respostas

  1. Best Answer
    char buff[8192];
// ...
// reinterpret the bytes received as struct A, copy elision
const A* a_obj = reinterpret_cast<const A*>(buff);
a_obj->print();

    Em C++, esse é sempre um comportamento indefinido. É uma violação estrita de alias porque buff(após a conversão de array em ponteiro) é um ponteiro para um charobjeto, mas você está acessando seu printmembro por meio do type A. Isso não é permitido; veja [expr.ref] p9 .

    bufftambém está possivelmente subalinhado e você precisa usá-lo alignas(A)para garantir o alinhamento adequado do Aobjeto potencialmente interno.

    C++23 adicionou uma função perfeita para este caso de uso std::start_lifetime_as:

    alingas(A) char buff[8192];
// ...
const A* a_obj = std::start_lifetime_as<A>(buff);
a_obj->print();

    Para que isso funcione, Aé necessário que haja um tipo de classe de vida implícita , o que parece possível no seu caso. Infelizmente, nenhum compilador implementa std::start_lifetime_asno momento da escrita, então você precisará de uma solução alternativa que seja tecnicamente UB, mas não obviamente:

    alingas(A) char buff[8192];
// ...
const A* a_obj = std::launder(reinterpret_cast<A*>(buff));
a_obj->print();

    Com std::launder, você transforma um ponteiro para um charobjeto em um ponteiro para um Aobjeto no mesmo endereço. Este ainda é um comportamento indefinido se não houver realmente um Aobjeto lá, mas você pode assumir que isso recvfromcoloca um Alá. Pelo menos, o compilador não pode provar que recvfromnão colocou um Aali, então ele fará o que você quiser.

    Nota sobre conversão Endianness

    Tenha em mente que todas essas abordagens assumem que o objeto fornecido já está na ordem de bytes nativa, e não na ordem de bytes da rede. Nenhuma conversão Endianness está sendo realizada aqui.

    Para obter valores significativos para os membros dos seus dados, você precisaria corrigir a ordem dos bytes após a reinterpretação (não importa qual abordagem), por exemplo, usando std::byteswappara cada membro.

    • 4

relate perguntas