l’ordre inverse de celui où on les écrit (unités, dizaines, centaines...).
Pour pouvoir accepter les expressions mixtes, on dispose de plusieurs solutions :
soit surdéfinir l’opérateur + pour tous les cas possibles ;
soit surdéfinir + uniquement lorsqu’il porte sur des grands entiers et prévoir un
constructeur recevant un argument de type unsigned long ; il permettra ainsi la
conversion en big_int de n'importe quel type numérique.
C’est la seconde solution que nous avons adoptée. Notez toutefois que, si elle a le
mérite d’être la plus simple à programmer, elle n’est pas la plus efficace en temps
d’exécution.
Par ailleurs, pour que les conversions envisagées s’appliquent au premier opérande de
l’addition, il est nécessaire de surdéfinir l’opérateur + comme une fonction amie.
Voici la déclaration de notre classe big_int (la présence d’un constructeur privé à deux
arguments entiers sera justifiée un peu plus loin) :
/* fichier bigint.h : déclaration de la classe big_int */
#define NCHIFMAX 32 // nombre maxi de chiffres d'un entier (dépend de
// l'implémentation)
#include
using namespace std ;
class big_int
{ int nchif ; // nombre de chiffres
char * adchif ; // adresse emplacement contenant les chiffres
big_int (int, int) ; // constructeur privé (à usage interne)
public :
big_int (unsigned long=0) ; // constructeur à partir d'un nombre usuel
big_int (char *) ; // constructeur à partir d'une chaîne
big_int (big_int &) ; // constructeur par recopie, voir remarque 1
big_int & operator = (const big_int &) ; // affectation,
// voir remarque 2
friend big_int operator + (const big_int &,const big_int &) ;
// opérateur +,
// voir remarque 3
friend ostream & operator << (ostream &, big_int &) ; // opérateur <<
} ;
1. On pourrait ajouter le qualificatif const au constructeur par recopie, ce qui aurait pour
effet d’autoriser l’initialisation d’un grand entier par un grand entier constant ou
encore (compte tenu des possibilités de conversion implicite de l’opérande) par un
entier, voire un flottant (par conversion en entier).
2. La transmission par référence du résultat de l’opérateur d’affectation autorise les
affectations multiples. La transmission par référence de l’unique argument n’est pas
obligatoire. On a ajouté le qualificatif const pour autoriser l’affectation d’une
expression (notamment la somme de deux grands entiers) ; compte tenu des
361
Pour pouvoir accepter les expressions mixtes, on dispose de plusieurs solutions :
soit surdéfinir l’opérateur + pour tous les cas possibles ;
soit surdéfinir + uniquement lorsqu’il porte sur des grands entiers et prévoir un
constructeur recevant un argument de type unsigned long ; il permettra ainsi la
conversion en big_int de n'importe quel type numérique.
C’est la seconde solution que nous avons adoptée. Notez toutefois que, si elle a le
mérite d’être la plus simple à programmer, elle n’est pas la plus efficace en temps
d’exécution.
Par ailleurs, pour que les conversions envisagées s’appliquent au premier opérande de
l’addition, il est nécessaire de surdéfinir l’opérateur + comme une fonction amie.
Voici la déclaration de notre classe big_int (la présence d’un constructeur privé à deux
arguments entiers sera justifiée un peu plus loin) :
/* fichier bigint.h : déclaration de la classe big_int */
#define NCHIFMAX 32 // nombre maxi de chiffres d'un entier (dépend de
// l'implémentation)
#include
using namespace std ;
class big_int
{ int nchif ; // nombre de chiffres
char * adchif ; // adresse emplacement contenant les chiffres
big_int (int, int) ; // constructeur privé (à usage interne)
public :
big_int (unsigned long=0) ; // constructeur à partir d'un nombre usuel
big_int (char *) ; // constructeur à partir d'une chaîne
big_int (big_int &) ; // constructeur par recopie, voir remarque 1
big_int & operator = (const big_int &) ; // affectation,
// voir remarque 2
friend big_int operator + (const big_int &,const big_int &) ;
// opérateur +,
// voir remarque 3
friend ostream & operator << (ostream &, big_int &) ; // opérateur <<
} ;
1. On pourrait ajouter le qualificatif const au constructeur par recopie, ce qui aurait pour
effet d’autoriser l’initialisation d’un grand entier par un grand entier constant ou
encore (compte tenu des possibilités de conversion implicite de l’opérande) par un
entier, voire un flottant (par conversion en entier).
2. La transmission par référence du résultat de l’opérateur d’affectation autorise les
affectations multiples. La transmission par référence de l’unique argument n’est pas
obligatoire. On a ajouté le qualificatif const pour autoriser l’affectation d’une
expression (notamment la somme de deux grands entiers) ; compte tenu des
361