estructurar la lista enlazada de volcado de memoria

Question

¿hay algún método estándar que me he perdido en la escuela para volcar C estructura con listas enlazadas anidados en el disco en forma razonable? Lo que no quiero hacer es:

• uso de protocolo-buffers o cualquier otro como serializators,
• no quieren crear JSON, XML u otro

Tengo algunas ideas:

• asignar cantidad de memoria precisa (o ampliar uno ya existente) y administrar por mí mismo, la colocación de elementos de la lista en la pila como enfoque el uso de algunos campos adicionales para gestionar direcciones relativas. Cuando el bloque volcado necesario en el disco. Tener procedimientos de correlación de bloques de disco crear una estructura deseable ser consciente de orden de bytes.
• empujar estructura principal de archivo, a continuación, empuje los elementos de la lista, almacenar información sobre la lista en el encabezado de un archivo.

Para esta imagen Voy a dar algunos detalles más escribiendo código de ejemplo:

typedef struct{
   int b;
   List *next;
}List;

typedef struct{
   float b;
   List2 *next;
}List2;

typedef struct{
   List *head;
   List *tail;
} info;

typedef struct{
   List2 *head;
   List2 *tail;
} info2;

struct data
{
    int a;
    char t[10];
    info first;
    info second;
    info2 third;
};

aplausos P.

EDIT:

he extendido estructura principal, parece que la anterior no han indicar el problema totalmente. Soy consciente de que los punteros en el disco son inútiles. Ideas y pseudocódigo permitidos.

Answer 1

serializar los datos en el orden que ha celebrado en la lista enlazada, ficha de estilo en un archivo. fwrite es particularmente bueno para esto. Asegúrese de punteros dereference, y ser conscientes del papel que juega en este endianness.

Aquí hay algo de pseudocódigo vaga:

List *list_new();
List *list_add(List *, void *data);
List *list_next(List *);

while (node) {
    fwrite(node->data, sizeof(node->data), 1, fp);
    node = list_next(node);
}

Código áspera por un nuevo en una lista en directo la lectura:

List *node = list_new();
while (true) {
    struct data *buf = malloc(sizeof(*buf));
    if (1 != fread(buf, sizeof(*buf), 1, fp))
        break;
    list_add(node, buf);
}

Update0

Si usted empieza a anidar estructuras más avanzadas, como otras listas enlazadas, las cadenas de longitud variable, etc., tendrá que proporcionar tipos y longitudes para cada registro, y una forma de registros de anidación dentro de otros registros.

A modo de ejemplo, si la lista de alto nivel vinculados tenía un miembro de datos que era otra lista, que sería mejor para almacenar ese miembro como un registro anidada, con una longitud, y el campo de tipo. Alternativamente, se podría definir registros centinela, como \0 de cadenas de caracteres (una opción obvia), y los bloques puestos a cero para los datos struct.

Answer 2

No he entendido su problema correctamente, pero vertido una estructura en el disco y leer de nuevo de forma fiable tiene varios problemas.

Lo más importante es el relleno estructura o el relleno de bytes. Así que tendría que hacerse cargo de eso también.

Answer 3

No hay clara forma de hacer esto, ya que estos tendrán direcciones de memoria, y la próxima vez que se lee en, contendrá las direcciones de memoria que podría no ser válido ... la única cosa que podría hacer es tener una participación área de datos para leer / escribir, vamos a ver cómo escribir los datos en el disco basado en el contenido de la lista enlazada ...

struct rwBufferData{
    int a;
    char t[10];
};

y llenar el 'rwBufferData' antes de escribir utilizando memset y memmove

struct rwBufferData rwBuf;
struct data *dataPtr;
memset(&rwBuf, '\0', sizeof(struct rwBufferData));
memmove(&rwBuf, dataPtr, sizeof(struct rwBufferData));

Ahora usted puede entonces rwBuf escribir en el archivo ... Voy a dejar la operación inversa como un ejercicio ...