Quais são as boas soluções para serialização em C ++? [fechadas]

Estou curioso para saber quais soluções os desenvolvedores de jogos criaram para serializar os diferentes tipos de dados com os quais lidam em seus jogos. Vocês usam alguma hierarquia monolítica do GameObject que abriga uma interface de serialização para tipos derivados, usam uma solução personalizada baseada em RTTI, realizam a serialização explícita de fluxo para determinadas classes ou usam algumas das soluções de código aberto (boost :: serialization, s11n, etc).

Os buffers de protocolo do Google podem ser uma boa abordagem para serializar objetos c ++. Pode ser necessário criar alguns objetos intermediários como parte do processo de serialização, mas também funciona em várias plataformas e idiomas.

Em nosso jogo, simplesmente usamos o boost.serilization , é fácil de usar e muito rápido, mas, na minha opinião, é útil apenas para jogos de salvamento . Se você tentar criar caracteres, eu recomendo que você use algo baseado em XML'ish ou JSON, porque eles são fáceis de ler e editáveis, mesmo que você não tenha o editor.

Eu gosto bastante de JSON para serialização. É bem simples de analisar e existem bibliotecas gratuitas disponíveis, como http://jsoncpp.sourceforge.net/ . Nunca fui fã de boost ou RTTI em C ++. O Tinyxml também funciona bem para serialização e desserialização de xml. http://www.grinninglizard.com/tinyxml/ Por fim, não quero gastar mais tempo do que preciso para serialização.

O Google FlatBuffers é uma biblioteca eficiente de serialização de plataforma cruzada para C ++, com suporte para Java e Go. Foi criado no Google especificamente para o desenvolvimento de jogos e outros aplicativos críticos para o desempenho.

Está disponível como código aberto sob a licença Apache, v2.

O pacote de mensagens também é uma ótima alternativa! (http://msgpack.org)

O XDS foi projetado apenas para esse fim, oferece os benefícios do XML durante o desenvolvimento e os benefícios de uma representação binária compacta no momento da distribuição.

Se você estiver em uma plataforma Linux, poderá usar diretamente a json.hbiblioteca para serialização. Aqui está o código de exemplo que me deparei. Fonte: 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;
}

Os buffers jsonCpp e Protocol são boas opções. Que eu saiba, ambos apenas permitirão estruturas de árvore em série prontas para uso (corrija-me se estiver errado). boost :: serialization pode lidar com gráficos arbitrários, mas não possui um bom formato de texto como o json (acho que existe um formato xml)

Pessoalmente, acho que a abordagem para serialização json adotada pelo Dojo é a melhor
http://docs.dojocampus.org/dojox/json/ref

Eu fiz minha própria versão em c ++ usando jsoncpp, que também desserializa objetos digitados (eu tenho uma grande fábrica para todos os meus tipos). Ele me permite fazer uma cena a partir de uma coleção de arquivos json que podem ser referenciados de qualquer maneira que eu quiser.