Rangement pour vos booléens

Soyez le premier à donner votre avis sur cette source.

Snippet vu 7 648 fois - Téléchargée 34 fois

Contenu du snippet

C'est un type structure qui gère, stocke et facilite l'accès à autant de variable booléenne que vous pourriez avoir besoin. Pour la moment je m'en suis tenu à un accès direct par index, mais dans le futur on pourrait imaginer un accès par clé. Le problème étant que cela aurait pour conséquence d'alourdir la structure.

Source / Exemple :


/// <summary>
	/// Description résumée de boolz
	/// </summary>
	public struct boolz
	{
		private int[] _tval;
		
		private void AddInt()
		{
			// pas besoin de vérifier que tval est initialisé,
			// puisque nous sommes en présence d'une structure
			int[] temp = new int[this._tval.Length + 1];
			Array.Copy(this._tval,0,temp,0,this._tval.Length);
			temp[this._tval.Length] = 0; // pas nécessaire ... 
			this._tval = temp;
		}

		public boolz(System.Int32 newValue)
		{
			this._tval = new int[1];
			this._tval[0] = newValue;

		}
		public boolz(params bool[] InitialValues)
		{
			int ILen = InitialValues.Length; // valeur utilisée fréquemment
			int TLen = ((ILen - (ILen % 32)) / 32) + 1;
			this._tval = new int[TLen];
			for(int i=0;i<ILen;i++)
				this[i] = InitialValues[i];
		}
		public static implicit operator boolz(System.Int32 NewValue)
		{
			return new boolz(NewValue);
		}
		public static implicit operator boolz(bool[] InitialValues)
		{
			return new boolz(InitialValues);
		}
		public bool this[int position]
		{
			get
			{
				// Si il y a dépassement de capacité
				if(position > (this._tval.Length * 32))
					throw new OverflowException("La position spéficiée excède les possiblités du type actuel.");
				
				// On détermine la position interne sur l'entier
				int tabPosA = position % 32;
				// On détermine la position dans le tableau
				// (De quel entier s'agit-il ?)
				int tabPosB = ((position - tabPosA) / 32) + 1;
				// On fabrique la condition AND appropriée
				int ANDAttr = Convert.ToInt32(Math.Pow(2,tabPosA -1));
				// On vérifie le resultat obtenu et retour.
				if((this._tval[tabPosB-1] & ANDAttr) > 0)
					return true;
				else
					return false;
			}
			set
			{
				// si la position est plus grande que le tableau actuel
				// il faut ajouter autant d'entier que nécessaire
				// pour satisfaire la condition "position".
				if(position > (this._tval.Length * 32))
				{
					int mod = position % 32;
					int len = ((position - mod) / 32) + 1;
					while(this._tval.Length < len)
						AddInt();
				}
				
				// si on arrive ici c'est qu'on a suffisamment d'entier
				// pour réaliser la modification de la valeur
				int tabPosA = position % 32;
				int tabPosB = ((position - tabPosA) / 32) + 1;
				int ANDAttr = Convert.ToInt32(Math.Pow(2,tabPosA -1));
                				
				if(value == true)
				{
					if((this._tval[tabPosB-1] & ANDAttr) == 0)
					{
						this._tval[tabPosB-1] += ANDAttr;
					}
				}
				else
				{
					if((this._tval[tabPosB-1] & ANDAttr) > 0)
					{
						this._tval[tabPosB-1] -= ANDAttr;
					}
				}
			}
		}

	}

Conclusion :


Vous pouvez voir par là, la force des structures pour ce type d'utilisation. Je vous encourage à me faire part de vos impressions.

A voir également

Ajouter un commentaire Commentaires
Messages postés
412
Date d'inscription
lundi 26 mai 2003
Statut
Membre
Dernière intervention
13 août 2007

J'ai pas trop compris ce que ton code est censé faire, mais je vais répondre ce qu'on ma répondu la dernière fois que j'ai posté une source sur des tableaux de bool:

BitArray !

;-)
Messages postés
1182
Date d'inscription
mercredi 21 janvier 2004
Statut
Membre
Dernière intervention
6 septembre 2011
13
je rejoignais un peu l'idée de gg00xiv...

mais bon....

me suis peut etre trompé...
Messages postés
1182
Date d'inscription
mercredi 21 janvier 2004
Statut
Membre
Dernière intervention
6 septembre 2011
13
en gros j'ai du lire en diagonale... :o)))
Messages postés
103
Date d'inscription
lundi 8 juillet 2002
Statut
Membre
Dernière intervention
24 novembre 2005

Tu peux encore améliorer un peu le code pour accéder et modifier un bit dans la liste, par exemple en utilisant les opérateurs de décalage << et >> au lieu de Math.Pow, et les opérateurs binaires |= et &= au lieu de += et -=.
Par exemple, voilà un extrait d'une de mes classes qui a à peu près le même but que ta structure boolz: (data est le tableau d'uint dans lequel les bits sont stockés)

private bool GetBit( uint index )
{
return ((data[(int)(index / 32)] & (1 << (int)(index % 32))) != 0);
}
private void SetBit( uint index, bool @value )
{
if( @value )
{
data[(int)(index / 32)] |= (uint)(1 << (int)(index % 32));
}
else
{
data[(int)(index / 32)] &= ~(uint)(1 << (int)(index % 32));
}
}
Messages postés
656
Date d'inscription
mercredi 22 août 2001
Statut
Membre
Dernière intervention
11 mars 2005
13
Tant qu'à faire dans le détails, tu pourrais utiliser l'implémentation de l'interface IList, comme ca, tu aurais une Collection (pour booleens) sur laquel tu pourrais utiliser un foreach et puis bien plus complète.

Remarque: avec l'arrivée de Whidbey et les collections typées, ce genre de code ne sera plus nécessaire...
Afficher les 7 commentaires

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.