Obtenir l'etat des bits qui composent un octet (conversion xx->binaire)

Commenter

Contenu du snippet

J'ai regardé très rapidement si la source n'existait pas et je ne l'ai pas trouvé.
Je précise que c'est une astuce que je viens d'apprendre en cours.
En utilisant "Les champs de bits" et une union, nous pouvons très simplement obtenir l'état des bits qui composent un octet... mais pourquoi pas un int en modifiant un peu le code.
Les champs de bits :
Pour se qui ne connaisse pas, ils permettent de limiter la place occupé en mémoire d'une variable si tous ces bits ne sont pas utilisés.
Pour représenter cela il suffit de mettre après le nom de la variable :nombre_bit
Par exemple, int état:1; //ici l'int ne fera pas 32bits mais qu'un seul, les valeurs max et min de etat seront donc -1 ou 0
union
A la différence d'un struct, les éléments contenus dans une union sont contenu au même emplacement mémoire
(La structure les met à la suite dans la mémoire)
Je me doute que se n'ai pas très clair un exemple:
struct _test{
int a;
unsigned char b;
}
Ici la structure occupera 5octets en mémoire (sizeof(int)=4octets et sizeof(char)=1octet)

union _test2{
int a;
unsigned char b;
}test2;
Ici sizeof(test2)=4octet
si
test2.a=0xFDE8; //valeur prise au hasard
Alors
b=0xE8;

Schéma de la mémoire:

structure union
|-----------| |-----------|
| | | |
| a | | a et b |
| | | |
|-----------| |-----------|
| b |
|-----------|

J?espère que c'est clair.
Revenons au but...créer une union entre un caractère et une structure et lire la structure pour avoir l'état des bits, regardez le code.

Les champs de bits ne sont pas toujours obligatoires.
Autre utilisation de l'union :
#include <stdio.h>

union _ip{
unsigned char membres[4]; //Les 4 membres qui compose une adresse IP
unsigned int adIp; //L'adresse IP au complet
}ip;

main()
{
printf("saisir une adresse ip en hexa :");
scanf("%x",&ip.adIp); //Saisie en hexa de l'adresse ip au complet

printf("l'adresse ip est : %03d.%03d.%03d.%03d\n"
,ip.membres[3],ip.membres[2],ip.membres[1],ip.membres[0]); //Attention a l'ordre,il est inversé
}

Source / Exemple : 


#include <stdio.h>

typedef unsigned char uchar;	//evite de récrire le tout

/*Ma structure qui contiendra l'etat de chacun des bit qui compose un char*/
typedef struct{
	uchar b0:1;		//Poid faible
	uchar b1:1;
	uchar b2:1;
	uchar b3:1;
	uchar b4:1;
	uchar b5:1;
	uchar b6:1;
	uchar b7:1;		//Poid fort
}octet;

/*Mon union qui me permet de superposer les variable 'valeur' et 'etat'*/
union _mot{
	char valeur;
	octet etat;
}mot;

/*Mon main qui me permet de tester*/
main()
{
	printf("saisir une valeur (de -128 a +127):");   //Valeur max d'un char signé
	scanf("%d",&mot.valeur);

	printf("sizeof(octet) = %d\n",sizeof(octet));    //Montre l'interait des champ de bits 1 octet au lieu de 8
	printf("sizeof(mot) = %d\n",sizeof(mot));        //Montre que l'union superpose bien les deux variables et ne les met pas à la suite

	printf("Etat b0: %d\n",mot.etat.b0);
	printf("Etat b1: %d\n",mot.etat.b1);
	printf("Etat b2: %d\n",mot.etat.b2);
	printf("Etat b3: %d\n",mot.etat.b3);
	printf("Etat b4: %d\n",mot.etat.b4);
	printf("Etat b5: %d\n",mot.etat.b5);
	printf("Etat b6: %d\n",mot.etat.b6);
	printf("Etat b7: %d\n",mot.etat.b7);
}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.