Discussion :

[Snooker9]

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 !

[Invité]

Bonjour,
Moi, je ferais un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[3DArchi]

Salut,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

typedef __int16 int16_t;

[Goten]

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)

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 ...

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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>

[3DArchi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

Bien volontiers

Solution1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

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.

[3DArchi]

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

[Invité]

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.

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?

[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

[Invité]

Bonjour Koala,
Voila ce que j'ai écrit

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 :

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

[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 ?

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";

Merci d'avance !

[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

[Snooker9]

Dac j'ai compris !

Merci encore.