caster un int en char sur taille fixe

Bonjour à tous,

Je vais essayer de vous expliquer ce que je cherche à faire, et pourquoi je cherche à le faire.
Actuellement j'utilise sprintf pour transformer des long long int dans une chaine de caractère en séparant les 2 nombres par une virgule.
Seulement le problème est le suivant: si mon long long int contient le nombre "450" par exemple (je sais que cela tient dans un int mais cette variable est amené à contenir des nombres > 4 milliards).
En mettant dans le tableau cela va prendre 3 "cases", donc 3 octets,je peux voir ça avec strlen().
Mais pour mon application je dois savoir si j'ai reçu assez d'informations sur la socket pour pouvoir faire le traitement.

Et pour faire cela je dois avoir la première "case" de mon paquet qui contient la taille du reste des données. Et cette case doit avoir une taille fixe (ne contiendra pas une valeur > a celle que peut contenir un int) de façon à ce que je puisse regarder si la taille des données accessibles sur la socket est au moins supérieurs à cette taille fixe. Si c'est le cas je suis capable de récupérer la taille de ce qui va suivre, et vérifier ensuite que j'ai reçu assez de données pour faire le traitement, sinon j'attends pour revérifier.

D'ailleurs cette fonction sprintf() n'est pas dérangé si je lui met un char tab[3] et que je cherche à mettre dedans un nombre comme "599400", alors qu'il devrait y avoir un débordement du tableau.

Du coup je ne sais vraiment pas quoi faire.
Aujourd'hui ça marche parce que la taille des données envoyées pour l'initialisation est faible donc je les reçois quasi à coup sûr, mais je préfère assurer mes arrières, et de plus j'en aurais besoin pour la suite pour de la messagerie instantanée (on ne peux pas afficher qu'un morceau du message).

EDIT: Ce code ne veut pas fonctionner, mais fonctionne si je met juste un char, mais dans ce cas pas possible de mettre un nombre > 255...

Code:

---

1 2	char c[2] = static_cast<char[2]>( i );

---

Merci :)

Pour sérialiser un entier sur des chars, afin d'éviter les problèmes d'endianness, on les écrit octets par octets.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

int ecrire_int(char *buf, size_t taille, size_t *pIndex, int valeur) { int i; for(i=0 ; i<4 ; i++) { if((*pIndex) >= taille) return -1; buf[*pIndex] = (char)((valeur & 0xFF000000)>>24); (*pIndex)++; valeur <<= 8; } return 0; }

---

Bonjour,

Merci pour ta réponse, mais je ne comprends pas vraiment le code...
Notament avec le *pIndex. Est-il possible que tu m'expliques ce qui est fait avec un exemple sur un int qui vaut "6800" par exemple et qui soit codé sur mis sur 8 octets dans un tableau?

Merci d'avoir pris le temps de répondre

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void UneFonction(void) { char buffer[256]; size_t index = 0; ecrire_int(buffer, sizeof buffer, &index, 6800); /*Maintenant, le nombre 6800 a été écrit en big-endian dans les quatre premiers octets du buffer, et index vaut 4.*/ ecrire_int(buffer, sizeof buffer, &index, 42); ecrire_int(buffer, sizeof buffer, &index, 129987); /*Maintenant, index vaut 12.*/ }

---

Je vois maintenant comment utiliser la fonction, mais cela ne semble pas fonctionner.
La valeur de index vaut bien 12 quand je l'affiche à la fin, par contre buffer est vide (cout<<buffer<<endl).

De plus je n'ai pas vraiment compris le fonctionnement de ce code:

Code:

---

1 2 3 4 5 6

if((*pIndex) >= taille) return -1; buf[*pIndex] = (char)((valeur & 0xFF000000)>>24); (*pIndex)++; valeur <<= 8;

---

Merci :)

buffer est un tableau d'octets bruts, tu ne peux donc pas l'afficher directement avec cout.
Mais tu peux l'afficher ainsi:

Code:

---

1 2 3 4 5 6 7

cout << hex << setfill('0'); for(size_t i=0 ; i<index ; i++) { unsigned char uc = buffer[i]; cout << setw(2) << (int)uc) << ' '; } cout << endl;

---

Le code que tu as copié:

