afficher en hexa

bonjour tout le monde

Voilà, je dois afficher à l'ecran un nombre entier positif passé en parametre a une procédure AfficherEnBase16 ce nombre devra donc apparaitre en hexa. Pour cela je dois m'aider d'une fonction que j'ai créée précedement qui permet de convertir un nombre en hexa seuleument voilà je ne vois vraimment pas comment afficher ce nombre en hexa j'ai bien trouvé quelques pistes seulement la conversion et a l'envers et je ne peut pas encore utiliser de tableau de chaine de caractére ou autre donc c'est un peu la merde si vous pouvez m'aidez ce serait le pied :)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

#include<iostream>   using namespace std;   char ChiffreVersLettre(unsigned int n) //converti un nombre compris entre 0 et 15 en hexa { if(n<10 && n>0) return (char)(n+48); else return (char)(n+55); }   void AfficherEnBase16(unsigned int n) //affiche un nombre positif quelconque en hexa {   }   int main() { ... return 0; }

---

Pour afficher en base 16, c'est beaucoup plus simple qu'en base 10, puisque tu peux isoler chaque "chiffre" hexa avec un ET binaire. Ensuite, quelques décalages de bits bien placés devraient faire l'affaire:

ex:
chiffre1 = (nombre & 0xF0000000) >>28;
...
chiffre8 = (nombre & 0x0000000F);

à toi d'en faire une boucle...

j'y est pensé mais malheureusement ùême ca je n'ai pas le droit :/

il faut que je trouve un truc en faisant des division successive par 16 je pense mais je ne vois pas comment

Pour ça, il te faut un buffer de caractères (9 devrait suffire pour des long) que tu remplis à l'envers (en commençant par la droite, c'est-à-dire au caractère 7, le caractère 8 étant réservé pour le zéro terminal).

Ainsi, tu commences avec le premier chiffre à droite.
* Tu prends le reste de la division par 16 (nombre % 16) ou (nombre & 0xF) pour obtenir le chiffre hexa (que tu convertis en caractères, et tu le places dans ton buffer)
* Puis tu divises le nombre par 16, pour que le chiffre hexa suivant se retourve en dernier (nombre /= 16) ou (nombre >>= 4).
* Et hop, tu répètes la séquence jusqu'à ce que le nombre soit nul.

(Note: le nombre doit être unsigned pour une conversion en hexa)

je ne peux pas non plus utiliser de tableau :/

Salut,

fais des division successive par 16.

exemple : 572

572 / 16 = 35 reste 12
35 / 16 = 2 reste 3

ton nombre hexa sera : 2 - 3 - ChiffreVersLettre(12)

si tu verifies 2*16^2 + 3*16 + 12 = 572

donc ton algo sera une boucle jusqu'a ce que tu ne puisses plus diviser par 16.

XXiemeciel

oui mais pour le traduire en c++ O_O

je bloque,

Code:

---

1 2 3 4 5 6 7 8 9 10

