[SOLUCIONADO] Guardar una lista en un fichero

[dehm]

Hola:

Pues este es mi problema:
Quiero guardar una lista en un fichero. Lo estoy haciendo así (lo he visto en StackOverflow) pero a la hora de leer la lista que recupero de un fichero tengo un error.

Este es el código:

Código C++:

#include <fstream>
#include <iostream>
#include <list>
using namespace std;
typedef list<int> ListaEnteros;
 
 
 
int main()
{
 
    ListaEnteros lista1;
    lista1.push_back(1);
    lista1.push_back(3);
    lista1.push_back(5);
    lista1.push_back(7);
    lista1.push_back(9);
    lista1.push_back(11);
    lista1.push_back(13);
    /***********guardar en fichero*******************/
    int tamLista=lista1.size();
    ofstream ofs("borrar.dat", ios::out|ios::binary);
    ofs.write (reinterpret_cast<char*>(&tamLista),sizeof(int));
    ofs.write (reinterpret_cast<char*>(&lista1),(tamLista*sizeof(int)));
    ofs.close();
    /*********recuperar de fichero***************/
    ListaEnteros lista2;
    int tamLista2;
    ifstream ifs("borrar.dat",ios::in|ios::binary);
    ifs.read(reinterpret_cast<char*>(&tamLista2),sizeof(int));
    lista2.resize(tamLista2);
    ifs.read(reinterpret_cast<char*>(&lista2),(tamLista2*sizeof(int)));
    ifs.close();
    /*********imprimir la lista*******************/
    for (auto it=lista2.begin();it!=lista2.end();it++)
    {
        cout<<*it<<endl;
    }
 
 
    return 0;
 
}
 

Bueno, pues como siempre, gracias por adelantado

[dehm]

Finalmente parece que no se pueden hacer atajos, así que me resigno a leer el contenido de la lista e ir guardándolos uno a uno, e igualmente, volver a crear la lista e ir insertando los valores...

Código C++:

ListaEnteros lista1;
    lista1.push_back(1);
    lista1.push_back(3);
    lista1.push_back(5);
    lista1.push_back(7);
    lista1.push_back(9);
    lista1.push_back(11);
    lista1.push_back(13);
    /***********guardar en fichero*******************/
    int tamLista=lista1.size();
    ofstream ofs("borrar.dat", ios::out|ios::binary);
    ofs.write(reinterpret_cast<char*>(&tamLista),sizeof(int));
 
    for (auto it=lista1.begin();it!=lista1.end();++it)
    {
        ofs.write (reinterpret_cast<char*>(&*it),sizeof(int));
    }
    ofs.close();
    /*********recuperar de fichero***************/
    ListaEnteros lista2;
    int tamLista2;
    ifstream ifs("borrar.dat",ios::in|ios::binary);
    ifs.read(reinterpret_cast<char*>(&tamLista2),sizeof(int));
    int var=0;
    for (int i=0;i<tamLista2;i++)
    {
        ifs.read(reinterpret_cast<char*>(&var),sizeof(int));
        lista2.push_back(var);
    }
    ifs.close();
    /*********imprimir la lista*******************/
    for (auto it=lista2.begin();it!=lista2.end();it++)
    {
        cout<<*it<<endl;
    }
 return 0;
}
 

[eferion]

Iniciado por dehm

Finalmente parece que no se pueden hacer atajos, así que me resigno a leer el contenido de la lista e ir guardándolos uno a uno, e igualmente, volver a crear la lista e ir insertando los valores...

No se pueden coger atajos por una razón muy sencilla: Los contenedores de C++ gestionan internamente memoria dinámica para almacenar los elementos que se les vayan pasando. Debido a esto, si tu vuelcas directamente la memoria del contenedor lo que consigues es guardar punteros en vez de información útil.

De hecho, a modo de ejemplo, el único contenido que almacena directamente el objeto "list" usado por mi compilador es la siguiente:

Código C++:

_Nodeptr _Myhead;   // pointer to head node
size_type _Mysize;  // number of elements
 

Es decir, un puntero a la lista de elementos y una variable que indica cuantos elementos tiene la lista... y eso es lo que vas a guardar en el fichero si lo haces a lo bestia.

Al leer "a lo bestia" vas a insertar esta información a lo bruto en el nuevo contenedor y el resultado es el siguiente:

* Vas a crear lagunas de memoria. El contenedor en el que vayas a almacenar el contenido del fichero va a perder el puntero a la memoria que previamente ha reservado para sus propios fines, por lo que no podrá liberar esa memoria.

* Si la lectura la realizas una vez hayas destruido la lista original vas a acceder a memoria que no te corresponde.

* Si la lectura se realiza según tu primer ejemplo vas a conseguir que los dos contenedores apunten a la misma lista. El problema que genera esto es que si uno de los dos altera la lista el otro contenedor va a empezar a acceder a memoria no válida. En el caso concreto de tu programa los dos contenedores van a hacer delete sobre la misma región de memoria y el segundo va a dar error, lo cual es lógico.

Espero que esta explicación te aclare los motivos por los que no funcionaba tu primer ejemplo.

Un saludo.

[dehm]

Muchas gracias por la explicación.

[eferion]

De nada. A mandar :)