pourrait cependant interdire de telles possibilités en utilisant le mot-clé explicit dans
le constructeur à un argument de type int.
2. La présence d’une valeur de retour dans l’opérateur d’affectation n’est utile que pour
permettre les affectations multiples. La transmission par référence de l’unique
argument n'est pas obligatoire. On pourrait ajouter le qualificatif const pour autoriser
l’affectation d’un objet constant (moyennant alors une recopie). Mais, du même
coup, compte tenu des possibilités de conversions implicites, on autoriserait
également l’utilisation d’un entier ou d’un flottant, ce qui n’est pas nécessairement
satisfaisant ; là encore, ces possibilités pourraient être interdites, moyennant
l’utilisation appropriée du mot-clé explicit.
Voici la définition des différentes fonctions.
#include "bitarray.h"
#include
#include
using namespace std ;
bit_array::bit_array (int nb)
{ nbits = nb ;
ncar = nbits / CHAR_BIT + 1 ;
adb = new char [ncar] ;
int i ;
for (i=0 ; i }
bit_array::bit_array (bit_array & t)
{ nbits = t.nbits ; ncar = t.ncar ;
adb = new char [ncar] ;
int i ;
for (i=0 ; i }
bit_array::~bit_array()
{ delete adb ;
}
bit_array & bit_array::operator = (bit_array & t)
{ if (this != & t) // on ne fait rien pour t=t
{ delete adb ;
nbits = t.nbits ; ncar = t.ncar ;
adb = new char [ncar] ;
int i ;
for (i=0 ; i adb[i] = t.adb[i] ;
}
return *this ;
}
int bit_array::operator [] (int i)
{ // le bit de rang i s'obtient en considérant le bit
// de rang i % CHAR_BIT du caractère de rang i / CHAR_BIT
int carpos = i / CHAR_BIT ;
int bitpos = i % CHAR_BIT ;
return ( adb [carpos] >> CHAR_BIT - bitpos -1 ) & 0x01 ;
}
void bit_array::operator += (int i)
{ int carpos = i / CHAR_BIT ;
if (carpos < 0 || carpos >= ncar) return ; // protection
int bitpos = i % CHAR_BIT ;
adb [carpos] |= (1 << (CHAR_BIT - bitpos - 1) ) ;
357