Binaire en entier.

Version imprimable

Binaire en entier.

Bonsoir,

J'ai une valeur binaire composée de six bits, enregistré sur un octet, que je voudrais convertir en entier.

alors, que pensez vous si je fais ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int intValue; typedef struct scom { unsigned char bit1 : 1; unsigned char bit2 : 1; unsigned char bit3 : 1; unsigned char bit4 : 1; unsigned char bit5 : 1; unsigned char bit6 : 1; } var1; var1 var; intValue = var.bit1 + var.bit2 * 2 + var.bit3 * 4 + var.bit4 * 8 + var.bit5 * 16 + var.bit6 * 32;
Comment arriver à avoir la valeur de chaque bit afin de pouvoir utiliser l'expression :
intValue = var.bit1 + var.bit2 * 2 + var.bit3 * 4 + var.bit4 * 8 + var.bit5 * 16 + var.bit6 * 32

merci à vous d m'aider.

Ce code a l'air de fonctionner :

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
#include <stdio.h>
#include <string.h>
 
int main (void)
{
  union u
  {
    unsigned int valeur;
 
    struct
    {
      unsigned int b0:1;
      unsigned int b1:1;
      unsigned int b2:1;
      unsigned int b3:1;
      unsigned int b4:1;
      unsigned int b5:1;
    } bits;
  };
 
  union u test;
 
  memset(&test, 0, sizeof(test));
  test.bits.b5 = 1;
  printf("%u\n", test.valeur);
 
  return 0;
}

16/07/2008, 23h37
bulki
Je comprends pas trop pourquoi tu n'écris pas directement le nombre, le cpu va s'occuper de faire le calcul pour toi...
Code:

1 2 3 uint8 locByte = 0x98; //0y10011000 printf("%#x", locByte);
Si vraiment tu veux absolument avoir la valeur de chaque bit, fais un truc genre:
Code:

1 2 3 4 5 6 7 unsigned i; uint8 locByte = 0x98; //0y10011000 for (i = 0; i < 8; i++) { printf("valeur du bit %d est %x", i, locByte & 0x1); locByte >> 1: }
Btw les union bitfields sont peu utilisés, à moins que tu doives écrire du code qui doit optimiser la place mémoire.

Citation:

Envoyé par dapounet

Ce code a l'air de fonctionner :

Ca fonctionne par hasard. Ce n'est pas garanti par le langage. Avec un autre compilateur, une autre machine, une autre option, ça pourrait ne pas fonctionner. La bonne solution est de placer les bits un par un dans un entier non signé.
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 struct { unsigned int b0:1; unsigned int b1:1; unsigned int b2:1; unsigned int b3:1; unsigned int b4:1; unsigned int b5:1; } bits; bits.b0 = 0; bits.b1 = 1; bits.b2 = 0; bits.b3 = 1; bits.b4 = 0; bits.b5 = 1; unsigned data = 0; data |= (bits.b0 << 0); data |= (bits.b1 << 1); data |= (bits.b2 << 2); data |= (bits.b3 << 3); data |= (bits.b4 << 4); data |= (bits.b5 << 5);

Bonsoir tlm et merci pour vos réponses.....
Citation:
Envoyé par Emmanuel Delahaye
Code:

1 2 3 4 5 6 7 8 bits.b0 = 0; bits.b1 = 1; bits.b2 = 0; bits.b3 = 1; bits.b4 = 0; bits.b5 = 1;
en fait, le mot dont j voudrais acceder aux bits est de type char et est le paramètre d'une fonction et sortie d'une autre fonction.......je n connais donc pas la valeur d ses bits au préalable..Comment avoir les valeurs de ces bits??...et dans cette fonction en question, je veux transformer la valeur d la donnée type char en entier..., voilà c que j'ai essayé d faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 char in_car; int intValue; struct { unsigned char b0:1; unsigned char b1:1; unsigned char b2:1; unsigned char b3:1; unsigned char b4:1; unsigned char b5:1; } bits; bits.bit0 = get (in_car, 1); bits.bit1 = get (in_car, 2); bits.bit2 = get (in_car, 3); bits.bit3 = get (in_car, 4); bits.bit4 = get (in_car, 5); bits.bit5 = get (in_car, 6); intValue = bits.bit0 + bits.bit1 * 2 + bits.bit2 * 4 + bits.bit3 * 8 + bits.bit4 * 16 + bits.bit5 * 32
....mais ça marche pas.....que pensez vous de l'utilisation d la fct : get ?....

j'essayerai d'en tirer des choses de vos suggestions aussi,

Merci à vous d m'aider encore une fois...

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
 
	int intValue;
	 struct
		{
		  unsigned char b0:1;
		  unsigned char b1:1;
		  unsigned char b2:1;
		  unsigned char b3:1;
		  unsigned char b4:1;
		  unsigned char b5:1;
		} bits;
/* Lecture des bits: */	 
	bits.b0 = ((in_car&(1<<0))>>0);
	bits.b1 = ((in_car&(1<<1))>>1);
	bits.b2 = ((in_car&(1<<2))>>2);
	bits.b3 = ((in_car&(1<<3))>>3);
	bits.b4 = ((in_car&(1<<4))>>4);
	bits.b5 = ((in_car&(1<<5))>>5);
/* conversion de l'entier: */	
	intValue = (int)(in_car&0x3F);
/* autre solution: */
	intValue = 0;
	intValue |= (bits.b0 << 0);
	intValue |= (bits.b1 << 1);
	intValue |= (bits.b2 << 2);
	intValue |= (bits.b3 << 3);
	intValue |= (bits.b4 << 4);
	intValue |= (bits.b5 << 5);

21/07/2008, 23h24
Clopinet85

Bonsoir ,

Je voudrais savoir s'il y a pas un problème d'affectation qui va se poser vu que :

intValue est de type int mais pas bits.bit0 par exple..................non?
21/07/2008, 23h34
wiztricks

Citation:

Envoyé par Clopinet85

Bonsoir ,

Je voudrais savoir s'il y a pas un problème d'affectation qui va se poser vu que :

intValue est de type int mais pas bits.bit0 par exple..................non?

la magie de l'union fait qu'on peut utiliser "l'emplacement" mémoire comme un entier ou comme un tableau de bits. Donc on remplit l'emplacement comme on veut.
- W
22/07/2008, 10h11
Thierry Chappuis

Citation:

Envoyé par wiztricks

la magie de l'union fait qu'on peut utiliser "l'emplacement" mémoire comme un entier ou comme un tableau de bits. Donc on remplit l'emplacement comme on veut.
- W

Sauf que ce n'est absolument pas portable. Une solution portable a été donnée plus haut.

Thierry
22/07/2008, 18h55
wiztricks

Citation:

Envoyé par Thierry Chappuis

Sauf que ce n'est absolument pas portable. Une solution portable a été donnée plus haut.
Thierry

Je suis d'accord et cela a déjà été dit mais est-ce que la portabilité est un aspect important dans ce que souhaite faire l'auteur du post?
- W