l'utilisation de printf pour imprimer chaîne de caractères au format hex, déformée résultats

Je veux imprimer chaîne de caractères au format hex,

sur Une machine , quelque chose comme

ori_mesg = gen_rdm_bytestream (1400,seed)
sendto(machine B, ori_mesg, len(mesg))

sur la machine B

 recvfrom(machine A, mesg)

mesg_check = gen_rdm_bytestream (1400, seed)

            for(i=0;i<20;i++){
                    printf("%02x ", *(mesg+i)& 0xFF);
            }
            printf("\n");
            for(i=0;i<20;i++){
                    printf("%02x ", *(mesg_check+i));
            }
            printf("\n");

seed varie entre 1, 2 3....

les octets de génération de la fonction est:

u_char *gen_rdm_bytestream (size_t num_bytes, unsigned int seed)
{
    u_char *stream = malloc (num_bytes+4);
    size_t i;

    u_int16_t seq = seed;
    seq = htons(seq);
    u_int16_t tail = num_bytes;
    tail = htons(tail);
    memcpy(stream, &seq, sizeof(seq));
    srand(seed);
    for (i = 3; i < num_bytes+2; i++){
            stream[i] = rand ();
            }
    memcpy(stream+num_bytes+2, &tail, sizeof(tail));

  return stream;
}

mais j'ai obtenu des résultats de printf comme:

00 01 00 67 c6 69 73 51 ff 4a ec 29 cd ba ab f2 fb e3 46 7c 
00 01 00 67 ffffffc6 69 73 51 ffffffff 4a ffffffec 29 ffffffcd ffffffba ffffffab fffffff2 fffffffb ffffffe3 46 7c

00 02 88 fa 7f 44 4f d5 d2 00 2d 29 4b 96 c3 4d c5 7d 29 7e 
00 02 00 fffffffa 7f 44 4f ffffffd5 ffffffd2 00 2d 29 4b ffffff96 ffffffc3 4d ffffffc5 7d 29 7e

pourquoi sont-ils si nombreux fffff pour mesg_check?

sont là toutes les raisons possibles de ce phénomène?
merci!

Ce n' mesg et mesg_check ressembler?
serait mesg être un char* ou char [], par hasard?
Essayer de mettre un space dans le printf spécificateur. C'est à dire, "%2,2 x " Vous avez obtenu le plus grand nombre de mettre ensemble et négatifs sont signe étendu.
Vous avez accepté la réponse, mais vous n'avez pas encore montré comment mesg et mesg_check sont définies -- pas comment vous les initialiser, mais ce que leurs déclarations. Nous montrant que pourrait être utile pour les futurs lecteurs de cette question.
Double Possible de Pourquoi ne printf pas imprimer juste un octet lors de l'impression hex?

OriginalL'auteur misteryes | 2013-04-04

c printf

17

Voici un petit programme qui illustre le problème que j'ai pense que vous pourriez avoir:
```
#include <stdio.h>
int main(void) {
    char arr[] = { 0, 16, 127, 128, 255 };
    for (int i = 0; i < sizeof arr; i ++) {
        printf(" %2x", arr[i]);
    }
    putchar('\n');
    return 0;
}
```
Sur mon système (sur lequel plaine char est signé), j'obtiens ce résultat:
```
  0 10 7f ffffff80 ffffffff
```
La valeur 255, lorsqu'il est stocké dans un (signé) char, est stockée en tant que -1. Dans le printf appel, il est promu (signé) int -- mais le "%2x" format dit printf de la traiter comme une unsigned int, de sorte qu'il affiche fffffffff.

Assurez-vous que votre mesg et mesg_check tableaux sont définis comme des tableaux de unsigned char, pas plaine char.

Mise à JOUR: à une Relecture de cette réponse plus qu'un an plus tard, je me rends compte que c'est pas tout à fait correcte. Voici un programme qui fonctionne correctement sur mon système, et sera presque certainement travailler sur n'importe quel système raisonnable:
```
#include <stdio.h>
int main(void) {
    unsigned char arr[] = { 0, 16, 127, 128, 255 };
    for (int i = 0; i < sizeof arr; i ++) {
        printf(" %02x", arr[i]);
    }
    putchar('\n');
    return 0;
}
```
La sortie est:
```
 00 10 7f 80 ff
```
Un argument de type unsigned char est promu (signé) int (en supposant que int peut contenir toutes les valeurs de type unsigned char, c'est à dire, INT_MAX >= UCHAR_MAX, ce qui est le cas sur pratiquement tous les systèmes). Donc, l'argument arr[i] est promu int, tandis que le " %02x" format nécessite un argument de type unsigned int.

Le C standard implique fortement, mais n'a pas assez état directement, que les arguments de correspondant entiers signés et non signés sont interchangeables tant qu'ils sont dans la gamme de ces deux types -- ce qui est le cas ici.

Être complètement correcte, vous devez vous assurer que l'argument est en fait de type unsigned int:
```
printf("%02x", (unsigned)arr[i]);
```
Ne peut-il pas simplement utiliser un largeur et précision like "%2,2 x" et puis il n'a pas d'importance s'il est signé ou pas? Je suppose qu'il est plus efficace de changer le signe.
%2,2 x ??? qu'est-ce que cela signifie?
ah, mesg est de recvfrom(), qui est de type void*, alors comment puis-je modifier les octets de unsigned char?
+1 c'est en effet ce qui se passe, mais la solution la plus simple est juste de masquer toutes les ordures, comme printf(" %2x", arr[i] & 0xFF);
La vraie question est de savoir comment sont mesg et mesg_check défini? Sans doute que vous avez défini vous-même (dans le code, vous n'avez pas encore montré). Si vous faites affaire avec des octets de données, unsigned char est un meilleur choix que la plaine char (pour cela, et pour d'autres raisons); plaine char est pour caractère de données. Vous pouvez passer une unsigned char* que le 2ème argument de recvfrom(). Et si vous êtes dumping données en hexadécimal, puis "%02x" généralement plus de sens; il affiche les valeurs de moins de 0x10 avec un 0.

OriginalL'auteur Keith Thompson
1

Yup, toujours de la chaîne d'impression au format hex:
```
for(i=0;till string length;i++)
printf("%02X",(unsigned char)str[i]);
```
vous obtiendrez d'erreur lorsque vous essayez d'imprimer

l'ensemble de la chaîne de caractères en une seule fois et lors de l'impression d'Hex de la chaîne caractère par caractère à l'aide de la "Unsigned char" si la chaîne est en format autre que 'Unsigned char

Le Format de votre code.

OriginalL'auteur Akash kumar

Vous devez vous connecter pour publier un commentaire.