emballage, déballage des fonctions en C++

NOTE: je sais que cela a été demandé de nombreuses fois avant, mais aucun de ces questions ont un lien vers un de béton, de portable, de maintenir bibliothèque pour cela.

J'ai besoin d'un C ou C++ de la bibliothèque qui implémente Python/Ruby/Perl comme pack/unpack fonctions. Cette bibliothèque existe pas?

EDIT: Parce que les données que je vous fais parvenir est simple, j'ai décidé de l'utiliser juste memcpy, les pointeurs et les hton* fonctions. Ai-je besoin de manipuler un char en aucune façon à l'envoyer sur le réseau en une plate-forme agnostique? (le char est seulement utilisé comme un octet, non pas comme un caractère).

Pourriez-vous expliquer ce pack/unpack dans ces langues?
Emballer et déballer sont utilisés pour transformer des variables dans une chaîne binaire et vice-versa, respectivement. Ils sont très utiles pour la création de paquets et les fichiers binaires et d'autres interactions binaires. Les langues que j'ai mentionnés ont cette fonction dans leur bibliothèque standard. C/C++ ne le font pas.
Oh hmm... pour info, ce pourrait même ne pas être possible. Elle aurait besoin de beaucoup de métaprogrammation (ou IDE) pour obtenir toutes les informations de terrain et comme... la seule langue maternelle, je sais qui pourrait sans doute faire c'est D.
Je veux dire quelque chose le long des lignes de sprintf, juste les prescripteurs serait pour des données binaires. Juste le même genre de géant switch déclaration.

OriginalL'auteur Linuxios | 2012-03-02

c++pack serialization unpack

5

Pourquoi ne pas stimuler la sérialisation ou protocol buffers?

Parce que ces assumer certains formats.

OriginalL'auteur Jon
5

En C/C++ généralement, il suffit d'écrire une struct avec les différents membres dans l'ordre correct (emballage correct peut exiger compilateur spécifique pragmas) et de vidage/lire/à partir d'un fichier avec un raw fwrite/fread (ou read/write lorsque vous traitez avec C++ cours d'eau). En fait, pack et unpack sont nés pour lire des trucs générés avec cette méthode.

Si vous devez plutôt le résultat dans un tampon au lieu d'un fichier, il est encore plus facile, il suffit de copier la structure de votre tampon avec un memcpy.

Si la représentation doit être portable, vos principales préoccupations est l'octet de commande et de champs d'emballage; le premier problème peut être résolu avec les différents hton* fonctions, tandis que le second, avec la compilation des directives spécifiques.

En particulier, de nombreux compilateurs de soutien de la #pragma pack directive (voir ici pour VC++, ici pour gcc), qui vous permet de gérer l' (indésirables) rembourrage que le compilateur peut insérer dans le struct avoir ses champs alignés sur les pratiques limites.

Gardez à l'esprit, cependant, que sur certaines architectures, il n'est pas autorisé à accéder aux champs de types particuliers si elles ne sont pas alignées sur leurs limites naturelles, donc, dans ces cas, il aurait probablement besoin de faire quelques manuel memcpys pour copier les octets brutes à des variables qui sont correctement alignés.

Pouvez-vous élaborer sur la #pragmas? J'utilise GCC.
ajout de quelques liens sur #pragma pack.
hton*/ah* convertir entre l'hôte par l'ordre (peut-être big ou little endian) et le réseau d'ordre des octets (big endian). Ils ne fournissent pas un moyen de sérialiser/désérialiser les valeurs qui sont stockées little endian d'une manière portable.

OriginalL'auteur Matteo Italia
1

Oui: l'Utilisation std::copy de <algorithm> pour fonctionner sur la représentation en octets d'une variable. Chaque variable T x; peut être consulté comme un tableau d'octets via char * p = reinterpret_cast<char*>(&x); et p peut être traité comme un pointeur vers le premier élément d'un tableau char[sizeof(T)]. Par exemple:
```
char buf[100];
double q = get_value();

char const * const p = reinterpret_cast<char const *>(&q);
std::copy(p, p + sizeof(double), buf);

//more stuff like that

some_stream.write(buf) //... etc.
```
Et de revenir en arrière:
```
double r;

std::copy(data, data + sizeof(double), reinterpret_cast<char *>(&r));
```
En bref, vous n'avez pas besoin d'un dédié pack/unpack en C++, parce que la langue déjà vous permet d'accéder à ses variables binaires de la représentation comme une partie standard de la langue.

Je sais. Je veux un pack/unpack pour portable de représentation, et non d'octets local de manipulation.
Vous avez la garantie d'obtenir un objet valide de retour seulement pour les types qui sont trivialement copiable. Je suis sûr que vous le savez déjà, mais vous n'avez pas le dire.
Ce n'est pas portable du tout. Vous êtes pas tenu compte de l'endianess pour commencer, et bien sûr, il ne fonctionne que pour les POD (plain old données).
Eh bien, qu'est ce qu'un "portable" manière de stocker des flotteurs? Ce que je dis, c'est que vous pouvez utiliser l'octet, l'accès à l' œuvre de toute sorte de sérialisation que vous le souhaitez. Par exemple, vous pouvez lire/écrire des entiers non signés avec l'habitude des manipulations algébriques (buf[0] = n % 256; buf [1] = (n / 256) % 256;, etc. (Si vous avez besoin unsigned caractères dans ce cas.) Et oui, c'est seulement pour les types fondamentaux (pas même les Gousses).

OriginalL'auteur Kerrek SB

Vous devez vous connecter pour publier un commentaire.