c++ - sinonimos - serializar y deserializar json c#

Serializar y deserializar el vector en binario

Question

Tengo problemas para serializar un vector (std :: vector) en un formato binario y luego deserializarlo correctamente y poder leer los datos. Esta es la primera vez que utilizo un formato binario (estaba usando ASCII pero ahora es demasiado difícil de usar), así que estoy comenzando de manera simple con solo un vector de entradas.

Cada vez que leo los datos, el vector siempre tiene la longitud correcta, pero los datos son 0, indefinidos o aleatorios.

class Example  
{  
public:  
    std::vector<int> val;  
};

ESCRIBIR:

Example example = Example();  
example.val.push_back(10);  
size_t size = sizeof BinaryExample + (sizeof(int) * example.val.size()); 

std::fstream file ("Levels/example.sld", std::ios::out | std::ios::binary);

if (file.is_open())  
{  
    file.seekg(0);  
    file.write((char*)&example, size);  
    file.close();  
}

LEER:

BinaryExample example = BinaryExample();

std::ifstream::pos_type size;  
std::ifstream file ("Levels/example.sld", std::ios::in | std::ios::binary | std::ios::ate);

if (file.is_open())  
{   
    size = file.tellg();

    file.seekg(0, std::ios::beg);
    file.read((char*)&example, size);
    file.close();
}

¿Alguien sabe lo que estoy haciendo mal o qué hacer o puede apuntarme en la dirección que tengo que hacer?

Answer 1

Escribiría en orden de bytes de red para asegurar que el archivo se pueda escribir y leer en cualquier plataforma. Asi que:

#include <fstream>
#include <iostream>
#include <iomanip>
#include <vector>

#include <arpa/inet.h>

int main(void) {

  std::vector<int32_t> v = std::vector<int32_t>();
  v.push_back(111);
  v.push_back(222);
  v.push_back(333);


  {
    std::ofstream ofs;
    ofs.open("vecdmp.bin", std::ios::out | std::ios::binary);

    uint32_t sz = htonl(v.size());
    ofs.write((const char*)&sz, sizeof(uint32_t));
    for (uint32_t i = 0, end_i = v.size(); i < end_i; ++i) {
      int32_t val = htonl(v[i]);
      ofs.write((const char*)&val, sizeof(int32_t));
    }

    ofs.close();
  }

  {
    std::ifstream ifs;
    ifs.open("vecdmp.bin", std::ios::in | std::ios::binary);

    uint32_t sz = 0;
    ifs.read((char*)&sz, sizeof(uint32_t));
    sz = ntohl(sz);

    for (uint32_t i = 0; i < sz; ++i) {
      int32_t val = 0;
      ifs.read((char*)&val, sizeof(int32_t));
      val = ntohl(val);
      std::cout << i << ''='' << val << ''/n'';
    }
  }

  return 0;
}

Answer 2

Estás usando la dirección del vector. Lo que necesita / desea es la dirección de los datos que contiene el vector. Escribir, por ejemplo, sería algo así como:

size = example.size();
file.write((char *)&size, sizeof(size));
file.write((char *)&example[0], sizeof(example[0] * size));

Answer 3

Lea la respuesta del otro para ver cómo debe leer / escribir una estructura binaria.

Agregué este porque creo que tus motivaciones para usar un formato binario están equivocadas. Un formato binario no será más fácil que uno ASCII, generalmente es al revés.

Tiene muchas opciones para guardar / leer datos para uso a largo plazo (ORM, bases de datos, formatos estructurados, archivos de configuración, etc.). El archivo binario plano suele ser el peor y el más difícil de mantener a excepción de estructuras muy simples.

Answer 4

No puede deserializar una clase que no sea POD sobrescribiendo una instancia existente como parece estar tratando de hacer; necesita dar a la clase un constructor que lea los datos de la secuencia y construya una nueva instancia de la clase con ella.

En resumen, dado algo como esto:

class A {
    A();   
    A( istream & is );    
    void serialise( ostream & os );
    vector <int> v;
};

luego serialise () escribiría la longitud del vector seguido de los contenidos del vector. El constructor leería la longitud del vector, redimensionaría el vector usando la longitud y luego leería los contenidos vectoriales:

void A :: serialise( ostream & os ) {
    size_t vsize = v.size();    
    os.write((char*)&vsize, sizeof(vsize));
    os.write((char*)&v[0], vsize * sizeof(int) );
}

A :: A( istream & is ) {
    size_t vsize;
    is.read((char*)&vsize, sizeof(vsize));
    v.resize( vsize );
    is.read((char*)&v[0], vsize * sizeof(int));
}