écriture « emballé » struct à déposer en C

Question

Comment un struct dans un fichier puis-je « pack » et « écrire » en utilisant C de sorte que:

struct a { 
    uint64_t a; 
    char* b; 
    uint16_t c; 
} a; 
a b; 
b.a = 3; 
b.b = "Hello"; 
b.c = 4;

écrites sur le fichier en tant que

00 00 00 00 00 00 00 03 48 65 6c 6c 6f 00 00 04

Answer 1

En C, vous devrez coder une fonction pour le faire pour vous. Vous ne pouvez pas simplement blatir la structure sur le disque car b est un pointeur qui n'a aucun sens sans la chaîne de sauvegarde. Et, à moins que vous sachiez (et pouvez contrôler) comment votre compilateur conditionne ses structures, vous êtes mieux avec une fonction utilitaire de toute façon, même sans pointeurs. Et, comme si cela ne suffisait pas, vous devriez également afficher la longueur de la chaîne afin de connaître le nombre d'octets à lire.

Vous allez chercher quelque chose comme:

int better_than_blat (FILE *f, struct a *x) { 
    size_t len = strlen (x->b); 
    if (fwrite (&(x->a), sizeof(long), 1, f) != 1) return -1; 
    if (fwrite (&len, sizeof(size_t), 1, f) != 1) return -1; 
    if (fwrite (x->b, len, 1, f) != 1) return -1; 
    if (fwrite (&(x->c), sizeof(short), 1, f) != 1) return -1; 
    return 0; 
} 

int better_than_unblat (FILE *f, struct a *x) { 
    size_t len; 
    if (fread (&(x->a), sizeof(long), 1, f) != 1) return -1; 
    if (fread (&len, sizeof(size_t), 1, f) != 1) return -1; 
    x->b = malloc (len + 1); 
    if (x->b == NULL) return -1; 
    memset (x->b, 0, len + 1); 
    if (fread (x->b, len, 1, f) != 1) return -1; 
    if (fread (&(x->c), sizeof(short), 1, f) != 1) return -1; 
    return 0; 
} 

Answer 2

vous devez écrire votre propre façon de sérialiser ces données; le compilateur ne vous donnera pas un moyen intégré de gérer la chaîne. Il existe des bibliothèques de sérialisation mais je n'en connais pas pour C.

Mais, pensez à utiliser une méthode plus structurée pour sérialiser les données, telles que json ou xml. Même un fichier INI est meilleur qu'un vidage binaire brut. Les raisons sont:

• plus facile à déboguer
• plus postcompatible
• moins rigide/sujette à erreur
• si vous utilisez une bibliothèque existante, vous récolterez les récompenses de la communauté qui va avec il.
• une bibliothèque existante est susceptible de prendre en charge les fonctionnalités que vous allez plus tard gratter la tête sur comme des tableaux
• meilleure compatibilité multi-plateforme.

Answer 3

Est-ce que l'aide suivante?

struct buffer { 

    char bytes[1000]; 
    int nbytes; 
}; 

struct buffer *new_buffer(){ 
    struct buffer b = (struct buffer*) malloc(sizeof(struct buffer)); 
    b->nbytes = 0; 
    return b; 
} 

void append_long(struct buffer *b, long *l){ 
    memcpy(b->bytes + b->nbytes, l); 
    b->nbytes += sizeof(*l); 
} 

// ...and so on for other types 

void fwrite_buffer(FILE *fp, struct buffer *b){ 
    fwrite(b->bytes, sizeof(*b), 1, fp); 
} 

Utilisation:

struct buffer *buf = new_buffer(); 
struct a b; 
b.a = 3; 
b.b = "Hello"; 
b.c = 4; 
append_long(buf, &(b.a)); 
append_pointer(buf, &(b.b)); 
append_short(buf, &(b.b)); 
fwrite_buffer(fp, buf); 

Answer 4

Vous pouvez en toute sécurité emballer la structure en tableau d'octets, si vous n'utiliser des pointeurs dans et définirez explicitement l'alignement d'emballage.

Par exemple (gcc):

 
struct a { 
    long a; 
    char b[256]; 
    short c; 
} __attribute__((__packed__)); 

int size = sizeof(a); 
void* buffer = malloc(size); 
memcpy(buffer, (void*)a, size);