sérialiser un type de données comme vector<u_int8_t> - utiliser reinterpret_cast?

Je n'ai pas trouver quoi que ce soit directement liés à la recherche, de sorte s'il vous plaît pardonnez si c'est un doublon.

Ce que je cherche à faire est de sérialiser des données via une connexion réseau. Mon approche est de convertir tout ce que j'ai besoin de transférer à un std::vector< uint8_t > et sur le côté de réception de décompresser les données dans les variables appropriées. Ma démarche ressemble à ceci:

template <typename T>
inline void pack (std::vector< uint8_t >& dst, T& data) {
    uint8_t * src = static_cast < uint8_t* >(static_cast < void * >(&data));
    dst.insert (dst.end (), src, src + sizeof (T));
}   

template <typename T>
inline void unpack (vector <uint8_t >& src, int index, T& data) {
    copy (&src[index], &src[index + sizeof (T)], &data);
}

Qui je suis en utilisant comme

vector< uint8_t > buffer;
uint32_t foo = 103, bar = 443;
pack (buff, foo);
pack (buff, bar);

//And on the receive side
uint32_t a = 0, b = 0;
size_t offset = 0;
unpack (buffer, offset, a);
offset += sizeof (a);
unpack (buffer, offset, b);

Ma préoccupation est la

uint8_t * src = static_cast < uint8_t* >(static_cast < void * >(&data));

ligne (ce que je comprends à faire la même chose que reinterpret_cast). Est-il un meilleur moyen pour y parvenir sans le double cast?

Mon approche naïve était simplement utiliser static_cast< uint8_t* >(&data) qui a échoué. J'ai été dit dans le passé que reinterpret_cast est mauvais. Donc je voudrais l'éviter (ou de la construction, j'ai actuellement), si possible.

Bien sûr, il y a toujours uint8_t * src = (uint8_t *)(&data).

Suggestions?

InformationsquelleAutor ezpz | 2010-07-01