Discussion :

[boula]

Bonjour,

Est ce quelqu'un a une idée de comment déclarer et manipuler une variable qui est sur un seul bit.

Je vous remercie d'avance.

[JulienDuSud]

Rien de standard. Ce que tu peux faire, c'est utiliser les opérateurs de bit et traiter un char, int, ou c'que tu veux comme un ensemble de bit dont la valeur en tant qu'ensemble ne veut rien dire.

Tu peux par exemple considérer que char c'est 8 variables de 1 bit, ou que short c'est 16 variables de 1 bit, etc...

Après, tu peux utiliser les opérateurs <<, & et | pour récupérer leur contenu.

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
26
27
28
29
30
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
void set_bit( int* bitset32, char bit )
{
	*bitset32 |= ( 1 << bit );
}
 
bool is_set( int* bitset32, char bit )
{
	return *bitset32 & ( 1 << bit );
}
 
void unset_bit( int* bitset32, char bit )
{
	if( is_set( bitset32, bit ) )
		*bitset32 -= ( 1 << bit );
}
 
int main()
{
	int bitset = 0;
	set_bit( &bitset, 0 );
	printf("%d\n", is_set( &bitset, 0 ) );
	printf("%d\n", is_set( &bitset, 1 ) );
	unset_bit( &bitset, 0 );
	printf("%d\n", is_set( &bitset, 0 ) );
	return 0;
}

[jabbounet]

ou bien manipuler un champ de bit dans une structure

exemple unsigned 32 ou chaque bit est accessible, ensuite il faut faire des manipulations comme celle indiqué par julien du sud:

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
26
27
28
29
30
31
32
33
34
35
36
 
struct bytefield32  {
     unsigned bt0:1;
     unsigned bt1:1;
     unsigned bt2:1;
     unsigned bt3:1;
     unsigned bt4:1;
     unsigned bt5:1;
     unsigned bt6:1;
     unsigned bt7:1;
     unsigned bt8:1;
     unsigned bt9:1;
     unsigned bt10:1;
     unsigned bt11:1;
     unsigned bt12:1;
     unsigned bt13:1;
     unsigned bt14:1;
     unsigned bt15:1;
     unsigned bt16:1;
     unsigned bt17:1;
     unsigned bt18:1;
     unsigned bt19:1;
     unsigned bt20:1;
     unsigned bt21:1;
     unsigned bt22:1;
     unsigned bt23:1;
     unsigned bt24:1;
     unsigned bt25:1;
     unsigned bt26:1;
     unsigned bt27:1;
     unsigned bt28:1;
     unsigned bt29:1;
     unsigned bt30:1;
     unsigned bt31:1;
 
};

quelques informations complémentaires ici
http://www.technoplaza.net/programming/lesson8.php
http://msdn.microsoft.com/en-us/libr...xh(VS.80).aspx
http://stackoverflow.com/questions/1...ipulation-in-c
http://www.pagetable.com/?p=250

[Franck.H]

Attention cependant pour le retour de la fonction is_set, le type bool n'existe qu'en C99 sinon, il faut le remplacer par un type int

[PRomu@ld]

Tu peux par exemple considérer que char c'est 8 variables de 1 bit, ou que short c'est 16 variables de 1 bit, etc...

Attention, un char ne fait pas toujours 8 bits. Pour savoir ce qu'il en est en pratique, il faut consulter la constante CHAR_BIT définie dans <limits.h>

[gl]

Attention, un char ne fait pas toujours 8 bits. Pour savoir ce qu'il en est en pratique, il faut consulter la constante CHAR_BIT définie dans <limits.h>

Non effectivement un char ne fait pas toujours exactement 8 bits mais il fait obligatoirement au moins 8 bits.

N'utiliser que 8 bits (et utiliser explicitement des unsigned char et non des char) permet donc d'être portable au prix d'un petit "gaspillage" de mémoire sur les rares plateformes où un char représente plus de 8 bits.

[droggo]

Goe,

Non effectivement un char ne fait pas toujours exactement 8 bits mais il fait obligatoirement au moins 8 bits.

N'utiliser que 8 bits (et utiliser explicitement des unsigned char et non des char) permet donc d'être portable.

Pas forcément.

Ça peut par exemple changer l'alignement dans une structure ...