Modo corretto per inviare strutture dati personalizzate tramite socket

Mi chiedo quale sia il modo corretto per inviare strutture come array di caratteri tramite socket.

In questo momento ho qualcosa come sotto ma non è una buona soluzione perché causa un comportamento indefinito. È possibile inviare tipi come string o altri tipi definiti dall'utente?

O forse le strutture che funzionano come frame di protocollo dovrebbero avere solo tipi bult-in come int, char o char array con dimensione fissa?

Forse conosci qualche best practice su questo? Forse conosci qualche libreria di lavoro per farlo?

Non ho trovato alcun esempio funzionante che sarebbe diverso dal mio.

class FrameProtocol
{
public:
    std::array<char, 4096> buffer;
};

class FrameHeader
{
public:
    typedef enum { hello, priv} types;
    types type;
    const size_t size = sizeof(FrameHeader);
};

class PrivateMessage
{
public:
    int sender;
    int receiver;
    std::string value;
    const size_t size = sizeof(PrivateMessage);
};

class HelloMessage
{
public:
    std::string nickname;
    size_t size = sizeof(HelloMessage);
};


void sendTo(FrameProtocol& protocol)
{
    FrameHeader frame_header;
    memcpy(&frame_header, protocol.buffer.begin(), frame_header.size);

    std::cout << "Type: " << frame_header.type << std::endl;

    switch (frame_header.type)
    {
        case frame_header.priv:
        {
            std::cout << "###############################################" << std::endl;
            std::cout << "PRIV RECEIVED!" << std::endl;
            PrivateMessage priv;
            memcpy(&priv, protocol.buffer.begin() + frame_header.size, priv.size);
            std::cout << "PrivateMessage!, From: " << priv.sender << " To: " << priv.receiver << " val: " << priv.value << std::endl;
            std::cout << "################################################\n" << std::endl;
            break;
        }
        case frame_header.hello:
        {
            std::cout << "###############################################" << std::endl;
            std::cout << "HELLO RECEIVED!" << std::endl;
            HelloMessage hello {};
            memcpy(&hello, protocol.buffer.begin() + frame_header.size, sizeof(HelloMessage));
            std::cout << "HelloMessage!, Nickname: " << hello.nickname << std::endl;
            std::cout << "################################################\n" << std::endl;
        break;

            break;
        }

    }
}

int main()
{
    FrameProtocol frame;
    FrameHeader frame_header;
    frame_header.type = frame_header.priv;

    PrivateMessage pm;
    pm.sender = 10;
    pm.receiver = 20;
    pm.value = "Test";

    memcpy(frame.buffer.begin(), &frame_header, frame_header.size); // write header
    memcpy(frame.buffer.begin() + frame_header.size, &pm, pm.size); // write body

    FrameProtocol frame2;
    FrameHeader frame_header2;
    frame_header2.type = frame_header2.hello;

    HelloMessage hello;
    hello.nickname = "testas";
    hello.size = sizeof(hello);
    memcpy(frame2.buffer.begin(), &frame_header2, frame_header2.size); //write header
    memcpy(frame2.buffer.begin() + frame_header2.size, &hello, hello.size); // write body

    sendTo(frame2);
    sendTo(frame);