Manipulation d'un bit sur un entier

Bonjour!!!
encore une petite question pour la route ;) tant que je suis sur ma lancée :mouarf:

en fait, je souhaiterai manipuler un bit particulier d'un entier sur 16 bits.
par exemple, admettons le code suivant :

Code:

---

uint16 entier = 0000 1010 1100 0110

---

je souhaiterais pouvoir faire quelquechose de la sorte :

Code:

---

1 2 3 4

if (bit en gras de l'entier sur 16 bit = 1) { instruction }

---

j'ai essayer avec les decalage de bits, mais ils ne me permettent pas d'acceder a un bit en particulier
existe t-il un procédé?
merci encore pour votre aide si précieuse!!!

On peut utiliser des masques. Par exemple, pour effectuer une action en fonction de la valeur du troisième bit de poids faible de i:

Code:

---

1 2 3 4

if (i & 0x4) ... else ...

---

merci stephl ms je ne comprends pas tres bien la commande

(i & 0x4)

je ne vois pas comment je peux agir selon la valeur du 3e bit :bug:
pourrais-tu me donner des precisions?
merci d'avance ;)

Il faut que tu penses en binaire.
L'opérateur & fait un ET binaire entre deux arguments.
Donc, pour l'exemple, 4 en binaire vaut 0000 0100. On ne fait donc un ET qu'avec le 3ème bit. Tu n'agis donc que selon la valeur du 3ème bit.

Citation:

---

Envoyé par SybVicious

merci stephl ms je ne comprends pas tres bien la commande

(i & 0x4)

je ne vois pas comment je peux agir selon la valeur du 3e bit :bug:
pourrais-tu me donner des precisions?
merci d'avance ;)

---

Il s'agit juste d'un ET bit à bit. Par exemple, si i vaut 20, voici ce qui se passe au niveau des bits en considérant juste l'octet de poids faible:

Code:

---

1 2 3

i: 00010100 masque: 00000100 ET: 00000100

---

ok je commence a voir, merci.
par contre derniere question, si i vaut 16 j'aurai alors

i: 00010000
masque: 00000100
ET: 00000100

si je veux travailler sur le 3e bit qui vaut 0 (je ne suis pas censé connaitre sa valeur) si je fais un ET avec 0x4 comme dans le code ci dessus, sa valeur ne sera t elle pas affectée?

petite correction, je me suis trompé, je confondais en croyant que 0 '&' 1 était égal à 1, tout est plus clair!
merci beaucoup!!!

Citation:

---

i: 00010000
masque: 00000100
ET: 00000000

---

commence par:
http://fr.wikipedia.org/wiki/Fonction_ET

Citation:

---

Envoyé par SybVicious

ok je commence a voir, merci.
par contre derniere question, si i vaut 16 j'aurai alors

i: 00010000
masque: 00000100
ET: 00000100

si je veux travailler sur le 3e bit qui vaut 0 (je ne suis pas censé connaitre sa valeur) si je fais un ET avec 0x4 comme dans le code ci dessus, sa valeur ne sera t elle pas affectée?

---

Le ET bit-à-bit n'affecte en rien la valeur des variables utilisées dans le calcul. Avec i=16 et le masque 0x4, le résultat est 0 ce qui indique que le troisième bit de poids faible de i est à zéro.

merci infiniment de votre aide, je vais pouvoir desormais manipuler mes bits un par un!!
cependant, est-ce que je peux utiliser un masque si je veux travailler sur 2 bits ou plus en particulier? par exemple :

i = 00010100

si je ve travailler sur la valeur des 3 bits en gras, est-ce que je peux utiliser le masque suivant ?

masque = 00011100

Bah il faut que tu fasses le masque approprié, imaginons que tu veuilles manipuler les bits de poids faible 2 et 3, le masque sera 0x6 (0000 0110).

Mais si tes groupes de bits sont toujours les mêmes, tu peux toujours te tourner vers les champs de bits grâce aux structures :

Code:

---

1 2 3 4 5 6

typedef struct maStruct { unsigned invisible:1; // signifie que la champ n'aura qu'un seul bit unsigned ouvert:1; unsigned codeErreur:3; // signifie qu'il en aura 3 unsigned numeroDeSerie:11; } Etats;

---

Ici l'addition des 4 champs fait 16 bits donc la structure finale fera 16 bits, en théorie si tu ne donne pas un multiple de 8 (1 octets) le compilateur arrondira à un multiple de 8 supérieur et ajoutera donc des bits inutilisés. Tu peux les ajouter toi pour connaître leur position exacte. Tu peux faire plein de combinaisons grâce à ces champs de bits, par contre il faut faire attention, selon le processeur que tu as (big endian, little endian) l'ordre des bits est inversé...

Après pour accéder à un champ, c'est simple :

Code:

---

1 2	Etats var = nombre; if(Etat.ouvert)...

---

merci pshychoH13, ms justement mes groupes de bits ne sont pas toujours les memes ;) mais c'est quand meme bon à savoir :king:
en tout cas merci à tous de votre aide!!!

Ils changent systématiquement ou alors il y a de motifs récurrents ?? :D

Ben en fait je manipule 96 bits qui sont séparés en un tableau d'entiers sur 16 bits composés de 6 éléments. Chaque bit ou groupe de bits correspondent à un état particulier que je manipule et qui varie selon un facteur bien particulier. Par conséquent les motifs sont amenés à varier tres souvent ;)

Ca m'interesse ce système de structure => dans mon problème :

2. Implantation des ensembles

On représente en mémoire tout ensemble e comme un entier naturel écrit en binaire b26...b2,b1, ou bk est le chiffre binaire 1 si la lettre rang k est dans e, et 0 sinon. Le chiffre b1 est le bit de poids faible et b26 celui de poids fort.
Ecrire la représentation binaire de l'ensemble e1 pris en exemple dans 1., et sa valeur en décimal.

Déclarer en C le type des ensembles pour cette représentation. Programmer en C très simplement les fonctions rang et lettre, en se rappelant que, en C, tout caractère est assimilé à son codage en entier.

Programmer en C toutes les opérations de la question 1., en passant pour i, app, card et d par des fonctions auxiliaires appelées i1, app1, card1 et d1, où l'argument caractère est remplacé par son rang. Ces dernières fonctions sont à programmer récursivement, en même temps sur l'ensemble et sur le rang. On pourra à cet effet utiliser des quotients et restes de divisions entières par 2.

Je peux faire une structure du genre :

Code:

---

1 2 3 4

typedef struct maStruct { unsigned int ensemble:26; }Ens;

---

Je sais que ca compile j'ai essayé mais je voulais savoir si ca faisait bien d'ensemble un entier de 26 bits ??

Le truc c'est que si tu n'as qu'un seul champ ça ne vaut pas vraiment le coup de faire une structure... Le problème avec ce système c'est que ta structure fera quand même 32 bits parce que le compilateur arrondi toujours... Mais tu ne pourras utiliser que 26 bits. Et le problème qui personnellement me ferait chier, c'est que pour modifier la valeur de ce truc tu devras obligatoirement utiliser l'opérateur de déréférencement d'attribut : -> ou .
Les champs de bits valent le coup lorsque tu as plusieurs champs de taille différentes que tu dois réunir.
Dans ton cas il serait préférable, je pense, mais tu fais ce que tu veux, d'utiliser un masque à chaque fois que tu manipules une valeur, un masque en hexa par exemple dans ton cas :

Code:

---

#define MON_MASQUE 0x3FFFFFF

---

après à chaque fois que tu as un nombre tu le masque avec l'opérateur bit-à-bit & :

Code:

---

monNombre = MON_MASQUE & valeur;

---

Mais comme il semblerait que tu aies bel et bien besoin d'une structure pour ton exercice, alors oui le champs de bits tel que tu le déclares est valable. Mais comme j'ai pas la question 1 de ton exercice je peux pas plus t'aider...

Voici le numéro 1 :

1. Spécification des ensembles

Ecrire un module de spéc ENSEMBLE pour la sorte Ens des ensembles de caractères pris uniquement dans l'alphabet des 26 lettres majuscules romaines de 'A' à 'Z', avec les constructeurs de base :

- v : ensemble vide;
- i : tel que i(e,x) est l'insertion dans l'ensemble e de la lettre désignée par x;

Donnez l'expression de construction avec v et i de l'ensemble e1 contenant exactement les lettres 'B', 'C', 'G'.

Dans ENSEMBLE, définir par rapport à v et i les fonctions :

- estv, telle que estv(e) retourne vrai si et seulement l'ensemble e est vide;
- app, telle que app(e,z) est vrai si et seulement si la lettre z est dans l'ensemble e;
- card, telle que card(e) est le cardinal de l'ensemble e;
- d, telle que d(e,z) efface la lettre z de l'ensemble e;

Spécifier également la fonction rang fournissant le rang d'une lettre dans l'alphabet, et la fonction lettre faisant l'inverse.

On écrira soigneusement les préconditions nécessaires, en utilisant la comparaison <= entre les caractères supposée connue, et des constantes notées entre deux '.

En fait, la structure n'est pas obligatoire me semble t'il donc ton idée de faire un masque (define) et de le manipuler est une très bonne idée et j'avais commencé comme ca. Mais quand j'ai vu ton système de structure, ca m'intéressais grandement et je connaissais pas trop : j'ai jamais trop fait de chose bit à bit en fait.

Je viens de voir que dans mon bouquin de C, il parlait des champs de bits mais vers la fin donc comme je suis en train de le lire j'y étais pas encore ;) mais je regarderais ca tranquillement.

@PsychoH13 : Je viens de réagir sur le fait qu'il faut que je programme ce truc par récursivité donc pour la fonction i par exemple qui insert dans l'ensemble e une lettre, il faut passer par une fonction i1 intermédiaire...

je vois pas trop comment faire : d'après ce que je comprend j'appelle la fonction i qui va appeler dans un premier temps la fonction rang pour obtenir le rang de la lettre et après on appelle la fonction i1 qui va modifier le bit de rang k (rang de la lettre) de façon récursive... je vois pas comment faire cela exactement.
Tu as une idée judicieuse à me proposer ou quelqu'un d'autre, je suis pas sectaire lol

Citation:

---

Envoyé par PsychoH13

Mais si tes groupes de bits sont toujours les mêmes, tu peux toujours te tourner vers les champs de bits grâce aux structures :

---

Non, ce n'est pas du tout portable. Seules les opération bits à bits sont portables.

http://emmanuel-delahaye.developpez....s.htm#bitfield