}
/************ opérateur d'ajout << ***************/
set_int & set_int::operator << (int nb)
{ // on examine si nb appartient déjà à l'ensemble
// en utilisant l'opérateur %
// s'il n'y appartient pas, et s'il y a encore de la place
// on l'ajoute à l'ensemble
if ( ! (nb % *this) && nelem < nmax ) adval [nelem++] = nb ;
return (*this) ;
}
/*********** opérateur d'appartenance % **********/
int operator % (int nb, set_int & e)
{ int i=0 ;
// on examine si nb appartient déjà à l'ensemble
// (dans ce cas i vaudra nele en fin de boucle)
while ( (i
/****** opérateur << pour sortie sur un flot *****/
ostream & operator << (ostream & sortie, set_int & e)
{ sortie << "[ " ;
int i ;
for (i=0 ; i
sortie << "]" ;
return sortie ;
}
1. On pourrait ajouter le qualificatif const au constructeur par recopie, ce qui
autoriserait l’initialisation d’un objet par un objet constant. Mais compte tenu des
possibilités d’utilisation de l’autre constructeur dans des conversions implicites, on
autoriserait du même coup l’initialisation par un entier ou un flottant, ce qui n’est
guère satisfaisant ; on pourrait cependant interdire de telles possibilités en utilisant
le mot-clé explicit dans la déclaration du constructeur.
2. La transmission de la valeur de retour de l’opérateur d’affectation n’est utile que si
l’on souhaite permettre les affectations multiples. Il n’est pas indispensable de
transmettre l’argument et la valeur de retour par référence, mais cela évite les
recopies. On pourrait ici déclarer constant l’unique argument, ce qui autoriserait
l’utilisation d’un objet constant en second opérande de l’affectation (moyennant 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 souhaité ; là encore, ces possibilités pourraient être
interdites, moyennant l’utilisation appropriée du mot-clé explicit.
3. On pourrait ajouter le qualificatif const à l’opérateur %, ce qui permettrait de
travailler sur un ensemble constant ; néanmoins, dans ce cas, il y aurait transmission
d’une copie de cet ensemble à la fonction, ce qui n'est plus très efficace !
349
/************ opérateur d'ajout << ***************/
set_int & set_int::operator << (int nb)
{ // on examine si nb appartient déjà à l'ensemble
// en utilisant l'opérateur %
// s'il n'y appartient pas, et s'il y a encore de la place
// on l'ajoute à l'ensemble
if ( ! (nb % *this) && nelem < nmax ) adval [nelem++] = nb ;
return (*this) ;
}
/*********** opérateur d'appartenance % **********/
int operator % (int nb, set_int & e)
{ int i=0 ;
// on examine si nb appartient déjà à l'ensemble
// (dans ce cas i vaudra nele en fin de boucle)
while ( (i
/****** opérateur << pour sortie sur un flot *****/
ostream & operator << (ostream & sortie, set_int & e)
{ sortie << "[ " ;
int i ;
for (i=0 ; i
sortie << "]" ;
return sortie ;
}
1. On pourrait ajouter le qualificatif const au constructeur par recopie, ce qui
autoriserait l’initialisation d’un objet par un objet constant. Mais compte tenu des
possibilités d’utilisation de l’autre constructeur dans des conversions implicites, on
autoriserait du même coup l’initialisation par un entier ou un flottant, ce qui n’est
guère satisfaisant ; on pourrait cependant interdire de telles possibilités en utilisant
le mot-clé explicit dans la déclaration du constructeur.
2. La transmission de la valeur de retour de l’opérateur d’affectation n’est utile que si
l’on souhaite permettre les affectations multiples. Il n’est pas indispensable de
transmettre l’argument et la valeur de retour par référence, mais cela évite les
recopies. On pourrait ici déclarer constant l’unique argument, ce qui autoriserait
l’utilisation d’un objet constant en second opérande de l’affectation (moyennant 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 souhaité ; là encore, ces possibilités pourraient être
interdites, moyennant l’utilisation appropriée du mot-clé explicit.
3. On pourrait ajouter le qualificatif const à l’opérateur %, ce qui permettrait de
travailler sur un ensemble constant ; néanmoins, dans ce cas, il y aurait transmission
d’une copie de cet ensemble à la fonction, ce qui n'est plus très efficace !
349