QBitArray

La classe QBitArray fournit un tableau de bits. Plus d'informations...

#include <QBitArray>

Voir la position dans l'arbre des classes.

Note : toutes les fonctions de cette classe sont réentrantes.

Description détaillée

La classe QBitArray fournit un tableau de bits

Un QBitArray est un tableau donnant l'accès aux bits individuellement et qui fournit les opérateurs (ET, OU, XOR et NOT) fonctionnant sur l'ensemble du tableau de bits. Le tableau utilise le partage implicite (copie à l'écriture) afin de réduire la charge en mémoire et d'éviter les copies inutiles.

Le code suivant construit un QBitArray contenant 200 bits initialisés à false (0) :

 QBitArray ba(200);

Pour initialiser les bits à true, passez true comme second argument au constructeur ou appelez fill() plus tard.

Le QBitArray utilise un index démarrant à 0, tout comme les tableaux C++. Pour accéder à un bit à une position particulière, vous pouvez utiliser l'opérateur []. Sur les tableaux de bits non constants, l'opérateur[]() retourne une référence à un bit qui peut être utilisé comme partie gauche d'une affectation. Par exemple :

 QBitArray ba;
 ba.resize(3);
 ba[0] = true;
 ba[1] = false;
 ba[2] = true;

Pour des raisons techniques, il est plus efficace d'utiliser les fonctions testBit() et setBit() pour accéder aux bits dans le tableau que l'opérateur[](). Par exemple :

 QBitArray ba(3);
 ba.setBit(0, true);
 ba.setBit(1, false);
 ba.setBit(2, true);

Le QBitArray gère & (ET), | (OU), ^ (XOR), ~ (NOT), ainsi que &=, |= et ^=. Ces opérateurs fonctionnent de la même manière que les opérateurs logiques du C++ de même nom. Par exemple :

 QBitArray x(5);
 x.setBit(3, true);
 // x: [ 0, 0, 0, 1, 0 ]
 
 QBitArray y(5);
 y.setBit(4, true);
 // y: [ 0, 0, 0, 0, 1 ]
 
 x |= y;
 // x: [ 0, 0, 0, 1, 1 ]

Pour des raisons historiques, le QBitArray différencie un tableau de bits nul d'un tableau vide. Un tableau de bits nul est un tableau de bits initialisé avec le constructeur par défaut. Un tableau de bits vide correspond à n'importe quel tableau de bits ayant une taille de 0. Un tableau de bits nul est toujours vide mais un tableau vide n'est pas toujours nul :

 QBitArray().isNull();           // retourne vrai
 QBitArray().isEmpty();          // retourne vrai
 
 QBitArray(0).isNull();          // retourne faux
 QBitArray(0).isEmpty();         // retourne vrai
 
 QBitArray(3).isNull();          // retourne faux
 QBitArray(3).isEmpty();         // retourne faux

Toutes les fonctions sauf isNull() traitent les tableaux de bits nuls de la même façon que les tableaux de bits vides ; par exemple, QBitArray() est égal à QBitArray(0). Nous recommandons de toujours utiliser la fonction isEmpty() et d'éviter la fonction isNull().

Voir aussi QByteArray et QVector.

Fonctions membres

QBitArray::QBitArray ()

Construit un tableau de bits vide.

Voir aussi isEmpty().

QBitArray::QBitArray ( int size, bool value = false )

Construit un tableau de bits contenant size bits. Les bits sont initialisés avec la valeur value, qui, par défaut est false (0).

QBitArray::QBitArray ( const QBitArray & other )

Construit une copie de other.

Cette opération s'exécute en temps constant, car QBitArray est partagé implicitement. Cela signifie que le retour d'un QBitArray par une fonction est très rapide. Si l'instance partagée est modifiée, elle va être copiée (copie à l'écriture) et ceci prendra un temps linéaire.

Voir aussi operator=().

bool QBitArray::at ( int i ) const

Retourne la valeur du bit à la position i.