while(n>0) { int reste;   reste= n%16; n= n/16;   cout << //là je bloque :/ }

---

bonsoir,

Tu n'as pas le droit d'utiliser cout << hex << LEntier ; ???

non c'est trop facile sinon :)

(c'est ce que mon prof m'a dit)

Salut,

scuze je me suis cru dans le forum algorithme quand je t'ai repondu

en C++ ca donnerais ca:

dans mon exemple chiffreEnLettre retourne un string.

Code:

---

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

N = nombre a transformer en hexa R = 0 //reste std::string S = "" //ce sera le resultat en string dans ton cas fais en ce que tu veux   while(N >= 16) { int tmp = (int)(N/16); R = N - tmp*16; S = S + chiffreEnLettre(R); N = tmp; }   S = S + chiffreEnLettre(N); S = inverse(S);

---

XXiemeciel

c'est bien làle problème, je n'ai pas le droit d'utiliser un type string non plus :s

ca fais au moins la troisieme proposition que j'ai faites à mon prof et il ne me les accepte jamais :s

je viens de trouver encore un autre truc, mais là encore je ne sais pas si il va accepter car ca utilise la récurcivitée et comme nous avons jamais vu d'exemple sur la récurrence je sais pas si il va me le prendre :s

Code:

---

1 2 3 4 5 6 7 8 9

void AfficherEnBase16(unsigned int n) { if(n) { AfficherEnBase16(n/16); } cout <<ChiffreVersLettre(n%16); }

---

ta recurrence a l'air bonne, ca devrait fonctionner

XXiemeciel

Inverser les chiffres sans tableau ni chaine... super.
Hum ... Il y a toujours moyen de gruger à partir de la représentation interne non portable du nombre, ou plus simplement en profitant qu'un octet s'écrit toujours sur 2 caractères en hexa:

Code:

---

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

// non testé void affiche16(unsigned char) { .... // même idée que la surcharge suivante, // mais quartet par quartet }   void affiche16(unsigned int N) { const int nb_octets = sizeof(N); for (int n=nb_octets-1 ; n>= 0 ; --n) // attention à ne pas utiliser >=0 avec des unsigned { const unsigned char o = (N >> (8*n)) & 0xff; affiche16(o); } }

---

Faut-il qu'il vous aie parler de masquages et bidouilles sur les bits. Avant les std::string, ça craind un peu.

EDIT: après avoir lu ce qu'avait dit médinoc. Ici, le décalage est une division par le nombre qui va bien, le ET-binaire, un modulo. La convertion se fait très bien. C'est laid, mais possible.

(Au fait: ce n'est pas une récurrence, mais une fonction récursive.)

Le problème majeur est qu'avec des divisions pas 16, on obtient beaucoup plus facilement le dernier chiffre que le premier. Aussi, oui, soit on remplit un tableau à l'envers (ce qui revient à s'en servir comme d'une pile) soit on fait une fonction récursive, ce qui revient à se servir de la pile existante.

Sinon, il y a peut-être des solutions (bien lentes) pour obtenir les chiffres dans le bon ordre sans utiliser de pile, mais c'est bien plus ch***t à coder...

je ne peut pas non plus utiliser sizeof() ni le décalage de bit :/

je vais déja présenter cette nouvelle méthode (fonction résursive) pour voir si là il l'accepte sinon ben je vois plus trop comment faire :/

peut etre en comparant le chiffre a 1 puis si il est plus petit je multiplie par 10 et ainsi de suiste puis diviserai par 10 ce qui me donnerai par exemple (pour 567 1000 que je diviserai par 10 ce qui me donnerai 100) comme ca je pourrai isoler les chiffres des centaines, dizaine etc... mais apres je ne vois pas comment faire

Ho, on parle d'hexa ou de décimal, là ?

d'hexa mais regarde si j'ai un nombre decimal en parametre a convertir en hexa si j'isole tout ses chiffres ce sera peut-être plus simple pour le convertir et l'afficher en hexa non ?

Citation:

---

Envoyé par blastmanu

je ne peut pas non plus utiliser sizeof() ni le décalage de bit :/

je vais déja présenter cette nouvelle méthode (fonction résursive) pour voir si là il l'accepte sinon ben je vois plus trop comment faire :/

---

Moi a ce niveau je chercherais a faire le maximum de propositions repondant au probleme en sachant qu'il les refusera.

Quelque chose comme ceci finira peut-etre par lui plaire.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

void AfficheChiffreHexadecimal(unsigned int c) { assert(c < 16); std::cout << "0123456789ABCDEF"[c]; }   bool AfficheDeuxChiffresHexadecimaux(unsigned int c, bool initial, bool final) { int premier = (c /16) % 16; int second = c % 16; if (!inital || premier != 0) { AfficheChiffreHexadecimal(premier); initial = false; } if (!initial || final || second != 0) { AfficheChiffreHexadecimal(second); initial = false; } return initial; }   bool AfficheQuatreChiffresHexadecimaux(unsigned int, bool initial, bool final) { int premier = (c/256) % 256; int second = c % 256; initial = AfficheDeuxChiffresHexadecimaux(premier, initial, false); initial = AfficheDeuxChiffresHexadecimaux(second, initial, final); return initial; }   void AfficheHuitChiffresHexadecimaux(unsigned int, bool initial) { int premier = (c/65536) % 65536; int second = c % 65536; initial = AfficheQuatreChiffresHexadecimaux(premier, initial, false); initial = AfficheQuatreChiffresHexadecimaux(second, initial, true); }

---

Citation:

---

Envoyé par blastmanu

d'hexa mais regarde si j'ai un nombre decimal en parametre a convertir en hexa si j'isole tout ses chiffres ce sera peut-être plus simple pour le convertir et l'afficher en hexa non ?

---

En aucun cas.
Pour le convertir en hexa, il faut isoler tous ses chiffres hexa: Les chiffres décimaux n'ont plus rien à voir, et sont plus un handicap qu'autre chose: un ordi, basé sur le binaire, compte beaucoup mieux en hexa (2^4) qu'en décimal (2*5, c'est le 5 qui gène)

Si tu as le droit de te servir d'une pile tu stoques tes elements dedans et tu depile pour les avoirs dans le bon sens.

XXiemeciel

Citation:

---

Envoyé par blastmanu

je ne peut pas non plus utiliser sizeof() ni le décalage de bit :/

---

Tu as obligatoirement besoin du sizeof ou son équivalent qui est le nombre max atteignable par un int. J'avais utilisé sizeof pour savoir le nombre de chiffres hexa nécessaires à la représentation d'un int. Tu peux utiliser le nombre magique 8 (2*4) à la place si cela te chante, tu ne pourras pas t'en passer si tu ne peux pas renverser une chaine ou partir dans le récursif.

Pour le décalage de bits, comme signalé, en base 16, un décalage de 8 bits, c'est une division par 256. Un ET-logique avec 0xff, un modulo avec 256.

A mon avis, cela devrait passer -- après réécriture avec / et %...

Citation:

---

Pour le décalage de bits, comme signalé, en base 16, un décalage de 8 bits, c'est une division par 256. Un ET-logique avec 0xff, un modulo avec 256.

---

Vu qu'on parle de bits, en n'importe quelle base, un decalage de 8 bits reviens a une division de 256 (256 exprime en base decimal)... Pareil pour ton modulo...

Par contre en base 16, un decalage de 2 chiffres revient a une division par 256 en base decimal...

Oui. Tout à fait -- a quelle heure j'avais encore posté moi ...?
Je voulais souligner le fait qu'avec la base 16, deux caractères codent exactement 256 valeurs, qui tiennent sur 8 bits, tout ça. Et en y réfléchissant mieux, cela ne change rien si on part sur des divisions, le compilo fera les "optimisations" de lui même.

oyo !

printf() à une option pour écrire en hexadécimal :)

Citation:

---

Envoyé par Bob.Killer

oyo !

printf() à une option pour écrire en hexadécimal :)

---

Les flux C++ aussi. Mais de toute façon c'est hors sujet.

Citation:

---

Envoyé par hegros

bonsoir,

Tu n'as pas le droit d'utiliser cout << hex << LEntier ; ???

---

Citation:

---

Envoyé par blastmanu

non c'est trop facile sinon :)

(c'est ce que mon prof m'a dit)

---