dynamique en question, ainsi que du nombre de bits du tableau. Pour simplifier
certaines des fonctions membre, nous prévoirons également de conserver le nombre de
caractères correspondant.
Les opérateurs +=, -=, ++ et -- peuvent être définis indifféremment sous la forme d’une
fonction membre ou d’une fonction amie. Ici, nous avons choisi des fonctions membre.
L’énoncé ne précise rien quant au résultat fourni par ces 4 opérateurs. En fait, on
pourrait prévoir qu’ils restituent le tableau après qu’ils y ont effectué l’opération
voulue, mais en pratique, cela semble de peu d’intérêt. Ici, nous avons donc simplement
prévu que ces opérateurs ne fourniraient aucun résultat.
Pour que [] ne soit pas utilisable dans une affectation de la forme t[i] = ..., il suffit de
prévoir qu’il fournisse son résultat par valeur (et non par référence comme on a
généralement l’habitude de le faire).
Naturellement, ici encore, l’énoncé nous impose de surdéfinir l’opérateur d’affectation
et de prévoir un constructeur par recopie.
Voici ce que pourrait être la déclaration de notre classe bit_array :
/* fichier bitarray.h : déclaration de la classe bit_array */
#include
using namespace std ;
class bit_array
{ int nbits ; // nombre courant de bits du tableau
int ncar ; // nombre de caractères nécessaires (redondant)
char * adb ; // adresse de l'emplacement contenant les bits
public :
bit_array (int = 16) ; // constructeur usuel
bit_array (bit_array &) ; // constructeur par recopie,
// voir remarque 1 ci-après
~bit_array () ; // destructeur
// les opérateurs binaires
bit_array & operator = (bit_array &) ; // affectation,
// voir remarque 2 ci-après
int operator [] (int) ; // valeur d'un bit
void operator += (int) ; // activation d'un bit
void operator -= (int) ; // désactivation d'un bit
// envoi sur flot
friend ostream & operator << (ostream &, bit_array &) ;
// les opérateurs unaires
void operator ++ () ; // mise à 1
void operator -- () ; // mise à 0
void operator ~ () ; // complément à 1
} ;
1. On pourrait ajouter le qualificatif const au constructeur par recopie, ce qui
autoriserait l’initialisation d’un objet bit_array par un objet constant. Mais compte
tenu des possibilités de conversions implicites, on autoriserait du même coup
l’initialisation par un entier ou par un flottant, ce qui n’est guère satisfaisant ; on
356
certaines des fonctions membre, nous prévoirons également de conserver le nombre de
caractères correspondant.
Les opérateurs +=, -=, ++ et -- peuvent être définis indifféremment sous la forme d’une
fonction membre ou d’une fonction amie. Ici, nous avons choisi des fonctions membre.
L’énoncé ne précise rien quant au résultat fourni par ces 4 opérateurs. En fait, on
pourrait prévoir qu’ils restituent le tableau après qu’ils y ont effectué l’opération
voulue, mais en pratique, cela semble de peu d’intérêt. Ici, nous avons donc simplement
prévu que ces opérateurs ne fourniraient aucun résultat.
Pour que [] ne soit pas utilisable dans une affectation de la forme t[i] = ..., il suffit de
prévoir qu’il fournisse son résultat par valeur (et non par référence comme on a
généralement l’habitude de le faire).
Naturellement, ici encore, l’énoncé nous impose de surdéfinir l’opérateur d’affectation
et de prévoir un constructeur par recopie.
Voici ce que pourrait être la déclaration de notre classe bit_array :
/* fichier bitarray.h : déclaration de la classe bit_array */
#include
using namespace std ;
class bit_array
{ int nbits ; // nombre courant de bits du tableau
int ncar ; // nombre de caractères nécessaires (redondant)
char * adb ; // adresse de l'emplacement contenant les bits
public :
bit_array (int = 16) ; // constructeur usuel
bit_array (bit_array &) ; // constructeur par recopie,
// voir remarque 1 ci-après
~bit_array () ; // destructeur
// les opérateurs binaires
bit_array & operator = (bit_array &) ; // affectation,
// voir remarque 2 ci-après
int operator [] (int) ; // valeur d'un bit
void operator += (int) ; // activation d'un bit
void operator -= (int) ; // désactivation d'un bit
// envoi sur flot
friend ostream & operator << (ostream &, bit_array &) ;
// les opérateurs unaires
void operator ++ () ; // mise à 1
void operator -- () ; // mise à 0
void operator ~ () ; // complément à 1
} ;
1. On pourrait ajouter le qualificatif const au constructeur par recopie, ce qui
autoriserait l’initialisation d’un objet bit_array par un objet constant. Mais compte
tenu des possibilités de conversions implicites, on autoriserait du même coup
l’initialisation par un entier ou par un flottant, ce qui n’est guère satisfaisant ; on
356