Quelles sont les bonnes solutions pour la sérialisation en C ++? [fermé]

18

Je suis curieux de savoir quelles solutions les développeurs de jeux ont trouvées pour sérialiser les différents types de données avec lesquels ils traitent pour leurs jeux. Utilisez-vous une hiérarchie GameObject monolithique qui héberge une interface de sérialisation pour les types dérivés, utilisez-vous une sorte de solution RTTI personnalisée, effectuez-vous une sérialisation de flux explicite pour certaines classes, ou utilisez certaines des solutions open source (boost :: serialization, s11n, etc).

Mark
la source
1
Je pense que la sérialisation dans la programmation de développement de jeux est un sujet important, mais je n'aime pas cette question. Qu'essayez- vous de faire? Quels problèmes spécifiques essayez-vous de résoudre? Au lieu de cela, je l'ai converti en wiki communautaire pour qu'il soit plus un format de discussion.
Tetrad
Je pense qu'il serait bon d'appliquer un formatage à cela, (ala la question du contrôle de version).
Jesse Dorsey

Réponses:

9

Les tampons de protocole de Google peuvent être une assez bonne approche pour sérialiser des objets c ++. Vous devrez peut-être créer des objets intermédiaires dans le cadre du processus de sérialisation, mais cela fonctionne également sur de nombreuses plates-formes et langages.

Ben Zeigler
la source
1
Je l'utilise et c'est facile si vous pouvez automatiser la génération de code dans votre système de construction. Bien qu'un avantage vraiment excellent soit qu'il vous permette de transférer des données sur des machnies distants sans tenir compte de la plate-forme utilisée, il est optimisé pour cela afin que les objets générés ne soient pas gros.
Klaim
10

Dans notre jeu, nous utilisons simplement boost.serilization , c'est facile à utiliser et très rapide, mais c'est à mon avis juste utile pour les sauvegardes. Si vous essayez de créer des personnages, je vous recommande quelque chose basé sur XML'ish ou JSON, car ils sont faciles à lire et modifiables même si vous n'avez pas l'éditeur.

awildturtok
la source
J'ai également vu boost :: serialization utilisé avec succès pour la communication client / serveur. Cependant, AFAIK est basé sur le flux, il n'est donc pas exactement tolérant aux versions. Cela peut ne pas être un facteur décisif pour la communication client / serveur, mais si vous l'utilisez pour des jeux enregistrés, toute modification des structures de données de jeu rend le chargement de jeux enregistrés plus anciens une impossibilité virtuelle (la prise en charge du chargement de versions d'objet plus anciennes devient une véritable corvée ).
Mike Strobel
2
@MikeStrobel J'ai récemment examiné quelques kits de sérialisation et json et suis tombé sur ce commentaire. boost :: serialization prend explicitement en charge la gestion des versions. Les appels sérialisés peuvent recevoir un numéro de version, puis c'est à l'utilisateur d'implémenter la logique de branchement de base (si (version> 1.0) ...). Globalement, cela semble assez robuste.
M2tM
Dommage qu'il ne semble pas prendre en charge l'allocateur / suppresseur personnalisé.
JamesAMD
1
Je viens de passer de la sérialisation de boost aux céréales. Le port était remarquablement lisse . Ça a marché comme sur des roulettes. Cereal prend en charge xml, json, binary et portable binary . La raison pour laquelle j'ai porté des céréales était la dernière. J'avais besoin d'archives binaires portables car je gère un serveur auquel se connectent les clients (pour l'instant un mac, bientôt iOS et Android). J'étais assez satisfait de la sérialisation de boost, mais je pense que certaines des fonctionnalités des céréales vont encore plus loin, d'une meilleure manière, comme la sérialisation binaire portable mentionnée. Pour les tampons de protocole d'interopérabilité des langues, c'est mieux.
Germán Diago
Per docs boost.serialization n'est pas thread-safe. Cereal n'utilise pas non plus une API similaire.
Hi-Angel
3

J'aime plutôt JSON pour la sérialisation. Il est assez simple à analyser et il existe des bibliothèques gratuites telles que http://jsoncpp.sourceforge.net/ Je n'ai jamais été fan de boost ou RTTI en C ++. Tinyxml fonctionne également bien pour la sérialisation et la désérialisation xml.http://www.grinninglizard.com/tinyxml/ En fin de compte, je ne veux pas avoir à passer plus de temps que je n'en ai pour la sérialisation.