• Le test permet de vérifier qu'on ne dépasse pas de la taille du buffer
• Si on va dépasser, on retourne -1 à la place.
• La ligne suivante place l'octet supérieur du int (en supposant qu'un int fasse 32 bits) dans le buffer. Résultat, indépendamment de l'endianness de la machine, le int est toujours écrit en big-endian (poids fort en premier).
• La ligne suivante incrémente l'index
• Et la dernière décale la valeur vers la gauche pour mettre l'octet suivant en poids fort.

J'avais a peu près compris l'idée qui était de se déplacer dans le tableau pour écrire "case par case", mais pourquoi faire du code hexadécimal.

Et justement le dernier code posté me retourne de l'hexa, comment puis-je le récupérer en int?
J'avoue que j'ai encore beaucoup de mal avec ces concepts :roll:

Merci à toi

Des données brutes, traditionnellement on les affiche en hexa.
Si tu veux relire le int, il te faut faire la procédure inverse :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

int lire_int(char const *buf, size_t taille, size_t *pIndex, int *pValeur) { int i, valeur=0; for(i=0 ; i<4 ; i++) { if((*pIndex) >= taille) return -1; valeur <<= 8; valeur |= (unsigned char)(buf[*pIndex]); (*pIndex)++; } *pValeur = valeur; return 0; }

---

Avec ce code:

Code:

---

1 2 3 4 5

index = 0; int mavaleur; lire_int(buffer, sizeof(buffer), &index, &mavaleur); cout<<"valeur int= "<<mavaleur<<endl;

---

J'obtiens valeur int = 1a90, ce qui n'est pas vraiment ce que l'on attends.
De plus peux tu me dire comment est codé un int en mémoire (sur 4 octets) parce que moi je voyais ça comme une succession de 1 et de 0 (du binaire quoi) qui permet d'aller jusqu'à une valeur décimale de 2 milliard et quelques.

Merci

Il faut remettre cout en décimal, pour commencer.
PS: 0x1A90 est égal à 6800, donc c'est parfaitement ce qu'on attendait.

Bonsoir,

J'ai quasiment compris ton code, pour ça j'ai du réécrire des morceaux pour me démontrer le fonctionnement, et résultat cela fonctionne aussi donc j'en déduis que j'ai bien compris le fonctionnement.

Je crois que je n'aurais vraiment pas su sortir un tel code par moi-même.
Un mot: merci ;)

EDIT: J'en profite: Est ce que tu peux m'expliquer le fonctionnement exact de tes surcharges d'opérateur dans la fonction lire_int?
Merci bien

Bonne soirée

Il n'y a aucune surcharge d'opérateur, c'est du C pur.
C'est le vrai opérateur de décalage de bit <<, >>, <<= et >>=, et non pas les opérateurs surchargés pour les flux C++.

Bonjour,

Et pour celui-ci: |= ?
C'est surtout cette ligne qui me pose problème.
Une autre question le décalage de bit: Quand on décale de 8 vers la gauche est ce que l'on retrouve nos 8 bits tout à gauche (jeu su serpent qui sort d'un coté et ressort de l'autre?) ou alors c'est remplacé par des 0?

Merci bien

a |= b correspond à a = a | b.
Le symbole | représente le OU bit-à-bit, à ne pas confondre avec || qui représente le OU booléen:

• 2 | 4 donne 6
• 2 || 4 donne 1.

Le décalage de bits n'est pas une rotation. Par contre, il me semble que la norme ne garantit pas ce qui est inséré à gauche dans le cas d'une rotation vers la droite de nombre non-signé: Soit c'est des zéros, soit le bit de poids fort est dupliqué.

• Si je fais a = 0x12345678 << 8 (décalage vers la gauche), a vaudra 0x34567800.
• Si je fais a = 0xFEDCBA98 >> 8 (décalage vers la droite), a vaudra 0x00FEDCBA ou 0xFFFEDCBA. Si je précise que la constante est non-signée (en rajoutant un u derrière), alors ce sera forcément la première solution).

Je me souviens que les processeurs 68000 ont deux instructions séparées pour le décalage à droite (et aussi à gauche, mais les deux sont identiques).

Ok merci bien pour les explications. Je pense qu'il faudrait que je m'ecrive sur une feuille une exemple avec un tableau et le OU | parce que j'ai encore du mal à voir les opération (par contre ecrire_int c'est tout bon).

Merci encore pour ton aide :D