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

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).

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.

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.

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.

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.

Le pack de messages est aussi une excellente alternative! (http://msgpack.org)

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.

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;
}

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.