absolument être surdéfini comme fonction membre. Pour qu’il ne soit pas possible
d’écrire des affectations de la forme h[i] = ..., on fera en sorte que cet opérateur
fournisse son résultat par valeur.
Voici ce que pourrait être la déclaration de notre classe histo :
/*** fichier histo.h : déclaration de la classe histo ***/
class histo
{ float min ; // borne inférieure
float max ; // borne supérieure
int nint ; // nombre de tranches utiles
int * adc ; // pointeur sur les compteurs associés à chaque intervalle
// adc [i-1] = compteur valeurs de la tranche de rang i
float ecart ;// larg d'une tranche (pour éviter un recalcul systématique)
public :
histo (float=0.0, float=1.0, int=10) ; // constructeur
~histo () ; // destructeur
histo & operator << (float) ; // ajoute une valeur
int operator [] (int) ; // nombre de valeurs dans chaque tranche
} ;
Notez que nous avons prévu des valeurs par défaut pour les arguments du constructeur
(celles-ci n’étaient pas imposées par l’énoncé).
En ce qui concerne la définition des différents membres, il faut noter qu’il est
indispensable qu’une telle classe soit protégée contre toute utilisation incorrecte.
Certes, cela passe par un contrôle de la valeur du numéro de tranche fourni à
l’opérateur [], ou par le refus de prendre en compte une valeur hors limites (qui
fournirait un numéro de tranche conduisant à un emplacement situé en dehors de celui
alloué par le constructeur).
Mais nous devons de surcroît nous assurer que les valeurs des arguments fournis au
constructeur ne risquent pas de mettre en cause le fonctionnement ultérieur des
différentes fonctions membre. En particulier, il est bon de vérifier que le nombre de
tranches n’est pas négatif (notamment, une valeur nulle conduirait dans << à une division
par zéro) et que les valeurs du minimum et du maximum sont convenablement
ordonnées et différentes l’une de l’autre (dans ce dernier cas, on aboutirait encore à
une division par zéro). Ici, nous avons prévu de régler ce problème en attribuant le cas
échéant des valeurs par défaut arbitraires (max = min + 1, nint = 1).
Voici ce que pourrait être la définition des différentes fonctions membre de notre classe
histo :
/************** définition de la classe histo **********/
#include "histo.h"
#include
using namespace std ;
/********************* constructeur ********************/
histo::histo (float mini, float maxi, int ninter)
{ // protection contre arguments erronés
if (maxi < mini)
{ float temp = maxi ; maxi = mini ; mini = temp ; }
if (maxi == mini) maxi = mini + 1.0 ; // arbitraire
218
d’écrire des affectations de la forme h[i] = ..., on fera en sorte que cet opérateur
fournisse son résultat par valeur.
Voici ce que pourrait être la déclaration de notre classe histo :
/*** fichier histo.h : déclaration de la classe histo ***/
class histo
{ float min ; // borne inférieure
float max ; // borne supérieure
int nint ; // nombre de tranches utiles
int * adc ; // pointeur sur les compteurs associés à chaque intervalle
// adc [i-1] = compteur valeurs de la tranche de rang i
float ecart ;// larg d'une tranche (pour éviter un recalcul systématique)
public :
histo (float=0.0, float=1.0, int=10) ; // constructeur
~histo () ; // destructeur
histo & operator << (float) ; // ajoute une valeur
int operator [] (int) ; // nombre de valeurs dans chaque tranche
} ;
Notez que nous avons prévu des valeurs par défaut pour les arguments du constructeur
(celles-ci n’étaient pas imposées par l’énoncé).
En ce qui concerne la définition des différents membres, il faut noter qu’il est
indispensable qu’une telle classe soit protégée contre toute utilisation incorrecte.
Certes, cela passe par un contrôle de la valeur du numéro de tranche fourni à
l’opérateur [], ou par le refus de prendre en compte une valeur hors limites (qui
fournirait un numéro de tranche conduisant à un emplacement situé en dehors de celui
alloué par le constructeur).
Mais nous devons de surcroît nous assurer que les valeurs des arguments fournis au
constructeur ne risquent pas de mettre en cause le fonctionnement ultérieur des
différentes fonctions membre. En particulier, il est bon de vérifier que le nombre de
tranches n’est pas négatif (notamment, une valeur nulle conduirait dans << à une division
par zéro) et que les valeurs du minimum et du maximum sont convenablement
ordonnées et différentes l’une de l’autre (dans ce dernier cas, on aboutirait encore à
une division par zéro). Ici, nous avons prévu de régler ce problème en attribuant le cas
échéant des valeurs par défaut arbitraires (max = min + 1, nint = 1).
Voici ce que pourrait être la définition des différentes fonctions membre de notre classe
histo :
/************** définition de la classe histo **********/
#include "histo.h"
#include
using namespace std ;
/********************* constructeur ********************/
histo::histo (float mini, float maxi, int ninter)
{ // protection contre arguments erronés
if (maxi < mini)
{ float temp = maxi ; maxi = mini ; mini = temp ; }
if (maxi == mini) maxi = mini + 1.0 ; // arbitraire
218