Discussion :

[MacInTouch]

Bonjour à tous,

Je travaille actuellement sur un projet dont l'explication détaillée ne sera pas utile ici pour comprendre le problème, ceci je vais tout de même préciser d'avantage le contexte :

1/ Nous avons à faire à des ensembles dont les éléments varient entre 1 et 32, ainsi, aucun ensemble ne possèdera la valeur 33 ou 45 ou 0.

2/ Un ensemble possède un nom d'au plus une lettre, non case sensitive ainsi, l'ensemble 'A' contient les mêmes éléments que l'ensemble 'a'.

3/ QQs exemples :
A = { 3, 23 }
b = { }
c = {10, 9, 8, 6 }
etc.

Je dois retenir quel éléments appartiennent à quel ensemble pour que dans la suite, je puisse faire des opération tel que l'union, l'intersection etc. entre les ensembles.
Le type int en C étant codé sur 32 bits (exactement la valeur max d'un élément de l'ensemble), j'ai décidé de représenter ceci sous forme d'un tableau de 26 entiers (26 lettres possibles => 26 cases dans le tableau ).

Ainsi, je voudrais au final utiliser le contenu de mes cases (de types entier) en tant que booléen. Je m'explique, si la valeur 25 est affecté à l'ensemble 'A', je voudrais positionner le bit numéro 25 de la première case du tableau à 1 etc.

Exemple

Etat Initial :
Case 1 du tableau (lettre A) = 00000000000000000000000000000000
Case 2 du tableau (lettre B) = 00000000000000000000000000000000
.
.
.

a = { 3, 12 } => on transforme le bit 2 et 12 dans la case A du tableau et on obtient :
Case 2 du tableau (lettre B) = 00000000000000000000100000000100
.
.
.

Le problème, c'est que je ne sais pas du tout comment accéder au Iième bit d'un entier =/

Quelqu'un peut il m'aider ?

Merci à vous =)

[Steph_ng8]

Bonjour,

Pour faire ce que tu souhaites, il te faut utiliser les opérateurs sur les bits :

• & (ET)
• &= (idem avec affectation)
• | (OU)
• |= (idem avec affectation)
• << (décalage à gauche)
• >> (décalage à droite)
• etc.

Quelques petits exemples :

• 1 << 2 == 4 == 00000100
• 9 | 2 == 11 == 00001001 | 00000010 == 00001011
• 10 & 4 == 0 == 00001010 & 00000100 == 00000000
• 12 & 4 == 4 == 00001100 & 00000100 == 00000100

Je te laisse un peu te renseigner dessus, et si tu ne vois toujours pas comment les utiliser, reviens poster ici.

[MacInTouch]

Merci pour ta réponse,

J'ai finalement résolu le soucis.
J'ai tout simplement utilisé la fonction puissance ( pow ).
Ainsi si je veux que le bit i de mon entier soit à 1 j'affecte à celui ci la valeur de pow(2, i).

A bientôt =)

[Pouet_forever]

La fonction pow fait des calculs sur des nombres flottants, et tu veux des nombres entiers.
Le mieux est encore de faire ta propre fonction (ou éventuellement macro) qui fait un décalage de bits.
Pour mettre le bit i à 1 (en considérant que le premier bit est le bit 0) il suffit de faire 1 << i.
Ensuite pour 'l'ajouter' à ton nombre, tu fais nb | (1 << i), le tour est joué.

[jeroman]

Attention, un int ne fait pas forcément 32 bits. Ton programme risque de ne pas être portable.