Programmation en C : comment puis-je lire et d'imprimer un octet dans un fichier binaire?

Je veux ouvrir un fichier binaire, à lire le premier octet du fichier et enfin d'imprimer la valeur hexadécimale (dans un format de chaîne) sur la sortie standard (ie, si le premier octet est 03 hex, je souhaite imprimer 0x03 par exemple). La sortie j'obtiens ne correspond pas avec ce que je sais être dans mon exemple binaire, alors je me demande si quelqu'un peut aider avec ceci.

Voici le code:

#include <stdio.h>
#include <fcntl.h>

int main(int argc, char* argv[])
{
int fd;
char raw_buf[1],str_buf[1];

fd = open(argv[1],O_RDONLY|O_BINARY);

    /* Position at beginning */
lseek(fd,0,SEEK_SET);

    /* Read one byte */
read(fd,raw_buf,1);

    /* Convert to string format */
sprintf(str_buf,"0x%x",raw_buf);
printf("str_buf= <%s>\n",str_buf);

close (fd);
return 0;   
}

Le programme est compilé comme suit:

gcc rd_byte.c -o rd_byte

et exécuter comme suit:

rd_byte BINFILE.bin

Sachant que l'exemple de fichier binaire utilisé a 03 de son premier octet, je reçois la sortie:

str_buf= <0x22cce3>

Ce que j'attends est
str_buf= <0x03>

Où est l'erreur dans mon code?

Merci pour toute aide.

Nick réponse est bonne. D'un côté, la lseek est inutile (fichier commence à zéro après fopen), et vous pourriez juste printf la valeur directement, au lieu de l'impression sur une chaîne de première ie printf ("0x%x",raw_buf[0]). Utiliser %02x au lieu de %x si vous voulez toujours l'impression que les deux chiffres. Aussi, assurez-vous que raw_buf est déclarée comme unsigned char pour éviter de signer des extensions.

OriginalL'auteur Esquif | 2010-01-08

Moins, c'est plus...

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(int argc, char* argv[]) {
    int fd;
    unsigned char c;

    /* needs error checking */
    fd = open(argv[1], O_RDONLY);
    read(fd, &c, sizeof(c));
    close(fd);

    printf("<0x%x>\n", c);
    return 0;
}

seeking n'est pas nécessaire
si vous voulez lire un octet utiliser un unsigned char
printf fera le format

Je pense close(fd); est également nécessaire

OriginalL'auteur Diego Torres Milano

7

De l'impression de la valeur du pointeur raw_buf, pas la mémoire à cet emplacement:
```
sprintf(str_buf,"0x%x",raw_buf[0]);
```
Andreas dit, str_buf est pas assez grand. Mais: pas besoin d'un deuxième tampon, vous pouvez simplement appeler printf directement.
```
printf("0x%x",raw_buf[0]);
```
je préfère utiliser printf("0x%.02x",raw_buf[0]); de sorte qu'il imprime la même taille de chaque octet d'entrée

OriginalL'auteur Nick Meyer

Je pense que vous êtes de compliquer à l'excès et consommer des non-portable constructions où ils ne sont pas vraiment nécessaires.

Vous devriez être en mesure de faire:

#include <stdio.h>

int main(int argc, char** argv)
{
    if (argc < 2)
        return 1; /* TODO: better error handling */

    FILE* f = fopen(argv[1], "rb");

    /* TODO: check f is not NULL */

    /* Read one byte */    
    int first = fgetc(f);

    if (first != EOF)
        printf("first byte = %x\n", (unsigned)first);

    /* TODO else read failed, empty file?? */

    fclose(f);

    return 0;
}

OriginalL'auteur CB Bailey

2

str_buf a une taille maximale de 1 (char str_buf[1];), il devrait au moins 5 octets de long (4 pour XxXX, plus le \0).

En outre, le changement
```
sprintf(str_buf,"0x%x",raw_buf);
```
à
```
sprintf(str_buf,"0x%x",*raw_buf);
```
sinon vous allez imprimer l'adresse de la raw_buf aiguille, au lieu de sa valeur (que l'on peut obtenir par déréférencement le pointeur).

Enfin, assurez-vous que les deux raw_buf est unsigned. La norme définie que l'signness de caractères (si ce n'est explicitement spécifié) est définie par l'implémentation, c'est à dire, chaque réalisation décide si elles doivent être signés ou non. Dans la pratique, sur la plupart des implémentations ils sont signés par défaut, sauf si vous compilez avec un pavillon particulier. Lorsque vous traitez avec des octets assurez-vous toujours qu'ils ne sont pas signés; sinon, vous obtiendrez des résultats étonnants si vous voulez les convertir en nombres entiers.

OriginalL'auteur Thomas Bonini
0

À l'aide de l'information provenant de différentes réponses ci-dessus (merci à tous!) Je tiens à poster ce morceau de code qui est une version tronquée en bas de ce que j'ai finalement utilisé.

Il y a cependant une différence entre ce que le code suivant qui fonctionne et ce qui a été décrit dans mon origal question : ce code n'a pas lu le premier octet de l'en-tête de fichier binaire tel que décrit à l'origine, mais à la place lit les 11 et 12 octets (décalages 10 & 11) de l'entrée binaire du fichier (un .Fichier DBF). Les 11 et 12 octets contiennent la longueur d'un enregistrement de données (c'est ce que je veux savoir en fait) avec l'Octet le Moins Significatif positionné en premier: par exemple, si les 11 et 12 octets sont respectivement : 0x06 0x08, la longueur d'un enregistrement de données serait 0x0806 octets, ou 2054bytes en décimal
```
 #include <stdio.h>
 #include <fcntl.h>

 int main(int argc, char* argv[]) {
 int fd, dec;
 unsigned char c[1];
 unsigned char hex_buf[6];

 /* No error checking, etc. done here for brevity */

 /* Open the file given as the input argument */
 fd = open(argv[1], O_RDONLY);

 /* Position ourselves on the 11th byte aka offset 10 of the input file */
 lseek(fd,10,SEEK_SET);

 /* read 2 bytes into memory location c */
 read(fd, &c, 2*sizeof(c));

 /* write the data at c to the buffer hex_buf in the required (reverse) byte order + formatted */
 sprintf(hex_buf,"%.2x%.2x",c[1],c[0]);
 printf("Hexadecimal value:<0x%s>\n", hex_buf);

 /* copy the hex data in hex_buf to memory location dec, formatting it into decimal */
 sscanf(hex_buf, "%x", &dec);

 printf("Answer: Size of a data record=<%u>\n", dec);

 return 0;
```
}

OriginalL'auteur Esquif

Vous devez vous connecter pour publier un commentaire.