Steven Behnke
la source
2

Google FlatBuffers est une bibliothèque de sérialisation multiplateforme efficace pour C ++, avec prise en charge de Java et Go. Il a été créé chez Google spécifiquement pour le développement de jeux et d'autres applications critiques pour les performances.

Il est disponible en open source sous la licence Apache, v2.

Kimi
la source
1

XDS a été conçu spécialement à cet effet, il vous offre les avantages de XML pendant le développement et les avantages d'une représentation binaire compacte au moment de la distribution.

user16
la source
Je ne sais pas vraiment ce qui différencie XDS des tampons de protocole Google? Ils semblent servir le même but, sauf que XDS était le premier.
jacmoe
Vous voulez sûrement dire XSD et non XDS? codesynthesis.com/products/xsd Je voulais poster une réponse à ce sujet pour compléter la liste.
v.oddou
1

Si vous êtes sur une plateforme Linux, vous pouvez directement utiliser la json.hbibliothèque pour la sérialisation. Voici un exemple de code que j'ai rencontré. Source: Json Serializer

//============================================================================
// Name        : JsonTest.cpp
// Author      : Manis Kumar Khedawat
//============================================================================

#include <iostream>
#include <json/json.h>

using namespace std;

struct objStruct{
    string str;
    int n1;
    int n2;
};

typedef objStruct obj;

void serializeToJson(json_object *jObj,obj* pObj)
{
    /*
    string str;
    int n1;
    int n2;
    */

    // Create json object for every member in struct Obj.

    json_object *jstr = json_object_new_string (pObj->str.c_str());
    json_object *jn1 =json_object_new_int(pObj->n1);
    json_object *jn2 =json_object_new_int(pObj->n2);

    // Add all above created object into jObj

    json_object_object_add(jObj,"str",jstr);
    json_object_object_add(jObj,"n1",jn1);
    json_object_object_add(jObj,"n2",jn2);

    // pObj is Serialzed into jObj
}

void deSerializeToJson(json_object *jObj,obj* pObj)
{
    /*
    string str;
    int n1;
    int n2;
    */

    // Get every member as different json obj from jObj
    json_object *jstr = json_object_object_get (jObj,"str");
    json_object *jn1 =json_object_object_get(jObj,"n1");
    json_object *jn2 =json_object_object_get(jObj,"n2");

    pObj->str=json_object_get_string(jstr);
    pObj->n1=json_object_get_int(jn1);
    pObj->n2=json_object_get_int(jn2);

    // jObj is DeSerialzed into pObj
}

int main() {
    // Lets Create an Object which we will serialze into Json
    obj obj1;
    obj1.n1=3;
    obj1.n2=6;
    obj1.str="This is String";

    // Create a json Object
    json_object* jObj=json_object_new_object();

    // To serialize into Json Object
    // Please Keep in mind , we are passing address of object (pointer) & not object
    serializeToJson(jObj,&obj1);

    obj obj2;
    // To serialize into Json Object
    // Please Keep in mind , we are passing address of object (pointer) & not object
    deSerializeToJson(jObj,&obj2);

    cout<<"String str == "<<obj2.str<<endl;
    cout<<"n1 & n2 : "<<obj2.n1<<" "<<obj2.n2<<endl;

    return 0;
}
Philip Allgaier
la source
0

Les tampons jsonCpp et Protocol sont de bonnes options. À ma connaissance, les deux vont seulement vous permettre de créer des structures d'arborescence en série (veuillez me corriger si je me trompe). boost :: serialization peut gérer des graphes arbitraires, mais n'a pas un bon format de texte comme json (je pense qu'il y a un format xml)

Personnellement, je pense que l'approche de sérialisation json que Dojo a adoptée est la meilleure
http://docs.dojocampus.org/dojox/json/ref

J'en ai fait ma propre version en c ++ en utilisant jsoncpp, qui désérialisera également les objets typés (j'ai une sorte de grosse usine pour tous mes types). Cela me permet de créer une scène à partir d'une collection de fichiers json qui peuvent être référencés de toute façon, je le souhaite.

Jonathan Fischoff
la source