Discussion :

[SybVicious]

Bonjour,

voila la question que je me pose : j'ai un tableau d'entiers sur 16 bits contenant 2 éléments que j'ai déclaré comme ci dessous :

T_Uint16 donnees[2];

T_Uint16 étant bien entendu un type que j'ai défini auparavant.

Je voulais savoir comment regrouper les 2 éléments du tableau en un entier de 32 bits? Afin de pouvoir manipuler l'entier de 32 bits.
Dois-je faire une structure? ou une simple addition suffit-elle?

par exemple : donnees[0]+donnees[1] ?

Merci d'avance de votre aide, en esperant avoir été assez clair!

[Franck.H]

Je voulais savoir comment regrouper les 2 éléments du tableau en un entier de 32 bits? Afin de pouvoir manipuler l'entier de 32 bits.
Dois-je faire une structure? ou une simple addition suffit-elle?

par exemple : donnees[0]+donnees[1] ?

Salut !


Ce que tu veux faire en fait, c'est une concaténation de deux entier c'est ca ? Si c'est le cas (en adméttant que tu dispose d'un type T_Uint32):

Code :

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

T_Uint32 resultat = 10 * donnees[0] + donnees[1];

[valefor]

Tu peux faire une union

Code :

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

1
2
3
4
5
 
union{
T_Uint32 _raw;
T_Uint16 _tab[2];
};

Mais attention à l'endianess. Suivant si tu es sur une machine en little ou en big, _tab[0] sera le LSB ou le MSB respectivement !

[aoyou]

Bonjour,

donnees[0] * pow (2, 16) +donnees[1]

si donnees[0] représente les bits de poids fort par exemple
et si tu te tiens à cette représentation des données (poids fort puis poids faible). A voir.

Mais je me demande bien ce que tu veux faire avec ça.

[scr]

Tu peux directement calculer la somme dans un entier 32 bits.

Par contre il faut utiliser un cast pour que la somme soit calculée sur 32 bits

Code :

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

1
2
3
 
DWORD x;
x=((DWORD)donnees[0])+donnees[1];

[Franck.H]

Mais je me demande bien ce que tu veux faire avec ça.

En fait, il dispose de deux entiers 16bits et veux en faire un entier 32bits, un peut comme on à la séparation des données dans un registre processeur par exemple. Donc à mon avis ce qu'il veut faire c'est une concaténation des deux données.

Exemple: Si tu as donnees[0] = 5 et donnees[1] = 9, le but est de fait un entier 32bits qui vaut 59

[aoyou]

Alors, dans ce cas, multiplier par 10 donnees[0] ne résoud pas le problème.
Si donnees [1] vaut 99, je n'aurais pas 599 mais 149.

Attendons que SybVicious nous donne un exemple de ce qu'il veut faire car au vue de la multiplicité des réponses, il y a plusieurs interprétations possibles.

[Franck.H]

Alors, dans ce cas, multiplier par 10 donnees[0] ne résoud pas le problème.
Si donnees [1] vaut 99, je n'aurais pas 599 mais 149.

Oui c'est vrai que j'ai donné un exemple très simpliste mais j'avais oublié de préciser que si donnee[0] par exemple possède une valeur supérieure ou égale à 10, tu multiplies alors par 100 et non pas 10 et ainsi de suite

Maintenant s'il y a plus élégant... ma méthode n'est peut-être pas la plus pratique suivant les cas

[SybVicious]

Bonjour,
deja merci a tous de votre aide!
je vais essayer detre plus précis:
en fait je recupere des données (en l'occurence un compteur) qui est sur 32 bits. Seulement, les données que je récupère sont, comme vous l'avez compris séparés en 2 éléments de tableau de 16 bits. Imaginons que mes donnees soient les suivantes :

donnees[0]=0000 0101 1000 0100
donnees[1]=0100 1100 0000 1000

j'aimerais récuperer un entier sur 32 bits et pouvoir le manipuler dont la valeur est la suivante:

T_Uint32 = 0000 0101 1000 0100 0100 1100 0000 1000

je pense que l'union est la bonne solution? ou la reponse de aoyou me semble appropriée également
qu'en pensez vous ?
Merci!!!

[scr]

oui les deux solutions fonctionnent.

il me semble quand même qu'un cast est nécessaire pour la solution de aoyou

pow (2, 16) peut être remplacé par 0xFFFF plutot que de le recalculer a chaque fois

oups petite correction :

pow (2, 16) peut être remplacé par 0xFF et non 0xFFFF

oups encore n'importe quoi

pow (2,16) = 0x100 et non 0xFF

[aoyou]

Oui, ce sera plus efficace.

L'opérateur << l'est peut-être encore plus.

Code :

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

1
2
3
4
 
uint16_t a = 12;
uint16_t b = 24;
uint32_t c = (a << 16) + b;

Compile sans warning avec gcc sous Linux et Windows.

[scr]

oui effectivement l'opérateur est plus efficace

pas besoin de caster alors ?

[scr]

En effet pas besoin de caster je viens de tester.

Je retire toutes les conneries que j'ai raconté...

Il aurait fallu multiplier par 0x100 et non 0xFF

Désolé

[SybVicious]

merci beaucoup, je pense que je vais utiliser l'opérateur << qui me semble le plus simple et le plus efficace!
merci de votre aide!!!