Afficher un int16_t en ASCII

Version imprimable

09/11/2010, 18h38
Snooker9

Afficher un int16_t en ASCII

Bonjour à tous !

J'ai du mal à trouver une méthode propre pour afficher un int16_t en ASCII.

Je m'explique :

Je possède une variable de type int16_t qui contient le code ASCII de 2 caractères. Je souhaite afficher le contenu de cette variable en ASCII.

Exemple :
Ma variable int16_t contient 0x3031.
Je souhaite donc afficher "01".

J'ai bien réussi à faire un truck de bidouilleurs en C pure avec des memcpy ; Mais c'est pas très propre et surtout pas du C++.

Avez vous une idée de la chose ?

Je vous remercie d'avance !

Bonjour,
Moi, je ferais un truc du genre

Code:

1
2
3
4
5
6
7
int ASCII=0x3031;
unsigned char v1=ASCII>>8;
unsigned char v2=ASCII & 0x00FF;
char ASCII_t[3];
ASCII_t[0]=v1;
ASCII_t[1]=v2;
ASCII_t[2]='\0';

C'est bon.

Salut,

Code:

1
2
3
4
5
6
7
8
9
#include <cstdint>
#include <iostream>
int main()
{
    int16_t v=0x3031;
    std::cout<<static_cast<char>((v>>8)&0xFF)<<static_cast<char>(v)<<"\n";
    std::wcout<<static_cast<wchar_t>((v>>8)&0xFF)<<static_cast<wchar_t>(v&0xFF)<<L"\n";
   return 0;
}

Ou de façon plus explicite :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <cstdint>
#include <iostream>
inline uint8_t low_byte(uint16_t v_)
{
    return static_cast<unsigned char>(v_&0xFF);
}
 
inline uint8_t hi_byte(uint16_t v_)
{
    return static_cast<unsigned char>((v_>>8)&0xFF);
}
 
int main()
{
    int16_t v=0x3031;
    std::cout<<static_cast<char>(hi_byte(v))<<static_cast<char>(low_byte(v))<<"\n";
    std::wcout<<static_cast<wchar_t>(hi_byte(v))<<static_cast<wchar_t>(low_byte(v))<<L"\n";
   return 0;
}

10/11/2010, 09h00
koala01
Salut,

Tu pourrais te baser sur cette entrée de la FAQ, et principalement sur les fonctions template qu'elle présente, car elle est adaptée à n'importe quel flux d'entrée / sortie (tu peux donc parfaitement envisager de passer std::cou à write ;).

Il faut cependant être conscient que tu risque d'être confronté à un problème d'organisation des bytes en mémoire, car, comme le font apparaitre les codes présentés par mes honorable confrères, la partie "0x30" trouve place dans... le deuxième byte de ton (u)int16_t.

Cependant, étant donné que (u)int16_t est un type primitif représentant
- une valeur numérique, j'envisage (mais je peux en oublier) trois trois manières possibles dont on pourrait en effectuer l'affichage:
- sous la forme du caractère représentant chaque byte de la valeur (un peu à la manière des éditeurs hexadécimaux)
- sous la forme de la valeur qu'il représente, que ce soit en décimal, en hexadécimal ou en binaire
- éventuellement sous la forme d'un "caractère multybyte"
A mon sens, la position des bytes en mémoire n'aura donc que peu d'importance, vu que le système interprétera correctement la valeur ;)
10/11/2010, 14h15
Invité

Bonjour,
Pour un exercice de style, la méthode donnée par 3DAchi est parfaite, par contre, pour un traitement le code donné en première réponse est deux fois plus rapide. (soit 655274 passages contre 318667 en 10 secondes)
Par ailleurs, le type int16_t est défini dans stdint.h

Code:

typedef __int16 int16_t;
10/11/2010, 14h30
Goten

Citation:

Envoyé par Pierre Dolez

Bonjour,
Pour un exercice de style, la méthode donnée par 3DAchi est parfaite, par contre, pour un traitement le code donné en première réponse est deux fois plus rapide. (soit 655274 passages contre 318667 en 10 secondes)

Citation:

Je possède une variable de type int16_t qui contient le code ASCII de 2 caractères. Je souhaite afficher le contenu de cette variable en ASCII.

Le PO parle d'afficher ...

Citation:

Envoyé par Pierre Dolez

Par ailleurs, le type int16_t est défini dans stdint.h

Code:

typedef __int16 int16_t;

Les entêtes standards en *.h sont deprecated en C++ et remplacés par un fichier commençant par un 'c' et sans le .h ie :
<stdint.h> => <cstdint>
10/11/2010, 17h53
3DArchi

Citation:

Envoyé par Pierre Dolez

Bonjour,
Pour un exercice de style, la méthode donnée par 3DAchi est parfaite, par contre, pour un traitement le code donné en première réponse est deux fois plus rapide. (soit 655274 passages contre 318667 en 10 secondes)
Par ailleurs, le type int16_t est défini dans stdint.h

Code:

typedef __int16 int16_t;

