Discussion :

[Irene - 1]

Bonjour,

J'ai deux séquences de 64 bits en hexa que j'ai codé dans des variables de type unsigned long long int.

En entrée je réçois des données de type unsigned char que je voudrais convertir en unsigned long long int afin de comparer la valeur hexadécimal que je reçois en entrée avec les deux séquences fixées précedement.

Comment convertir unsigned char en unsigned long long int?

Merci en avance pour votre aide,

Irene

[Médinoc]

Tu veux dire des suites de unsigned char, ou juste un unsigned char à comparer (je ne sais pas comment) à des unsigned long long int ?

[Irene - 1]

Au fait j'ai un flux de données qui arrive (je code un block pour GNU Radio) au format unsigned char donc mon but était de convertir chaque unsigned char en unsigned long long int, puis décaler les données et venir y "concatener" chaque unsigned char converti.

Le code en python ressemble à ceci (sauf que là j'avais pas des questions à me poser concernant le type des données) :

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
 
Frame_1 = 0x F3 FF 01 C6 A6 51 0F 95
Frame_2 = 0x 33 AA 55 C6 65 9A 0C 59
 
Sequence = 0
 
for i in range(...):
   Byte = arrTxt[i]                              # arrTxt = données en entrée 
   for j in range (8):
      b0 = ((Byte >> (7-j)) & 0x1)
      Sequence ((Sequence << 1)+ b0) & 0xFFFFFFFFFFFFFFFF
      if (Sequence == Frame_1):
         # Frame 1 a été retrouvé
      if(Sequence == Frame_2):
         # Frame 2 a été retrouvé

Je cherche à coder ça en c++.

[Irene - 1]

Une solution à laquelle j'ai pensé ce serait de récupérer la valeur hexadécimale des caractères non signés et la stocker dans une variable de type unsigned long long int.

Quel est l'équivalent de la fonction python ord(char) en c++?
Comment récupérer la valeur hexadécimale d'un caractère?

[Tymk]

La valeur hexa du caractere tu l'as deja. C'est avec elle que le programme manipule ton caractere.

J'imagine que ton probleme c'est d'afficher ce caractere en hexa. C'est a dire, d'empecher le programme de te le traduire a l'aide de la table ASCII.

Je te donne la fonction que j'utilise :

Code :

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

1
2
3
4
5
6
7
8
string bin2str(uint8_t data)
{
    ostringstream oss;
    oss << hex << (int) data;
    string str = oss.str();
    if(str.size() == 1) str = "0" + str;
    return str;
}

Avec un petit tour dans la FAQ tu devrais avoir une explication sur ce code. Sinon je repasserais.

[tnarol]

Le caractère correspond à un nombre codée sur 8 bits entre 0 et 255, donc finalement il n'y a pas vraiment à "récupérer" sa valeur hexadécimale car c'est exactement la même chose que la valeur entre 0 et 255.

Là tu veux apparemment comparer des suites de valeurs hexadécimales pour savoir si tu trouves des motifs particuliers ce qui équivaut à comparer des chaines de caractères.

Il y a plein de façons différentes de faire, si on suit ton idée qui consiste à créer et comparer des nombres unsigned long long int, il faut utiliser les décalages de bits :

Si je ne me trompe pas :

le nombre unsigned long long = (unsigned long long)1er caractère << 56 + (unsigned long long)2eme caractère << 48 + ... + (unsigned long long)7ème caractère << 8 + (unsigned long long)8ème caractère

Sinon on peut aussi créer un tableau de char :

char tab[9];
tab[0] = 1er caractère
...
tab[7] = 8ème caractère
tab[8] = '\0'

et utiliser les fonctions de comparaison de chaines de caractère.

[Irene - 1]

J'ai vu ce code sur d'autres forums, mais j'ai lu que le fait d'utiliser ostringstream ralentit extrèmement (à confirmer vu que je m'y connais pas personnellement) et j'ai des fortes contraintes temps-réel vu qu'il s'agit de traiter un flux.

Par ailleurs les séquences que je recherche sont constituées de 64 bits non signés donc je pense que le fait d'utiliser le type de variable 'string' n'est pas possible c'est pourquoi j'utilise des unsigned long long int. (Je suis ouverte à d'autres solutions si quequ'un a une autre idée).

Par contre les données réçues se trouvent au format 'unsigned char'. Je voulais récupérer la valeur hexadécimale en sorte à la stocker sous forme d'un unsigned long long int afin de pouvoir la comparer avec les séquences de 64 bits dont je vous parlais.

[Médinoc]

Je pense que le mieux est de faire comme en python : Un unsigned long long pour accumuler, des décalages de bit et un OU logique.

[Irene - 1]

Là tu veux apparemment comparer des suites de valeurs hexadécimales pour savoir si tu trouves des motifs particuliers ce qui équivaut à comparer des chaines de caractères.

Tout à fait.

Le caractère correspond à un nombre codée sur 8 bits entre 0 et 255, donc finalement il n'y a pas vraiment à "récupérer" sa valeur hexadécimale car c'est exactement la même chose que la valeur entre 0 et 255.

Je suis d'accord. Par contre (corrige-moi si je dis des betisses parce que c'est vraiment pas clair dans mon esprit), supposons un truc dans le genre :

Code :

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

1
2
3
4
5
6
7
 
unsigned long long int frame = 0x556F58AC...;
unsigned char = "t";
unsigned long long test = char;
 
if (test == frame)
...

Il y a quand même un problème de type de données :

unsigned long long test = char;

J'aurai une erreur du genre 'ne peut pas convertir char en unsigned long long int' même si char = un entier entre 0 et 255.

[wiztricks]

Bonsoir,
écrire plutôt cela:

Code :

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

1
2
3
4
5
6
7
 
unsigned long long int frame = 0x556F58AC...;
unsigned char ch = 't';
unsigned long long test = 't' ;
 
if (test == frame)
...

-W

[Irene - 1]

Je pense que le mieux est de faire comme en python : Un unsigned long long pour accumuler, des décalages de bit et un OU logique.

A ce moment là je me pose toujours la même question :

Les séquences de 64 bits que je veux retrouver je les déclare comme :

Code :

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

1
2
 
unsigned long long int frame = 0x....;

Par contre le flux en entrée je le récupère de la manière suivante :

Code :

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

1
2
 
const unsigned char *in = (const unsigned char *) input_items[0];

donc si je me trompes pas, chaque char réçu je le récupère ainsi :

Code :

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

1
2
3
4
5
 
for (i = 0; i < ...; i++)
{
   unsigned char car = in[i];
}

En suite je passe par une variable intermédiaire "Sequence" comme dans le code en python où j'accumule les données réçues en décalant les bits. Pour pouvoir la comparer avec les séquences recherchées le format des données doit être le même (unsigned long long int).

Autrement dit, comment passer de car (unsigned char) à Sequence (unsigned long long int) afin de comparer à ce moment là deux valeurs hexadécimales?

[tnarol]

Tout à fait.
J'aurai une erreur du genre 'ne peut pas convertir char en unsigned long long int' même si char = un entier entre 0 et 255.

Tout à fait c'est pour ça que j'ai ajouté des "casts" en unsigned long long des caractères matérialisés par "(unsigned long long)" devant chaque caractère :

celà indique au compilateur d'interpréter la caractère comme un unsigned long long :

si tu as un char c qui vaut 0x5F (sur 8 bits)
alors (unsigned long long)c vaut 0x000000000000005F
et (unsigned long long)c << 56 vaut 0x5F00000000000000

si tu as un autre char c2 qui vaut 0x4A
alors (unsigned long long)c2 vaut 0x000000000000004A
et (unsigned long long)c2 << 48 vaut 0x004A000000000000

et la somme des deux (ou bien le "OU" logique |) fait 0x5F4A000000000000

ainsi de suite tu construis ta séquence de 64 bits ...

mais sinon il y a encore plus simple par rapport au code que tu as posté. Si input_items[] est comme il se doit un tableau d'au moins 8 char alors tu as directement ton nombre en faisant :

unsigned long long resultat = *((unsigned long long*)(&input_items[0]));

&input_items[0] te donne l'adresse du premier des 8 octets
(unsigned long long*) interprète cette adresse comme un pointeur d'un nombre sur 8 octets
et enfin le * donne la valeur contenue à cette adresse.

[wiztricks]

Ca pourrait être qqc comme:

Code :

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

1
2
3
4
5
6
sequence = 0;
for (i = 0; i <  8 ; i++)
{
    sequence <<= 8;     // je décale
    sequence += in[i];   // j'accumule.
}

-W

[koala01]

Salut,

Pourquoi, tout simplement, ne pas utiliser une union

je ne sais pas, un truc du genre de

Code :

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

1
2
3
4
5
union myUnion
{
    unsigned char tabchar[8];
    unsigned long long my64;
};

Quand tu reçois te unsigned char, tu les fais entrer, à la position qui leur correspond, par tabchar[i], et, quand tu veux réobtenir ta valeur sous la forme d'un unsigned long long, tu la récupère dans my64

[EDIT]pour la précision, cela donnerait quelque chose comme

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
int main()
{
    myUnion mu;
    /* récupération des unsigned char */
    for(size_t i= 0 ; i<8; ++i)
    {
        unsigned char c;
        /* tu récupère ton unsigned char où tu veux ;) */
        mu[i]=c;
    }
    /* pour travailler avec ton unsigned long long */
    mu.my64 /* que faire de lui :P) */
 
    /*...*/
    return 0;
}

[Montag]

Salut,

Pourquoi, tout simplement, ne pas utiliser une union

je ne sais pas, un truc du genre de

Code :

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

1
2
3
4
5
union myUnion
{
    unsigned char tabchar[8];
    unsigned long long my64;
};

Quand tu reçois te unsigned char, tu les fais entrer, à la position qui leur correspond, par tabchar[i], et, quand tu veux réobtenir ta valeur sous la forme d'un unsigned long long, tu la récupère dans my64

[EDIT]pour la précision, cela donnerait quelque chose comme

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
int main()
{
    myUnion mu;
    /* récupération des unsigned char */
    for(size_t i= 0 ; i<8; ++i)
    {
        unsigned char c;
        /* tu récupère ton unsigned char où tu veux ;) */
        mu[i]=c;
    }
    /* pour travailler avec ton unsigned long long */
    mu.my64 /* que faire de lui :P) */
 
    /*...*/
    return 0;
}

Sauf que d'après cette discussion (http://www.developpez.net/forums/sho...d.php?t=513797) la solution que tu proposes a un comportement indéterminé.

[koala01]

Attention, la solution n'a absolument pas un comportement indéterminé, étant donné qu'il s'agit de travailler avec des entiers...

Par contre, ce qui est possible (vraisemblable, risqué), c'est que tu te trouve confronté à un problème de boutisme

Autrement, c'est bel et bien le but et le rôle des unions que de permettre de faire correspondre une seule et même adresse mémoire à plusieurs types de données différents

[EDIT]en fait, le problème de comportement indéfini apparait si tu envisage l'union pour faire correspondre un certain nombre de char's qui ne sont pas *forcément* fournis dans le but de correspondre à un réel avec une valeur interprétée sous la forme de réel (float ou double) du fait que l'on ne peut jamais s'assurer des positions et des tailles utilisées pour les exposants et mantisses...

Pour ce qu'il en est de la mise en concordance entre valeurs entières (de char vers int, long, long long), les seules inconnues qui peuvent valoir des surprises est le boutisme utilisé et l'ordre dans lequel les caractères auront été envoyés

[Médinoc]

Avec un problème de boutisme, le comportement n'est donc pas déterminé par la norme.
Mais normalement, il est déterminé par la plate-forme, il n'est donc pas "indéterminé".

[koala01]

Avec un problème de boutisme, le comportement n'est donc pas déterminé par la norme.
Mais normalement, il est déterminé par la plate-forme, il n'est donc pas "indéterminé".

En plus... ce qui tend à confirmer que la solution est viable s'il s'agit de travailler sur des entiers...

Il n'est donc effectivement pas exclu que tu doive envisager une adaptation en vue de faire correspondre l'ordre dans lequel tu reçois les variables au boutisme, mais cela reste du domaine du "facilement gérable"

[Montag]

Vous avez sans doute raison mais alors pourquoi dans ce post (http://www.developpez.net/forums/sho...4&postcount=18) Jean-Marc Bourguet évoque un comportement indéterminé ?

[koala01]

Vous avez sans doute raison mais alors pourquoi dans ce post (http://www.developpez.net/forums/sho...4&postcount=18) Jean-Marc Bourguet évoque un comportement indéterminé ?

Tu remarquera qu'il a écrit "je crois" que le comportement est indéterminé...

Cependant, tu as eu le dont de me faire me questionner sur les unions, et j'ai donc décidé de vérifier ce qu'en dit la norme...

En gros, elle interdit juste d'essayer de travailler sur plus d'un champs de l'union à la fois.

Ainsi, tu ne pourrais pas envisager quelque chose comme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
union MyUnion
{
    char chartab[8];
    long long mylong;
}
 
void foo()
{
    MyUnion u;
    u.chartab[1]=0xff,u.mylong=0xFAFAFAFAFAFA;
}

Pour le reste, il n'y a pas grand chose de nouveau:
le chapitre 9.5 signale que:

• la taille de l'union correspond à la taille du champs le plus long (et c'est préférable )
• les différents champs d'une union peuvent etre des POD
• une union peut contenir des fonctions qui ne peuvent pas être virtuelles
• une union ne peut pas servir de classe de base pour un héritage
• une union ne peut contenir une classe (ou une structure) dont l'un des "big four" ne serait pas trivial
• si une union contient un champs static, le programme est mal formé

En dehors du chapitre 9.5 qui est particulièrement réservé aux unions, on trouve des références

• au chapite 3.5 qui précise qu'un nom ayant une portée d'espace de noms subira une liaison des données interne s'il s'agit d'un champs d'une union anonyme
• au chapitre 3.9.10 qui indique que les types scalaires, les structurees-POD, les unions-POD et les tableaux sont appelés de manière commune "types POD"
• au chapitre 3.9.2 qui explique ce que sont les type composés
• au chapitre 3.10 qui parle des rvalue et lvalue et qui en dit que,
  
  

  si un programme essaye d'accéder à une valeur au travers d'une rvalue autrement que par
  

  • un type dynamique de l'objet
  • une version CV qualifiée du type dynamique de l'objet
  • un type signé ou non signé correspondant au type dynamique de l'objet
  • un type signé ou non signé correspondant à la version CV qualifié du type dynamique de l'objet
  • un agrégat ou une union qui comprend un de ces types parmi ces membres
  • (...)

  
  il aura un comportement indéfini

• de ci de là quand elle aborde le problème des références, ou pour signaler que ce qu'elle appelle les "class objects" peuvent être des unons

Autrement dit, un comportement proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
union myUnion
{
    unsigned char tabchar[8];
    unsigned long long my64;
};
void foo()
{
    myUnion myu;
    /*...*/
    unsigned long long monentierlong;
    monentierlong= myu.my64;
}

n'est absolument pas indéfini