i doit être appelé avec un index valide pour le tableau de bits (c'est-à-dire 0 <= i < size()).

Voir aussi operator[]().

void QBitArray::clear ()

Efface le contenu du tableau de bits et le vide.

Voir aussi resize() et isEmpty().

void QBitArray::clearBit ( int i )

Définit le bit à la position i à 0.

i doit être appelé avec un index valide pour le tableau de bits (c'est-à-dire 0 <= i < size()).

Voir aussi setBit() et toggleBit().

int QBitArray::count () const

Identique à size().

int QBitArray::count ( bool on ) const

Si on est true, cette fonction retourne le nombre de bits à 1 stockés dans le tableau; sinon retourne le nombre de bits à 0.

bool QBitArray::fill ( bool value, int size = -1 )

Définit tous les bits du tableau de bits à la valeur value, retournant true en cas de succès ; sinon, retourne false. Si size est différent de -1 (la valeur par défaut), le tableau de bits est auparavant redimensionné à la taille size.

Exemple:

 QBitArray ba(8);
 ba.fill(true);
 // ba: [ 1, 1, 1, 1, 1, 1, 1, 1 ]
 
 ba.fill(false, 2);
 // ba: [ 0, 0 ]

Voir aussi resize().

void QBitArray::fill ( bool value, int begin, int end )

Il s'agit d'une fonction surchargée.

Définit les bits entre la position de début begin jusqu'à la position de fin end (exclue) à la valeur value.

begin et end doivent être des index valides dans le tableau de bits (c'est-à-dire 0 <= begin <= size() et 0 <= end <= size()).

bool QBitArray::isEmpty () const

Retourne true si ce tableau de bits est de taille 0 ; sinon retourne false.

Voir aussi size().

bool QBitArray::isNull () const

Retourne true si ce tableau de bits est nul ; sinon, retourne false.

Exemple:

 QBitArray().isNull();           // retourne vrai
 QBitArray(0).isNull();          // retourne faux
 QBitArray(3).isNull();          // retourne faux

Historiquement, Qt fait la différence entre les tableaux de bits nuls et les tableaux de bits vides. La plupart des applications veulent uniquement savoir si le tableau de bits contient des données ou non, ce qui peut être déterminé en utilisant la fonction isEmpty().

Voir aussi isEmpty().

void QBitArray::resize ( int size )

Redimensionne le tableau de bits à la taille size.

Si la taille size est plus grande que la taille courante, le tableau de bits est étendu à la taille size avec les bits supplémentaires ajoutés à la fin. Les nouveaux bits sont initialisés à false (0).

Si la taille size est inférieure à la taille actuelle, les bits de fin sont retirés.

Voir aussi size().

void QBitArray::setBit ( int i )

Définit le bit de la position i à 1.

i doit être un index valide dans le tableau de bits (c'est-à-dire 0 <= i < size()).

Voir aussi clearBit() et toggleBit().

void QBitArray::setBit ( int i, bool value )

Il s'agit d'une fonction surchargée.

Définit le bit à la position i à la valeur value.

int QBitArray::size () const

Retourne le nombre de bits stockés dans le tableau de bits.

Voir aussi resize().

bool QBitArray::testBit ( int i ) const

Retourne true si le bit à la position i est 1 ; sinon, retourne false.

i doit être un index valide dans le tableau de bits (c'est-à-dire 0 <= i < size()).

Voir aussi setBit() et clearBit().

bool QBitArray::toggleBit ( int i )

Inverse la valeur du bit à la position i, retournant l'ancienne valeur de ce bit, soit true s'il était défini et false sinon.

Si la valeur précédente était 0, la nouvelle valeur sera 1. Si la valeur précédente était 1, la nouvelle valeur sera 0.

i doit être un index valide dans le tableau de bits (c'est-à-dire 0 <= i < size()).

Voir aussi setBit() et clearBit().

void QBitArray::truncate ( int pos )

Tronque le tableau de bits à la position pos.

Si pos dépasse la fin du tableau, rien ne se passe.

Voir aussi resize().

bool QBitArray::operator!= ( const QBitArray & other ) const

Retourne true si other est différent de ce tableau de bits ; sinon retourne false.

Voir aussi operator==().

QBitArray & QBitArray::operator&= ( const QBitArray & other )

Effectue une opération logique ET sur tous les bits entre ce tableau et other. Affecte le résultat à ce tableau et retourne une référence sur celui-ci.

Le résultat est de la longueur du plus grand tableau, avec tous les bits manquants (si un tableau est plus petit que l'autre) à 0.

Exemple :

 QBitArray a(3);
 QBitArray b(2);
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
 a &= b;                         // a: [ 1, 0, 0 ]

Voir aussi operator&(), operator|=(), operator^=() et operator~().

QBitArray & QBitArray::operator= ( const QBitArray & other )

Affecte other à ce tableau de bits et retourne une référence sur ce tableau.

bool QBitArray::operator== ( const QBitArray & other ) const

Retourne true si other est égal à ce tableau de bits ; sinon retourne false.

Voir aussi operator!=().

QBitRef QBitArray::operator[] ( int i )

Retourne le bit à la positon i sous forme d'une référence modifiable.

i doit être un index valide dans le tableau de bits (c'est-à-dire 0 <= i < size()).

Exemple :

 QBitArray a(3);
 a[0] = false;
 a[1] = true;
 a[2] = a[0] ^ a[1];

La valeur retournée est de type QBitRef, une classe d'aide pour QBitArray. Lorsque vous recevez un objet de type QBitRef, vous pouvez lui affecter une valeur et l'affectation sera appliquée au bit du QBitArray à partir duquel vous avez obtenu la référence.

Les fonctions testBit(), setBit() et clearBit() sont légèrement plus rapides.

Voir aussi at(), testBit(), setBit() et clearBit().

bool QBitArray::operator[] ( int i ) const

Il s'agit d'une fonction surchargée.

QBitRef QBitArray::operator[] ( uint i )

Il s'agit d'une fonction surchargée.

bool QBitArray::operator[] ( uint i ) const

Il s'agit d'une fonction surchargée.

QBitArray & QBitArray::operator^= ( const QBitArray & other )

Effectue une opération logique XOR entre tous les bits de ce tableau et other. Affecte le résultat à ce tableau et retourne une référence sur celui-ci.

Le résultat a la longueur du plus long des deux tableaux. Les bits manquants (si un tableau est plus petit que l'autre) seront mis à 0.

Exemple:

 QBitArray a(3);
 QBitArray b(2);
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
 a ^= b;                         // a: [ 0, 1, 1 ]

Voir aussi operator^(), operator&=(), operator|=() et operator~().

QBitArray & QBitArray::operator|= ( const QBitArray & other )

Effectue une opération logique OU entre tous les bits de ce tableau et other. Affecte le résultat à ce tableau de bits et retourne une référence sur celui-ci.

Le résultat a la longueur du plus long des deux tableaux. Les bits manquants (si un tableau est plus petit que l'autre) seront mis à 0.

Exemple:

 QBitArray a(3);
 QBitArray b(2);
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
 a |= b;                         // a: [ 1, 1, 1 ]

Voir aussi operator|(), operator&=(), operator^=() et operator~().

QBitArray QBitArray::operator~ () const

Retourne un tableau de bits qui contient le complément des bits de ce tableau.

Exemple:

 QBitArray a(3);
 QBitArray b;
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b = ~a;                         // b: [ 0, 1, 0 ]

Voir aussi operator&(), operator|() et operator^().

En relation mais non membres de la classe

QBitArray operator& ( const QBitArray & a1, const QBitArray & a2 )

Retourne un tableau de bits qui est le résultat de l'opération logique ET entre a1 et a2.

Le résultat a la longueur du plus long des deux tableaux. Les bits manquants (si un tableau est plus petit que l'autre) seront mis à 0.

Exemple:

 QBitArray a(3);
 QBitArray b(2);
 QBitArray c;
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
 c = a & b;                      // c: [ 1, 0, 0 ]

Voir aussi QBitArray::operator&=(), operator|() et operator^().

QDataStream & operator<< ( QDataStream & out, const QBitArray & ba )

Écrit le tableau de bits ba sur le flux out.

Voir aussi Format des opérateurs QDataStream.

QDataStream & operator>> ( QDataStream & in, QBitArray & ba )

Lit le tableau de bits ba à partir du flux in.

Voir aussi Format des opérateurs QDataStream.

QBitArray operator^ ( const QBitArray & a1, const QBitArray & a2 )

Retourne le tableau de bits résultat de l'opération logique XOR entre a1 et a2.

Le résultat a la longueur du plus long des deux tableaux. Les bits manquants (si un tableau est plus petit que l'autre) seront mis à 0.

Exemple:

 QBitArray a(3);
 QBitArray b(2);
 QBitArray c;
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
 c = a ^ b;                      // c: [ 0, 1, 1 ]

Voir aussi QBitArray::operator^=(), operator&() et operator|().

QBitArray operator| ( const QBitArray & a1, const QBitArray & a2 )

Retourne le tableau de bits résultat de l'opération logique OU entre a1 et a2.

Le résultat a la longueur du plus long des deux tableaux. Les bits manquants (si un tableau est plus petit que l'autre) seront mis à 0.

Exemple:

 QBitArray a(3);
 QBitArray b(2);
 QBitArray c;
 a[0] = 1; a[1] = 0; a[2] = 1;   // a: [ 1, 0, 1 ]
 b[0] = 1; b[1] = 0;             // b: [ 1, 1 ]
 c = a | b;                      // c: [ 1, 1, 1 ]

Voir aussi QBitArray::operator|=(), operator&() et operator^().

Remerciements

Merci à Alexandre Laurent pour la traduction, ainsi qu'à Ilya Diallo et Claude Leloup pour la relecture !