On pourrait voir l'intégralité du code utilisé pour le bench (les 2 codes). Bench en mode release, j'imagine ;).

Hormis ces petits détails, chercher les performances dans de l'affichage c'est un peu contradictoire ;)

Bien volontiers

Solution1
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 int main() { int ASCII=0x3031; clock_t start, end; start = clock(); unsigned long Compte=0; char ASCII_t[3]; do { unsigned char v1=ASCII>>8; unsigned char v2=ASCII & 0x00FF; char ASCII_t[3]; ASCII_t[0]=v1; ASCII_t[1]=v2; ASCII_t[2]='\n'; write(1, ASCII_t, 3); end = clock(); Compte++; } while ( ((end - start) / CLK_TCK) < 10); // 10 secondes printf(" Compte = %d pour 10 S.\n", Compte); system("Pause"); return 0; }
Solution 2
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 int main() { int16_t v=0x3031; clock_t start, end; start = clock(); unsigned long Compte=0; do { std::cout<<static_cast<char>((v>>8)&0xFF)<<static_cast<char>(v)<<"\n"; end = clock(); Compte++; } while ( ((end - start) / CLK_TCK) < 10); // 10 secondes printf(" Compte = %d pour 10 S.\n", Compte); system("Pause"); return 0; }
Citation:

Hormis ces petits détails, chercher les performances dans de l'affichage c'est un peu contradictoire

Je ne cherche rien. Simplement j'ai voulu me rendre compte des différences de temps d'exécution, et cela m'a paru intéressant de donner l'information.
Il y a lieu de remarquer que dans les 2 traitements, il y a une constante (appel à clock(), test de délai et impression), identique dans les 2 traitements.

10/11/2010, 20h16
3DArchi

:hola:
Tu prouves que write est plus performant que std::cout :mrgreen: Comment en faisant varier plusieurs paramètres de comparaison, peux-tu dire celui qui est discriminant :koi: Et les sorties consoles restent toujours aléatoires pour les mesures de perfs ;). Tes mesures étaient bien en release et pas en debug ?
10/11/2010, 23h35
Invité

Citation:

Tu prouves que write est plus performant que std::cout

Oh, moi je prouve rien.
J'exécute 2 codes qui font le même chose, j'informe, et puis c'est tout.
Chacun fait comme il veut, chacun donne les informations qu'il constate, il s'agit d'un forum, et pas d'une tribune.
Je n'ai rien dit, j'ai juste donné des résultats. Je n'en tire d'ailleurs aucune conclusion.

Si on veut être plus précis, on peut toujours exécuter ce code, sans aucun traitement, seulement le comptage et le calcul des 10 s., noter le nombre de passages, c'est à dire la partie fixe et commune aux deux traitements, par une simple soustraction, on en déduira la différence réelle entre les deux type de traitements.

Citation:

Tes mesures étaient bien en release et pas en debug ?

J'ai fait l'exécution plusieurs fois en "release" avec 10s et 5s.
Le bon moyen est de le faire vous-même.
Moi, ça m'est complètement égal, j'ai proposé un code, vous en avez proposé un autre (au passage vous m'avez mis une note négative) que voulez- vous que je vous dise de plus?
10/11/2010, 23h43
koala01

Ce que 3DArchi exprime à juste titre, c'est que tu manipule d'un coté une fonction write et de l'autre un flux de sortie, tous deux pris en compte dans le temps que dure ton test.

Tu peux donc, au mieux, déduire de write est plus efficace que l'utilisation de cout, mais tu ne peux en aucun cas déduire que ton code en vue de convertir la valeur de l'int16_t soit plus efficace.

On ne juge pas le code en lui-même, on juge la conclusion que tu en tire, car elle n'est absolument pas fondée
11/11/2010, 11h27
Invité

Bonjour Koala,
Voila ce que j'ai écrit

Citation:

Je n'ai rien dit, j'ai juste donné des résultats. Je n'en tire d'ailleurs aucune conclusion.

Et voilà ce que vous me répondez :

Citation:

On ne juge pas le code en lui-même, on juge la conclusion que tu en tire, car elle n'est absolument pas fondée
11/11/2010, 21h46
Snooker9

Bon, malgré cette petite querelle, je vous remercie tous pour avoir répondu à ma question.

Problème résolu !

Par contre, pouvez vous m'expliquer la différence entre ces deux lignes ?

Citation:

std::cout<<static_cast<char>((v>>8)&0xFF)<<static_cast<char>(v)<<"\n";

Citation:

std::wcout<<static_cast<wchar_t>((v>>8)&0xFF)<<static_cast<wchar_t>(v&0xFF)<<L"\n";

Merci d'avance !
12/11/2010, 10h08
3DArchi

Salut,
CF F.A.Q. : Comment manipuler des chaînes de caractères Unicode ?
En gros :
> std::string (qui n'est jamais qu'un std::basic_string<char>) + std::cout => ANSI
> std::wstring (qui n'est jamais qu'un std::basic_string<wchar_t>) + std::wcout => unicode
14/11/2010, 17h24
Snooker9

Dac j'ai compris !

Merci encore.