possibilités de conversions implicites, cela autorise du même coup l’affectation
d’un entier, d’un flottant (par conversion en entier) ou d’un pointeur de type char *
(encore faut-il, comme ici, ne pas avoir utilisé le mot-clé explicit dans les
constructeurs correspondants).
3. Pour les arguments de l’opérateur +, le qualificatif const est indispensable si l’on
souhaite bénéficier des conversions implicites des opérandes, notamment d’un entier
en un grand entier. Du coup, compte tenu des possibilités de conversions implicites
des opérandes, on autorise également l’utilisation de flottants ou de pointeurs de
type char *.
L’opérateur + commence par créer un emplacement temporaire pouvant recevoir un
nombre comportant un chiffre de plus que le plus grand de ses deux opérandes (on ne
sait pas encore combien de chiffres comportera exactement le résultat). On y calcule la
somme suivant un algorithme calqué sur le processus manuel d’addition.
Puis on crée un objet de type big_int en utilisant un constructeur particulier : big_int (int,
int). En fait, nous avons besoin d’un constructeur créant un big_int comportant un
nombre de chiffres donné, ce dont nous ne disposons pas dans les constructeurs
publics. De plus, nous ne pouvons pas utiliser un constructeur de la forme big_int (int)
car, alors, les additions mixtes faisant intervenir des entiers chercheraient à l’employer
pour effectuer une conversion ! C’est pourquoi nous avons prévu un constructeur à deux
arguments, le second étant fictif ; de plus, nous l’avons rendu privé, car il n’a nullement
besoin d’être accessible à un utilisateur de la classe.
Voici la définition des fonctions de la classe big_int :
/* définition des fonctions de la classe big_int */
#include
#include "bigint.h"
#include
using namespace std ;
big_int::big_int (int n, int p) // l'argument p est fictif
{ nchif = n ;
adchif = new char [nchif] ;
}
big_int::big_int (char * ch)
{
nchif = strlen (ch) ;
adchif = new char [nchif] ;
int i ; char c ;
for (i=0 ; i
if (c<0 || c>9) c=0 ; // précaution
adchif[nchif-i-1] = c ; // attention à l'ordre des chiffres !
}
}
big_int::big_int (unsigned long n)
{ // on crée le grand entier correspondant dans un emplacement temporaire
362
d’un entier, d’un flottant (par conversion en entier) ou d’un pointeur de type char *
(encore faut-il, comme ici, ne pas avoir utilisé le mot-clé explicit dans les
constructeurs correspondants).
3. Pour les arguments de l’opérateur +, le qualificatif const est indispensable si l’on
souhaite bénéficier des conversions implicites des opérandes, notamment d’un entier
en un grand entier. Du coup, compte tenu des possibilités de conversions implicites
des opérandes, on autorise également l’utilisation de flottants ou de pointeurs de
type char *.
L’opérateur + commence par créer un emplacement temporaire pouvant recevoir un
nombre comportant un chiffre de plus que le plus grand de ses deux opérandes (on ne
sait pas encore combien de chiffres comportera exactement le résultat). On y calcule la
somme suivant un algorithme calqué sur le processus manuel d’addition.
Puis on crée un objet de type big_int en utilisant un constructeur particulier : big_int (int,
int). En fait, nous avons besoin d’un constructeur créant un big_int comportant un
nombre de chiffres donné, ce dont nous ne disposons pas dans les constructeurs
publics. De plus, nous ne pouvons pas utiliser un constructeur de la forme big_int (int)
car, alors, les additions mixtes faisant intervenir des entiers chercheraient à l’employer
pour effectuer une conversion ! C’est pourquoi nous avons prévu un constructeur à deux
arguments, le second étant fictif ; de plus, nous l’avons rendu privé, car il n’a nullement
besoin d’être accessible à un utilisateur de la classe.
Voici la définition des fonctions de la classe big_int :
/* définition des fonctions de la classe big_int */
#include
#include "bigint.h"
#include
using namespace std ;
big_int::big_int (int n, int p) // l'argument p est fictif
{ nchif = n ;
adchif = new char [nchif] ;
}
big_int::big_int (char * ch)
{
nchif = strlen (ch) ;
adchif = new char [nchif] ;
int i ; char c ;
for (i=0 ; i
if (c<0 || c>9) c=0 ; // précaution
adchif[nchif-i-1] = c ; // attention à l'ordre des chiffres !
}
}
big_int::big_int (unsigned long n)
{ // on crée le grand entier correspondant dans un emplacement temporaire
362